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
76 # if !defined(__APPLE__) && defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 8))
80 # define OVERRIDE override
88 class EventDispatcherImpl;
252 GradientTopLeftToBottomRight,
253 GradientTopRightToBottomLeft,
254 GradientBottomLeftToTopRight,
255 GradientBottomRightToTopLeft,
364 FeatureSizePercentage
565 SubsegmentsAndIncludes
606 Everything = 0x00ffffff,
609 Include = 0x00000042,
610 Segment = 0x00000043,
612 Includer = 0x00000100,
615 Geometry = 0x10000000,
622 NURBSSurface = 0x1000002b,
625 Polygon = 0x1000002f,
628 CircularWedge = 0x10000032,
629 Ellipse = 0x10000033,
631 NURBSCurve = 0x10000037,
632 CircularArc = 0x10000038,
633 EllipticalArc = 0x10000039,
638 Reference = 0x10000040,
641 DistantLight = 0x10000100,
643 InfiniteRay = 0x10000102,
646 Attribute = 0x20000000,
648 Priority = 0x20000001,
653 ModellingMatrix = 0x20000010,
654 UserData = 0x20000021,
655 TextureMatrix = 0x20000023,
658 Culling = 0x20001000,
659 CullingBackFace = 0x20001001,
660 CullingExtent = 0x20001002,
661 CullingVector = 0x20001003,
662 CullingVectorTolerance = 0x20001004,
663 CullingFrustum = 0x20001005,
664 CullingDeferralExtent = 0x20001006,
666 CurveAttribute = 0x20002000,
667 CurveAttributeBudget = 0x20002001,
668 CurveAttributeContinuedBudget = 0x20002002,
669 CurveAttributeViewDependent = 0x20002003,
670 CurveAttributeMaximumDeviation = 0x20002004,
671 CurveAttributeMaximumAngle = 0x20002005,
672 CurveAttributeMaximumLength = 0x20002006,
674 CylinderAttribute = 0x20003000,
675 CylinderAttributeTessellation = 0x20003001,
676 CylinderAttributeOrientation = 0x20003002,
679 EdgeAttribute = 0x20004000,
680 EdgeAttributePattern = 0x20004015,
681 EdgeAttributeWeight = 0x20004016,
683 LightingAttribute = 0x20005000,
684 LightingAttributeInterpolation = 0x20005001,
687 LineAttribute = 0x20006000,
688 LineAttributePattern = 0x20006019,
689 LineAttributeWeight = 0x2000601a,
692 MarkerAttribute = 0x20007000,
693 MarkerAttributeSize = 0x2000701b,
694 MarkerAttributeSymbol = 0x2000701c,
696 SurfaceAttribute = 0x20008000,
697 SurfaceAttributeBudget = 0x20008001,
698 SurfaceAttributeMaximumFacetDeviation = 0x20008002,
699 SurfaceAttributeMaximumFacetAngle = 0x20008003,
700 SurfaceAttributeMaximumFacetWidth = 0x20008004,
701 SurfaceAttributeTrimCurveBudget = 0x20008005,
702 SurfaceAttributeMaximumTrimCurveDeviation = 0x20008006,
705 SelectabilityWindows = 0x20009001,
706 SelectabilityEdges = 0x20009002,
707 SelectabilityFaces = 0x20009003,
708 SelectabilityLights = 0x20009004,
709 SelectabilityLines = 0x20009005,
710 SelectabilityMarkers = 0x20009006,
711 SelectabilityVertices = 0x20009007,
712 SelectabilityText = 0x20009008,
714 SphereAttribute = 0x2000a000,
715 SphereAttributeTessellation = 0x2000a001,
718 SubwindowEitherType = 0x2000b001,
719 SubwindowStandard = 0x2000b00d,
720 SubwindowLightweight = 0x2000b002,
721 SubwindowBackground = 0x2000b003,
722 SubwindowBorder = 0x2000b004,
723 SubwindowRenderingAlgorithm = 0x2000b005,
726 TextAttribute = 0x2000c000,
727 TextAttributeAlignment = 0x2000c01d,
728 TextAttributeBold = 0x2000c002,
729 TextAttributeItalic = 0x2000c003,
730 TextAttributeOverline = 0x2000c004,
731 TextAttributeStrikethrough = 0x2000c005,
732 TextAttributeUnderline = 0x2000c006,
733 TextAttributeSlant = 0x2000c007,
734 TextAttributeLineSpacing = 0x2000c008,
735 TextAttributeRotation = 0x2000c00a,
736 TextAttributeExtraSpace = 0x2000c00b,
737 TextAttributeGreeking = 0x2000c00c,
738 TextAttributeSizeTolerance = 0x2000c00d,
739 TextAttributeSize = 0x2000c00e,
740 TextAttributeFont = 0x2000c00f,
741 TextAttributeTransform = 0x2000c010,
742 TextAttributeRenderer = 0x2000c011,
743 TextAttributePreference = 0x2000c012,
744 TextAttributePath = 0x2000c01f,
745 TextAttributeSpacing = 0x2000c020,
748 TransparencyMethod = 0x2000d001,
749 TransparencyAlgorithm = 0x2000d002,
750 TransparencyDepthPeelingLayers = 0x2000d004,
751 TransparencyDepthPeelingMinimumArea = 0x2000d005,
752 TransparencyDepthWriting = 0x2000d006,
754 Visibility = 0x2000e000,
755 VisibilityCuttingSections = 0x2000e001,
756 VisibilityCutEdges = 0x2000e002,
757 VisibilityCutFaces = 0x2000e003,
758 VisibilityWindows = 0x2000e004,
759 VisibilityText = 0x2000e005,
760 VisibilityLines = 0x2000e006,
761 VisibilityEdgeLights = 0x2000e007,
762 VisibilityMarkerLights = 0x2000e008,
763 VisibilityFaceLights = 0x2000e009,
764 VisibilityGenericEdges = 0x2000e00a,
765 VisibilityHardEdges = 0x2000e00b,
766 VisibilityAdjacentEdges = 0x2000e00c,
767 VisibilityInteriorSilhouetteEdges = 0x2000e00d,
768 VisibilityShadowEmitting = 0x2000e00e,
769 VisibilityShadowReceiving = 0x2000e00f,
770 VisibilityShadowCasting = 0x2000e010,
771 VisibilityMarkers = 0x2000e011,
772 VisibilityVertices = 0x2000e012,
773 VisibilityFaces = 0x2000e013,
774 VisibilityPerimeterEdges = 0x2000e014,
775 VisibilityNonCulledEdges = 0x2000e015,
776 VisibilityMeshQuadEdges = 0x2000e016,
778 VisualEffects = 0x2000f000,
779 VisualEffectsPostProcessEffectsEnabled = 0x2000f001,
780 VisualEffectsAntiAliasing = 0x2000f002,
781 VisualEffectsShadowMaps = 0x2000f003,
782 VisualEffectsSimpleShadow = 0x2000f004,
783 VisualEffectsSimpleShadowPlane = 0x2000f005,
784 VisualEffectsSimpleShadowLightDirection = 0x2000f006,
785 VisualEffectsSimpleShadowColor = 0x2000f007,
786 VisualEffectsSimpleReflection = 0x2000f008,
787 VisualEffectsSimpleReflectionPlane = 0x2000f009,
788 VisualEffectsSimpleReflectionVisibility = 0x2000f00a,
791 PerformanceDisplayLists = 0x20010001,
792 PerformanceStaticModel = 0x20010002,
793 StaticModelSegment = 0x40000043,
796 DrawingAttribute = 0x20011000,
797 DrawingAttributePolygonHandedness = 0x20011001,
798 DrawingAttributeDepthRange = 0x20011002,
799 DrawingAttributeFaceDisplacement = 0x20011003,
800 DrawingAttributeGeneralDisplacement = 0x20011004,
801 DrawingAttributeVertexDisplacement = 0x20011005,
802 DrawingAttributeOverlay = 0x20011006,
803 DrawingAttributeDeferral = 0x20011007,
804 DrawingAttributeClipRegion = 0x20011012,
805 DrawingAttributeWorldHandedness = 0x20011018,
807 HiddenLineAttribute = 0x20012000,
808 HiddenLineAttributeColor = 0x20012001,
809 HiddenLineAttributeDimFactor = 0x20012002,
810 HiddenLineAttributeFaceDisplacement = 0x20012003,
811 HiddenLineAttributeLinePattern = 0x20012005,
812 HiddenLineAttributeRenderFaces = 0x20012006,
813 HiddenLineAttributeRenderText = 0x20012007,
814 HiddenLineAttributeAlgorithm = 0x20012008,
815 HiddenLineAttributeSilhouetteCleanup = 0x20012009,
816 HiddenLineAttributeVisibility = 0x2001200a,
817 HiddenLineAttributeWeight = 0x2001200b,
818 HiddenLineAttributeTransparencyCutoff = 0x2001200c,
820 SegmentStyle = 0x20013001,
821 NamedStyle = 0x20013002,
822 MaterialPalette = 0x20013003,
823 Portfolio = 0x20013004,
826 ContourLineVisibility = 0x20014001,
827 ContourLinePosition = 0x20014002,
828 ContourLineColor = 0x20014003,
829 ContourLinePattern = 0x20014004,
830 ContourLineWeight = 0x20014005,
831 ContourLineLighting = 0x20014006,
836 BoundingVolume = 0x20016001,
837 BoundingExclusion = 0x20016002,
840 AttributeLockSetting = 0x20017001,
841 AttributeLockSubsegmentOverride = 0x20017002,
843 TransformMask = 0x20018000,
844 TransformMaskCamera = 0x20018001,
845 TransformMaskCameraTranslation = 0x20018002,
846 TransformMaskCameraScale = 0x20018003,
847 TransformMaskCameraOffset = 0x20018004,
848 TransformMaskCameraRotation = 0x20018005,
849 TransformMaskCameraPerspectiveScale = 0x20018006,
850 TransformMaskCameraProjection = 0x20018007,
851 TransformMaskModellingMatrix = 0x20018008,
852 TransformMaskModellingMatrixTranslation = 0x20018009,
853 TransformMaskModellingMatrixScale = 0x20018010,
854 TransformMaskModellingMatrixOffset = 0x20018011,
855 TransformMaskModellingMatrixRotation = 0x20018012,
857 ColorInterpolation = 0x20019000,
858 ColorInterpolationFaceColor = 0x20019001,
859 ColorInterpolationEdgeColor = 0x20019002,
860 ColorInterpolationMarkerColor = 0x20019003,
861 ColorInterpolationFaceIndex = 0x20019004,
862 ColorInterpolationEdgeIndex = 0x20019005,
863 ColorInterpolationMarkerIndex = 0x20019006,
865 CuttingSectionAttribute = 0x2001a000,
866 CuttingSectionAttributeCuttingLevel = 0x2001a001,
867 CuttingSectionAttributeCappingLevel = 0x2001a002,
868 CuttingSectionAttributeMaterialPreference = 0x2001a003,
886 InvalidMaterialIndex = -1,
913 EnvironmentTexture = 8,
914 EnvironmentCubeMap = 9,
953 EnvironmentTexture = 8,
954 EnvironmentCubeMap = 9
1100 GeometryDisplayLists,
1119 AttributeStaticModel,
1120 AttributeSpatialStaticModel
1136 Everything = 0x01000000,
1138 Visibility = 0x02000000,
1140 VisibilityCuttingSections,
1146 VisibilityEdgeLights,
1147 VisibilityMarkerLights,
1148 VisibilityFaceLights,
1149 VisibilityGenericEdges,
1150 VisibilityHardEdges,
1151 VisibilityAdjacentEdges,
1152 VisibilityInteriorSilhouetteEdges,
1153 VisibilityShadowEmitting,
1154 VisibilityShadowReceiving,
1155 VisibilityShadowCasting,
1159 VisibilityPerimeterEdges,
1160 VisibilityNonCulledEdges,
1161 VisibilityMeshQuadEdges,
1162 VisibilityCutGeometry,
1171 MaterialCutGeometry,
1173 MaterialAmbientLightUpColor,
1174 MaterialAmbientLightDownColor,
1175 MaterialAmbientLightColor,
1177 MaterialWindowColor,
1178 MaterialWindowContrastColor,
1182 MaterialMarkerColor,
1184 MaterialCutEdgeColor,
1187 MaterialVertexDiffuse,
1188 MaterialVertexDiffuseColor,
1189 MaterialVertexDiffuseAlpha,
1190 MaterialVertexDiffuseTexture,
1191 MaterialVertexSpecular,
1192 MaterialVertexMirror,
1193 MaterialVertexTransmission,
1194 MaterialVertexEmission,
1195 MaterialVertexEnvironment,
1197 MaterialVertexGloss,
1200 MaterialEdgeDiffuse,
1201 MaterialEdgeDiffuseColor,
1202 MaterialEdgeDiffuseAlpha,
1203 MaterialEdgeDiffuseTexture,
1204 MaterialEdgeSpecular,
1206 MaterialEdgeTransmission,
1207 MaterialEdgeEmission,
1208 MaterialEdgeEnvironment,
1213 MaterialFaceDiffuse,
1214 MaterialFaceDiffuseColor,
1215 MaterialFaceDiffuseAlpha,
1216 MaterialFaceDiffuseTexture,
1217 MaterialFaceSpecular,
1219 MaterialFaceTransmission,
1220 MaterialFaceEmission,
1221 MaterialFaceEnvironment,
1226 MaterialBackFaceDiffuse,
1227 MaterialBackFaceDiffuseColor,
1228 MaterialBackFaceDiffuseAlpha,
1229 MaterialBackFaceDiffuseTexture,
1230 MaterialBackFaceSpecular,
1231 MaterialBackFaceMirror,
1232 MaterialBackFaceTransmission,
1233 MaterialBackFaceEmission,
1234 MaterialBackFaceEnvironment,
1235 MaterialBackFaceBump,
1236 MaterialBackFaceGloss,
1239 MaterialFrontFaceDiffuse,
1240 MaterialFrontFaceDiffuseColor,
1241 MaterialFrontFaceDiffuseAlpha,
1242 MaterialFrontFaceDiffuseTexture,
1243 MaterialFrontFaceSpecular,
1244 MaterialFrontFaceMirror,
1245 MaterialFrontFaceTransmission,
1246 MaterialFrontFaceEmission,
1247 MaterialFrontFaceEnvironment,
1248 MaterialFrontFaceBump,
1249 MaterialFrontFaceGloss,
1252 MaterialCutFaceDiffuse,
1253 MaterialCutFaceDiffuseColor,
1254 MaterialCutFaceDiffuseAlpha,
1255 MaterialCutFaceDiffuseTexture,
1256 MaterialCutFaceSpecular,
1257 MaterialCutFaceMirror,
1258 MaterialCutFaceTransmission,
1259 MaterialCutFaceEmission,
1260 MaterialCutFaceEnvironment,
1261 MaterialCutFaceBump,
1262 MaterialCutFaceGloss,
1568 CharacterPositionOnly,
1571 CharacterPositionAdjusted
1792 UnableToLoadLibraries,
1793 VersionIncompatibility,
1794 InitializationFailed,
1955 TriangleDownWithDot,
1958 TriangleRightWithDot,
1961 TriangleLeftWithDot,
1968 SolidTriangleRightV,
2042 SubsegmentsAndIncludes,
2045 enum class Expansion
2050 IncludesAndReferences,
2060 enum class Reorganization
2069 typedef double Time;
2073 # define HPS_INLINE __forceinline
2076 # define HPS_INLINE inline
2079 #ifndef HPS_UNREFERENCED
2080 #define HPS_UNREFERENCED(param) ((void)(param))
2084 const double PI = 3.141592653589793238462643383279502884197169399375105820974944592308;
2086 template<
typename T>
2087 HPS_INLINE T Degrees_To_Radians(T
const & degrees)
2089 return degrees * (T)(PI / 180.0);
2092 template<
typename T>
2093 HPS_INLINE T Radians_To_Degrees(T
const & radians)
2095 return radians * (T)(180.0 / PI);
2098 template<
typename T>
2099 HPS_INLINE
void SinCos(T
const & angle, T & sine, T & cosine) {
2100 T a = Degrees_To_Radians(angle);
2105 template<
typename T>
2106 HPS_INLINE T Cos(T
const & angle) {
2107 return cos (Degrees_To_Radians(angle));
2110 template<
typename T>
2111 HPS_INLINE T Sin(T
const & angle) {
2112 return sin (Degrees_To_Radians(angle));
2115 template<
typename T>
2116 HPS_INLINE T ACos(T
const & x) {
2121 return Radians_To_Degrees(acos(x));
2124 template<
typename T>
2125 HPS_INLINE T ATan2(T
const & y, T
const & x) {
2126 if (x == 0 && y == 0)
2128 return Radians_To_Degrees(atan2(y, x));
2134 typedef double Alternative;
2135 static const int Type = 1;
2136 static float Epsilon () {
return 1.0e-30f; }
2139 typedef float Alternative;
2140 static const int Type = 2;
2141 static double Epsilon () {
return 1.0e-300; }
2150 # if HOOPS_BIGENDIAN
2158 static HPS_INLINE
bool is_infinite(int32_t
const & v) {
return (v & 0x7FFFFFFF) == 0x7F800000; }
2159 static HPS_INLINE
bool is_infinite(uint32_t
const & v) {
return (v & 0x7FFFFFFF) == 0x7F800000; }
2160 static HPS_INLINE
bool is_infinite(int32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2161 static HPS_INLINE
bool is_infinite(uint32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2163 static HPS_INLINE
bool is_nan(int32_t
const & v) {
2164 uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2165 return exp == 0x7F800000 && mantissa != 0;
2167 static HPS_INLINE
bool is_nan(uint32_t
const & v) {
2168 uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2169 return exp == 0x7F800000 && mantissa != 0;
2171 static HPS_INLINE
bool is_nan(int32_t
const * v) {
2172 uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2173 return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2175 static HPS_INLINE
bool is_nan(uint32_t
const * v) {
2176 uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2177 return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2180 static HPS_INLINE
bool is_special(int32_t
const & v) {
return (v & 0x7F800000) == 0x7F800000; }
2181 static HPS_INLINE
bool is_special(uint32_t
const & v) {
return (v & 0x7F800000) == 0x7F800000; }
2182 static HPS_INLINE
bool is_special(int32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2183 static HPS_INLINE
bool is_special(uint32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2192 static HPS_INLINE
bool IsInfinite(
float const & a) {
return is_infinite (extract_uint32_t(a)); }
2193 static HPS_INLINE
bool IsInfinite(
double const & a) {
2195 memcpy (v, &a,
sizeof(
double));
2196 return is_infinite (v);
2200 static HPS_INLINE
bool IsNAN(
float const & a) {
return is_nan (extract_uint32_t(a)); }
2201 static HPS_INLINE
bool IsNAN(
double const & a) {
2203 memcpy (v, &a,
sizeof(
double));
2208 static HPS_INLINE
bool IsAbnormal(
float const & a) {
return is_special (extract_uint32_t(a)); }
2209 static HPS_INLINE
bool IsAbnormal(
double const & a) {
2211 memcpy (v, &a,
sizeof(
double));
2212 return is_special (v);
2217 static HPS_INLINE
bool Equals(
float const & a,
float const & b,
int tolerance = 32);
2218 static HPS_INLINE
bool Equals(
double const & a,
double const & b,
int tolerance = 32);
2220 #ifndef HOOPS_DEFINED
2221 template <
typename Alloc>
2222 static HPS_INLINE
bool Equals(std::vector<float, Alloc>
const & a, std::vector<float, Alloc>
const & b,
int tolerance = 32)
2224 if (a.size() != b.size())
2227 auto it1 = a.begin();
2228 auto it2 = b.begin();
2229 auto const end = a.end();
2230 for ( ; it1 != end; ++it1, ++it2)
2232 if (!Equals(*it1, *it2, tolerance))
2239 static HPS_INLINE uint32_t extract_sign_bit(
float const & a) {
2240 return extract_uint32_t(a) & 0x80000000;
2242 static HPS_INLINE uint32_t extract_sign_bit(
double const & a) {
2244 memcpy (v, &a,
sizeof(
double));
2245 return v[High] & 0x80000000;
2248 static HPS_INLINE
void apply_sign_bit(
float & a, uint32_t
const & sign_bit) {
2249 uint32_t v = extract_uint32_t(a);
2252 inject_uint32_t(a, v);
2254 static HPS_INLINE
void apply_sign_bit(
double & a, uint32_t
const & sign_bit) {
2256 memcpy (v, &a,
sizeof(
double));
2257 v[High] &= 0x7FFFFFFF;
2258 v[High] |= sign_bit;
2259 memcpy (&a, v,
sizeof(
double));
2263 static HPS_INLINE
unsigned char unit_to_byte(
float const & a) {
2264 uint32_t v = extract_uint32_t(a);
2272 uint32_t exp = v >> 23;
2273 uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2275 return (
unsigned char) (man >> (16 + 126 - exp));
2278 static HPS_INLINE
unsigned char unit_to_byte_scaled(
float const & a,
unsigned char mix) {
2279 uint32_t v = extract_uint32_t(a);
2287 uint32_t exp = v >> 23;
2288 uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2290 uint32_t x = (man >> (16 + 126 - exp));
2292 return (
unsigned char) ((x * (mix+1)) >> 8);
2296 static HPS_INLINE
bool match(
float const & a,
float const & b) {
2297 uint32_t va = extract_uint32_t(a);
2298 uint32_t vb = extract_uint32_t(b);
2300 if (((va | vb) & 0x7FFFFFFF) == 0)
2305 static HPS_INLINE
bool match(
double const & a,
double const & b) {
2310 static HPS_INLINE
void replace_if_smaller(
float & a,
float const & b) {
2311 uint32_t va = extract_uint32_t(a);
2312 uint32_t vb = extract_uint32_t(b);
2314 uint32_t a_sign = va & 0x80000000;
2315 uint32_t b_sign = vb & 0x80000000;
2317 (int32_t&)a_sign >>= 31;
2318 (int32_t&)b_sign >>= 31;
2320 uint32_t mash = (a_sign&b_sign);
2325 if ((int32_t&)vb < (int32_t&)va)
2326 memcpy(&a, &b,
sizeof(
float));
2328 static HPS_INLINE
void replace_if_smaller(
double & a,
double const & b) {
2333 static HPS_INLINE
void replace_if_larger(
float & a,
float const & b) {
2334 uint32_t va = extract_uint32_t(a);
2335 uint32_t vb = extract_uint32_t(b);
2337 uint32_t a_sign = va & 0x80000000;
2338 uint32_t b_sign = vb & 0x80000000;
2340 (int32_t&)a_sign >>= 31;
2341 (int32_t&)b_sign >>= 31;
2343 uint32_t mash = (a_sign&b_sign);
2348 if ((int32_t&)vb > (int32_t&)va)
2349 memcpy(&a, &b,
sizeof(
float));
2351 static HPS_INLINE
void replace_if_larger(
double & a,
double const & b) {
2357 static HPS_INLINE uint32_t extract_uint32_t(
float const & a) {
2359 memcpy(&i, &a,
sizeof(
float));
2363 static HPS_INLINE
void inject_uint32_t(
float & a, uint32_t
const & i) {
2364 memcpy(&a, &i,
sizeof(
float));
2367 static HPS_INLINE
float C2F(
unsigned char x) {
2369 return char_to_float[x];
2374 static HPS_INLINE
void pack_4(
float const & f,
float * m) {
2375 memcpy(&m[0], &f,
sizeof(
float));
2376 memcpy(&m[1], &f,
sizeof(
float));
2377 memcpy(&m[2], &f,
sizeof(
float));
2378 memcpy(&m[3], &f,
sizeof(
float));
2381 static HPS_INLINE
void pack_4(
float const & f0,
float const & f1,
float const & f2,
float const & f3,
float * m) {
2382 memcpy(&m[0], &f0,
sizeof(
float));
2383 memcpy(&m[1], &f1,
sizeof(
float));
2384 memcpy(&m[2], &f2,
sizeof(
float));
2385 memcpy(&m[3], &f3,
sizeof(
float));
2388 static HPS_INLINE
void unpack_4(
float * f0,
float const *
const m) {
2389 memcpy(f0, m,
sizeof(
float)*4);
2392 static HPS_INLINE
void unpack_4(
float & f0,
float & f1,
float & f2,
float & f3,
float const *
const m) {
2393 memcpy(&f0, &m[0],
sizeof(
float));
2394 memcpy(&f1, &m[1],
sizeof(
float));
2395 memcpy(&f2, &m[2],
sizeof(
float));
2396 memcpy(&f3, &m[3],
sizeof(
float));
2400 static const float char_to_float[256];
2409 template <
typename T> HPS_INLINE T * Alter (T
const * a) {
return const_cast<T *
>(a); }
2410 template <
typename T> HPS_INLINE T & Alter (T
const & a) {
return const_cast<T &
>(a); }
2412 template <
typename T> HPS_INLINE T Abs (T
const & a) {
return a < 0 ? -a : a; }
2413 template <
typename T> HPS_INLINE
int Compare (T
const & a, T
const & b) {
return a == b ? 0 : a < b ? -1 : 1; }
2414 template <
typename T> HPS_INLINE
int Sign (T
const & a) {
return Compare(a,(T)0); }
2415 template <
typename T> HPS_INLINE
void Swap (T & a, T & b) { T temp = a; a = b; b = temp; }
2416 template <
typename T> HPS_INLINE
int Floor(T
const & a) {
return ((a > 0 || (T)(
int)a == a) ? (
int)a : ((
int)a - 1)); }
2417 template <
typename T> HPS_INLINE
int Ceiling(T
const & a) {
return ((a < 0 || (T)(
int)a == a) ? (
int)a : ((
int)a + 1)); }
2419 template <
typename T> HPS_INLINE T
const & Min (T
const & a, T
const & b) {
return a < b ? a : b; }
2420 template <
typename T> HPS_INLINE T
const & Min (T
const & a, T
const & b, T
const & c) {
return Min(Min(a,b),c); }
2421 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); }
2422 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); }
2423 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); }
2425 template <
typename T> HPS_INLINE T
const & Max (T
const & a, T
const & b) {
return a > b ? a : b; }
2426 template <
typename T> HPS_INLINE T
const & Max (T
const & a, T
const & b, T
const & c) {
return Max(Max(a,b),c); }
2427 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); }
2428 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); }
2429 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); }
2431 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; }
2434 template <> HPS_INLINE
float Abs<float> (
float const & a) {
2435 uint32_t v = Float::extract_uint32_t(a);
2438 Float::inject_uint32_t(f,v);
2442 template <> HPS_INLINE
int Sign<float> (
float const & a) {
2443 uint32_t v = Float::extract_uint32_t(a);
2445 if ((v & 0x7FFFFFFF) == 0)
2448 return ((int32_t)(v & 0x80000000)>>31) | 0x01;
2451 template <> HPS_INLINE
int Compare<float> (
float const & a,
float const & b) {
2452 int a_sign = Sign(a);
2453 int b_sign = Sign(b);
2455 if (a_sign != b_sign)
2456 return Compare(a_sign, b_sign);
2458 uint32_t v = Float::extract_uint32_t(a);
2459 uint32_t u = Float::extract_uint32_t(b);
2461 return Compare((v & 0x7FFFFFFF), (u & 0x7FFFFFFF)) * a_sign;
2464 template <> HPS_INLINE
float const & Min<float> (
float const & a,
float const & b) {
2470 template <> HPS_INLINE
float const & Max<float> (
float const & a,
float const & b) {
2479 HPS_INLINE
bool Float::Equals(
float const & a,
float const & b,
int tolerance) {
2480 int32_t va = Float::extract_uint32_t(a);
2481 int32_t vb = Float::extract_uint32_t(b);
2483 if (is_special(va) || is_special(vb)) {
2484 if (is_infinite(va) || is_infinite(vb))
2486 if (is_nan(va) || is_nan(vb))
2490 int const close_to_zero = 0x36A00000;
2491 if ((va & 0x7FFFFFFF) == 0)
2492 return (vb & 0x7FFFFFFF) < close_to_zero;
2493 else if ((vb & 0x7FFFFFFF) == 0)
2494 return (va & 0x7FFFFFFF) < close_to_zero;
2496 uint32_t sign_mask = va ^ vb;
2497 (int32_t &)sign_mask >>= 31;
2499 int32_t diff = ((va + sign_mask) ^ (sign_mask & 0x7FFFFFFF)) -vb;
2500 int32_t v1 = tolerance + diff;
2501 int32_t v2 = tolerance - diff;
2502 return (v1|v2) >= 0;
2505 HPS_INLINE
bool Float::Equals(
double const & a,
double const & b,
int tolerance) {
2506 int32_t va[2], vb[2];
2507 memcpy (va, &a,
sizeof(
double));
2508 memcpy (vb, &b,
sizeof(
double));
2510 if (is_special(va) || is_special(vb)) {
2511 if (is_infinite(va) || is_infinite(vb))
2512 return va[High] == vb[High] && va[Low] == vb[Low];
2513 if (is_nan(va) || is_nan(vb))
2517 if ((va[High] == 0 && va[Low] == 0) || (vb[High] == 0 && vb[Low] == 0))
2518 return Abs(a - b) < 0.000000000000005;
2520 if (extract_sign_bit(a) != extract_sign_bit(b))
2523 if (va[High] != vb[High])
2526 return Abs(va[Low] - vb[Low]) <= tolerance;
2533 HPS_INLINE
bool Is_Abnormal (
double const & d) {
return Float::IsAbnormal (d); }
2535 template <
typename T>
2536 HPS_INLINE
bool Is_Abnormal (
size_t count, T
const * t) {
2538 if (Is_Abnormal (*t++))
2543 template <
typename T>
2544 HPS_INLINE
bool Is_Abnormal (
int count, T
const * t) {
2545 return count >= 0 && Is_Abnormal((
size_t)count, t);
2552 template <
typename F>
class HPS_TEMPLATE_API Vector_3D;
2553 template <
typename F>
class HPS_TEMPLATE_API Plane_3D;
2554 template <
typename F>
class HPS_TEMPLATE_API Vector_2D;
2555 template <
typename F>
class HPS_TEMPLATE_API Point_2D;
2558 template <
typename F>
2566 Point_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2568 template <
typename D>
2569 explicit Point_3D (
Point_3D<D> const & that) : x ((F)that.x), y ((F)that.y), z ((F)that.z) {}
2577 bool operator== (
Point_3D const & p)
const {
return x == p.x && y == p.y && z == p.z; }
2578 bool operator!= (
Point_3D const & p)
const {
return !(*
this == p); }
2580 bool Equals(
Point_3D const & p,
int in_tolerance = 32)
const {
2587 Point_3D & operator*= (F s) { x *= s; y *= s; z *= s;
return *
this; }
2588 Point_3D & operator/= (F s) {
return operator*= ((F)1 / s); }
2589 Point_3D const operator* (F s)
const {
return Point_3D (x * s, y * s, z * s); }
2590 Point_3D const operator/ (F s)
const {
return operator* ((F)1 / s); }
2592 F & operator[] (
size_t i) {
return (&x)[i]; }
2593 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2626 template <
typename F,
typename S>
2629 template <
typename F>
2630 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F>
const & a, Point_3D<F>
const & b) {
2631 return Point_3D<F> (a.x + b.x, a.y + b.y, a.z + b.z) * 0.5f;
2634 template <
typename F>
2635 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F>
const & a, Point_3D<F>
const & b, Point_3D<F>
const & c) {
2636 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);
2639 template <
typename F>
2640 HPS_INLINE
bool Is_Abnormal (Point_3D<F>
const & p) {
2641 return Is_Abnormal (p.x) || Is_Abnormal (p.y) || Is_Abnormal (p.z);
2645 template <
typename F>
2652 Point_2D (F v1, F v2) : x (v1), y (v2) {}
2654 template <
typename D>
2662 bool operator== (
Point_2D const & p)
const {
return x == p.x && y == p.y; }
2663 bool operator!= (
Point_2D const & p)
const {
return !(*
this == p); }
2665 bool Equals(
Point_2D const & p,
int in_tolerance = 32)
const {
2670 Point_2D & operator*= (F s) { x *= s; y *= s;
return *
this; }
2671 Point_2D & operator/= (F s) {
return operator*= ((F)1 / s); }
2673 Point_2D const operator/ (F s)
const {
return operator* ((F)1 / s); }
2675 F & operator[] (
size_t i) {
return (&x)[i]; }
2676 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2697 template <
typename F>
2700 template <
typename F,
typename S>
2701 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)); }
2703 template <
typename F>
2704 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F>
const & a, Point_2D<F>
const & b) {
2705 return Point_2D<F> (a.x + b.x, a.y + b.y) * 0.5f;
2708 template <
typename F>
2709 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F>
const & a, Point_2D<F>
const & b, Point_2D<F>
const & c) {
2710 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);
2713 template <
typename F>
2714 HPS_INLINE
bool Is_Abnormal (Point_2D<F>
const & p) {
2715 return Is_Abnormal (p.x) || Is_Abnormal (p.y);
2719 template <
typename F>
2727 Vector_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2728 template <
typename D>
2737 bool operator== (
Vector_3D const & v)
const {
2738 return Float::match(x, v.x) && Float::match(y, v.y) && Float::match(z, v.z);
2740 bool operator!= (
Vector_3D const & v)
const {
return !(*
this == v); }
2742 bool Equals(
Vector_3D const & v,
int in_tolerance = 32)
const {
2748 Vector_3D & operator+= (
Vector_3D const & v) { x += v.x; y += v.y; z += v.z;
return *
this; }
2749 Vector_3D & operator-= (
Vector_3D const & v) { x -= v.x; y -= v.y; z -= v.z;
return *
this; }
2753 Vector_3D & operator*= (F s) { x *= s; y *= s; z *= s;
return *
this; }
2754 Vector_3D & operator/= (F s) {
return operator*= (1.0f / s); }
2756 Vector_3D const operator/ (F s)
const {
return operator* (1.0f / s); }
2758 F & operator[] (
size_t i) {
return (&x)[i]; }
2759 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2761 HPS_INLINE
double Length ()
const {
return sqrt (LengthSquared()); }
2763 HPS_INLINE
double LengthSquared ()
const {
return (
double)x*(double)x + (
double)y*(double)y + (
double)z*(double)z; }
2765 HPS_INLINE
double Length2D ()
const {
return sqrt (LengthSquared2D()); }
2767 HPS_INLINE
double LengthSquared2D ()
const {
return (
double)x*(double)x + (
double)y*(double)y;}
2771 F range = Max (Abs (x), Abs (y), Abs (z));
2772 if (range > F(1.0e10))
2776 F len = (F)Length();
2783 HPS_INLINE
Vector_3D & Normalize (F epsilon) {
return Normalize (
false, epsilon); }
2785 HPS_INLINE F Magnitude ()
const {
return Max (Abs(x), Abs(y), Abs(z)); }
2786 HPS_INLINE F Manhattan ()
const {
return Abs(x)+Abs(y)+Abs(z); }
2788 HPS_INLINE F Dot (
Vector_3D const & v)
const {
return x * v.x + y * v.y + z * v.z; }
2791 return Vector_3D (y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
2796 return Vector_3D (x * v.x, y * v.y, z * v.z);
2810 template <
typename F,
typename S>
2813 template <
typename F>
2814 HPS_INLINE
bool Is_Abnormal (Vector_3D<F>
const & v) {
2815 return Is_Abnormal (v.x) || Is_Abnormal (v.y) || Is_Abnormal (v.z);
2819 template <
typename F>
2820 HPS_INLINE Point_3D<F>::Point_3D(Vector_3D<F>
const & v) : x(v.x), y(v.y), z(v.z) {}
2822 template <
typename F>
2823 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; }
2824 template <
typename F>
2825 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; }
2827 template <
typename F>
2828 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); }
2830 template <
typename F>
2831 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); }
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); }
2835 template <
typename F>
2836 HPS_INLINE Point_3D<F> & Point_3D<F>::operator*= (Vector_3D<F>
const & v) { x *= v.x; y *= v.y; z *= v.z;
return *
this; }
2837 template <
typename F>
2838 HPS_INLINE Point_3D<F> & Point_3D<F>::operator/= (Vector_3D<F>
const & v) { x /= v.x; y /= v.y; z /= v.z;
return *
this; }
2839 template <
typename F>
2840 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); }
2841 template <
typename F>
2842 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); }
2846 template <
typename F>
2847 HPS_INLINE Point_3D<F> Interpolate(Point_3D<F>
const & a, Point_3D<F>
const & b,
float t) {
2848 return a + (b - a) * t;
2851 template <
typename F>
2852 HPS_INLINE Vector_3D<F> Interpolate(Vector_3D<F>
const & a, Vector_3D<F>
const & b,
float t) {
2853 return Vector_3D<F>(a + (b - a) * t).Normalize();
2858 template <
typename F>
2859 HPS_INLINE
double PointToPointDistance(Point_3D<F>
const & p1, Point_3D<F>
const & p2) {
2860 return (p2 - p1).Length();
2863 template <
typename F>
2864 HPS_INLINE
double PointToPointDistanceSquared(Point_3D<F>
const & p1, Point_3D<F>
const & p2) {
2865 return (p2 - p1).LengthSquared();
2868 template <
typename F>
2869 HPS_INLINE Point_3D<F> Circumcenter(Point_3D<F>
const & a, Point_3D<F>
const & b, Point_3D<F>
const & c) {
2870 F p =
static_cast<F
>((c - b).LengthSquared());
2871 F q =
static_cast<F
>((c - a).LengthSquared());
2872 F r =
static_cast<F
>((b - a).LengthSquared());
2875 (a * (p*(q+r-p)) + (Vector_3D<F>)b * (q*(r+p-q)) + (Vector_3D<F>)c * (r*(p+q-r)))
2876 / (2 * (p*q + p*r + q*r) - (p*p + q*q + r*r)) );
2881 template <
typename F>
2882 HPS_INLINE
bool Normalize(
size_t count, Vector_3D<F> * vectors) {
2883 bool success =
true;
2884 for (
size_t i = 0; i < count; ++i) {
2885 if (vectors->Normalize() == Vector_3D<F>::Zero())
2893 template <
typename F>
class HPS_TEMPLATE_API Plane_2D;
2895 template <
typename F>
2902 Vector_2D (F v1, F v2) : x (v1), y (v2) {}
2903 template <
typename D>
2912 bool operator== (
Vector_2D const & v)
const {
2913 return Float::match(x, v.x) && Float::match(y, v.y);
2915 bool operator!= (
Vector_2D const & v)
const {
return !(*
this == v); }
2917 bool Equals(
Vector_2D const & v,
int in_tolerance = 32)
const {
2926 Vector_2D & operator*= (F s) { x *= s; y *= s;
return *
this; }
2927 Vector_2D & operator/= (F s) {
return operator*= (1.0f / s); }
2929 Vector_2D const operator/ (F s)
const {
return operator* (1.0f / s); }
2931 F & operator[] (
size_t i) {
return (&x)[i]; }
2932 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2934 HPS_INLINE
double Length ()
const {
return sqrt (LengthSquared()); }
2936 HPS_INLINE
double LengthSquared ()
const {
return (
double)x*(double)x + (
double)y*(double)y; }
2940 F range = Max (Abs (x), Abs (y));
2941 if (range > F(1.0e10))
2945 F len = (F)Length();
2952 HPS_INLINE
Vector_2D & Normalize (F epsilon) {
return Normalize (
false, epsilon); }
2954 HPS_INLINE F Magnitude ()
const {
return Max (Abs(x), Abs(y)); }
2955 HPS_INLINE F Manhattan ()
const {
return Abs(x)+Abs(y); }
2957 HPS_INLINE F Dot (
Vector_2D const & v)
const {
return x * v.x + y * v.y; }
2960 HPS_INLINE
float Cross (
Vector_2D const & v)
const {
2961 return x * v.y - y * v.x;
2978 template <
typename F,
typename S>
2981 template <
typename F>
2982 HPS_INLINE
bool Is_Abnormal (Vector_2D<F>
const & v) {
2983 return Is_Abnormal (v.x) || Is_Abnormal (v.y);
2987 template <
typename F>
2988 HPS_INLINE Vector_3D<F>::Vector_3D (Vector_2D<F>
const & that) : x (that.x), y (that.y), z(0) {}
2990 template <
typename F>
2991 HPS_INLINE Point_3D<F>::Point_3D(Vector_2D<F>
const & v) : x(v.x), y(v.y), z(0) {}
2993 template <
typename F>
2994 HPS_INLINE Point_3D<F> & Point_3D<F>::operator+= (Vector_2D<F>
const & v) { x += v.x; y += v.y;
return *
this; }
2995 template <
typename F>
2996 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>
const Point_3D<F>::operator+ (Vector_2D<F>
const & v)
const {
return Point_3D<F> (x + v.x, y + v.y, z); }
3000 template <
typename F>
3001 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> & Point_3D<F>::operator*= (Vector_2D<F>
const & v) { x *= v.x; y *= v.y;
return *
this; }
3005 template <
typename F>
3006 HPS_INLINE Point_3D<F> & Point_3D<F>::operator/= (Vector_2D<F>
const & v) { x /= v.x; y /= v.y;
return *
this; }
3008 template <
typename F>
3009 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator* (Vector_2D<F>
const & v)
const {
return Point_3D<F> (x * v.x, y * v.y, z); }
3010 template <
typename F>
3011 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); }
3014 template <
typename F>
3015 HPS_INLINE Point_2D<F> & Point_2D<F>::operator+= (Vector_2D<F>
const & v) { x += v.x; y += v.y;
return *
this; }
3016 template <
typename F>
3017 HPS_INLINE Point_2D<F> & Point_2D<F>::operator-= (Vector_2D<F>
const & v) { x -= v.x; y -= v.y;
return *
this; }
3019 template <
typename F>
3020 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); }
3022 template <
typename F>
3023 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); }
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); }
3027 template <
typename F>
3028 HPS_INLINE Point_2D<F> & Point_2D<F>::operator*= (Vector_2D<F>
const & v) { x *= v.x; y *= v.y;
return *
this; }
3029 template <
typename F>
3030 HPS_INLINE Point_2D<F> & Point_2D<F>::operator/= (Vector_2D<F>
const & v) { x /= v.x; y /= v.y;
return *
this; }
3031 template <
typename F>
3032 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>
3034 HPS_INLINE Point_2D<F>
const Point_2D<F>::operator/ (Vector_2D<F>
const & v)
const {
return Point_2D<F> (x / v.x, y / v.y); }
3040 template <
typename F>
3049 Plane_3D (F v1, F v2, F v3, F v4) : a (v1), b (v2), c (v3), d (v4) {}
3053 template <
typename D>
3054 explicit Plane_3D (
Plane_3D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c), d ((F)that.d) {}
3070 for (
size_t i=0; i<count; ++i) {
3073 normal.x += (p0->y + p1->y) * (p1->z - p0->z);
3074 normal.y += (p0->z + p1->z) * (p1->x - p0->x);
3075 normal.z += (p0->x + p1->x) * (p1->y - p0->y);
3085 double inv_count = 1.0 / (double)count;
3093 *
this = Plane_3D::Zero();
3099 bool operator== (
Plane_3D const & p)
const {
return a == p.a && b == p.b && c == p.c && d == p.d; }
3100 bool operator!= (
Plane_3D const & p)
const {
return !(*
this == p); }
3102 F & operator[] (
size_t i) {
return (&a)[i]; }
3103 F
const & operator[] (
size_t i)
const {
return (&a)[i]; }
3105 HPS_INLINE
bool Equals(
Plane_3D const & p,
int in_tolerance = 32)
const {
3120 F val1 = Abs (a * p1.x + b * p1.y + c * p1.z + d);
3121 F val2 = Abs (a * p2.x + b * p2.y + c * p2.z + d);
3124 return Point_3D<F> (((val1 * p2.x) + (val2 * p1.x)) / (val1 + val2),
3125 ((val1 * p2.y) + (val2 * p1.y)) / (val1 + val2),
3126 ((val1 * p2.z) + (val2 * p1.z)) / (val1 + val2));
3133 F u = (a * p1.x + b * p1.y + c * p1.z + d) /
3134 (a * (p1.x - p2.x) + b * (p1.y - p2.y) + c * (p1.z - p2.z));
3136 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));
3139 static HPS_INLINE
Plane_3D Zero() {
return Plane_3D (0.0f, 0.0f, 0.0f, 0.0f);};
3143 Plane_3D & operator*= (F s) { a *= s; b *= s; c *= s; d *= s;
return *
this; }
3144 Plane_3D & operator/= (F s) {
return operator*= ((F)1.0 / s); }
3145 Plane_3D const operator* (F s)
const {
return Plane_3D (a * s, b * s, c * s, d * s); }
3146 Plane_3D const operator/ (F s)
const {
return operator* ((F)1.0 / s); }
3153 template <
typename F>
3154 HPS_INLINE
bool Is_Abnormal (
Plane_3D<F> const & p) {
3155 return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c) || Is_Abnormal (p.d);
3159 template <
typename F>
3160 HPS_INLINE F operator* (Plane_3D<F>
const & plane, Point_3D<F>
const & point) {
3161 return plane.a * point.x + plane.b * point.y + plane.c * point.z + plane.d;
3163 template <
typename F>
3164 HPS_INLINE F operator* (Point_3D<F>
const & point, Plane_3D<F>
const & plane) {
3165 return plane * point;
3168 template <
typename F>
3169 HPS_INLINE Plane_3D<F> Interpolate(Plane_3D<F>
const & a, Plane_3D<F>
const & b,
float t) {
3170 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);
3173 template <
typename F>
3174 Vector_3D<F>::Vector_3D(Plane_3D<F>
const & p) : x(p.a), y(p.b), z(p.c) {}
3181 template <
typename F>
3189 Plane_2D (F v1, F v2, F v3) : a (v1), b (v2), c (v3) {}
3193 template <
typename D>
3194 explicit Plane_2D (
Plane_2D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c) {}
3198 bool operator== (
Plane_2D const & p)
const {
return a == p.a && b == p.b && c == p.c; }
3199 bool operator!= (
Plane_2D const & p)
const {
return !(*
this == p); }
3201 F & operator[] (
size_t i) {
return (&a)[i]; }
3202 F
const & operator[] (
size_t i)
const {
return (&a)[i]; }
3204 HPS_INLINE
bool Equals(
Plane_2D const & p,
int in_tolerance = 32)
const {
3221 Plane_2D & operator*= (F s) { a *= s; b *= s; c *= s;
return *
this; }
3222 Plane_2D & operator/= (F s) {
return operator*= ((F)1.0 / s); }
3223 Plane_2D const operator* (F s)
const {
return Plane_2D (a * s, b * s, c * s); }
3224 Plane_2D const operator/ (F s)
const {
return operator* ((F)1.0 / s); }
3231 template <
typename F>
3232 HPS_INLINE
bool Is_Abnormal (
Plane_2D<F> const & p) {
3233 return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c);
3237 template <
typename F>
3238 HPS_INLINE F operator* (Plane_2D<F>
const & plane, Point_2D<F>
const & point) {
3239 return plane.a * point.x + plane.b * point.y + plane.c;
3241 template <
typename F>
3242 HPS_INLINE F operator* (Point_3D<F>
const & point, Plane_2D<F>
const & plane) {
3243 return plane * point;
3246 template <
typename F>
3247 HPS_INLINE Plane_2D<F> Interpolate(Plane_2D<F>
const & a, Plane_2D<F>
const & b,
float t) {
3248 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);
3251 template <
typename F>
3252 Vector_2D<F>::Vector_2D(Plane_2D<F>
const & p) : x(p.a), y(p.b) {}
3266 : left(std::numeric_limits<int>::max()), right(std::numeric_limits<int>::min()),
3267 bottom(std::numeric_limits<int>::max()), top(std::numeric_limits<int>::min()) {}
3269 IntRectangle(
int in_left,
int in_right,
int in_bottom,
int in_top)
3270 : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3273 : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3278 return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3282 return !(*
this == rect);
3285 HPS_INLINE
int PixelWidth()
const {
3286 return right - left + 1;
3289 HPS_INLINE
int PixelHeight()
const {
3290 return top - bottom + 1;
3293 HPS_INLINE
int Width()
const {
3294 return right - left;
3297 HPS_INLINE
int Height()
const {
3298 return top - bottom;
3301 HPS_INLINE
int Area()
const {
3302 return Width() * Height();
3305 HPS_INLINE
Point2D Center()
const {
3306 return Point2D((
float)(left + right) * 0.5f, (
float)(bottom + top) * 0.5f);
3309 HPS_INLINE
bool Intersecting(
IntRectangle const & rect)
const {
3310 return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3313 HPS_INLINE
bool Contains(
IntRectangle const & rect)
const {
3314 return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3327 right += rect.right;
3328 bottom -= rect.bottom;
3343 right -= rect.right;
3344 bottom += rect.bottom;
3350 left = Max(left, rect.left);
3351 right = Min(right, rect.right);
3352 bottom = Max(bottom, rect.bottom);
3353 top = Min(top, rect.top);
3358 left = Min(left, rect.left);
3359 right = Max(right, rect.right);
3360 bottom = Min(bottom, rect.bottom);
3361 top = Max(top, rect.top);
3378 return temp.Expand(border);
3381 HPS_INLINE IntRectangle Expand(IntRectangle
const & a,
int border) {
3382 IntRectangle temp = a;
3383 return temp.Expand(border);
3386 HPS_INLINE IntRectangle Contract(IntRectangle
const & a,
int border) {
3387 IntRectangle temp = a;
3388 return temp.Contract(border);
3391 HPS_INLINE IntRectangle Contract(IntRectangle
const & a, IntRectangle
const & border) {
3392 IntRectangle temp = a;
3393 return temp.Contract(border);
3396 HPS_INLINE IntRectangle Intersect(IntRectangle
const & a, IntRectangle
const & b) {
3397 IntRectangle temp = a;
3398 return temp.Intersect(b);
3401 HPS_INLINE IntRectangle Union(IntRectangle
const & a, IntRectangle
const & b) {
3402 IntRectangle temp = a;
3403 return temp.Union(b);
3413 : left(std::numeric_limits<float>::max()), right(std::numeric_limits<float>::min()),
3414 bottom(std::numeric_limits<float>::max()), top(std::numeric_limits<float>::min()) {}
3416 Rectangle(
float in_left,
float in_right,
float in_bottom,
float in_top)
3417 : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3420 : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3423 : left((
float)that.left), right((
float)that.right), bottom((
float)that.bottom), top((
float)that.top) {}
3433 Merge(count, points);
3445 Merge(count, points);
3449 HPS_INLINE
float Width()
const {
3450 return right - left;
3453 HPS_INLINE
float Height()
const {
3454 return top - bottom;
3457 HPS_INLINE
float Area()
const {
3458 return Width() * Height();
3461 HPS_INLINE
Point2D Center()
const {
3462 return Point2D((left + right) * 0.5f, (bottom + top) * 0.5f);
3465 HPS_INLINE
void Merge(
size_t count,
Point const * points) {
3468 if (Compare(points[0].x, points[1].x)>0) {
3469 Float::replace_if_smaller(left, points[1].x);
3470 Float::replace_if_larger(right, points[0].x);
3473 Float::replace_if_smaller(left, points[0].x);
3474 Float::replace_if_larger(right, points[1].x);
3477 if (Compare(points[0].y, points[1].y)>0) {
3478 Float::replace_if_smaller(bottom, points[1].y);
3479 Float::replace_if_larger(top, points[0].y);
3482 Float::replace_if_smaller(bottom, points[0].y);
3483 Float::replace_if_larger(top, points[1].y);
3494 HPS_INLINE
void Merge(
Point const & point) {
3495 Float::replace_if_smaller(left, point.x);
3496 Float::replace_if_smaller(bottom, point.y);
3497 Float::replace_if_larger(right, point.x);
3498 Float::replace_if_larger(top, point.y);
3501 HPS_INLINE
void Merge(
size_t count,
Point2D const * points) {
3504 if (Compare(points[0].x, points[1].x)>0) {
3505 Float::replace_if_smaller(left, points[1].x);
3506 Float::replace_if_larger(right, points[0].x);
3509 Float::replace_if_smaller(left, points[0].x);
3510 Float::replace_if_larger(right, points[1].x);
3513 if (Compare(points[0].y, points[1].y)>0) {
3514 Float::replace_if_smaller(bottom, points[1].y);
3515 Float::replace_if_larger(top, points[0].y);
3518 Float::replace_if_smaller(bottom, points[0].y);
3519 Float::replace_if_larger(top, points[1].y);
3530 HPS_INLINE
void Merge(
Point2D const & point) {
3531 Float::replace_if_smaller(left, point.x);
3532 Float::replace_if_smaller(bottom, point.y);
3533 Float::replace_if_larger(right, point.x);
3534 Float::replace_if_larger(top, point.y);
3537 bool operator==(
Rectangle const & rect)
const {
3538 return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3541 bool operator!=(
Rectangle const & rect)
const {
3542 return !(*
this == rect);
3545 HPS_INLINE
bool Intersecting(
Rectangle const & rect)
const {
3546 return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3549 HPS_INLINE
bool Contains(
Point const & contained)
const {
3550 return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3553 HPS_INLINE
bool Contains(
Point2D const & contained)
const {
3554 return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3557 HPS_INLINE
bool Contains(
Rectangle const & rect) {
3558 return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3561 HPS_INLINE
bool Contains(
Rectangle const & rect,
float epsilon) {
3562 return (left <= rect.left + epsilon && right >= rect.right - epsilon &&
3563 bottom <= rect.bottom + epsilon && top >= rect.top - epsilon);
3566 HPS_INLINE
Rectangle & Expand(
float border) {
3574 HPS_INLINE
Rectangle & Expand(
int border) {
3575 Expand((
float)border);
3581 right += rect.right;
3582 bottom -= rect.bottom;
3587 HPS_INLINE
Rectangle & Contract(
int border) {
3597 right -= rect.right;
3598 bottom += rect.bottom;
3604 left = Max(left, rect.left);
3605 right = Min(right, rect.right);
3606 bottom = Max(bottom, rect.bottom);
3607 top = Min(top, rect.top);
3612 left = Min(left, rect.left);
3613 right = Max(right, rect.right);
3614 bottom = Min(bottom, rect.bottom);
3615 top = Max(top, rect.top);
3620 float scale = (scope.right - scope.left) * 0.5f;
3621 float trans = (scope.right + scope.left) * 0.5f;
3623 left = left * scale + trans;
3624 right = right * scale + trans;
3626 scale = (scope.top - scope.bottom) * 0.5f;
3627 trans = (scope.top + scope.bottom) * 0.5f;
3629 bottom = bottom * scale + trans;
3630 top = top * scale + trans;
3635 float tmp = 2.0f/(scope.right - scope.left);
3636 right = (right - scope.left) * tmp - 1.0f;
3637 left = (left - scope.left) * tmp - 1.0f;
3639 tmp = 2.0f/(scope.top - scope.bottom);
3640 top = (top - scope.bottom) * tmp - 1.0f;
3641 bottom = (bottom - scope.bottom) * tmp - 1.0f;
3645 static HPS_INLINE
Rectangle FullScope() {
3646 return Rectangle(-1.0f, 1.0f, -1.0f, 1.0f);
3649 static HPS_INLINE
Rectangle InvalidScope() {
3650 return Rectangle(1.0f, -1.0f, 1.0f, -1.0f);
3662 temp.left = Floor (a.left);
3663 temp.right = Floor (a.right);
3664 temp.bottom = Floor (a.bottom);
3665 temp.top = Floor (a.top);
3669 HPS_INLINE Rectangle Expand(Rectangle
const & a, Rectangle
const & border) {
3671 return temp.Expand(border);
3674 HPS_INLINE Rectangle Expand(Rectangle
const & a,
float border) {
3676 return temp.Expand(border);
3679 HPS_INLINE Rectangle Contract(Rectangle
const & a,
int border) {
3681 return temp.Contract(border);
3684 HPS_INLINE Rectangle Contract(Rectangle
const & a, Rectangle
const & border) {
3686 return temp.Contract(border);
3689 HPS_INLINE Rectangle Intersect(Rectangle
const & a, Rectangle
const & b) {
3691 return temp.Intersect(b);
3694 HPS_INLINE Rectangle Union(Rectangle
const & a, Rectangle
const & b) {
3696 return temp.Union(b);
3699 HPS_INLINE Rectangle Inscribe_Scope(Rectangle
const & a, Rectangle
const & scope) {
3701 return temp.Inscribe_Scope(scope);
3704 HPS_INLINE Rectangle Circumscribe_Scope(Rectangle
const & a, Rectangle
const & scope) {
3706 return temp.Circumscribe_Scope(scope);
3709 HPS_INLINE IntRectangle::IntRectangle(Rectangle
const & that)
3710 : left ((int)that.left), right ((int)that.right), bottom ((int)that.bottom), top ((int)that.top) {}
3715 template <
typename F>
3718 template <
typename F>
3731 template <
typename D>
3760 min = Limit_Point();
3761 max = -Limit_Point();
3764 min = max = *points++;
3767 Merge(count, points);
3780 return min.x <= max.x && min.y <= max.y && min.z <= max.z;
3797 HPS_INLINE
bool operator== (
Cuboid_3D const & cuboid)
const {
return (min == cuboid.
min && max == cuboid.
max); }
3803 HPS_INLINE
bool operator!= (
Cuboid_3D const & cuboid)
const {
return !(*
this == cuboid); }
3828 HPS_INLINE F
Volume ()
const {
return (max.x - min.x) * (max.y - min.y) * (max.z - min.z); }
3836 return max.x >= cuboid.
min.x && min.x <= cuboid.
max.x &&
3837 max.y >= cuboid.
min.y && min.y <= cuboid.
max.y &&
3838 max.z >= cuboid.
min.z && min.z <= cuboid.
max.z;
3847 return max.x + allowance >= cuboid.
min.x && min.x - allowance <= cuboid.
max.x &&
3848 max.y + allowance >= cuboid.
min.y && min.y - allowance <= cuboid.
max.y &&
3849 max.z + allowance >= cuboid.
min.z && min.z - allowance <= cuboid.
max.z;
3860 return max[dimension] >= cuboid.
min[dimension] && min[dimension] <= cuboid.
max[dimension];
3872 return max[dimension] + allowance >= cuboid.
min[dimension] && min[dimension] - allowance <= cuboid.
max[dimension];
3882 return LineIntersecting(start, direction,
true);
3893 return LineIntersecting(point1, direction,
false);
3902 Float::replace_if_smaller(min.x, cuboid.
min.x);
3903 Float::replace_if_smaller(min.y, cuboid.
min.y);
3904 Float::replace_if_smaller(min.z, cuboid.
min.z);
3905 Float::replace_if_larger(max.x, cuboid.
max.x);
3906 Float::replace_if_larger(max.y, cuboid.
max.y);
3907 Float::replace_if_larger(max.z, cuboid.
max.z);
3923 Float::replace_if_smaller(min.x, point.x);
3924 Float::replace_if_smaller(min.y, point.y);
3925 Float::replace_if_smaller(min.z, point.z);
3926 Float::replace_if_larger(max.x, point.x);
3927 Float::replace_if_larger(max.y, point.y);
3928 Float::replace_if_larger(max.z, point.z);
3939 if (Compare(points[0].x, points[1].x)>0) {
3940 Float::replace_if_smaller(min.x, points[1].x);
3941 Float::replace_if_larger(max.x, points[0].x);
3944 Float::replace_if_smaller(min.x, points[0].x);
3945 Float::replace_if_larger(max.x, points[1].x);
3948 if (Compare(points[0].y, points[1].y)>0) {
3949 Float::replace_if_smaller(min.y, points[1].y);
3950 Float::replace_if_larger(max.y, points[0].y);
3953 Float::replace_if_smaller(min.y, points[0].y);
3954 Float::replace_if_larger(max.y, points[1].y);
3957 if (Compare(points[0].z, points[1].z)>0) {
3958 Float::replace_if_smaller(min.z, points[1].z);
3959 Float::replace_if_larger(max.z, points[0].z);
3962 Float::replace_if_smaller(min.z, points[0].z);
3963 Float::replace_if_larger(max.z, points[1].z);
3980 return (contained.
min.x >= min.x &&
3981 contained.
min.y >= min.y &&
3982 contained.
min.z >= min.z &&
3983 contained.
max.x <= max.x &&
3984 contained.
max.y <= max.y &&
3985 contained.
max.z <= max.z);
3994 return (contained.x >= min.x &&
3995 contained.y >= min.y &&
3996 contained.z >= min.z &&
3997 contained.x <= max.x &&
3998 contained.y <= max.y &&
3999 contained.z <= max.z);
4009 return (contained.x >= min.x - epsilon &&
4010 contained.y >= min.y - epsilon &&
4011 contained.z >= min.z - epsilon &&
4012 contained.x <= max.x + epsilon &&
4013 contained.y <= max.y + epsilon &&
4014 contained.z <= max.z + epsilon);
4023 Float::replace_if_larger(min.x, cuboid.
min.x);
4024 Float::replace_if_larger(min.y, cuboid.
min.y);
4025 Float::replace_if_larger(min.z, cuboid.
min.z);
4026 Float::replace_if_smaller(max.x, cuboid.
max.x);
4027 Float::replace_if_smaller(max.y, cuboid.
max.y);
4028 Float::replace_if_smaller(max.z, cuboid.
max.z);
4038 Float::replace_if_smaller(min.x, cuboid.
min.x);
4039 Float::replace_if_smaller(min.y, cuboid.
min.y);
4040 Float::replace_if_smaller(min.z, cuboid.
min.z);
4041 Float::replace_if_larger(max.x, cuboid.
max.x);
4042 Float::replace_if_larger(max.y, cuboid.
max.y);
4043 Float::replace_if_larger(max.z, cuboid.
max.z);
4073 F
const limit = std::numeric_limits<F>::max();
4077 bool LineIntersecting (Point_3D<F>
const & start, Vector_3D<F>
const & direction,
bool is_ray)
const;
4080 typedef Cuboid_3D<float> SimpleCuboid;
4081 typedef Cuboid_3D<double> DSimpleCuboid;
4084 template <
typename F>
4085 HPS_INLINE Cuboid_3D<F> Intersect(Cuboid_3D<F>
const & a, Cuboid_3D<F>
const & b) {
4086 Cuboid_3D<F> temp = a;
4087 return temp.Intersect(b);
4090 template <
typename F>
4091 HPS_INLINE Cuboid_3D<F> Union(Cuboid_3D<F>
const & a, Cuboid_3D<F>
const & b) {
4092 Cuboid_3D<F> temp = a;
4093 return temp.Union(b);
4096 template <
typename F>
4097 HPS_INLINE Cuboid_3D<F> Expand(Cuboid_3D<F>
const & a, F border) {
4098 Cuboid_3D<F> temp = a;
4099 return temp.Expand(border);
4102 template <
typename F>
4103 HPS_INLINE Cuboid_3D<F> Contract(Cuboid_3D<F>
const & a, F border) {
4104 Cuboid_3D<F> temp = a;
4105 return temp.Contract(border);
4110 template <
typename F>
4111 struct HPS_TEMPLATE_API Sphere_3D {
4115 Sphere_3D () : center(Point_3D<F>(0, 0, 0)), radius(0) {}
4117 template <
typename D>
4118 explicit Sphere_3D (Sphere_3D<D>
const & that) : center(Point_3D<F>(that.center)), radius(F(that.radius)) {}
4120 Sphere_3D (Cuboid_3D<F>
const & cuboid) :
4121 center (Midpoint(cuboid.min, cuboid.max)), radius (F(0.5 * cuboid.Diagonal().Length())) {}
4123 Sphere_3D (Point_3D<F>
const & starting_center, F in_radius = 0) : center(starting_center), radius(in_radius) {}
4125 Sphere_3D (
size_t count, Point_3D<F>
const * points) : radius(0.0f) {
4126 Cuboid_3D<F> cuboid(count, points);
4127 center = Midpoint(cuboid.min, cuboid.max);
4128 Engulf (count, points);
4131 Sphere_3D (
size_t count, Point_3D<F>
const * points, Point_3D<F>
const & starting_center) : center(starting_center), radius(0) {
4132 Engulf (count, points);
4135 HPS_INLINE
bool IsValid()
const {
4139 static HPS_INLINE Sphere_3D Invalid() {
return Sphere_3D(Point_3D<F>(0,0,0), -1);};
4141 void Invalidate() {radius = -1;}
4143 HPS_INLINE
bool operator== (Sphere_3D
const & sphere)
const {
return (center == sphere.center && radius == sphere.radius); }
4144 HPS_INLINE
bool operator!= (Sphere_3D
const & sphere)
const {
return !(*
this == sphere); }
4146 HPS_INLINE F Volume ()
const {
return F((4.0 / 3.0 * PI) * radius * radius * radius); }
4148 HPS_INLINE
void Merge(Point_3D<F>
const & point) {
4149 Vector_3D<F> dir = point - center;
4150 F distance = (F)dir.Length();
4152 if (distance > radius) {
4153 F t = F(0.5) * (distance - radius);
4154 center += t * dir.Normalize();
4159 HPS_INLINE
void Merge(
size_t count, Point_3D<F>
const * points) {
4161 for (
size_t i = 0; i < count; ++i) {
4162 Vector_3D<F> dir = *points - center;
4163 F distance = (F)dir.Length();
4165 if (distance > radius) {
4166 F t = F(0.5) * (distance - radius);
4167 center += t * dir.Normalize();
4175 HPS_INLINE
void Merge (Sphere_3D
const & sphere) {
4176 Vector_3D<F> dir = sphere.center - center;
4177 F distance = (F)dir.Length();
4179 if (distance + sphere.radius > radius) {
4180 if (distance + radius > sphere.radius) {
4181 F t = F(0.5 * (sphere.radius + distance - radius));
4182 center += t * dir.Normalize();
4186 center = sphere.center;
4187 radius = sphere.radius;
4192 HPS_INLINE
void Merge (Cuboid_3D<F>
const & cuboid) { Merge (Sphere_3D (cuboid)); }
4196 HPS_INLINE
void Engulf (
size_t count, Point_3D<F>
const * points) {
4197 for (
size_t i = 0; i < count; ++i) {
4198 double dsq = (*points++ - center).LengthSquared();
4199 if ((F)dsq > radius * radius)
4200 radius = (F)sqrt(dsq);
4205 typedef Sphere_3D<float> SimpleSphere;
4206 typedef Sphere_3D<double> DSimpleSphere;
4209 template <
typename F>
4211 min =
Point_3D<F>(sphere.center.x - sphere.radius, sphere.center.y - sphere.radius, sphere.center.z - sphere.radius);
4212 max =
Point_3D<F>(sphere.center.x + sphere.radius, sphere.center.y + sphere.radius, sphere.center.z + sphere.radius);
4230 HPS_INLINE
RGBColor (
float r,
float g,
float b) : red (r), green (g), blue (b) {}
4231 explicit HPS_INLINE RGBColor (
RGB24Color const & c24);
4232 explicit HPS_INLINE RGBColor (
float gray) : red (gray), green (gray), blue (gray) {}
4233 explicit HPS_INLINE RGBColor (
RGBAS32Color const & c32);
4234 explicit HPS_INLINE RGBColor (
RGBA32Color const & c32);
4235 explicit HPS_INLINE RGBColor (
RGBAColor const & c);
4237 HPS_INLINE
bool IsGray()
const {
return (red == green && green == blue);}
4238 HPS_INLINE
float Gray()
const {
return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4239 float Distance(RGBColor
const & other_color)
const;
4240 HPS_INLINE
bool IsValid()
const {
4241 return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue)) == 0;
4244 HPS_INLINE
bool operator== (RGBColor
const & c)
const {
return red == c.red && green == c.green && blue == c.blue; }
4245 HPS_INLINE
bool operator!= (RGBColor
const & c)
const {
return !(*
this == c); }
4247 HPS_INLINE
bool Equals(RGBColor
const & c,
int in_tolerance = 32)
const
4250 HPS_INLINE RGBColor & operator*= (RGBColor
const & c) { red *= c.red; green *= c.green; blue *= c.blue;
return *
this; }
4251 HPS_INLINE RGBColor & operator+= (RGBColor
const & c) { red += c.red; green += c.green; blue += c.blue;
return *
this; }
4252 HPS_INLINE RGBColor & operator-= (RGBColor
const & c) { red -= c.red; green -= c.green; blue -= c.blue;
return *
this; }
4253 HPS_INLINE RGBColor
const operator* (RGBColor
const & c)
const {
return RGBColor (red * c.red, green * c.green, blue * c.blue); }
4254 HPS_INLINE RGBColor
const operator+ (RGBColor
const & c)
const {
return RGBColor (red + c.red, green + c.green, blue + c.blue); }
4255 HPS_INLINE RGBColor
const operator- (RGBColor
const & c)
const {
return RGBColor (red - c.red, green - c.green, blue - c.blue); }
4257 HPS_INLINE RGBColor & operator*= (
float s) { red *= s; green *= s; blue *= s;
return *
this; }
4258 HPS_INLINE RGBColor & operator/= (
float s) {
return operator*= (1.0f / s); }
4259 HPS_INLINE RGBColor & operator+= (
float s) { red += s; green += s; blue += s;
return *
this; }
4260 HPS_INLINE RGBColor & operator-= (
float s) { red -= s; green -= s; blue -= s;
return *
this; }
4261 HPS_INLINE RGBColor
const operator* (
float s)
const {
return RGBColor (red * s, green * s, blue * s); }
4262 HPS_INLINE RGBColor
const operator/ (
float s)
const {
return operator* (1.0f / s); }
4263 HPS_INLINE RGBColor
const operator+ (
float s)
const {
return RGBColor (red + s, green + s, blue + s); }
4264 HPS_INLINE RGBColor
const operator- (
float s)
const {
return RGBColor (red - s, green - s, blue - s); }
4266 static HPS_INLINE RGBColor Black() {
return RGBColor (0, 0, 0);};
4267 static HPS_INLINE RGBColor White() {
return RGBColor (1, 1, 1);};
4268 static HPS_INLINE RGBColor Invalid() {
return RGBColor (-1, -1, -1);};
4270 void ShowHLS(
float & out_hue,
float & out_lightness,
float & out_saturation)
const;
4271 void ShowHSV(
float & out_hue,
float & out_saturation,
float & out_value)
const;
4272 void ShowHIC(
float & out_hue,
float & out_intensity,
float & out_chromaticity)
const;
4274 static RGBColor HLS(
float in_hue,
float in_lightness,
float in_saturation);
4275 static RGBColor HSV(
float in_hue,
float in_saturation,
float in_value);
4276 static RGBColor HIC(
float in_hue,
float in_intensity,
float in_chromaticity);
4279 HPS_INLINE
RGBColor const operator* (
float s,
RGBColor const & v) {
return RGBColor (s * v.red, s * v.green, s * v.blue); }
4280 HPS_INLINE RGBColor
const operator+ (
float s, RGBColor
const & v) {
return RGBColor (s + v.red, s + v.green, s + v.blue); }
4281 HPS_INLINE RGBColor
const operator- (
float s, RGBColor
const & v) {
return RGBColor (s - v.red, s - v.green, s - v.blue); }
4293 explicit HPS_INLINE
RGBAColor (
float gray,
float a = 1) : red (gray), green (gray), blue (gray), alpha (a) {}
4294 HPS_INLINE RGBAColor (
float r,
float g,
float b,
float a = 1) : red (r), green (g), blue (b), alpha (a) {}
4296 HPS_INLINE RGBAColor (RGBColor
const & c) {
4297 memcpy(
this, &c,
sizeof(RGBColor));
4299 Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4301 HPS_INLINE RGBAColor (RGBColor
const & c,
float a) {
4302 memcpy(
this, &c,
sizeof(RGBColor));
4303 memcpy(&alpha, &a,
sizeof(
float));
4304 Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4306 explicit HPS_INLINE RGBAColor (RGBA32Color
const & c32);
4307 explicit HPS_INLINE RGBAColor (RGBAS32Color
const & c32);
4309 HPS_INLINE
bool IsGray()
const {
return (red == green && green == blue);}
4310 HPS_INLINE
float Gray()
const {
return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4311 HPS_INLINE
bool IsValid()
const {
4312 return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue) | Float::extract_sign_bit(alpha)) == 0;
4329 HPS_INLINE
bool operator!= (
RGBAColor const & c)
const {
return !(*
this == c); }
4331 HPS_INLINE
bool Equals(
RGBAColor const & c,
int in_tolerance = 32)
const {
4336 HPS_INLINE RGBAColor & operator*= (RGBAColor
const & c) { red *= c.red; green *= c.green; blue *= c.blue; alpha *= c.alpha;
return *
this; }
4337 HPS_INLINE RGBAColor & operator+= (RGBAColor
const & c) { red += c.red; green += c.green; blue += c.blue; alpha += c.alpha;
return *
this; }
4338 HPS_INLINE RGBAColor & operator-= (RGBAColor
const & c) { red -= c.red; green -= c.green; blue -= c.blue; alpha -= c.alpha;
return *
this; }
4339 HPS_INLINE RGBAColor
const operator* (RGBAColor
const & c)
const {
return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha * c.alpha); }
4340 HPS_INLINE RGBAColor
const operator+ (RGBAColor
const & c)
const {
return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha + c.alpha); }
4341 HPS_INLINE RGBAColor
const operator- (RGBAColor
const & c)
const {
return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha - c.alpha); }
4343 HPS_INLINE RGBAColor & operator*= (
float s) { red *= s; green *= s; blue *= s; alpha *= s;
return *
this; }
4344 HPS_INLINE RGBAColor & operator/= (
float s) {
return operator*= (1.0f / s); }
4345 HPS_INLINE RGBAColor & operator+= (
float s) { red += s; green += s; blue += s; alpha += s;
return *
this; }
4346 HPS_INLINE RGBAColor & operator-= (
float s) { red -= s; green -= s; blue -= s; alpha -= s;
return *
this; }
4347 HPS_INLINE RGBAColor
const operator* (
float s)
const {
return RGBAColor (red * s, green * s, blue * s, alpha * s); }
4348 HPS_INLINE RGBAColor
const operator/ (
float s)
const {
return operator* (1.0f / s); }
4349 HPS_INLINE RGBAColor
const operator+ (
float s)
const {
return RGBAColor (red + s, green + s, blue + s, alpha + s); }
4350 HPS_INLINE RGBAColor
const operator- (
float s)
const {
return RGBAColor (red - s, green - s, blue - s, alpha - s); }
4352 HPS_INLINE RGBAColor & operator*= (RGBColor
const & c) { red *= c.red; green *= c.green; blue *= c.blue;
return *
this; }
4353 HPS_INLINE RGBAColor & operator+= (RGBColor
const & c) { red += c.red; green += c.green; blue += c.blue;
return *
this; }
4354 HPS_INLINE RGBAColor & operator-= (RGBColor
const & c) { red -= c.red; green -= c.green; blue -= c.blue;
return *
this; }
4355 HPS_INLINE RGBAColor
const operator* (RGBColor
const & c)
const {
return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha); }
4356 HPS_INLINE RGBAColor
const operator+ (RGBColor
const & c)
const {
return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha); }
4357 HPS_INLINE RGBAColor
const operator- (RGBColor
const & c)
const {
return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha); }
4359 static HPS_INLINE RGBAColor Black() {
return RGBAColor (0, 0, 0, 1);};
4360 static HPS_INLINE RGBAColor White() {
return RGBAColor (1, 1, 1, 1);};
4361 static HPS_INLINE RGBAColor Nothing() {
return RGBAColor (0, 0, 0, 0);};
4362 static HPS_INLINE RGBAColor Invalid() {
return RGBAColor (-1, -1, -1, -1);};
4376 HPS_INLINE
static Order Preferred_Order () {
return Order_BGRA;}
4377 unsigned char b, g, r, a;
4381 HPS_INLINE
static Order Preferred_Order () {
return Order_RGBA;}
4382 unsigned char r, g, b, a;
4386 HPS_INLINE
static Order Preferred_Order () {
return Order_RGBA;}
4387 unsigned char r, g, b, a;
4397 explicit HPS_INLINE
RGBAS32Color (
unsigned char gray,
unsigned char aa = 255) {
4403 HPS_INLINE
RGBAS32Color (
unsigned char rr,
unsigned char gg,
unsigned char bb,
unsigned char aa = 255) {
4411 explicit HPS_INLINE RGBAS32Color (
RGBColor const & c)
4413 r = Float::unit_to_byte(c.red);
4414 g = Float::unit_to_byte(c.green);
4415 b = Float::unit_to_byte(c.blue);
4419 HPS_INLINE RGBAS32Color (
RGB24Color const & c);
4423 HPS_INLINE RGBAS32Color (
RGBColor const & c,
float alpha)
4425 r = Float::unit_to_byte(c.red);
4426 g = Float::unit_to_byte(c.green);
4427 b = Float::unit_to_byte(c.blue);
4428 a = Float::unit_to_byte(alpha);
4430 HPS_INLINE RGBAS32Color (
RGBColor const & c,
unsigned char aa)
4432 r = Float::unit_to_byte(c.red);
4433 g = Float::unit_to_byte(c.green);
4434 b = Float::unit_to_byte(c.blue);
4437 explicit HPS_INLINE RGBAS32Color (
RGBAColor const & c)
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(c.
alpha);
4444 HPS_INLINE RGBAS32Color (
RGBAColor const & c,
unsigned char mix)
4446 r = Float::unit_to_byte(c.
red);
4447 g = Float::unit_to_byte(c.
green);
4448 b = Float::unit_to_byte(c.
blue);
4449 a = Float::unit_to_byte_scaled(c.
alpha, mix);
4452 HPS_INLINE
bool IsGray()
const {
return (r == g && g == b);}
4453 HPS_INLINE
unsigned char Gray()
const {
return (
unsigned char)(0.3125f * (float)r + 0.5000f * (
float)g + 0.1875f * (float)b); }
4454 HPS_INLINE
bool IsValid()
const {
return ((r | g | b | a) != 0); }
4456 HPS_INLINE
bool operator== (RGBAS32Color
const & c)
const {
return (r == c.r && g == c.g && b == c.b && a == c.a); }
4457 HPS_INLINE
bool operator!= (RGBAS32Color
const & c)
const {
return !(*
this == c); }
4459 static HPS_INLINE RGBAS32Color Black() {
return RGBAS32Color (0, 0, 0, 255);};
4460 static HPS_INLINE RGBAS32Color White() {
return RGBAS32Color (255, 255, 255, 255);};
4461 static HPS_INLINE RGBAS32Color Invalid() {
return RGBAS32Color (0, 0, 0, 0);};
4463 static HPS_INLINE
unsigned char Opaque_Alpha () {
return 0xFF;}
4474 explicit HPS_INLINE
RGBA32Color (
unsigned char gray,
unsigned char aa = 255)
4475 : r (gray), g (gray), b (gray), a (aa) {}
4476 HPS_INLINE RGBA32Color (
unsigned char rr,
unsigned char gg,
unsigned char bb,
unsigned char aa = 255)
4477 : r (rr), g (gg), b (bb), a (aa) {}
4479 : r (c32.r), g (c32.g), b (c32.b), a (c32.a) {}
4480 explicit HPS_INLINE RGBA32Color (
RGBColor const & c) {
4481 r = Float::unit_to_byte(c.red);
4482 g = Float::unit_to_byte(c.green);
4483 b = Float::unit_to_byte(c.blue);
4486 HPS_INLINE RGBA32Color (
RGBColor const & c,
float alpha) {
4487 r = Float::unit_to_byte(c.red);
4488 g = Float::unit_to_byte(c.green);
4489 b = Float::unit_to_byte(c.blue);
4490 a = Float::unit_to_byte(alpha);
4492 HPS_INLINE RGBA32Color (
RGBColor const & c,
unsigned char aa) {
4493 r = Float::unit_to_byte(c.red);
4494 g = Float::unit_to_byte(c.green);
4495 b = Float::unit_to_byte(c.blue);
4498 explicit HPS_INLINE RGBA32Color (
RGBAColor const & c) {
4499 r = Float::unit_to_byte(c.
red);
4500 g = Float::unit_to_byte(c.
green);
4501 b = Float::unit_to_byte(c.
blue);
4502 a = Float::unit_to_byte(c.
alpha);
4504 HPS_INLINE RGBA32Color (
RGBAColor const & c,
unsigned char mix) {
4505 r = Float::unit_to_byte(c.
red);
4506 g = Float::unit_to_byte(c.
green);
4507 b = Float::unit_to_byte(c.
blue);
4508 a = Float::unit_to_byte_scaled(c.
alpha, mix);
4511 HPS_INLINE
bool IsGray()
const {
return (r == g && g == b);}
4512 HPS_INLINE
unsigned char Gray()
const {
return (
unsigned char)(0.3125f * (float)r + 0.5000f * (
float)g + 0.1875f * (float)b); }
4514 HPS_INLINE
bool operator== (RGBA32Color
const & c)
const {
return (r == c.r && g == c.g && b == c.b && a == c.a); }
4515 HPS_INLINE
bool operator!= (RGBA32Color
const & c)
const {
return !(*
this == c); }
4517 static HPS_INLINE RGBA32Color Black() {
return RGBA32Color (0, 0, 0, 255);};
4518 static HPS_INLINE RGBA32Color White() {
return RGBA32Color (255, 255, 255, 255);};
4520 static HPS_INLINE
unsigned char Opaque_Alpha () {
return 0xFF;}
4532 explicit HPS_INLINE
RGB24Color (
unsigned char gray)
4533 : r (gray), g (gray), b (gray) {}
4534 HPS_INLINE RGB24Color (
unsigned char rr,
unsigned char gg,
unsigned char bb)
4535 : r (rr), g (gg), b (bb) {}
4536 explicit HPS_INLINE RGB24Color (
RGBColor const & c) {
4537 r = Float::unit_to_byte(c.red);
4538 g = Float::unit_to_byte(c.green);
4539 b = Float::unit_to_byte(c.blue);
4542 HPS_INLINE
bool IsGray()
const {
return (r == g && g == b);}
4543 HPS_INLINE
unsigned char Gray()
const {
return (
unsigned char)(0.3125f * (float)r + 0.5000f * (
float)g + 0.1875f * (float)b); }
4545 HPS_INLINE
bool operator== (RGB24Color
const & c)
const {
return (r == c.r && g == c.g && b == c.b); }
4546 HPS_INLINE
bool operator!= (RGB24Color
const & c)
const {
return !(*
this == c); }
4549 HPS_INLINE RGBColor::RGBColor (
RGBAS32Color const & c32) {
4550 red = Float::C2F(c32.r);
4551 green = Float::C2F(c32.g);
4552 blue = Float::C2F(c32.b);
4555 HPS_INLINE RGBColor::RGBColor (RGBA32Color
const & c32) {
4556 red = Float::C2F(c32.r);
4557 green = Float::C2F(c32.g);
4558 blue = Float::C2F(c32.b);
4561 HPS_INLINE RGBColor::RGBColor (RGBAColor
const & c) {
4567 HPS_INLINE RGBColor::RGBColor (RGB24Color
const & c24) {
4568 red = Float::C2F(c24.r);
4569 green = Float::C2F(c24.g);
4570 blue = Float::C2F(c24.b);
4573 HPS_INLINE RGBAS32Color::RGBAS32Color (RGB24Color
const & c)
4581 HPS_INLINE RGBAS32Color::RGBAS32Color (RGBA32Color
const & c)
4589 HPS_INLINE RGBAColor::RGBAColor (RGBAS32Color
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 RGBAColor::RGBAColor (RGBA32Color
const & c32) {
4597 red = Float::C2F(c32.r);
4598 green = Float::C2F(c32.g);
4599 blue = Float::C2F(c32.b);
4600 alpha = Float::C2F(c32.a);
4603 HPS_INLINE RGBColor Modulate(RGBColor
const & a, RGBColor
const & b) {
4604 return RGBColor(a.red * b.red, a.green * b.green, a.blue * b.blue);
4609 HPS_INLINE RGBColor Interpolate(RGBColor
const & a, RGBColor
const & b,
float t) {
4610 return RGBColor(a.red + (b.red - a.red) * t, a.green + (b.green - a.green) * t, a.blue + (b.blue - a.blue) * t);
4613 HPS_INLINE RGBAColor Interpolate(RGBAColor
const & a, RGBAColor
const & b,
float t) {
4614 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);
4617 HPS_INLINE RGBAS32Color Interpolate(RGBAS32Color
const & a, RGBAS32Color
const & b,
float t) {
4618 return RGBAS32Color(
4619 (
unsigned char)(a.r + ((
float)b.r - (
float)a.r) * t),
4620 (
unsigned char)(a.g + ((
float)b.g - (
float)a.g) * t),
4621 (
unsigned char)(a.b + ((
float)b.b - (
float)a.b) * t),
4622 (
unsigned char)(a.a + ((
float)b.a - (
float)a.a) * t));
4625 HPS_INLINE RGBA32Color Interpolate(RGBA32Color
const & a, RGBA32Color
const & b,
float t) {
4627 (
unsigned char)(a.r + ((
float)b.r - (
float)a.r) * t),
4628 (
unsigned char)(a.g + ((
float)b.g - (
float)a.g) * t),
4629 (
unsigned char)(a.b + ((
float)b.b - (
float)a.b) * t),
4630 (
unsigned char)(a.a + ((
float)b.a - (
float)a.a) * t));
4633 HPS_INLINE RGB24Color Interpolate(RGB24Color
const & a, RGB24Color
const & b,
float t) {
4635 (
unsigned char)(a.r + ((
float)b.r - (
float)a.r) * t),
4636 (
unsigned char)(a.g + ((
float)b.g - (
float)a.g) * t),
4637 (
unsigned char)(a.b + ((
float)b.b - (
float)a.b) * t));
4649 Quaternion() : w(0.0f), x(0.0f), y(0.0f), z(0.0f) { }
4651 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) { }
4669 return Quaternion(w*in_right.w - x*in_right.x - y*in_right.y - z*in_right.z,
4670 y*in_right.z - z*in_right.y + w*in_right.x + x*in_right.w,
4671 z*in_right.x - x*in_right.z + w*in_right.y + y*in_right.w,
4672 x*in_right.y - y*in_right.x + w*in_right.z + z*in_right.w);
4675 Quaternion operator* (
float in_right)
const {
4676 return Quaternion(w*in_right, x*in_right, y*in_right, z*in_right);
4680 return Quaternion(in_left*in_right.w, in_left*in_right.x, in_left*in_right.y, in_left*in_right.z);
4683 Quaternion operator/ (
float in_right)
const {
4684 return Quaternion(w/in_right, x/in_right, y/in_right, z/in_right);
4688 return Quaternion(w-in_right.w, x-in_right.x, y-in_right.y, z-in_right.z);
4692 return Quaternion(w+in_right.w, x+in_right.x, y+in_right.y, z+in_right.z);
4695 inline float Norm()
const {
4696 return static_cast<float>(sqrt(w*w + x*x + y*y + z*z));
4702 float mag_q = Norm();
4703 float mag_V =
static_cast<float>(sqrt(x*x + y*y + z*z));
4705 ret.w =
static_cast<float>(log(mag_q));
4708 float scale =
static_cast<float>(acos(w / mag_q) / mag_V);
4715 ret.x = ret.y = ret.z = 0;
4722 float ea =
static_cast<float>(exp(w));
4723 float mag_V =
static_cast<float>(sqrt(x*x + y*y + z*z));
4724 float scale = ea * sin(mag_V) / mag_V;
4726 ret.w = ea * cos(mag_V);
4735 Quaternion ret = *
this + in_fraction * (in_right - *
this);
4736 return ret.Normalize();
4740 Quaternion Slerp(
Quaternion const & in_right,
float in_fraction,
bool in_shortest_path_only =
true)
const {
4742 float dot = x*in_right.x + y*in_right.y + z*in_right.z + w*in_right.w;
4744 if (in_shortest_path_only && dot < 0) {
4751 if (dot > -0.95f && dot < 0.95f) {
4752 float angle =
static_cast<float>(acos(dot));
4753 float sina =
static_cast<float>(sin(angle));
4754 float sinat =
static_cast<float>(sin(angle*in_fraction));
4755 float sinaomt =
static_cast<float>(sin(angle*(1-in_fraction)));
4757 return (*
this * sinaomt + q3 * sinat) / sina;
4760 return Lerp(q3, in_fraction);
4773 Quaternion q1 = Slerp(in_right , in_fraction,
false);
4774 Quaternion q2 = in_control1.Slerp(in_control2, in_fraction,
false);
4776 return q1.Slerp(q2, 2*in_fraction*(1-in_fraction),
false);
4788 return *
this *
Quaternion(((qni*in_previous).Log() + (qni*in_next).Log()) / -4).Exp();
4795 size_t dot_dc_count;
4796 size_t dot_3d_count;
4797 size_t line_dc_count;
4798 size_t line_3d_count;
4799 size_t triangle_dc_count;
4800 size_t triangle_3d_count;
4801 size_t polygon_dc_count;
4802 size_t polygon_3d_count;
4803 size_t polyhedron_count;
4804 size_t deleted_display_list_count;
4805 size_t display_list_line_3d_count;
4806 size_t display_list_triangle_3d_count;
4807 size_t display_list_vertex_3d_count;
4808 size_t display_list_tristrip_count;
4809 size_t non_display_list_tristrip_count;
4810 size_t culled_display_list_tristrip_count;
4811 size_t raster_count;
4812 size_t segment_count;
4813 size_t frustum_culled_segment_count;
4814 size_t extent_culled_segment_count;
4815 size_t vector_culled_segment_count;
4819 typedef unsigned char byte;
4820 typedef signed char sbyte;
4821 typedef intptr_t WindowHandle;
4822 typedef int64_t TouchID;
4823 typedef intptr_t PlatformData;
4824 typedef intptr_t OpaqueHandle;
4857 class AttributesControl;
4873 class GeometryInsertControl;
4970 class ShaderDefinition;
5018 class FontInfoControl;
5085 enum class Type : uint32_t
5088 GenericMask = 0xffffff00,
5092 EventDispatcher = 0x00000003,
5093 EventHandler = 0x00000004,
5094 EventNotifier = 0x00000005,
5095 UpdateNotifier = 0x00000006,
5096 SearchResults = 0x00000008,
5097 FontSearchResults = 0x00000009,
5098 SearchResultsIterator = 0x0100000a,
5099 FontSearchResultsIterator = 0x0100000b,
5100 SelectionResults = 0x0000000c,
5101 SelectionResultsIterator = 0x0100000d,
5102 SelectionItem = 0x0000000e,
5103 TreeContext = 0x0000000f,
5104 StreamToolkit = 0x00000010,
5105 DriverEventHandler = 0x00000011,
5107 IONotifier = 0x04000100,
5108 StreamImportNotifier = 0x04000101,
5109 STLImportNotifier = 0x04000102,
5110 OBJImportNotifier = 0x04000103,
5111 ExchangeImportNotifier = 0x04000104,
5112 SketchupImportNotifier = 0x04000105,
5113 ParasolidImportNotifier = 0x04000106,
5114 ExchangeTranslationNotifier = 0x04000107,
5115 ExchangeExportNotifier = 0x04000108,
5116 StreamExportNotifier = 0x04000109,
5117 ExchangeReloadNotifier = 0x0400010a,
5120 MarkerKit = 0x01000010,
5121 SphereAttributeKit = 0x01000011,
5122 TextAttributeKit = 0x01000012,
5123 TransparencyKit = 0x01000013,
5124 VisibilityKit = 0x01000014,
5125 VisualEffectsKit = 0x01000015,
5126 CuttingSectionAttributeKit = 0x01000016,
5127 CircleKit = 0x01000017,
5128 CircularArcKit = 0x01000018,
5129 CircularWedgeKit = 0x01000019,
5130 CuttingSectionKit = 0x0100001a,
5131 CylinderKit = 0x0100001b,
5132 DistantLightKit = 0x0100001c,
5133 EllipseKit = 0x0100001d,
5134 EllipticalArcKit = 0x0100001e,
5135 InfiniteLineKit = 0x0100001f,
5136 LineKit = 0x01000020,
5137 NURBSCurveKit = 0x01000021,
5138 MeshKit = 0x01000022,
5139 NURBSSurfaceKit = 0x01000023,
5140 PolygonKit = 0x01000024,
5141 SphereKit = 0x01000025,
5142 SpotlightKit = 0x01000026,
5143 ShellKit = 0x01000027,
5144 TextKit = 0x01000028,
5145 MaterialKit = 0x01000029,
5146 TrimKit = 0x0100002a,
5147 TextureOptionsKit = 0x0100002c,
5148 LinePatternKit = 0x0100002d,
5149 GlyphKit = 0x0100002e,
5150 ImageKit = 0x0100002f,
5151 LinePatternOptionsKit = 0x01000030,
5152 CameraKit = 0x01000031,
5153 BoundingKit = 0x01000032,
5154 CullingKit = 0x01000033,
5155 CurveAttributeKit = 0x01000034,
5156 CylinderAttributeKit = 0x01000035,
5157 EdgeAttributeKit = 0x01000036,
5158 LightingAttributeKit = 0x01000037,
5159 LineAttributeKit = 0x01000038,
5160 MarkerAttributeKit = 0x01000039,
5161 MaterialMappingKit = 0x0100003a,
5162 MatrixKit = 0x0100003b,
5163 NURBSSurfaceAttributeKit = 0x0100003c,
5164 PostProcessEffectsKit = 0x0100003d,
5165 SelectabilityKit = 0x0100003e,
5166 SelectionOptionsKit = 0x0100003f,
5167 StandAloneWindowOptionsKit = 0x01000040,
5168 OffScreenWindowOptionsKit = 0x01000041,
5169 ApplicationWindowOptionsKit = 0x01000042,
5170 HighlightOptionsKit = 0x01000043,
5171 LinePatternParallelKit = 0x01000044,
5172 SubwindowKit = 0x01000045,
5173 PerformanceKit = 0x01000046,
5174 HiddenLineAttributeKit = 0x01000047,
5175 DrawingAttributeKit = 0x01000048,
5176 ShaderKit = 0x01000049,
5177 DebuggingKit = 0x0100004a,
5178 ContourLineKit = 0x0100004b,
5179 StreamImportOptionsKit = 0x0100004c,
5180 StreamImportResultsKit = 0x0100004d,
5181 StreamExportOptionsKit = 0x0100004e,
5182 StreamExportResultsKit = 0x0100004f,
5183 WindowInfoKit = 0x01000050,
5184 ImageImportOptionsKit = 0x01000051,
5185 SearchOptionsKit = 0x01000052,
5186 ShaderImportOptionsKit = 0x01000053,
5187 HardcopyExportOptionsKit = 0x01000055,
5188 AttributeLockKit = 0x01000056,
5189 TransformMaskKit = 0x01000057,
5190 ColorInterpolationKit = 0x01000058,
5191 UpdateOptionsKit = 0x01000059,
5192 ImageExportOptionsKit = 0x0100005a,
5193 OBJImportOptionsKit = 0x0100005b,
5194 OBJImportResultsKit = 0x0100005c,
5195 STLImportOptionsKit = 0x0100005d,
5196 STLImportResultsKit = 0x0100005e,
5197 ShellOptimizationOptionsKit = 0x0100005f,
5198 ShellRelationOptionsKit = 0x01000060,
5199 ShellRelationResultsKit = 0x01000061,
5200 GridKit = 0x01000062,
5201 CutGeometryGatheringOptionsKit = 0x01000063,
5202 SegmentOptimizationOptionsKit = 0x01000064,
5205 LinePatternElement = 0x03000000,
5206 SolidLinePatternElement = 0x03000001,
5207 BlankLinePatternElement = 0x03000002,
5208 GlyphLinePatternElement = 0x03000003,
5210 GlyphElement = 0x05000000,
5211 DotGlyphElement = 0x05000001,
5212 LineGlyphElement = 0x05000002,
5213 EllipseGlyphElement = 0x05000003,
5214 CircularArcGlyphElement = 0x05000004,
5215 InfiniteLineGlyphElement = 0x05000005,
5217 TrimElement = 0x07000000,
5219 Condition = 0x09000000,
5220 NOTCondition = 0x09000001,
5221 ANDCondition = 0x09000002,
5222 ORCondition = 0x09000003,
5223 XORCondition = 0x09000004,
5224 EQCondition = 0x09000005,
5225 NEQCondition = 0x09000006,
5226 GTCondition = 0x09000007,
5227 LTCondition = 0x09000008,
5228 GTEQCondition = 0x09000009,
5229 LTEQCondition = 0x0900000A,
5231 MouseState = 0x01001001,
5232 TouchState = 0x01001002,
5233 KeyboardState = 0x01001003,
5234 FontInfoState = 0x01001004,
5236 KeyPath = 0x01000F01,
5239 IncludeKey = 0x10000001,
5240 PortfolioKey = 0x10000002,
5241 StyleKey = 0x10000003,
5243 SegmentKey = 0x10200000,
5244 WindowKey = 0x10600000,
5245 StandAloneWindowKey = 0x10600001,
5246 OffScreenWindowKey = 0x10600002,
5247 ApplicationWindowKey = 0x10600003,
5249 GeometryKey = 0x10100000,
5250 ReferenceKey = 0x10100001,
5251 CircleKey = 0x10100002,
5252 CircularArcKey = 0x10100003,
5253 CircularWedgeKey = 0x10100004,
5254 CuttingSectionKey = 0x10100005,
5255 CylinderKey = 0x10100006,
5256 EllipseKey = 0x10100007,
5257 EllipticalArcKey = 0x10100008,
5258 InfiniteLineKey = 0x10100009,
5259 LineKey = 0x1010000a,
5260 DistantLightKey = 0x1010000b,
5261 SpotlightKey = 0x1010000c,
5262 MarkerKey = 0x1010000d,
5263 MeshKey = 0x1010000e,
5264 NURBSCurveKey = 0x1010000f,
5265 NURBSSurfaceKey = 0x10100010,
5266 PolygonKey = 0x10100011,
5267 ShellKey = 0x10100012,
5268 SphereKey = 0x10100013,
5269 TextKey = 0x10100014,
5270 GridKey = 0x10100015,
5272 Definition = 0x20000000,
5273 NamedStyleDefinition = 0x20000001,
5274 TextureDefinition = 0x20000002,
5275 LinePatternDefinition = 0x20000003,
5276 GlyphDefinition = 0x20000004,
5277 CubeMapDefinition = 0x20000005,
5278 ImageDefinition = 0x20000006,
5279 MaterialPaletteDefinition = 0x20000007,
5280 ShaderDefinition = 0x20000008,
5282 Control = 0x50000000,
5283 CameraControl = 0x50000001,
5284 SelectabilityControl = 0x50000002,
5285 MarkerAttributeControl = 0x50000003,
5286 SphereAttributeControl = 0x50000004,
5287 LightingAttributeControl = 0x50000005,
5288 CylinderAttributeControl = 0x50000006,
5289 TextAttributeControl = 0x50000007,
5290 LineAttributeControl = 0x50000008,
5291 EdgeAttributeControl = 0x50000009,
5292 CurveAttributeControl = 0x5000000a,
5293 ModellingMatrixControl = 0x5000000b,
5294 TextureMatrixControl = 0x5000000c,
5295 CullingControl = 0x5000000d,
5296 TransparencyControl = 0x5000000e,
5297 MaterialMappingControl = 0x5000000f,
5298 NURBSSurfaceAttributeControl = 0x50000010,
5299 PostProcessEffectsControl = 0x50000011,
5300 BoundingControl = 0x50000012,
5301 VisualEffectsControl = 0x50000013,
5302 SelectionOptionsControl = 0x50000014,
5303 HighlightOptionsControl = 0x50000015,
5304 DefinitionControl = 0x50000016,
5305 SelectionControl = 0x50000017,
5306 HighlightControl = 0x50000018,
5307 StandAloneWindowOptionsControl = 0x50000019,
5308 OffScreenWindowOptionsControl = 0x5000001a,
5309 ApplicationWindowOptionsControl = 0x5000001b,
5310 VisibilityControl = 0x5000001c,
5311 SubwindowControl = 0x5000001d,
5312 PerformanceControl = 0x5000001e,
5313 HiddenLineAttributeControl = 0x5000001f,
5314 DrawingAttributeControl = 0x50000020,
5315 DebuggingControl = 0x50000021,
5316 ContourLineControl = 0x50000022,
5317 StyleControl = 0x50000023,
5318 ConditionControl = 0x50000024,
5319 PortfolioControl = 0x50000025,
5320 WindowInfoControl = 0x50000026,
5321 AttributeLockControl = 0x50000027,
5322 TransformMaskControl = 0x50000028,
5323 ColorInterpolationControl = 0x50000029,
5324 UpdateOptionsControl = 0x50000030,
5325 CuttingSectionAttributeControl = 0x50000031,
5327 LibraryMask = 0x80FF0000,
5329 Sprocket = 0x80000000,
5330 Canvas = 0x80000001,
5331 Layout = 0x80000002,
5334 Operator = 0x80000005,
5335 SprocketPath = 0x80000007,
5337 SprocketControl = 0xD0000000,
5338 OperatorControl = 0xD0000008,
5339 NavigationCubeControl = 0xD0000009,
5340 AxisTriadControl = 0xD000000A,
5342 Metadata = 0x80001000,
5343 IntegerMetadata = 0x80001001,
5344 UnsignedIntegerMetadata = 0x80001002,
5345 DoubleMetadata = 0x80001003,
5346 StringMetadata = 0x80001004,
5347 TimeMetadata = 0x80001005,
5348 BooleanMetadata = 0x80001006,
5350 Component = 0x80000200,
5351 Filter = 0x80000600,
5352 Capture = 0x80000a00,
5353 CADModel = 0x80000300,
5354 ComponentPath = 0x81001000,
5356 ExchangeMask = 0x80020000,
5357 ExchangeComponent = 0x80021200,
5358 ExchangeFilter = 0x80020601,
5359 ExchangeCapture = 0x80020a01,
5360 ExchangeCADModel = 0x80020301,
5361 ExchangeConfiguration = 0x81020001,
5362 ExchangeImportOptionsKit = 0x81020002,
5363 ExchangeExportACISOptionsKit = 0x81020003,
5364 ExchangeExportIGESOptionsKit = 0x81020004,
5365 ExchangeExportJTOptionsKit = 0x81020005,
5366 ExchangeExportParasolidOptionsKit = 0x81020006,
5367 ExchangeExportPRCOptionsKit = 0x81020007,
5368 ExchangeExportSTEPOptionsKit = 0x81020008,
5369 ExchangeExportSTLOptionsKit = 0x81020009,
5370 ExchangeExportU3DOptionsKit = 0x8102000a,
5371 ExchangeExportXMLOptionsKit = 0x8102000b,
5372 ExchangeTessellationOptionsKit = 0x8102000c,
5373 ExchangeSheet = 0x80021201,
5374 ExchangeModelFileImportOptionsKit = 0x8102000d,
5376 PublishMask = 0x80040000,
5377 PublishDocumentKit = 0x81040001,
5378 PublishPageKit = 0x81040002,
5379 PublishTemplateKit = 0x81040003,
5380 PublishAnnotationKit = 0x81040004,
5381 PublishArtworkKit = 0x81040005,
5382 PublishViewKit = 0x81040006,
5383 PublishTextKit = 0x81040007,
5384 PublishImageKit = 0x81040008,
5385 PublishTableKit = 0x81040009,
5386 PublishExportOptionsKit = 0x8104000a,
5387 PublishLinkKit = 0x8104000b,
5388 PublishButtonKit = 0x8104000c,
5389 PublishTextFieldKit = 0x8104000d,
5390 PublishSlideTableKit = 0x8104000e,
5391 PublishCheckBoxKit = 0x8104000f,
5392 PublishRadioButtonKit = 0x81040010,
5393 PublishListBoxKit = 0x81040011,
5394 PublishDropDownListKit = 0x81040012,
5395 PublishSignatureFieldKit = 0x81040013,
5397 PublishDocumentKey = 0x80040001,
5398 PublishPageControl = 0x80040002,
5400 SceneTree = 0x80008001,
5401 SceneTreeItem = 0x80008002,
5403 ComponentTree = 0x80008003,
5404 ComponentTreeItem = 0x80008004,
5406 SketchupMask = 0x80100000,
5407 SketchupImportOptionsKit = 0x81100001,
5408 SketchupImportResultsKit = 0x81100002,
5410 ParasolidMask = 0x80200000,
5411 ParasolidComponent = 0x80201201,
5412 ParasolidCADModel = 0x80200302,
5413 ParasolidImportOptionsKit = 0x81200003,
5414 ParasolidFacetTessellationKit = 0x81200004,
5415 ParasolidLineTessellationKit = 0x81200005,
5416 ParasolidExportOptionsKit = 0x81200006,
5418 IONotifierData = 0x84000200,
5419 StreamImportNotifierData = 0x84000201,
5420 STLImportNotifierData = 0x84000202,
5421 OBJImportNotifierData = 0x84000203,
5422 ExchangeImportNotifierData = 0x84020204,
5423 SketchupImportNotifierData = 0x84100205,
5424 ParasolidImportNotifierData = 0x84200206,
5425 ExchangeTranslationNotifierData = 0x84020207,
5426 ExchangeExportNotifierData = 0x84020208,
5427 StreamExportNotifierData = 0x84000209,
5439 static void * Allocate(
size_t in_bytes,
bool in_clear_memory =
true);
5446 static void Free(
void * in_pointer);
5455 template <
typename T>
5456 class NO_HPS_API Allocator
5459 typedef T value_type;
5460 typedef value_type * pointer;
5461 typedef value_type
const * const_pointer;
5462 typedef value_type & reference;
5463 typedef value_type
const & const_reference;
5464 typedef size_t size_type;
5465 typedef ptrdiff_t difference_type;
5469 Allocator(Allocator<T>
const & in_that) { HPS_UNREFERENCED(in_that); }
5472 template <
typename U> Allocator(Allocator<U>
const &) {}
5474 template <
typename U>
5477 typedef Allocator<U> other;
5481 pointer address(reference x)
const {
return &x; }
5482 const_pointer address(const_reference x)
const {
return &x; }
5484 pointer allocate(size_type n,
void * v = 0) { HPS_UNREFERENCED(v);
return static_cast<pointer
>(
Memory::Allocate(n *
sizeof(T))); }
5485 void deallocate(pointer p, size_type n) { HPS_UNREFERENCED(n);
Memory::Free(p); }
5487 #if defined(_MSC_VER) || defined (__APPLE__)
5488 void construct(pointer p, const_reference x) {
new(p) T(x); }
5490 template<
typename U,
typename... Args>
5491 void construct(U * p, Args&&... args) {
new(p) U(std::forward<Args>(args)...); }
5493 void destroy(pointer p) { HPS_UNREFERENCED(p); p->~T(); }
5495 size_type max_size()
const {
return static_cast<size_type
>(-1) /
sizeof(T); }
5498 template <
typename T,
typename U>
5499 bool operator==(
const Allocator<T> &,
const Allocator<U> &) {
return true; }
5501 template <
typename T,
typename U>
5502 bool operator!=(
const Allocator<T> &,
const Allocator<U> &) {
return false; }
5508 Exception(
char const * in_info) : std::runtime_error(in_info) { }
5516 InvalidObjectException(
char const * in_info =
"Attempted to use a deleted, uninitialized, or otherwise invalid object.") :
5526 IndexOutOfRangeException(
char const * in_info =
"Attempted to access an element outside the bounds of the array.") :
5596 HPS::Type Type()
const;
5605 virtual bool Empty()
const {
return (impl_ == 0);};
5608 virtual void Reset();
5613 bool HasType(HPS::Type in_mask)
const;
5617 intptr_t GetClassID()
const;
5622 intptr_t GetInstanceID()
const;
5624 template <
typename T>
5625 static intptr_t ClassID()
5627 static const intptr_t ret = T().GetClassID();
5632 friend class HPSI::Impl;
5633 friend class HPSI::KeyImpl;
5634 friend class HPSI::TicketImpl;
5643 HPS::Type ObjectType()
const {
return HPS::Type::Control;}
5660 this->Object::operator=(std::move(in_that));
6128 Event(intptr_t in_channel = 0): channel(in_channel), consumable(true), time_stamp(0) {}
6133 intptr_t GetClassID()
const;
6137 virtual Event * Clone()
const=0;
6140 virtual bool Drop(
Event const * in_that_event)
const { HPS_UNREFERENCED(in_that_event);
return false; }
6155 static void *
operator new (
size_t in_size) {
return Memory::Allocate(in_size); }
6156 static void operator delete (
void * in_ptr,
size_t in_size)
throw () { HPS_UNREFERENCED(in_size);
Memory::Free(in_ptr); }
6163 friend class HPSI::EventDispatcherImpl;
6213 enum class KeyboardCode
6413 : ID(in_id), Location(in_location), TapCount(in_tap_count) {}
6420 return (ID == in_that.
ID && Location == in_that.
Location && TapCount == in_that.
TapCount);
6428 return !(*
this == in_that);
6437 typedef std::vector<Point, Allocator<Point> > PointArray;
6438 typedef std::vector<ObjectPoint, Allocator<ObjectPoint> > ObjectPointArray;
6439 typedef std::vector<WorldPoint, Allocator<WorldPoint> > WorldPointArray;
6440 typedef std::vector<CameraPoint, Allocator<CameraPoint> > CameraPointArray;
6441 typedef std::vector<NormalizedPoint, Allocator<NormalizedPoint> > NormalizedPointArray;
6442 typedef std::vector<ScreenRangePoint, Allocator<ScreenRangePoint> > ScreenRangePointArray;
6443 typedef std::vector<InnerWindowPoint, Allocator<InnerWindowPoint> > InnerWindowPointArray;
6444 typedef std::vector<InnerPixelPoint, Allocator<InnerPixelPoint> > InnerPixelPointArray;
6445 typedef std::vector<WindowPoint, Allocator<WindowPoint> > WindowPointArray;
6446 typedef std::vector<PixelPoint, Allocator<PixelPoint> > PixelPointArray;
6447 typedef std::vector<Vector, Allocator<Vector> > VectorArray;
6448 typedef std::vector<DVector, Allocator<DVector> > DVectorArray;
6449 typedef std::vector<Plane, Allocator<Plane> > PlaneArray;
6450 typedef std::vector<int, Allocator<int> > IntArray;
6451 typedef std::vector<RGBColor, Allocator<RGBColor> > RGBColorArray;
6452 typedef std::vector<RGBAColor, Allocator<RGBAColor> > RGBAColorArray;
6453 typedef std::vector<unsigned int, Allocator<unsigned int> > UnsignedIntArray;
6454 typedef std::vector<size_t, Allocator<size_t> > SizeTArray;
6455 typedef std::vector<float, Allocator<float> > FloatArray;
6456 typedef std::vector<SegmentKey, Allocator<SegmentKey> > SegmentKeyArray;
6457 typedef std::vector<WindowKey, Allocator<WindowKey> > WindowKeyArray;
6458 typedef std::vector<EventHandler, Allocator<EventHandler> > EventHandlerArray;
6459 typedef std::vector<GlyphElement, Allocator<GlyphElement> > GlyphElementArray;
6460 typedef std::vector<GlyphPoint, Allocator<GlyphPoint> > GlyphPointArray;
6461 typedef std::vector<UTF8, Allocator<UTF8> > UTF8Array;
6462 typedef std::vector<UTF8Array, Allocator<UTF8Array> > UTF8ArrayArray;
6463 typedef std::vector<bool, Allocator<bool> > BoolArray;
6464 typedef std::vector<TrimKit, Allocator<TrimKit> > TrimKitArray;
6465 typedef std::vector<Key, Allocator<Key> > KeyArray;
6466 typedef std::vector<PortfolioKey, Allocator<PortfolioKey> > PortfolioKeyArray;
6467 typedef std::vector<char, Allocator<char> > CharArray;
6468 typedef std::vector<wchar_t, Allocator<wchar_t> > WCharArray;
6469 typedef std::vector<byte, Allocator<byte> > ByteArray;
6470 typedef std::vector<ByteArray, Allocator<ByteArray> > ByteArrayArray;
6471 typedef std::vector<sbyte, Allocator<sbyte> > SByteArray;
6472 typedef std::vector<MaterialKit, Allocator<MaterialKit> > MaterialKitArray;
6473 typedef std::vector<LinePatternElement, Allocator<LinePatternElement> > LinePatternElementArray;
6474 typedef std::vector<LinePatternParallelKit, Allocator<LinePatternParallelKit> > LinePatternParallelKitArray;
6475 typedef std::vector<Material::Type, Allocator<Material::Type> > MaterialTypeArray;
6476 typedef std::vector<Search::Type, Allocator<Search::Type> > SearchTypeArray;
6477 typedef std::vector<Line::SizeUnits, Allocator<Line::SizeUnits> > LineSizeUnitsArray;
6478 typedef std::vector<CameraKit, Allocator<CameraKit> > CameraKitArray;
6479 typedef std::vector<Condition, Allocator<Condition> > ConditionArray;
6480 typedef std::vector<TextureDefinition, Allocator<TextureDefinition> > TextureDefinitionArray;
6481 typedef std::vector<CubeMapDefinition, Allocator<CubeMapDefinition> > CubeMapDefinitionArray;
6482 typedef std::vector<ImageDefinition, Allocator<ImageDefinition> > ImageDefinitionArray;
6483 typedef std::vector<NamedStyleDefinition, Allocator<NamedStyleDefinition> > NamedStyleDefinitionArray;
6484 typedef std::vector<MaterialPaletteDefinition, Allocator<MaterialPaletteDefinition> > MaterialPaletteDefinitionArray;
6485 typedef std::vector<GlyphDefinition, Allocator<GlyphDefinition> > GlyphDefinitionArray;
6486 typedef std::vector<LinePatternDefinition, Allocator<LinePatternDefinition> > LinePatternDefinitionArray;
6487 typedef std::vector<ShaderDefinition, Allocator<ShaderDefinition> > ShaderDefinitionArray;
6488 typedef std::vector<IntRectangle, Allocator<IntRectangle> > IntRectangleArray;
6489 typedef std::vector<AttributeLock::Type, Allocator<AttributeLock::Type> > AttributeLockTypeArray;
6490 typedef std::vector<Style::Type, Allocator<Style::Type> > StyleTypeArray;
6491 typedef std::vector<TrimElement, Allocator<TrimElement> > TrimElementArray;
6492 typedef std::vector<KeyPath, Allocator<KeyPath> > KeyPathArray;
6493 typedef std::vector<IncludeKey, Allocator<IncludeKey> > IncludeKeyArray;
6494 typedef std::vector<KeyboardCode, Allocator<KeyboardCode> > KeyboardCodeArray;
6495 typedef std::vector<Touch, Allocator<Touch> > TouchArray;
6496 typedef std::vector<ReferenceKey, Allocator<ReferenceKey> > ReferenceKeyArray;
6497 typedef std::vector<intptr_t, Allocator<intptr_t> > IntPtrTArray;
6498 typedef std::vector<GeometryKey, Allocator<GeometryKey> > GeometryKeyArray;
6499 typedef std::vector<Shell::Relation, Allocator<Shell::Relation> > ShellRelationArray;
6500 typedef std::vector<StyleKey, Allocator<StyleKey> > StyleKeyArray;
6501 typedef std::vector<PointArray, Allocator<PointArray> > PointArrayArray;
6529 HPS::Type
ObjectType()
const {
return HPS::Type::SearchResultsIterator;}
6565 bool IsValid()
const;
6573 Key GetItem()
const;
6577 Key operator*()
const;
6581 SearchTypeArray GetResultTypes()
const;
6606 virtual void Reset();
6625 size_t GetCount()
const;
6664 HPS::Type
ObjectType()
const {
return HPS::Type::FontSearchResultsIterator;}
6695 bool IsValid()
const;
6734 virtual void Reset();
6739 HPS::Type
ObjectType()
const {
return HPS::Type::FontSearchResults;}
6754 size_t GetCount()
const;
6778 UTF8(
char const * in_string,
char const * in_locale = 0);
6782 UTF8(
wchar_t const * in_string);
6801 return Assign(std::move(in_utf8));
6808 size_t ToWStr(
wchar_t * out_wide_string)
const;
6813 size_t ToWStr(WCharArray & out_wide_string)
const;
6819 return (_length > 0);
6826 return (_length == 0);
6860 inline operator char const * ()
const
6867 char At(
size_t in_index)
const
6871 else if(in_index >= _length)
6874 return _text[in_index];
6880 UTF8 & Assign(
UTF8 const & in_utf8);
6887 return Assign(in_utf8);
6893 UTF8 & operator+= (
UTF8 const & in_utf8);
6898 UTF8 & operator+= (
char const * in_utf8);
6903 UTF8 operator+ (
UTF8 const & in_utf8)
const;
6908 UTF8 operator+ (
char const * in_utf8)
const;
6913 bool operator== (
UTF8 const & in_utf8)
const;
6918 bool operator!= (
UTF8 const & in_utf8)
const
6920 return !(*
this == in_utf8);
6926 bool operator== (
char const * in_utf8)
const;
6931 bool operator!= (
char const * in_utf8)
const
6933 return !(*
this == in_utf8);
6942 return in_right == in_left;
6951 return in_right != in_left;
6960 return in_right ==
UTF8(in_left);
6969 return in_right !=
UTF8(in_left);
6976 friend inline UTF8 operator+ (
char const * in_left,
UTF8 const & in_right)
6978 return UTF8(in_left) + in_right;
6985 friend inline UTF8 operator+ (
wchar_t const * in_left,
UTF8 const & in_right)
6987 return UTF8(in_left) + in_right;
6993 size_t GetHash()
const;
6997 size_t internal_encode(
wchar_t const * in_wide_string);
6998 size_t internal_decode(
wchar_t * out_wide_string)
const;
7002 mutable size_t _hash_key;
7003 static const size_t _buffer_size = 64 -
sizeof(
const char *) - 2 *
sizeof(
size_t);
7004 char _buffer[_buffer_size];
7009 inline size_t operator()(
const HPS::UTF8 & in_utf8)
const
7021 enum class Intrinsic
7040 Condition(HPS::Condition::Intrinsic in_special);
7061 bool ShowCondition(
UTF8 & out_condition)
const;
7066 bool ShowNumber(
float & out_number)
const;
7071 bool ShowIntrinsic(Condition::Intrinsic & out_special)
const;
7076 bool ShowOperands(ConditionArray & out_operands)
const;
7086 bool Equals(
Condition const & in_that)
const;
7091 bool operator==(
Condition const & in_that)
const;
7096 bool operator!=(
Condition const & in_that)
const;
7101 bool IsSatisfiedBy(UTF8Array
const & in_conditions)
const;
7106 bool IsSatisfiedBy(
char const * in_condition)
const;
7250 HPS_API Condition NOT(Condition
const & in_operand);
7256 HPS_API Condition OR(Condition
const & in_operand1, Condition
const & in_operand2);
7262 HPS_API Condition XOR(Condition
const & in_operand1, Condition
const & in_operand2);
7268 HPS_API Condition AND(Condition
const & in_operand1, Condition
const & in_operand2);
7274 HPS_API Condition EQ(Condition
const & in_operand1, Condition
const & in_operand2);
7280 HPS_API Condition NEQ(Condition
const & in_operand1, Condition
const & in_operand2);
7286 HPS_API Condition GT(Condition
const & in_operand1, Condition
const & in_operand2);
7292 HPS_API Condition LT(Condition
const & in_operand1, Condition
const & in_operand2);
7298 HPS_API Condition GTEQ(Condition
const & in_operand1, Condition
const & in_operand2);
7304 HPS_API Condition LTEQ(Condition
const & in_operand1, Condition
const & in_operand2);
7319 Key(
Key const & in_that);
7332 Key & operator=(
Key && in_that);
7340 bool HasOwner()
const;
7352 void MoveTo(
SegmentKey const & in_new_owner);
7359 Key & operator=(
Key const & in_that);
7362 virtual void Assign(
Key const & in_that);
7365 bool Equals(
Key const & in_that)
const;
7368 bool operator!= (
Key const & in_that)
const;
7371 bool operator== (
Key const & in_that)
const;
7375 size_t GetHash()
const;
7380 inline size_t operator()(
const HPS::Key & in_key)
const
7428 SegmentKey Down(
char const * in_segment_name,
bool in_create_if_not_present =
false)
const;
7432 SegmentKey Subsegment(
char const * in_segment_name =
"",
bool in_create_if_not_present =
true)
const;
7490 size_t ShowSubsegments()
const;
7493 size_t ShowSubsegments(SegmentKeyArray & out_children)
const;
7498 size_t ShowReferrers(SegmentKeyArray & out_segments)
const;
7503 size_t ShowReferrers(ReferenceKeyArray & out_references)
const;
7508 size_t ShowStylers(SegmentKeyArray & out_segments)
const;
7513 size_t ShowStylers(StyleKeyArray & out_styles)
const;
7518 size_t ShowIncluders(SegmentKeyArray & out_segments)
const;
7523 size_t ShowIncluders(IncludeKeyArray & out_includes)
const;
7542 SegmentKey & SetCondition(
char const * in_condition);
7545 SegmentKey & SetConditions(UTF8Array
const & in_conditions);
7548 SegmentKey & SetConditions(
size_t in_count,
UTF8 const in_conditions []);
7554 bool ShowConditions(UTF8Array & out_conditions)
const;
7564 SegmentKey & SetMaterialPalette(
char const * in_name);
7570 bool ShowMaterialPalette(
UTF8 & out_name)
const;
7588 bool ShowPriority(
int & out_priority)
const;
7594 SegmentKey & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
7601 SegmentKey & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
7607 SegmentKey & SetUserData(intptr_t in_index, ByteArray
const & in_data);
7612 SegmentKey & UnsetUserData(intptr_t in_index);
7618 SegmentKey & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
7623 SegmentKey & UnsetUserData(HPS::IntPtrTArray
const & in_indices);
7630 size_t ShowUserDataCount()
const;
7636 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
7641 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
7647 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
7654 LineKey InsertLine(
size_t in_count,
Point const in_pts[]);
7657 LineKey InsertLine(PointArray
const & in_pts);
7733 PolygonKey InsertPolygon(PointArray
const & in_pts);
7743 ShellKey InsertShell(PointArray
const & in_points, IntArray
const & in_facelist);
7746 ShellKey InsertShell(
size_t in_point_count,
Point const in_points [],
size_t in_facelist_count,
int const in_facelist []);
7749 ShellKey InsertShellByTristrips(PointArray
const & in_points, IntArray
const & in_tristrips);
7752 ShellKey InsertShellByTristrips(
size_t in_point_count,
Point const in_points [],
size_t in_tristrips_count,
int const in_tristrips []);
7758 MeshKey InsertMesh(
size_t in_rows,
size_t in_columns, PointArray
const & in_points);
7761 MeshKey InsertMesh(
size_t in_rows,
size_t in_columns,
size_t in_point_count,
Point const in_points []);
7809 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);
7812 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);
7819 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);
7822 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[]);
7825 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);
7828 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[]);
7839 TextKey InsertText(
Point const & in_position,
char const * in_text);
7858 LineKey InsertLineFromGeometry(
CircleKey const & in_circle,
float in_deviation = -1.0f);
7885 LineKey InsertLineFromGeometry(
EllipseKey const & in_ellipse,
float in_deviation = -1.0f);
7903 LineKey InsertLineFromGeometry(
NURBSCurveKey const & in_nurbs_curve,
float in_deviation = -1.0f);
7985 bool ShowCamera(
CameraKit & out_kit)
const;
8034 bool ShowCulling(
CullingKit & out_kit)
const;
8063 SegmentKey & UnsetCuttingSectionAttributes();
8210 bool ShowModellingMatrix(
MatrixKit & out_kit)
const;
8330 bool ShowTextureMatrix(
MatrixKit & out_kit)
const;
8431 HPS::Type
ObjectType()
const {
return HPS::Type::SegmentOptimizationOptionsKit; }
8542 bool ShowUserData(HPS::SegmentOptimizationOptions::UserData & out_user_data)
const;
8544 bool ShowMatrix(HPS::SegmentOptimizationOptions::Matrix & out_matrix)
const;
8546 bool ShowExpansion(HPS::SegmentOptimizationOptions::Expansion & out_expansion)
const;
8548 bool ShowScope(HPS::SegmentOptimizationOptions::Scope & out_scope)
const;
8550 bool ShowReorganization(HPS::SegmentOptimizationOptions::Reorganization & out_reorganization)
const;
8552 bool ShowShellInstancing(
bool & out_shell_instancing)
const;
8554 bool ShowShellMerging(
bool & out_shell_merging)
const;
8556 bool ShowAttributeDelocalization(
bool & out_attribute_delocalization)
const;
8610 HPS::Type
ObjectType()
const {
return HPS::Type::UpdateNotifier;};
8633 intptr_t GetClassID()
const;
8668 void DrawTexturedBackground(OpaqueHandle in_texture,
MatrixKit const & in_matrix,
Rectangle const & in_extent)
const;
8672 mutable HPS::FloatArray matrix_elements;
8680 HPS::Type
ObjectType() const OVERRIDE {
return HPS::Type::DriverEventHandler; };
8693 HPS_UNREFERENCED(in_event);
8764 WindowKey & UnsetDriverEventHandler(intptr_t in_type);
8871 bool ShowSnapshot(
ImageKit & out_kit)
const;
8882 SegmentKey & UnsetCuttingSectionAttributes();
8905 void MoveTo(
SegmentKey const & in_new_owner);
8924 KeyPath(KeyArray
const & in_path);
8929 KeyPath(
size_t in_path_count,
Key const in_path []);
8962 KeyPath & operator+=(KeyArray
const & in_key_array);
8977 KeyPath & Append(KeyArray
const & in_key_array);
8987 KeyPath & operator=(KeyArray
const & in_path);
8991 void Set(
KeyPath const & in_that);
8996 bool Equals(
KeyPath const & in_that)
const;
9001 bool operator!= (
KeyPath const & in_that)
const;
9006 bool operator== (
KeyPath const & in_that)
const;
9012 KeyPath & SetKeys(KeyArray
const & in_keys);
9018 KeyPath & SetKeys(
size_t in_key_count,
Key const in_keys []);
9028 bool ShowKeys(KeyArray & out_keys)
const;
9052 bool ComputeTextExtent(
const char* in_text,
float & out_xfrac,
float & out_yfrac)
const;
9069 bool ShowNetBounding(
BoundingKit & out_kit)
const;
9073 bool ShowNetCamera(
CameraKit & out_kit)
const;
9137 bool ShowNetModellingMatrix(
MatrixKit & out_kit)
const;
9141 bool ShowNetTextureMatrix(
MatrixKit & out_kit)
const;
9145 bool ShowNetCulling(
CullingKit & out_kit)
const;
9177 bool ShowNetConditions(UTF8Array & out_conditions)
const;
9193 inline KeyPath operator+(Key
const & in_lhs, Key
const & in_rhs)
9202 inline KeyPath operator+(Key
const & in_lhs, KeyArray
const & in_rhs)
9211 inline KeyPath operator+(Key
const & in_lhs, KeyPath
const & in_rhs)
9220 inline KeyPath operator+(KeyArray
const & in_lhs, Key
const & in_rhs)
9229 inline KeyPath operator+(KeyArray
const & in_lhs, KeyArray
const & in_rhs)
9238 inline KeyPath operator+(KeyArray
const & in_lhs, KeyPath
const & in_rhs)
9247 inline KeyPath operator+(KeyPath
const & in_lhs, Key
const & in_rhs)
9256 inline KeyPath operator+(KeyPath
const & in_lhs, KeyArray
const & in_rhs)
9265 inline KeyPath operator+(KeyPath
const & in_lhs, KeyPath
const & in_rhs)
9332 bool operator==(
BoundingKit const & in_kit)
const;
9337 bool operator!=(
BoundingKit const & in_kit)
const;
9378 bool ShowExclusion(
bool & out_exclusion)
const;
9408 HPS::Type
ObjectType()
const {
return HPS::Type::BoundingControl;};
9457 bool ShowExclusion(
bool & out_exclusion)
const;
9792 bool ShowCuttingSections(
bool & out_state)
const;
9797 bool ShowCutEdges(
bool & out_state)
const;
9802 bool ShowCutFaces(
bool & out_state)
const;
9807 bool ShowWindows(
bool & out_state)
const;
9812 bool ShowText(
bool & out_state)
const;
9817 bool ShowLines(
bool & out_state)
const;
9822 bool ShowEdgeLights(
bool & out_state)
const;
9827 bool ShowMarkerLights(
bool & out_state)
const;
9832 bool ShowFaceLights(
bool & out_state)
const;
9837 bool ShowGenericEdges(
bool & out_state)
const;
9842 bool ShowInteriorSilhouetteEdges(
bool & out_state)
const;
9847 bool ShowAdjacentEdges(
bool & out_state)
const;
9852 bool ShowHardEdges(
bool & out_state)
const;
9857 bool ShowMeshQuadEdges(
bool & out_state)
const;
9862 bool ShowNonCulledEdges(
bool & out_state)
const;
9867 bool ShowPerimeterEdges(
bool & out_state)
const;
9872 bool ShowFaces(
bool & out_state)
const;
9877 bool ShowVertices(
bool & out_state)
const;
9882 bool ShowMarkers(
bool & out_state)
const;
9887 bool ShowShadowCasting(
bool & out_state)
const;
9892 bool ShowShadowReceiving(
bool & out_state)
const;
9897 bool ShowShadowEmitting(
bool & out_state)
const;
9929 HPS::Type
ObjectType()
const {
return HPS::Type::VisibilityControl;};
10194 bool ShowCuttingSections(
bool & out_state)
const;
10199 bool ShowCutEdges(
bool & out_state)
const;
10204 bool ShowCutFaces(
bool & out_state)
const;
10209 bool ShowWindows(
bool & out_state)
const;
10214 bool ShowText(
bool & out_state)
const;
10219 bool ShowLines(
bool & out_state)
const;
10224 bool ShowEdgeLights(
bool & out_state)
const;
10229 bool ShowMarkerLights(
bool & out_state)
const;
10234 bool ShowFaceLights(
bool & out_state)
const;
10239 bool ShowGenericEdges(
bool & out_state)
const;
10244 bool ShowInteriorSilhouetteEdges(
bool & out_state)
const;
10249 bool ShowAdjacentEdges(
bool & out_state)
const;
10254 bool ShowHardEdges(
bool & out_state)
const;
10259 bool ShowMeshQuadEdges(
bool & out_state)
const;
10264 bool ShowNonCulledEdges(
bool & out_state)
const;
10269 bool ShowPerimeterEdges(
bool & out_state)
const;
10274 bool ShowFaces(
bool & out_state)
const;
10279 bool ShowVertices(
bool & out_state)
const;
10284 bool ShowMarkers(
bool & out_state)
const;
10289 bool ShowShadowCasting(
bool & out_state)
const;
10294 bool ShowShadowReceiving(
bool & out_state)
const;
10299 bool ShowShadowEmitting(
bool & out_state)
const;
10356 bool Empty()
const;
10361 bool Equals(
CameraKit const & in_kit)
const;
10366 bool operator==(
CameraKit const & in_kit)
const;
10371 bool operator!=(
CameraKit const & in_kit)
const;
10401 CameraKit & SetField(
float in_width,
float in_height);
10412 CameraKit & SetNearLimit(
float const in_limit);
10446 bool ShowUpVector(
Vector & out_up_vector)
const;
10451 bool ShowPosition(
Point & out_position)
const;
10456 bool ShowTarget(
Point & out_target)
const;
10468 bool ShowProjection(
Camera::Projection & out_type,
float & out_oblique_y_skew,
float & out_oblique_x_skew)
const;
10473 bool ShowWidth(
float & out_width)
const;
10478 bool ShowHeight(
float & out_height)
const;
10484 bool ShowField(
float & out_width,
float & out_height)
const;
10489 bool ShowNearLimit(
float & out_near_limit)
const;
10497 CameraKit & Dolly(
float in_x_dir,
float in_up,
float in_forward);
10505 CameraKit & Orbit(
float in_theta,
float in_phi);
10513 CameraKit & Pan(
float in_theta,
float in_phi);
10615 bool ShowUpVector(
Vector & out_up_vector)
const;
10620 bool ShowPosition(
Point & out_position)
const;
10625 bool ShowTarget(
Point & out_target)
const;
10637 bool ShowProjection(
Camera::Projection & out_type,
float & out_oblique_x_skew,
float & out_oblique_y_skew)
const;
10642 bool ShowWidth(
float & out_width)
const;
10647 bool ShowHeight(
float & out_height)
const;
10653 bool ShowField(
float & out_width,
float & out_height)
const;
10658 bool ShowNearLimit(
float & out_width)
const;
10666 CameraControl & Dolly(
float in_x_dir,
float in_up,
float in_forward);
10752 bool Empty()
const;
10931 HPS::Type
ObjectType()
const {
return HPS::Type::SelectabilityControl;};
11122 bool Empty()
const;
11208 bool ShowDepthPeelingLayers(
unsigned int & out_layers)
const;
11219 bool ShowDepthWriting(
bool & out_state)
const;
11250 HPS::Type
ObjectType()
const {
return HPS::Type::TransparencyControl;};
11323 bool ShowDepthPeelingLayers(
unsigned int & out_layers)
const;
11334 bool ShowDepthWriting(
bool & out_state)
const;
11365 HPS::Type
ObjectType()
const {
return HPS::Type::ColorInterpolationKit;};
11379 bool Empty()
const;
11454 bool ShowFaceColor(
bool & out_state)
const;
11459 bool ShowEdgeColor(
bool & out_state)
const;
11464 bool ShowVertexColor(
bool & out_state)
const;
11469 bool ShowFaceIndex(
bool & out_state)
const;
11474 bool ShowEdgeIndex(
bool & out_state)
const;
11479 bool ShowVertexIndex(
bool & out_state)
const;
11509 HPS::Type
ObjectType()
const {
return HPS::Type::ColorInterpolationControl;};
11575 bool ShowFaceColor(
bool & out_state)
const;
11580 bool ShowEdgeColor(
bool & out_state)
const;
11585 bool ShowVertexColor(
bool & out_state)
const;
11590 bool ShowFaceIndex(
bool & out_state)
const;
11595 bool ShowEdgeIndex(
bool & out_state)
const;
11600 bool ShowVertexIndex(
bool & out_state)
const;
11655 bool Empty()
const;
11660 bool Equals(
CullingKit const & in_kit)
const;
11665 bool operator==(
CullingKit const & in_kit)
const;
11670 bool operator!=(
CullingKit const & in_kit)
const;
11676 CullingKit & SetDeferralExtent(
bool in_state,
unsigned int in_pixels);
11682 CullingKit & SetDeferralExtent(
unsigned int in_pixels);
11688 CullingKit & SetExtent(
bool in_state,
unsigned int in_pixels);
11694 CullingKit & SetExtent(
unsigned int in_pixels);
11735 CullingKit & SetVectorTolerance(
float in_tolerance_degrees);
11774 bool ShowDeferralExtent(
bool & out_state,
unsigned int & out_pixels)
const;
11780 bool ShowExtent(
bool & out_state,
unsigned int & out_pixels)
const;
11785 bool ShowBackFace(
bool & out_state)
const;
11792 bool ShowVector(
bool & out_state,
HPS::Vector & out_vector)
const;
11797 bool ShowVectorTolerance(
float & out_tolerance_degrees)
const;
11802 bool ShowFrustum(
bool & out_state)
const;
11842 CullingControl & SetDeferralExtent(
bool in_state,
unsigned int in_pixels);
11856 CullingControl & SetExtent(
bool in_state,
unsigned int in_pixels);
11904 CullingControl & SetVectorTolerance(
float in_tolerance_degrees);
11943 bool ShowDeferralExtent(
bool & out_state,
unsigned int & out_pixels)
const;
11949 bool ShowExtent(
bool & out_state,
unsigned int & out_pixels)
const;
11954 bool ShowBackFace(
bool & out_state)
const;
11961 bool ShowVector(
bool & out_state,
HPS::Vector & out_vector)
const;
11966 bool ShowVectorTolerance(
float & out_tolerance_degrees)
const;
11971 bool ShowFrustum(
bool & out_state)
const;
12006 HPS::Type
ObjectType()
const {
return HPS::Type::MarkerAttributeKit;};
12028 bool Empty()
const;
12074 bool ShowSymbol(
UTF8 & out_glyph_name)
const;
12111 HPS::Type
ObjectType()
const {
return HPS::Type::MarkerAttributeControl;};
12144 bool ShowSymbol(
UTF8 & out_glyph_name)
const;
12183 HPS::Type
ObjectType()
const {
return HPS::Type::SphereAttributeKit;};
12205 bool Empty()
const;
12241 bool ShowTessellation(
size_t & out_facets)
const;
12270 HPS::Type
ObjectType()
const {
return HPS::Type::SphereAttributeControl;};
12295 bool ShowTessellation(
size_t & out_facets)
const;
12328 HPS::Type
ObjectType()
const {
return HPS::Type::LightingAttributeKit;};
12350 bool Empty()
const;
12419 HPS::Type
ObjectType()
const {
return HPS::Type::LightingAttributeControl;};
12477 HPS::Type
ObjectType()
const {
return HPS::Type::CylinderAttributeKit;};
12499 bool Empty()
const;
12545 bool ShowTessellation(
size_t & out_facets)
const;
12581 HPS::Type
ObjectType()
const {
return HPS::Type::CylinderAttributeControl;};
12615 bool ShowTessellation(
size_t & out_facets)
const;
12654 HPS::Type
ObjectType()
const {
return HPS::Type::CuttingSectionAttributeKit;};
12676 bool Empty()
const;
12771 HPS::Type
ObjectType()
const {
return HPS::Type::CuttingSectionAttributeControl;};
12879 bool Empty()
const;
13153 bool ShowBold(
bool & out_state)
const;
13158 bool ShowItalic(
bool & out_state)
const;
13163 bool ShowOverline(
bool & out_state)
const;
13168 bool ShowStrikethrough(
bool & out_state)
const;
13173 bool ShowUnderline(
bool & out_state)
const;
13178 bool ShowSlant(
float & out_angle)
const;
13183 bool ShowLineSpacing(
float & out_multiplier)
const;
13189 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
13196 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
13222 bool ShowFont(
UTF8 & out_name)
const;
13245 bool ShowPath(
Vector & out_path)
const;
13250 bool ShowSpacing(
float & out_multiplier)
const;
13281 HPS::Type
ObjectType()
const {
return HPS::Type::TextAttributeControl;};
13543 bool ShowBold(
bool & out_state)
const;
13548 bool ShowItalic(
bool & out_state)
const;
13553 bool ShowOverline(
bool & out_state)
const;
13558 bool ShowStrikethrough(
bool & out_state)
const;
13563 bool ShowUnderline(
bool & out_state)
const;
13568 bool ShowSlant(
float & out_angle)
const;
13573 bool ShowLineSpacing(
float & out_multiplier)
const;
13579 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
13586 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
13612 bool ShowFont(
UTF8 & out_name)
const;
13635 bool ShowPath(
Vector & out_path)
const;
13640 bool ShowSpacing(
float & out_multiplier)
const;
13698 bool Empty()
const;
13757 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
13788 HPS::Type
ObjectType()
const {
return HPS::Type::LineAttributeControl;};
13835 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
13891 bool Empty()
const;
13937 bool ShowPattern(
UTF8 & out_pattern_name)
const;
13943 bool ShowWeight(
float & out_weight,
Edge::SizeUnits & out_units)
const;
13974 HPS::Type
ObjectType()
const {
return HPS::Type::EdgeAttributeControl;};
14007 bool ShowPattern(
UTF8 & out_pattern_name)
const;
14013 bool ShowWeight(
float & out_weight,
Edge::SizeUnits & out_units)
const;
14068 bool Empty()
const;
14163 bool ShowBudget(
size_t & out_budget)
const;
14169 bool ShowContinuedBudget(
bool & out_state,
size_t & out_budget)
const;
14174 bool ShowViewDependent(
bool & out_state)
const;
14180 bool ShowMaximumDeviation(
float & out_deviation)
const;
14186 bool ShowMaximumAngle(
float & out_degrees)
const;
14192 bool ShowMaximumLength(
float & out_length)
const;
14222 HPS::Type
ObjectType()
const {
return HPS::Type::CurveAttributeControl;};
14306 bool ShowBudget(
size_t & out_budget)
const;
14312 bool ShowContinuedBudget(
bool & out_state,
size_t & out_budget)
const;
14317 bool ShowViewDependent(
bool & out_state)
const;
14323 bool ShowMaximumDeviation(
float & out_deviation)
const;
14329 bool ShowMaximumAngle(
float & out_degrees)
const;
14335 bool ShowMaximumLength(
float & out_length)
const;
14370 MatrixKit(FloatArray
const & in_matrix_source);
14375 MatrixKit(
float const in_matrix_source []);
14405 bool Empty()
const;
14410 bool Equals(
MatrixKit const & in_kit)
const;
14415 bool operator==(
MatrixKit const & in_kit)
const;
14420 bool operator!=(
MatrixKit const & in_kit)
const;
14427 MatrixKit & SetElement(
size_t in_row,
size_t in_column,
float in_value);
14433 MatrixKit & SetElement(
size_t in_ordinal_zero_to_fifteen,
float in_value);
14438 MatrixKit & SetElements(FloatArray
const & in_matrix);
14444 MatrixKit & SetElements(
size_t in_value_count,
float const in_values []);
14457 bool ShowElement(
size_t in_row,
size_t in_column,
float & out_value)
const;
14463 bool ShowElement(
size_t in_ordinal_zero_to_fifteen,
float & out_value)
const;
14468 bool ShowElements(FloatArray & out_matrix)
const;
14473 bool ShowDeterminant(
float & out_determinant)
const;
14478 bool ShowInverse(
MatrixKit & out_matrix)
const;
14484 bool ShowAdjoint(
MatrixKit & out_matrix)
const;
14492 MatrixKit & Rotate(
float in_x,
float in_y,
float in_z);
14505 MatrixKit & Translate(
float in_x,
float in_y,
float in_z);
14512 MatrixKit & Scale(
float in_x,
float in_y,
float in_z);
14546 MatrixKit Multiply(
float in_scalar)
const;
14551 MatrixKit const & MultiplyAndAssign(
float in_scalar);
14566 MatrixKit operator*(
float in_scalar)
const;
14571 MatrixKit const & operator*=(
float in_scalar);
14577 Point Transform(
Point const & in_source)
const;
14582 PointArray Transform(PointArray
const & in_source)
const;
14588 PointArray Transform(
size_t in_count,
Point const in_source [])
const;
14598 VectorArray Transform(VectorArray
const & in_source)
const;
14604 VectorArray Transform(
size_t in_count,
Vector const in_source [])
const;
14609 Plane Transform(
Plane const & in_source)
const;
14614 PlaneArray Transform(PlaneArray
const & in_source)
const;
14620 PlaneArray Transform(
size_t in_count,
Plane const in_source [])
const;
14662 HPS::Type
ObjectType()
const {
return HPS::Type::ModellingMatrixControl;};
14702 bool ShowElement(
size_t in_row,
size_t in_column,
float & out_value)
const;
14708 bool ShowElement(
size_t in_ordinal_zero_to_fifteen,
float & out_value)
const;
14713 bool ShowElements(FloatArray & out_matrix)
const;
14718 bool ShowDeterminant(
float & out_determinant)
const;
14723 bool ShowInverse(
MatrixKit & out_matrix)
const;
14729 bool ShowAdjoint(
MatrixKit & out_matrix)
const;
14806 HPS::Type
ObjectType()
const {
return HPS::Type::TextureMatrixControl;};
14847 bool ShowElement(
size_t in_row,
size_t in_column,
float & out_value)
const;
14853 bool ShowElement(
size_t in_ordinal_zero_to_fifteen,
float & out_value)
const;
14858 bool ShowElements(FloatArray & out_matrix)
const;
14863 bool ShowDeterminant(
float & out_determinant)
const;
14868 bool ShowInverse(
MatrixKit & out_matrix)
const;
14874 bool ShowAdjoint(
MatrixKit & out_matrix)
const;
14953 HPS::Type
ObjectType()
const {
return HPS::Type::MaterialMappingKit;};
14975 bool Empty()
const;
15579 bool ShowAmbientLightUpColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
15586 bool ShowAmbientLightDownColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
15805 bool ShowWindowContrastColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
15837 HPS::Type
ObjectType()
const {
return HPS::Type::MaterialMappingControl;};
16430 bool ShowAmbientLightUpColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
16438 bool ShowAmbientLightDownColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
16656 bool ShowWindowContrastColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
16687 HPS::Type
ObjectType()
const {
return HPS::Type::PortfolioControl; };
16693 size_t GetCount()
const;
16746 bool Show(PortfolioKeyArray & out_portfolios)
const;
16784 size_t GetCount()
const;
16788 StyleKey PushNamed(
char const * in_style_name);
16791 StyleKey PushNamed(
char const * in_style_name,
Condition const & in_condition);
16827 void Flush(
SegmentKey const & in_style_source);
16840 void Flush(
char const * in_style_name);
16848 void Flush(
char const * in_style_name,
Condition const & in_condition);
16853 StyleKey SetNamed(
char const * in_style_name);
16876 void Set(StyleTypeArray
const & in_types, SegmentKeyArray
const & in_segment_sources, UTF8Array
const & in_style_names, ConditionArray
const & in_conditions);
16882 void Set(StyleTypeArray
const & in_types, SegmentKeyArray
const & in_segment_sources, UTF8Array
const & in_style_names);
16898 void UnsetAllSegment();
16901 void UnsetAllNamed();
16904 void UnsetEverything();
16918 bool ShowTop(
StyleKey & out_style)
const;
16926 bool Show(StyleTypeArray & out_types, SegmentKeyArray & out_segment_sources, UTF8Array & out_style_names, ConditionArray & out_conditions)
const;
16931 bool Show(StyleKeyArray & out_styles)
const;
16937 bool ShowAllSegment(SegmentKeyArray & out_segments, HPS::ConditionArray & out_conditions)
const;
16942 bool ShowAllSegment(StyleKeyArray & out_styles)
const;
16948 bool ShowAllNamed(UTF8Array & out_names, HPS::ConditionArray & out_conditions)
const;
16953 bool ShowAllNamed(StyleKeyArray & out_styles)
const;
16985 HPS::Type
ObjectType()
const {
return HPS::Type::ConditionControl; };
16992 size_t GetCount()
const;
17030 bool ShowCondition(
char const * in_condition)
const;
17035 bool ShowConditions(UTF8Array & out_conditions)
const;
17086 bool Empty()
const;
17096 bool operator==(
MaterialKit const & in_kit)
const;
17101 bool operator!=(
MaterialKit const & in_kit)
const;
17138 MaterialKit & SetDiffuseTexture(
char const * in_texture_name,
size_t in_layer=0);
17147 MaterialKit & SetDiffuseTexture(
char const * in_texture_name,
RGBAColor const & in_modulating_color,
size_t in_layer=0);
17153 MaterialKit & SetDiffuseTexture(UTF8Array
const & in_texture_names);
17160 MaterialKit & SetDiffuseTexture(
size_t in_count,
UTF8 const in_texture_names []);
17168 MaterialKit & SetDiffuseTexture(UTF8Array
const & in_texture_names, RGBAColorArray
const & in_modulating_colors);
17177 MaterialKit & SetDiffuseTexture(
size_t in_count,
UTF8 const in_texture_names [],
RGBAColor const in_modulating_colors []);
17183 MaterialKit & SetShader(
char const * in_shader_name);
17195 MaterialKit & SetSpecular(
char const * in_texture_name);
17201 MaterialKit & SetSpecular(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
17213 MaterialKit & SetMirror(
char const * in_texture_name);
17226 MaterialKit & SetTransmission(
char const * in_texture_name);
17232 MaterialKit & SetTransmission(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
17244 MaterialKit & SetEmission(
char const * in_texture_name);
17250 MaterialKit & SetEmission(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
17257 MaterialKit & SetEnvironmentTexture(
char const * in_texture_name);
17263 MaterialKit & SetEnvironmentTexture(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
17268 MaterialKit & SetEnvironmentCubeMap(
char const * in_cubemap_name);
17274 MaterialKit & SetEnvironmentCubeMap(
char const * in_cubemap_name,
RGBAColor const & in_modulating_color);
17284 MaterialKit & SetBump(
char const * in_texture_name);
17315 MaterialKit & UnsetDiffuseTexture(
size_t in_layer);
17356 bool ShowDiffuse()
const;
17361 bool ShowDiffuseColor(
RGBColor & out_rgb_color)
const;
17366 bool ShowDiffuseColor(
RGBAColor & out_rgba_color)
const;
17371 bool ShowDiffuseAlpha(
float & out_alpha)
const;
17396 bool ShowDiffuseTexture(MaterialTypeArray & out_types, RGBAColorArray & out_colors, UTF8Array & out_texture_names)
const;
17401 bool ShowShader(
UTF8 & out_shader_name)
const;
17461 bool ShowBump(
UTF8 & out_texture_name)
const;
17467 bool ShowGloss(
float & out_gloss)
const;
17496 HPS::Type
ObjectType()
const {
return HPS::Type::NURBSSurfaceAttributeKit;};
17518 bool Empty()
const;
17600 bool ShowBudget(
size_t & out_budget)
const;
17605 bool ShowMaximumDeviation(
float & out_deviation)
const;
17610 bool ShowMaximumAngle(
float & out_degrees)
const;
17615 bool ShowMaximumWidth(
float & out_width)
const;
17620 bool ShowTrimBudget(
size_t & out_budget)
const;
17625 bool ShowMaximumTrimDeviation(
float & out_deviation)
const;
17656 HPS::Type
ObjectType()
const {
return HPS::Type::NURBSSurfaceAttributeControl;};
17726 bool ShowBudget(
size_t & out_budget)
const;
17731 bool ShowMaximumDeviation(
float & out_deviation)
const;
17736 bool ShowMaximumAngle(
float & out_degrees)
const;
17741 bool ShowMaximumWidth(
float & out_width)
const;
17746 bool ShowTrimBudget(
size_t & out_budget)
const;
17751 bool ShowMaximumTrimDeviation(
float & out_deviation)
const;
17807 bool Empty()
const;
17889 HPS::Type
ObjectType()
const {
return HPS::Type::PerformanceControl;};
17962 HPS::Type
ObjectType()
const {
return HPS::Type::HiddenLineAttributeKit;};
17984 bool Empty()
const;
18124 bool ShowColor(
RGBAColor & out_color)
const;
18129 bool ShowDimFactor(
float & out_zero_to_one)
const;
18134 bool ShowFaceDisplacement(
float & out_buckets)
const;
18139 bool ShowLinePattern(
UTF8 & out_pattern)
const;
18144 bool ShowRenderFaces(
bool & out_state)
const;
18149 bool ShowRenderText(
bool & out_state)
const;
18159 bool ShowSilhouetteCleanup(
bool & out_state)
const;
18164 bool ShowVisibility(
bool & out_state)
const;
18170 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
18175 bool ShowTransparencyCutoff(
float & out_zero_to_one)
const;
18207 HPS::Type
ObjectType()
const {
return HPS::Type::HiddenLineAttributeControl;};
18334 bool ShowColor(
RGBAColor & out_color)
const;
18339 bool ShowDimFactor(
float & out_zero_to_one)
const;
18344 bool ShowFaceDisplacement(
float & out_buckets)
const;
18349 bool ShowLinePattern(
UTF8 & out_pattern)
const;
18354 bool ShowRenderFaces(
bool & out_state)
const;
18359 bool ShowRenderText(
bool & out_state)
const;
18369 bool ShowSilhouetteCleanup(
bool & out_state)
const;
18374 bool ShowVisibility(
bool & out_state)
const;
18380 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
18385 bool ShowTransparencyCutoff(
float & out_zero_to_one)
const;
18419 HPS::Type
ObjectType()
const {
return HPS::Type::DrawingAttributeKit;};
18441 bool Empty()
const;
18625 bool ShowDepthRange(
float & out_near,
float & out_far)
const;
18631 bool ShowFaceDisplacement(
bool & out_state,
int & out_buckets)
const;
18637 bool ShowGeneralDisplacement(
bool & out_state,
int & out_buckets)
const;
18643 bool ShowVertexDisplacement(
bool & out_state,
int & out_buckets)
const;
18653 bool ShowDeferral(
int & out_defer_batch)
const;
18699 HPS::Type
ObjectType()
const {
return HPS::Type::DrawingAttributeControl;};
18865 bool ShowDepthRange(
float & out_x,
float & out_y)
const;
18871 bool ShowFaceDisplacement(
bool & out_state,
int & out_buckets)
const;
18877 bool ShowGeneralDisplacement(
bool & out_state,
int & out_buckets)
const;
18883 bool ShowVertexDisplacement(
bool & out_state,
int & out_buckets)
const;
18893 bool ShowDeferral(
int & out_defer_batch)
const;
18933 HPS::Type
ObjectType()
const {
return HPS::Type::PostProcessEffectsKit;};
18955 bool Empty()
const;
19018 PostProcessEffectsKit & SetDepthOfField(
float in_strength,
float in_near_distance,
float in_far_distance);
19027 PostProcessEffectsKit & SetSilhouetteEdges(
bool in_state,
float in_tolerance = 1.0f,
bool in_heavy_exterior =
false);
19044 PostProcessEffectsKit & SetEyeDomeLighting(
bool in_state,
float in_exponent = 50.0f,
float in_tolerance = 1.0f,
float in_strength = 1.0f);
19052 PostProcessEffectsKit & SetEyeDomeLighting(
float in_exponent,
bool in_tolerance,
float in_strength);
19101 bool ShowDepthOfField(
bool & out_state,
float & out_strength,
float & out_near_distance,
float & out_far_distance)
const;
19110 bool ShowSilhouetteEdges(
bool & out_state,
float & out_tolerance,
bool & out_heavy_exterior)
const;
19119 bool ShowEyeDomeLighting(
bool & out_state,
float & out_exponent,
float & out_tolerance,
float & out_strength)
const;
19149 HPS::Type
ObjectType()
const {
return HPS::Type::PostProcessEffectsControl;};
19209 PostProcessEffectsControl & SetSilhouetteEdges(
bool in_state,
float in_tolerance = 1.0f,
bool in_heavy_exterior =
false);
19225 PostProcessEffectsControl & SetEyeDomeLighting(
bool in_state,
float in_exponent = 50.0f,
float in_tolerance = 1.0f,
float in_strength = 1.0f);
19283 bool ShowDepthOfField(
bool & out_state,
float & out_strength,
float & out_near_distance,
float & out_far_distance)
const;
19292 bool ShowSilhouetteEdges(
bool & out_state,
float & out_tolerance,
bool & out_heavy_exterior)
const;
19301 bool ShowEyeDomeLighting(
bool & out_state,
float & out_exponent,
float & out_tolerance,
float & out_strength)
const;
19346 bool Empty()
const;
19490 bool ShowCameraRotation(
bool & out_state)
const;
19495 bool ShowCameraScale(
bool & out_state)
const;
19500 bool ShowCameraTranslation(
bool & out_state)
const;
19505 bool ShowCameraPerspectiveScale(
bool & out_state)
const;
19510 bool ShowCameraProjection(
bool & out_state)
const;
19515 bool ShowCameraOffset(
bool & out_state)
const;
19520 bool ShowCameraNearLimit(
bool & out_state)
const;
19525 bool ShowModellingMatrixRotation(
bool & out_state)
const;
19530 bool ShowModellingMatrixScale(
bool & out_state)
const;
19535 bool ShowModellingMatrixTranslation(
bool & out_state)
const;
19540 bool ShowModellingMatrixOffset(
bool & out_state)
const;
19571 HPS::Type
ObjectType()
const {
return HPS::Type::TransformMaskControl;};
19706 bool ShowCameraRotation(
bool & out_state)
const;
19711 bool ShowCameraScale(
bool & out_state)
const;
19716 bool ShowCameraTranslation(
bool & out_state)
const;
19721 bool ShowCameraPerspectiveScale(
bool & out_state)
const;
19726 bool ShowCameraProjection(
bool & out_state)
const;
19731 bool ShowCameraOffset(
bool & out_state)
const;
19736 bool ShowCameraNearLimit(
bool & out_state)
const;
19741 bool ShowModellingMatrixRotation(
bool & out_state)
const;
19746 bool ShowModellingMatrixScale(
bool & out_state)
const;
19751 bool ShowModellingMatrixTranslation(
bool & out_state)
const;
19756 bool ShowModellingMatrixOffset(
bool & out_state)
const;
19812 bool Empty()
const;
19848 VisualEffectsKit & SetShadowMaps(
bool in_state,
unsigned int in_samples = 4,
unsigned int in_resolution = 1024,
bool in_view_dependent =
true,
bool in_jitter =
true);
19858 VisualEffectsKit & SetShadowMaps(
unsigned int in_samples,
unsigned int in_resolution,
bool in_view_dependent,
bool in_jitter);
19866 VisualEffectsKit & SetSimpleShadow(
bool in_state,
unsigned int in_resolution = 256,
unsigned int in_blurring = 1,
bool in_ignore_transparency =
false);
19873 VisualEffectsKit & SetSimpleShadow(
unsigned int in_resolution,
unsigned int in_blurring,
bool in_ignore_transparency);
19900 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);
19911 VisualEffectsKit & SetSimpleReflection(
float in_opacity,
unsigned int in_blurring,
bool in_fading,
float in_attenuation_near_distance,
float in_attenuation_far_distance);
19971 bool ShowPostProcessEffectsEnabled(
bool & out_state)
const;
19976 bool ShowAntiAliasing(
bool & out_state)
const;
19985 bool ShowShadowMaps(
bool & out_state,
unsigned int & out_samples,
unsigned int & out_resolution,
bool & out_view_dependent,
bool & out_jitter)
const;
19993 bool ShowSimpleShadow(
bool & out_state,
unsigned int & out_resolution,
unsigned int & out_blurring,
bool & out_ignore_transparency)
const;
19998 bool ShowSimpleShadowPlane(
Plane & out_projected_onto)
const;
20003 bool ShowSimpleShadowLightDirection(
Vector & out_direction)
const;
20008 bool ShowSimpleShadowColor(
RGBAColor & out_color)
const;
20018 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;
20024 bool ShowSimpleReflectionPlane(
Plane & out_projected_onto)
const;
20029 bool ShowSimpleReflectionVisibility(
VisibilityKit & out_reflected_types)
const;
20061 HPS::Type
ObjectType()
const {
return HPS::Type::VisualEffectsControl;};
20085 VisualEffectsControl & SetShadowMaps(
bool in_state,
unsigned int in_samples = 4,
unsigned int in_resolution = 1024,
bool in_view_dependent =
true,
bool in_jitter =
true);
20095 VisualEffectsControl & SetShadowMaps(
unsigned int in_samples,
unsigned int in_resolution,
bool in_view_dependent,
bool in_jitter);
20103 VisualEffectsControl & SetSimpleShadow(
bool in_state,
unsigned int in_resolution = 256,
unsigned int in_blurring = 1,
bool in_ignore_transparency =
false);
20110 VisualEffectsControl & SetSimpleShadow(
unsigned int in_resolution,
unsigned int in_blurring,
bool in_ignore_transparency);
20137 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);
20148 VisualEffectsControl & SetSimpleReflection(
float in_opacity,
unsigned int in_blurring,
bool in_fading,
float in_attenuation_near_distance,
float in_attenuation_far_distance);
20209 bool ShowPostProcessEffectsEnabled(
bool & out_state)
const;
20214 bool ShowAntiAliasing(
bool & out_state)
const;
20223 bool ShowShadowMaps(
bool & out_state,
unsigned int & out_samples,
unsigned int & out_resolution,
bool & out_view_dependent,
bool & out_jitter)
const;
20231 bool ShowSimpleShadow(
bool & out_state,
unsigned int & out_resolution,
unsigned int & out_blurring,
bool & out_ignore_transparency)
const;
20236 bool ShowSimpleShadowPlane(
Plane & out_projected_onto)
const;
20241 bool ShowSimpleShadowLightDirection(
Vector & out_direction)
const;
20246 bool ShowSimpleShadowColor(
RGBAColor & out_color)
const;
20256 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;
20261 bool ShowSimpleReflectionPlane(
Plane & out_projected_onto)
const;
20266 bool ShowSimpleReflectionVisibility(
VisibilityKit & out_reflected_types)
const;
20322 bool Empty()
const;
20349 ContourLineKit & SetPositions(
float in_interval,
float in_offset);
20360 ContourLineKit & SetPositions(
size_t in_count,
float const in_positions[]);
20398 ContourLineKit & SetWeights(FloatArray
const & in_weights, LineSizeUnitsArray
const & in_units);
20451 bool ShowVisibility(
bool & out_state)
const;
20458 bool ShowPositions(
ContourLine::Mode & out_mode, FloatArray & out_positions)
const;
20463 bool ShowColors(RGBColorArray & out_colors)
const;
20468 bool ShowPatterns(UTF8Array & out_patterns)
const;
20474 bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units)
const;
20479 bool ShowLighting(
bool & out_state)
const;
20508 HPS::Type
ObjectType()
const {
return HPS::Type::ContourLineControl; };
20572 ContourLineControl & SetWeights(FloatArray
const & in_weights, LineSizeUnitsArray
const & in_units);
20625 bool ShowVisibility(
bool & out_state)
const;
20632 bool ShowPositions(
ContourLine::Mode & out_mode, FloatArray & out_positions)
const;
20637 bool ShowColors(RGBColorArray & out_colors)
const;
20642 bool ShowPatterns(UTF8Array & out_patterns)
const;
20648 bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units)
const;
20653 bool ShowLighting(
bool & out_state)
const;
20708 bool Empty()
const;
20821 bool ShowModelCompareMode(
bool & out_state,
SegmentKey & out_source1,
SegmentKey & out_source2)
const;
20957 bool ShowModelCompareMode(
bool & out_state,
SegmentKey & out_source1,
SegmentKey & out_source2)
const;
21012 bool Empty()
const;
21048 bool ShowResourceMonitor(
bool & out_display)
const;
21091 bool ShowResourceMonitor(
bool & out_display)
const;
21096 bool ShowLastUpdateInfo(
UpdateInfo & out_info);
21145 bool Empty()
const;
21167 WindowInfoKit & SetPhysicalPixels(
unsigned int in_width,
unsigned int in_height);
21173 WindowInfoKit & SetPhysicalSize(
float in_width,
float in_height);
21179 WindowInfoKit & SetWindowPixels(
unsigned int in_width,
unsigned int in_height);
21185 WindowInfoKit & SetWindowSize(
float in_width,
float in_height);
21213 bool ShowPhysicalPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
21219 bool ShowPhysicalSize(
float & out_width,
float & out_height)
const;
21225 bool ShowWindowPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
21231 bool ShowWindowSize(
float & out_width,
float & out_height)
const;
21238 bool ShowResolution(
float & out_horizontal,
float & out_vertical)
const;
21243 bool ShowWindowAspectRatio(
float & out_window_aspect)
const;
21248 bool ShowPixelAspectRatio(
float & out_pixel_aspect)
const;
21286 bool ShowPhysicalPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
21292 bool ShowPhysicalSize(
float & out_width,
float & out_height)
const;
21298 bool ShowWindowPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
21304 bool ShowWindowSize(
float & out_width,
float & out_height)
const;
21311 bool ShowResolution(
float & out_horizontal,
float & out_vertical)
const;
21316 bool ShowWindowAspectRatio(
float & out_window_aspect)
const;
21321 bool ShowPixelAspectRatio(
float & out_pixel_aspect)
const;
21327 bool ShowMaxTextureSize(
unsigned int & out_width,
unsigned int & out_height)
const;
21333 bool ShowLastUpdateTime(Time & out_time)
const;
21338 bool ShowDepthPeelingLayers(
size_t & out_layers)
const;
21343 bool ShowVideoMemory(
size_t & out_video_memory)
const;
21348 bool ShowDepthBufferSize(
size_t & out_bits)
const;
21353 bool ShowMaxLights(
size_t & out_lights)
const;
21358 bool ShowColorBitPlanes(
size_t & out_planes)
const;
21410 bool Empty()
const;
21429 UTF8 GetName()
const;
21433 bool GetShellConvertibility()
const;
21486 bool Empty()
const;
21514 AttributeLockKit & SetLock(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
21528 AttributeLockKit & SetSubsegmentLockOverride(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
21545 AttributeLockKit & UnsetSubsegmentLockOverride(AttributeLockTypeArray
const & in_types);
21562 bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
21574 bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
21605 HPS::Type
ObjectType()
const {
return HPS::Type::AttributeLockControl;}
21622 AttributeLockControl & SetLock(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
21636 AttributeLockControl & SetSubsegmentLockOverride(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
21670 bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
21682 bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
21731 size_t ShowReferrers(SegmentKeyArray & out_segments)
const;
21736 size_t ShowReferrers(ReferenceKeyArray & out_references)
const;
21755 bool ShowPriority(
int & out_priority)
const;
21763 GeometryKey & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
21769 GeometryKey & SetUserData(intptr_t in_index, ByteArray
const & in_data);
21775 GeometryKey & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
21786 GeometryKey & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
21791 GeometryKey & UnsetUserData(IntPtrTArray
const & in_indices);
21798 size_t ShowUserDataCount()
const;
21803 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
21809 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
21815 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
21852 void Consume(
LineKit & in_kit);
21856 void Set(
LineKit const & in_kit);
21860 void Show(
LineKit & out_kit)
const;
21869 bool Empty()
const;
21874 bool Equals(
LineKit const & in_kit)
const;
21879 bool operator==(
LineKit const & in_kit)
const;
21884 bool operator!=(
LineKit const & in_kit)
const;
21888 size_t GetPointCount()
const;
21896 LineKit & SetPriority(
int in_priority);
21905 bool ShowPriority(
int & out_priority)
const;
21911 LineKit & SetPoints(PointArray
const & in_points);
21917 LineKit & SetPoints(
size_t in_count,
Point const in_points []);
21932 bool ShowPoints(PointArray & out_points)
const;
21939 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
21945 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
21952 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
21960 LineKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
21966 LineKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
21972 LineKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
21979 LineKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
21986 LineKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
21993 LineKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
21999 LineKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
22005 LineKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
22010 LineKit & UnsetUserData(intptr_t in_index);
22016 LineKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
22021 LineKit & UnsetUserData(IntPtrTArray
const & in_indices);
22025 LineKit & UnsetAllUserData();
22028 size_t ShowUserDataCount()
const;
22033 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
22039 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
22045 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
22086 void Consume(
LineKit & in_kit);
22090 void Set(
LineKit const & in_kit);
22094 void Show(
LineKit & out_kit)
const;
22098 size_t GetPointCount()
const;
22103 LineKey & SetPoints(PointArray
const & in_points);
22109 LineKey & SetPoints(
size_t in_count,
Point const in_points []);
22115 bool ShowPoints(PointArray & out_points)
const;
22122 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
22128 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
22135 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
22143 LineKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
22149 LineKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
22155 LineKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
22162 LineKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
22169 LineKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
22218 bool Empty()
const;
22223 bool Equals(
MarkerKit const & in_kit)
const;
22228 bool operator==(
MarkerKit const & in_kit)
const;
22233 bool operator!=(
MarkerKit const & in_kit)
const;
22242 MarkerKit & SetPriority(
int in_priority);
22251 bool ShowPriority(
int & out_priority)
const;
22271 bool ShowPoint(
HPS::Point & out_point)
const;
22278 MarkerKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
22284 MarkerKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
22290 MarkerKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
22295 MarkerKit & UnsetUserData(intptr_t in_index);
22301 MarkerKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
22306 MarkerKit & UnsetUserData(IntPtrTArray
const & in_indices);
22313 size_t ShowUserDataCount()
const;
22318 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
22324 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
22330 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
22390 bool ShowPoint(
Point & out_point)
const;
22439 bool Empty()
const;
22514 bool ShowPriority(
int & out_priority)
const;
22519 bool ShowDirection(
HPS::Vector & out_vector)
const;
22531 bool ShowCameraRelative(
bool & out_state)
const;
22538 DistantLightKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
22544 DistantLightKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
22550 DistantLightKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
22561 DistantLightKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
22573 size_t ShowUserDataCount()
const;
22578 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
22584 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
22590 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
22674 bool ShowDirection(
HPS::Vector & out_vector)
const;
22686 bool ShowCameraRelative(
bool & out_state)
const;
22736 bool Empty()
const;
22746 bool operator==(
CylinderKit const & in_kit)
const;
22751 bool operator!=(
CylinderKit const & in_kit)
const;
22755 size_t GetPointCount()
const;
22772 bool ShowPriority(
int & out_priority)
const;
22778 CylinderKit & SetPoints(PointArray
const & in_points);
22789 CylinderKit & SetRadii(FloatArray
const & in_radii);
22795 CylinderKit & SetRadii(
size_t in_count,
float const in_radii []);
22823 bool ShowPoints(PointArray & out_points)
const;
22830 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
22836 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
22843 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
22848 bool ShowRadii(FloatArray & out_radii)
const;
22974 CylinderKit & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
22979 CylinderKit & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
23012 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;
23026 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
23033 CylinderKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
23039 CylinderKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
23045 CylinderKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
23056 CylinderKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
23061 CylinderKit & UnsetUserData(IntPtrTArray
const & in_indices);
23068 size_t ShowUserDataCount()
const;
23073 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
23079 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
23085 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
23139 CylinderKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
23145 CylinderKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
23151 CylinderKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
23158 CylinderKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
23165 CylinderKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
23173 CylinderKey & EditRadiiByInsertion(
size_t in_offset,
size_t in_count,
float const in_radii[]);
23179 CylinderKey & EditRadiiByInsertion(
size_t in_offset, FloatArray
const & in_radii);
23185 CylinderKey & EditRadiiByDeletion(
size_t in_offset,
size_t in_count);
23192 CylinderKey & EditRadiiByReplacement(
size_t in_offset,
size_t in_count,
float const in_radii[]);
23199 CylinderKey & EditRadiiByReplacement(
size_t in_offset, FloatArray
const & in_radii);
23208 size_t GetPointCount()
const;
23213 bool ShowPoints(PointArray & out_points)
const;
23220 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
23226 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
23233 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
23238 bool ShowRadii(FloatArray & out_radii)
const;
23304 CylinderKey & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
23330 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;
23344 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
23394 bool Empty()
const;
23399 bool Equals(
SphereKit const & in_kit)
const;
23404 bool operator==(
SphereKit const & in_kit)
const;
23409 bool operator!=(
SphereKit const & in_kit)
const;
23417 SphereKit & SetPriority(
int in_priority);
23426 bool ShowPriority(
int & out_priority)
const;
23436 SphereKit & SetRadius(
float in_radius);
23465 bool ShowCenter(
Point & out_center)
const;
23470 bool ShowRadius(
float & out_radius)
const;
23476 bool ShowBasis(
Vector & out_vertical,
Vector & out_horizontal)
const;
23483 SphereKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
23489 SphereKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
23495 SphereKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
23500 SphereKit & UnsetUserData(intptr_t in_index);
23506 SphereKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
23511 SphereKit & UnsetUserData(IntPtrTArray
const & in_indices);
23518 size_t ShowUserDataCount()
const;
23523 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
23529 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
23535 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
23594 SphereKey & SetRadius(
float in_radius);
23606 bool ShowCenter(
Point & out_center)
const;
23611 bool ShowRadius(
float & out_radius)
const;
23617 bool ShowBasis(
Vector & out_vertical,
Vector & out_horizontal)
const;
23667 bool Empty()
const;
23672 bool Equals(
CircleKit const & in_kit)
const;
23677 bool operator==(
CircleKit const & in_kit)
const;
23682 bool operator!=(
CircleKit const & in_kit)
const;
23690 CircleKit & SetPriority(
int const in_priority);
23699 bool ShowPriority(
int & out_priority)
const;
23711 CircleKit & SetRadius(
float in_radius);
23739 bool ShowCenter(
Point & out_center)
const;
23744 bool ShowRadius(
float & out_radius)
const;
23749 bool ShowNormal(
Vector & out_normal)
const;
23756 CircleKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
23762 CircleKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
23768 CircleKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
23773 CircleKit & UnsetUserData(intptr_t in_index);
23779 CircleKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
23784 CircleKit & UnsetUserData(IntPtrTArray
const & in_indices);
23791 size_t ShowUserDataCount()
const;
23796 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
23802 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
23808 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
23870 CircleKey & SetRadius(
float in_radius);
23881 bool ShowCenter(
Point & out_center)
const;
23886 bool ShowRadius(
float & out_radius)
const;
23891 bool ShowNormal(
Vector & out_normal)
const;
23941 bool Empty()
const;
23973 bool ShowPriority(
int & out_priority)
const;
24012 bool ShowStart(
Point & out_start)
const;
24017 bool ShowMiddle(
Point & out_middle)
const;
24022 bool ShowEnd(
Point & out_end)
const;
24029 CircularArcKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
24035 CircularArcKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
24041 CircularArcKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
24052 CircularArcKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
24057 CircularArcKit & UnsetUserData(IntPtrTArray
const & in_indices);
24064 size_t ShowUserDataCount()
const;
24069 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
24075 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
24081 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
24153 bool ShowStart(
Point & out_start)
const;
24158 bool ShowMiddle(
Point & out_middle)
const;
24163 bool ShowEnd(
Point & out_end)
const;
24191 HPS::Type
ObjectType()
const {
return HPS::Type::CircularWedgeKit; };
24212 bool Empty()
const;
24245 bool ShowPriority(
int & out_priority)
const;
24284 bool ShowStart(
Point & out_start)
const;
24289 bool ShowMiddle(
Point & out_middle)
const;
24294 bool ShowEnd(
Point & out_end)
const;
24301 CircularWedgeKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
24307 CircularWedgeKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
24313 CircularWedgeKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
24324 CircularWedgeKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
24336 size_t ShowUserDataCount()
const;
24341 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
24347 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
24353 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
24392 HPS::Type
ObjectType()
const {
return HPS::Type::CircularWedgeKey; };
24427 bool ShowStart(
Point & out_start)
const;
24432 bool ShowMiddle(
Point & out_middle)
const;
24437 bool ShowEnd(
Point & out_end)
const;
24465 HPS::Type
ObjectType()
const {
return HPS::Type::CuttingSectionKit; };
24486 bool Empty()
const;
24518 bool ShowPriority(
int & out_priority)
const;
24560 size_t GetPlaneCount()
const;
24565 bool ShowPlanes(HPS::PlaneArray & out_planes)
const;
24588 CuttingSectionKit & EditPlanesByInsertion(
size_t in_offset, PlaneArray
const & in_planes);
24604 CuttingSectionKit & EditPlanesByReplacement(
size_t in_offset,
size_t in_count,
Plane const in_planes[]);
24613 CuttingSectionKit & EditPlanesByReplacement(
size_t in_offset, PlaneArray
const & in_planes);
24620 CuttingSectionKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
24632 CuttingSectionKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
24643 CuttingSectionKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
24655 size_t ShowUserDataCount()
const;
24660 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
24666 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
24672 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
24709 HPS::Type
ObjectType()
const {
return HPS::Type::CuttingSectionKey; };
24751 size_t GetPlaneCount()
const;
24756 bool ShowPlanes(HPS::PlaneArray & out_planes)
const;
24779 CuttingSectionKey & EditPlanesByInsertion(
size_t in_offset, PlaneArray
const & in_planes);
24795 CuttingSectionKey & EditPlanesByReplacement(
size_t in_offset,
size_t in_count,
Plane const in_planes[]);
24802 CuttingSectionKey & EditPlanesByReplacement(
size_t in_offset, PlaneArray
const & in_planes);
24851 bool Empty()
const;
24883 bool ShowPriority(
int & out_priority)
const;
24922 bool ShowFirst(
Point & out_first)
const;
24927 bool ShowSecond(
Point & out_second)
const;
24939 InfiniteLineKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
24945 InfiniteLineKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
24951 InfiniteLineKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
24962 InfiniteLineKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
24974 size_t ShowUserDataCount()
const;
24979 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
24985 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
24991 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
25062 bool ShowFirst(
Point & out_first)
const;
25067 bool ShowSecond(
Point & out_second)
const;
25128 bool Empty()
const;
25197 SpotlightKit & SetConcentration(
float in_concentration);
25247 bool ShowPriority(
int & out_priority)
const;
25252 bool ShowPosition(
HPS::Point & out_position)
const;
25257 bool ShowTarget(
HPS::Point & out_target)
const;
25281 bool ShowConcentration(
float & out_concentration)
const;
25286 bool ShowCameraRelative(
bool & out_state)
const;
25293 SpotlightKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
25299 SpotlightKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
25305 SpotlightKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
25316 SpotlightKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
25321 SpotlightKit & UnsetUserData(IntPtrTArray
const & in_indices);
25328 size_t ShowUserDataCount()
const;
25333 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
25339 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
25345 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
25440 SpotlightKey & SetConcentration(
float in_concentration);
25458 bool ShowPosition(
HPS::Point & out_position)
const;
25463 bool ShowTarget(
HPS::Point & out_target)
const;
25487 bool ShowConcentration(
float & out_concentration)
const;
25492 bool ShowCameraRelative(
bool & out_state)
const;
25541 bool Empty()
const;
25560 size_t GetPointCount()
const;
25577 bool ShowPriority(
int & out_priority)
const;
25604 NURBSCurveKit & SetWeights(
size_t in_count,
float const in_weights []);
25615 NURBSCurveKit & SetKnots(
size_t in_count,
float const in_knots []);
25621 NURBSCurveKit & SetParameters(
float in_start,
float in_end);
25652 bool ShowDegree(
size_t & out_degree)
const;
25657 bool ShowPoints(PointArray & out_points)
const;
25664 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
25670 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
25677 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
25682 bool ShowWeights(FloatArray & out_weights)
const;
25687 bool ShowKnots(FloatArray & out_knots)
const;
25693 bool ShowParameters(
float & out_start,
float & out_end)
const;
25702 NURBSCurveKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
25709 NURBSCurveKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
25717 NURBSCurveKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
25725 NURBSCurveKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
25733 NURBSCurveKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
25743 NURBSCurveKit & EditWeightsByInsertion(
size_t in_offset,
size_t in_count,
float const in_weights[]);
25751 NURBSCurveKit & EditWeightsByInsertion(
size_t in_offset, FloatArray
const & in_weights);
25760 NURBSCurveKit & EditWeightsByDeletion(
size_t in_offset,
size_t in_count);
25768 NURBSCurveKit & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
25776 NURBSCurveKit & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
25784 NURBSCurveKit & EditKnotsByInsertion(
size_t in_offset,
size_t in_count,
float const in_knots[]);
25790 NURBSCurveKit & EditKnotsByInsertion(
size_t in_offset, FloatArray
const & in_knots);
25797 NURBSCurveKit & EditKnotsByDeletion(
size_t in_offset,
size_t in_count);
25805 NURBSCurveKit & EditKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
25813 NURBSCurveKit & EditKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
25820 NURBSCurveKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
25826 NURBSCurveKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
25832 NURBSCurveKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
25843 NURBSCurveKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
25848 NURBSCurveKit & UnsetUserData(IntPtrTArray
const & in_indices);
25855 size_t ShowUserDataCount()
const;
25860 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
25866 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
25872 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
25925 size_t GetPointCount()
const;
25931 NURBSCurveKey & SetParameters(
float in_start,
float in_end);
25936 bool ShowDegree(
size_t & out_degree)
const;
25941 bool ShowPoints(PointArray & out_points)
const;
25948 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
25954 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
25961 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
25966 bool ShowWeights(FloatArray & out_weights)
const;
25971 bool ShowKnots(FloatArray & out_knots)
const;
25977 bool ShowParameters(
float & out_start,
float & out_end)
const;
25987 NURBSCurveKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
25995 NURBSCurveKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
26006 NURBSCurveKey & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
26015 NURBSCurveKey & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
26025 NURBSCurveKey & EditKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26033 NURBSCurveKey & EditKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
26082 bool Empty()
const;
26101 size_t GetPointCount()
const;
26118 bool ShowPriority(
int & out_priority)
const;
26162 NURBSSurfaceKit & SetWeights(
size_t in_count,
float const in_weights []);
26175 NURBSSurfaceKit & SetUKnots(
size_t in_count,
float const in_knots []);
26188 NURBSSurfaceKit & SetVKnots(
size_t in_count,
float const in_knots []);
26246 bool ShowUDegree(
size_t & out_degree)
const;
26251 bool ShowVDegree(
size_t & out_degree)
const;
26256 bool ShowUCount(
size_t & out_count)
const;
26261 bool ShowVCount(
size_t & out_count)
const;
26266 bool ShowPoints(PointArray & out_points)
const;
26273 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
26279 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
26286 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
26291 bool ShowWeights(FloatArray & out_weights)
const;
26296 bool ShowUKnots(FloatArray & out_knots)
const;
26301 bool ShowVKnots(FloatArray & out_knots)
const;
26306 bool ShowTrims(TrimKitArray & out_trims)
const;
26315 NURBSSurfaceKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
26322 NURBSSurfaceKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
26330 NURBSSurfaceKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
26338 NURBSSurfaceKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
26346 NURBSSurfaceKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
26356 NURBSSurfaceKit & EditWeightsByInsertion(
size_t in_offset,
size_t in_count,
float const in_weights[]);
26364 NURBSSurfaceKit & EditWeightsByInsertion(
size_t in_offset, FloatArray
const & in_weights);
26373 NURBSSurfaceKit & EditWeightsByDeletion(
size_t in_offset,
size_t in_count);
26381 NURBSSurfaceKit & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
26389 NURBSSurfaceKit & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
26398 NURBSSurfaceKit & EditUKnotsByInsertion(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26405 NURBSSurfaceKit & EditUKnotsByInsertion(
size_t in_offset, FloatArray
const & in_knots);
26413 NURBSSurfaceKit & EditUKnotsByDeletion(
size_t in_offset,
size_t in_count);
26421 NURBSSurfaceKit & EditUKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26429 NURBSSurfaceKit & EditUKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
26438 NURBSSurfaceKit & EditVKnotsByInsertion(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26445 NURBSSurfaceKit & EditVKnotsByInsertion(
size_t in_offset, FloatArray
const & in_knots);
26453 NURBSSurfaceKit & EditVKnotsByDeletion(
size_t in_offset,
size_t in_count);
26461 NURBSSurfaceKit & EditVKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26469 NURBSSurfaceKit & EditVKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
26476 NURBSSurfaceKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
26482 NURBSSurfaceKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
26488 NURBSSurfaceKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
26499 NURBSSurfaceKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
26511 size_t ShowUserDataCount()
const;
26516 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
26522 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
26528 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
26581 size_t GetPointCount()
const;
26603 bool ShowUDegree(
size_t & out_degree)
const;
26608 bool ShowVDegree(
size_t & out_degree)
const;
26613 bool ShowUCount(
size_t & out_count)
const;
26618 bool ShowVCount(
size_t & out_count)
const;
26623 bool ShowPoints(PointArray & out_points)
const;
26630 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
26636 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
26643 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
26648 bool ShowWeights(FloatArray & out_weights)
const;
26653 bool ShowUKnots(FloatArray & out_knots)
const;
26658 bool ShowVKnots(FloatArray & out_knots)
const;
26663 bool ShowTrims(TrimKitArray & out_trims)
const;
26673 NURBSSurfaceKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
26681 NURBSSurfaceKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
26692 NURBSSurfaceKey & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
26701 NURBSSurfaceKey & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
26711 NURBSSurfaceKey & EditUKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26719 NURBSSurfaceKey & EditUKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
26729 NURBSSurfaceKey & EditVKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26737 NURBSSurfaceKey & EditVKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
26794 bool operator==(
TrimElement const & in_that)
const;
26799 bool operator!=(
TrimElement const & in_that)
const;
26805 void SetCurve(
LineKit const & in_line);
26849 void Set(
TrimKit const & in_kit);
26853 void Show(
TrimKit & out_kit)
const;
26862 bool Empty()
const;
26867 bool Equals(
TrimKit const & in_kit)
const;
26872 bool operator==(
TrimKit const & in_kit)
const;
26877 bool operator!=(
TrimKit const & in_kit)
const;
26889 TrimKit & SetShape(TrimElementArray
const & in_shape);
26913 bool ShowShape(TrimElementArray & out_shape)
const;
26967 bool Empty()
const;
26972 bool Equals(
EllipseKit const & in_kit)
const;
26977 bool operator==(
EllipseKit const & in_kit)
const;
26982 bool operator!=(
EllipseKit const & in_kit)
const;
26999 bool ShowPriority(
int & out_priority)
const;
27038 bool ShowCenter(
Point & out_center)
const;
27043 bool ShowMajor(
Point & out_major)
const;
27048 bool ShowMinor(
Point & out_minor)
const;
27055 EllipseKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
27061 EllipseKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
27067 EllipseKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
27072 EllipseKit & UnsetUserData(intptr_t in_index);
27078 EllipseKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
27083 EllipseKit & UnsetUserData(IntPtrTArray
const & in_indices);
27090 size_t ShowUserDataCount()
const;
27095 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
27101 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
27107 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
27179 bool ShowCenter(
Point & out_center)
const;
27184 bool ShowMajor(
Point & out_major)
const;
27189 bool ShowMinor(
Point & out_minor)
const;
27217 HPS::Type
ObjectType()
const {
return HPS::Type::EllipticalArcKit; };
27238 bool Empty()
const;
27270 bool ShowPriority(
int & out_priority)
const;
27335 bool ShowCenter(
Point & out_center)
const;
27340 bool ShowMajor(
Point & out_major)
const;
27345 bool ShowMinor(
Point & out_minor)
const;
27350 bool ShowStart(
float & out_start)
const;
27355 bool ShowEnd(
float & out_end)
const;
27362 EllipticalArcKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
27368 EllipticalArcKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
27374 EllipticalArcKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
27385 EllipticalArcKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
27397 size_t ShowUserDataCount()
const;
27402 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
27408 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
27414 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
27451 HPS::Type
ObjectType()
const {
return HPS::Type::EllipticalArcKey; };
27504 bool ShowCenter(
Point & out_center)
const;
27509 bool ShowMajor(
Point & out_major)
const;
27514 bool ShowMinor(
Point & out_minor)
const;
27519 bool ShowStart(
float & out_start)
const;
27524 bool ShowEnd(
float & out_end)
const;
27556 void Consume(
TextKit & in_kit);
27560 void Set(
TextKit const & in_kit);
27564 void Show(
TextKit & out_kit)
const;
27573 bool Empty()
const;
27578 bool Equals(
TextKit const & in_kit)
const;
27583 bool operator==(
TextKit const & in_kit)
const;
27588 bool operator!=(
TextKit const & in_kit)
const;
27596 TextKit & SetPriority(
int in_priority);
27605 bool ShowPriority(
int & out_priority)
const;
27615 TextKit & SetText(
char const * in_string);
27625 TextKit & SetColorByIndex(
float in_index);
27642 TextKit & SetBold(
bool in_state);
27647 TextKit & SetItalic(
bool in_state);
27652 TextKit & SetOverline(
bool in_state);
27657 TextKit & SetStrikethrough(
bool in_state);
27662 TextKit & SetUnderline(
bool in_state);
27668 TextKit & SetSlant(
float in_angle);
27673 TextKit & SetLineSpacing(
float in_multiplier);
27685 TextKit & SetRotation(
float in_angle);
27745 TextKit & SetFont(
char const * in_name);
27780 TextKit & SetSpacing(
float in_multiplier);
27797 TextKit & UnsetModellingMatrix();
27817 TextKit & UnsetStrikethrough();
27829 TextKit & UnsetLineSpacing();
27845 TextKit & UnsetSizeTolerance();
27883 bool ShowPosition(
Point & out_position)
const;
27888 bool ShowText(
UTF8 & out_string)
const;
27900 bool ShowModellingMatrix(
MatrixKit & out_matrix)
const;
27912 bool ShowBold(
bool & out_state)
const;
27917 bool ShowItalic(
bool & out_state)
const;
27922 bool ShowOverline(
bool & out_state)
const;
27927 bool ShowStrikethrough(
bool & out_state)
const;
27932 bool ShowUnderline(
bool & out_state)
const;
27937 bool ShowSlant(
float & out_angle)
const;
27942 bool ShowLineSpacing(
float & out_multiplier)
const;
27948 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
27955 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
27981 bool ShowFont(
UTF8 & out_name)
const;
28004 bool ShowPath(
Vector & out_path)
const;
28009 bool ShowSpacing(
float & out_multiplier)
const;
28019 TextKit & EditTextByInsertion(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
28027 TextKit & EditTextByDeletion(
size_t in_row,
size_t in_column,
size_t in_count);
28035 TextKit & EditTextByReplacement(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
28045 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;
28059 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);
28074 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);
28081 TextKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
28091 TextKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
28097 TextKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
28102 TextKit & UnsetUserData(intptr_t in_index);
28108 TextKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
28113 TextKit & UnsetUserData(IntPtrTArray
const & in_indices);
28117 TextKit & UnsetAllUserData();
28120 size_t ShowUserDataCount()
const;
28125 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
28131 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
28137 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
28178 void Consume(
TextKit & in_kit);
28182 void Set(
TextKit const & in_kit);
28186 void Show(
TextKit & out_kit)
const;
28205 TextKey & SetText(
char const * in_string);
28215 TextKey & SetColorByIndex(
float in_index);
28232 TextKey & SetBold(
bool in_state);
28237 TextKey & SetItalic(
bool in_state);
28242 TextKey & SetOverline(
bool in_state);
28247 TextKey & SetStrikethrough(
bool in_state);
28252 TextKey & SetUnderline(
bool in_state);
28258 TextKey & SetSlant(
float in_angle);
28264 TextKey & SetLineSpacing(
float in_multiplier);
28276 TextKey & SetRotation(
float in_angle);
28336 TextKey & SetFont(
char const * in_name);
28373 TextKey & SetSpacing(
float in_multiplier);
28387 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);
28402 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);
28411 TextKey & UnsetModellingMatrix();
28431 TextKey & UnsetStrikethrough();
28443 TextKey & UnsetLineSpacing();
28459 TextKey & UnsetSizeTolerance();
28501 bool ShowPosition(
Point & out_position)
const;
28506 bool ShowText(
UTF8 & out_string)
const;
28518 bool ShowModellingMatrix(
MatrixKit & out_matrix)
const;
28530 bool ShowBold(
bool & out_state)
const;
28535 bool ShowItalic(
bool & out_state)
const;
28540 bool ShowOverline(
bool & out_state)
const;
28545 bool ShowStrikethrough(
bool & out_state)
const;
28550 bool ShowUnderline(
bool & out_state)
const;
28555 bool ShowSlant(
float & out_angle)
const;
28560 bool ShowLineSpacing(
float & out_multiplier)
const;
28566 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
28573 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
28599 bool ShowFont(
UTF8 & out_name)
const;
28622 bool ShowPath(
Vector & out_path)
const;
28627 bool ShowSpacing(
float & out_multiplier)
const;
28637 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;
28647 TextKey & EditTextByInsertion(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
28655 TextKey & EditTextByDeletion(
size_t in_row,
size_t in_column,
size_t in_count);
28663 TextKey & EditTextByReplacement(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
28685 HPS::Type
ObjectType()
const {
return HPS::Type::ShellOptimizationOptionsKit; };
28711 bool Empty()
const;
28782 bool ShowNormalTolerance(
float & out_normal_tolerance)
const;
28793 bool ShowOrphanElimination(
bool & out_orphan_elimination)
const;
28828 HPS::Type
ObjectType()
const {
return HPS::Type::ShellRelationOptionsKit; };
28854 bool Empty()
const;
28918 bool ShowTolerance(
float & out_tolerance)
const;
28928 bool ShowTreeContext(
TreeContext & out_tree_context)
const;
28933 bool ShowNearestFaceCalculation(
bool & out_state)
const;
28959 HPS::Type
ObjectType()
const {
return HPS::Type::ShellRelationResultsKit; };
28980 bool Empty()
const;
29001 bool ShowRelations(ShellRelationArray & out_results)
const;
29006 bool ShowNearestFaces(SizeTArray & out_faces)
const;
29011 bool ShowDistances(FloatArray & out_distances)
const;
29046 void Set(
ShellKit const & in_kit);
29050 void Show(
ShellKit & out_kit)
const;
29054 size_t GetPointCount()
const;
29058 size_t GetFaceCount()
const;
29067 bool Empty()
const;
29072 bool Equals(
ShellKit const & in_kit)
const;
29077 bool operator==(
ShellKit const & in_kit)
const;
29082 bool operator!=(
ShellKit const & in_kit)
const;
29090 ShellKit & SetPriority(
int in_priority);
29099 bool ShowPriority(
int & out_priority)
const;
29106 ShellKit & SetPoints(PointArray
const & in_points);
29112 ShellKit & SetPoints(
size_t in_count,
Point const in_points []);
29117 ShellKit & SetFacelist(IntArray
const & in_facelist);
29123 ShellKit & SetFacelist(
size_t in_count,
int const in_facelist []);
29128 ShellKit & SetTristrips(IntArray
const & in_tristrips);
29134 ShellKit & SetTristrips(
size_t in_count,
int const in_tristrips []);
29155 bool ShowPoints(PointArray & out_points)
const;
29162 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
29168 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
29175 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
29180 bool ShowFacelist(IntArray & out_facelist)
const;
29185 bool ShowTristrips(IntArray & out_tristrips)
const;
29365 ShellKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
29371 ShellKit & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
29378 ShellKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
29385 ShellKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
29391 ShellKit & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
29398 ShellKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
29404 ShellKit & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
29413 ShellKit & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
29421 ShellKit & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
29431 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);
29440 ShellKit & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
29448 ShellKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
29454 ShellKit & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
29461 ShellKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
29468 ShellKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
29474 ShellKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
29481 ShellKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
29487 ShellKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
29492 ShellKit & UnsetMaterialMapping();
29503 ShellKit & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
29508 ShellKit & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
29538 ShellKit & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
29543 ShellKit & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
29548 ShellKit & UnsetVertexParameters();
29554 ShellKit & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
29559 ShellKit & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
29564 ShellKit & UnsetVertexVisibilities();
29570 ShellKit & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
29575 ShellKit & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
29580 ShellKit & UnsetVertexEverything();
29602 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Shell::Component in_applied_to, MaterialTypeArray & out_types,
29603 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
29619 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Shell::Component in_applied_to, MaterialTypeArray & out_types,
29620 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
29631 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
29641 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
29653 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
29664 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
29675 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
29686 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
29697 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
29707 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
29716 ShellKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
29722 ShellKit & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
29729 ShellKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
29736 ShellKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
29742 ShellKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
29749 ShellKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
29755 ShellKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
29763 ShellKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
29769 ShellKit & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
29776 ShellKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
29783 ShellKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
29789 ShellKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
29796 ShellKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
29802 ShellKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
29810 ShellKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
29816 ShellKit & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
29823 ShellKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
29830 ShellKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
29836 ShellKit & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
29843 ShellKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
29849 ShellKit & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
29857 ShellKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
29863 ShellKit & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
29870 ShellKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
29877 ShellKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
29883 ShellKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
29890 ShellKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
29896 ShellKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
29907 ShellKit & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
29912 ShellKit & UnsetFaceColorsByList(SizeTArray
const & in_faces);
29923 ShellKit & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
29928 ShellKit & UnsetFaceNormalsByList(SizeTArray
const & in_vertices);
29933 ShellKit & UnsetFaceVisibilities();
29939 ShellKit & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
29944 ShellKit & UnsetFaceVisibilitiesByList(SizeTArray
const & in_vertices);
29961 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
29973 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
29984 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
29994 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
30005 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
30015 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
30024 ShellKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
30031 ShellKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
30038 ShellKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
30045 ShellKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
30052 ShellKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
30061 ShellKit & EditFacelistByInsertion(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
30068 ShellKit & EditFacelistByInsertion(
size_t in_offset, IntArray
const & in_facelist);
30075 ShellKit & EditFacelistByDeletion(
size_t in_offset,
size_t in_count);
30085 ShellKit & EditFacelistByReplacement(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
30094 ShellKit & EditFacelistByReplacement(
size_t in_offset, IntArray
const & in_facelist);
30123 ShellKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
30129 ShellKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
30135 ShellKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
30140 ShellKit & UnsetUserData(intptr_t in_index);
30146 ShellKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
30151 ShellKit & UnsetUserData(IntPtrTArray
const & in_indices);
30158 size_t ShowUserDataCount()
const;
30163 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
30169 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
30175 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
30222 void Set(
ShellKit const & in_kit);
30226 void Show(
ShellKit & out_kit)
const;
30230 size_t GetPointCount()
const;
30234 size_t GetFaceCount()
const;
30240 ShellKey & SetPoints(PointArray
const & in_points);
30246 ShellKey & SetPoints(
size_t in_count,
Point const in_points []);
30251 ShellKey & SetFacelist(IntArray
const & in_facelist);
30257 ShellKey & SetFacelist(
size_t in_count,
int const in_facelist []);
30262 ShellKey & SetTristrips(IntArray
const & in_tristrips);
30268 ShellKey & SetTristrips(
size_t in_count,
int const in_tristrips []);
30290 ShellKey & UnsetMaterialMapping();
30299 bool ShowPoints(PointArray & out_points)
const;
30306 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
30312 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
30319 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
30324 bool ShowFacelist(IntArray & out_facelist)
const;
30329 bool ShowTristrips(IntArray & out_tristrips)
const;
30510 ShellKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
30517 ShellKey & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
30524 ShellKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
30531 ShellKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
30537 ShellKey & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
30544 ShellKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
30550 ShellKey & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
30560 ShellKey & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
30568 ShellKey & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
30578 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);
30587 ShellKey & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
30595 ShellKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
30602 ShellKey & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
30609 ShellKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
30616 ShellKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
30622 ShellKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
30629 ShellKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
30635 ShellKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
30646 ShellKey & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
30651 ShellKey & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
30681 ShellKey & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
30686 ShellKey & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
30691 ShellKey & UnsetVertexParameters();
30697 ShellKey & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
30702 ShellKey & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
30707 ShellKey & UnsetVertexVisibilities();
30713 ShellKey & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
30718 ShellKey & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
30723 ShellKey & UnsetVertexEverything();
30739 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Shell::Component in_applied_to, MaterialTypeArray & out_types,
30740 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
30756 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Shell::Component in_applied_to, MaterialTypeArray & out_types,
30757 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
30768 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
30778 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
30790 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
30801 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
30812 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
30823 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
30834 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
30844 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
30852 ShellKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
30859 ShellKey & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
30866 ShellKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
30873 ShellKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
30879 ShellKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
30886 ShellKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
30892 ShellKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
30900 ShellKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
30907 ShellKey & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
30914 ShellKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
30921 ShellKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
30927 ShellKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
30934 ShellKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
30940 ShellKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
30948 ShellKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
30955 ShellKey & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
30962 ShellKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
30969 ShellKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
30975 ShellKey & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
30982 ShellKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
30988 ShellKey & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
30996 ShellKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
31003 ShellKey & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
31010 ShellKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
31017 ShellKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
31023 ShellKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
31030 ShellKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
31036 ShellKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
31047 ShellKey & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
31052 ShellKey & UnsetFaceColorsByList(SizeTArray
const & in_vertices);
31063 ShellKey & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
31068 ShellKey & UnsetFaceNormalsByList(SizeTArray
const & in_vertices);
31073 ShellKey & UnsetFaceVisibilities();
31079 ShellKey & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
31084 ShellKey & UnsetFaceVisibilitiesByList(SizeTArray
const & in_vertices);
31101 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
31113 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
31124 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
31134 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
31142 bool ShowNetFaceNormalsByRange(
size_t in_start,
size_t in_count, VectorArray & out_normals)
const;
31150 bool ShowNetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray & out_normals)
const;
31161 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
31171 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
31180 ShellKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
31187 ShellKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
31194 ShellKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
31201 ShellKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
31208 ShellKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
31217 ShellKey & EditFacelistByInsertion(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
31224 ShellKey & EditFacelistByInsertion(
size_t in_offset, IntArray
const & in_facelist);
31231 ShellKey & EditFacelistByDeletion(
size_t in_offset,
size_t in_count);
31241 ShellKey & EditFacelistByReplacement(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
31250 ShellKey & EditFacelistByReplacement(
size_t in_offset, IntArray
const & in_facelist);
31304 void Consume(
MeshKit & in_kit);
31308 void Set(
MeshKit const & in_kit);
31312 void Show(
MeshKit & out_kit)
const;
31321 bool Empty()
const;
31326 bool Equals(
MeshKit const & in_kit)
const;
31331 bool operator==(
MeshKit const & in_kit)
const;
31336 bool operator!=(
MeshKit const & in_kit)
const;
31340 size_t GetPointCount()
const;
31348 MeshKit & SetPriority(
int in_priority);
31357 bool ShowPriority(
int & out_priority)
const;
31362 MeshKit & SetPoints(PointArray
const & in_points);
31368 MeshKit & SetPoints(
size_t in_count,
Point const in_points []);
31375 MeshKit & SetPoints(
size_t in_rows,
size_t in_columns, HPS::PointArray
const & in_points);
31383 MeshKit & SetPoints(
size_t in_rows,
size_t in_columns,
size_t in_count,
Point const in_points []);
31388 MeshKit & SetRows(
size_t in_rows);
31393 MeshKit & SetColumns(
size_t in_columns);
31414 bool ShowPoints(PointArray & out_points)
const;
31421 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
31427 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
31434 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
31441 bool ShowPoints(
size_t & out_rows,
size_t & out_columns, PointArray & out_points)
const;
31446 bool ShowRows(
size_t & out_rows)
const;
31451 bool ShowColumns(
size_t & out_columns)
const;
31631 MeshKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
31637 MeshKit & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
31644 MeshKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
31651 MeshKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
31657 MeshKit & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
31664 MeshKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
31670 MeshKit & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
31679 MeshKit & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
31687 MeshKit & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
31697 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);
31706 MeshKit & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
31714 MeshKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
31720 MeshKit & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
31727 MeshKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
31734 MeshKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
31740 MeshKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
31747 MeshKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
31753 MeshKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
31758 MeshKit & UnsetMaterialMapping();
31762 MeshKit & UnsetVertexColors();
31768 MeshKit & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
31773 MeshKit & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
31797 MeshKit & UnsetVertexNormals();
31803 MeshKit & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
31808 MeshKit & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
31813 MeshKit & UnsetVertexParameters();
31819 MeshKit & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
31824 MeshKit & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
31829 MeshKit & UnsetVertexVisibilities();
31835 MeshKit & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
31840 MeshKit & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
31845 MeshKit & UnsetVertexEverything();
31866 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Mesh::Component in_applied_to, MaterialTypeArray & out_types,
31867 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
31883 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Mesh::Component in_applied_to, MaterialTypeArray & out_types,
31884 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
31895 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
31905 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
31917 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
31928 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
31939 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
31950 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
31961 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
31971 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
31979 MeshKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
31985 MeshKit & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
31992 MeshKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
31999 MeshKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
32005 MeshKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
32012 MeshKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
32018 MeshKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
32026 MeshKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
32032 MeshKit & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
32039 MeshKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
32046 MeshKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
32052 MeshKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
32059 MeshKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
32065 MeshKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
32073 MeshKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
32079 MeshKit & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
32086 MeshKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
32093 MeshKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
32099 MeshKit & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
32106 MeshKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
32112 MeshKit & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
32120 MeshKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
32126 MeshKit & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
32133 MeshKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
32140 MeshKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
32146 MeshKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
32153 MeshKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
32159 MeshKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
32170 MeshKit & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
32175 MeshKit & UnsetFaceColorsByList(SizeTArray
const & in_vertices);
32180 MeshKit & UnsetFaceNormals();
32186 MeshKit & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
32191 MeshKit & UnsetFaceNormalsByList(SizeTArray
const & in_vertices);
32196 MeshKit & UnsetFaceVisibilities();
32202 MeshKit & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
32207 MeshKit & UnsetFaceVisibilitiesByList(SizeTArray
const & in_vertices);
32212 MeshKit & UnsetFaceEverything();
32224 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
32236 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
32247 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
32257 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
32268 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32278 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32285 MeshKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
32291 MeshKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
32297 MeshKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
32302 MeshKit & UnsetUserData(intptr_t in_index);
32308 MeshKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
32313 MeshKit & UnsetUserData(IntPtrTArray
const & in_indices);
32317 MeshKit & UnsetAllUserData();
32320 size_t ShowUserDataCount()
const;
32325 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
32331 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
32337 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
32381 void Consume(
MeshKit & in_kit);
32385 void Set(
MeshKit const & in_kit);
32389 void Show(
MeshKit & out_kit)
const;
32393 size_t GetPointCount()
const;
32400 MeshKey & SetPoints(
size_t in_rows,
size_t in_columns, PointArray
const & in_points);
32408 MeshKey & SetPoints(
size_t in_rows,
size_t in_columns,
size_t in_count,
Point const in_points []);
32413 bool ShowPoints(PointArray & out_points)
const;
32420 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
32426 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
32433 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
32440 bool ShowPoints(
size_t & out_rows,
size_t & out_columns, PointArray & out_points)
const;
32445 bool ShowRows(
size_t & out_rows)
const;
32450 bool ShowColumns(
size_t & out_columns)
const;
32461 MeshKey & UnsetMaterialMapping();
32642 MeshKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
32649 MeshKey & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
32656 MeshKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
32663 MeshKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
32669 MeshKey & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
32676 MeshKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
32682 MeshKey & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
32692 MeshKey & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
32700 MeshKey & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
32710 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);
32719 MeshKey & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
32727 MeshKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
32734 MeshKey & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
32741 MeshKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
32748 MeshKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
32754 MeshKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
32761 MeshKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
32767 MeshKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
32772 MeshKey & UnsetVertexColors();
32778 MeshKey & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
32783 MeshKey & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
32807 MeshKey & UnsetVertexNormals();
32813 MeshKey & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
32818 MeshKey & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
32823 MeshKey & UnsetVertexParameters();
32829 MeshKey & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
32834 MeshKey & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
32839 MeshKey & UnsetVertexVisibilities();
32845 MeshKey & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
32850 MeshKey & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
32855 MeshKey & UnsetVertexEverything();
32875 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Mesh::Component in_applied_to, MaterialTypeArray & out_types,
32876 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
32892 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Mesh::Component in_applied_to, MaterialTypeArray & out_types,
32893 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
32904 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
32914 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
32926 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
32937 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
32948 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
32959 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
32970 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32980 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32988 MeshKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
32995 MeshKey & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
33002 MeshKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
33009 MeshKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
33015 MeshKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
33022 MeshKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
33028 MeshKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
33036 MeshKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
33043 MeshKey & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
33050 MeshKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
33057 MeshKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
33063 MeshKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
33070 MeshKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
33076 MeshKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
33084 MeshKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
33091 MeshKey & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
33098 MeshKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
33105 MeshKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
33111 MeshKey & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
33118 MeshKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
33124 MeshKey & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
33132 MeshKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
33139 MeshKey & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
33146 MeshKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
33153 MeshKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
33159 MeshKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
33166 MeshKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
33172 MeshKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
33183 MeshKey & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
33188 MeshKey & UnsetFaceColorsByList(SizeTArray
const & in_faces);
33193 MeshKey & UnsetFaceNormals();
33199 MeshKey & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
33204 MeshKey & UnsetFaceNormalsByList(SizeTArray
const & in_faces);
33209 MeshKey & UnsetFaceVisibilities();
33215 MeshKey & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
33220 MeshKey & UnsetFaceVisibilitiesByList(SizeTArray
const & in_faces);
33225 MeshKey & UnsetFaceEverything();
33237 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
33249 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
33260 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
33270 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
33281 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
33291 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
33301 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[]);
33310 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);
33360 bool Empty()
const;
33365 bool Equals(
PolygonKit const & in_kit)
const;
33370 bool operator==(
PolygonKit const & in_kit)
const;
33375 bool operator!=(
PolygonKit const & in_kit)
const;
33379 size_t GetPointCount()
const;
33396 bool ShowPriority(
int & out_priority)
const;
33402 PolygonKit & SetPoints(PointArray
const & in_points);
33421 bool ShowPoints(PointArray & out_points)
const;
33428 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
33434 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
33441 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
33448 PolygonKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
33454 PolygonKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
33460 PolygonKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
33467 PolygonKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
33473 PolygonKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
33480 PolygonKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
33486 PolygonKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
33492 PolygonKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
33497 PolygonKit & UnsetUserData(intptr_t in_index);
33503 PolygonKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
33508 PolygonKit & UnsetUserData(IntPtrTArray
const & in_indices);
33515 size_t ShowUserDataCount()
const;
33520 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
33526 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
33532 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
33587 size_t GetPointCount()
const;
33592 PolygonKey & SetPoints(PointArray
const & in_points);
33603 bool ShowPoints(PointArray & out_points)
const;
33610 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
33616 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
33623 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
33630 PolygonKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
33636 PolygonKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
33642 PolygonKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
33649 PolygonKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
33655 PolygonKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
33682 void Consume(
GridKit & in_kit);
33686 void Set(
GridKit const & in_kit);
33690 void Show(
GridKit & out_kit)
const;
33704 bool Empty()
const;
33709 bool Equals(
GridKit const & in_kit)
const;
33714 bool operator==(
GridKit const & in_kit)
const;
33719 bool operator!=(
GridKit const & in_kit)
const;
33728 GridKit & SetPriority(
int in_priority);
33746 GridKit & SetFirstPoint(
Point const & in_first_point);
33755 GridKit & SetSecondPoint(
Point const & in_second_point);
33770 GridKit & SetFirstCount(
int in_first_count);
33782 GridKit & SetSecondCount(
int in_second_count);
33803 GridKit & UnsetSecondPoint();
33811 GridKit & UnsetSecondCount();
33821 bool ShowPriority(
int & out_priority)
const;
33831 bool ShowOrigin(
Point & out_origin)
const;
33836 bool ShowFirstPoint(
Point & out_first_point)
const;
33841 bool ShowSecondPoint(
Point & out_second_point)
const;
33846 bool ShowFirstCount(
int & out_first_count)
const;
33851 bool ShowSecondCount(
int & out_second_count)
const;
33858 GridKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
33864 GridKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
33870 GridKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
33875 GridKit & UnsetUserData(intptr_t in_index);
33881 GridKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
33886 GridKit & UnsetUserData(IntPtrTArray
const & in_indices);
33890 GridKit & UnsetAllUserData();
33893 size_t ShowUserDataCount()
const;
33898 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
33904 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
33910 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
33951 void Consume(
GridKit & in_kit);
33955 void Set(
GridKit const & in_kit);
33959 void Show(
GridKit & out_kit)
const;
33978 GridKey & SetFirstPoint(
Point const & in_first_point);
33987 GridKey & SetSecondPoint(
Point const & in_second_point);
34002 GridKey & SetFirstCount(
int in_first_count);
34014 GridKey & SetSecondCount(
int in_second_count);
34026 bool ShowOrigin(
Point & out_origin)
const;
34031 bool ShowFirstPoint(
Point & out_first_point)
const;
34036 bool ShowSecondPoint(
Point & out_second_point)
const;
34041 bool ShowFirstCount(
int & out_first_count)
const;
34046 bool ShowSecondCount(
int & out_second_count)
const;
34122 bool ShowPriority(
int & out_priority)
const;
34127 bool ShowCondition(
Condition & out_condition)
const;
34149 IncludeKey & SetFilter(AttributeLockTypeArray
const & in_types);
34171 IncludeKey & UnsetFilter(AttributeLockTypeArray
const & in_types);
34178 bool ShowFilter(AttributeLockTypeArray & out_types)
const;
34253 bool ShowCondition(
Condition & out_condition)
const;
34276 StyleKey & SetFilter(AttributeLockTypeArray
const & in_types);
34298 StyleKey & UnsetFilter(AttributeLockTypeArray
const & in_types);
34305 bool ShowFilter(AttributeLockTypeArray & out_types)
const;
34356 Key GetTarget()
const;
34361 size_t ShowTargets(
bool masked=
true)
const;
34367 size_t ShowTargets(KeyArray & out_keys,
bool masked=
true)
const;
34372 size_t ShowGeometryMask()
const;
34378 size_t ShowGeometryMask(SearchTypeArray & out_geometry_types)
const;
34383 ReferenceKey & SetGeometryMask(SearchTypeArray
const & in_geometry_types);
34391 void SetModellingMatrix(
MatrixKit const & in_kit);
34405 void UnsetModellingMatrix();
34415 bool ShowModellingMatrix(
MatrixKit & out_kit)
const;
34420 bool ShowCondition(
Condition & out_condition)
const;
34459 HPS::Type
ObjectType()
const {
return HPS::Type::StandAloneWindowOptionsKit; };
34481 bool Empty()
const;
34567 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
34572 bool ShowTitle(
UTF8 & out_window_name)
const;
34577 bool ShowSubscreen(
Rectangle & out_subscreen)
const;
34587 bool ShowFullScreen(
bool & out_state)
const;
34621 HPS::Type
ObjectType()
const {
return HPS::Type::StandAloneWindowOptionsControl; };
34653 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
34658 bool ShowTitle(
UTF8 & out_window_name)
const;
34663 bool ShowSubscreen(
Rectangle & out_subscreen)
const;
34673 bool ShowFullScreen(
bool & out_state)
const;
34707 HPS::Type
ObjectType()
const {
return HPS::Type::OffScreenWindowOptionsKit; };
34729 bool Empty()
const;
34813 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
34818 bool ShowHardwareResident(
bool & out_state)
const;
34830 bool ShowOpacity(
bool & out_state,
float & out_opacity)
const;
34858 HPS::Type
ObjectType()
const {
return HPS::Type::ApplicationWindowOptionsKit; };
34880 bool Empty()
const;
34947 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
34952 bool ShowPlatformData(PlatformData & out_platform_data)
const;
34957 bool ShowFramebufferRetention(
bool & out_retain)
const;
34988 HPS::Type
ObjectType()
const {
return HPS::Type::ApplicationWindowOptionsControl; };
34999 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
35009 bool ShowWindowHandle(WindowHandle & out_window_handle)
const;
35014 bool ShowPlatformData(PlatformData & out_platform_data)
const;
35019 bool ShowFramebufferRetention(
bool & out_retain)
const;
35070 HPS::Type
ObjectType()
const {
return HPS::Type::StandAloneWindowKey; };
35121 HPS::Type
ObjectType()
const {
return HPS::Type::ApplicationWindowKey; };
35198 void SetIndexedColor(byte in_index);
35201 void SetNormalColor();
35205 void SetExplicitColor(
RGBAColor const & in_color);
35259 HPS::Type
ObjectType()
const {
return HPS::Type::LineGlyphElement; };
35263 void SetPoints(GlyphPointArray
const & in_points);
35268 void SetPoints(
size_t in_count,
GlyphPoint const in_points[]);
35273 bool ShowPoints(GlyphPointArray & out_points)
const;
35318 bool ShowPoint(
GlyphPoint & out_point)
const;
35356 HPS::Type
ObjectType()
const {
return HPS::Type::EllipseGlyphElement; };
35360 void SetLowerLeft(
GlyphPoint const & in_point);
35364 void SetUpperRight(
GlyphPoint const & in_point);
35374 bool ShowLowerLeft(
GlyphPoint & out_point)
const;
35379 bool ShowUpperRight(
GlyphPoint & out_point)
const;
35418 HPS::Type
ObjectType()
const {
return HPS::Type::CircularArcGlyphElement; };
35422 void SetStartPoint(
GlyphPoint const & in_point);
35426 void SetIntermediatePoint(
GlyphPoint const & in_point);
35430 void SetEndPoint(
GlyphPoint const & in_point);
35441 bool ShowStartPoint(
GlyphPoint & out_point)
const;
35446 bool ShowIntermediatePoint(
GlyphPoint & out_point)
const;
35451 bool ShowEndPoint(
GlyphPoint & out_point)
const;
35491 HPS::Type
ObjectType()
const {
return HPS::Type::InfiniteLineGlyphElement; };
35495 void SetFirstPoint(
GlyphPoint const & in_point);
35499 void SetSecondPoint(
GlyphPoint const & in_point);
35513 bool ShowFirstPoint(
GlyphPoint & out_point)
const;
35518 bool ShowSecondPoint(
GlyphPoint & out_point)
const;
35560 void Set(
GlyphKit const & in_kit);
35564 void Show(
GlyphKit & out_kit)
const;
35573 bool Empty()
const;
35578 bool Equals(
GlyphKit const & in_kit)
const;
35583 bool operator==(
GlyphKit const & in_kit)
const;
35588 bool operator!=(
GlyphKit const & in_kit)
const;
35593 GlyphKit & SetRadius(sbyte in_radius);
35604 GlyphKit & SetElements(GlyphElementArray
const & in_def);
35631 bool ShowRadius(sbyte & out_radius)
const;
35636 bool ShowOffset(
GlyphPoint & out_point)
const;
35641 bool ShowElements(GlyphElementArray & out_def)
const;
35673 HPS::Type
ObjectType()
const {
return HPS::Type::LinePatternOptionsKit; };
35690 bool Empty()
const;
35816 HPS::Type
ObjectType()
const {
return HPS::Type::LinePatternElement; };
35888 HPS::Type
ObjectType()
const {
return HPS::Type::SolidLinePatternElement; };
35893 void SetColor(
RGBAColor const & in_color);
35898 void SetMaterialByIndex(
float in_material_index);
35943 HPS::Type
ObjectType()
const {
return HPS::Type::BlankLinePatternElement; };
35981 HPS::Type
ObjectType()
const {
return HPS::Type::GlyphLinePatternElement; };
35985 void SetSource(
char const * in_source);
35998 void SetMirror(
bool in_state);
36002 void SetFixed(
bool in_state);
36006 void SetRotation(
float in_degrees);
36011 bool ShowSource(
UTF8 & out_source)
const;
36027 bool ShowMirror(
bool & out_state)
const;
36032 bool ShowFixed(
bool & out_state)
const;
36037 bool ShowRotation(
float & out_degrees)
const;
36063 HPS::Type
ObjectType()
const {
return HPS::Type::LinePatternParallelKit; };
36080 bool Empty()
const;
36220 bool ShowBody(LinePatternElementArray & out_elements)
const;
36225 bool ShowAbsoluteLength(
bool & out_state)
const;
36230 bool ShowAbsoluteWeight(
bool & out_state)
const;
36254 bool ShowContinuous(
bool & out_state)
const;
36303 bool Empty()
const;
36323 LinePatternKit & SetParallels(LinePatternParallelKitArray
const & in_parallels);
36351 bool ShowParallels(LinePatternParallelKitArray & out_parallels)
const;
36409 virtual void Assign(
Definition const & in_that);
36414 bool Equals(
Definition const & in_that)
const;
36419 bool operator==(
Definition const & in_that)
const;
36424 bool operator!=(
Definition const & in_that)
const;
36570 ShaderDefinition DefineShader(
char const * in_name, ShaderKit
const & in_source);
36593 PortfolioKey & UndefineNamedStyle(
char const * in_name);
36598 PortfolioKey & UndefineMaterialPalette(
char const * in_name);
36608 PortfolioKey & UndefineLinePattern(
char const * in_name);
36721 ShaderDefinition ImportShader(ShaderDefinition
const & in_definition);
36726 size_t GetDefinitionCount()
const;
36729 size_t GetTextureDefinitionCount()
const;
36732 size_t GetCubeMapDefinitionCount()
const;
36735 size_t GetImageDefinitionCount()
const;
36738 size_t GetNamedStyleDefinitionCount()
const;
36741 size_t GetMaterialPaletteDefinitionCount()
const;
36744 size_t GetGlyphDefinitionCount()
const;
36747 size_t GetLinePatternDefinitionCount()
const;
36750 size_t GetShaderDefinitionCount()
const;
36756 bool ShowTextureDefinition(
char const * in_name,
TextureDefinition & out_found)
const;
36761 bool ShowAllTextureDefinitions(TextureDefinitionArray & out_definitions)
const;
36767 bool ShowCubeMapDefinition(
char const * in_name,
CubeMapDefinition & out_found)
const;
36772 bool ShowAllCubeMapDefinitions(CubeMapDefinitionArray & out_definitions)
const;
36778 bool ShowImageDefinition(
char const * in_name,
ImageDefinition & out_found)
const;
36783 bool ShowAllImageDefinitions(ImageDefinitionArray & out_definitions)
const;
36794 bool ShowAllNamedStyleDefinitions(NamedStyleDefinitionArray & out_definitions)
const;
36805 bool ShowAllMaterialPaletteDefinitions(MaterialPaletteDefinitionArray & out_definitions)
const;
36811 bool ShowGlyphDefinition(
char const * in_name,
GlyphDefinition & out_found)
const;
36816 bool ShowAllGlyphDefinitions(GlyphDefinitionArray & out_definitions)
const;
36827 bool ShowAllLinePatternDefinitions(LinePatternDefinitionArray & out_definitions)
const;
36833 bool ShowShaderDefinition(
char const * in_name, ShaderDefinition & out_found)
const;
36838 bool ShowAllShaderDefinitions(ShaderDefinitionArray & out_definitions)
const;
36842 void MoveTo(
SegmentKey const & in_new_owner);
36888 void Set(
GlyphKit const & in_kit);
36892 void Show(
GlyphKit & out_kit)
const;
36930 HPS::Type
ObjectType()
const {
return HPS::Type::TextureDefinition; };
36975 HPS::Type
ObjectType()
const {
return HPS::Type::TextureOptionsKit; };
36997 bool Empty()
const;
37103 bool ShowDecal(
bool & out_state)
const;
37108 bool ShowDownSampling(
bool & out_state)
const;
37113 bool ShowModulation(
bool & out_state)
const;
37118 bool ShowParameterOffset(
size_t & out_offset)
const;
37143 bool ShowTransformMatrix(
MatrixKit & out_transform)
const;
37192 HPS::Type
ObjectType()
const {
return HPS::Type::ImageExportOptionsKit; };
37214 bool Empty()
const;
37235 ExportOptionsKit & SetSize(
unsigned int in_width,
unsigned int in_height);
37259 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
37290 HPS::Type
ObjectType()
const {
return HPS::Type::ImageImportOptionsKit; };
37307 bool Empty()
const;
37330 ImportOptionsKit & SetSize(
unsigned int in_width,
unsigned int in_height);
37373 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
37383 bool ShowDownSampling(
bool & out_state)
const;
37388 bool ShowCompressionQuality(
float & out_quality)
const;
37417 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);
37423 static void Export(
char const * in_file_name,
HPS::ImageKit const & in_image_kit);
37469 void Set(
ImageKit const & in_kit);
37473 void Show(
ImageKit & out_kit)
const;
37482 bool Empty()
const;
37487 bool Equals(
ImageKit const & in_kit)
const;
37492 bool operator==(
ImageKit const & in_kit)
const;
37497 bool operator!=(
ImageKit const & in_kit)
const;
37512 ImageKit & SetSize(
unsigned int in_width,
unsigned int in_height);
37517 ImageKit & SetData(ByteArray
const & in_image_data);
37523 ImageKit & SetData(
size_t in_byte_count, byte
const in_image_data []);
37533 ImageKit & SetDownSampling(
bool in_state);
37538 ImageKit & SetCompressionQuality(
float in_quality);
37558 ImageKit & UnsetCompressionQuality();
37568 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
37573 bool ShowData(ByteArray & out_image_data)
const;
37583 bool ShowDownSampling(
bool & out_state)
const;
37588 bool ShowCompressionQuality(
float & out_quality)
const;
37620 HPS::Type
ObjectType()
const {
return HPS::Type::OffScreenWindowOptionsControl; };
37648 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
37654 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
37666 bool ShowImage(ByteArray & out_bytes)
const;
37671 bool ShowHardwareResident(
bool & out_state)
const;
37677 bool ShowOpacity(
bool & out_state,
float & out_opacity)
const;
37722 HPS::Type
ObjectType()
const {
return HPS::Type::OffScreenWindowKey; };
37779 void Set(
ImageKit const & in_kit);
37783 void Show(
ImageKit & out_kit)
const;
37820 HPS::Type
ObjectType()
const {
return HPS::Type::CubeMapDefinition; };
37847 void ShowSource(ImageDefinitionArray & out_image_sources)
const;
37893 HPS::Type
ObjectType()
const {
return HPS::Type::NamedStyleDefinition; };
37936 HPS::Type
ObjectType()
const {
return HPS::Type::MaterialPaletteDefinition; };
37940 void Set(MaterialKitArray
const & in_source);
37945 void Set(
size_t in_count,
MaterialKit const in_source []);
37949 void Show(MaterialKitArray & out_source)
const;
37988 HPS::Type
ObjectType()
const {
return HPS::Type::LinePatternDefinition; };
38002 class HPS_API Shader
38007 enum class Parameterization
38012 PhysicalReflection,
38034 class HPS_API ImportOptionsKit :
public Object
38038 ImportOptionsKit();
38042 ImportOptionsKit(ImportOptionsKit
const & in_kit);
38047 ImportOptionsKit(ImportOptionsKit && in_that);
38052 ImportOptionsKit & operator=(ImportOptionsKit && in_that);
38054 virtual ~ImportOptionsKit();
38056 HPS::Type ObjectType()
const {
return HPS::Type::ShaderImportOptionsKit; };
38060 void Set(ImportOptionsKit
const & in_kit);
38064 void Show(ImportOptionsKit & out_kit)
const;
38069 ImportOptionsKit & operator=(ImportOptionsKit
const & in_kit);
38073 bool Empty()
const;
38078 bool Equals(ImportOptionsKit
const & in_kit)
const;
38083 bool operator==(ImportOptionsKit
const & in_kit)
const;
38088 bool operator!=(ImportOptionsKit
const & in_kit)
const;
38096 ImportOptionsKit & SetMultitexture(
bool in_state);
38101 ImportOptionsKit & SetParameterizationSource(Parameterization in_source);
38106 ImportOptionsKit & SetTransformMatrix(MatrixKit
const & in_transform);
38111 ImportOptionsKit & UnsetMultitexture();
38115 ImportOptionsKit & UnsetParameterizationSource();
38119 ImportOptionsKit & UnsetTransformMatrix();
38123 ImportOptionsKit & UnsetEverything();
38130 bool ShowMultitexture(
bool & out_state)
const;
38135 bool ShowParameterizationSource(Parameterization & out_source)
const;
38140 bool ShowTransformMatrix(MatrixKit & out_transform)
const;
38152 static ShaderKit Import(
char const * in_file_name, ImportOptionsKit
const & in_options);
38166 class HPS_API ShaderKit :
public Object
38174 ShaderKit(ShaderKit
const & in_kit);
38179 ShaderKit(ShaderKit && in_that);
38184 ShaderKit & operator=(ShaderKit && in_that);
38186 virtual ~ShaderKit();
38188 HPS::Type ObjectType()
const {
return HPS::Type::ShaderKit; };
38192 void Set(ShaderKit
const & in_kit);
38196 void Show(ShaderKit & out_kit)
const;
38201 ShaderKit & operator=(ShaderKit
const & in_kit);
38205 bool Empty()
const;
38210 bool Equals(ShaderKit
const & in_kit)
const;
38215 bool operator==(ShaderKit
const & in_kit)
const;
38220 bool operator!=(ShaderKit
const & in_kit)
const;
38225 ShaderKit & SetSource(
char const * in_source);
38233 ShaderKit & SetMultitexture(
bool in_state);
38238 ShaderKit & SetParameterizationSource(Shader::Parameterization in_source);
38243 ShaderKit & SetTransformMatrix(MatrixKit
const & in_transform);
38247 ShaderKit & UnsetSource();
38252 ShaderKit & UnsetMultitexture();
38256 ShaderKit & UnsetParameterizationSource();
38260 ShaderKit & UnsetTransformMatrix();
38264 ShaderKit & UnsetEverything();
38269 bool ShowSource(UTF8 & out_source)
const;
38276 bool ShowMultitexture(
bool & out_state)
const;
38281 bool ShowParameterizationSource(Shader::Parameterization & out_source)
const;
38286 bool ShowTransformMatrix(MatrixKit & out_transform)
const;
38291 class HPS_API ShaderDefinition :
public Definition
38295 ShaderDefinition();
38301 ShaderDefinition(Definition
const & in_that);
38305 ShaderDefinition(ShaderDefinition
const & in_that);
38310 ShaderDefinition & operator=(ShaderDefinition
const & in_that);
38315 ShaderDefinition(ShaderDefinition && in_that);
38320 ShaderDefinition & operator=(ShaderDefinition && in_that);
38322 ~ShaderDefinition();
38324 HPS::Type ObjectType()
const {
return HPS::Type::ShaderDefinition; };
38328 void Set(ShaderKit
const & in_kit);
38332 void Show(ShaderKit & out_kit)
const;
38364 HPS::Type
ObjectType()
const {
return HPS::Type::CutGeometryGatheringOptionsKit;};
38386 bool Empty()
const;
38445 bool ShowOffset(
size_t & out_offset)
const;
38498 bool Empty()
const;
38565 bool ShowCriteria(SearchTypeArray & out_types)
const;
38570 bool ShowSearchSpace(
Search::Space & out_search_space)
const;
38615 bool operator==(
TreeContext const & in_that)
const;
38620 bool operator!=(
TreeContext const & in_that)
const;
38647 HPS::Type
ObjectType()
const {
return HPS::Type::SelectionOptionsKit;};
38669 bool Empty()
const;
38851 bool ShowProximity(
float & out_proximity)
const;
38861 bool ShowInternalLimit(
size_t & out_limit)
const;
38866 bool ShowRelatedLimit(
size_t & out_limit)
const;
38871 bool ShowSorting(
bool & out_sorted)
const;
38886 bool ShowScope(
KeyPath & out_start_path)
const;
38891 bool ShowTreeContext(
TreeContext & out_tree_context)
const;
38896 bool ShowExtentCullingRespected(
bool & out_state)
const;
38901 bool ShowDeferralExtentCullingRespected(
bool & out_state)
const;
38906 bool ShowFrustumCullingRespected(
bool & out_state)
const;
38911 bool ShowVectorCullingRespected(
bool & out_state)
const;
38942 HPS::Type
ObjectType()
const {
return HPS::Type::SelectionOptionsControl;};
39041 bool ShowProximity(
float & out_proximity)
const;
39051 bool ShowInternalLimit(
size_t & out_limit)
const;
39056 bool ShowRelatedLimit(
size_t & out_limit)
const;
39061 bool ShowSorting(
bool & out_sorted)
const;
39076 bool ShowExtentCullingRespected(
bool & out_state)
const;
39081 bool ShowDeferralExtentCullingRespected(
bool & out_state)
const;
39086 bool ShowFrustumCullingRespected(
bool & out_state)
const;
39091 bool ShowVectorCullingRespected(
bool & out_state)
const;
39157 bool ShowSelectedItem(
Key & out_selection)
const;
39162 bool ShowPath(
KeyPath & out_path)
const;
39167 bool ShowFaces(SizeTArray & out_faces)
const;
39172 bool ShowVertices(SizeTArray & out_vertices)
const;
39178 bool ShowEdges(SizeTArray & out_vertices1, SizeTArray & out_vertices2)
const;
39183 bool ShowCharacters(SizeTArray & out_characters)
const;
39188 bool ShowSelectionPosition(
WindowPoint & out_location)
const;
39193 bool ShowSelectionPosition(
WorldPoint & out_location)
const;
39221 HPS::Type
ObjectType()
const {
return HPS::Type::SelectionResultsIterator;}
39254 bool IsValid()
const;
39322 virtual void Reset();
39330 size_t GetCount()
const;
39436 size_t SelectByPolygon(PointArray
const & in_points,
SelectionResults & out_results)
const;
39451 size_t SelectByPolygon(
size_t in_point_count,
Point const in_points [],
SelectionResults & out_results)
const;
39464 size_t SelectByLine(PointArray
const & in_points,
SelectionResults & out_results)
const;
39479 size_t SelectByLine(
size_t in_point_count,
Point const in_points [],
SelectionResults & out_results)
const;
39581 HPS::Type
ObjectType()
const {
return HPS::Type::HighlightOptionsKit;};
39603 bool Empty()
const;
39671 bool ShowStyleName(
UTF8 & out_style_name)
const;
39676 bool ShowSecondaryStyleName(
UTF8 & out_style_name)
const;
39686 bool ShowNotification(
bool & out_state)
const;
39840 bool Empty()
const;
39888 bool ShowTimeLimit(HPS::Time & out_time_limit)
const;
39922 HPS::Type
ObjectType()
const {
return HPS::Type::UpdateOptionsControl;};
39959 bool ShowTimeLimit(HPS::Time & out_time_limit)
const;
39974 World(
char const * in_license);
39985 World & SetMaterialLibraryDirectory(
char const * in_directory);
39991 World & SetFontDirectory(
char const * in_directory);
39998 World & SetFontDirectories(
size_t in_count,
UTF8 const in_directories[]);
40004 World & SetFontDirectories(UTF8Array
const & in_directories);
40011 World & SetDriverConfigFile(
char const * in_filename);
40018 World & SetExchangeLibraryDirectory(
char const * in_directory);
40025 World & SetPublishResourceDirectory(
char const * in_directory);
40031 World & SetParasolidSchemaDirectory(
char const * in_directory);
40035 World & UnsetMaterialLibraryDirectory();
40039 World & UnsetFontDirectories();
40043 World & UnsetDriverConfigFile();
40047 World & UnsetExchangeLibraryDirectory();
40051 World & UnsetPublishResourceDirectory();
40055 World & UnsetParasolidSchemaDirectory();
40060 bool ShowLicense(
UTF8 & out_license)
const;
40065 bool ShowMaterialLibraryDirectory(
UTF8 & out_directory)
const;
40070 bool ShowFontDirectories(UTF8Array & out_directories)
const;
40075 bool ShowDriverConfigFile(
UTF8 & out_filename)
const;
40080 bool ShowExchangeLibraryDirectory(
UTF8 & out_directory)
const;
40085 bool ShowPublishResourceDirectory(
UTF8 & out_directory)
const;
40090 bool ShowParasolidSchemaDirectory(
UTF8 & out_directory)
const;
40097 virtual void Reset() {}
40126 intptr_t GetClassID()
const;
40137 static void *
operator new (
size_t in_size){
return Memory::Allocate(in_size); }
40138 static void operator delete (
void * in_ptr,
size_t in_size)
throw () { HPS_UNREFERENCED(in_size);
Memory::Free(in_ptr); }
40151 static void Execute(
bool in_once=
true);
40155 static Time GetTime();
40158 static void Sleep(Time milliseconds);
40184 static void RelinquishMemory();
40212 static void ShowMemoryUsage(
size_t & out_allocated,
size_t & out_used);
40221 static void Reset();
40224 static void Synchronize();
40228 static WindowKeyArray GetWindowKeys();
40232 static SegmentKeyArray GetRootSegments();
40236 static PortfolioKeyArray GetPortfolios();
40242 static PortfolioKey const GetMaterialLibraryPortfolio();
40317 static size_t SelectByShell(
ShellKit const & in_shell,
40326 static size_t SelectByShell(
ShellKey const & in_shell,
40336 static size_t SelectByVolume(
SimpleCuboid const & in_volume,
40346 static size_t SelectByRay(
Point const & in_start_point,
Vector const & in_direction,
40374 static bool SetInformationEventFilter(
HPS::Info::Code in_code,
bool in_filtered);
40380 static bool SetWarningEventFilter(
HPS::Info::Code in_code,
bool in_filtered);
40386 static bool SetErrorEventFilter(
HPS::Info::Code in_code,
bool in_filtered);
40394 static void UnsetEmergencyHandler();
40398 static size_t GetSoftMemoryLimit();
40403 static size_t SetSoftMemoryLimit(
size_t in_limit_bytes);
40472 bool Subscribe(
EventHandler const & in_handler, intptr_t in_type)
const;
40478 bool UnSubscribe(
EventHandler const & in_handler, intptr_t in_type)
const;
40484 bool UnSubscribe(
EventHandler const & in_handler)
const;
40489 bool UnSubscribe(intptr_t in_type)
const;
40494 bool InjectEvent(
Event const & in_event)
const;
40504 void Shutdown()
const;
40508 bool IsShutdown()
const;
40513 void SetName(
char const * in_name)
const;
40517 void ShowName(
UTF8 & out_name)
const;
40521 virtual void Reset() {}
40560 bool Subscribe(
EventDispatcher const & in_dispatcher, intptr_t in_type)
const;
40566 bool UnSubscribe(
EventDispatcher const & in_dispatcher, intptr_t in_type)
const;
40574 void UnSubscribeEverything()
const;
40577 virtual void Reset() { UnSubscribeEverything(); }
40607 channel = GetClassID();
40608 consumable =
false;
40616 if(in_event.
GetChannel() != Object::ClassID<TimerTickEvent>())
40635 HPS_UNREFERENCED(in_that_event);
40640 return GetClassID();
40658 channel = GetClassID();
40659 consumable =
false;
40660 action = Action::None;
40664 :
Event(), action(in_action), results(in_results), options(in_options)
40666 channel = GetClassID();
40667 consumable =
false;
40674 if (in_event.
GetChannel() == Object::ClassID<HighlightEvent>())
40677 action = that.action;
40678 results = that.results;
40679 options = that.options;
40720 if (in_event.
GetChannel() == Object::ClassID<InformationEvent>())
40724 code =
event->code;
40747 return message == in_that.
message && code == in_that.
code;
40755 return Equals(in_that);
40763 return !Equals(in_that);
40780 WarningEvent(
char const * in_message) :
Event(), message(in_message), code(HPS::
Info::Code::Unknown) { channel = GetClassID(); }
40791 if(in_event.
GetChannel() == Object::ClassID<WarningEvent>())
40795 code =
event->code;
40818 return message == in_that.
message && code == in_that.
code;
40826 return Equals(in_that);
40834 return !Equals(in_that);
40851 ErrorEvent(
char const * in_message) :
Event(), message(in_message), code(HPS::
Info::Code::Unknown) { channel = GetClassID(); }
40862 if(in_event.
GetChannel() == Object::ClassID<ErrorEvent>())
40866 code =
event->code;
40889 return message == in_that.
message && code == in_that.
code;
40897 return Equals(in_that);
40905 return !Equals(in_that);
40940 if(in_event.
GetChannel() == Object::ClassID<StandAloneWindowEvent>())
40966 return action == in_that.
action;
40974 return Equals(in_that);
40982 return !Equals(in_that);
40995 { channel = GetClassID(); }
41023 if(in_event.
GetChannel() == Object::ClassID<UpdateCompletedEvent>())
41026 update_time =
event->update_time;
41054 , import_status_message(HPS::
UTF8())
41055 { channel = GetClassID(); }
41059 , import_status_message(in_message)
41060 { channel = GetClassID(); }
41066 if (in_event.
GetChannel() == Object::ClassID<ImportStatusEvent>())
41069 import_status_message =
event.import_status_message;
41100 return modifiers == in_that.modifiers;
41108 return Equals(in_that);
41116 return !Equals(in_that);
41121 bool None()
const {
return modifiers == _key_none; }
41125 bool Shift()
const {
return (modifiers & _key_shift) != 0; }
41129 bool Control()
const {
return (modifiers & _key_control) != 0; }
41133 bool Alt()
const {
return (modifiers & _key_alt) != 0; }
41137 bool Meta()
const {
return (modifiers & _key_meta) != 0; }
41143 bool HasAll(
ModifierKeys const & in_keys)
const {
return (modifiers & in_keys.modifiers) == in_keys.modifiers; }
41153 void Shift(
bool in_state) {
if(in_state) modifiers |= _key_shift;
else modifiers &= ~(_key_shift); }
41157 void Control(
bool in_state) {
if(in_state) modifiers |= _key_control;
else modifiers &= ~(_key_control); }
41161 void Alt(
bool in_state) {
if(in_state) modifiers |= _key_alt;
else modifiers &= ~(_key_alt); }
41165 void Meta(
bool in_state) {
if(in_state) modifiers |= _key_meta;
else modifiers &= ~(_key_meta); }
41173 ret.modifiers = modifiers | in_modifiers_to_merge.modifiers;
41183 ret.modifiers = modifiers & ~in_modifiers_to_remove.modifiers;
41220 _key_none = 0x0000,
41221 _key_shift = 0x0001,
41222 _key_control = 0x0002,
41224 _key_meta = 0x0008,
41267 return Equals(in_that);
41275 return !Equals(in_that);
41282 return ModifierKeyState;
41309 :
InputEvent(in_modifier), CurrentAction(in_action) { channel = GetClassID(); }
41317 :
InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches) { channel = GetClassID(); }
41326 :
InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches, in_touches + in_touch_count) { channel = GetClassID(); }
41333 if(in_event.
GetChannel() == Object::ClassID<TouchEvent>())
41336 channel = GetClassID();
41337 CurrentAction =
event->CurrentAction;
41338 Touches =
event->Touches;
41339 ModifierKeyState =
event->ModifierKeyState;
41369 return Equals(in_that);
41377 return !Equals(in_that);
41387 if (CurrentAction == that_touch_event->
CurrentAction && CurrentAction == Action::Move
41388 && Touches.size() == that_touch_event->
Touches.size() )
41390 TouchArray these_touches = Touches;
41391 TouchArray those_touches = that_touch_event->
Touches;
41393 std::sort(those_touches.begin(), those_touches.end(), sort_predicate);
41394 std::sort(these_touches.begin(), these_touches.end(), sort_predicate);
41396 for (
size_t i = 0 ; i < these_touches.size() ; i++)
41398 if (these_touches[i].ID != those_touches[i].ID)
41412 Touches.assign(in_touches, in_touches + in_touch_count);
41419 Touches = in_touches;
41431 static bool sort_predicate(
Touch const & in_a,
Touch const & in_b)
41433 return static_cast<int>(in_a.
ID) < static_cast<int>(in_b.
ID);
41450 return buttons == in_that.buttons;
41458 return Equals(in_that);
41466 return !Equals(in_that);
41471 bool None()
const {
return buttons == _button_none; }
41475 bool Left()
const {
return (buttons & _button_left) != 0; }
41479 bool Right()
const {
return (buttons & _button_right) != 0; }
41483 bool Middle()
const {
return (buttons & _button_middle) != 0; }
41487 bool X1()
const {
return (buttons & _button_x1) != 0; }
41491 bool X2()
const {
return (buttons & _button_x2) != 0; }
41497 bool HasAll(
MouseButtons const & in_buttons)
const {
return (buttons & in_buttons.buttons) == in_buttons.buttons; }
41506 void Left(
bool in_state) {
if(in_state) buttons |= _button_left;
else buttons &= ~(_button_left); }
41510 void Right(
bool in_state) {
if(in_state) buttons |= _button_right;
else buttons &= ~(_button_right); }
41514 void Middle(
bool in_state) {
if(in_state) buttons |= _button_middle;
else buttons &= ~(_button_middle); }
41518 void X1(
bool in_state) {
if(in_state) buttons |= _button_x1;
else buttons &= ~(_button_x1); }
41522 void X2(
bool in_state) {
if(in_state) buttons |= _button_x2;
else buttons &= ~(_button_x2); }
41530 ret.buttons = buttons | in_buttons_to_merge.buttons;
41540 ret.buttons = buttons & ~in_buttons_to_remove.buttons;
41581 _button_none = 0x0000,
41582 _button_left = 0x0001,
41583 _button_right = 0x0002,
41584 _button_middle = 0x0004,
41585 _button_x1 = 0x0008,
41586 _button_x2 = 0x0010
41619 :
InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), CurrentButton(in_button), WheelDelta(0), ClickCount(in_click_count) { channel = GetClassID(); }
41629 :
InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), WheelDelta(in_wheel_delta), ClickCount(in_click_count) { channel = GetClassID(); }
41635 if(in_event.
GetChannel() == Object::ClassID<MouseEvent>())
41638 channel = GetClassID();
41639 CurrentAction =
event->CurrentAction;
41640 Location =
event->Location;
41641 CurrentButton =
event->CurrentButton;
41642 WheelDelta =
event->WheelDelta;
41643 ClickCount =
event->ClickCount;
41676 return Equals(in_that);
41684 return !Equals(in_that);
41695 (CurrentAction == Action::ButtonDown || CurrentAction == Action::ButtonUp || CurrentAction == Action::Move) &&
41704 if (CurrentAction == Action::Move)
41705 return GetClassID();
41738 :
InputEvent(in_modifiers), CurrentAction(in_action) { channel = GetClassID(); }
41746 :
InputEvent(in_modifiers), CurrentAction(in_action)
41748 channel = GetClassID();
41749 KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
41757 :
InputEvent(in_modifiers), CurrentAction(in_action)
41759 channel = GetClassID();
41760 KeyboardCodes = in_keyboardcodes;
41767 if(in_event.
GetChannel() == Object::ClassID<KeyboardEvent>())
41770 channel = GetClassID();
41771 KeyboardCodes =
event->KeyboardCodes;
41772 CurrentAction =
event->CurrentAction;
41803 return Equals(in_that);
41811 return !Equals(in_that);
41819 KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
41826 KeyboardCodes = in_keyboardcodes;
41871 bool Equals(
MouseState const & in_that)
const;
41876 bool operator== (
MouseState const & in_that)
const;
41881 bool operator!= (
MouseState const & in_that)
const;
41909 HPS::KeyArray GetEventPath()
const;
41925 void SetActiveEvent(
MouseEvent const & in_event);
41929 void SetEventPath(KeyArray
const & in_path);
41983 bool Equals(
TouchState const & in_that)
const;
41988 bool operator== (
TouchState const & in_that)
const;
41993 bool operator!= (
TouchState const & in_that)
const;
42014 HPS::KeyArray GetEventPath()
const;
42018 size_t GetTouchCount()
const;
42022 HPS::TouchArray GetTouches()
const;
42030 void SetActiveEvent(
TouchEvent const & in_event);
42034 void SetEventPath(KeyArray
const & in_path);
42038 void SetTouches(TouchArray
const & in_touches);
42115 HPS::KeyArray GetEventPath()
const;
42119 size_t GetKeyboardCodeCount()
const;
42123 HPS::KeyboardCodeArray GetKeyboardCodes()
const;
42128 bool GetKeyState(HPS::KeyboardCode in_key_code)
const;
42140 void SetEventPath(KeyArray
const & in_path);
42144 void SetKeyboardCodes(KeyboardCodeArray
const & in_keyboard_codes);
42196 IOResult Status()
const;
42201 IOResult Status(
float & out_percent_complete)
const;
42242 virtual void Restart();
42247 static Toolkit CreateToolkit();
42272 HPS::Type
ObjectType()
const {
return HPS::Type::StreamImportOptionsKit; };
42289 bool Empty()
const;
42332 bool ShowSegment(
SegmentKey & out_segment)
const;
42347 bool ShowAlternateRoot(
SegmentKey & out_segment)
const;
42362 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
42392 HPS::Type
ObjectType()
const {
return HPS::Type::StreamImportResultsKit; };
42409 bool Empty()
const;
42441 bool ShowSegment(
SegmentKey & out_segment)
const;
42459 bool ShowAlternateRoot(
SegmentKey & out_segment)
const;
42477 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
42493 bool ShowDefaultCamera(
CameraKit & out_camera)
const;
42501 ImportResultsKit & SetAlternateCameras(UTF8Array
const & in_names, CameraKitArray & in_cameras);
42512 bool ShowAlternateCameras(UTF8Array & out_names, CameraKitArray & out_cameras)
const;
42548 HPS::Type
ObjectType()
const {
return HPS::Type::StreamExportOptionsKit; };
42565 bool Empty()
const;
42593 ExportOptionsKit & SetVertexCompression(
bool in_state,
unsigned int in_bits_per_vertex = 24);
42602 ExportOptionsKit & SetNormalCompression(
bool in_state,
unsigned int in_bits_per_normal = 10);
42609 ExportOptionsKit & SetParameterCompression(
bool in_state,
unsigned int in_bits_per_parameter = 8);
42618 ExportOptionsKit & SetColorCompression(
bool in_state,
unsigned int in_bits_per_color = 24);
42627 ExportOptionsKit & SetIndexCompression(
bool in_state,
unsigned int in_bits_per_index = 8);
42651 ExportOptionsKit & SetImageCompression(
bool in_state,
float in_quality = 0.75f);
42702 bool ShowVertexCompression(
bool & out_state,
unsigned int & out_bits_per_vertex)
const;
42708 bool ShowNormalCompression(
bool & out_state,
unsigned int & out_bits_per_normal)
const;
42714 bool ShowParameterCompression(
bool & out_state,
unsigned int & out_bits_per_parameter)
const;
42720 bool ShowColorCompression(
bool & out_state,
unsigned int & out_bits_per_color)
const;
42726 bool ShowIndexCompression(
bool & out_state,
unsigned int & out_bits_per_index)
const;
42731 bool ShowConnectivityCompression(
bool & out_state)
const;
42737 bool ShowImageCompression(
bool & out_state,
float & out_quality)
const;
42742 bool ShowSerializeTristrips(
bool & out_state)
const;
42775 HPS::Type
ObjectType()
const {
return HPS::Type::StreamImportNotifier;};
42822 HPS::Type
ObjectType()
const {
return HPS::Type::StreamExportNotifier;};
42895 DotsPerCentimeter = DPCM,
42927 HPS::Type
ObjectType()
const {
return HPS::Type::HardcopyExportOptionsKit; };
42944 bool Empty()
const;
42969 bool ShowSize(
float & out_width,
float & out_height,
Hardcopy::SizeUnits & out_units)
const;
43009 bool ShowWYSIWYG(
bool & out_onoff)
const;
43052 static IOResult Export(
char const * in_filename, Driver in_driver_type,
HPS::WindowKey const & in_window, ExportOptionsKit
const & in_options);
43063 class HPS_API ExportOptionsKit :
public Object
43067 ExportOptionsKit();
43071 ExportOptionsKit(ExportOptionsKit
const & in_kit);
43076 ExportOptionsKit(ExportOptionsKit && in_that);
43081 ExportOptionsKit & operator=(ExportOptionsKit && in_that);
43083 virtual ~ExportOptionsKit();
43085 HPS::Type ObjectType()
const {
return HPS::Type::HardcopyExportOptionsKit; };
43089 void Set(ExportOptionsKit
const & in_kit);
43093 void Show(ExportOptionsKit & out_kit)
const;
43098 ExportOptionsKit & operator=(ExportOptionsKit
const & in_kit);
43102 bool Empty()
const;
43107 bool Equals(ExportOptionsKit
const & in_kit)
const;
43112 bool operator==(ExportOptionsKit
const & in_kit)
const;
43117 bool operator!=(ExportOptionsKit
const & in_kit)
const;
43125 bool ShowResolution(
float & out_resolution)
const;
43130 ExportOptionsKit & SetResolution(
float in_resolution);
43134 ExportOptionsKit & UnsetResolution();
43141 bool ShowWYSIWYG(
bool & out_onoff)
const;
43146 ExportOptionsKit & SetWYSIWYG(
bool in_onoff);
43150 ExportOptionsKit & UnsetWYSIWYG();
43155 ExportOptionsKit & UnsetEverything();
43164 static IOResult Export(intptr_t hdc, intptr_t attribdc,
HPS::WindowKey const & window, ExportOptionsKit
const & options);
43207 HPS::Type
ObjectType()
const {
return HPS::Type::OBJImportOptionsKit; };
43224 bool Empty()
const;
43254 bool ShowSegment(
SegmentKey & out_segment)
const;
43269 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
43315 HPS::Type
ObjectType()
const {
return HPS::Type::OBJImportResultsKit; };
43332 bool Empty()
const;
43364 bool ShowSegment(
SegmentKey & out_segment)
const;
43382 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
43506 HPS::Type
ObjectType()
const {
return HPS::Type::STLImportOptionsKit; };
43523 bool Empty()
const;
43585 bool ShowSegment(
SegmentKey & out_segment)
const;
43617 HPS::Type
ObjectType()
const {
return HPS::Type::STLImportResultsKit; };
43634 bool Empty()
const;
43666 bool ShowSegment(
SegmentKey & out_segment)
const;
43744 # pragma warning(pop)
HPS::Type ObjectType() const
Definition: hps.h:39979
Rotation
Definition: hps.h:1595
HPS::Type ObjectType() const
Definition: hps.h:26946
bool Empty() const
Definition: hps.h:6824
CameraPoint(Point const &in_point)
Definition: hps.h:5775
Alignment
Definition: hps.h:1528
Space
Definition: hps.h:561
WindowPoint Location
Location in window space of the mouse cursor.
Definition: hps.h:41711
Channel
Definition: hps.h:945
HPS::Type ObjectType() const
Definition: hps.h:24118
Handedness
Definition: hps.h:1276
ColorSource
Definition: hps.h:1921
HPS::Type ObjectType() const
Definition: hps.h:17069
HPS::Type ObjectType() const
Definition: hps.h:36281
Event(intptr_t in_channel=0)
Definition: hps.h:6128
HPS::Type ObjectType() const
Definition: hps.h:43436
Cuboid_3D(Point_3D< F > const &in_min, Point_3D< F > const &in_max)
Definition: hps.h:3751
float alpha
Definition: hps.h:4290
HPS::Type ObjectType() const
Definition: hps.h:35888
bool operator==(Touch const &in_that) const
Definition: hps.h:6418
Both cylinder ends will be capped.
Search for all attributes, geometry, segments, includes and includers.
void Shift(bool in_state)
Definition: hps.h:41153
HPS::Info::Code code
The error code for this ErrorEvent.
Definition: hps.h:40909
HPS::Type ObjectType() const
Definition: hps.h:34351
HPS::Type ObjectType() const
Definition: hps.h:21848
HPS::Type ObjectType() const
Definition: hps.h:23646
HPS::Type ObjectType() const
Definition: hps.h:24392
Action
Definition: hps.h:41294
Orientation
Definition: hps.h:537
Code
Definition: hps.h:134
Definition: sprk_exchange.h:43
Algorithm
Definition: hps.h:1331
Multiline strings will be left justfied.
HPS::Type ObjectType() const
Definition: hps.h:14953
virtual bool Equals(StandAloneWindowEvent const &in_that) const
Definition: hps.h:40964
HPS::Type ObjectType() const
Definition: hps.h:8610
HPS::Type ObjectType() const
Definition: hps.h:28174
Event * Clone() const
Definition: hps.h:40807
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:41628
virtual HandleResult Handle(Event const *in_event)
Definition: hps.h:40595
ImportStatusEvent()
Definition: hps.h:41052
HPS::Type ObjectType() const
Definition: hps.h:21464
HPS::Type ObjectType() const
Definition: hps.h:36063
HPS::Type ObjectType() const
Definition: hps.h:25909
virtual bool Equals(TouchEvent const &in_that) const
Definition: hps.h:41359
HPS::Type ObjectType() const
Definition: hps.h:30214
HPS::Type ObjectType() const
Definition: hps.h:25520
HPS::Type ObjectType() const
Definition: hps.h:11633
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:40856
void SetKeyboardCodes(size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[])
Definition: hps.h:41817
HPS::Type ObjectType() const
Definition: hps.h:37775
ObjectPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5672
InnerWindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5920
Driver
Definition: hps.h:154
HPS::Type ObjectType() const
Definition: hps.h:41857
static HPS_INLINE bool IsInfinite(float const &a)
Definition: hps.h:2192
HPS::Type ObjectType() const
Definition: hps.h:39123
CappingLevel
Definition: hps.h:1727
virtual void Handle(DriverEvent const *in_event)
Definition: hps.h:8691
HPS::Type ObjectType() const
Definition: hps.h:23373
HPS::Type ObjectType() const
Definition: hps.h:35816
Object space units ignoring any scaling components in modelling matrices.
HPS::Type ObjectType() const
Definition: hps.h:12771
HPS::Type ObjectType() const
Definition: hps.h:41969
HPS::Type ObjectType() const
Definition: hps.h:20508
HPS::Type ObjectType() const
Definition: hps.h:13788
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5532
HPS::Type ObjectType() const
Definition: hps.h:28959
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid) const
Definition: hps.h:3858
KeyboardEvent(KeyboardEvent::Action in_action, KeyboardCodeArray const &in_keyboardcodes, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:41756
static ModifierKeys KeyMeta()
Definition: hps.h:41212
HPS::Type ObjectType() const
Definition: hps.h:35551
Visualize will perform runtime query of the 3D capabilities of the Operating System and graphics card...
HPS::Type ObjectType() const
Definition: hps.h:36930
HPS::Type ObjectType() const
Definition: hps.h:42822
Cuboid_3D(Cuboid_3D< D > const &that)
Definition: hps.h:3737
HPS::Type ObjectType() const
Definition: hps.h:39295
HPS::Type ObjectType() const
Definition: hps.h:23571
HPS::Type ObjectType() const
Definition: hps.h:35121
HPS::Type ObjectType() const
Definition: hps.h:16778
HPS::Type ObjectType() const
Definition: hps.h:38364
Time GetTimeStamp() const
Definition: hps.h:6150
HPS::Type ObjectType() const
Definition: hps.h:22366
NormalizedPoint(Point const &in_point)
Definition: hps.h:5825
HPS::Type ObjectType() const
Definition: hps.h:23920
Event * Clone() const
Definition: hps.h:40624
static HPS_INLINE Cuboid_3D Invalid()
Definition: hps.h:3786
Renderer
Definition: hps.h:1576
HPS::Type ObjectType() const
Definition: hps.h:34087
KeyboardEvent()
Definition: hps.h:41732
HPS::Type ObjectType() const
Definition: hps.h:7337
HPS_INLINE bool Contains(Cuboid_3D const &contained) const
Definition: hps.h:3979
ObjectPoint(Point const &in_point)
Definition: hps.h:5675
HPS::Type ObjectType() const
Definition: hps.h:17656
Object space units ignoring any scaling components in modelling matrices.
Point_3D< F > min
Definition: hps.h:3721
StandAloneWindowEvent(Event const &in_event)
Definition: hps.h:40938
static ModifierKeys KeyAlt()
Definition: hps.h:41208
bool IsConsumable() const
Definition: hps.h:6153
MaterialPreference
Definition: hps.h:1744
KeyboardEvent(KeyboardEvent::Action in_action, size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[], ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:41745
Mobility
Definition: hps.h:194
HPS::Type ObjectType() const
Definition: hps.h:13281
ScreenRangePoint(Point const &in_point)
Definition: hps.h:5873
InterpolationAlgorithm
Definition: hps.h:1511
Fill
Definition: hps.h:1912
Cuboid_3D(Rectangle const &that)
Definition: hps.h:3774
HPS::Type ObjectType() const
Definition: hps.h:27451
HPS::Type ObjectType() const
Definition: hps.h:19149
char At(size_t in_index) const
Definition: hps.h:6867
bool HasAny(ModifierKeys const &in_keys) const
Definition: hps.h:41148
HPS::Type ObjectType() const
Definition: hps.h:35943
ReferenceFrame
Definition: hps.h:1543
HPS::Type ObjectType() const
Definition: hps.h:16985
GreekingUnits
Definition: hps.h:1630
HPS::Type ObjectType() const
Definition: hps.h:12183
InnerConeUnits
Definition: hps.h:486
InnerPixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5969
HPS_INLINE bool Intersecting(Point_3D< F > const &point1, Point_3D< F > const &point2) const
Definition: hps.h:3891
KeyPath & Append(Key const &in_key)
UpdateCompletedEvent()
Definition: hps.h:41014
OuterConeUnits
Definition: hps.h:472
HPS::Type ObjectType() const
Definition: hps.h:18933
HPS::Type ObjectType() const
Definition: hps.h:40446
HPS::Type ObjectType() const
Definition: hps.h:39392
HPS::Type ObjectType() const
Definition: hps.h:14384
HPS::Type ObjectType() const
Definition: hps.h:33570
void SetKeyboardCodes(HPS::KeyboardCodeArray const &in_keyboardcodes)
Definition: hps.h:41824
HPS::Type ObjectType() const
Definition: hps.h:26845
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:41383
HPS::Type ObjectType() const
Definition: hps.h:12654
HPS::Type ObjectType() const
Definition: hps.h:25102
HPS::Type ObjectType() const
Definition: hps.h:36394
Channel
Definition: hps.h:904
HPS::Info::Code code
The warning code for this WarningEvent.
Definition: hps.h:40838
AreaUnits
Definition: hps.h:1457
Definition: sprk_publish.h:42
HPS_INLINE F Volume() const
Definition: hps.h:3828
HPS::Type ObjectType() const
Definition: hps.h:12006
HPS::Type ObjectType() const
Definition: hps.h:34707
Action
Definition: hps.h:40920
HPS::Type ObjectType() const
Definition: hps.h:14222
HPS::Type ObjectType() const
Definition: hps.h:42548
HPS::Type ObjectType() const
Definition: hps.h:27552
size_t TapCount
Number of taps for this Touch.
Definition: hps.h:6433
HPS::Type ObjectType() const
Definition: hps.h:37893
HPS::Type ObjectType() const
Definition: hps.h:34224
TouchEvent(Action in_action, TouchArray const &in_touches, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:41316
void Merge(size_t count, Point_3D< F > const *points)
Definition: hps.h:3937
Border
Definition: hps.h:264
UpdateControl
Definition: hps.h:175
bool HasAll(ModifierKeys const &in_keys) const
Definition: hps.h:41143
HPS::Type ObjectType() const
Definition: hps.h:23123
virtual bool Equals(KeyboardEvent const &in_that) const
Definition: hps.h:41793
HPS::Type ObjectType() const
Definition: hps.h:21389
WarningEvent(Event const &in_event)
Definition: hps.h:40789
HPS::Type ObjectType() const
Definition: hps.h:11509
The geometry inside the clip region is drawn. Everything outside of it is clipped.
Default
Definition: hps.h:1931
static ModifierKeys KeyShift()
Definition: hps.h:41200
HPS::Type ObjectType() const
Definition: hps.h:28685
Shape
Definition: hps.h:1073
bool IsValid() const
Definition: hps.h:6817
Cuboid_3D()
Definition: hps.h:3729
ErrorEvent(Event const &in_event)
Definition: hps.h:40860
size_t GetWStrLength() const
Definition: hps.h:6846
Event * Clone() const
Definition: hps.h:40689
HPS::Type ObjectType() const
Definition: hps.h:11100
AppendMode
Definition: hps.h:332
static void Free(void *in_pointer)
HPS_INLINE void Merge(Point_3D< F > const &point)
Definition: hps.h:3922
void Meta(bool in_state)
Definition: hps.h:41165
PixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6068
HPS::Type ObjectType() const
Definition: hps.h:14662
UpdateStatus
Definition: hps.h:164
HPS_INLINE bool IsValid() const
Definition: hps.h:3779
HPS::Type ObjectType() const
Definition: hps.h:38476
Action action
The action for this StandAloneWindowEvent.
Definition: hps.h:40985
Quality
Definition: hps.h:1057
ResolutionUnits
Definition: hps.h:42891
TimerTickEvent(Event const &in_event)
Definition: hps.h:40614
Component
Definition: hps.h:352
WindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6019
HPS::Type ObjectType() const
Definition: hps.h:12270
Default
Definition: hps.h:1885
HPS::Type ObjectType() const
Definition: hps.h:10730
bool Equals(GlyphPoint const &in_that) const
Definition: hps.h:5065
bool Shift() const
Definition: hps.h:41125
SizeToleranceUnits
Definition: hps.h:1617
HPS::Type ObjectType() const
Definition: hps.h:38600
HPS_INLINE bool Contains(Point_3D< F > const &contained, F epsilon) const
Definition: hps.h:4008
Cap
Definition: hps.h:1836
Point_3D< F > max
Definition: hps.h:3723
HPS::Type ObjectType() const
Definition: hps.h:7417
HPS::Type ObjectType() const
Definition: hps.h:43207
HPS::Type ObjectType() const
Definition: hps.h:43315
MouseEvent()
Definition: hps.h:41610
HPS::Type ObjectType() const
Definition: hps.h:12111
HPS::Type ObjectType() const
Definition: hps.h:16687
HPS::Type ObjectType() const
Definition: hps.h:35166
Material Texture Channel.
static const float Infinity
Definition: hps.h:2187
InsetBehavior
Definition: hps.h:1817
HPS::Type ObjectType() const
Definition: hps.h:25028
static HPS_INLINE bool IsNAN(float const &a)
Definition: hps.h:2200
HPS::Type ObjectType() const
Definition: hps.h:13676
HPS::Type ObjectType() const
Definition: hps.h:27145
WindowPoint Location
Location in window space for this Touch.
Definition: hps.h:6432
HPS::Type ObjectType() const
Definition: hps.h:35356
HPS::Type ObjectType() const
Definition: hps.h:37620
HPS_INLINE void Merge(Cuboid_3D const &cuboid)
Definition: hps.h:3901
Algorithm
Definition: hps.h:1445
Decimation
Definition: hps.h:1014
Granularity
Definition: hps.h:1366
Search the current segment only.
KeyboardEvent(Event const &in_event)
Definition: hps.h:41765
ClipOperation
Definition: hps.h:1305
HPS::Type ObjectType() const
Definition: hps.h:8947
Method
Definition: hps.h:1435
HPS::Type ObjectType() const
Definition: hps.h:26565
Parameterization
Definition: hps.h:959
FocusLostEvent()
Definition: hps.h:40993
CuttingLevel
Definition: hps.h:1736
Channel
Definition: hps.h:925
HandleResult
Definition: hps.h:40585
bool operator!=(GlyphPoint const &in_that) const
Definition: hps.h:5077
UTF8 message
The error message for this ErrorEvent.
Definition: hps.h:40908
Value
Definition: hps.h:1416
static HPS_INLINE bool IsAbnormal(float const &a)
Definition: hps.h:2208
Code
Definition: hps.h:105
HPS::Type ObjectType() const
Definition: hps.h:26061
Event * Clone() const
Definition: hps.h:41001
virtual bool Equals(MouseEvent const &in_that) const
Definition: hps.h:41664
ErrorEvent()
Definition: hps.h:40847
Justification
Definition: hps.h:1551
The vertex colors applied to faces.
HPS::Type ObjectType() const
Definition: hps.h:14046
An InvalidOperationException is thrown when an operation is not supported on the current platform...
Definition: hps.h:5550
ErrorEvent(char const *in_message)
Definition: hps.h:40851
UpdateCompletedEvent(Event const &in_event)
Definition: hps.h:41021
FrameSize
Definition: hps.h:205
Justification
Definition: hps.h:1853
HPS::Type ObjectType() const
Definition: hps.h:11831
HPS::Type ObjectType() const
Definition: hps.h:19790
HPS::Type ObjectType() const
Definition: hps.h:22197
HPS::Type ObjectType() const
Definition: hps.h:8730
HPS::Type ObjectType() const
Definition: hps.h:36884
HPS::Type ObjectType() const
Definition: hps.h:35070
GreekingMode
Definition: hps.h:1642
HPS::Type ObjectType() const
Definition: hps.h:20300
HPS::KeyboardCodeArray KeyboardCodes
Array of keyboard codes for this KeyboardEvent.
Definition: hps.h:41829
Operation
Definition: hps.h:455
HPS::Type ObjectType() const
Definition: hps.h:37465
Type
Definition: hps.h:1999
WorldPoint(Point const &in_point)
Definition: hps.h:5725
HPS::TouchArray Touches
Array of Touches for this TouchEvent.
Definition: hps.h:41423
HPS::Type ObjectType() const
Definition: hps.h:9929
static HPS_INLINE bool Equals(float const &a, float const &b, int tolerance=32)
Definition: hps.h:2479
HPS::Type ObjectType() const
Definition: hps.h:6664
TouchEvent(Event const &in_event)
Definition: hps.h:41331
void SetTouches(HPS::TouchArray const &in_touches)
Definition: hps.h:41417
friend bool operator!=(char const *in_left, UTF8 const &in_right)
Definition: hps.h:6949
Relation
Definition: hps.h:378
Action
Definition: hps.h:41724
ChannelMapping
Definition: hps.h:1028
HPS::Type ObjectType() const
Definition: hps.h:22715
IOResult result
Enumeration indicating the category of the exception.
Definition: hps.h:5567
HPS::Type ObjectType() const
Definition: hps.h:38942
HPS::Type ObjectType() const
Definition: hps.h:39581
bool Alt() const
Definition: hps.h:41133
ToleranceUnits
Definition: hps.h:361
HPS::Type ObjectType() const
Definition: hps.h:12581
SizeUnits
Definition: hps.h:1804
Type
Definition: hps.h:2016
The vertex colors applied to faces.
RelationTest
Definition: hps.h:388
Type
Definition: hps.h:323
HPS::Type ObjectType() const
Definition: hps.h:14806
Behavior
Definition: hps.h:570
Ambient Occulsion Quality.
HPS::Type ObjectType() const
Definition: hps.h:6739
HPS::KeyboardEvent::Action CurrentAction
The action for the keyboard codes for this KeyboardEvent.
Definition: hps.h:41830
HPS::Type ObjectType() const
Definition: hps.h:18699
ImageFormat
Definition: hps.h:220
An InvalidLicenseException is thrown when trying to run Visualize with an invalid license...
Definition: hps.h:5541
float blue
Definition: hps.h:4289
A grid of lines will be drawn in place of characters below the greeking limit.
Type
Definition: hps.h:428
HPS::Type ObjectType() const
Definition: hps.h:21128
friend bool operator!=(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:6967
PixelPoint(Point const &in_point)
Definition: hps.h:6071
HPS::Type ObjectType() const
Definition: hps.h:6193
HPS::Type ObjectType() const
Definition: hps.h:7056
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:41690
HPS::Type ObjectType() const
Definition: hps.h:21725
HPS::Type ObjectType() const
Definition: hps.h:21605
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:35309
HPS::Type ObjectType() const
Definition: hps.h:28828
HPS::Type ObjectType() const
Definition: hps.h:24191
HPS::Type ObjectType() const
Definition: hps.h:39221
HPS::Type ObjectType() const
Definition: hps.h:20990
HPS::MouseEvent::Action CurrentAction
The action for this MouseEvent.
Definition: hps.h:41710
Event * Clone() const
Definition: hps.h:41079
bool operator==(GlyphPoint const &in_that) const
Definition: hps.h:5071
HPS::Type ObjectType() const
Definition: hps.h:34621
HPS::Type ObjectType() const
Definition: hps.h:40554
Alignment and justification will be defined relative to a screen-facing box around the text...
HPS::Type ObjectType() const
Definition: hps.h:15837
Infinite line which extends infinitely in both directions along a vector.
intptr_t GetChannel() const
Definition: hps.h:6147
HPS::Type ObjectType() const
Definition: hps.h:9300
Algorithm
Definition: hps.h:1358
HPS::Type ObjectType() const
Definition: hps.h:31300
HPS::Type ObjectType() const
Definition: hps.h:37936
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3846
Driver
Definition: hps.h:43041
SizeUnits
Definition: hps.h:1672
StandAloneWindowEvent()
Definition: hps.h:40929
HPS::Type ObjectType() const
Definition: hps.h:36463
HPS::Type ObjectType() const
Definition: hps.h:34459
HPS::Type ObjectType() const
Definition: hps.h:12419
HPS::Type ObjectType() const
Definition: hps.h:11250
virtual bool Equals(WarningEvent const &in_that) const
Definition: hps.h:40816
MouseEvent(Action in_action, WindowPoint in_location, MouseButtons in_button=MouseButtons(), ModifierKeys in_modifier=ModifierKeys(), size_t in_click_count=0)
Definition: hps.h:41618
An InvalidObjectException is thrown when a user tries to interact with an object that either is unini...
Definition: hps.h:5513
HPS::Type ObjectType() const
Definition: hps.h:17496
Level
Definition: hps.h:1349
bool Equals(ModifierKeys const &in_that) const
Definition: hps.h:41098
void Control(bool in_state)
Definition: hps.h:41157
HPS::Type ObjectType() const
Definition: hps.h:42775
HPS::Type ObjectType() const
Definition: hps.h:18207
HPS_INLINE bool Contains(Point_3D< F > const &contained) const
Definition: hps.h:3993
UTF8 message
The warning message for this WarningEvent.
Definition: hps.h:40837
The base class of all HPS exceptions.
Definition: hps.h:5505
RegionAlignment
Definition: hps.h:1651
TouchEvent(Action in_action, size_t in_touch_count, Touch const in_touches[], ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:41325
Event * Clone() const
Definition: hps.h:41655
HPS::Type ObjectType() const
Definition: hps.h:21277
void Invalidate()
Definition: hps.h:3791
Quaternion Spline(Quaternion const &in_previous, Quaternion const &in_next) const
Definition: hps.h:4785
IOException(char const *in_info, IOResult in_result)
Definition: hps.h:5564
UpdateCompletedEvent(Time in_update_time)
Definition: hps.h:41017
HPS::Type ObjectType() const
Definition: hps.h:33947
HPS::Type ObjectType() const
Definition: hps.h:39818
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:6140
char const * GetBytes() const
Definition: hps.h:6853
virtual intptr_t Freshen() const
Definition: hps.h:41702
HPS::Type ObjectType() const
Definition: hps.h:35418
float green
Definition: hps.h:4288
Action
Definition: hps.h:41599
The vertex colors applied to faces.
SizeUnits
Definition: hps.h:1696
HPS::Type ObjectType() const
Definition: hps.h:10334
HPS::Type ObjectType() const
Definition: hps.h:27217
HPS::Type ObjectType() const
Definition: hps.h:24709
HPS::Type ObjectType() const
Definition: hps.h:24465
static void * Allocate(size_t in_bytes, bool in_clear_memory=true)
HPS::Type ObjectType() const
Definition: hps.h:37988
HPS::Type ObjectType() const
Definition: hps.h:24830
InnerPixelPoint(Point const &in_point)
Definition: hps.h:5972
ImportStatusEvent(Event const &in_event)
Definition: hps.h:41064
NormalizedPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5822
Touch(TouchID in_id, WindowPoint const &in_location, size_t in_tap_count=1)
Definition: hps.h:6412
static const float NegativeInfinity
Definition: hps.h:2189
HighlightEvent(Event const &in_event)
Definition: hps.h:40672
friend bool operator==(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:6958
SizeUnits
Definition: hps.h:1477
HPS::Type ObjectType() const
Definition: hps.h:12857
HPS::Type ObjectType() const
Definition: hps.h:20686
HPS::MouseButtons CurrentButton
If the action involves a button, this is the button.
Definition: hps.h:41712
HPS::Type ObjectType() const
Definition: hps.h:10555
InnerWindowPoint(Point const &in_point)
Definition: hps.h:5923
GatheringLevel
Definition: hps.h:1752
HPS::Type ObjectType() const
Definition: hps.h:29038
Cuboid_3D(size_t count, Point_3D< F > const *points)
Definition: hps.h:3758
FrameOptions
Definition: hps.h:214
HPS::Type ObjectType() const
Definition: hps.h:35259
Space
Definition: hps.h:8568
void Alt(bool in_state)
Definition: hps.h:41161
KeyboardEvent(KeyboardEvent::Action in_action, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:41737
HPS::Type ObjectType() const
Definition: hps.h:37192
Type
Definition: hps.h:258
bool operator!=(Touch const &in_that) const
Definition: hps.h:6426
Type
Definition: hps.h:446
HPS::Type ObjectType() const
Definition: hps.h:42272
HPS::Type ObjectType() const
Definition: hps.h:43617
HPS::Type ObjectType() const
Definition: hps.h:43506
HPS::Type ObjectType() const
Definition: hps.h:33678
WorldPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5722
HPS::Type ObjectType() const
Definition: hps.h:9490
HPS::Type ObjectType() const
Definition: hps.h:43703
friend bool operator==(char const *in_left, UTF8 const &in_right)
Definition: hps.h:6940
void SetTouches(size_t in_touch_count, Touch const in_touches[])
Definition: hps.h:41410
Event * Clone() const
Definition: hps.h:41350
virtual bool Equals(ErrorEvent const &in_that) const
Definition: hps.h:40887
Event * Clone() const
Definition: hps.h:40955
size_t GetLength() const
Definition: hps.h:6838
HPS::Type ObjectType() const
Definition: hps.h:21077
HPS::Type ObjectType() const
Definition: hps.h:26775
Type
Definition: hps.h:1134
HPS::Type ObjectType() const
Definition: hps.h:9408
bool None() const
Definition: hps.h:41121
size_t ClickCount
The number of clicks received.
Definition: hps.h:41714
virtual intptr_t Freshen() const
Definition: hps.h:6144
void Reset()
Definition: hps.h:6833
HPS::Type ObjectType() const
Definition: hps.h:37722
HPS::Type ObjectType() const
Definition: hps.h:23846
HPS::Type ObjectType() const
Definition: hps.h:39922
SizeUnits
Definition: hps.h:1605
Event * Clone() const
Definition: hps.h:40878
MouseEvent(Event const &in_event)
Definition: hps.h:41633
virtual bool Empty() const
Definition: hps.h:5605
Join
Definition: hps.h:1827
HPS_INLINE void Merge(Sphere_3D< F > const &sphere)
Definition: hps.h:3915
Modifier
Definition: hps.h:1864
TouchEvent(Action in_action, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:41308
HighlightEvent()
Definition: hps.h:40656
virtual HPS::Type ObjectType() const
Definition: hps.h:5601
HPS::Type ObjectType() const
Definition: hps.h:13869
HPS::TouchEvent::Action CurrentAction
The action for the touches of this TouchEvent.
Definition: hps.h:41422
Type
Definition: hps.h:581
virtual intptr_t Freshen() const
Definition: hps.h:40639
Background
Definition: hps.h:239
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid) const
Definition: hps.h:3835
static ModifierKeys KeyControl()
Definition: hps.h:41204
HPS::Type ObjectType() const
Definition: hps.h:18419
HPS::Type ObjectType() const
Definition: hps.h:35673
ScreenRangePoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5870
HPS::Type ObjectType() const
Definition: hps.h:39714
StandAloneWindowEvent(Action in_action)
Definition: hps.h:40934
Mode
Definition: hps.h:1717
Event * Clone() const
Definition: hps.h:41038
HPS_INLINE Cuboid_3D & Expand(F border)
Definition: hps.h:4052
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3870
Type
Definition: hps.h:884
HPS_INLINE Vector_3D< F > Diagonal() const
Definition: hps.h:3823
HPS::Type ObjectType() const
Definition: hps.h:12328
HPS::Type ObjectType() const
Definition: hps.h:32377
HPS::Type ObjectType() const
Definition: hps.h:37820
HPS::Type ObjectType() const
Definition: hps.h:42392
HPS::Type ObjectType() const
Definition: hps.h:42070
HPS_INLINE void Generate_Cuboid_Points(Point_3D< F > *points) const
Definition: hps.h:3809
HPS::Type ObjectType() const
Definition: hps.h:36975
HPS::Type ObjectType() const
Definition: hps.h:12477
HPS::Type ObjectType() const
Definition: hps.h:17962
Mode
Definition: hps.h:1770
Event * Clone() const
Definition: hps.h:41784
HPS_INLINE bool Intersecting(Point_3D< F > const &start, Vector_3D< F > const &direction) const
Definition: hps.h:3881
Tiling
Definition: hps.h:987
HPS_INLINE Cuboid_3D & Union(Cuboid_3D const &cuboid)
Definition: hps.h:4037
WindowPoint(Point const &in_point)
Definition: hps.h:6022
Transform
Definition: hps.h:1560
HPS::Type ObjectType() const
Definition: hps.h:37290
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:38647
ModifierKeys()
Definition: hps.h:41093
Preference
Definition: hps.h:1585
HPS::Type ObjectType() const
Definition: hps.h:25382
Capping
Definition: hps.h:526
HPS::Type ObjectType() const
Definition: hps.h:35491
TouchEvent()
Definition: hps.h:41302
Interpolation
Definition: hps.h:1003
HPS::Type ObjectType() const
Definition: hps.h:20061
WarningEvent(char const *in_message)
Definition: hps.h:40780
HPS::Type ObjectType() const
Definition: hps.h:20854
Modifiers
Definition: hps.h:41218
Component
Definition: hps.h:518
HPS::Type ObjectType() const
Definition: hps.h:35981
HPS::Type ObjectType() const
Definition: hps.h:6529
HPS::Type ObjectType() const
Definition: hps.h:22628
HPS_INLINE Cuboid_3D & Intersect(Cuboid_3D const &cuboid)
Definition: hps.h:4022
HPS::Type ObjectType() const
Definition: hps.h:42927
HPS::Type ObjectType() const
Definition: hps.h:22418
Format
Definition: hps.h:37153
WarningEvent()
Definition: hps.h:40776
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:40633
Touch()
Definition: hps.h:6406
Component
Definition: hps.h:408
A unitless linear scaling factor. A value of 2.0 will cause lines to be rendered twice as thick...
float red
Definition: hps.h:4287
ClipSpace
Definition: hps.h:1313
Control & operator=(Control &&in_that)
Definition: hps.h:5658
WarningEvent(char const *in_message, HPS::Info::Code in_code)
Definition: hps.h:40785
HPS::Type ObjectType() const
Definition: hps.h:13974
SizeUnits
Definition: hps.h:42884
virtual void Reset()
Definition: hps.h:40577
HPS::Type ObjectType() const
Definition: hps.h:11365
bool Meta() const
Definition: hps.h:41137
HPS_INLINE Cuboid_3D & Contract(F border)
Definition: hps.h:4064
TimerTickEvent()
Definition: hps.h:40605
HPS::Type ObjectType() const
Definition: hps.h:22081
RenderingAlgorithm
Definition: hps.h:275
EmergencyHandler()
Definition: hps.h:40121
CameraPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5772
TouchID ID
TouchID for this Touch.
Definition: hps.h:6431
HPS::Type ObjectType() const
Definition: hps.h:10931
HPS::Type ObjectType() const
Definition: hps.h:33339
HPS::Type ObjectType() const
Definition: hps.h:8431
HandednessOptimization
Definition: hps.h:369
Projection
Definition: hps.h:1395
Control(Control &&in_that)
Definition: hps.h:5653
bool Control() const
Definition: hps.h:41129
HPS::Type ObjectType() const
Definition: hps.h:34858
HPS::Type ObjectType() const OVERRIDE
Definition: hps.h:8680
Overlay
Definition: hps.h:1285
Status
Definition: hps.h:6120
HPS::Type ObjectType() const
Definition: hps.h:34988
HPS::Type ObjectType() const
Definition: hps.h:6611
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:41713
HPS::Type ObjectType() const
Definition: hps.h:42180