16 # ifdef HPS_CORE_BUILD
17 # define HPS_API __declspec (dllexport)
18 # define EXPIMP_TEMPLATE
20 # define HPS_API __declspec (dllimport)
21 # define EXPIMP_TEMPLATE extern
23 # define HPS_TEMPLATE_API __declspec (dllexport)
33 # pragma warning(push)
34 # pragma warning(disable: 4251) //Not an issue as long as debug and release libraries aren't mixed
40 # ifdef HPS_CORE_BUILD
41 # define HPS_API __attribute__ ((visibility ("default")))
42 # define EXPIMP_TEMPLATE
44 # define EXPIMP_TEMPLATE extern
46 # define HPS_TEMPLATE_API __attribute__ ((visibility ("default")))
53 #ifndef HPS_TEMPLATE_API
54 # define HPS_TEMPLATE_API
56 #ifndef EXPIMP_TEMPLATE
57 # define EXPIMP_TEMPLATE
60 # define ENUM_CLASS enum class
82 class EventDispatcherImpl;
237 GradientTopLeftToBottomRight,
238 GradientTopRightToBottomLeft,
239 GradientBottomLeftToTopRight,
240 GradientBottomRightToTopLeft,
349 FeatureSizePercentage
550 SubsegmentsAndIncludes
591 Everything = 0x00ffffff,
594 Include = 0x00000042,
595 Segment = 0x00000043,
597 Includer = 0x00000100,
600 Geometry = 0x10000000,
607 NURBSSurface = 0x1000002b,
610 Polygon = 0x1000002f,
613 CircularWedge = 0x10000032,
614 Ellipse = 0x10000033,
616 NURBSCurve = 0x10000037,
617 CircularArc = 0x10000038,
618 EllipticalArc = 0x10000039,
623 Reference = 0x10000040,
626 DistantLight = 0x10000100,
628 InfiniteRay = 0x10000102,
631 Attribute = 0x20000000,
633 Priority = 0x20000001,
638 ModellingMatrix = 0x20000010,
639 UserData = 0x20000021,
640 TextureMatrix = 0x20000023,
643 Culling = 0x20001000,
644 CullingBackFace = 0x20001001,
645 CullingExtent = 0x20001002,
646 CullingVector = 0x20001003,
647 CullingVectorTolerance = 0x20001004,
648 CullingFrustum = 0x20001005,
649 CullingDeferralExtent = 0x20001006,
651 CurveAttribute = 0x20002000,
652 CurveAttributeBudget = 0x20002001,
653 CurveAttributeContinuedBudget = 0x20002002,
654 CurveAttributeViewDependent = 0x20002003,
655 CurveAttributeMaximumDeviation = 0x20002004,
656 CurveAttributeMaximumAngle = 0x20002005,
657 CurveAttributeMaximumLength = 0x20002006,
659 CylinderAttribute = 0x20003000,
660 CylinderAttributeTessellation = 0x20003001,
661 CylinderAttributeOrientation = 0x20003002,
664 EdgeAttribute = 0x20004000,
665 EdgeAttributePattern = 0x20004015,
666 EdgeAttributeWeight = 0x20004016,
668 LightingAttribute = 0x20005000,
669 LightingAttributeInterpolation = 0x20005001,
672 LineAttribute = 0x20006000,
673 LineAttributePattern = 0x20006019,
674 LineAttributeWeight = 0x2000601a,
677 MarkerAttribute = 0x20007000,
678 MarkerAttributeSize = 0x2000701b,
679 MarkerAttributeSymbol = 0x2000701c,
681 SurfaceAttribute = 0x20008000,
682 SurfaceAttributeBudget = 0x20008001,
683 SurfaceAttributeMaximumFacetDeviation = 0x20008002,
684 SurfaceAttributeMaximumFacetAngle = 0x20008003,
685 SurfaceAttributeMaximumFacetWidth = 0x20008004,
686 SurfaceAttributeTrimCurveBudget = 0x20008005,
687 SurfaceAttributeMaximumTrimCurveDeviation = 0x20008006,
690 SelectabilityWindows = 0x20009001,
691 SelectabilityEdges = 0x20009002,
692 SelectabilityFaces = 0x20009003,
693 SelectabilityLights = 0x20009004,
694 SelectabilityLines = 0x20009005,
695 SelectabilityMarkers = 0x20009006,
696 SelectabilityVertices = 0x20009007,
697 SelectabilityText = 0x20009008,
699 SphereAttribute = 0x2000a000,
700 SphereAttributeTessellation = 0x2000a001,
703 SubwindowEitherType = 0x2000b001,
704 SubwindowStandard = 0x2000b00d,
705 SubwindowLightweight = 0x2000b002,
706 SubwindowBackground = 0x2000b003,
707 SubwindowBorder = 0x2000b004,
708 SubwindowRenderingAlgorithm = 0x2000b005,
711 TextAttribute = 0x2000c000,
712 TextAttributeAlignment = 0x2000c01d,
713 TextAttributeBold = 0x2000c002,
714 TextAttributeItalic = 0x2000c003,
715 TextAttributeOverline = 0x2000c004,
716 TextAttributeStrikethrough = 0x2000c005,
717 TextAttributeUnderline = 0x2000c006,
718 TextAttributeSlant = 0x2000c007,
719 TextAttributeLineSpacing = 0x2000c008,
720 TextAttributeRotation = 0x2000c00a,
721 TextAttributeExtraSpace = 0x2000c00b,
722 TextAttributeGreeking = 0x2000c00c,
723 TextAttributeSizeTolerance = 0x2000c00d,
724 TextAttributeSize = 0x2000c00e,
725 TextAttributeFont = 0x2000c00f,
726 TextAttributeTransform = 0x2000c010,
727 TextAttributeRenderer = 0x2000c011,
728 TextAttributePreference = 0x2000c012,
729 TextAttributePath = 0x2000c01f,
730 TextAttributeSpacing = 0x2000c020,
733 TransparencyMethod = 0x2000d001,
734 TransparencyAlgorithm = 0x2000d002,
735 TransparencyDepthPeelingLayers = 0x2000d004,
736 TransparencyDepthPeelingMinimumArea = 0x2000d005,
737 TransparencyDepthWriting = 0x2000d006,
739 Visibility = 0x2000e000,
740 VisibilityCuttingSections = 0x2000e001,
741 VisibilityCutEdges = 0x2000e002,
742 VisibilityCutFaces = 0x2000e003,
743 VisibilityWindows = 0x2000e004,
744 VisibilityText = 0x2000e005,
745 VisibilityLines = 0x2000e006,
746 VisibilityEdgeLights = 0x2000e007,
747 VisibilityMarkerLights = 0x2000e008,
748 VisibilityFaceLights = 0x2000e009,
749 VisibilityGenericEdges = 0x2000e00a,
750 VisibilityHardEdges = 0x2000e00b,
751 VisibilityAdjacentEdges = 0x2000e00c,
752 VisibilityInteriorSilhouetteEdges = 0x2000e00d,
753 VisibilityShadowEmitting = 0x2000e00e,
754 VisibilityShadowReceiving = 0x2000e00f,
755 VisibilityShadowCasting = 0x2000e010,
756 VisibilityMarkers = 0x2000e011,
757 VisibilityVertices = 0x2000e012,
758 VisibilityFaces = 0x2000e013,
759 VisibilityPerimeterEdges = 0x2000e014,
760 VisibilityNonCulledEdges = 0x2000e015,
761 VisibilityMeshQuadEdges = 0x2000e016,
763 VisualEffects = 0x2000f000,
764 VisualEffectsPostProcessEffectsEnabled = 0x2000f001,
765 VisualEffectsAntiAliasing = 0x2000f002,
766 VisualEffectsShadowMaps = 0x2000f003,
767 VisualEffectsSimpleShadow = 0x2000f004,
768 VisualEffectsSimpleShadowPlane = 0x2000f005,
769 VisualEffectsSimpleShadowLightDirection = 0x2000f006,
770 VisualEffectsSimpleShadowColor = 0x2000f007,
771 VisualEffectsSimpleReflection = 0x2000f008,
772 VisualEffectsSimpleReflectionPlane = 0x2000f009,
773 VisualEffectsSimpleReflectionVisibility = 0x2000f00a,
776 PerformanceDisplayLists = 0x20010001,
777 PerformanceStaticModel = 0x20010002,
778 StaticModelSegment = 0x40000043,
781 DrawingAttribute = 0x20011000,
782 DrawingAttributePolygonHandedness = 0x20011001,
783 DrawingAttributeDepthRange = 0x20011002,
784 DrawingAttributeFaceDisplacement = 0x20011003,
785 DrawingAttributeGeneralDisplacement = 0x20011004,
786 DrawingAttributeVertexDisplacement = 0x20011005,
787 DrawingAttributeOverlay = 0x20011006,
788 DrawingAttributeDeferral = 0x20011007,
789 DrawingAttributeWorldHandedness = 0x20011018,
790 DrawingAttributeClipRegion = 0x20011019,
792 HiddenLineAttribute = 0x20012000,
793 HiddenLineAttributeColor = 0x20012001,
794 HiddenLineAttributeDimFactor = 0x20012002,
795 HiddenLineAttributeFaceDisplacement = 0x20012003,
796 HiddenLineAttributeLinePattern = 0x20012005,
797 HiddenLineAttributeRenderFaces = 0x20012006,
798 HiddenLineAttributeRenderText = 0x20012007,
799 HiddenLineAttributeAlgorithm = 0x20012008,
800 HiddenLineAttributeSilhouetteCleanup = 0x20012009,
801 HiddenLineAttributeVisibility = 0x2001200a,
802 HiddenLineAttributeWeight = 0x2001200b,
803 HiddenLineAttributeTransparencyCutoff = 0x2001200c,
805 SegmentStyle = 0x20013001,
806 NamedStyle = 0x20013002,
807 MaterialPalette = 0x20013003,
808 Portfolio = 0x20013004,
811 ContourLineVisibility = 0x20014001,
812 ContourLinePosition = 0x20014002,
813 ContourLineColor = 0x20014003,
814 ContourLinePattern = 0x20014004,
815 ContourLineWeight = 0x20014005,
816 ContourLineLighting = 0x20014006,
821 BoundingVolume = 0x20016001,
822 BoundingExclusion = 0x20016002,
825 AttributeLockSetting = 0x20017001,
826 AttributeLockSubsegmentOverride = 0x20017002,
828 TransformMask = 0x20018000,
829 TransformMaskCamera = 0x20018001,
830 TransformMaskCameraTranslation = 0x20018002,
831 TransformMaskCameraScale = 0x20018003,
832 TransformMaskCameraOffset = 0x20018004,
833 TransformMaskCameraRotation = 0x20018005,
834 TransformMaskCameraPerspectiveScale = 0x20018006,
835 TransformMaskCameraProjection = 0x20018007,
836 TransformMaskModellingMatrix = 0x20018008,
837 TransformMaskModellingMatrixTranslation = 0x20018009,
838 TransformMaskModellingMatrixScale = 0x20018010,
839 TransformMaskModellingMatrixOffset = 0x20018011,
840 TransformMaskModellingMatrixRotation = 0x20018012,
842 ColorInterpolation = 0x20019000,
843 ColorInterpolationFaceColor = 0x20019001,
844 ColorInterpolationEdgeColor = 0x20019002,
845 ColorInterpolationMarkerColor = 0x20019003,
846 ColorInterpolationFaceIndex = 0x20019004,
847 ColorInterpolationEdgeIndex = 0x20019005,
848 ColorInterpolationMarkerIndex = 0x20019006,
850 CuttingSectionAttribute = 0x2001a000,
851 CuttingSectionAttributeCuttingLevel = 0x2001a001,
852 CuttingSectionAttributeCappingLevel = 0x2001a002,
853 CuttingSectionAttributeMaterialPreference = 0x2001a003,
871 InvalidMaterialIndex = -1,
898 EnvironmentTexture = 8,
899 EnvironmentCubeMap = 9,
938 EnvironmentTexture = 8,
939 EnvironmentCubeMap = 9
1085 GeometryDisplayLists,
1104 AttributeStaticModel,
1105 AttributeSpatialStaticModel
1121 Everything = 0x01000000,
1123 Visibility = 0x02000000,
1125 VisibilityCuttingSections,
1131 VisibilityEdgeLights,
1132 VisibilityMarkerLights,
1133 VisibilityFaceLights,
1134 VisibilityGenericEdges,
1135 VisibilityHardEdges,
1136 VisibilityAdjacentEdges,
1137 VisibilityInteriorSilhouetteEdges,
1138 VisibilityShadowEmitting,
1139 VisibilityShadowReceiving,
1140 VisibilityShadowCasting,
1144 VisibilityPerimeterEdges,
1145 VisibilityNonCulledEdges,
1146 VisibilityMeshQuadEdges,
1147 VisibilityCutGeometry,
1156 MaterialCutGeometry,
1158 MaterialAmbientLightUpColor,
1159 MaterialAmbientLightDownColor,
1160 MaterialAmbientLightColor,
1162 MaterialWindowColor,
1163 MaterialWindowContrastColor,
1167 MaterialMarkerColor,
1169 MaterialCutEdgeColor,
1172 MaterialVertexDiffuse,
1173 MaterialVertexDiffuseColor,
1174 MaterialVertexDiffuseAlpha,
1175 MaterialVertexDiffuseTexture,
1176 MaterialVertexSpecular,
1177 MaterialVertexMirror,
1178 MaterialVertexTransmission,
1179 MaterialVertexEmission,
1180 MaterialVertexEnvironment,
1182 MaterialVertexGloss,
1185 MaterialEdgeDiffuse,
1186 MaterialEdgeDiffuseColor,
1187 MaterialEdgeDiffuseAlpha,
1188 MaterialEdgeDiffuseTexture,
1189 MaterialEdgeSpecular,
1191 MaterialEdgeTransmission,
1192 MaterialEdgeEmission,
1193 MaterialEdgeEnvironment,
1198 MaterialFaceDiffuse,
1199 MaterialFaceDiffuseColor,
1200 MaterialFaceDiffuseAlpha,
1201 MaterialFaceDiffuseTexture,
1202 MaterialFaceSpecular,
1204 MaterialFaceTransmission,
1205 MaterialFaceEmission,
1206 MaterialFaceEnvironment,
1211 MaterialBackFaceDiffuse,
1212 MaterialBackFaceDiffuseColor,
1213 MaterialBackFaceDiffuseAlpha,
1214 MaterialBackFaceDiffuseTexture,
1215 MaterialBackFaceSpecular,
1216 MaterialBackFaceMirror,
1217 MaterialBackFaceTransmission,
1218 MaterialBackFaceEmission,
1219 MaterialBackFaceEnvironment,
1220 MaterialBackFaceBump,
1221 MaterialBackFaceGloss,
1224 MaterialFrontFaceDiffuse,
1225 MaterialFrontFaceDiffuseColor,
1226 MaterialFrontFaceDiffuseAlpha,
1227 MaterialFrontFaceDiffuseTexture,
1228 MaterialFrontFaceSpecular,
1229 MaterialFrontFaceMirror,
1230 MaterialFrontFaceTransmission,
1231 MaterialFrontFaceEmission,
1232 MaterialFrontFaceEnvironment,
1233 MaterialFrontFaceBump,
1234 MaterialFrontFaceGloss,
1237 MaterialCutFaceDiffuse,
1238 MaterialCutFaceDiffuseColor,
1239 MaterialCutFaceDiffuseAlpha,
1240 MaterialCutFaceDiffuseTexture,
1241 MaterialCutFaceSpecular,
1242 MaterialCutFaceMirror,
1243 MaterialCutFaceTransmission,
1244 MaterialCutFaceEmission,
1245 MaterialCutFaceEnvironment,
1246 MaterialCutFaceBump,
1247 MaterialCutFaceGloss,
1553 CharacterPositionOnly,
1556 CharacterPositionAdjusted
1777 UnableToLoadLibraries,
1778 VersionIncompatibility,
1779 InitializationFailed,
1940 TriangleDownWithDot,
1943 TriangleRightWithDot,
1946 TriangleLeftWithDot,
1953 SolidTriangleRightV,
2015 # define HPS_INLINE __forceinline
2018 # define HPS_INLINE inline
2021 #ifndef HPS_UNREFERENCED
2022 #define HPS_UNREFERENCED(param) ((void)(param))
2026 const double PI = 3.141592653589793238462643383279502884197169399375105820974944592308;
2028 template<
typename T>
2029 HPS_INLINE T Degrees_To_Radians(T
const & degrees)
2031 return degrees * (T)(PI / 180.0);
2034 template<
typename T>
2035 HPS_INLINE T Radians_To_Degrees(T
const & radians)
2037 return radians * (T)(180.0 / PI);
2040 template<
typename T>
2041 HPS_INLINE
void SinCos(T
const & angle, T & sine, T & cosine) {
2042 T a = Degrees_To_Radians(angle);
2047 template<
typename T>
2048 HPS_INLINE T Cos(T
const & angle) {
2049 return cos (Degrees_To_Radians(angle));
2052 template<
typename T>
2053 HPS_INLINE T Sin(T
const & angle) {
2054 return sin (Degrees_To_Radians(angle));
2057 template<
typename T>
2058 HPS_INLINE T ACos(T
const & x) {
2063 return Radians_To_Degrees(acos(x));
2066 template<
typename T>
2067 HPS_INLINE T ATan2(T
const & y, T
const & x) {
2068 if (x == 0 && y == 0)
2070 return Radians_To_Degrees(atan2(y, x));
2076 typedef double Alternative;
2077 static const int Type = 1;
2078 static float Epsilon () {
return 1.0e-30f; }
2081 typedef float Alternative;
2082 static const int Type = 2;
2083 static double Epsilon () {
return 1.0e-300; }
2092 # if HOOPS_BIGENDIAN
2100 static HPS_INLINE
bool is_infinite(int32_t
const & v) {
return (v & 0x7FFFFFFF) == 0x7F800000; }
2101 static HPS_INLINE
bool is_infinite(uint32_t
const & v) {
return (v & 0x7FFFFFFF) == 0x7F800000; }
2102 static HPS_INLINE
bool is_infinite(int32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2103 static HPS_INLINE
bool is_infinite(uint32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2105 static HPS_INLINE
bool is_nan(int32_t
const & v) {
2106 uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2107 return exp == 0x7F800000 && mantissa != 0;
2109 static HPS_INLINE
bool is_nan(uint32_t
const & v) {
2110 uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2111 return exp == 0x7F800000 && mantissa != 0;
2113 static HPS_INLINE
bool is_nan(int32_t
const * v) {
2114 uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2115 return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2117 static HPS_INLINE
bool is_nan(uint32_t
const * v) {
2118 uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2119 return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2122 static HPS_INLINE
bool is_special(int32_t
const & v) {
return (v & 0x7F800000) == 0x7F800000; }
2123 static HPS_INLINE
bool is_special(uint32_t
const & v) {
return (v & 0x7F800000) == 0x7F800000; }
2124 static HPS_INLINE
bool is_special(int32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2125 static HPS_INLINE
bool is_special(uint32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2134 static HPS_INLINE
bool IsInfinite(
float const & a) {
return is_infinite (extract_uint32_t(a)); }
2135 static HPS_INLINE
bool IsInfinite(
double const & a) {
2137 memcpy (v, &a,
sizeof(
double));
2138 return is_infinite (v);
2142 static HPS_INLINE
bool IsNAN(
float const & a) {
return is_nan (extract_uint32_t(a)); }
2143 static HPS_INLINE
bool IsNAN(
double const & a) {
2145 memcpy (v, &a,
sizeof(
double));
2150 static HPS_INLINE
bool IsAbnormal(
float const & a) {
return is_special (extract_uint32_t(a)); }
2151 static HPS_INLINE
bool IsAbnormal(
double const & a) {
2153 memcpy (v, &a,
sizeof(
double));
2154 return is_special (v);
2159 static HPS_INLINE
bool Equals(
float const & a,
float const & b,
int tolerance = 32);
2160 static HPS_INLINE
bool Equals(
double const & a,
double const & b,
int tolerance = 32);
2162 #ifndef HOOPS_DEFINED
2163 template <
typename Alloc>
2164 static HPS_INLINE
bool Equals(std::vector<float, Alloc>
const & a, std::vector<float, Alloc>
const & b,
int tolerance = 32)
2166 if (a.size() != b.size())
2169 auto it1 = a.begin();
2170 auto it2 = b.begin();
2171 auto const end = a.end();
2172 for ( ; it1 != end; ++it1, ++it2)
2174 if (!Equals(*it1, *it2, tolerance))
2181 static HPS_INLINE uint32_t extract_sign_bit(
float const & a) {
2182 return extract_uint32_t(a) & 0x80000000;
2184 static HPS_INLINE uint32_t extract_sign_bit(
double const & a) {
2186 memcpy (v, &a,
sizeof(
double));
2187 return v[High] & 0x80000000;
2190 static HPS_INLINE
void apply_sign_bit(
float & a, uint32_t
const & sign_bit) {
2191 uint32_t v = extract_uint32_t(a);
2194 inject_uint32_t(a, v);
2196 static HPS_INLINE
void apply_sign_bit(
double & a, uint32_t
const & sign_bit) {
2198 memcpy (v, &a,
sizeof(
double));
2199 v[High] &= 0x7FFFFFFF;
2200 v[High] |= sign_bit;
2201 memcpy (&a, v,
sizeof(
double));
2205 static HPS_INLINE
unsigned char unit_to_byte(
float const & a) {
2206 uint32_t v = extract_uint32_t(a);
2214 uint32_t exp = v >> 23;
2215 uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2217 return (
unsigned char) (man >> (16 + 126 - exp));
2220 static HPS_INLINE
unsigned char unit_to_byte_scaled(
float const & a,
unsigned char mix) {
2221 uint32_t v = extract_uint32_t(a);
2229 uint32_t exp = v >> 23;
2230 uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2232 uint32_t x = (man >> (16 + 126 - exp));
2234 return (
unsigned char) ((x * (mix+1)) >> 8);
2238 static HPS_INLINE
bool match(
float const & a,
float const & b) {
2239 uint32_t va = extract_uint32_t(a);
2240 uint32_t vb = extract_uint32_t(b);
2242 if (((va | vb) & 0x7FFFFFFF) == 0)
2247 static HPS_INLINE
bool match(
double const & a,
double const & b) {
2252 static HPS_INLINE
void replace_if_smaller(
float & a,
float const & b) {
2253 uint32_t va = extract_uint32_t(a);
2254 uint32_t vb = extract_uint32_t(b);
2256 uint32_t a_sign = va & 0x80000000;
2257 uint32_t b_sign = vb & 0x80000000;
2259 (int32_t&)a_sign >>= 31;
2260 (int32_t&)b_sign >>= 31;
2262 uint32_t mash = (a_sign&b_sign);
2267 if ((int32_t&)vb < (int32_t&)va)
2268 memcpy(&a, &b,
sizeof(
float));
2270 static HPS_INLINE
void replace_if_smaller(
double & a,
double const & b) {
2275 static HPS_INLINE
void replace_if_larger(
float & a,
float const & b) {
2276 uint32_t va = extract_uint32_t(a);
2277 uint32_t vb = extract_uint32_t(b);
2279 uint32_t a_sign = va & 0x80000000;
2280 uint32_t b_sign = vb & 0x80000000;
2282 (int32_t&)a_sign >>= 31;
2283 (int32_t&)b_sign >>= 31;
2285 uint32_t mash = (a_sign&b_sign);
2290 if ((int32_t&)vb > (int32_t&)va)
2291 memcpy(&a, &b,
sizeof(
float));
2293 static HPS_INLINE
void replace_if_larger(
double & a,
double const & b) {
2299 static HPS_INLINE uint32_t extract_uint32_t(
float const & a) {
2301 memcpy(&i, &a,
sizeof(
float));
2305 static HPS_INLINE
void inject_uint32_t(
float & a, uint32_t
const & i) {
2306 memcpy(&a, &i,
sizeof(
float));
2309 static HPS_INLINE
float C2F(
unsigned char x) {
2311 return char_to_float[x];
2316 static HPS_INLINE
void pack_4(
float const & f,
float * m) {
2317 memcpy(&m[0], &f,
sizeof(
float));
2318 memcpy(&m[1], &f,
sizeof(
float));
2319 memcpy(&m[2], &f,
sizeof(
float));
2320 memcpy(&m[3], &f,
sizeof(
float));
2323 static HPS_INLINE
void pack_4(
float const & f0,
float const & f1,
float const & f2,
float const & f3,
float * m) {
2324 memcpy(&m[0], &f0,
sizeof(
float));
2325 memcpy(&m[1], &f1,
sizeof(
float));
2326 memcpy(&m[2], &f2,
sizeof(
float));
2327 memcpy(&m[3], &f3,
sizeof(
float));
2330 static HPS_INLINE
void unpack_4(
float * f0,
float const *
const m) {
2331 memcpy(f0, m,
sizeof(
float)*4);
2334 static HPS_INLINE
void unpack_4(
float & f0,
float & f1,
float & f2,
float & f3,
float const *
const m) {
2335 memcpy(&f0, &m[0],
sizeof(
float));
2336 memcpy(&f1, &m[1],
sizeof(
float));
2337 memcpy(&f2, &m[2],
sizeof(
float));
2338 memcpy(&f3, &m[3],
sizeof(
float));
2342 static const float char_to_float[256];
2351 template <
typename T> HPS_INLINE T * Alter (T
const * a) {
return const_cast<T *
>(a); }
2352 template <
typename T> HPS_INLINE T & Alter (T
const & a) {
return const_cast<T &
>(a); }
2354 template <
typename T> HPS_INLINE T Abs (T
const & a) {
return a < 0 ? -a : a; }
2355 template <
typename T> HPS_INLINE
int Compare (T
const & a, T
const & b) {
return a == b ? 0 : a < b ? -1 : 1; }
2356 template <
typename T> HPS_INLINE
int Sign (T
const & a) {
return Compare(a,(T)0); }
2357 template <
typename T> HPS_INLINE
void Swap (T & a, T & b) { T temp = a; a = b; b = temp; }
2358 template <
typename T> HPS_INLINE
int Floor(T
const & a) {
return ((a > 0 || (T)(
int)a == a) ? (
int)a : ((
int)a - 1)); }
2359 template <
typename T> HPS_INLINE
int Ceiling(T
const & a) {
return ((a < 0 || (T)(
int)a == a) ? (
int)a : ((
int)a + 1)); }
2361 template <
typename T> HPS_INLINE T
const & Min (T
const & a, T
const & b) {
return a < b ? a : b; }
2362 template <
typename T> HPS_INLINE T
const & Min (T
const & a, T
const & b, T
const & c) {
return Min(Min(a,b),c); }
2363 template <
typename T> HPS_INLINE T
const & Min (T
const & a, T
const & b, T
const & c, T
const & d) {
return Min(Min(a, b, c),d); }
2364 template <
typename T> HPS_INLINE T
const & Min (T
const & a, T
const & b, T
const & c, T
const & d, T
const & e) {
return Min(Min(a,b,c,d),e); }
2365 template <
typename T> HPS_INLINE T
const & Min (T
const & a, T
const & b, T
const & c, T
const & d, T
const & e, T
const & f) {
return Min(Min(a,b,c,d,e),f); }
2367 template <
typename T> HPS_INLINE T
const & Max (T
const & a, T
const & b) {
return a > b ? a : b; }
2368 template <
typename T> HPS_INLINE T
const & Max (T
const & a, T
const & b, T
const & c) {
return Max(Max(a,b),c); }
2369 template <
typename T> HPS_INLINE T
const & Max (T
const & a, T
const & b, T
const & c, T
const & d) {
return Max(Max(a, b, c),d); }
2370 template <
typename T> HPS_INLINE T
const & Max (T
const & a, T
const & b, T
const & c, T
const & d, T
const & e) {
return Max(Max(a,b,c,d),e); }
2371 template <
typename T> HPS_INLINE T
const & Max (T
const & a, T
const & b, T
const & c, T
const & d, T
const & e, T
const & f) {
return Max(Max(a,b,c,d,e),f); }
2373 template <
typename T> HPS_INLINE T
const & Clamp(T
const & x, T
const & min, T
const & max) {
return x < min ? min : x > max ? max : x; }
2376 template <> HPS_INLINE
float Abs<float> (
float const & a) {
2377 uint32_t v = Float::extract_uint32_t(a);
2380 Float::inject_uint32_t(f,v);
2384 template <> HPS_INLINE
int Sign<float> (
float const & a) {
2385 uint32_t v = Float::extract_uint32_t(a);
2387 if ((v & 0x7FFFFFFF) == 0)
2390 return ((int32_t)(v & 0x80000000)>>31) | 0x01;
2393 template <> HPS_INLINE
int Compare<float> (
float const & a,
float const & b) {
2394 int a_sign = Sign(a);
2395 int b_sign = Sign(b);
2397 if (a_sign != b_sign)
2398 return Compare(a_sign, b_sign);
2400 uint32_t v = Float::extract_uint32_t(a);
2401 uint32_t u = Float::extract_uint32_t(b);
2403 return Compare((v & 0x7FFFFFFF), (u & 0x7FFFFFFF)) * a_sign;
2406 template <> HPS_INLINE
float const & Min<float> (
float const & a,
float const & b) {
2412 template <> HPS_INLINE
float const & Max<float> (
float const & a,
float const & b) {
2421 HPS_INLINE
bool Float::Equals(
float const & a,
float const & b,
int tolerance) {
2422 int32_t va = Float::extract_uint32_t(a);
2423 int32_t vb = Float::extract_uint32_t(b);
2425 if (is_special(va) || is_special(vb)) {
2426 if (is_infinite(va) || is_infinite(vb))
2428 if (is_nan(va) || is_nan(vb))
2432 int const close_to_zero = 0x36A00000;
2433 if ((va & 0x7FFFFFFF) == 0)
2434 return (vb & 0x7FFFFFFF) < close_to_zero;
2435 else if ((vb & 0x7FFFFFFF) == 0)
2436 return (va & 0x7FFFFFFF) < close_to_zero;
2438 uint32_t sign_mask = va ^ vb;
2439 (int32_t &)sign_mask >>= 31;
2441 int32_t diff = ((va + sign_mask) ^ (sign_mask & 0x7FFFFFFF)) -vb;
2442 int32_t v1 = tolerance + diff;
2443 int32_t v2 = tolerance - diff;
2444 return (v1|v2) >= 0;
2447 HPS_INLINE
bool Float::Equals(
double const & a,
double const & b,
int tolerance) {
2448 int32_t va[2], vb[2];
2449 memcpy (va, &a,
sizeof(
double));
2450 memcpy (vb, &b,
sizeof(
double));
2452 if (is_special(va) || is_special(vb)) {
2453 if (is_infinite(va) || is_infinite(vb))
2454 return va[High] == vb[High] && va[Low] == vb[Low];
2455 if (is_nan(va) || is_nan(vb))
2459 if ((va[High] == 0 && va[Low] == 0) || (vb[High] == 0 && vb[Low] == 0))
2460 return Abs(a - b) < 0.000000000000005;
2462 if (extract_sign_bit(a) != extract_sign_bit(b))
2465 if (va[High] != vb[High])
2468 return Abs(va[Low] - vb[Low]) <= tolerance;
2475 HPS_INLINE
bool Is_Abnormal (
double const & d) {
return Float::IsAbnormal (d); }
2477 template <
typename T>
2478 HPS_INLINE
bool Is_Abnormal (
size_t count, T
const * t) {
2480 if (Is_Abnormal (*t++))
2485 template <
typename T>
2486 HPS_INLINE
bool Is_Abnormal (
int count, T
const * t) {
2487 return count >= 0 && Is_Abnormal((
size_t)count, t);
2494 template <
typename F>
class HPS_TEMPLATE_API Vector_3D;
2495 template <
typename F>
class HPS_TEMPLATE_API Plane_3D;
2496 template <
typename F>
class HPS_TEMPLATE_API Vector_2D;
2497 template <
typename F>
class HPS_TEMPLATE_API Point_2D;
2500 template <
typename F>
2508 Point_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2510 template <
typename D>
2511 explicit Point_3D (
Point_3D<D> const & that) : x ((F)that.x), y ((F)that.y), z ((F)that.z) {}
2519 bool operator== (
Point_3D const & p)
const {
return x == p.x && y == p.y && z == p.z; }
2520 bool operator!= (
Point_3D const & p)
const {
return !(*
this == p); }
2522 bool Equals(
Point_3D const & p,
int in_tolerance = 32)
const {
2529 Point_3D & operator*= (F s) { x *= s; y *= s; z *= s;
return *
this; }
2530 Point_3D & operator/= (F s) {
return operator*= ((F)1 / s); }
2531 Point_3D const operator* (F s)
const {
return Point_3D (x * s, y * s, z * s); }
2532 Point_3D const operator/ (F s)
const {
return operator* ((F)1 / s); }
2534 F & operator[] (
size_t i) {
return (&x)[i]; }
2535 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2568 template <
typename F,
typename S>
2571 template <
typename F>
2572 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F>
const & a, Point_3D<F>
const & b) {
2573 return Point_3D<F> (a.x + b.x, a.y + b.y, a.z + b.z) * 0.5f;
2576 template <
typename F>
2577 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F>
const & a, Point_3D<F>
const & b, Point_3D<F>
const & c) {
2578 return Point_3D<F> (a.x + b.x + c.x, a.y + b.y + c.y, a.z + b.z + c.z) * (F)(1.0/3.0);
2581 template <
typename F>
2582 HPS_INLINE
bool Is_Abnormal (Point_3D<F>
const & p) {
2583 return Is_Abnormal (p.x) || Is_Abnormal (p.y) || Is_Abnormal (p.z);
2587 template <
typename F>
2594 Point_2D (F v1, F v2) : x (v1), y (v2) {}
2596 template <
typename D>
2604 bool operator== (
Point_2D const & p)
const {
return x == p.x && y == p.y; }
2605 bool operator!= (
Point_2D const & p)
const {
return !(*
this == p); }
2607 bool Equals(
Point_2D const & p,
int in_tolerance = 32)
const {
2612 Point_2D & operator*= (F s) { x *= s; y *= s;
return *
this; }
2613 Point_2D & operator/= (F s) {
return operator*= ((F)1 / s); }
2615 Point_2D const operator/ (F s)
const {
return operator* ((F)1 / s); }
2617 F & operator[] (
size_t i) {
return (&x)[i]; }
2618 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2639 template <
typename F>
2642 template <
typename F,
typename S>
2643 HPS_INLINE Point_2D<F> operator* (S s, Point_2D<F>
const & a) {
return Point_2D<F> (F(s * a.x), F(s * a.y)); }
2645 template <
typename F>
2646 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F>
const & a, Point_2D<F>
const & b) {
2647 return Point_2D<F> (a.x + b.x, a.y + b.y) * 0.5f;
2650 template <
typename F>
2651 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F>
const & a, Point_2D<F>
const & b, Point_2D<F>
const & c) {
2652 return Point_2D<F> (a.x + b.x + c.x, a.y + b.y + c.y, a.z + b.z + c.z) * (F)(1.0/3.0);
2655 template <
typename F>
2656 HPS_INLINE
bool Is_Abnormal (Point_2D<F>
const & p) {
2657 return Is_Abnormal (p.x) || Is_Abnormal (p.y);
2661 template <
typename F>
2669 Vector_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2670 template <
typename D>
2679 bool operator== (
Vector_3D const & v)
const {
2680 return Float::match(x, v.x) && Float::match(y, v.y) && Float::match(z, v.z);
2682 bool operator!= (
Vector_3D const & v)
const {
return !(*
this == v); }
2684 bool Equals(
Vector_3D const & v,
int in_tolerance = 32)
const {
2690 Vector_3D & operator+= (
Vector_3D const & v) { x += v.x; y += v.y; z += v.z;
return *
this; }
2691 Vector_3D & operator-= (
Vector_3D const & v) { x -= v.x; y -= v.y; z -= v.z;
return *
this; }
2695 Vector_3D & operator*= (F s) { x *= s; y *= s; z *= s;
return *
this; }
2696 Vector_3D & operator/= (F s) {
return operator*= (1.0f / s); }
2698 Vector_3D const operator/ (F s)
const {
return operator* (1.0f / s); }
2700 F & operator[] (
size_t i) {
return (&x)[i]; }
2701 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2703 HPS_INLINE
double Length ()
const {
return sqrt (LengthSquared()); }
2705 HPS_INLINE
double LengthSquared ()
const {
return (
double)x*(double)x + (
double)y*(double)y + (
double)z*(double)z; }
2707 HPS_INLINE
double Length2D ()
const {
return sqrt (LengthSquared2D()); }
2709 HPS_INLINE
double LengthSquared2D ()
const {
return (
double)x*(double)x + (
double)y*(double)y;}
2713 F range = Max (Abs (x), Abs (y), Abs (z));
2714 if (range > F(1.0e10))
2718 F len = (F)Length();
2725 HPS_INLINE
Vector_3D & Normalize (F epsilon) {
return Normalize (
false, epsilon); }
2727 HPS_INLINE F Magnitude ()
const {
return Max (Abs(x), Abs(y), Abs(z)); }
2728 HPS_INLINE F Manhattan ()
const {
return Abs(x)+Abs(y)+Abs(z); }
2730 HPS_INLINE F Dot (
Vector_3D const & v)
const {
return x * v.x + y * v.y + z * v.z; }
2733 return Vector_3D (y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
2738 return Vector_3D (x * v.x, y * v.y, z * v.z);
2752 template <
typename F,
typename S>
2755 template <
typename F>
2756 HPS_INLINE
bool Is_Abnormal (Vector_3D<F>
const & v) {
2757 return Is_Abnormal (v.x) || Is_Abnormal (v.y) || Is_Abnormal (v.z);
2761 template <
typename F>
2762 HPS_INLINE Point_3D<F>::Point_3D(Vector_3D<F>
const & v) : x(v.x), y(v.y), z(v.z) {}
2764 template <
typename F>
2765 HPS_INLINE Point_3D<F> & Point_3D<F>::operator+= (Vector_3D<F>
const & v) { x += v.x; y += v.y; z += v.z;
return *
this; }
2766 template <
typename F>
2767 HPS_INLINE Point_3D<F> & Point_3D<F>::operator-= (Vector_3D<F>
const & v) { x -= v.x; y -= v.y; z -= v.z;
return *
this; }
2769 template <
typename F>
2770 HPS_INLINE Vector_3D<F>
const Point_3D<F>::operator- (Point_3D<F>
const & p)
const {
return Vector_3D<F> (x - p.x, y - p.y, z - p.z); }
2772 template <
typename F>
2773 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator+ (Vector_3D<F>
const & v)
const {
return Point_3D<F> (x + v.x, y + v.y, z + v.z); }
2774 template <
typename F>
2775 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator- (Vector_3D<F>
const & v)
const {
return Point_3D<F> (x - v.x, y - v.y, z - v.z); }
2777 template <
typename F>
2778 HPS_INLINE Point_3D<F> & Point_3D<F>::operator*= (Vector_3D<F>
const & v) { x *= v.x; y *= v.y; z *= v.z;
return *
this; }
2779 template <
typename F>
2780 HPS_INLINE Point_3D<F> & Point_3D<F>::operator/= (Vector_3D<F>
const & v) { x /= v.x; y /= v.y; z /= v.z;
return *
this; }
2781 template <
typename F>
2782 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator* (Vector_3D<F>
const & v)
const {
return Point_3D<F> (x * v.x, y * v.y, z * v.z); }
2783 template <
typename F>
2784 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator/ (Vector_3D<F>
const & v)
const {
return Point_3D<F> (x / v.x, y / v.y, z / v.z); }
2788 template <
typename F>
2789 HPS_INLINE Point_3D<F> Interpolate(Point_3D<F>
const & a, Point_3D<F>
const & b,
float t) {
2790 return a + (b - a) * t;
2793 template <
typename F>
2794 HPS_INLINE Vector_3D<F> Interpolate(Vector_3D<F>
const & a, Vector_3D<F>
const & b,
float t) {
2795 return Vector_3D<F>(a + (b - a) * t).Normalize();
2800 template <
typename F>
2801 HPS_INLINE
double PointToPointDistance(Point_3D<F>
const & p1, Point_3D<F>
const & p2) {
2802 return (p2 - p1).Length();
2805 template <
typename F>
2806 HPS_INLINE
double PointToPointDistanceSquared(Point_3D<F>
const & p1, Point_3D<F>
const & p2) {
2807 return (p2 - p1).LengthSquared();
2810 template <
typename F>
2811 HPS_INLINE Point_3D<F> Circumcenter(Point_3D<F>
const & a, Point_3D<F>
const & b, Point_3D<F>
const & c) {
2812 F p =
static_cast<F
>((c - b).LengthSquared());
2813 F q =
static_cast<F
>((c - a).LengthSquared());
2814 F r =
static_cast<F
>((b - a).LengthSquared());
2817 (a * (p*(q+r-p)) + (Vector_3D<F>)b * (q*(r+p-q)) + (Vector_3D<F>)c * (r*(p+q-r)))
2818 / (2 * (p*q + p*r + q*r) - (p*p + q*q + r*r)) );
2823 template <
typename F>
2824 HPS_INLINE
bool Normalize(
size_t count, Vector_3D<F> * vectors) {
2825 bool success =
true;
2826 for (
size_t i = 0; i < count; ++i) {
2827 if (vectors->Normalize() == Vector_3D<F>::Zero())
2835 template <
typename F>
class HPS_TEMPLATE_API Plane_2D;
2837 template <
typename F>
2844 Vector_2D (F v1, F v2) : x (v1), y (v2) {}
2845 template <
typename D>
2854 bool operator== (
Vector_2D const & v)
const {
2855 return Float::match(x, v.x) && Float::match(y, v.y);
2857 bool operator!= (
Vector_2D const & v)
const {
return !(*
this == v); }
2859 bool Equals(
Vector_2D const & v,
int in_tolerance = 32)
const {
2868 Vector_2D & operator*= (F s) { x *= s; y *= s;
return *
this; }
2869 Vector_2D & operator/= (F s) {
return operator*= (1.0f / s); }
2871 Vector_2D const operator/ (F s)
const {
return operator* (1.0f / s); }
2873 F & operator[] (
size_t i) {
return (&x)[i]; }
2874 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2876 HPS_INLINE
double Length ()
const {
return sqrt (LengthSquared()); }
2878 HPS_INLINE
double LengthSquared ()
const {
return (
double)x*(double)x + (
double)y*(double)y; }
2882 F range = Max (Abs (x), Abs (y));
2883 if (range > F(1.0e10))
2887 F len = (F)Length();
2894 HPS_INLINE
Vector_2D & Normalize (F epsilon) {
return Normalize (
false, epsilon); }
2896 HPS_INLINE F Magnitude ()
const {
return Max (Abs(x), Abs(y)); }
2897 HPS_INLINE F Manhattan ()
const {
return Abs(x)+Abs(y); }
2899 HPS_INLINE F Dot (
Vector_2D const & v)
const {
return x * v.x + y * v.y; }
2902 HPS_INLINE
float Cross (
Vector_2D const & v)
const {
2903 return x * v.y - y * v.x;
2920 template <
typename F,
typename S>
2923 template <
typename F>
2924 HPS_INLINE
bool Is_Abnormal (Vector_2D<F>
const & v) {
2925 return Is_Abnormal (v.x) || Is_Abnormal (v.y);
2929 template <
typename F>
2930 HPS_INLINE Vector_3D<F>::Vector_3D (Vector_2D<F>
const & that) : x (that.x), y (that.y), z(0) {}
2932 template <
typename F>
2933 HPS_INLINE Point_3D<F>::Point_3D(Vector_2D<F>
const & v) : x(v.x), y(v.y), z(0) {}
2935 template <
typename F>
2936 HPS_INLINE Point_3D<F> & Point_3D<F>::operator+= (Vector_2D<F>
const & v) { x += v.x; y += v.y;
return *
this; }
2937 template <
typename F>
2938 HPS_INLINE Point_3D<F> & Point_3D<F>::operator-= (Vector_2D<F>
const & v) { x -= v.x; y -= v.y;
return *
this; }
2940 template <
typename F>
2941 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator+ (Vector_2D<F>
const & v)
const {
return Point_3D<F> (x + v.x, y + v.y, z); }
2942 template <
typename F>
2943 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator- (Vector_2D<F>
const & v)
const {
return Point_3D<F> (x - v.x, y - v.y, z); }
2945 template <
typename F>
2946 HPS_INLINE Point_3D<F> & Point_3D<F>::operator*= (Vector_2D<F>
const & v) { x *= v.x; y *= v.y;
return *
this; }
2947 template <
typename F>
2948 HPS_INLINE Point_3D<F> & Point_3D<F>::operator/= (Vector_2D<F>
const & v) { x /= v.x; y /= v.y;
return *
this; }
2950 template <
typename F>
2951 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator* (Vector_2D<F>
const & v)
const {
return Point_3D<F> (x * v.x, y * v.y, z); }
2952 template <
typename F>
2953 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator/ (Vector_2D<F>
const & v)
const {
return Point_3D<F> (x / v.x, y / v.y, z); }
2956 template <
typename F>
2957 HPS_INLINE Point_2D<F> & Point_2D<F>::operator+= (Vector_2D<F>
const & v) { x += v.x; y += v.y;
return *
this; }
2958 template <
typename F>
2959 HPS_INLINE Point_2D<F> & Point_2D<F>::operator-= (Vector_2D<F>
const & v) { x -= v.x; y -= v.y;
return *
this; }
2961 template <
typename F>
2962 HPS_INLINE Vector_2D<F>
const Point_2D<F>::operator- (Point_2D<F>
const & p)
const {
return Vector_2D<F> (x - p.x, y - p.y); }
2964 template <
typename F>
2965 HPS_INLINE Point_2D<F>
const Point_2D<F>::operator+ (Vector_2D<F>
const & v)
const {
return Point_2D<F> (x + v.x, y + v.y); }
2966 template <
typename F>
2967 HPS_INLINE Point_2D<F>
const Point_2D<F>::operator- (Vector_2D<F>
const & v)
const {
return Point_2D<F> (x - v.x, y - v.y); }
2969 template <
typename F>
2970 HPS_INLINE Point_2D<F> & Point_2D<F>::operator*= (Vector_2D<F>
const & v) { x *= v.x; y *= v.y;
return *
this; }
2971 template <
typename F>
2972 HPS_INLINE Point_2D<F> & Point_2D<F>::operator/= (Vector_2D<F>
const & v) { x /= v.x; y /= v.y;
return *
this; }
2973 template <
typename F>
2974 HPS_INLINE Point_2D<F>
const Point_2D<F>::operator* (Vector_2D<F>
const & v)
const {
return Point_2D<F> (x * v.x, y * v.y); }
2975 template <
typename F>
2976 HPS_INLINE Point_2D<F>
const Point_2D<F>::operator/ (Vector_2D<F>
const & v)
const {
return Point_2D<F> (x / v.x, y / v.y); }
2982 template <
typename F>
2991 Plane_3D (F v1, F v2, F v3, F v4) : a (v1), b (v2), c (v3), d (v4) {}
2995 template <
typename D>
2996 explicit Plane_3D (
Plane_3D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c), d ((F)that.d) {}
3012 for (
size_t i=0; i<count; ++i) {
3015 normal.x += (p0->y + p1->y) * (p1->z - p0->z);
3016 normal.y += (p0->z + p1->z) * (p1->x - p0->x);
3017 normal.z += (p0->x + p1->x) * (p1->y - p0->y);
3027 double inv_count = 1.0 / (double)count;
3035 *
this = Plane_3D::Zero();
3041 bool operator== (
Plane_3D const & p)
const {
return a == p.a && b == p.b && c == p.c && d == p.d; }
3042 bool operator!= (
Plane_3D const & p)
const {
return !(*
this == p); }
3044 F & operator[] (
size_t i) {
return (&a)[i]; }
3045 F
const & operator[] (
size_t i)
const {
return (&a)[i]; }
3047 HPS_INLINE
bool Equals(
Plane_3D const & p,
int in_tolerance = 32)
const {
3062 F val1 = Abs (a * p1.x + b * p1.y + c * p1.z + d);
3063 F val2 = Abs (a * p2.x + b * p2.y + c * p2.z + d);
3066 return Point_3D<F> (((val1 * p2.x) + (val2 * p1.x)) / (val1 + val2),
3067 ((val1 * p2.y) + (val2 * p1.y)) / (val1 + val2),
3068 ((val1 * p2.z) + (val2 * p1.z)) / (val1 + val2));
3075 F u = (a * p1.x + b * p1.y + c * p1.z + d) /
3076 (a * (p1.x - p2.x) + b * (p1.y - p2.y) + c * (p1.z - p2.z));
3078 return Point_3D<F>(p1.x + u * (p2.x - p1.x), p1.y + u * (p2.y - p1.y), p1.z + u * (p2.z - p1.z));
3081 static HPS_INLINE
Plane_3D Zero() {
return Plane_3D (0.0f, 0.0f, 0.0f, 0.0f);};
3085 Plane_3D & operator*= (F s) { a *= s; b *= s; c *= s; d *= s;
return *
this; }
3086 Plane_3D & operator/= (F s) {
return operator*= ((F)1.0 / s); }
3087 Plane_3D const operator* (F s)
const {
return Plane_3D (a * s, b * s, c * s, d * s); }
3088 Plane_3D const operator/ (F s)
const {
return operator* ((F)1.0 / s); }
3095 template <
typename F>
3096 HPS_INLINE
bool Is_Abnormal (
Plane_3D<F> const & p) {
3097 return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c) || Is_Abnormal (p.d);
3101 template <
typename F>
3102 HPS_INLINE F operator* (Plane_3D<F>
const & plane, Point_3D<F>
const & point) {
3103 return plane.a * point.x + plane.b * point.y + plane.c * point.z + plane.d;
3105 template <
typename F>
3106 HPS_INLINE F operator* (Point_3D<F>
const & point, Plane_3D<F>
const & plane) {
3107 return plane * point;
3110 template <
typename F>
3111 HPS_INLINE Plane_3D<F> Interpolate(Plane_3D<F>
const & a, Plane_3D<F>
const & b,
float t) {
3112 return Plane_3D<F>(a.a + (b.a - a.a) * t, a.b + (b.b - a.b) * t, a.c + (b.c - a.c) * t, a.d + (b.d - a.d) * t);
3115 template <
typename F>
3116 Vector_3D<F>::Vector_3D(Plane_3D<F>
const & p) : x(p.a), y(p.b), z(p.c) {}
3123 template <
typename F>
3131 Plane_2D (F v1, F v2, F v3) : a (v1), b (v2), c (v3) {}
3135 template <
typename D>
3136 explicit Plane_2D (
Plane_2D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c) {}
3140 bool operator== (
Plane_2D const & p)
const {
return a == p.a && b == p.b && c == p.c; }
3141 bool operator!= (
Plane_2D const & p)
const {
return !(*
this == p); }
3143 F & operator[] (
size_t i) {
return (&a)[i]; }
3144 F
const & operator[] (
size_t i)
const {
return (&a)[i]; }
3146 HPS_INLINE
bool Equals(
Plane_2D const & p,
int in_tolerance = 32)
const {
3163 Plane_2D & operator*= (F s) { a *= s; b *= s; c *= s;
return *
this; }
3164 Plane_2D & operator/= (F s) {
return operator*= ((F)1.0 / s); }
3165 Plane_2D const operator* (F s)
const {
return Plane_2D (a * s, b * s, c * s); }
3166 Plane_2D const operator/ (F s)
const {
return operator* ((F)1.0 / s); }
3173 template <
typename F>
3174 HPS_INLINE
bool Is_Abnormal (
Plane_2D<F> const & p) {
3175 return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c);
3179 template <
typename F>
3180 HPS_INLINE F operator* (Plane_2D<F>
const & plane, Point_2D<F>
const & point) {
3181 return plane.a * point.x + plane.b * point.y + plane.c;
3183 template <
typename F>
3184 HPS_INLINE F operator* (Point_3D<F>
const & point, Plane_2D<F>
const & plane) {
3185 return plane * point;
3188 template <
typename F>
3189 HPS_INLINE Plane_2D<F> Interpolate(Plane_2D<F>
const & a, Plane_2D<F>
const & b,
float t) {
3190 return Plane_2D<F>(a.a + (b.a - a.a) * t, a.b + (b.b - a.b) * t, a.c + (b.c - a.c) * t);
3193 template <
typename F>
3194 Vector_2D<F>::Vector_2D(Plane_2D<F>
const & p) : x(p.a), y(p.b) {}
3208 : left(std::numeric_limits<int>::max()), right(std::numeric_limits<int>::min()),
3209 bottom(std::numeric_limits<int>::max()), top(std::numeric_limits<int>::min()) {}
3211 IntRectangle(
int in_left,
int in_right,
int in_bottom,
int in_top)
3212 : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3215 : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3220 return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3224 return !(*
this == rect);
3227 HPS_INLINE
int PixelWidth()
const {
3228 return right - left + 1;
3231 HPS_INLINE
int PixelHeight()
const {
3232 return top - bottom + 1;
3235 HPS_INLINE
int Width()
const {
3236 return right - left;
3239 HPS_INLINE
int Height()
const {
3240 return top - bottom;
3243 HPS_INLINE
int Area()
const {
3244 return Width() * Height();
3247 HPS_INLINE
Point2D Center()
const {
3248 return Point2D((
float)(left + right) * 0.5f, (
float)(bottom + top) * 0.5f);
3251 HPS_INLINE
bool Intersecting(
IntRectangle const & rect)
const {
3252 return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3255 HPS_INLINE
bool Contains(
IntRectangle const & rect)
const {
3256 return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3269 right += rect.right;
3270 bottom -= rect.bottom;
3285 right -= rect.right;
3286 bottom += rect.bottom;
3292 left = Max(left, rect.left);
3293 right = Min(right, rect.right);
3294 bottom = Max(bottom, rect.bottom);
3295 top = Min(top, rect.top);
3300 left = Min(left, rect.left);
3301 right = Max(right, rect.right);
3302 bottom = Min(bottom, rect.bottom);
3303 top = Max(top, rect.top);
3320 return temp.Expand(border);
3323 HPS_INLINE IntRectangle Expand(IntRectangle
const & a,
int border) {
3324 IntRectangle temp = a;
3325 return temp.Expand(border);
3328 HPS_INLINE IntRectangle Contract(IntRectangle
const & a,
int border) {
3329 IntRectangle temp = a;
3330 return temp.Contract(border);
3333 HPS_INLINE IntRectangle Contract(IntRectangle
const & a, IntRectangle
const & border) {
3334 IntRectangle temp = a;
3335 return temp.Contract(border);
3338 HPS_INLINE IntRectangle Intersect(IntRectangle
const & a, IntRectangle
const & b) {
3339 IntRectangle temp = a;
3340 return temp.Intersect(b);
3343 HPS_INLINE IntRectangle Union(IntRectangle
const & a, IntRectangle
const & b) {
3344 IntRectangle temp = a;
3345 return temp.Union(b);
3355 : left(std::numeric_limits<float>::max()), right(std::numeric_limits<float>::min()),
3356 bottom(std::numeric_limits<float>::max()), top(std::numeric_limits<float>::min()) {}
3358 Rectangle(
float in_left,
float in_right,
float in_bottom,
float in_top)
3359 : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3362 : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3365 : left((
float)that.left), right((
float)that.right), bottom((
float)that.bottom), top((
float)that.top) {}
3375 Merge(count, points);
3387 Merge(count, points);
3391 HPS_INLINE
float Width()
const {
3392 return right - left;
3395 HPS_INLINE
float Height()
const {
3396 return top - bottom;
3399 HPS_INLINE
float Area()
const {
3400 return Width() * Height();
3403 HPS_INLINE
Point2D Center()
const {
3404 return Point2D((left + right) * 0.5f, (bottom + top) * 0.5f);
3407 HPS_INLINE
void Merge(
size_t count,
Point const * points) {
3410 if (Compare(points[0].x, points[1].x)>0) {
3411 Float::replace_if_smaller(left, points[1].x);
3412 Float::replace_if_larger(right, points[0].x);
3415 Float::replace_if_smaller(left, points[0].x);
3416 Float::replace_if_larger(right, points[1].x);
3419 if (Compare(points[0].y, points[1].y)>0) {
3420 Float::replace_if_smaller(bottom, points[1].y);
3421 Float::replace_if_larger(top, points[0].y);
3424 Float::replace_if_smaller(bottom, points[0].y);
3425 Float::replace_if_larger(top, points[1].y);
3436 HPS_INLINE
void Merge(
Point const & point) {
3437 Float::replace_if_smaller(left, point.x);
3438 Float::replace_if_smaller(bottom, point.y);
3439 Float::replace_if_larger(right, point.x);
3440 Float::replace_if_larger(top, point.y);
3443 HPS_INLINE
void Merge(
size_t count,
Point2D const * points) {
3446 if (Compare(points[0].x, points[1].x)>0) {
3447 Float::replace_if_smaller(left, points[1].x);
3448 Float::replace_if_larger(right, points[0].x);
3451 Float::replace_if_smaller(left, points[0].x);
3452 Float::replace_if_larger(right, points[1].x);
3455 if (Compare(points[0].y, points[1].y)>0) {
3456 Float::replace_if_smaller(bottom, points[1].y);
3457 Float::replace_if_larger(top, points[0].y);
3460 Float::replace_if_smaller(bottom, points[0].y);
3461 Float::replace_if_larger(top, points[1].y);
3472 HPS_INLINE
void Merge(
Point2D const & point) {
3473 Float::replace_if_smaller(left, point.x);
3474 Float::replace_if_smaller(bottom, point.y);
3475 Float::replace_if_larger(right, point.x);
3476 Float::replace_if_larger(top, point.y);
3479 bool operator==(
Rectangle const & rect)
const {
3480 return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3483 bool operator!=(
Rectangle const & rect)
const {
3484 return !(*
this == rect);
3487 HPS_INLINE
bool Intersecting(
Rectangle const & rect)
const {
3488 return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3491 HPS_INLINE
bool Contains(
Point const & contained)
const {
3492 return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3495 HPS_INLINE
bool Contains(
Point2D const & contained)
const {
3496 return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3499 HPS_INLINE
bool Contains(
Rectangle const & rect) {
3500 return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3503 HPS_INLINE
bool Contains(
Rectangle const & rect,
float epsilon) {
3504 return (left <= rect.left + epsilon && right >= rect.right - epsilon &&
3505 bottom <= rect.bottom + epsilon && top >= rect.top - epsilon);
3508 HPS_INLINE
Rectangle & Expand(
float border) {
3516 HPS_INLINE
Rectangle & Expand(
int border) {
3517 Expand((
float)border);
3523 right += rect.right;
3524 bottom -= rect.bottom;
3529 HPS_INLINE
Rectangle & Contract(
int border) {
3539 right -= rect.right;
3540 bottom += rect.bottom;
3546 left = Max(left, rect.left);
3547 right = Min(right, rect.right);
3548 bottom = Max(bottom, rect.bottom);
3549 top = Min(top, rect.top);
3554 left = Min(left, rect.left);
3555 right = Max(right, rect.right);
3556 bottom = Min(bottom, rect.bottom);
3557 top = Max(top, rect.top);
3562 float scale = (scope.right - scope.left) * 0.5f;
3563 float trans = (scope.right + scope.left) * 0.5f;
3565 left = left * scale + trans;
3566 right = right * scale + trans;
3568 scale = (scope.top - scope.bottom) * 0.5f;
3569 trans = (scope.top + scope.bottom) * 0.5f;
3571 bottom = bottom * scale + trans;
3572 top = top * scale + trans;
3577 float tmp = 2.0f/(scope.right - scope.left);
3578 right = (right - scope.left) * tmp - 1.0f;
3579 left = (left - scope.left) * tmp - 1.0f;
3581 tmp = 2.0f/(scope.top - scope.bottom);
3582 top = (top - scope.bottom) * tmp - 1.0f;
3583 bottom = (bottom - scope.bottom) * tmp - 1.0f;
3587 static HPS_INLINE
Rectangle FullScope() {
3588 return Rectangle(-1.0f, 1.0f, -1.0f, 1.0f);
3591 static HPS_INLINE
Rectangle InvalidScope() {
3592 return Rectangle(1.0f, -1.0f, 1.0f, -1.0f);
3604 temp.left = Floor (a.left);
3605 temp.right = Floor (a.right);
3606 temp.bottom = Floor (a.bottom);
3607 temp.top = Floor (a.top);
3611 HPS_INLINE Rectangle Expand(Rectangle
const & a, Rectangle
const & border) {
3613 return temp.Expand(border);
3616 HPS_INLINE Rectangle Expand(Rectangle
const & a,
float border) {
3618 return temp.Expand(border);
3621 HPS_INLINE Rectangle Contract(Rectangle
const & a,
int border) {
3623 return temp.Contract(border);
3626 HPS_INLINE Rectangle Contract(Rectangle
const & a, Rectangle
const & border) {
3628 return temp.Contract(border);
3631 HPS_INLINE Rectangle Intersect(Rectangle
const & a, Rectangle
const & b) {
3633 return temp.Intersect(b);
3636 HPS_INLINE Rectangle Union(Rectangle
const & a, Rectangle
const & b) {
3638 return temp.Union(b);
3641 HPS_INLINE Rectangle Inscribe_Scope(Rectangle
const & a, Rectangle
const & scope) {
3643 return temp.Inscribe_Scope(scope);
3646 HPS_INLINE Rectangle Circumscribe_Scope(Rectangle
const & a, Rectangle
const & scope) {
3648 return temp.Circumscribe_Scope(scope);
3651 HPS_INLINE IntRectangle::IntRectangle(Rectangle
const & that)
3652 : left ((int)that.left), right ((int)that.right), bottom ((int)that.bottom), top ((int)that.top) {}
3657 template <
typename F>
3660 template <
typename F>
3673 template <
typename D>
3702 min = Limit_Point();
3703 max = -Limit_Point();
3706 min = max = *points++;
3709 Merge(count, points);
3722 return min.x <= max.x && min.y <= max.y && min.z <= max.z;
3739 HPS_INLINE
bool operator== (
Cuboid_3D const & cuboid)
const {
return (min == cuboid.
min && max == cuboid.
max); }
3745 HPS_INLINE
bool operator!= (
Cuboid_3D const & cuboid)
const {
return !(*
this == cuboid); }
3770 HPS_INLINE F
Volume ()
const {
return (max.x - min.x) * (max.y - min.y) * (max.z - min.z); }
3778 return max.x >= cuboid.
min.x && min.x <= cuboid.
max.x &&
3779 max.y >= cuboid.
min.y && min.y <= cuboid.
max.y &&
3780 max.z >= cuboid.
min.z && min.z <= cuboid.
max.z;
3789 return max.x + allowance >= cuboid.
min.x && min.x - allowance <= cuboid.
max.x &&
3790 max.y + allowance >= cuboid.
min.y && min.y - allowance <= cuboid.
max.y &&
3791 max.z + allowance >= cuboid.
min.z && min.z - allowance <= cuboid.
max.z;
3802 return max[dimension] >= cuboid.
min[dimension] && min[dimension] <= cuboid.
max[dimension];
3814 return max[dimension] + allowance >= cuboid.
min[dimension] && min[dimension] - allowance <= cuboid.
max[dimension];
3831 Float::replace_if_smaller(min.x, cuboid.
min.x);
3832 Float::replace_if_smaller(min.y, cuboid.
min.y);
3833 Float::replace_if_smaller(min.z, cuboid.
min.z);
3834 Float::replace_if_larger(max.x, cuboid.
max.x);
3835 Float::replace_if_larger(max.y, cuboid.
max.y);
3836 Float::replace_if_larger(max.z, cuboid.
max.z);
3852 Float::replace_if_smaller(min.x, point.x);
3853 Float::replace_if_smaller(min.y, point.y);
3854 Float::replace_if_smaller(min.z, point.z);
3855 Float::replace_if_larger(max.x, point.x);
3856 Float::replace_if_larger(max.y, point.y);
3857 Float::replace_if_larger(max.z, point.z);
3868 if (Compare(points[0].x, points[1].x)>0) {
3869 Float::replace_if_smaller(min.x, points[1].x);
3870 Float::replace_if_larger(max.x, points[0].x);
3873 Float::replace_if_smaller(min.x, points[0].x);
3874 Float::replace_if_larger(max.x, points[1].x);
3877 if (Compare(points[0].y, points[1].y)>0) {
3878 Float::replace_if_smaller(min.y, points[1].y);
3879 Float::replace_if_larger(max.y, points[0].y);
3882 Float::replace_if_smaller(min.y, points[0].y);
3883 Float::replace_if_larger(max.y, points[1].y);
3886 if (Compare(points[0].z, points[1].z)>0) {
3887 Float::replace_if_smaller(min.z, points[1].z);
3888 Float::replace_if_larger(max.z, points[0].z);
3891 Float::replace_if_smaller(min.z, points[0].z);
3892 Float::replace_if_larger(max.z, points[1].z);
3909 return (contained.
min.x >= min.x &&
3910 contained.
min.y >= min.y &&
3911 contained.
min.z >= min.z &&
3912 contained.
max.x <= max.x &&
3913 contained.
max.y <= max.y &&
3914 contained.
max.z <= max.z);
3923 return (contained.x >= min.x &&
3924 contained.y >= min.y &&
3925 contained.z >= min.z &&
3926 contained.x <= max.x &&
3927 contained.y <= max.y &&
3928 contained.z <= max.z);
3938 return (contained.x >= min.x - epsilon &&
3939 contained.y >= min.y - epsilon &&
3940 contained.z >= min.z - epsilon &&
3941 contained.x <= max.x + epsilon &&
3942 contained.y <= max.y + epsilon &&
3943 contained.z <= max.z + epsilon);
3952 Float::replace_if_larger(min.x, cuboid.
min.x);
3953 Float::replace_if_larger(min.y, cuboid.
min.y);
3954 Float::replace_if_larger(min.z, cuboid.
min.z);
3955 Float::replace_if_smaller(max.x, cuboid.
max.x);
3956 Float::replace_if_smaller(max.y, cuboid.
max.y);
3957 Float::replace_if_smaller(max.z, cuboid.
max.z);
3967 Float::replace_if_smaller(min.x, cuboid.
min.x);
3968 Float::replace_if_smaller(min.y, cuboid.
min.y);
3969 Float::replace_if_smaller(min.z, cuboid.
min.z);
3970 Float::replace_if_larger(max.x, cuboid.
max.x);
3971 Float::replace_if_larger(max.y, cuboid.
max.y);
3972 Float::replace_if_larger(max.z, cuboid.
max.z);
4002 F
const limit = std::numeric_limits<F>::max();
4007 typedef Cuboid_3D<float> SimpleCuboid;
4008 typedef Cuboid_3D<double> DSimpleCuboid;
4011 template <
typename F>
4012 HPS_INLINE Cuboid_3D<F> Intersect(Cuboid_3D<F>
const & a, Cuboid_3D<F>
const & b) {
4013 Cuboid_3D<F> temp = a;
4014 return temp.Intersect(b);
4017 template <
typename F>
4018 HPS_INLINE Cuboid_3D<F> Union(Cuboid_3D<F>
const & a, Cuboid_3D<F>
const & b) {
4019 Cuboid_3D<F> temp = a;
4020 return temp.Union(b);
4023 template <
typename F>
4024 HPS_INLINE Cuboid_3D<F> Expand(Cuboid_3D<F>
const & a, F border) {
4025 Cuboid_3D<F> temp = a;
4026 return temp.Expand(border);
4029 template <
typename F>
4030 HPS_INLINE Cuboid_3D<F> Contract(Cuboid_3D<F>
const & a, F border) {
4031 Cuboid_3D<F> temp = a;
4032 return temp.Contract(border);
4037 template <
typename F>
4038 struct HPS_TEMPLATE_API Sphere_3D {
4042 Sphere_3D () : center(Point_3D<F>(0, 0, 0)), radius(0) {}
4044 template <
typename D>
4045 explicit Sphere_3D (Sphere_3D<D>
const & that) : center(Point_3D<F>(that.center)), radius(F(that.radius)) {}
4047 Sphere_3D (Cuboid_3D<F>
const & cuboid) :
4048 center (Midpoint(cuboid.min, cuboid.max)), radius (F(0.5 * cuboid.Diagonal().Length())) {}
4050 Sphere_3D (Point_3D<F>
const & starting_center, F in_radius = 0) : center(starting_center), radius(in_radius) {}
4052 Sphere_3D (
size_t count, Point_3D<F>
const * points) : radius(0.0f) {
4053 Cuboid_3D<F> cuboid(count, points);
4054 center = Midpoint(cuboid.min, cuboid.max);
4055 Engulf (count, points);
4058 Sphere_3D (
size_t count, Point_3D<F>
const * points, Point_3D<F>
const & starting_center) : center(starting_center), radius(0) {
4059 Engulf (count, points);
4062 HPS_INLINE
bool IsValid()
const {
4066 static HPS_INLINE Sphere_3D Invalid() {
return Sphere_3D(Point_3D<F>(0,0,0), -1);};
4068 void Invalidate() {radius = -1;}
4070 HPS_INLINE
bool operator== (Sphere_3D
const & sphere)
const {
return (center == sphere.center && radius == sphere.radius); }
4071 HPS_INLINE
bool operator!= (Sphere_3D
const & sphere)
const {
return !(*
this == sphere); }
4073 HPS_INLINE F Volume ()
const {
return F((4.0 / 3.0 * PI) * radius * radius * radius); }
4075 HPS_INLINE
void Merge(Point_3D<F>
const & point) {
4076 Vector_3D<F> dir = point - center;
4077 F distance = (F)dir.Length();
4079 if (distance > radius) {
4080 F t = F(0.5) * (distance - radius);
4081 center += t * dir.Normalize();
4086 HPS_INLINE
void Merge(
size_t count, Point_3D<F>
const * points) {
4088 for (
size_t i = 0; i < count; ++i) {
4089 Vector_3D<F> dir = *points - center;
4090 F distance = (F)dir.Length();
4092 if (distance > radius) {
4093 F t = F(0.5) * (distance - radius);
4094 center += t * dir.Normalize();
4102 HPS_INLINE
void Merge (Sphere_3D
const & sphere) {
4103 Vector_3D<F> dir = sphere.center - center;
4104 F distance = (F)dir.Length();
4106 if (distance + sphere.radius > radius) {
4107 if (distance + radius > sphere.radius) {
4108 F t = F(0.5 * (sphere.radius + distance - radius));
4109 center += t * dir.Normalize();
4113 center = sphere.center;
4114 radius = sphere.radius;
4119 HPS_INLINE
void Merge (Cuboid_3D<F>
const & cuboid) { Merge (Sphere_3D (cuboid)); }
4123 HPS_INLINE
void Engulf (
size_t count, Point_3D<F>
const * points) {
4124 for (
size_t i = 0; i < count; ++i) {
4125 double dsq = (*points++ - center).LengthSquared();
4126 if ((F)dsq > radius * radius)
4127 radius = (F)sqrt(dsq);
4132 typedef Sphere_3D<float> SimpleSphere;
4133 typedef Sphere_3D<double> DSimpleSphere;
4136 template <
typename F>
4138 min =
Point_3D<F>(sphere.center.x - sphere.radius, sphere.center.y - sphere.radius, sphere.center.z - sphere.radius);
4139 max =
Point_3D<F>(sphere.center.x + sphere.radius, sphere.center.y + sphere.radius, sphere.center.z + sphere.radius);
4157 HPS_INLINE
RGBColor (
float r,
float g,
float b) : red (r), green (g), blue (b) {}
4158 explicit HPS_INLINE RGBColor (
RGB24Color const & c24);
4159 explicit HPS_INLINE RGBColor (
float gray) : red (gray), green (gray), blue (gray) {}
4160 explicit HPS_INLINE RGBColor (
RGBAS32Color const & c32);
4161 explicit HPS_INLINE RGBColor (
RGBA32Color const & c32);
4162 explicit HPS_INLINE RGBColor (
RGBAColor const & c);
4164 HPS_INLINE
bool IsGray()
const {
return (red == green && green == blue);}
4165 HPS_INLINE
float Gray()
const {
return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4166 float Distance(RGBColor
const & other_color)
const;
4167 HPS_INLINE
bool IsValid()
const {
4168 return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue)) == 0;
4171 HPS_INLINE
bool operator== (RGBColor
const & c)
const {
return red == c.red && green == c.green && blue == c.blue; }
4172 HPS_INLINE
bool operator!= (RGBColor
const & c)
const {
return !(*
this == c); }
4174 HPS_INLINE
bool Equals(RGBColor
const & c,
int in_tolerance = 32)
const
4177 HPS_INLINE RGBColor & operator*= (RGBColor
const & c) { red *= c.red; green *= c.green; blue *= c.blue;
return *
this; }
4178 HPS_INLINE RGBColor & operator+= (RGBColor
const & c) { red += c.red; green += c.green; blue += c.blue;
return *
this; }
4179 HPS_INLINE RGBColor & operator-= (RGBColor
const & c) { red -= c.red; green -= c.green; blue -= c.blue;
return *
this; }
4180 HPS_INLINE RGBColor
const operator* (RGBColor
const & c)
const {
return RGBColor (red * c.red, green * c.green, blue * c.blue); }
4181 HPS_INLINE RGBColor
const operator+ (RGBColor
const & c)
const {
return RGBColor (red + c.red, green + c.green, blue + c.blue); }
4182 HPS_INLINE RGBColor
const operator- (RGBColor
const & c)
const {
return RGBColor (red - c.red, green - c.green, blue - c.blue); }
4184 HPS_INLINE RGBColor & operator*= (
float s) { red *= s; green *= s; blue *= s;
return *
this; }
4185 HPS_INLINE RGBColor & operator/= (
float s) {
return operator*= (1.0f / s); }
4186 HPS_INLINE RGBColor & operator+= (
float s) { red += s; green += s; blue += s;
return *
this; }
4187 HPS_INLINE RGBColor & operator-= (
float s) { red -= s; green -= s; blue -= s;
return *
this; }
4188 HPS_INLINE RGBColor
const operator* (
float s)
const {
return RGBColor (red * s, green * s, blue * s); }
4189 HPS_INLINE RGBColor
const operator/ (
float s)
const {
return operator* (1.0f / s); }
4190 HPS_INLINE RGBColor
const operator+ (
float s)
const {
return RGBColor (red + s, green + s, blue + s); }
4191 HPS_INLINE RGBColor
const operator- (
float s)
const {
return RGBColor (red - s, green - s, blue - s); }
4193 static HPS_INLINE RGBColor Black() {
return RGBColor (0, 0, 0);};
4194 static HPS_INLINE RGBColor White() {
return RGBColor (1, 1, 1);};
4195 static HPS_INLINE RGBColor Invalid() {
return RGBColor (-1, -1, -1);};
4197 void ShowHLS(
float & out_hue,
float & out_lightness,
float & out_saturation)
const;
4198 void ShowHSV(
float & out_hue,
float & out_saturation,
float & out_value)
const;
4199 void ShowHIC(
float & out_hue,
float & out_intensity,
float & out_chromaticity)
const;
4201 static RGBColor HLS(
float in_hue,
float in_lightness,
float in_saturation);
4202 static RGBColor HSV(
float in_hue,
float in_saturation,
float in_value);
4203 static RGBColor HIC(
float in_hue,
float in_intensity,
float in_chromaticity);
4206 HPS_INLINE
RGBColor const operator* (
float s,
RGBColor const & v) {
return RGBColor (s * v.red, s * v.green, s * v.blue); }
4207 HPS_INLINE RGBColor
const operator+ (
float s, RGBColor
const & v) {
return RGBColor (s + v.red, s + v.green, s + v.blue); }
4208 HPS_INLINE RGBColor
const operator- (
float s, RGBColor
const & v) {
return RGBColor (s - v.red, s - v.green, s - v.blue); }
4220 explicit HPS_INLINE
RGBAColor (
float gray,
float a = 1) : red (gray), green (gray), blue (gray), alpha (a) {}
4221 HPS_INLINE RGBAColor (
float r,
float g,
float b,
float a = 1) : red (r), green (g), blue (b), alpha (a) {}
4223 HPS_INLINE RGBAColor (RGBColor
const & c) {
4224 memcpy(
this, &c,
sizeof(RGBColor));
4226 Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4228 HPS_INLINE RGBAColor (RGBColor
const & c,
float a) {
4229 memcpy(
this, &c,
sizeof(RGBColor));
4230 memcpy(&alpha, &a,
sizeof(
float));
4231 Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4233 explicit HPS_INLINE RGBAColor (RGBA32Color
const & c32);
4234 explicit HPS_INLINE RGBAColor (RGBAS32Color
const & c32);
4236 HPS_INLINE
bool IsGray()
const {
return (red == green && green == blue);}
4237 HPS_INLINE
float Gray()
const {
return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4238 HPS_INLINE
bool IsValid()
const {
4239 return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue) | Float::extract_sign_bit(alpha)) == 0;
4256 HPS_INLINE
bool operator!= (
RGBAColor const & c)
const {
return !(*
this == c); }
4258 HPS_INLINE
bool Equals(
RGBAColor const & c,
int in_tolerance = 32)
const {
4263 HPS_INLINE RGBAColor & operator*= (RGBAColor
const & c) { red *= c.red; green *= c.green; blue *= c.blue; alpha *= c.alpha;
return *
this; }
4264 HPS_INLINE RGBAColor & operator+= (RGBAColor
const & c) { red += c.red; green += c.green; blue += c.blue; alpha += c.alpha;
return *
this; }
4265 HPS_INLINE RGBAColor & operator-= (RGBAColor
const & c) { red -= c.red; green -= c.green; blue -= c.blue; alpha -= c.alpha;
return *
this; }
4266 HPS_INLINE RGBAColor
const operator* (RGBAColor
const & c)
const {
return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha * c.alpha); }
4267 HPS_INLINE RGBAColor
const operator+ (RGBAColor
const & c)
const {
return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha + c.alpha); }
4268 HPS_INLINE RGBAColor
const operator- (RGBAColor
const & c)
const {
return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha - c.alpha); }
4270 HPS_INLINE RGBAColor & operator*= (
float s) { red *= s; green *= s; blue *= s; alpha *= s;
return *
this; }
4271 HPS_INLINE RGBAColor & operator/= (
float s) {
return operator*= (1.0f / s); }
4272 HPS_INLINE RGBAColor & operator+= (
float s) { red += s; green += s; blue += s; alpha += s;
return *
this; }
4273 HPS_INLINE RGBAColor & operator-= (
float s) { red -= s; green -= s; blue -= s; alpha -= s;
return *
this; }
4274 HPS_INLINE RGBAColor
const operator* (
float s)
const {
return RGBAColor (red * s, green * s, blue * s, alpha * s); }
4275 HPS_INLINE RGBAColor
const operator/ (
float s)
const {
return operator* (1.0f / s); }
4276 HPS_INLINE RGBAColor
const operator+ (
float s)
const {
return RGBAColor (red + s, green + s, blue + s, alpha + s); }
4277 HPS_INLINE RGBAColor
const operator- (
float s)
const {
return RGBAColor (red - s, green - s, blue - s, alpha - s); }
4279 HPS_INLINE RGBAColor & operator*= (RGBColor
const & c) { red *= c.red; green *= c.green; blue *= c.blue;
return *
this; }
4280 HPS_INLINE RGBAColor & operator+= (RGBColor
const & c) { red += c.red; green += c.green; blue += c.blue;
return *
this; }
4281 HPS_INLINE RGBAColor & operator-= (RGBColor
const & c) { red -= c.red; green -= c.green; blue -= c.blue;
return *
this; }
4282 HPS_INLINE RGBAColor
const operator* (RGBColor
const & c)
const {
return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha); }
4283 HPS_INLINE RGBAColor
const operator+ (RGBColor
const & c)
const {
return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha); }
4284 HPS_INLINE RGBAColor
const operator- (RGBColor
const & c)
const {
return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha); }
4286 static HPS_INLINE RGBAColor Black() {
return RGBAColor (0, 0, 0, 1);};
4287 static HPS_INLINE RGBAColor White() {
return RGBAColor (1, 1, 1, 1);};
4288 static HPS_INLINE RGBAColor Nothing() {
return RGBAColor (0, 0, 0, 0);};
4289 static HPS_INLINE RGBAColor Invalid() {
return RGBAColor (-1, -1, -1, -1);};
4303 HPS_INLINE
static Order Preferred_Order () {
return Order_BGRA;}
4304 unsigned char b, g, r, a;
4308 HPS_INLINE
static Order Preferred_Order () {
return Order_RGBA;}
4309 unsigned char r, g, b, a;
4313 HPS_INLINE
static Order Preferred_Order () {
return Order_RGBA;}
4314 unsigned char r, g, b, a;
4324 explicit HPS_INLINE
RGBAS32Color (
unsigned char gray,
unsigned char aa = 255) {
4330 HPS_INLINE
RGBAS32Color (
unsigned char rr,
unsigned char gg,
unsigned char bb,
unsigned char aa = 255) {
4338 explicit HPS_INLINE RGBAS32Color (
RGBColor const & c)
4340 r = Float::unit_to_byte(c.red);
4341 g = Float::unit_to_byte(c.green);
4342 b = Float::unit_to_byte(c.blue);
4346 HPS_INLINE RGBAS32Color (
RGB24Color const & c);
4350 HPS_INLINE RGBAS32Color (
RGBColor const & c,
float alpha)
4352 r = Float::unit_to_byte(c.red);
4353 g = Float::unit_to_byte(c.green);
4354 b = Float::unit_to_byte(c.blue);
4355 a = Float::unit_to_byte(alpha);
4357 HPS_INLINE RGBAS32Color (
RGBColor const & c,
unsigned char aa)
4359 r = Float::unit_to_byte(c.red);
4360 g = Float::unit_to_byte(c.green);
4361 b = Float::unit_to_byte(c.blue);
4364 explicit HPS_INLINE RGBAS32Color (
RGBAColor const & c)
4366 r = Float::unit_to_byte(c.
red);
4367 g = Float::unit_to_byte(c.
green);
4368 b = Float::unit_to_byte(c.
blue);
4369 a = Float::unit_to_byte(c.
alpha);
4371 HPS_INLINE RGBAS32Color (
RGBAColor const & c,
unsigned char mix)
4373 r = Float::unit_to_byte(c.
red);
4374 g = Float::unit_to_byte(c.
green);
4375 b = Float::unit_to_byte(c.
blue);
4376 a = Float::unit_to_byte_scaled(c.
alpha, mix);
4379 HPS_INLINE
bool IsGray()
const {
return (r == g && g == b);}
4380 HPS_INLINE
unsigned char Gray()
const {
return (
unsigned char)(0.3125f * (float)r + 0.5000f * (
float)g + 0.1875f * (float)b); }
4381 HPS_INLINE
bool IsValid()
const {
return ((r | g | b | a) != 0); }
4383 HPS_INLINE
bool operator== (RGBAS32Color
const & c)
const {
return (r == c.r && g == c.g && b == c.b && a == c.a); }
4384 HPS_INLINE
bool operator!= (RGBAS32Color
const & c)
const {
return !(*
this == c); }
4386 static HPS_INLINE RGBAS32Color Black() {
return RGBAS32Color (0, 0, 0, 255);};
4387 static HPS_INLINE RGBAS32Color White() {
return RGBAS32Color (255, 255, 255, 255);};
4388 static HPS_INLINE RGBAS32Color Invalid() {
return RGBAS32Color (0, 0, 0, 0);};
4390 static HPS_INLINE
unsigned char Opaque_Alpha () {
return 0xFF;}
4401 explicit HPS_INLINE
RGBA32Color (
unsigned char gray,
unsigned char aa = 255)
4402 : r (gray), g (gray), b (gray), a (aa) {}
4403 HPS_INLINE RGBA32Color (
unsigned char rr,
unsigned char gg,
unsigned char bb,
unsigned char aa = 255)
4404 : r (rr), g (gg), b (bb), a (aa) {}
4406 : r (c32.r), g (c32.g), b (c32.b), a (c32.a) {}
4407 explicit HPS_INLINE RGBA32Color (
RGBColor const & c) {
4408 r = Float::unit_to_byte(c.red);
4409 g = Float::unit_to_byte(c.green);
4410 b = Float::unit_to_byte(c.blue);
4413 HPS_INLINE RGBA32Color (
RGBColor const & c,
float alpha) {
4414 r = Float::unit_to_byte(c.red);
4415 g = Float::unit_to_byte(c.green);
4416 b = Float::unit_to_byte(c.blue);
4417 a = Float::unit_to_byte(alpha);
4419 HPS_INLINE RGBA32Color (
RGBColor const & c,
unsigned char aa) {
4420 r = Float::unit_to_byte(c.red);
4421 g = Float::unit_to_byte(c.green);
4422 b = Float::unit_to_byte(c.blue);
4425 explicit HPS_INLINE RGBA32Color (
RGBAColor const & c) {
4426 r = Float::unit_to_byte(c.
red);
4427 g = Float::unit_to_byte(c.
green);
4428 b = Float::unit_to_byte(c.
blue);
4429 a = Float::unit_to_byte(c.
alpha);
4431 HPS_INLINE RGBA32Color (
RGBAColor const & c,
unsigned char mix) {
4432 r = Float::unit_to_byte(c.
red);
4433 g = Float::unit_to_byte(c.
green);
4434 b = Float::unit_to_byte(c.
blue);
4435 a = Float::unit_to_byte_scaled(c.
alpha, mix);
4438 HPS_INLINE
bool IsGray()
const {
return (r == g && g == b);}
4439 HPS_INLINE
unsigned char Gray()
const {
return (
unsigned char)(0.3125f * (float)r + 0.5000f * (
float)g + 0.1875f * (float)b); }
4441 HPS_INLINE
bool operator== (RGBA32Color
const & c)
const {
return (r == c.r && g == c.g && b == c.b && a == c.a); }
4442 HPS_INLINE
bool operator!= (RGBA32Color
const & c)
const {
return !(*
this == c); }
4444 static HPS_INLINE RGBA32Color Black() {
return RGBA32Color (0, 0, 0, 255);};
4445 static HPS_INLINE RGBA32Color White() {
return RGBA32Color (255, 255, 255, 255);};
4447 static HPS_INLINE
unsigned char Opaque_Alpha () {
return 0xFF;}
4459 explicit HPS_INLINE
RGB24Color (
unsigned char gray)
4460 : r (gray), g (gray), b (gray) {}
4461 HPS_INLINE RGB24Color (
unsigned char rr,
unsigned char gg,
unsigned char bb)
4462 : r (rr), g (gg), b (bb) {}
4463 explicit HPS_INLINE RGB24Color (
RGBColor const & c) {
4464 r = Float::unit_to_byte(c.red);
4465 g = Float::unit_to_byte(c.green);
4466 b = Float::unit_to_byte(c.blue);
4469 HPS_INLINE
bool IsGray()
const {
return (r == g && g == b);}
4470 HPS_INLINE
unsigned char Gray()
const {
return (
unsigned char)(0.3125f * (float)r + 0.5000f * (
float)g + 0.1875f * (float)b); }
4472 HPS_INLINE
bool operator== (RGB24Color
const & c)
const {
return (r == c.r && g == c.g && b == c.b); }
4473 HPS_INLINE
bool operator!= (RGB24Color
const & c)
const {
return !(*
this == c); }
4476 HPS_INLINE RGBColor::RGBColor (
RGBAS32Color const & c32) {
4477 red = Float::C2F(c32.r);
4478 green = Float::C2F(c32.g);
4479 blue = Float::C2F(c32.b);
4482 HPS_INLINE RGBColor::RGBColor (RGBA32Color
const & c32) {
4483 red = Float::C2F(c32.r);
4484 green = Float::C2F(c32.g);
4485 blue = Float::C2F(c32.b);
4488 HPS_INLINE RGBColor::RGBColor (RGBAColor
const & c) {
4494 HPS_INLINE RGBColor::RGBColor (RGB24Color
const & c24) {
4495 red = Float::C2F(c24.r);
4496 green = Float::C2F(c24.g);
4497 blue = Float::C2F(c24.b);
4500 HPS_INLINE RGBAS32Color::RGBAS32Color (RGB24Color
const & c)
4508 HPS_INLINE RGBAS32Color::RGBAS32Color (RGBA32Color
const & c)
4516 HPS_INLINE RGBAColor::RGBAColor (RGBAS32Color
const & c32) {
4517 red = Float::C2F(c32.r);
4518 green = Float::C2F(c32.g);
4519 blue = Float::C2F(c32.b);
4520 alpha = Float::C2F(c32.a);
4523 HPS_INLINE RGBAColor::RGBAColor (RGBA32Color
const & c32) {
4524 red = Float::C2F(c32.r);
4525 green = Float::C2F(c32.g);
4526 blue = Float::C2F(c32.b);
4527 alpha = Float::C2F(c32.a);
4530 HPS_INLINE RGBColor Modulate(RGBColor
const & a, RGBColor
const & b) {
4531 return RGBColor(a.red * b.red, a.green * b.green, a.blue * b.blue);
4536 HPS_INLINE RGBColor Interpolate(RGBColor
const & a, RGBColor
const & b,
float t) {
4537 return RGBColor(a.red + (b.red - a.red) * t, a.green + (b.green - a.green) * t, a.blue + (b.blue - a.blue) * t);
4540 HPS_INLINE RGBAColor Interpolate(RGBAColor
const & a, RGBAColor
const & b,
float t) {
4541 return RGBAColor(a.red + (b.red - a.red) * t, a.green + (b.green - a.green) * t, a.blue + (b.blue - a.blue) * t, a.alpha + (b.alpha - a.alpha) * t);
4544 HPS_INLINE RGBAS32Color Interpolate(RGBAS32Color
const & a, RGBAS32Color
const & b,
float t) {
4545 return RGBAS32Color(
4546 (
unsigned char)(a.r + ((
float)b.r - (
float)a.r) * t),
4547 (
unsigned char)(a.g + ((
float)b.g - (
float)a.g) * t),
4548 (
unsigned char)(a.b + ((
float)b.b - (
float)a.b) * t),
4549 (
unsigned char)(a.a + ((
float)b.a - (
float)a.a) * t));
4552 HPS_INLINE RGBA32Color Interpolate(RGBA32Color
const & a, RGBA32Color
const & b,
float t) {
4554 (
unsigned char)(a.r + ((
float)b.r - (
float)a.r) * t),
4555 (
unsigned char)(a.g + ((
float)b.g - (
float)a.g) * t),
4556 (
unsigned char)(a.b + ((
float)b.b - (
float)a.b) * t),
4557 (
unsigned char)(a.a + ((
float)b.a - (
float)a.a) * t));
4560 HPS_INLINE RGB24Color Interpolate(RGB24Color
const & a, RGB24Color
const & b,
float t) {
4562 (
unsigned char)(a.r + ((
float)b.r - (
float)a.r) * t),
4563 (
unsigned char)(a.g + ((
float)b.g - (
float)a.g) * t),
4564 (
unsigned char)(a.b + ((
float)b.b - (
float)a.b) * t));
4576 Quaternion() : w(0.0f), x(0.0f), y(0.0f), z(0.0f) { }
4578 Quaternion(
float in_w,
float in_x,
float in_y,
float in_z) : w(in_w), x(in_x), y(in_y), z(in_z) { }
4596 return Quaternion(w*in_right.w - x*in_right.x - y*in_right.y - z*in_right.z,
4597 y*in_right.z - z*in_right.y + w*in_right.x + x*in_right.w,
4598 z*in_right.x - x*in_right.z + w*in_right.y + y*in_right.w,
4599 x*in_right.y - y*in_right.x + w*in_right.z + z*in_right.w);
4602 Quaternion operator* (
float in_right)
const {
4603 return Quaternion(w*in_right, x*in_right, y*in_right, z*in_right);
4607 return Quaternion(in_left*in_right.w, in_left*in_right.x, in_left*in_right.y, in_left*in_right.z);
4610 Quaternion operator/ (
float in_right)
const {
4611 return Quaternion(w/in_right, x/in_right, y/in_right, z/in_right);
4615 return Quaternion(w-in_right.w, x-in_right.x, y-in_right.y, z-in_right.z);
4619 return Quaternion(w+in_right.w, x+in_right.x, y+in_right.y, z+in_right.z);
4622 inline float Norm()
const {
4623 return static_cast<float>(sqrt(w*w + x*x + y*y + z*z));
4629 float mag_q = Norm();
4630 float mag_V =
static_cast<float>(sqrt(x*x + y*y + z*z));
4632 ret.w =
static_cast<float>(log(mag_q));
4635 float scale =
static_cast<float>(acos(w / mag_q) / mag_V);
4642 ret.x = ret.y = ret.z = 0;
4649 float ea =
static_cast<float>(exp(w));
4650 float mag_V =
static_cast<float>(sqrt(x*x + y*y + z*z));
4651 float scale = ea * sin(mag_V) / mag_V;
4653 ret.w = ea * cos(mag_V);
4662 Quaternion ret = *
this + in_fraction * (in_right - *
this);
4663 return ret.Normalize();
4667 Quaternion Slerp(
Quaternion const & in_right,
float in_fraction,
bool in_shortest_path_only =
true)
const {
4669 float dot = x*in_right.x + y*in_right.y + z*in_right.z + w*in_right.w;
4671 if (in_shortest_path_only && dot < 0) {
4678 if (dot > -0.95f && dot < 0.95f) {
4679 float angle =
static_cast<float>(acos(dot));
4680 float sina =
static_cast<float>(sin(angle));
4681 float sinat =
static_cast<float>(sin(angle*in_fraction));
4682 float sinaomt =
static_cast<float>(sin(angle*(1-in_fraction)));
4684 return (*
this * sinaomt + q3 * sinat) / sina;
4687 return Lerp(q3, in_fraction);
4700 Quaternion q1 = Slerp(in_right , in_fraction,
false);
4701 Quaternion q2 = in_control1.Slerp(in_control2, in_fraction,
false);
4703 return q1.Slerp(q2, 2*in_fraction*(1-in_fraction),
false);
4715 return *
this *
Quaternion(((qni*in_previous).Log() + (qni*in_next).Log()) / -4).Exp();
4720 typedef unsigned char byte;
4721 typedef signed char sbyte;
4722 typedef intptr_t WindowHandle;
4723 typedef double Time;
4724 typedef int64_t TouchID;
4725 typedef intptr_t PlatformData;
4758 class AttributesControl;
4764 class VisibilityControl;
4765 class CameraControl;
4766 class SelectabilityControl;
4767 class TransparencyKit;
4768 class TransparencyControl;
4770 class CullingControl;
4772 class MarkerAttributeControl;
4773 class GlyphDefinition;
4774 class GeometryInsertControl;
4776 class TextAttributeControl;
4777 class TextAttributeKit;
4778 class LineAttributeKit;
4779 class LineAttributeControl;
4780 class EdgeAttributeKit;
4781 class EdgeAttributeControl;
4782 class CurveAttributeKit;
4783 class CurveAttributeControl;
4786 class ModellingMatrixControl;
4787 class TextureMatrixControl;
4788 class TextureDefinition;
4789 class MaterialMappingKit;
4790 class MaterialMappingControl;
4794 class DistantLightKit;
4795 class DistantLightKey;
4796 class CuttingSectionKit;
4797 class CuttingSectionKey;
4798 class CuttingSectionAttributeKit;
4799 class CuttingSectionAttributeControl;
4800 class CylinderAttributeKit;
4801 class CylinderAttributeControl;
4807 class SphereAttributeKit;
4808 class SphereAttributeControl;
4813 class CircularArcKey;
4814 class CircularArcKit;
4815 class CircularWedgeKey;
4816 class CircularWedgeKit;
4818 class InfiniteLineKey;
4819 class InfiniteLineKit;
4822 class NURBSCurveKey;
4823 class NURBSCurveKit;
4824 class NURBSSurfaceKey;
4825 class NURBSSurfaceKit;
4830 class EllipticalArcKey;
4831 class EllipticalArcKit;
4839 class NURBSSurfaceAttributeKit;
4840 class NURBSSurfaceAttributeControl;
4843 class PerformanceKit;
4844 class PerformanceControl;
4845 class HiddenLineAttributeKit;
4846 class HiddenLineAttributeControl;
4847 class DrawingAttributeKit;
4848 class DrawingAttributeControl;
4851 class SelectionOptionsKit;
4852 class SelectionResults;
4853 class SelectionItem;
4854 class SelectionControl;
4855 class HighlightControl;
4856 class HighlightOptionsKit;
4857 class ImageDefinition;
4859 class TextureDefinition;
4860 class TextureOptionsKit;
4861 class NamedStyleDefinition;
4862 class MaterialPaletteDefinition;
4863 class GlyphDefinition;
4864 class LinePatternOptionsKit;
4865 class LinePatternDefinition;
4866 class LinePatternKit;
4867 class LinePatternElement;
4868 class LinePatternParallelKit;
4869 class CubeMapDefinition;
4871 class ShaderDefinition;
4872 class EmergencyHandler;
4873 class EventDispatcher;
4876 class StandAloneWindowKey;
4877 class StandAloneWindowOptionsKit;
4878 class ApplicationWindowKey;
4879 class ApplicationWindowOptionsKit;
4880 class OffScreenWindowKey;
4881 class OffScreenWindowOptionsKit;
4882 class LightingAttributeControl;
4883 class VisualEffectsControl;
4884 class PostProcessEffectsControl;
4885 class SelectionOptionsControl;
4889 class NormalizedPoint;
4890 class ScreenRangePoint;
4891 class InnerWindowPoint;
4892 class InnerPixelPoint;
4895 class VisibilityKit;
4897 class SelectabilityKit;
4898 class MarkerAttributeKit;
4899 class LightingAttributeKit;
4900 class VisualEffectsKit;
4901 class PostProcessEffectsKit;
4903 class SubwindowControl;
4906 class DebuggingControl;
4909 class ContourLineKit;
4910 class ContourLineControl;
4913 class PortfolioControl;
4915 class ConditionControl;
4916 class WindowInfoKit;
4917 class WindowInfoControl;
4918 class FontInfoState;
4919 class FontInfoControl;
4920 class SearchOptionsKit;
4921 class AttributeLockControl;
4922 class AttributeLockKit;
4926 class BoundingControl;
4927 class TransformMaskKit;
4928 class TransformMaskControl;
4929 class ColorInterpolationKit;
4930 class ColorInterpolationControl;
4931 class UpdateOptionsKit;
4932 class UpdateOptionsControl;
4935 class ShellRelationOptionsKit;
4936 class ShellRelationResultsKit;
4939 class CutGeometryGatheringOptionsKit;
4985 enum class Type : uint32_t
4988 GenericMask = 0xffffff00,
4992 EventDispatcher = 0x00000003,
4993 EventHandler = 0x00000004,
4994 EventNotifier = 0x00000005,
4995 UpdateNotifier = 0x00000006,
4996 SearchResults = 0x00000008,
4997 FontSearchResults = 0x00000009,
4998 SearchResultsIterator = 0x0100000a,
4999 FontSearchResultsIterator = 0x0100000b,
5000 SelectionResults = 0x0000000c,
5001 SelectionResultsIterator = 0x0100000d,
5002 SelectionItem = 0x0000000e,
5003 TreeContext = 0x0000000f,
5005 IONotifier = 0x04000100,
5006 StreamImportNotifier = 0x04000101,
5007 STLImportNotifier = 0x04000102,
5008 OBJImportNotifier = 0x04000103,
5009 ExchangeImportNotifier = 0x04000104,
5010 SketchupImportNotifier = 0x04000105,
5011 ParasolidImportNotifier = 0x04000106,
5012 ExchangeTranslationNotifier = 0x04000107,
5013 ExchangeExportNotifier = 0x04000108,
5016 MarkerKit = 0x01000010,
5017 SphereAttributeKit = 0x01000011,
5018 TextAttributeKit = 0x01000012,
5019 TransparencyKit = 0x01000013,
5020 VisibilityKit = 0x01000014,
5021 VisualEffectsKit = 0x01000015,
5022 CuttingSectionAttributeKit = 0x01000016,
5023 CircleKit = 0x01000017,
5024 CircularArcKit = 0x01000018,
5025 CircularWedgeKit = 0x01000019,
5026 CuttingSectionKit = 0x0100001a,
5027 CylinderKit = 0x0100001b,
5028 DistantLightKit = 0x0100001c,
5029 EllipseKit = 0x0100001d,
5030 EllipticalArcKit = 0x0100001e,
5031 InfiniteLineKit = 0x0100001f,
5032 LineKit = 0x01000020,
5033 NURBSCurveKit = 0x01000021,
5034 MeshKit = 0x01000022,
5035 NURBSSurfaceKit = 0x01000023,
5036 PolygonKit = 0x01000024,
5037 SphereKit = 0x01000025,
5038 SpotlightKit = 0x01000026,
5039 ShellKit = 0x01000027,
5040 TextKit = 0x01000028,
5041 MaterialKit = 0x01000029,
5042 TrimKit = 0x0100002a,
5043 TextureOptionsKit = 0x0100002c,
5044 LinePatternKit = 0x0100002d,
5045 GlyphKit = 0x0100002e,
5046 ImageKit = 0x0100002f,
5047 LinePatternOptionsKit = 0x01000030,
5048 CameraKit = 0x01000031,
5049 BoundingKit = 0x01000032,
5050 CullingKit = 0x01000033,
5051 CurveAttributeKit = 0x01000034,
5052 CylinderAttributeKit = 0x01000035,
5053 EdgeAttributeKit = 0x01000036,
5054 LightingAttributeKit = 0x01000037,
5055 LineAttributeKit = 0x01000038,
5056 MarkerAttributeKit = 0x01000039,
5057 MaterialMappingKit = 0x0100003a,
5058 MatrixKit = 0x0100003b,
5059 NURBSSurfaceAttributeKit = 0x0100003c,
5060 PostProcessEffectsKit = 0x0100003d,
5061 SelectabilityKit = 0x0100003e,
5062 SelectionOptionsKit = 0x0100003f,
5063 StandAloneWindowOptionsKit = 0x01000040,
5064 OffScreenWindowOptionsKit = 0x01000041,
5065 ApplicationWindowOptionsKit = 0x01000042,
5066 HighlightOptionsKit = 0x01000043,
5067 LinePatternParallelKit = 0x01000044,
5068 SubwindowKit = 0x01000045,
5069 PerformanceKit = 0x01000046,
5070 HiddenLineAttributeKit = 0x01000047,
5071 DrawingAttributeKit = 0x01000048,
5072 ShaderKit = 0x01000049,
5073 DebuggingKit = 0x0100004a,
5074 ContourLineKit = 0x0100004b,
5075 StreamImportOptionsKit = 0x0100004c,
5076 StreamImportResultsKit = 0x0100004d,
5077 StreamExportOptionsKit = 0x0100004e,
5078 StreamExportResultsKit = 0x0100004f,
5079 WindowInfoKit = 0x01000050,
5080 ImageImportOptionsKit = 0x01000051,
5081 SearchOptionsKit = 0x01000052,
5082 ShaderImportOptionsKit = 0x01000053,
5083 HardcopyExportOptionsKit = 0x01000055,
5084 AttributeLockKit = 0x01000056,
5085 TransformMaskKit = 0x01000057,
5086 ColorInterpolationKit = 0x01000058,
5087 UpdateOptionsKit = 0x01000059,
5088 ImageExportOptionsKit = 0x0100005a,
5089 OBJImportOptionsKit = 0x0100005b,
5090 OBJImportResultsKit = 0x0100005c,
5091 STLImportOptionsKit = 0x0100005d,
5092 STLImportResultsKit = 0x0100005e,
5093 ShellOptimizationOptionsKit = 0x0100005f,
5094 ShellRelationOptionsKit = 0x01000060,
5095 ShellRelationResultsKit = 0x01000061,
5096 GridKit = 0x01000062,
5097 CutGeometryGatheringOptionsKit = 0x01000063,
5100 LinePatternElement = 0x03000000,
5101 SolidLinePatternElement = 0x03000001,
5102 BlankLinePatternElement = 0x03000002,
5103 GlyphLinePatternElement = 0x03000003,
5105 GlyphElement = 0x05000000,
5106 DotGlyphElement = 0x05000001,
5107 LineGlyphElement = 0x05000002,
5108 EllipseGlyphElement = 0x05000003,
5109 CircularArcGlyphElement = 0x05000004,
5110 InfiniteLineGlyphElement = 0x05000005,
5112 TrimElement = 0x07000000,
5114 Condition = 0x09000000,
5115 NOTCondition = 0x09000001,
5116 ANDCondition = 0x09000002,
5117 ORCondition = 0x09000003,
5118 XORCondition = 0x09000004,
5120 MouseState = 0x01001001,
5121 TouchState = 0x01001002,
5122 KeyboardState = 0x01001003,
5123 FontInfoState = 0x01001004,
5125 KeyPath = 0x01000F01,
5128 IncludeKey = 0x10000001,
5129 PortfolioKey = 0x10000002,
5130 StyleKey = 0x10000003,
5132 SegmentKey = 0x10200000,
5133 WindowKey = 0x10600000,
5134 StandAloneWindowKey = 0x10600001,
5135 OffScreenWindowKey = 0x10600002,
5136 ApplicationWindowKey = 0x10600003,
5138 GeometryKey = 0x10100000,
5139 ReferenceKey = 0x10100001,
5140 CircleKey = 0x10100002,
5141 CircularArcKey = 0x10100003,
5142 CircularWedgeKey = 0x10100004,
5143 CuttingSectionKey = 0x10100005,
5144 CylinderKey = 0x10100006,
5145 EllipseKey = 0x10100007,
5146 EllipticalArcKey = 0x10100008,
5147 InfiniteLineKey = 0x10100009,
5148 LineKey = 0x1010000a,
5149 DistantLightKey = 0x1010000b,
5150 SpotlightKey = 0x1010000c,
5151 MarkerKey = 0x1010000d,
5152 MeshKey = 0x1010000e,
5153 NURBSCurveKey = 0x1010000f,
5154 NURBSSurfaceKey = 0x10100010,
5155 PolygonKey = 0x10100011,
5156 ShellKey = 0x10100012,
5157 SphereKey = 0x10100013,
5158 TextKey = 0x10100014,
5159 GridKey = 0x10100015,
5161 Definition = 0x20000000,
5162 NamedStyleDefinition = 0x20000001,
5163 TextureDefinition = 0x20000002,
5164 LinePatternDefinition = 0x20000003,
5165 GlyphDefinition = 0x20000004,
5166 CubeMapDefinition = 0x20000005,
5167 ImageDefinition = 0x20000006,
5168 MaterialPaletteDefinition = 0x20000007,
5169 ShaderDefinition = 0x20000008,
5171 Control = 0x50000000,
5172 CameraControl = 0x50000001,
5173 SelectabilityControl = 0x50000002,
5174 MarkerAttributeControl = 0x50000003,
5175 SphereAttributeControl = 0x50000004,
5176 LightingAttributeControl = 0x50000005,
5177 CylinderAttributeControl = 0x50000006,
5178 TextAttributeControl = 0x50000007,
5179 LineAttributeControl = 0x50000008,
5180 EdgeAttributeControl = 0x50000009,
5181 CurveAttributeControl = 0x5000000a,
5182 ModellingMatrixControl = 0x5000000b,
5183 TextureMatrixControl = 0x5000000c,
5184 CullingControl = 0x5000000d,
5185 TransparencyControl = 0x5000000e,
5186 MaterialMappingControl = 0x5000000f,
5187 NURBSSurfaceAttributeControl = 0x50000010,
5188 PostProcessEffectsControl = 0x50000011,
5189 BoundingControl = 0x50000012,
5190 VisualEffectsControl = 0x50000013,
5191 SelectionOptionsControl = 0x50000014,
5192 HighlightOptionsControl = 0x50000015,
5193 DefinitionControl = 0x50000016,
5194 SelectionControl = 0x50000017,
5195 HighlightControl = 0x50000018,
5196 StandAloneWindowOptionsControl = 0x50000019,
5197 OffScreenWindowOptionsControl = 0x5000001a,
5198 ApplicationWindowOptionsControl = 0x5000001b,
5199 VisibilityControl = 0x5000001c,
5200 SubwindowControl = 0x5000001d,
5201 PerformanceControl = 0x5000001e,
5202 HiddenLineAttributeControl = 0x5000001f,
5203 DrawingAttributeControl = 0x50000020,
5204 DebuggingControl = 0x50000021,
5205 ContourLineControl = 0x50000022,
5206 StyleControl = 0x50000023,
5207 ConditionControl = 0x50000024,
5208 PortfolioControl = 0x50000025,
5209 WindowInfoControl = 0x50000026,
5210 AttributeLockControl = 0x50000027,
5211 TransformMaskControl = 0x50000028,
5212 ColorInterpolationControl = 0x50000029,
5213 UpdateOptionsControl = 0x50000030,
5214 CuttingSectionAttributeControl = 0x50000031,
5216 LibraryMask = 0x80FF0000,
5218 Sprocket = 0x80000000,
5219 Canvas = 0x80000001,
5220 Layout = 0x80000002,
5223 Operator = 0x80000005,
5224 SprocketPath = 0x80000007,
5226 SprocketControl = 0xD0000000,
5227 OperatorControl = 0xD0000008,
5228 NavigationCubeControl = 0xD0000009,
5229 AxisTriadControl = 0xD000000A,
5231 Metadata = 0x80001000,
5232 IntegerMetadata = 0x80001001,
5233 UnsignedIntegerMetadata = 0x80001002,
5234 DoubleMetadata = 0x80001003,
5235 StringMetadata = 0x80001004,
5236 TimeMetadata = 0x80001005,
5237 BooleanMetadata = 0x80001006,
5239 Component = 0x80000200,
5240 Filter = 0x80000600,
5241 Capture = 0x80000a00,
5242 CADModel = 0x80000300,
5243 ComponentPath = 0x81001000,
5245 ExchangeMask = 0x80020000,
5246 ExchangeComponent = 0x80021200,
5247 ExchangeFilter = 0x80020601,
5248 ExchangeCapture = 0x80020a01,
5249 ExchangeCADModel = 0x80020301,
5250 ExchangeConfiguration = 0x81020001,
5251 ExchangeImportOptionsKit = 0x81020002,
5252 ExchangeExportACISOptionsKit = 0x81020003,
5253 ExchangeExportIGESOptionsKit = 0x81020004,
5254 ExchangeExportJTOptionsKit = 0x81020005,
5255 ExchangeExportParasolidOptionsKit = 0x81020006,
5256 ExchangeExportPRCOptionsKit = 0x81020007,
5257 ExchangeExportSTEPOptionsKit = 0x81020008,
5258 ExchangeExportSTLOptionsKit = 0x81020009,
5259 ExchangeExportU3DOptionsKit = 0x8102000a,
5260 ExchangeExportXMLOptionsKit = 0x8102000b,
5261 ExchangeTessellationOptionsKit = 0x8102000c,
5262 ExchangeSheet = 0x80021201,
5263 ExchangeModelFileImportOptionsKit = 0x8102000d,
5265 PublishMask = 0x80040000,
5266 PublishDocumentKit = 0x81040001,
5267 PublishPageKit = 0x81040002,
5268 PublishTemplateKit = 0x81040003,
5269 PublishAnnotationKit = 0x81040004,
5270 PublishArtworkKit = 0x81040005,
5271 PublishViewKit = 0x81040006,
5272 PublishTextKit = 0x81040007,
5273 PublishImageKit = 0x81040008,
5274 PublishTableKit = 0x81040009,
5275 PublishExportOptionsKit = 0x8104000a,
5276 PublishLinkKit = 0x8104000b,
5277 PublishButtonKit = 0x8104000c,
5278 PublishTextFieldKit = 0x8104000d,
5279 PublishSlideTableKit = 0x8104000e,
5280 PublishCheckBoxKit = 0x8104000f,
5281 PublishRadioButtonKit = 0x81040010,
5282 PublishListBoxKit = 0x81040011,
5283 PublishDropDownListKit = 0x81040012,
5284 PublishSignatureFieldKit = 0x81040013,
5286 PublishDocumentKey = 0x80040001,
5287 PublishPageControl = 0x80040002,
5289 SceneTree = 0x80008001,
5290 SceneTreeItem = 0x80008002,
5292 ComponentTree = 0x80008003,
5293 ComponentTreeItem = 0x80008004,
5295 SketchupMask = 0x80100000,
5296 SketchupImportOptionsKit = 0x81100001,
5297 SketchupImportResultsKit = 0x81100002,
5299 ParasolidMask = 0x80200000,
5300 ParasolidComponent = 0x80201201,
5301 ParasolidCADModel = 0x80200302,
5302 ParasolidImportOptionsKit = 0x81200003,
5303 ParasolidFacetTessellationKit = 0x81200004,
5304 ParasolidLineTessellationKit = 0x81200005,
5305 ParasolidExportOptionsKit = 0x81200006,
5307 IONotifierData = 0x84000200,
5308 StreamImportNotifierData = 0x84000201,
5309 STLImportNotifierData = 0x84000202,
5310 OBJImportNotifierData = 0x84000203,
5311 ExchangeImportNotifierData = 0x84020204,
5312 SketchupImportNotifierData = 0x84100205,
5313 ParasolidImportNotifierData = 0x84200206,
5314 ExchangeTranslationNotifierData = 0x84020207,
5315 ExchangeExportNotifierData = 0x84020208,
5327 static void * Allocate(
size_t in_bytes,
bool in_clear_memory =
true);
5334 static void Free(
void * in_pointer);
5343 template <
typename T>
5344 class NO_HPS_API Allocator
5347 typedef T value_type;
5348 typedef value_type * pointer;
5349 typedef value_type
const * const_pointer;
5350 typedef value_type & reference;
5351 typedef value_type
const & const_reference;
5352 typedef size_t size_type;
5353 typedef ptrdiff_t difference_type;
5357 Allocator(Allocator<T>
const & in_that) { HPS_UNREFERENCED(in_that); }
5360 template <
typename U> Allocator(Allocator<U>
const &) {}
5362 template <
typename U>
5365 typedef Allocator<U> other;
5369 pointer address(reference x)
const {
return &x; }
5370 const_pointer address(const_reference x)
const {
return &x; }
5372 pointer allocate(size_type n,
void * v = 0) { HPS_UNREFERENCED(v);
return static_cast<pointer
>(
Memory::Allocate(n *
sizeof(T))); }
5373 void deallocate(pointer p, size_type n) { HPS_UNREFERENCED(n);
Memory::Free(p); }
5375 #if defined(_MSC_VER) || defined (__APPLE__)
5376 void construct(pointer p, const_reference x) {
new(p) T(x); }
5378 template<
typename U,
typename... Args>
5379 void construct(U * p, Args&&... args) {
new(p) U(std::forward<Args>(args)...); }
5381 void destroy(pointer p) { HPS_UNREFERENCED(p); p->~T(); }
5383 size_type max_size()
const {
return static_cast<size_type
>(-1) /
sizeof(T); }
5386 template <
typename T,
typename U>
5387 bool operator==(
const Allocator<T> &,
const Allocator<U> &) {
return true; }
5389 template <
typename T,
typename U>
5390 bool operator!=(
const Allocator<T> &,
const Allocator<U> &) {
return false; }
5396 Exception(
char const * in_info) : std::runtime_error(in_info) { }
5404 InvalidObjectException(
char const * in_info =
"Attempted to use a deleted, uninitialized, or otherwise invalid object.") :
5414 IndexOutOfRangeException(
char const * in_info =
"Attempted to access an element outside the bounds of the array.") :
5493 virtual bool Empty()
const {
return (impl_ == 0);};
5496 virtual void Reset();
5501 bool HasType(Type in_mask)
const;
5505 intptr_t GetClassID()
const;
5510 intptr_t GetInstanceID()
const;
5512 template <
typename T>
5513 static intptr_t ClassID()
5515 static const intptr_t ret = T().GetClassID();
5520 friend class HPSI::Impl;
5521 friend class HPSI::KeyImpl;
5522 friend class HPSI::TicketImpl;
5531 Type ObjectType()
const {
return Type::Control;}
5548 this->Object::operator=(std::move(in_that));
6016 Event(intptr_t in_channel = 0): channel(in_channel), consumable(true), time_stamp(0) {}
6021 intptr_t GetClassID()
const;
6025 virtual Event * Clone()
const=0;
6028 virtual bool Drop(
Event const * in_that_event)
const { HPS_UNREFERENCED(in_that_event);
return false; }
6043 static void *
operator new (
size_t in_size) {
return Memory::Allocate(in_size); }
6044 static void operator delete (
void * in_ptr,
size_t in_size)
throw () { HPS_UNREFERENCED(in_size);
Memory::Free(in_ptr); }
6051 friend class HPSI::EventDispatcherImpl;
6101 enum class KeyboardCode
6301 : ID(in_id), Location(in_location), TapCount(in_tap_count) {}
6308 return (ID == in_that.
ID && Location == in_that.
Location && TapCount == in_that.
TapCount);
6316 return !(*
this == in_that);
6325 typedef std::vector<Point, Allocator<Point> > PointArray;
6326 typedef std::vector<ObjectPoint, Allocator<ObjectPoint> > ObjectPointArray;
6327 typedef std::vector<WorldPoint, Allocator<WorldPoint> > WorldPointArray;
6328 typedef std::vector<CameraPoint, Allocator<CameraPoint> > CameraPointArray;
6329 typedef std::vector<NormalizedPoint, Allocator<NormalizedPoint> > NormalizedPointArray;
6330 typedef std::vector<ScreenRangePoint, Allocator<ScreenRangePoint> > ScreenRangePointArray;
6331 typedef std::vector<InnerWindowPoint, Allocator<InnerWindowPoint> > InnerWindowPointArray;
6332 typedef std::vector<InnerPixelPoint, Allocator<InnerPixelPoint> > InnerPixelPointArray;
6333 typedef std::vector<WindowPoint, Allocator<WindowPoint> > WindowPointArray;
6334 typedef std::vector<PixelPoint, Allocator<PixelPoint> > PixelPointArray;
6335 typedef std::vector<Vector, Allocator<Vector> > VectorArray;
6336 typedef std::vector<DVector, Allocator<DVector> > DVectorArray;
6337 typedef std::vector<Plane, Allocator<Plane> > PlaneArray;
6338 typedef std::vector<int, Allocator<int> > IntArray;
6339 typedef std::vector<RGBColor, Allocator<RGBColor> > RGBColorArray;
6340 typedef std::vector<RGBAColor, Allocator<RGBAColor> > RGBAColorArray;
6341 typedef std::vector<unsigned int, Allocator<unsigned int> > UnsignedIntArray;
6342 typedef std::vector<size_t, Allocator<size_t> > SizeTArray;
6343 typedef std::vector<float, Allocator<float> > FloatArray;
6344 typedef std::vector<SegmentKey, Allocator<SegmentKey> > SegmentKeyArray;
6345 typedef std::vector<WindowKey, Allocator<WindowKey> > WindowKeyArray;
6346 typedef std::vector<EventHandler, Allocator<EventHandler> > EventHandlerArray;
6347 typedef std::vector<GlyphElement, Allocator<GlyphElement> > GlyphElementArray;
6348 typedef std::vector<GlyphPoint, Allocator<GlyphPoint> > GlyphPointArray;
6349 typedef std::vector<UTF8, Allocator<UTF8> > UTF8Array;
6350 typedef std::vector<UTF8Array, Allocator<UTF8Array> > UTF8ArrayArray;
6351 typedef std::vector<bool, Allocator<bool> > BoolArray;
6352 typedef std::vector<TrimKit, Allocator<TrimKit> > TrimKitArray;
6353 typedef std::vector<Key, Allocator<Key> > KeyArray;
6354 typedef std::vector<PortfolioKey, Allocator<PortfolioKey> > PortfolioKeyArray;
6355 typedef std::vector<char, Allocator<char> > CharArray;
6356 typedef std::vector<wchar_t, Allocator<wchar_t> > WCharArray;
6357 typedef std::vector<byte, Allocator<byte> > ByteArray;
6358 typedef std::vector<ByteArray, Allocator<ByteArray> > ByteArrayArray;
6359 typedef std::vector<sbyte, Allocator<sbyte> > SByteArray;
6360 typedef std::vector<MaterialKit, Allocator<MaterialKit> > MaterialKitArray;
6361 typedef std::vector<LinePatternElement, Allocator<LinePatternElement> > LinePatternElementArray;
6362 typedef std::vector<LinePatternParallelKit, Allocator<LinePatternParallelKit> > LinePatternParallelKitArray;
6363 typedef std::vector<Material::Type, Allocator<Material::Type> > MaterialTypeArray;
6364 typedef std::vector<Search::Type, Allocator<Search::Type> > SearchTypeArray;
6365 typedef std::vector<Line::SizeUnits, Allocator<Line::SizeUnits> > LineSizeUnitsArray;
6366 typedef std::vector<CameraKit, Allocator<CameraKit> > CameraKitArray;
6367 typedef std::vector<Condition, Allocator<Condition> > ConditionArray;
6368 typedef std::vector<TextureDefinition, Allocator<TextureDefinition> > TextureDefinitionArray;
6369 typedef std::vector<CubeMapDefinition, Allocator<CubeMapDefinition> > CubeMapDefinitionArray;
6370 typedef std::vector<ImageDefinition, Allocator<ImageDefinition> > ImageDefinitionArray;
6371 typedef std::vector<NamedStyleDefinition, Allocator<NamedStyleDefinition> > NamedStyleDefinitionArray;
6372 typedef std::vector<MaterialPaletteDefinition, Allocator<MaterialPaletteDefinition> > MaterialPaletteDefinitionArray;
6373 typedef std::vector<GlyphDefinition, Allocator<GlyphDefinition> > GlyphDefinitionArray;
6374 typedef std::vector<LinePatternDefinition, Allocator<LinePatternDefinition> > LinePatternDefinitionArray;
6375 typedef std::vector<ShaderDefinition, Allocator<ShaderDefinition> > ShaderDefinitionArray;
6376 typedef std::vector<IntRectangle, Allocator<IntRectangle> > IntRectangleArray;
6377 typedef std::vector<AttributeLock::Type, Allocator<AttributeLock::Type> > AttributeLockTypeArray;
6378 typedef std::vector<Style::Type, Allocator<Style::Type> > StyleTypeArray;
6379 typedef std::vector<TrimElement, Allocator<TrimElement> > TrimElementArray;
6380 typedef std::vector<KeyPath, Allocator<KeyPath> > KeyPathArray;
6381 typedef std::vector<IncludeKey, Allocator<IncludeKey> > IncludeKeyArray;
6382 typedef std::vector<KeyboardCode, Allocator<KeyboardCode> > KeyboardCodeArray;
6383 typedef std::vector<Touch, Allocator<Touch> > TouchArray;
6384 typedef std::vector<ReferenceKey, Allocator<ReferenceKey> > ReferenceKeyArray;
6385 typedef std::vector<intptr_t, Allocator<intptr_t> > IntPtrTArray;
6386 typedef std::vector<GeometryKey, Allocator<GeometryKey> > GeometryKeyArray;
6387 typedef std::vector<Shell::Relation, Allocator<Shell::Relation> > ShellRelationArray;
6388 typedef std::vector<StyleKey, Allocator<StyleKey> > StyleKeyArray;
6389 typedef std::vector<PointArray, Allocator<PointArray> > PointArrayArray;
6453 bool IsValid()
const;
6461 Key GetItem()
const;
6465 Key operator*()
const;
6469 SearchTypeArray GetResultTypes()
const;
6494 virtual void Reset();
6513 size_t GetCount()
const;
6552 Type
ObjectType()
const {
return Type::FontSearchResultsIterator;}
6583 bool IsValid()
const;
6622 virtual void Reset();
6642 size_t GetCount()
const;
6666 UTF8(
char const * in_string,
char const * in_locale = 0);
6670 UTF8(
wchar_t const * in_string);
6689 return Assign(std::move(in_utf8));
6696 size_t ToWStr(
wchar_t * out_wide_string)
const;
6701 size_t ToWStr(WCharArray & out_wide_string)
const;
6707 return (_length > 0);
6714 return (_length == 0);
6748 inline operator char const * ()
const
6755 char At(
size_t in_index)
const
6759 else if(in_index >= _length)
6762 return _text[in_index];
6768 UTF8 & Assign(
UTF8 const & in_utf8);
6775 return Assign(in_utf8);
6781 UTF8 & operator+= (
UTF8 const & in_utf8);
6786 UTF8 & operator+= (
char const * in_utf8);
6791 UTF8 operator+ (
UTF8 const & in_utf8)
const;
6796 UTF8 operator+ (
char const * in_utf8)
const;
6801 bool operator== (
UTF8 const & in_utf8)
const;
6806 bool operator!= (
UTF8 const & in_utf8)
const
6808 return !(*
this == in_utf8);
6814 bool operator== (
char const * in_utf8)
const;
6819 bool operator!= (
char const * in_utf8)
const
6821 return !(*
this == in_utf8);
6830 return in_right == in_left;
6839 return in_right != in_left;
6848 return in_right ==
UTF8(in_left);
6857 return in_right !=
UTF8(in_left);
6864 friend inline UTF8 operator+ (
char const * in_left,
UTF8 const & in_right)
6866 return UTF8(in_left) + in_right;
6873 friend inline UTF8 operator+ (
wchar_t const * in_left,
UTF8 const & in_right)
6875 return UTF8(in_left) + in_right;
6881 size_t GetHash()
const;
6885 size_t internal_encode(
wchar_t const * in_wide_string);
6886 size_t internal_decode(
wchar_t * out_wide_string)
const;
6890 mutable size_t _hash_key;
6891 static const size_t _buffer_size = 64 -
sizeof(
const char *) - 2 *
sizeof(
size_t);
6892 char _buffer[_buffer_size];
6897 inline size_t operator()(
const UTF8 & in_utf8)
const
6936 bool ShowCondition(
UTF8 & out_condition)
const;
6942 bool ShowOperands(ConditionArray & out_operands)
const;
6952 bool Equals(
Condition const & in_that)
const;
6957 bool operator==(
Condition const & in_that)
const;
6962 bool operator!=(
Condition const & in_that)
const;
7034 HPS_API Condition NOT(Condition
const & in_operand);
7040 HPS_API Condition OR(Condition
const & in_operand1, Condition
const & in_operand2);
7046 HPS_API Condition XOR(Condition
const & in_operand1, Condition
const & in_operand2);
7052 HPS_API Condition AND(Condition
const & in_operand1, Condition
const & in_operand2);
7069 Key(
Key const & in_that);
7082 Key & operator=(
Key && in_that);
7090 bool HasOwner()
const;
7102 void MoveTo(
SegmentKey const & in_new_owner);
7109 Key & operator=(
Key const & in_that);
7112 virtual void Assign(
Key const & in_that);
7115 bool Equals(
Key const & in_that)
const;
7118 bool operator!= (
Key const & in_that)
const;
7121 bool operator== (
Key const & in_that)
const;
7125 size_t GetHash()
const;
7130 inline size_t operator()(
const Key & in_key)
const
7178 SegmentKey Down(
char const * in_segment_name,
bool in_create_if_not_present =
false)
const;
7182 SegmentKey Subsegment(
char const * in_segment_name =
"",
bool in_create_if_not_present =
true)
const;
7240 size_t ShowSubsegments()
const;
7243 size_t ShowSubsegments(SegmentKeyArray & out_children)
const;
7248 size_t ShowReferrers(SegmentKeyArray & out_segments)
const;
7253 size_t ShowReferrers(ReferenceKeyArray & out_references)
const;
7258 size_t ShowStylers(SegmentKeyArray & out_segments)
const;
7263 size_t ShowStylers(StyleKeyArray & out_styles)
const;
7268 size_t ShowIncluders(SegmentKeyArray & out_segments)
const;
7273 size_t ShowIncluders(IncludeKeyArray & out_includes)
const;
7292 SegmentKey & SetCondition(
char const * in_condition);
7295 SegmentKey & SetConditions(UTF8Array
const & in_conditions);
7298 SegmentKey & SetConditions(
size_t in_count,
UTF8 const in_conditions []);
7304 bool ShowConditions(UTF8Array & out_conditions)
const;
7314 SegmentKey & SetMaterialPalette(
char const * in_name);
7320 bool ShowMaterialPalette(
UTF8 & out_name)
const;
7338 bool ShowPriority(
int & out_priority)
const;
7346 SegmentKey & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
7352 SegmentKey & SetUserData(intptr_t in_index, ByteArray
const & in_data);
7357 SegmentKey & UnsetUserData(intptr_t in_index);
7363 SegmentKey & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
7368 SegmentKey & UnsetUserData(IntPtrTArray
const & in_indices);
7375 size_t ShowUserDataCount()
const;
7380 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
7386 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
7393 LineKey InsertLine(
size_t in_count,
Point const in_pts[]);
7396 LineKey InsertLine(PointArray
const & in_pts);
7472 PolygonKey InsertPolygon(PointArray
const & in_pts);
7482 ShellKey InsertShell(PointArray
const & in_points, IntArray
const & in_facelist);
7485 ShellKey InsertShell(
size_t in_point_count,
Point const in_points [],
size_t in_facelist_count,
int const in_facelist []);
7492 MeshKey InsertMesh(
size_t in_rows,
size_t in_columns, PointArray
const & in_points);
7495 MeshKey InsertMesh(
size_t in_rows,
size_t in_columns,
size_t in_point_count,
Point const in_points []);
7543 NURBSCurveKey InsertNURBSCurve(
size_t in_degree, PointArray
const & in_points, FloatArray
const & in_weights, FloatArray
const & in_knots,
float in_start_u,
float in_end_u);
7546 NURBSCurveKey InsertNURBSCurve(
size_t in_degree,
size_t in_pcount,
Point const in_points [],
float const in_weights[],
size_t in_knot_count,
float const in_knots[],
float in_start_u,
float in_end_u);
7553 NURBSSurfaceKey InsertNURBSSurface(
size_t in_udegree,
size_t in_vdegree,
size_t in_ucount,
size_t in_vcount, PointArray
const & in_points, FloatArray
const & in_weights, FloatArray
const & in_uknots, FloatArray
const & in_vknots);
7556 NURBSSurfaceKey InsertNURBSSurface(
size_t in_udegree,
size_t in_vdegree,
size_t in_ucount,
size_t in_vcount,
size_t in_point_count,
Point const in_points[],
float const in_weights[],
size_t in_uknot_count,
float const in_uknots[],
size_t in_vknot_count,
float const in_vknots[]);
7559 NURBSSurfaceKey InsertNURBSSurface(
size_t in_udegree,
size_t in_vdegree,
size_t in_ucount,
size_t in_vcount, PointArray
const & in_points, FloatArray
const & in_weights, FloatArray
const & in_uknots, FloatArray
const & in_vknots, TrimKitArray
const & in_trims);
7562 NURBSSurfaceKey InsertNURBSSurface(
size_t in_udegree,
size_t in_vdegree,
size_t in_ucount,
size_t in_vcount,
size_t in_point_count,
Point const in_points[],
float const in_weights[],
size_t in_uknot_count,
float const in_uknots[],
size_t in_vknot_count,
float const in_vknots[],
size_t in_trim_count,
TrimKit const in_trims[]);
7573 TextKey InsertText(
Point const & in_position,
char const * in_text);
7592 LineKey InsertLineFromGeometry(
CircleKey const & in_circle,
float in_deviation = -1.0f);
7619 LineKey InsertLineFromGeometry(
EllipseKey const & in_ellipse,
float in_deviation = -1.0f);
7637 LineKey InsertLineFromGeometry(
NURBSCurveKey const & in_nurbs_curve,
float in_deviation = -1.0f);
7719 bool ShowCamera(
CameraKit & out_kit)
const;
7768 bool ShowCulling(
CullingKit & out_kit)
const;
7797 SegmentKey & UnsetCuttingSectionAttributes();
7944 bool ShowModellingMatrix(
MatrixKit & out_kit)
const;
8064 bool ShowTextureMatrix(
MatrixKit & out_kit)
const;
8372 bool ShowSnapshot(
ImageKit & out_kit)
const;
8383 SegmentKey & UnsetCuttingSectionAttributes();
8406 void MoveTo(
SegmentKey const & in_new_owner);
8425 KeyPath(KeyArray
const & in_path);
8430 KeyPath(
size_t in_path_count,
Key const in_path []);
8463 KeyPath & operator+=(KeyArray
const & in_key_array);
8478 KeyPath & Append(KeyArray
const & in_key_array);
8488 KeyPath & operator=(KeyArray
const & in_path);
8492 void Set(
KeyPath const & in_that);
8497 bool Equals(
KeyPath const & in_that)
const;
8502 bool operator!= (
KeyPath const & in_that)
const;
8507 bool operator== (
KeyPath const & in_that)
const;
8513 KeyPath & SetKeys(KeyArray
const & in_keys);
8519 KeyPath & SetKeys(
size_t in_key_count,
Key const in_keys []);
8529 bool ShowKeys(KeyArray & out_keys)
const;
8553 bool ComputeTextExtent(
const char* in_text,
float & out_xfrac,
float & out_yfrac)
const;
8570 bool ShowNetBounding(
BoundingKit & out_kit)
const;
8574 bool ShowNetCamera(
CameraKit & out_kit)
const;
8638 bool ShowNetModellingMatrix(
MatrixKit & out_kit)
const;
8642 bool ShowNetTextureMatrix(
MatrixKit & out_kit)
const;
8646 bool ShowNetCulling(
CullingKit & out_kit)
const;
8678 bool ShowNetConditions(UTF8Array & out_conditions)
const;
8694 inline KeyPath operator+(Key
const & in_lhs, Key
const & in_rhs)
8703 inline KeyPath operator+(Key
const & in_lhs, KeyArray
const & in_rhs)
8712 inline KeyPath operator+(Key
const & in_lhs, KeyPath
const & in_rhs)
8721 inline KeyPath operator+(KeyArray
const & in_lhs, Key
const & in_rhs)
8730 inline KeyPath operator+(KeyArray
const & in_lhs, KeyArray
const & in_rhs)
8739 inline KeyPath operator+(KeyArray
const & in_lhs, KeyPath
const & in_rhs)
8748 inline KeyPath operator+(KeyPath
const & in_lhs, Key
const & in_rhs)
8757 inline KeyPath operator+(KeyPath
const & in_lhs, KeyArray
const & in_rhs)
8766 inline KeyPath operator+(KeyPath
const & in_lhs, KeyPath
const & in_rhs)
8833 bool operator==(
BoundingKit const & in_kit)
const;
8838 bool operator!=(
BoundingKit const & in_kit)
const;
8879 bool ShowExclusion(
bool & out_exclusion)
const;
8958 bool ShowExclusion(
bool & out_exclusion)
const;
9290 bool ShowCuttingSections(
bool & out_state)
const;
9295 bool ShowCutEdges(
bool & out_state)
const;
9300 bool ShowCutFaces(
bool & out_state)
const;
9305 bool ShowWindows(
bool & out_state)
const;
9310 bool ShowText(
bool & out_state)
const;
9315 bool ShowLines(
bool & out_state)
const;
9320 bool ShowEdgeLights(
bool & out_state)
const;
9325 bool ShowMarkerLights(
bool & out_state)
const;
9330 bool ShowFaceLights(
bool & out_state)
const;
9335 bool ShowGenericEdges(
bool & out_state)
const;
9340 bool ShowInteriorSilhouetteEdges(
bool & out_state)
const;
9345 bool ShowAdjacentEdges(
bool & out_state)
const;
9350 bool ShowHardEdges(
bool & out_state)
const;
9355 bool ShowMeshQuadEdges(
bool & out_state)
const;
9360 bool ShowNonCulledEdges(
bool & out_state)
const;
9365 bool ShowPerimeterEdges(
bool & out_state)
const;
9370 bool ShowFaces(
bool & out_state)
const;
9375 bool ShowVertices(
bool & out_state)
const;
9380 bool ShowMarkers(
bool & out_state)
const;
9385 bool ShowShadowCasting(
bool & out_state)
const;
9390 bool ShowShadowReceiving(
bool & out_state)
const;
9395 bool ShowShadowEmitting(
bool & out_state)
const;
9692 bool ShowCuttingSections(
bool & out_state)
const;
9697 bool ShowCutEdges(
bool & out_state)
const;
9702 bool ShowCutFaces(
bool & out_state)
const;
9707 bool ShowWindows(
bool & out_state)
const;
9712 bool ShowText(
bool & out_state)
const;
9717 bool ShowLines(
bool & out_state)
const;
9722 bool ShowEdgeLights(
bool & out_state)
const;
9727 bool ShowMarkerLights(
bool & out_state)
const;
9732 bool ShowFaceLights(
bool & out_state)
const;
9737 bool ShowGenericEdges(
bool & out_state)
const;
9742 bool ShowInteriorSilhouetteEdges(
bool & out_state)
const;
9747 bool ShowAdjacentEdges(
bool & out_state)
const;
9752 bool ShowHardEdges(
bool & out_state)
const;
9757 bool ShowMeshQuadEdges(
bool & out_state)
const;
9762 bool ShowNonCulledEdges(
bool & out_state)
const;
9767 bool ShowPerimeterEdges(
bool & out_state)
const;
9772 bool ShowFaces(
bool & out_state)
const;
9777 bool ShowVertices(
bool & out_state)
const;
9782 bool ShowMarkers(
bool & out_state)
const;
9787 bool ShowShadowCasting(
bool & out_state)
const;
9792 bool ShowShadowReceiving(
bool & out_state)
const;
9797 bool ShowShadowEmitting(
bool & out_state)
const;
9859 bool Equals(
CameraKit const & in_kit)
const;
9864 bool operator==(
CameraKit const & in_kit)
const;
9869 bool operator!=(
CameraKit const & in_kit)
const;
9899 CameraKit & SetField(
float in_width,
float in_height);
9910 CameraKit & SetNearLimit(
float const in_limit);
9944 bool ShowUpVector(
Vector & out_up)
const;
9949 bool ShowPosition(
Point & out_position)
const;
9954 bool ShowTarget(
Point & out_target)
const;
9966 bool ShowProjection(
Camera::Projection & out_type,
float & out_oblique_y_skew,
float & out_oblique_x_skew)
const;
9971 bool ShowWidth(
float & out_width)
const;
9976 bool ShowHeight(
float & out_height)
const;
9982 bool ShowField(
float & out_width,
float & out_height)
const;
9987 bool ShowNearLimit(
float & out_near_limit)
const;
9995 CameraKit & Dolly(
float in_x_dir,
float in_up,
float in_forward);
10003 CameraKit & Orbit(
float in_theta,
float in_phi);
10011 CameraKit & Pan(
float in_theta,
float in_phi);
10113 bool ShowUpVector(
Vector & out_up)
const;
10118 bool ShowPosition(
Point & out_position)
const;
10123 bool ShowTarget(
Point & out_target)
const;
10135 bool ShowProjection(
Camera::Projection & out_type,
float & out_oblique_x_skew,
float & out_oblique_y_skew)
const;
10140 bool ShowWidth(
float & out_width)
const;
10145 bool ShowHeight(
float & out_height)
const;
10151 bool ShowField(
float & out_width,
float & out_height)
const;
10156 bool ShowNearLimit(
float & out_width)
const;
10164 CameraControl & Dolly(
float in_x_dir,
float in_up,
float in_forward);
10250 bool Empty()
const;
10620 bool Empty()
const;
10706 bool ShowDepthPeelingLayers(
unsigned int & out_layers)
const;
10717 bool ShowDepthWriting(
bool & out_state)
const;
10821 bool ShowDepthPeelingLayers(
unsigned int & out_layers)
const;
10832 bool ShowDepthWriting(
bool & out_state)
const;
10877 bool Empty()
const;
10952 bool ShowFaceColor(
bool & out_state)
const;
10957 bool ShowEdgeColor(
bool & out_state)
const;
10962 bool ShowVertexColor(
bool & out_state)
const;
10967 bool ShowFaceIndex(
bool & out_state)
const;
10972 bool ShowEdgeIndex(
bool & out_state)
const;
10977 bool ShowVertexIndex(
bool & out_state)
const;
11073 bool ShowFaceColor(
bool & out_state)
const;
11078 bool ShowEdgeColor(
bool & out_state)
const;
11083 bool ShowVertexColor(
bool & out_state)
const;
11088 bool ShowFaceIndex(
bool & out_state)
const;
11093 bool ShowEdgeIndex(
bool & out_state)
const;
11098 bool ShowVertexIndex(
bool & out_state)
const;
11153 bool Empty()
const;
11158 bool Equals(
CullingKit const & in_kit)
const;
11163 bool operator==(
CullingKit const & in_kit)
const;
11168 bool operator!=(
CullingKit const & in_kit)
const;
11174 CullingKit & SetDeferralExtent(
bool in_state,
unsigned int in_pixels);
11180 CullingKit & SetDeferralExtent(
unsigned int in_pixels);
11186 CullingKit & SetExtent(
bool in_state,
unsigned int in_pixels);
11192 CullingKit & SetExtent(
unsigned int in_pixels);
11205 CullingKit & SetVector(
bool in_state,
Vector const & in_vector,
float in_tolerance_degrees);
11213 CullingKit & SetVector(
Vector const & in_vector,
float in_tolerance_degrees);
11233 CullingKit & SetVectorTolerance(
float in_tolerance_degrees);
11272 bool ShowDeferralExtent(
bool & out_state,
unsigned int & out_pixels)
const;
11278 bool ShowExtent(
bool & out_state,
unsigned int & out_pixels)
const;
11283 bool ShowBackFace(
bool & out_state)
const;
11290 bool ShowVector(
bool & out_state,
Vector & out_vector)
const;
11295 bool ShowVectorTolerance(
float & out_tolerance_degrees)
const;
11300 bool ShowFrustum(
bool & out_state)
const;
11340 CullingControl & SetDeferralExtent(
bool in_state,
unsigned int in_pixels);
11354 CullingControl & SetExtent(
bool in_state,
unsigned int in_pixels);
11374 CullingControl & SetVector(
bool in_state,
Vector const & in_vector,
float in_tolerance_degrees);
11402 CullingControl & SetVectorTolerance(
float in_tolerance_degrees);
11441 bool ShowDeferralExtent(
bool & out_state,
unsigned int & out_pixels)
const;
11447 bool ShowExtent(
bool & out_state,
unsigned int & out_pixels)
const;
11452 bool ShowBackFace(
bool & out_state)
const;
11459 bool ShowVector(
bool & out_state,
Vector & out_vector)
const;
11464 bool ShowVectorTolerance(
float & out_tolerance_degrees)
const;
11469 bool ShowFrustum(
bool & out_state)
const;
11526 bool Empty()
const;
11572 bool ShowSymbol(
UTF8 & out_glyph_name)
const;
11642 bool ShowSymbol(
UTF8 & out_glyph_name)
const;
11703 bool Empty()
const;
11739 bool ShowTessellation(
size_t & out_facets)
const;
11793 bool ShowTessellation(
size_t & out_facets)
const;
11848 bool Empty()
const;
11997 bool Empty()
const;
12043 bool ShowTessellation(
size_t & out_facets)
const;
12113 bool ShowTessellation(
size_t & out_facets)
const;
12174 bool Empty()
const;
12269 Type
ObjectType()
const {
return Type::CuttingSectionAttributeControl;};
12377 bool Empty()
const;
12651 bool ShowBold(
bool & out_state)
const;
12656 bool ShowItalic(
bool & out_state)
const;
12661 bool ShowOverline(
bool & out_state)
const;
12666 bool ShowStrikethrough(
bool & out_state)
const;
12671 bool ShowUnderline(
bool & out_state)
const;
12676 bool ShowSlant(
float & out_angle)
const;
12681 bool ShowLineSpacing(
float & out_multiplier)
const;
12687 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
12694 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
12720 bool ShowFont(
UTF8 & out_name)
const;
12743 bool ShowPath(
Vector & out_path)
const;
12748 bool ShowSpacing(
float & out_multiplier)
const;
13041 bool ShowBold(
bool & out_state)
const;
13046 bool ShowItalic(
bool & out_state)
const;
13051 bool ShowOverline(
bool & out_state)
const;
13056 bool ShowStrikethrough(
bool & out_state)
const;
13061 bool ShowUnderline(
bool & out_state)
const;
13066 bool ShowSlant(
float & out_angle)
const;
13071 bool ShowLineSpacing(
float & out_multiplier)
const;
13077 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
13084 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
13110 bool ShowFont(
UTF8 & out_name)
const;
13133 bool ShowPath(
Vector & out_path)
const;
13138 bool ShowSpacing(
float & out_multiplier)
const;
13196 bool Empty()
const;
13255 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
13333 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
13389 bool Empty()
const;
13435 bool ShowPattern(
UTF8 & out_pattern_name)
const;
13441 bool ShowWeight(
float & out_weight,
Edge::SizeUnits & out_units)
const;
13505 bool ShowPattern(
UTF8 & out_pattern_name)
const;
13511 bool ShowWeight(
float & out_weight,
Edge::SizeUnits & out_units)
const;
13566 bool Empty()
const;
13661 bool ShowBudget(
size_t & out_budget)
const;
13667 bool ShowContinuedBudget(
bool & out_state,
size_t & out_budget)
const;
13672 bool ShowViewDependent(
bool & out_state)
const;
13678 bool ShowMaximumDeviation(
float & out_deviation)
const;
13684 bool ShowMaximumAngle(
float & out_degrees)
const;
13690 bool ShowMaximumLength(
float & out_length)
const;
13804 bool ShowBudget(
size_t & out_budget)
const;
13810 bool ShowContinuedBudget(
bool & out_state,
size_t & out_budget)
const;
13815 bool ShowViewDependent(
bool & out_state)
const;
13821 bool ShowMaximumDeviation(
float & out_deviation)
const;
13827 bool ShowMaximumAngle(
float & out_degrees)
const;
13833 bool ShowMaximumLength(
float & out_length)
const;
13868 MatrixKit(FloatArray
const & in_matrix_source);
13873 MatrixKit(
float const in_matrix_source []);
13903 bool Empty()
const;
13908 bool Equals(
MatrixKit const & in_kit)
const;
13913 bool operator==(
MatrixKit const & in_kit)
const;
13918 bool operator!=(
MatrixKit const & in_kit)
const;
13925 MatrixKit & SetElement(
size_t in_row,
size_t in_column,
float in_value);
13931 MatrixKit & SetElement(
size_t in_ordinal_zero_to_fifteen,
float in_value);
13936 MatrixKit & SetElements(FloatArray
const & in_matrix);
13942 MatrixKit & SetElements(
size_t in_value_count,
float const in_values []);
13955 bool ShowElement(
size_t in_row,
size_t in_column,
float & out_value)
const;
13961 bool ShowElement(
size_t in_ordinal_zero_to_fifteen,
float & out_value)
const;
13966 bool ShowElements(FloatArray & out_matrix)
const;
13971 bool ShowDeterminant(
float & out_determinant)
const;
13976 bool ShowInverse(
MatrixKit & out_matrix)
const;
13982 bool ShowAdjoint(
MatrixKit & out_matrix)
const;
13990 MatrixKit & Rotate(
float in_x,
float in_y,
float in_z);
14003 MatrixKit & Translate(
float in_x,
float in_y,
float in_z);
14010 MatrixKit & Scale(
float in_x,
float in_y,
float in_z);
14044 MatrixKit Multiply(
float in_scalar)
const;
14049 MatrixKit const & MultiplyAndAssign(
float in_scalar);
14064 MatrixKit operator*(
float in_scalar)
const;
14069 MatrixKit const & operator*=(
float in_scalar);
14075 Point Transform(
Point const & in_source)
const;
14080 PointArray Transform(PointArray
const & in_source)
const;
14086 PointArray Transform(
size_t in_count,
Point const in_source [])
const;
14096 VectorArray Transform(VectorArray
const & in_source)
const;
14102 VectorArray Transform(
size_t in_count,
Vector const in_source [])
const;
14107 Plane Transform(
Plane const & in_source)
const;
14112 PlaneArray Transform(PlaneArray
const & in_source)
const;
14118 PlaneArray Transform(
size_t in_count,
Plane const in_source [])
const;
14190 bool ShowElement(
size_t in_row,
size_t in_column,
float & out_value)
const;
14196 bool ShowElement(
size_t in_ordinal_zero_to_fifteen,
float & out_value)
const;
14201 bool ShowElements(FloatArray & out_matrix)
const;
14206 bool ShowDeterminant(
float & out_determinant)
const;
14211 bool ShowInverse(
MatrixKit & out_matrix)
const;
14217 bool ShowAdjoint(
MatrixKit & out_matrix)
const;
14335 bool ShowElement(
size_t in_row,
size_t in_column,
float & out_value)
const;
14341 bool ShowElement(
size_t in_ordinal_zero_to_fifteen,
float & out_value)
const;
14346 bool ShowElements(FloatArray & out_matrix)
const;
14351 bool ShowDeterminant(
float & out_determinant)
const;
14356 bool ShowInverse(
MatrixKit & out_matrix)
const;
14362 bool ShowAdjoint(
MatrixKit & out_matrix)
const;
14463 bool Empty()
const;
15067 bool ShowAmbientLightUpColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
15074 bool ShowAmbientLightDownColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
15293 bool ShowWindowContrastColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
15919 bool ShowAmbientLightUpColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
15927 bool ShowAmbientLightDownColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
16145 bool ShowWindowContrastColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
16182 size_t GetCount()
const;
16235 bool Show(PortfolioKeyArray & out_portfolios)
const;
16273 size_t GetCount()
const;
16277 StyleKey PushNamed(
char const * in_style_name);
16280 StyleKey PushNamed(
char const * in_style_name,
Condition const & in_condition);
16316 void Flush(
SegmentKey const & in_style_source);
16329 void Flush(
char const * in_style_name);
16337 void Flush(
char const * in_style_name,
Condition const & in_condition);
16342 StyleKey SetNamed(
char const * in_style_name);
16365 void Set(StyleTypeArray
const & in_types, SegmentKeyArray
const & in_segment_sources, UTF8Array
const & in_style_names, ConditionArray
const & in_conditions);
16371 void Set(StyleTypeArray
const & in_types, SegmentKeyArray
const & in_segment_sources, UTF8Array
const & in_style_names);
16387 void UnsetAllSegment();
16390 void UnsetAllNamed();
16393 void UnsetEverything();
16407 bool ShowTop(
StyleKey & out_style)
const;
16415 bool Show(StyleTypeArray & out_types, SegmentKeyArray & out_segment_sources, UTF8Array & out_style_names, ConditionArray & out_conditions)
const;
16420 bool Show(StyleKeyArray & out_styles)
const;
16426 bool ShowAllSegment(SegmentKeyArray & out_segments, ConditionArray & out_conditions)
const;
16431 bool ShowAllSegment(StyleKeyArray & out_styles)
const;
16437 bool ShowAllNamed(UTF8Array & out_names, ConditionArray & out_conditions)
const;
16442 bool ShowAllNamed(StyleKeyArray & out_styles)
const;
16481 size_t GetCount()
const;
16519 bool ShowCondition(
char const * in_condition)
const;
16524 bool ShowConditions(UTF8Array & out_conditions)
const;
16575 bool Empty()
const;
16585 bool operator==(
MaterialKit const & in_kit)
const;
16590 bool operator!=(
MaterialKit const & in_kit)
const;
16627 MaterialKit & SetDiffuseTexture(
char const * in_texture_name,
size_t in_layer=0);
16636 MaterialKit & SetDiffuseTexture(
char const * in_texture_name,
RGBAColor const & in_modulating_color,
size_t in_layer=0);
16642 MaterialKit & SetDiffuseTexture(UTF8Array
const & in_texture_names);
16649 MaterialKit & SetDiffuseTexture(
size_t in_count,
UTF8 const in_texture_names []);
16657 MaterialKit & SetDiffuseTexture(UTF8Array
const & in_texture_names, RGBAColorArray
const & in_modulating_colors);
16666 MaterialKit & SetDiffuseTexture(
size_t in_count,
UTF8 const in_texture_names [],
RGBAColor const in_modulating_colors []);
16672 MaterialKit & SetShader(
char const * in_shader_name);
16684 MaterialKit & SetSpecular(
char const * in_texture_name);
16690 MaterialKit & SetSpecular(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
16702 MaterialKit & SetMirror(
char const * in_texture_name);
16715 MaterialKit & SetTransmission(
char const * in_texture_name);
16721 MaterialKit & SetTransmission(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
16733 MaterialKit & SetEmission(
char const * in_texture_name);
16739 MaterialKit & SetEmission(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
16746 MaterialKit & SetEnvironmentTexture(
char const * in_texture_name);
16752 MaterialKit & SetEnvironmentTexture(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
16757 MaterialKit & SetEnvironmentCubeMap(
char const * in_cubemap_name);
16763 MaterialKit & SetEnvironmentCubeMap(
char const * in_cubemap_name,
RGBAColor const & in_modulating_color);
16773 MaterialKit & SetBump(
char const * in_texture_name);
16804 MaterialKit & UnsetDiffuseTexture(
size_t in_layer);
16845 bool ShowDiffuse()
const;
16850 bool ShowDiffuseColor(
RGBColor & out_rgb_color)
const;
16855 bool ShowDiffuseColor(
RGBAColor & out_rgba_color)
const;
16860 bool ShowDiffuseAlpha(
float & out_alpha)
const;
16885 bool ShowDiffuseTexture(MaterialTypeArray & out_types, RGBAColorArray & out_colors, UTF8Array & out_texture_names)
const;
16890 bool ShowShader(
UTF8 & out_shader_name)
const;
16950 bool ShowBump(
UTF8 & out_texture_name)
const;
16956 bool ShowGloss(
float & out_gloss)
const;
17007 bool Empty()
const;
17089 bool ShowBudget(
size_t & out_budget)
const;
17094 bool ShowMaximumDeviation(
float & out_deviation)
const;
17099 bool ShowMaximumAngle(
float & out_degrees)
const;
17104 bool ShowMaximumWidth(
float & out_width)
const;
17109 bool ShowTrimBudget(
size_t & out_budget)
const;
17114 bool ShowMaximumTrimDeviation(
float & out_deviation)
const;
17145 Type
ObjectType()
const {
return Type::NURBSSurfaceAttributeControl;};
17215 bool ShowBudget(
size_t & out_budget)
const;
17220 bool ShowMaximumDeviation(
float & out_deviation)
const;
17225 bool ShowMaximumAngle(
float & out_degrees)
const;
17230 bool ShowMaximumWidth(
float & out_width)
const;
17235 bool ShowTrimBudget(
size_t & out_budget)
const;
17240 bool ShowMaximumTrimDeviation(
float & out_deviation)
const;
17296 bool Empty()
const;
17473 bool Empty()
const;
17613 bool ShowColor(
RGBAColor & out_color)
const;
17618 bool ShowDimFactor(
float & out_zero_to_one)
const;
17623 bool ShowFaceDisplacement(
float & out_buckets)
const;
17628 bool ShowLinePattern(
UTF8 & out_pattern)
const;
17633 bool ShowRenderFaces(
bool & out_state)
const;
17638 bool ShowRenderText(
bool & out_state)
const;
17648 bool ShowSilhouetteCleanup(
bool & out_state)
const;
17653 bool ShowVisibility(
bool & out_state)
const;
17659 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
17664 bool ShowTransparencyCutoff(
float & out_zero_to_one)
const;
17823 bool ShowColor(
RGBAColor & out_color)
const;
17828 bool ShowDimFactor(
float & out_zero_to_one)
const;
17833 bool ShowFaceDisplacement(
float & out_buckets)
const;
17838 bool ShowLinePattern(
UTF8 & out_pattern)
const;
17843 bool ShowRenderFaces(
bool & out_state)
const;
17848 bool ShowRenderText(
bool & out_state)
const;
17858 bool ShowSilhouetteCleanup(
bool & out_state)
const;
17863 bool ShowVisibility(
bool & out_state)
const;
17869 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
17874 bool ShowTransparencyCutoff(
float & out_zero_to_one)
const;
17930 bool Empty()
const;
18114 bool ShowDepthRange(
float & out_near,
float & out_far)
const;
18120 bool ShowFaceDisplacement(
bool & out_state,
int & out_buckets)
const;
18126 bool ShowGeneralDisplacement(
bool & out_state,
int & out_buckets)
const;
18132 bool ShowVertexDisplacement(
bool & out_state,
int & out_buckets)
const;
18142 bool ShowDeferral(
int & out_defer_batch)
const;
18354 bool ShowDepthRange(
float & out_x,
float & out_y)
const;
18360 bool ShowFaceDisplacement(
bool & out_state,
int & out_buckets)
const;
18366 bool ShowGeneralDisplacement(
bool & out_state,
int & out_buckets)
const;
18372 bool ShowVertexDisplacement(
bool & out_state,
int & out_buckets)
const;
18382 bool ShowDeferral(
int & out_defer_batch)
const;
18444 bool Empty()
const;
18507 PostProcessEffectsKit & SetDepthOfField(
float in_strength,
float in_near_distance,
float in_far_distance);
18516 PostProcessEffectsKit & SetSilhouetteEdges(
bool in_state,
float in_tolerance = 1.0f,
bool in_heavy_exterior =
false);
18533 PostProcessEffectsKit & SetEyeDomeLighting(
bool in_state,
float in_exponent = 50.0f,
float in_tolerance = 1.0f,
float in_strength = 1.0f);
18541 PostProcessEffectsKit & SetEyeDomeLighting(
float in_exponent,
bool in_tolerance,
float in_strength);
18590 bool ShowDepthOfField(
bool & out_state,
float & out_strength,
float & out_near_distance,
float & out_far_distance)
const;
18599 bool ShowSilhouetteEdges(
bool & out_state,
float & out_tolerance,
bool & out_heavy_exterior)
const;
18608 bool ShowEyeDomeLighting(
bool & out_state,
float & out_exponent,
float & out_tolerance,
float & out_strength)
const;
18698 PostProcessEffectsControl & SetSilhouetteEdges(
bool in_state,
float in_tolerance = 1.0f,
bool in_heavy_exterior =
false);
18714 PostProcessEffectsControl & SetEyeDomeLighting(
bool in_state,
float in_exponent = 50.0f,
float in_tolerance = 1.0f,
float in_strength = 1.0f);
18772 bool ShowDepthOfField(
bool & out_state,
float & out_strength,
float & out_near_distance,
float & out_far_distance)
const;
18781 bool ShowSilhouetteEdges(
bool & out_state,
float & out_tolerance,
bool & out_heavy_exterior)
const;
18790 bool ShowEyeDomeLighting(
bool & out_state,
float & out_exponent,
float & out_tolerance,
float & out_strength)
const;
18835 bool Empty()
const;
18979 bool ShowCameraRotation(
bool & out_state)
const;
18984 bool ShowCameraScale(
bool & out_state)
const;
18989 bool ShowCameraTranslation(
bool & out_state)
const;
18994 bool ShowCameraPerspectiveScale(
bool & out_state)
const;
18999 bool ShowCameraProjection(
bool & out_state)
const;
19004 bool ShowCameraOffset(
bool & out_state)
const;
19009 bool ShowCameraNearLimit(
bool & out_state)
const;
19014 bool ShowModellingMatrixRotation(
bool & out_state)
const;
19019 bool ShowModellingMatrixScale(
bool & out_state)
const;
19024 bool ShowModellingMatrixTranslation(
bool & out_state)
const;
19029 bool ShowModellingMatrixOffset(
bool & out_state)
const;
19195 bool ShowCameraRotation(
bool & out_state)
const;
19200 bool ShowCameraScale(
bool & out_state)
const;
19205 bool ShowCameraTranslation(
bool & out_state)
const;
19210 bool ShowCameraPerspectiveScale(
bool & out_state)
const;
19215 bool ShowCameraProjection(
bool & out_state)
const;
19220 bool ShowCameraOffset(
bool & out_state)
const;
19225 bool ShowCameraNearLimit(
bool & out_state)
const;
19230 bool ShowModellingMatrixRotation(
bool & out_state)
const;
19235 bool ShowModellingMatrixScale(
bool & out_state)
const;
19240 bool ShowModellingMatrixTranslation(
bool & out_state)
const;
19245 bool ShowModellingMatrixOffset(
bool & out_state)
const;
19301 bool Empty()
const;
19337 VisualEffectsKit & SetShadowMaps(
bool in_state,
unsigned int in_samples = 4,
unsigned int in_resolution = 1024,
bool in_view_dependent =
true,
bool in_jitter =
true);
19347 VisualEffectsKit & SetShadowMaps(
unsigned int in_samples,
unsigned int in_resolution,
bool in_view_dependent,
bool in_jitter);
19355 VisualEffectsKit & SetSimpleShadow(
bool in_state,
unsigned int in_resolution = 256,
unsigned int in_blurring = 1,
bool in_ignore_transparency =
false);
19362 VisualEffectsKit & SetSimpleShadow(
unsigned int in_resolution,
unsigned int in_blurring,
bool in_ignore_transparency);
19389 VisualEffectsKit & SetSimpleReflection(
bool in_state,
float in_opacity = 0.5f,
unsigned int in_blurring = 1,
bool in_fading =
false,
float in_attenuation_near_distance = 0.0f,
float in_attenuation_far_distance =
Float::Infinity);
19400 VisualEffectsKit & SetSimpleReflection(
float in_opacity,
unsigned int in_blurring,
bool in_fading,
float in_attenuation_near_distance,
float in_attenuation_far_distance);
19460 bool ShowPostProcessEffectsEnabled(
bool & out_state)
const;
19465 bool ShowAntiAliasing(
bool & out_state)
const;
19474 bool ShowShadowMaps(
bool & out_state,
unsigned int & out_samples,
unsigned int & out_resolution,
bool & out_view_dependent,
bool & out_jitter)
const;
19482 bool ShowSimpleShadow(
bool & out_state,
unsigned int & out_resolution,
unsigned int & out_blurring,
bool & out_ignore_transparency)
const;
19487 bool ShowSimpleShadowPlane(
Plane & out_projected_onto)
const;
19492 bool ShowSimpleShadowLightDirection(
Vector & out_direction)
const;
19497 bool ShowSimpleShadowColor(
RGBAColor & out_color)
const;
19507 bool ShowSimpleReflection(
bool & out_state,
float & out_opacity,
unsigned int & out_blurring,
bool & out_fading,
float & out_attenuation_near_distance,
float & out_attenuation_far_distance)
const;
19513 bool ShowSimpleReflectionPlane(
Plane & out_projected_onto)
const;
19518 bool ShowSimpleReflectionVisibility(
VisibilityKit & out_reflected_types)
const;
19574 VisualEffectsControl & SetShadowMaps(
bool in_state,
unsigned int in_samples = 4,
unsigned int in_resolution = 1024,
bool in_view_dependent =
true,
bool in_jitter =
true);
19584 VisualEffectsControl & SetShadowMaps(
unsigned int in_samples,
unsigned int in_resolution,
bool in_view_dependent,
bool in_jitter);
19592 VisualEffectsControl & SetSimpleShadow(
bool in_state,
unsigned int in_resolution = 256,
unsigned int in_blurring = 1,
bool in_ignore_transparency =
false);
19599 VisualEffectsControl & SetSimpleShadow(
unsigned int in_resolution,
unsigned int in_blurring,
bool in_ignore_transparency);
19626 VisualEffectsControl & SetSimpleReflection(
bool in_state,
float in_opacity = 0.5f,
unsigned int in_blurring = 1,
bool in_fading =
false,
float in_attenuation_near_distance = 0.0f,
float in_attenuation_far_distance =
Float::Infinity);
19637 VisualEffectsControl & SetSimpleReflection(
float in_opacity,
unsigned int in_blurring,
bool in_fading,
float in_attenuation_near_distance,
float in_attenuation_far_distance);
19698 bool ShowPostProcessEffectsEnabled(
bool & out_state)
const;
19703 bool ShowAntiAliasing(
bool & out_state)
const;
19712 bool ShowShadowMaps(
bool & out_state,
unsigned int & out_samples,
unsigned int & out_resolution,
bool & out_view_dependent,
bool & out_jitter)
const;
19720 bool ShowSimpleShadow(
bool & out_state,
unsigned int & out_resolution,
unsigned int & out_blurring,
bool & out_ignore_transparency)
const;
19725 bool ShowSimpleShadowPlane(
Plane & out_projected_onto)
const;
19730 bool ShowSimpleShadowLightDirection(
Vector & out_direction)
const;
19735 bool ShowSimpleShadowColor(
RGBAColor & out_color)
const;
19745 bool ShowSimpleReflection(
bool & out_state,
float & out_opacity,
unsigned int & out_blurring,
bool & out_fading,
float & out_attenuation_near_distance,
float & out_attenuation_far_distance)
const;
19750 bool ShowSimpleReflectionPlane(
Plane & out_projected_onto)
const;
19755 bool ShowSimpleReflectionVisibility(
VisibilityKit & out_reflected_types)
const;
19811 bool Empty()
const;
19838 ContourLineKit & SetPositions(
float in_interval,
float in_offset);
19849 ContourLineKit & SetPositions(
size_t in_count,
float const in_positions[]);
19887 ContourLineKit & SetWeights(FloatArray
const & in_weights, LineSizeUnitsArray
const & in_units);
19940 bool ShowVisibility(
bool & out_state)
const;
19947 bool ShowPositions(
ContourLine::Mode & out_mode, FloatArray & out_positions)
const;
19952 bool ShowColors(RGBColorArray & out_colors)
const;
19957 bool ShowPatterns(UTF8Array & out_patterns)
const;
19963 bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units)
const;
19968 bool ShowLighting(
bool & out_state)
const;
20061 ContourLineControl & SetWeights(FloatArray
const & in_weights, LineSizeUnitsArray
const & in_units);
20114 bool ShowVisibility(
bool & out_state)
const;
20121 bool ShowPositions(
ContourLine::Mode & out_mode, FloatArray & out_positions)
const;
20126 bool ShowColors(RGBColorArray & out_colors)
const;
20131 bool ShowPatterns(UTF8Array & out_patterns)
const;
20137 bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units)
const;
20142 bool ShowLighting(
bool & out_state)
const;
20197 bool Empty()
const;
20456 bool Empty()
const;
20492 bool ShowResourceMonitor(
bool & out_display)
const;
20536 bool ShowResourceMonitor(
bool & out_display)
const;
20585 bool Empty()
const;
20607 WindowInfoKit & SetPhysicalPixels(
unsigned int in_width,
unsigned int in_height);
20613 WindowInfoKit & SetPhysicalSize(
float in_width,
float in_height);
20619 WindowInfoKit & SetWindowPixels(
unsigned int in_width,
unsigned int in_height);
20625 WindowInfoKit & SetWindowSize(
float in_width,
float in_height);
20653 bool ShowPhysicalPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
20659 bool ShowPhysicalSize(
float & out_width,
float & out_height)
const;
20665 bool ShowWindowPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
20671 bool ShowWindowSize(
float & out_width,
float & out_height)
const;
20678 bool ShowResolution(
float & out_horizontal,
float & out_vertical)
const;
20683 bool ShowWindowAspectRatio(
float & out_window_aspect)
const;
20688 bool ShowPixelAspectRatio(
float & out_pixel_aspect)
const;
20727 bool ShowPhysicalPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
20733 bool ShowPhysicalSize(
float & out_width,
float & out_height)
const;
20739 bool ShowWindowPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
20745 bool ShowWindowSize(
float & out_width,
float & out_height)
const;
20752 bool ShowResolution(
float & out_horizontal,
float & out_vertical)
const;
20757 bool ShowWindowAspectRatio(
float & out_window_aspect)
const;
20762 bool ShowPixelAspectRatio(
float & out_pixel_aspect)
const;
20814 bool Empty()
const;
20833 UTF8 GetName()
const;
20837 bool GetShellConvertibility()
const;
20890 bool Empty()
const;
20918 AttributeLockKit & SetLock(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
20932 AttributeLockKit & SetSubsegmentLockOverride(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
20949 AttributeLockKit & UnsetSubsegmentLockOverride(AttributeLockTypeArray
const & in_types);
20966 bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
20978 bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
21026 AttributeLockControl & SetLock(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
21040 AttributeLockControl & SetSubsegmentLockOverride(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
21074 bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
21086 bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
21135 size_t ShowReferrers(SegmentKeyArray & out_segments)
const;
21140 size_t ShowReferrers(ReferenceKeyArray & out_references)
const;
21159 bool ShowPriority(
int & out_priority)
const;
21167 GeometryKey & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
21173 GeometryKey & SetUserData(intptr_t in_index, ByteArray
const & in_data);
21179 GeometryKey & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
21190 GeometryKey & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
21195 GeometryKey & UnsetUserData(IntPtrTArray
const & in_indices);
21202 size_t ShowUserDataCount()
const;
21207 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
21213 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
21219 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
21255 void Consume(
LineKit & in_kit);
21259 void Set(
LineKit const & in_kit);
21263 void Show(
LineKit & out_kit)
const;
21272 bool Empty()
const;
21277 bool Equals(
LineKit const & in_kit)
const;
21282 bool operator==(
LineKit const & in_kit)
const;
21287 bool operator!=(
LineKit const & in_kit)
const;
21291 size_t GetPointCount()
const;
21299 LineKit & SetPriority(
int in_priority);
21308 bool ShowPriority(
int & out_priority)
const;
21314 LineKit & SetPoints(PointArray
const & in_points);
21320 LineKit & SetPoints(
size_t in_count,
Point const in_points []);
21335 bool ShowPoints(PointArray & out_points)
const;
21343 LineKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
21349 LineKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
21355 LineKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
21362 LineKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
21369 LineKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
21376 LineKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
21382 LineKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
21388 LineKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
21393 LineKit & UnsetUserData(intptr_t in_index);
21399 LineKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
21404 LineKit & UnsetUserData(IntPtrTArray
const & in_indices);
21408 LineKit & UnsetAllUserData();
21411 size_t ShowUserDataCount()
const;
21416 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
21422 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
21428 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
21469 void Consume(
LineKit & in_kit);
21473 void Set(
LineKit const & in_kit);
21477 void Show(
LineKit & out_kit)
const;
21481 size_t GetPointCount()
const;
21486 LineKey & SetPoints(PointArray
const & in_points);
21492 LineKey & SetPoints(
size_t in_count,
Point const in_points []);
21498 bool ShowPoints(PointArray & out_points)
const;
21506 LineKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
21512 LineKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
21518 LineKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
21525 LineKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
21532 LineKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
21581 bool Empty()
const;
21586 bool Equals(
MarkerKit const & in_kit)
const;
21591 bool operator==(
MarkerKit const & in_kit)
const;
21596 bool operator!=(
MarkerKit const & in_kit)
const;
21605 MarkerKit & SetPriority(
int in_priority);
21614 bool ShowPriority(
int & out_priority)
const;
21634 bool ShowPoint(
Point & out_point)
const;
21641 MarkerKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
21647 MarkerKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
21653 MarkerKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
21658 MarkerKit & UnsetUserData(intptr_t in_index);
21664 MarkerKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
21669 MarkerKit & UnsetUserData(IntPtrTArray
const & in_indices);
21676 size_t ShowUserDataCount()
const;
21681 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
21687 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
21693 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
21753 bool ShowPoint(
Point & out_point)
const;
21802 bool Empty()
const;
21877 bool ShowPriority(
int & out_priority)
const;
21882 bool ShowDirection(
Vector & out_vector)
const;
21894 bool ShowCameraRelative(
bool & out_state)
const;
21901 DistantLightKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
21907 DistantLightKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
21913 DistantLightKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
21924 DistantLightKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
21936 size_t ShowUserDataCount()
const;
21941 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
21947 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
21953 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
22037 bool ShowDirection(
Vector & out_vector)
const;
22049 bool ShowCameraRelative(
bool & out_state)
const;
22099 bool Empty()
const;
22109 bool operator==(
CylinderKit const & in_kit)
const;
22114 bool operator!=(
CylinderKit const & in_kit)
const;
22118 size_t GetPointCount()
const;
22135 bool ShowPriority(
int & out_priority)
const;
22141 CylinderKit & SetPoints(PointArray
const & in_points);
22152 CylinderKit & SetRadii(FloatArray
const & in_radii);
22158 CylinderKit & SetRadii(
size_t in_count,
float const in_radii []);
22186 bool ShowPoints(PointArray & out_points)
const;
22191 bool ShowRadii(FloatArray & out_radii)
const;
22317 CylinderKit & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
22322 CylinderKit & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
22355 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
22369 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
22376 CylinderKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
22382 CylinderKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
22388 CylinderKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
22399 CylinderKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
22404 CylinderKit & UnsetUserData(IntPtrTArray
const & in_indices);
22411 size_t ShowUserDataCount()
const;
22416 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
22422 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
22428 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
22482 CylinderKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
22488 CylinderKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
22494 CylinderKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
22501 CylinderKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
22508 CylinderKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
22516 CylinderKey & EditRadiiByInsertion(
size_t in_offset,
size_t in_count,
float const in_radii[]);
22522 CylinderKey & EditRadiiByInsertion(
size_t in_offset, FloatArray
const & in_radii);
22528 CylinderKey & EditRadiiByDeletion(
size_t in_offset,
size_t in_count);
22535 CylinderKey & EditRadiiByReplacement(
size_t in_offset,
size_t in_count,
float const in_radii[]);
22542 CylinderKey & EditRadiiByReplacement(
size_t in_offset, FloatArray
const & in_radii);
22551 size_t GetPointCount()
const;
22556 bool ShowPoints(PointArray & out_points)
const;
22561 bool ShowRadii(FloatArray & out_radii)
const;
22627 CylinderKey & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
22653 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
22667 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
22717 bool Empty()
const;
22722 bool Equals(
SphereKit const & in_kit)
const;
22727 bool operator==(
SphereKit const & in_kit)
const;
22732 bool operator!=(
SphereKit const & in_kit)
const;
22740 SphereKit & SetPriority(
int in_priority);
22749 bool ShowPriority(
int & out_priority)
const;
22759 SphereKit & SetRadius(
float in_radius);
22788 bool ShowCenter(
Point & out_center)
const;
22793 bool ShowRadius(
float & out_radius)
const;
22799 bool ShowBasis(
Vector & out_vertical,
Vector & out_horizontal)
const;
22806 SphereKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
22812 SphereKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
22818 SphereKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
22823 SphereKit & UnsetUserData(intptr_t in_index);
22829 SphereKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
22834 SphereKit & UnsetUserData(IntPtrTArray
const & in_indices);
22841 size_t ShowUserDataCount()
const;
22846 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
22852 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
22858 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
22917 SphereKey & SetRadius(
float in_radius);
22929 bool ShowCenter(
Point & out_center)
const;
22934 bool ShowRadius(
float & out_radius)
const;
22940 bool ShowBasis(
Vector & out_vertical,
Vector & out_horizontal)
const;
22990 bool Empty()
const;
22995 bool Equals(
CircleKit const & in_kit)
const;
23000 bool operator==(
CircleKit const & in_kit)
const;
23005 bool operator!=(
CircleKit const & in_kit)
const;
23013 CircleKit & SetPriority(
int const in_priority);
23022 bool ShowPriority(
int & out_priority)
const;
23034 CircleKit & SetRadius(
float in_radius);
23062 bool ShowCenter(
Point & out_center)
const;
23067 bool ShowRadius(
float & out_radius)
const;
23072 bool ShowNormal(
Vector & out_normal)
const;
23079 CircleKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
23085 CircleKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
23091 CircleKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
23096 CircleKit & UnsetUserData(intptr_t in_index);
23102 CircleKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
23107 CircleKit & UnsetUserData(IntPtrTArray
const & in_indices);
23114 size_t ShowUserDataCount()
const;
23119 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
23125 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
23131 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
23193 CircleKey & SetRadius(
float in_radius);
23204 bool ShowCenter(
Point & out_center)
const;
23209 bool ShowRadius(
float & out_radius)
const;
23214 bool ShowNormal(
Vector & out_normal)
const;
23264 bool Empty()
const;
23296 bool ShowPriority(
int & out_priority)
const;
23335 bool ShowStart(
Point & out_start)
const;
23340 bool ShowMiddle(
Point & out_middle)
const;
23345 bool ShowEnd(
Point & out_end)
const;
23352 CircularArcKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
23358 CircularArcKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
23364 CircularArcKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
23375 CircularArcKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
23380 CircularArcKit & UnsetUserData(IntPtrTArray
const & in_indices);
23387 size_t ShowUserDataCount()
const;
23392 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
23398 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
23404 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
23476 bool ShowStart(
Point & out_start)
const;
23481 bool ShowMiddle(
Point & out_middle)
const;
23486 bool ShowEnd(
Point & out_end)
const;
23535 bool Empty()
const;
23568 bool ShowPriority(
int & out_priority)
const;
23607 bool ShowStart(
Point & out_start)
const;
23612 bool ShowMiddle(
Point & out_middle)
const;
23617 bool ShowEnd(
Point & out_end)
const;
23624 CircularWedgeKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
23630 CircularWedgeKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
23636 CircularWedgeKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
23647 CircularWedgeKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
23659 size_t ShowUserDataCount()
const;
23664 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
23670 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
23676 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
23750 bool ShowStart(
Point & out_start)
const;
23755 bool ShowMiddle(
Point & out_middle)
const;
23760 bool ShowEnd(
Point & out_end)
const;
23809 bool Empty()
const;
23841 bool ShowPriority(
int & out_priority)
const;
23883 size_t GetPlaneCount()
const;
23888 bool ShowPlanes(PlaneArray & out_planes)
const;
23911 CuttingSectionKit & EditPlanesByInsertion(
size_t in_offset, PlaneArray
const & in_planes);
23927 CuttingSectionKit & EditPlanesByReplacement(
size_t in_offset,
size_t in_count,
Plane const in_planes[]);
23936 CuttingSectionKit & EditPlanesByReplacement(
size_t in_offset, PlaneArray
const & in_planes);
23943 CuttingSectionKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
23955 CuttingSectionKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
23966 CuttingSectionKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
23978 size_t ShowUserDataCount()
const;
23983 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
23989 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
23995 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
24074 size_t GetPlaneCount()
const;
24079 bool ShowPlanes(PlaneArray & out_planes)
const;
24102 CuttingSectionKey & EditPlanesByInsertion(
size_t in_offset, PlaneArray
const & in_planes);
24118 CuttingSectionKey & EditPlanesByReplacement(
size_t in_offset,
size_t in_count,
Plane const in_planes[]);
24127 CuttingSectionKey & EditPlanesByReplacement(
size_t in_offset, PlaneArray
const & in_planes);
24176 bool Empty()
const;
24208 bool ShowPriority(
int & out_priority)
const;
24247 bool ShowFirst(
Point & out_first)
const;
24252 bool ShowSecond(
Point & out_second)
const;
24264 InfiniteLineKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
24270 InfiniteLineKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
24276 InfiniteLineKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
24287 InfiniteLineKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
24299 size_t ShowUserDataCount()
const;
24304 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
24310 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
24316 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
24387 bool ShowFirst(
Point & out_first)
const;
24392 bool ShowSecond(
Point & out_second)
const;
24453 bool Empty()
const;
24522 SpotlightKit & SetConcentration(
float in_concentration);
24572 bool ShowPriority(
int & out_priority)
const;
24577 bool ShowPosition(
Point & out_position)
const;
24582 bool ShowTarget(
Point & out_target)
const;
24606 bool ShowConcentration(
float & out_concentration)
const;
24611 bool ShowCameraRelative(
bool & out_state)
const;
24618 SpotlightKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
24624 SpotlightKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
24630 SpotlightKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
24641 SpotlightKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
24646 SpotlightKit & UnsetUserData(IntPtrTArray
const & in_indices);
24653 size_t ShowUserDataCount()
const;
24658 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
24664 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
24670 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
24765 SpotlightKey & SetConcentration(
float in_concentration);
24783 bool ShowPosition(
Point & out_position)
const;
24788 bool ShowTarget(
Point & out_target)
const;
24812 bool ShowConcentration(
float & out_concentration)
const;
24817 bool ShowCameraRelative(
bool & out_state)
const;
24866 bool Empty()
const;
24885 size_t GetPointCount()
const;
24902 bool ShowPriority(
int & out_priority)
const;
24929 NURBSCurveKit & SetWeights(
size_t in_count,
float const in_weights []);
24940 NURBSCurveKit & SetKnots(
size_t in_count,
float const in_knots []);
24946 NURBSCurveKit & SetParameters(
float in_start,
float in_end);
24977 bool ShowDegree(
size_t & out_degree)
const;
24982 bool ShowPoints(PointArray & out_points)
const;
24987 bool ShowWeights(FloatArray & out_weights)
const;
24992 bool ShowKnots(FloatArray & out_knots)
const;
24998 bool ShowParameters(
float & out_start,
float & out_end)
const;
25007 NURBSCurveKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
25014 NURBSCurveKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
25022 NURBSCurveKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
25030 NURBSCurveKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
25038 NURBSCurveKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
25048 NURBSCurveKit & EditWeightsByInsertion(
size_t in_offset,
size_t in_count,
float const in_weights[]);
25056 NURBSCurveKit & EditWeightsByInsertion(
size_t in_offset, FloatArray
const & in_weights);
25065 NURBSCurveKit & EditWeightsByDeletion(
size_t in_offset,
size_t in_count);
25073 NURBSCurveKit & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
25081 NURBSCurveKit & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
25089 NURBSCurveKit & EditKnotsByInsertion(
size_t in_offset,
size_t in_count,
float const in_knots[]);
25095 NURBSCurveKit & EditKnotsByInsertion(
size_t in_offset, FloatArray
const & in_knots);
25102 NURBSCurveKit & EditKnotsByDeletion(
size_t in_offset,
size_t in_count);
25110 NURBSCurveKit & EditKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
25118 NURBSCurveKit & EditKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
25125 NURBSCurveKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
25131 NURBSCurveKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
25137 NURBSCurveKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
25148 NURBSCurveKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
25153 NURBSCurveKit & UnsetUserData(IntPtrTArray
const & in_indices);
25160 size_t ShowUserDataCount()
const;
25165 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
25171 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
25177 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
25230 size_t GetPointCount()
const;
25236 NURBSCurveKey & SetParameters(
float in_start,
float in_end);
25241 bool ShowDegree(
size_t & out_degree)
const;
25246 bool ShowPoints(PointArray & out_points)
const;
25251 bool ShowWeights(FloatArray & out_weights)
const;
25256 bool ShowKnots(FloatArray & out_knots)
const;
25262 bool ShowParameters(
float & out_start,
float & out_end)
const;
25272 NURBSCurveKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
25280 NURBSCurveKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
25291 NURBSCurveKey & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
25300 NURBSCurveKey & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
25310 NURBSCurveKey & EditKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
25318 NURBSCurveKey & EditKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
25367 bool Empty()
const;
25386 size_t GetPointCount()
const;
25403 bool ShowPriority(
int & out_priority)
const;
25447 NURBSSurfaceKit & SetWeights(
size_t in_count,
float const in_weights []);
25460 NURBSSurfaceKit & SetUKnots(
size_t in_count,
float const in_knots []);
25473 NURBSSurfaceKit & SetVKnots(
size_t in_count,
float const in_knots []);
25531 bool ShowUDegree(
size_t & out_degree)
const;
25536 bool ShowVDegree(
size_t & out_degree)
const;
25541 bool ShowUCount(
size_t & out_count)
const;
25546 bool ShowVCount(
size_t & out_count)
const;
25551 bool ShowPoints(PointArray & out_points)
const;
25556 bool ShowWeights(FloatArray & out_weights)
const;
25561 bool ShowUKnots(FloatArray & out_knots)
const;
25566 bool ShowVKnots(FloatArray & out_knots)
const;
25571 bool ShowTrims(TrimKitArray & out_trims)
const;
25580 NURBSSurfaceKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
25587 NURBSSurfaceKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
25595 NURBSSurfaceKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
25603 NURBSSurfaceKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
25611 NURBSSurfaceKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
25621 NURBSSurfaceKit & EditWeightsByInsertion(
size_t in_offset,
size_t in_count,
float const in_weights[]);
25629 NURBSSurfaceKit & EditWeightsByInsertion(
size_t in_offset, FloatArray
const & in_weights);
25638 NURBSSurfaceKit & EditWeightsByDeletion(
size_t in_offset,
size_t in_count);
25646 NURBSSurfaceKit & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
25654 NURBSSurfaceKit & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
25663 NURBSSurfaceKit & EditUKnotsByInsertion(
size_t in_offset,
size_t in_count,
float const in_knots[]);
25670 NURBSSurfaceKit & EditUKnotsByInsertion(
size_t in_offset, FloatArray
const & in_knots);
25678 NURBSSurfaceKit & EditUKnotsByDeletion(
size_t in_offset,
size_t in_count);
25686 NURBSSurfaceKit & EditUKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
25694 NURBSSurfaceKit & EditUKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
25703 NURBSSurfaceKit & EditVKnotsByInsertion(
size_t in_offset,
size_t in_count,
float const in_knots[]);
25710 NURBSSurfaceKit & EditVKnotsByInsertion(
size_t in_offset, FloatArray
const & in_knots);
25718 NURBSSurfaceKit & EditVKnotsByDeletion(
size_t in_offset,
size_t in_count);
25726 NURBSSurfaceKit & EditVKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
25734 NURBSSurfaceKit & EditVKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
25741 NURBSSurfaceKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
25747 NURBSSurfaceKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
25753 NURBSSurfaceKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
25764 NURBSSurfaceKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
25776 size_t ShowUserDataCount()
const;
25781 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
25787 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
25793 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
25846 size_t GetPointCount()
const;
25868 bool ShowUDegree(
size_t & out_degree)
const;
25873 bool ShowVDegree(
size_t & out_degree)
const;
25878 bool ShowUCount(
size_t & out_count)
const;
25883 bool ShowVCount(
size_t & out_count)
const;
25888 bool ShowPoints(PointArray & out_points)
const;
25893 bool ShowWeights(FloatArray & out_weights)
const;
25898 bool ShowUKnots(FloatArray & out_knots)
const;
25903 bool ShowVKnots(FloatArray & out_knots)
const;
25908 bool ShowTrims(TrimKitArray & out_trims)
const;
25918 NURBSSurfaceKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
25926 NURBSSurfaceKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
25937 NURBSSurfaceKey & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
25946 NURBSSurfaceKey & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
25956 NURBSSurfaceKey & EditUKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
25964 NURBSSurfaceKey & EditUKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
25974 NURBSSurfaceKey & EditVKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
25982 NURBSSurfaceKey & EditVKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
26039 bool operator==(
TrimElement const & in_that)
const;
26044 bool operator!=(
TrimElement const & in_that)
const;
26050 void SetCurve(
LineKit const & in_line);
26094 void Set(
TrimKit const & in_kit);
26098 void Show(
TrimKit & out_kit)
const;
26107 bool Empty()
const;
26112 bool Equals(
TrimKit const & in_kit)
const;
26117 bool operator==(
TrimKit const & in_kit)
const;
26122 bool operator!=(
TrimKit const & in_kit)
const;
26134 TrimKit & SetShape(TrimElementArray
const & in_shape);
26158 bool ShowShape(TrimElementArray & out_shape)
const;
26212 bool Empty()
const;
26217 bool Equals(
EllipseKit const & in_kit)
const;
26222 bool operator==(
EllipseKit const & in_kit)
const;
26227 bool operator!=(
EllipseKit const & in_kit)
const;
26244 bool ShowPriority(
int & out_priority)
const;
26283 bool ShowCenter(
Point & out_center)
const;
26288 bool ShowMajor(
Point & out_major)
const;
26293 bool ShowMinor(
Point & out_minor)
const;
26300 EllipseKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
26306 EllipseKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
26312 EllipseKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
26317 EllipseKit & UnsetUserData(intptr_t in_index);
26323 EllipseKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
26328 EllipseKit & UnsetUserData(IntPtrTArray
const & in_indices);
26335 size_t ShowUserDataCount()
const;
26340 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
26346 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
26352 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
26424 bool ShowCenter(
Point & out_center)
const;
26429 bool ShowMajor(
Point & out_major)
const;
26434 bool ShowMinor(
Point & out_minor)
const;
26483 bool Empty()
const;
26515 bool ShowPriority(
int & out_priority)
const;
26580 bool ShowCenter(
Point & out_center)
const;
26585 bool ShowMajor(
Point & out_major)
const;
26590 bool ShowMinor(
Point & out_minor)
const;
26595 bool ShowStart(
float & out_start)
const;
26600 bool ShowEnd(
float & out_end)
const;
26607 EllipticalArcKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
26613 EllipticalArcKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
26619 EllipticalArcKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
26630 EllipticalArcKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
26642 size_t ShowUserDataCount()
const;
26647 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
26653 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
26659 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
26749 bool ShowCenter(
Point & out_center)
const;
26754 bool ShowMajor(
Point & out_major)
const;
26759 bool ShowMinor(
Point & out_minor)
const;
26764 bool ShowStart(
float & out_start)
const;
26769 bool ShowEnd(
float & out_end)
const;
26801 void Consume(
TextKit & in_kit);
26805 void Set(
TextKit const & in_kit);
26809 void Show(
TextKit & out_kit)
const;
26818 bool Empty()
const;
26823 bool Equals(
TextKit const & in_kit)
const;
26828 bool operator==(
TextKit const & in_kit)
const;
26833 bool operator!=(
TextKit const & in_kit)
const;
26841 TextKit & SetPriority(
int in_priority);
26850 bool ShowPriority(
int & out_priority)
const;
26860 TextKit & SetText(
char const * in_string);
26870 TextKit & SetColorByIndex(
float in_index);
26887 TextKit & SetBold(
bool in_state);
26892 TextKit & SetItalic(
bool in_state);
26897 TextKit & SetOverline(
bool in_state);
26902 TextKit & SetStrikethrough(
bool in_state);
26907 TextKit & SetUnderline(
bool in_state);
26913 TextKit & SetSlant(
float in_angle);
26918 TextKit & SetLineSpacing(
float in_multiplier);
26930 TextKit & SetRotation(
float in_angle);
26990 TextKit & SetFont(
char const * in_name);
27025 TextKit & SetSpacing(
float in_multiplier);
27042 TextKit & UnsetModellingMatrix();
27062 TextKit & UnsetStrikethrough();
27074 TextKit & UnsetLineSpacing();
27090 TextKit & UnsetSizeTolerance();
27128 bool ShowPosition(
Point & out_position)
const;
27133 bool ShowText(
UTF8 & out_string)
const;
27145 bool ShowModellingMatrix(
MatrixKit & out_matrix)
const;
27157 bool ShowBold(
bool & out_state)
const;
27162 bool ShowItalic(
bool & out_state)
const;
27167 bool ShowOverline(
bool & out_state)
const;
27172 bool ShowStrikethrough(
bool & out_state)
const;
27177 bool ShowUnderline(
bool & out_state)
const;
27182 bool ShowSlant(
float & out_angle)
const;
27187 bool ShowLineSpacing(
float & out_multiplier)
const;
27193 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
27200 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
27226 bool ShowFont(
UTF8 & out_name)
const;
27249 bool ShowPath(
Vector & out_path)
const;
27254 bool ShowSpacing(
float & out_multiplier)
const;
27264 TextKit & EditTextByInsertion(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
27272 TextKit & EditTextByDeletion(
size_t in_row,
size_t in_column,
size_t in_count);
27280 TextKit & EditTextByReplacement(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
27290 bool ShowRegion(PointArray & out_region,
Text::RegionAlignment & out_region_alignment,
bool & out_region_fitting,
bool & out_region_adjust_direction,
bool & out_region_relative_coordinates,
bool & out_region_window_space)
const;
27304 TextKit & SetRegion(PointArray & in_region,
Text::RegionAlignment in_region_alignment,
bool in_region_fitting,
bool in_region_adjust_direction,
bool in_region_relative_coordinates,
bool in_region_window_space);
27319 TextKit & SetRegion(
size_t in_region_count,
Point const in_region [],
Text::RegionAlignment in_region_alignment,
bool in_region_fitting,
bool in_region_adjust_direction,
bool in_region_relative_coordinates,
bool in_region_window_space);
27326 TextKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
27336 TextKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
27342 TextKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
27347 TextKit & UnsetUserData(intptr_t in_index);
27353 TextKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
27358 TextKit & UnsetUserData(IntPtrTArray
const & in_indices);
27362 TextKit & UnsetAllUserData();
27365 size_t ShowUserDataCount()
const;
27370 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
27376 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
27382 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
27423 void Consume(
TextKit & in_kit);
27427 void Set(
TextKit const & in_kit);
27431 void Show(
TextKit & out_kit)
const;
27450 TextKey & SetText(
char const * in_string);
27460 TextKey & SetColorByIndex(
float in_index);
27477 TextKey & SetBold(
bool in_state);
27482 TextKey & SetItalic(
bool in_state);
27487 TextKey & SetOverline(
bool in_state);
27492 TextKey & SetStrikethrough(
bool in_state);
27497 TextKey & SetUnderline(
bool in_state);
27503 TextKey & SetSlant(
float in_angle);
27509 TextKey & SetLineSpacing(
float in_multiplier);
27521 TextKey & SetRotation(
float in_angle);
27581 TextKey & SetFont(
char const * in_name);
27618 TextKey & SetSpacing(
float in_multiplier);
27632 TextKey & SetRegion(PointArray & in_region,
Text::RegionAlignment in_region_alignment,
bool in_region_fitting,
bool in_region_adjust_direction,
bool in_region_relative_coordinates,
bool in_region_window_space);
27647 TextKey & SetRegion(
size_t in_region_count,
Point const in_region [],
Text::RegionAlignment in_region_alignment,
bool in_region_fitting,
bool in_region_adjust_direction,
bool in_region_relative_coordinates,
bool in_region_window_space);
27656 TextKey & UnsetModellingMatrix();
27676 TextKey & UnsetStrikethrough();
27688 TextKey & UnsetLineSpacing();
27704 TextKey & UnsetSizeTolerance();
27746 bool ShowPosition(
Point & out_position)
const;
27751 bool ShowText(
UTF8 & out_string)
const;
27763 bool ShowModellingMatrix(
MatrixKit & out_matrix)
const;
27775 bool ShowBold(
bool & out_state)
const;
27780 bool ShowItalic(
bool & out_state)
const;
27785 bool ShowOverline(
bool & out_state)
const;
27790 bool ShowStrikethrough(
bool & out_state)
const;
27795 bool ShowUnderline(
bool & out_state)
const;
27800 bool ShowSlant(
float & out_angle)
const;
27805 bool ShowLineSpacing(
float & out_multiplier)
const;
27811 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
27818 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
27844 bool ShowFont(
UTF8 & out_name)
const;
27867 bool ShowPath(
Vector & out_path)
const;
27872 bool ShowSpacing(
float & out_multiplier)
const;
27882 bool ShowRegion(PointArray & out_region,
Text::RegionAlignment & out_region_alignment,
bool & out_region_fitting,
bool & out_region_adjust_direction,
bool & out_region_relative_coordinates,
bool & out_region_window_space)
const;
27892 TextKey & EditTextByInsertion(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
27900 TextKey & EditTextByDeletion(
size_t in_row,
size_t in_column,
size_t in_count);
27908 TextKey & EditTextByReplacement(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
27930 Type
ObjectType()
const {
return Type::ShellOptimizationOptionsKit; };
27956 bool Empty()
const;
28027 bool ShowNormalTolerance(
float & out_normal_tolerance)
const;
28038 bool ShowOrphanElimination(
bool & out_orphan_elimination)
const;
28099 bool Empty()
const;
28163 bool ShowTolerance(
float & out_tolerance)
const;
28173 bool ShowTreeContext(
TreeContext & out_tree_context)
const;
28178 bool ShowNearestFaceCalculation(
bool & out_state)
const;
28225 bool Empty()
const;
28246 bool ShowRelations(ShellRelationArray & out_results)
const;
28251 bool ShowNearestFaces(SizeTArray & out_faces)
const;
28256 bool ShowDistances(FloatArray & out_distances)
const;
28291 void Set(
ShellKit const & in_kit);
28295 void Show(
ShellKit & out_kit)
const;
28299 size_t GetPointCount()
const;
28303 size_t GetFaceCount()
const;
28312 bool Empty()
const;
28317 bool Equals(
ShellKit const & in_kit)
const;
28322 bool operator==(
ShellKit const & in_kit)
const;
28327 bool operator!=(
ShellKit const & in_kit)
const;
28335 ShellKit & SetPriority(
int in_priority);
28344 bool ShowPriority(
int & out_priority)
const;
28351 ShellKit & SetPoints(PointArray
const & in_points);
28357 ShellKit & SetPoints(
size_t in_count,
Point const in_points []);
28362 ShellKit & SetFacelist(IntArray
const & in_facelist);
28368 ShellKit & SetFacelist(
size_t in_count,
int const in_facelist []);
28385 bool ShowPoints(PointArray & out_points)
const;
28390 bool ShowFacelist(IntArray & out_facelist)
const;
28571 ShellKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
28577 ShellKit & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
28584 ShellKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
28591 ShellKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
28597 ShellKit & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
28604 ShellKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
28610 ShellKit & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
28619 ShellKit & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
28627 ShellKit & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
28637 ShellKit & SetVertexParametersByList(
size_t in_vertex_count,
size_t const in_vertices[],
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
28646 ShellKit & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
28654 ShellKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
28660 ShellKit & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
28667 ShellKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
28674 ShellKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
28680 ShellKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
28687 ShellKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
28693 ShellKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
28698 ShellKit & UnsetMaterialMapping();
28709 ShellKit & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
28714 ShellKit & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
28744 ShellKit & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
28749 ShellKit & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
28754 ShellKit & UnsetVertexParameters();
28760 ShellKit & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
28765 ShellKit & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
28770 ShellKit & UnsetVertexVisibilities();
28776 ShellKit & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
28781 ShellKit & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
28786 ShellKit & UnsetVertexEverything();
28808 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Shell::Component in_applied_to, MaterialTypeArray & out_types,
28809 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
28825 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Shell::Component in_applied_to, MaterialTypeArray & out_types,
28826 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
28837 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
28847 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
28859 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
28870 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
28881 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
28892 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
28903 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
28913 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
28922 ShellKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
28928 ShellKit & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
28935 ShellKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
28942 ShellKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
28948 ShellKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
28955 ShellKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
28961 ShellKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
28969 ShellKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
28975 ShellKit & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
28982 ShellKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
28989 ShellKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
28995 ShellKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
29002 ShellKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
29008 ShellKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
29016 ShellKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
29022 ShellKit & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
29029 ShellKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
29036 ShellKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
29042 ShellKit & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
29049 ShellKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
29055 ShellKit & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
29063 ShellKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
29069 ShellKit & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
29076 ShellKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
29083 ShellKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
29089 ShellKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
29096 ShellKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
29102 ShellKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
29113 ShellKit & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
29118 ShellKit & UnsetFaceColorsByList(SizeTArray
const & in_faces);
29129 ShellKit & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
29134 ShellKit & UnsetFaceNormalsByList(SizeTArray
const & in_vertices);
29139 ShellKit & UnsetFaceVisibilities();
29145 ShellKit & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
29150 ShellKit & UnsetFaceVisibilitiesByList(SizeTArray
const & in_vertices);
29167 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
29179 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
29190 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
29200 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
29211 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
29221 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
29230 ShellKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
29237 ShellKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
29244 ShellKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
29251 ShellKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
29258 ShellKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
29267 ShellKit & EditFacelistByInsertion(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
29274 ShellKit & EditFacelistByInsertion(
size_t in_offset, IntArray
const & in_facelist);
29281 ShellKit & EditFacelistByDeletion(
size_t in_offset,
size_t in_count);
29291 ShellKit & EditFacelistByReplacement(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
29300 ShellKit & EditFacelistByReplacement(
size_t in_offset, IntArray
const & in_facelist);
29329 ShellKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
29335 ShellKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
29341 ShellKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
29346 ShellKit & UnsetUserData(intptr_t in_index);
29352 ShellKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
29357 ShellKit & UnsetUserData(IntPtrTArray
const & in_indices);
29364 size_t ShowUserDataCount()
const;
29369 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
29375 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
29381 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
29428 void Set(
ShellKit const & in_kit);
29432 void Show(
ShellKit & out_kit)
const;
29436 size_t GetPointCount()
const;
29440 size_t GetFaceCount()
const;
29446 ShellKey & SetPoints(PointArray
const & in_points);
29452 ShellKey & SetPoints(
size_t in_count,
Point const in_points []);
29457 ShellKey & SetFacelist(IntArray
const & in_facelist);
29463 ShellKey & SetFacelist(
size_t in_count,
int const in_facelist []);
29481 ShellKey & UnsetMaterialMapping();
29490 bool ShowPoints(PointArray & out_points)
const;
29495 bool ShowFacelist(IntArray & out_facelist)
const;
29676 ShellKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
29683 ShellKey & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
29690 ShellKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
29697 ShellKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
29703 ShellKey & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
29710 ShellKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
29716 ShellKey & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
29726 ShellKey & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
29734 ShellKey & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
29744 ShellKey & SetVertexParametersByList(
size_t in_vertex_count,
size_t const in_vertices[],
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
29753 ShellKey & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
29761 ShellKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
29768 ShellKey & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
29775 ShellKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
29782 ShellKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
29788 ShellKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
29795 ShellKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
29801 ShellKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
29812 ShellKey & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
29817 ShellKey & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
29847 ShellKey & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
29852 ShellKey & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
29857 ShellKey & UnsetVertexParameters();
29863 ShellKey & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
29868 ShellKey & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
29873 ShellKey & UnsetVertexVisibilities();
29879 ShellKey & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
29884 ShellKey & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
29889 ShellKey & UnsetVertexEverything();
29905 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Shell::Component in_applied_to, MaterialTypeArray & out_types,
29906 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
29922 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Shell::Component in_applied_to, MaterialTypeArray & out_types,
29923 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
29934 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
29944 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
29956 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
29967 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
29978 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
29989 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
30000 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
30010 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
30018 ShellKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
30025 ShellKey & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
30032 ShellKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
30039 ShellKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
30045 ShellKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
30052 ShellKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
30058 ShellKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
30066 ShellKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
30073 ShellKey & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
30080 ShellKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
30087 ShellKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
30093 ShellKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
30100 ShellKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
30106 ShellKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
30114 ShellKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
30121 ShellKey & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
30128 ShellKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
30135 ShellKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
30141 ShellKey & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
30148 ShellKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
30154 ShellKey & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
30162 ShellKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
30169 ShellKey & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
30176 ShellKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
30183 ShellKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
30189 ShellKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
30196 ShellKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
30202 ShellKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
30213 ShellKey & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
30218 ShellKey & UnsetFaceColorsByList(SizeTArray
const & in_vertices);
30229 ShellKey & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
30234 ShellKey & UnsetFaceNormalsByList(SizeTArray
const & in_vertices);
30239 ShellKey & UnsetFaceVisibilities();
30245 ShellKey & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
30250 ShellKey & UnsetFaceVisibilitiesByList(SizeTArray
const & in_vertices);
30267 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
30279 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
30290 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
30300 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
30308 bool ShowNetFaceNormalsByRange(
size_t in_start,
size_t in_count, VectorArray & out_normals)
const;
30316 bool ShowNetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray & out_normals)
const;
30327 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
30337 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
30346 ShellKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
30353 ShellKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
30360 ShellKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
30367 ShellKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
30374 ShellKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
30383 ShellKey & EditFacelistByInsertion(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
30390 ShellKey & EditFacelistByInsertion(
size_t in_offset, IntArray
const & in_facelist);
30397 ShellKey & EditFacelistByDeletion(
size_t in_offset,
size_t in_count);
30407 ShellKey & EditFacelistByReplacement(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
30416 ShellKey & EditFacelistByReplacement(
size_t in_offset, IntArray
const & in_facelist);
30470 void Consume(
MeshKit & in_kit);
30474 void Set(
MeshKit const & in_kit);
30478 void Show(
MeshKit & out_kit)
const;
30487 bool Empty()
const;
30492 bool Equals(
MeshKit const & in_kit)
const;
30497 bool operator==(
MeshKit const & in_kit)
const;
30502 bool operator!=(
MeshKit const & in_kit)
const;
30506 size_t GetPointCount()
const;
30514 MeshKit & SetPriority(
int in_priority);
30523 bool ShowPriority(
int & out_priority)
const;
30528 MeshKit & SetPoints(PointArray
const & in_points);
30534 MeshKit & SetPoints(
size_t in_count,
Point const in_points []);
30541 MeshKit & SetPoints(
size_t in_rows,
size_t in_columns, PointArray
const & in_points);
30549 MeshKit & SetPoints(
size_t in_rows,
size_t in_columns,
size_t in_count,
Point const in_points []);
30554 MeshKit & SetRows(
size_t in_rows);
30559 MeshKit & SetColumns(
size_t in_columns);
30580 bool ShowPoints(PointArray & out_points)
const;
30587 bool ShowPoints(
size_t & out_rows,
size_t & out_columns, PointArray & out_points)
const;
30592 bool ShowRows(
size_t & out_rows)
const;
30597 bool ShowColumns(
size_t & out_columns)
const;
30777 MeshKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
30783 MeshKit & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
30790 MeshKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
30797 MeshKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
30803 MeshKit & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
30810 MeshKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
30816 MeshKit & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
30825 MeshKit & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
30833 MeshKit & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
30843 MeshKit & SetVertexParametersByList(
size_t in_vertex_count,
size_t const in_vertices[],
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
30852 MeshKit & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
30860 MeshKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
30866 MeshKit & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
30873 MeshKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
30880 MeshKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
30886 MeshKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
30893 MeshKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
30899 MeshKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
30904 MeshKit & UnsetMaterialMapping();
30908 MeshKit & UnsetVertexColors();
30914 MeshKit & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
30919 MeshKit & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
30943 MeshKit & UnsetVertexNormals();
30949 MeshKit & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
30954 MeshKit & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
30959 MeshKit & UnsetVertexParameters();
30965 MeshKit & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
30970 MeshKit & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
30975 MeshKit & UnsetVertexVisibilities();
30981 MeshKit & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
30986 MeshKit & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
30991 MeshKit & UnsetVertexEverything();
31012 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Mesh::Component in_applied_to, MaterialTypeArray & out_types,
31013 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
31029 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Mesh::Component in_applied_to, MaterialTypeArray & out_types,
31030 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
31041 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
31051 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
31063 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
31074 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
31085 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
31096 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
31107 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
31117 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
31125 MeshKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
31131 MeshKit & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
31138 MeshKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
31145 MeshKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
31151 MeshKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
31158 MeshKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
31164 MeshKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
31172 MeshKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
31178 MeshKit & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
31185 MeshKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
31192 MeshKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
31198 MeshKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
31205 MeshKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
31211 MeshKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
31219 MeshKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
31225 MeshKit & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
31232 MeshKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
31239 MeshKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
31245 MeshKit & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
31252 MeshKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
31258 MeshKit & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
31266 MeshKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
31272 MeshKit & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
31279 MeshKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
31286 MeshKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
31292 MeshKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
31299 MeshKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
31305 MeshKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
31316 MeshKit & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
31321 MeshKit & UnsetFaceColorsByList(SizeTArray
const & in_vertices);
31326 MeshKit & UnsetFaceNormals();
31332 MeshKit & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
31337 MeshKit & UnsetFaceNormalsByList(SizeTArray
const & in_vertices);
31342 MeshKit & UnsetFaceVisibilities();
31348 MeshKit & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
31353 MeshKit & UnsetFaceVisibilitiesByList(SizeTArray
const & in_vertices);
31358 MeshKit & UnsetFaceEverything();
31370 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
31382 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
31393 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
31403 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
31414 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
31424 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
31431 MeshKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
31437 MeshKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
31443 MeshKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
31448 MeshKit & UnsetUserData(intptr_t in_index);
31454 MeshKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
31459 MeshKit & UnsetUserData(IntPtrTArray
const & in_indices);
31463 MeshKit & UnsetAllUserData();
31466 size_t ShowUserDataCount()
const;
31471 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
31477 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
31483 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
31527 void Consume(
MeshKit & in_kit);
31531 void Set(
MeshKit const & in_kit);
31535 void Show(
MeshKit & out_kit)
const;
31539 size_t GetPointCount()
const;
31546 MeshKey & SetPoints(
size_t in_rows,
size_t in_columns, PointArray
const & in_points);
31554 MeshKey & SetPoints(
size_t in_rows,
size_t in_columns,
size_t in_count,
Point const in_points []);
31559 bool ShowPoints(PointArray & out_points)
const;
31566 bool ShowPoints(
size_t & out_rows,
size_t & out_columns, PointArray & out_points)
const;
31571 bool ShowRows(
size_t & out_rows)
const;
31576 bool ShowColumns(
size_t & out_columns)
const;
31587 MeshKey & UnsetMaterialMapping();
31768 MeshKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
31775 MeshKey & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
31782 MeshKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
31789 MeshKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
31795 MeshKey & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
31802 MeshKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
31808 MeshKey & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
31818 MeshKey & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
31826 MeshKey & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
31836 MeshKey & SetVertexParametersByList(
size_t in_vertex_count,
size_t const in_vertices[],
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
31845 MeshKey & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
31853 MeshKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
31860 MeshKey & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
31867 MeshKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
31874 MeshKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
31880 MeshKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
31887 MeshKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
31893 MeshKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
31898 MeshKey & UnsetVertexColors();
31904 MeshKey & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
31909 MeshKey & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
31933 MeshKey & UnsetVertexNormals();
31939 MeshKey & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
31944 MeshKey & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
31949 MeshKey & UnsetVertexParameters();
31955 MeshKey & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
31960 MeshKey & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
31965 MeshKey & UnsetVertexVisibilities();
31971 MeshKey & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
31976 MeshKey & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
31981 MeshKey & UnsetVertexEverything();
32001 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Mesh::Component in_applied_to, MaterialTypeArray & out_types,
32002 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
32018 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Mesh::Component in_applied_to, MaterialTypeArray & out_types,
32019 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
32030 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
32040 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
32052 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
32063 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
32074 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
32085 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
32096 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32106 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32114 MeshKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
32121 MeshKey & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
32128 MeshKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
32135 MeshKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
32141 MeshKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
32148 MeshKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
32154 MeshKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
32162 MeshKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
32169 MeshKey & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
32176 MeshKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
32183 MeshKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
32189 MeshKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
32196 MeshKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
32202 MeshKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
32210 MeshKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
32217 MeshKey & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
32224 MeshKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
32231 MeshKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
32237 MeshKey & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
32244 MeshKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
32250 MeshKey & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
32258 MeshKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
32265 MeshKey & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
32272 MeshKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
32279 MeshKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
32285 MeshKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
32292 MeshKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
32298 MeshKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
32309 MeshKey & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
32314 MeshKey & UnsetFaceColorsByList(SizeTArray
const & in_faces);
32319 MeshKey & UnsetFaceNormals();
32325 MeshKey & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
32330 MeshKey & UnsetFaceNormalsByList(SizeTArray
const & in_faces);
32335 MeshKey & UnsetFaceVisibilities();
32341 MeshKey & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
32346 MeshKey & UnsetFaceVisibilitiesByList(SizeTArray
const & in_faces);
32351 MeshKey & UnsetFaceEverything();
32363 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
32375 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
32386 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
32396 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
32407 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32417 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32427 MeshKey & EditMeshByReplacement(
size_t in_row_offset,
size_t in_column_offset,
size_t in_row_count,
size_t in_column_count,
size_t in_point_count,
Point const in_points[]);
32436 MeshKey & EditMeshByReplacement(
size_t in_row_offset,
size_t in_column_offset,
size_t in_row_count,
size_t in_column_count, PointArray
const & in_points);
32486 bool Empty()
const;
32491 bool Equals(
PolygonKit const & in_kit)
const;
32496 bool operator==(
PolygonKit const & in_kit)
const;
32501 bool operator!=(
PolygonKit const & in_kit)
const;
32505 size_t GetPointCount()
const;
32522 bool ShowPriority(
int & out_priority)
const;
32528 PolygonKit & SetPoints(PointArray
const & in_points);
32547 bool ShowPoints(PointArray & out_points)
const;
32554 PolygonKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
32560 PolygonKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
32566 PolygonKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
32573 PolygonKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
32579 PolygonKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
32586 PolygonKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
32592 PolygonKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
32598 PolygonKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
32603 PolygonKit & UnsetUserData(intptr_t in_index);
32609 PolygonKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
32614 PolygonKit & UnsetUserData(IntPtrTArray
const & in_indices);
32621 size_t ShowUserDataCount()
const;
32626 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
32632 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
32638 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
32693 size_t GetPointCount()
const;
32698 PolygonKey & SetPoints(PointArray
const & in_points);
32709 bool ShowPoints(PointArray & out_points)
const;
32716 PolygonKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
32722 PolygonKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
32728 PolygonKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
32735 PolygonKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
32741 PolygonKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
32768 void Consume(
GridKit & in_kit);
32772 void Set(
GridKit const & in_kit);
32776 void Show(
GridKit & out_kit)
const;
32790 bool Empty()
const;
32795 bool Equals(
GridKit const & in_kit)
const;
32800 bool operator==(
GridKit const & in_kit)
const;
32805 bool operator!=(
GridKit const & in_kit)
const;
32814 GridKit & SetPriority(
int in_priority);
32832 GridKit & SetFirstPoint(
Point const & in_first_point);
32841 GridKit & SetSecondPoint(
Point const & in_second_point);
32856 GridKit & SetFirstCount(
int in_first_count);
32868 GridKit & SetSecondCount(
int in_second_count);
32889 GridKit & UnsetSecondPoint();
32897 GridKit & UnsetSecondCount();
32907 bool ShowPriority(
int & out_priority)
const;
32917 bool ShowOrigin(
Point & out_origin)
const;
32922 bool ShowFirstPoint(
Point & out_first_point)
const;
32927 bool ShowSecondPoint(
Point & out_second_point)
const;
32932 bool ShowFirstCount(
int & out_first_count)
const;
32937 bool ShowSecondCount(
int & out_second_count)
const;
32944 GridKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
32950 GridKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
32956 GridKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
32961 GridKit & UnsetUserData(intptr_t in_index);
32967 GridKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
32972 GridKit & UnsetUserData(IntPtrTArray
const & in_indices);
32976 GridKit & UnsetAllUserData();
32979 size_t ShowUserDataCount()
const;
32984 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
32990 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
32996 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
33037 void Consume(
GridKit & in_kit);
33041 void Set(
GridKit const & in_kit);
33045 void Show(
GridKit & out_kit)
const;
33064 GridKey & SetFirstPoint(
Point const & in_first_point);
33073 GridKey & SetSecondPoint(
Point const & in_second_point);
33088 GridKey & SetFirstCount(
int in_first_count);
33100 GridKey & SetSecondCount(
int in_second_count);
33112 bool ShowOrigin(
Point & out_origin)
const;
33117 bool ShowFirstPoint(
Point & out_first_point)
const;
33122 bool ShowSecondPoint(
Point & out_second_point)
const;
33127 bool ShowFirstCount(
int & out_first_count)
const;
33132 bool ShowSecondCount(
int & out_second_count)
const;
33208 bool ShowPriority(
int & out_priority)
const;
33213 bool ShowCondition(
Condition & out_condition)
const;
33235 IncludeKey & SetFilter(AttributeLockTypeArray
const & in_types);
33257 IncludeKey & UnsetFilter(AttributeLockTypeArray
const & in_types);
33264 bool ShowFilter(AttributeLockTypeArray & out_types)
const;
33339 bool ShowCondition(
Condition & out_condition)
const;
33362 StyleKey & SetFilter(AttributeLockTypeArray
const & in_types);
33384 StyleKey & UnsetFilter(AttributeLockTypeArray
const & in_types);
33391 bool ShowFilter(AttributeLockTypeArray & out_types)
const;
33442 Key GetTarget()
const;
33447 size_t ShowTargets(
bool masked=
true)
const;
33453 size_t ShowTargets(KeyArray & out_keys,
bool masked=
true)
const;
33458 size_t ShowGeometryMask()
const;
33464 size_t ShowGeometryMask(SearchTypeArray & out_geometry_types)
const;
33469 ReferenceKey & SetGeometryMask(SearchTypeArray
const & in_geometry_types);
33477 void SetModellingMatrix(
MatrixKit const & in_kit);
33491 void UnsetModellingMatrix();
33501 bool ShowModellingMatrix(
MatrixKit & out_kit)
const;
33506 bool ShowCondition(
Condition & out_condition)
const;
33545 Type
ObjectType()
const {
return Type::StandAloneWindowOptionsKit; };
33567 bool Empty()
const;
33653 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
33658 bool ShowTitle(
UTF8 & out_window_name)
const;
33663 bool ShowSubscreen(
Rectangle & out_subscreen)
const;
33673 bool ShowFullScreen(
bool & out_state)
const;
33707 Type
ObjectType()
const {
return Type::StandAloneWindowOptionsControl; };
33739 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
33744 bool ShowTitle(
UTF8 & out_window_name)
const;
33749 bool ShowSubscreen(
Rectangle & out_subscreen)
const;
33759 bool ShowFullScreen(
bool & out_state)
const;
33815 bool Empty()
const;
33889 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
33894 bool ShowHardwareResident(
bool & out_state)
const;
33900 bool ShowOpacity(
bool & out_state,
float & out_opacity)
const;
33928 Type
ObjectType()
const {
return Type::ApplicationWindowOptionsKit; };
33950 bool Empty()
const;
34017 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
34022 bool ShowPlatformData(PlatformData & out_platform_data)
const;
34027 bool ShowFramebufferRetention(
bool & out_retain)
const;
34058 Type
ObjectType()
const {
return Type::ApplicationWindowOptionsControl; };
34069 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
34079 bool ShowWindowHandle(WindowHandle & out_window_handle)
const;
34084 bool ShowPlatformData(PlatformData & out_platform_data)
const;
34089 bool ShowFramebufferRetention(
bool & out_retain)
const;
34268 void SetIndexedColor(byte in_index);
34271 void SetNormalColor();
34275 void SetExplicitColor(
RGBAColor const & in_color);
34333 void SetPoints(GlyphPointArray
const & in_points);
34338 void SetPoints(
size_t in_count,
GlyphPoint const in_points[]);
34343 bool ShowPoints(GlyphPointArray & out_points)
const;
34388 bool ShowPoint(
GlyphPoint & out_point)
const;
34430 void SetLowerLeft(
GlyphPoint const & in_point);
34434 void SetUpperRight(
GlyphPoint const & in_point);
34444 bool ShowLowerLeft(
GlyphPoint & out_point)
const;
34449 bool ShowUpperRight(
GlyphPoint & out_point)
const;
34492 void SetStartPoint(
GlyphPoint const & in_point);
34496 void SetIntermediatePoint(
GlyphPoint const & in_point);
34500 void SetEndPoint(
GlyphPoint const & in_point);
34511 bool ShowStartPoint(
GlyphPoint & out_point)
const;
34516 bool ShowIntermediatePoint(
GlyphPoint & out_point)
const;
34521 bool ShowEndPoint(
GlyphPoint & out_point)
const;
34564 void SetFirstPoint(
GlyphPoint const & in_point);
34568 void SetSecondPoint(
GlyphPoint const & in_point);
34582 bool ShowFirstPoint(
GlyphPoint & out_point)
const;
34587 bool ShowSecondPoint(
GlyphPoint & out_point)
const;
34629 void Set(
GlyphKit const & in_kit);
34633 void Show(
GlyphKit & out_kit)
const;
34642 bool Empty()
const;
34647 bool Equals(
GlyphKit const & in_kit)
const;
34652 bool operator==(
GlyphKit const & in_kit)
const;
34657 bool operator!=(
GlyphKit const & in_kit)
const;
34662 GlyphKit & SetRadius(sbyte in_radius);
34673 GlyphKit & SetElements(GlyphElementArray
const & in_def);
34700 bool ShowRadius(sbyte & out_radius)
const;
34705 bool ShowOffset(
GlyphPoint & out_point)
const;
34710 bool ShowElements(GlyphElementArray & out_def)
const;
34759 bool Empty()
const;
34962 void SetColor(
RGBAColor const & in_color);
34967 void SetMaterialByIndex(
float in_material_index);
35054 void SetSource(
char const * in_source);
35067 void SetMirror(
bool in_state);
35071 void SetFixed(
bool in_state);
35075 void SetRotation(
float in_degrees);
35080 bool ShowSource(
UTF8 & out_source)
const;
35096 bool ShowMirror(
bool & out_state)
const;
35101 bool ShowFixed(
bool & out_state)
const;
35106 bool ShowRotation(
float & out_degrees)
const;
35149 bool Empty()
const;
35289 bool ShowBody(LinePatternElementArray & out_elements)
const;
35294 bool ShowAbsoluteLength(
bool & out_state)
const;
35299 bool ShowAbsoluteWeight(
bool & out_state)
const;
35323 bool ShowContinuous(
bool & out_state)
const;
35372 bool Empty()
const;
35392 LinePatternKit & SetParallels(LinePatternParallelKitArray
const & in_parallels);
35420 bool ShowParallels(LinePatternParallelKitArray & out_parallels)
const;
35478 virtual void Assign(
Definition const & in_that);
35483 bool Equals(
Definition const & in_that)
const;
35488 bool operator==(
Definition const & in_that)
const;
35493 bool operator!=(
Definition const & in_that)
const;
35662 PortfolioKey & UndefineNamedStyle(
char const * in_name);
35667 PortfolioKey & UndefineMaterialPalette(
char const * in_name);
35677 PortfolioKey & UndefineLinePattern(
char const * in_name);
35795 size_t GetDefinitionCount()
const;
35798 size_t GetTextureDefinitionCount()
const;
35801 size_t GetCubeMapDefinitionCount()
const;
35804 size_t GetImageDefinitionCount()
const;
35807 size_t GetNamedStyleDefinitionCount()
const;
35810 size_t GetMaterialPaletteDefinitionCount()
const;
35813 size_t GetGlyphDefinitionCount()
const;
35816 size_t GetLinePatternDefinitionCount()
const;
35819 size_t GetShaderDefinitionCount()
const;
35825 bool ShowTextureDefinition(
char const * in_name,
TextureDefinition & out_found)
const;
35830 bool ShowAllTextureDefinitions(TextureDefinitionArray & out_definitions)
const;
35836 bool ShowCubeMapDefinition(
char const * in_name,
CubeMapDefinition & out_found)
const;
35841 bool ShowAllCubeMapDefinitions(CubeMapDefinitionArray & out_definitions)
const;
35847 bool ShowImageDefinition(
char const * in_name,
ImageDefinition & out_found)
const;
35852 bool ShowAllImageDefinitions(ImageDefinitionArray & out_definitions)
const;
35863 bool ShowAllNamedStyleDefinitions(NamedStyleDefinitionArray & out_definitions)
const;
35874 bool ShowAllMaterialPaletteDefinitions(MaterialPaletteDefinitionArray & out_definitions)
const;
35880 bool ShowGlyphDefinition(
char const * in_name,
GlyphDefinition & out_found)
const;
35885 bool ShowAllGlyphDefinitions(GlyphDefinitionArray & out_definitions)
const;
35896 bool ShowAllLinePatternDefinitions(LinePatternDefinitionArray & out_definitions)
const;
35902 bool ShowShaderDefinition(
char const * in_name,
ShaderDefinition & out_found)
const;
35907 bool ShowAllShaderDefinitions(ShaderDefinitionArray & out_definitions)
const;
35911 void MoveTo(
SegmentKey const & in_new_owner);
35957 void Set(
GlyphKit const & in_kit);
35961 void Show(
GlyphKit & out_kit)
const;
36066 bool Empty()
const;
36172 bool ShowDecal(
bool & out_state)
const;
36177 bool ShowDownSampling(
bool & out_state)
const;
36182 bool ShowModulation(
bool & out_state)
const;
36187 bool ShowParameterOffset(
size_t & out_offset)
const;
36212 bool ShowTransformMatrix(
MatrixKit & out_transform)
const;
36282 bool Empty()
const;
36303 ExportOptionsKit & SetSize(
unsigned int in_width,
unsigned int in_height);
36327 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
36375 bool Empty()
const;
36398 ImportOptionsKit & SetSize(
unsigned int in_width,
unsigned int in_height);
36441 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
36451 bool ShowDownSampling(
bool & out_state)
const;
36456 bool ShowCompressionQuality(
float & out_quality)
const;
36485 static void Export(
char const * in_file_name,
WindowKey const & in_window,
unsigned int in_width,
unsigned int in_height,
Format in_format = Format::Png);
36491 static void Export(
char const * in_file_name,
ImageKit const & in_image_kit);
36537 void Set(
ImageKit const & in_kit);
36541 void Show(
ImageKit & out_kit)
const;
36550 bool Empty()
const;
36555 bool Equals(
ImageKit const & in_kit)
const;
36560 bool operator==(
ImageKit const & in_kit)
const;
36565 bool operator!=(
ImageKit const & in_kit)
const;
36580 ImageKit & SetSize(
unsigned int in_width,
unsigned int in_height);
36585 ImageKit & SetData(ByteArray
const & in_image_data);
36591 ImageKit & SetData(
size_t in_byte_count, byte
const in_image_data []);
36601 ImageKit & SetDownSampling(
bool in_state);
36606 ImageKit & SetCompressionQuality(
float in_quality);
36626 ImageKit & UnsetCompressionQuality();
36636 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
36641 bool ShowData(ByteArray & out_image_data)
const;
36651 bool ShowDownSampling(
bool & out_state)
const;
36656 bool ShowCompressionQuality(
float & out_quality)
const;
36688 Type
ObjectType()
const {
return Type::OffScreenWindowOptionsControl; };
36710 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
36716 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
36727 bool ShowHardwareResident(
bool & out_state)
const;
36733 bool ShowOpacity(
bool & out_state,
float & out_opacity)
const;
36828 void Set(
ImageKit const & in_kit);
36832 void Show(
ImageKit & out_kit)
const;
36896 void ShowSource(ImageDefinitionArray & out_image_sources)
const;
36989 void Set(MaterialKitArray
const & in_source);
36994 void Set(
size_t in_count,
MaterialKit const in_source []);
36998 void Show(MaterialKitArray & out_source)
const;
37061 PhysicalReflection,
37122 bool Empty()
const;
37179 bool ShowMultitexture(
bool & out_state)
const;
37189 bool ShowTransformMatrix(
MatrixKit & out_transform)
const;
37254 bool Empty()
const;
37259 bool Equals(
ShaderKit const & in_kit)
const;
37264 bool operator==(
ShaderKit const & in_kit)
const;
37269 bool operator!=(
ShaderKit const & in_kit)
const;
37274 ShaderKit & SetSource(
char const * in_source);
37282 ShaderKit & SetMultitexture(
bool in_state);
37305 ShaderKit & UnsetParameterizationSource();
37318 bool ShowSource(
UTF8 & out_source)
const;
37325 bool ShowMultitexture(
bool & out_state)
const;
37335 bool ShowTransformMatrix(
MatrixKit & out_transform)
const;
37413 Type
ObjectType()
const {
return Type::CutGeometryGatheringOptionsKit;};
37435 bool Empty()
const;
37494 bool ShowOffset(
size_t & out_offset)
const;
37547 bool Empty()
const;
37614 bool ShowCriteria(SearchTypeArray & out_types)
const;
37619 bool ShowSearchSpace(
Search::Space & out_search_space)
const;
37664 bool operator==(
TreeContext const & in_that)
const;
37669 bool operator!=(
TreeContext const & in_that)
const;
37718 bool Empty()
const;
37900 bool ShowProximity(
float & out_proximity)
const;
37910 bool ShowInternalLimit(
size_t & out_limit)
const;
37915 bool ShowRelatedLimit(
size_t & out_limit)
const;
37920 bool ShowSorting(
bool & out_sorted)
const;
37935 bool ShowScope(
KeyPath & out_start_path)
const;
37940 bool ShowTreeContext(
TreeContext & out_tree_context)
const;
37945 bool ShowExtentCullingRespected(
bool & out_state)
const;
37950 bool ShowDeferralExtentCullingRespected(
bool & out_state)
const;
37955 bool ShowFrustumCullingRespected(
bool & out_state)
const;
37960 bool ShowVectorCullingRespected(
bool & out_state)
const;
38090 bool ShowProximity(
float & out_proximity)
const;
38100 bool ShowInternalLimit(
size_t & out_limit)
const;
38105 bool ShowRelatedLimit(
size_t & out_limit)
const;
38110 bool ShowSorting(
bool & out_sorted)
const;
38125 bool ShowExtentCullingRespected(
bool & out_state)
const;
38130 bool ShowDeferralExtentCullingRespected(
bool & out_state)
const;
38135 bool ShowFrustumCullingRespected(
bool & out_state)
const;
38140 bool ShowVectorCullingRespected(
bool & out_state)
const;
38206 bool ShowSelectedItem(
Key & out_selection)
const;
38211 bool ShowPath(
KeyPath & out_path)
const;
38216 bool ShowFaces(SizeTArray & out_faces)
const;
38221 bool ShowVertices(SizeTArray & out_vertices)
const;
38227 bool ShowEdges(SizeTArray & out_vertices1, SizeTArray & out_vertices2)
const;
38232 bool ShowCharacters(SizeTArray & out_characters)
const;
38237 bool ShowSelectionPosition(
WindowPoint & out_location)
const;
38242 bool ShowSelectionPosition(
WorldPoint & out_location)
const;
38303 bool IsValid()
const;
38371 virtual void Reset();
38379 size_t GetCount()
const;
38485 size_t SelectByPolygon(PointArray
const & in_points,
SelectionResults & out_results)
const;
38500 size_t SelectByPolygon(
size_t in_point_count,
Point const in_points [],
SelectionResults & out_results)
const;
38513 size_t SelectByLine(PointArray
const & in_points,
SelectionResults & out_results)
const;
38528 size_t SelectByLine(
size_t in_point_count,
Point const in_points [],
SelectionResults & out_results)
const;
38652 bool Empty()
const;
38720 bool ShowStyleName(
UTF8 & out_style_name)
const;
38725 bool ShowSecondaryStyleName(
UTF8 & out_style_name)
const;
38735 bool ShowNotification(
bool & out_state)
const;
38889 bool Empty()
const;
38937 bool ShowTimeLimit(Time & out_time_limit)
const;
39008 bool ShowTimeLimit(Time & out_time_limit)
const;
39023 World(
char const * in_license);
39034 World & SetMaterialLibraryDirectory(
char const * in_directory);
39040 World & SetFontDirectory(
char const * in_directory);
39047 World & SetFontDirectories(
size_t in_count,
UTF8 const in_directories[]);
39053 World & SetFontDirectories(UTF8Array
const & in_directories);
39060 World & SetDriverConfigFile(
char const * in_filename);
39067 World & SetExchangeLibraryDirectory(
char const * in_directory);
39074 World & SetPublishResourceDirectory(
char const * in_directory);
39080 World & SetParasolidSchemaDirectory(
char const * in_directory);
39084 World & UnsetMaterialLibraryDirectory();
39088 World & UnsetFontDirectories();
39092 World & UnsetDriverConfigFile();
39096 World & UnsetExchangeLibraryDirectory();
39100 World & UnsetPublishResourceDirectory();
39104 World & UnsetParasolidSchemaDirectory();
39109 bool ShowLicense(
UTF8 & out_license)
const;
39114 bool ShowMaterialLibraryDirectory(
UTF8 & out_directory)
const;
39119 bool ShowFontDirectories(UTF8Array & out_directories)
const;
39124 bool ShowDriverConfigFile(
UTF8 & out_filename)
const;
39129 bool ShowExchangeLibraryDirectory(
UTF8 & out_directory)
const;
39134 bool ShowPublishResourceDirectory(
UTF8 & out_directory)
const;
39139 bool ShowParasolidSchemaDirectory(
UTF8 & out_directory)
const;
39147 virtual void Reset() {}
39176 intptr_t GetClassID()
const;
39185 virtual void Handle(
const char * message,
Emergency::Code code)
const = 0;
39187 static void *
operator new (
size_t in_size){
return Memory::Allocate(in_size); }
39188 static void operator delete (
void * in_ptr,
size_t in_size)
throw () { HPS_UNREFERENCED(in_size);
Memory::Free(in_ptr); }
39201 static void Execute(
bool in_once=
true);
39205 static Time GetTime();
39208 static void Sleep(Time milliseconds);
39234 static void RelinquishMemory();
39262 static void ShowMemoryUsage(
size_t & out_allocated,
size_t & out_used);
39271 static void Reset();
39274 static void Synchronize();
39278 static WindowKeyArray GetWindowKeys();
39282 static SegmentKeyArray GetRootSegments();
39286 static PortfolioKeyArray GetPortfolios();
39292 static PortfolioKey const GetMaterialLibraryPortfolio();
39367 static size_t SelectByShell(
ShellKit const & in_shell,
39376 static size_t SelectByShell(
ShellKey const & in_shell,
39386 static size_t SelectByVolume(
SimpleCuboid const & in_volume,
39396 static size_t SelectByRay(
Point const & in_start_point,
Vector const & in_direction,
39408 static bool GetInformationEventFilter(
Info::Code in_code);
39413 static bool GetWarningEventFilter(
Info::Code in_code);
39418 static bool GetErrorEventFilter(
Info::Code in_code);
39424 static bool SetInformationEventFilter(
Info::Code in_code,
bool in_filtered);
39430 static bool SetWarningEventFilter(
Info::Code in_code,
bool in_filtered);
39436 static bool SetErrorEventFilter(
Info::Code in_code,
bool in_filtered);
39441 static void SetEmergencyHandler(
EmergencyHandler const & in_emergency_handler);
39444 static void UnsetEmergencyHandler();
39448 static size_t GetSoftMemoryLimit();
39453 static size_t SetSoftMemoryLimit(
size_t in_limit_bytes);
39522 bool Subscribe(
EventHandler const & in_handler, intptr_t in_type)
const;
39528 bool UnSubscribe(
EventHandler const & in_handler, intptr_t in_type)
const;
39534 bool UnSubscribe(
EventHandler const & in_handler)
const;
39540 bool UnSubscribe(intptr_t in_type)
const;
39545 bool InjectEvent(
Event const & in_event)
const;
39555 void Shutdown()
const;
39559 bool IsShutdown()
const;
39564 void SetName(
char const * in_name)
const;
39568 void ShowName(
UTF8 & out_name)
const;
39572 virtual void Reset() {}
39611 bool Subscribe(
EventDispatcher const & in_dispatcher, intptr_t in_type)
const;
39617 bool UnSubscribe(
EventDispatcher const & in_dispatcher, intptr_t in_type)
const;
39625 void UnSubscribeEverything()
const;
39628 virtual void Reset() { UnSubscribeEverything(); }
39658 channel = GetClassID();
39659 consumable =
false;
39667 if(in_event.
GetChannel() != Object::ClassID<TimerTickEvent>())
39686 HPS_UNREFERENCED(in_that_event);
39691 return GetClassID();
39709 channel = GetClassID();
39710 consumable =
false;
39711 action = Action::None;
39715 :
Event(), action(in_action), results(in_results), options(in_options)
39717 channel = GetClassID();
39718 consumable =
false;
39725 if (in_event.
GetChannel() == Object::ClassID<HighlightEvent>())
39728 action = that.action;
39729 results = that.results;
39730 options = that.options;
39771 if (in_event.
GetChannel() == Object::ClassID<InformationEvent>())
39775 code =
event->code;
39798 return message == in_that.
message && code == in_that.
code;
39806 return Equals(in_that);
39814 return !Equals(in_that);
39842 if(in_event.
GetChannel() == Object::ClassID<WarningEvent>())
39846 code =
event->code;
39869 return message == in_that.
message && code == in_that.
code;
39877 return Equals(in_that);
39885 return !Equals(in_that);
39902 ErrorEvent(
char const * in_message) :
Event(), message(in_message), code(
Info::Code::Unknown) { channel = GetClassID(); }
39913 if(in_event.
GetChannel() == Object::ClassID<ErrorEvent>())
39917 code =
event->code;
39940 return message == in_that.
message && code == in_that.
code;
39948 return Equals(in_that);
39956 return !Equals(in_that);
39991 if(in_event.
GetChannel() == Object::ClassID<StandAloneWindowEvent>())
40017 return action == in_that.
action;
40025 return Equals(in_that);
40033 return !Equals(in_that);
40046 { channel = GetClassID(); }
40090 , import_status_message(
UTF8())
40091 { channel = GetClassID(); }
40095 , import_status_message(in_message)
40096 { channel = GetClassID(); }
40098 ~ImportStatusEvent() {};
40108 UTF8 import_status_message;
40123 return modifiers == in_that.modifiers;
40131 return Equals(in_that);
40139 return !Equals(in_that);
40144 bool None()
const {
return modifiers == _key_none; }
40148 bool Shift()
const {
return (modifiers & _key_shift) != 0; }
40152 bool Control()
const {
return (modifiers & _key_control) != 0; }
40156 bool Alt()
const {
return (modifiers & _key_alt) != 0; }
40160 bool Meta()
const {
return (modifiers & _key_meta) != 0; }
40166 bool HasAll(
ModifierKeys const & in_keys)
const {
return (modifiers & in_keys.modifiers) == in_keys.modifiers; }
40176 void Shift(
bool in_state) {
if(in_state) modifiers |= _key_shift;
else modifiers &= ~(_key_shift); }
40180 void Control(
bool in_state) {
if(in_state) modifiers |= _key_control;
else modifiers &= ~(_key_control); }
40184 void Alt(
bool in_state) {
if(in_state) modifiers |= _key_alt;
else modifiers &= ~(_key_alt); }
40188 void Meta(
bool in_state) {
if(in_state) modifiers |= _key_meta;
else modifiers &= ~(_key_meta); }
40196 ret.modifiers = modifiers | in_modifiers_to_merge.modifiers;
40206 ret.modifiers = modifiers & ~in_modifiers_to_remove.modifiers;
40243 _key_none = 0x0000,
40244 _key_shift = 0x0001,
40245 _key_control = 0x0002,
40247 _key_meta = 0x0008,
40290 return Equals(in_that);
40298 return !Equals(in_that);
40306 return ModifierKeyState;
40333 :
InputEvent(in_modifier), CurrentAction(in_action) { channel = GetClassID(); }
40341 :
InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches) { channel = GetClassID(); }
40350 :
InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches, in_touches + in_touch_count) { channel = GetClassID(); }
40357 if(in_event.
GetChannel() == Object::ClassID<TouchEvent>())
40360 channel = GetClassID();
40361 CurrentAction =
event->CurrentAction;
40362 Touches =
event->Touches;
40363 ModifierKeyState =
event->ModifierKeyState;
40393 return Equals(in_that);
40401 return !Equals(in_that);
40411 if (CurrentAction == that_touch_event->
CurrentAction && CurrentAction == Action::Move
40412 && Touches.size() == that_touch_event->
Touches.size() )
40414 TouchArray these_touches = Touches;
40415 TouchArray those_touches = that_touch_event->
Touches;
40417 std::sort(those_touches.begin(), those_touches.end(), sort_predicate);
40418 std::sort(these_touches.begin(), these_touches.end(), sort_predicate);
40420 for (
size_t i = 0 ; i < these_touches.size() ; i++)
40422 if (these_touches[i].ID != those_touches[i].ID)
40436 Touches.assign(in_touches, in_touches + in_touch_count);
40443 Touches = in_touches;
40455 static bool sort_predicate(
Touch const & in_a,
Touch const & in_b)
40457 return static_cast<int>(in_a.
ID) < static_cast<int>(in_b.
ID);
40474 return buttons == in_that.buttons;
40482 return Equals(in_that);
40490 return !Equals(in_that);
40495 bool None()
const {
return buttons == _button_none; }
40499 bool Left()
const {
return (buttons & _button_left) != 0; }
40503 bool Right()
const {
return (buttons & _button_right) != 0; }
40507 bool Middle()
const {
return (buttons & _button_middle) != 0; }
40511 bool X1()
const {
return (buttons & _button_x1) != 0; }
40515 bool X2()
const {
return (buttons & _button_x2) != 0; }
40521 bool HasAll(
MouseButtons const & in_buttons)
const {
return (buttons & in_buttons.buttons) == in_buttons.buttons; }
40530 void Left(
bool in_state) {
if(in_state) buttons |= _button_left;
else buttons &= ~(_button_left); }
40534 void Right(
bool in_state) {
if(in_state) buttons |= _button_right;
else buttons &= ~(_button_right); }
40538 void Middle(
bool in_state) {
if(in_state) buttons |= _button_middle;
else buttons &= ~(_button_middle); }
40542 void X1(
bool in_state) {
if(in_state) buttons |= _button_x1;
else buttons &= ~(_button_x1); }
40546 void X2(
bool in_state) {
if(in_state) buttons |= _button_x2;
else buttons &= ~(_button_x2); }
40554 ret.buttons = buttons | in_buttons_to_merge.buttons;
40564 ret.buttons = buttons & ~in_buttons_to_remove.buttons;
40605 _button_none = 0x0000,
40606 _button_left = 0x0001,
40607 _button_right = 0x0002,
40608 _button_middle = 0x0004,
40609 _button_x1 = 0x0008,
40610 _button_x2 = 0x0010
40643 :
InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), CurrentButton(in_button), WheelDelta(0), ClickCount(in_click_count) { channel = GetClassID(); }
40653 :
InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), WheelDelta(in_wheel_delta), ClickCount(in_click_count) { channel = GetClassID(); }
40659 if(in_event.
GetChannel() == Object::ClassID<MouseEvent>())
40662 channel = GetClassID();
40663 CurrentAction =
event->CurrentAction;
40664 Location =
event->Location;
40665 CurrentButton =
event->CurrentButton;
40666 WheelDelta =
event->WheelDelta;
40667 ClickCount =
event->ClickCount;
40700 return Equals(in_that);
40708 return !Equals(in_that);
40719 (CurrentAction == Action::ButtonDown || CurrentAction == Action::ButtonUp || CurrentAction == Action::Move) &&
40728 if (CurrentAction == Action::Move)
40729 return GetClassID();
40762 :
InputEvent(in_modifiers), CurrentAction(in_action) { channel = GetClassID(); }
40770 :
InputEvent(in_modifiers), CurrentAction(in_action)
40772 channel = GetClassID();
40773 KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
40781 :
InputEvent(in_modifiers), CurrentAction(in_action)
40783 channel = GetClassID();
40784 KeyboardCodes = in_keyboardcodes;
40791 if(in_event.
GetChannel() == Object::ClassID<KeyboardEvent>())
40794 channel = GetClassID();
40795 KeyboardCodes =
event->KeyboardCodes;
40796 CurrentAction =
event->CurrentAction;
40827 return Equals(in_that);
40835 return !Equals(in_that);
40843 KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
40850 KeyboardCodes = in_keyboardcodes;
40895 bool Equals(
MouseState const & in_that)
const;
40900 bool operator== (
MouseState const & in_that)
const;
40905 bool operator!= (
MouseState const & in_that)
const;
40919 KeyArray GetEventPath()
const;
40973 bool Equals(
TouchState const & in_that)
const;
40978 bool operator== (
TouchState const & in_that)
const;
40983 bool operator!= (
TouchState const & in_that)
const;
40997 KeyArray GetEventPath()
const;
41001 size_t GetTouchCount()
const;
41005 TouchArray GetTouches()
const;
41075 KeyArray GetEventPath()
const;
41079 size_t GetKeyboardCodeCount()
const;
41083 KeyboardCodeArray GetKeyboardCodes()
const;
41088 bool GetKeyState(KeyboardCode in_key_code)
const;
41140 IOResult Status()
const;
41145 IOResult Status(
float & out_percent_complete)
const;
41198 bool Empty()
const;
41228 bool ShowSegment(
SegmentKey & out_segment)
const;
41243 bool ShowAlternateRoot(
SegmentKey & out_segment)
const;
41258 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
41305 bool Empty()
const;
41337 bool ShowSegment(
SegmentKey & out_segment)
const;
41355 bool ShowAlternateRoot(
SegmentKey & out_segment)
const;
41373 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
41389 bool ShowDefaultCamera(
CameraKit & out_camera)
const;
41397 ImportResultsKit & SetAlternateCameras(UTF8Array
const & in_names, CameraKitArray & in_cameras);
41408 bool ShowAlternateCameras(UTF8Array & out_names, CameraKitArray & out_cameras)
const;
41461 bool Empty()
const;
41485 ExportOptionsKit & SetVertexCompression(
bool in_state,
unsigned int in_bits_per_vertex = 24);
41494 ExportOptionsKit & SetNormalCompression(
bool in_state,
unsigned int in_bits_per_normal = 10);
41501 ExportOptionsKit & SetParameterCompression(
bool in_state,
unsigned int in_bits_per_parameter = 8);
41510 ExportOptionsKit & SetColorCompression(
bool in_state,
unsigned int in_bits_per_color = 24);
41519 ExportOptionsKit & SetIndexCompression(
bool in_state,
unsigned int in_bits_per_index = 8);
41536 ExportOptionsKit & SetImageCompression(
bool in_state,
float in_quality = 0.75f);
41574 bool ShowVertexCompression(
bool & out_state,
unsigned int & out_bits_per_vertex)
const;
41580 bool ShowNormalCompression(
bool & out_state,
unsigned int & out_bits_per_normal)
const;
41586 bool ShowParameterCompression(
bool & out_state,
unsigned int & out_bits_per_parameter)
const;
41592 bool ShowColorCompression(
bool & out_state,
unsigned int & out_bits_per_color)
const;
41598 bool ShowIndexCompression(
bool & out_state,
unsigned int & out_bits_per_index)
const;
41603 bool ShowConnectivityCompression(
bool & out_state)
const;
41609 bool ShowImageCompression(
bool & out_state,
float & out_quality)
const;
41718 DotsPerCentimeter = DPCM,
41767 bool Empty()
const;
41792 bool ShowSize(
float & out_width,
float & out_height,
Hardcopy::SizeUnits & out_units)
const;
41832 bool ShowWYSIWYG(
bool & out_onoff)
const;
41869 static IOResult Export(
char const * in_filename, Driver in_driver_type,
WindowKey const & in_window, ExportOptionsKit
const & in_options);
41919 bool Empty()
const;
41942 bool ShowResolution(
float & out_resolution)
const;
41958 bool ShowWYSIWYG(
bool & out_onoff)
const;
41981 static IOResult Export(intptr_t hdc, intptr_t attribdc,
WindowKey const & window, ExportOptionsKit
const & options);
42041 bool Empty()
const;
42071 bool ShowSegment(
SegmentKey & out_segment)
const;
42086 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
42149 bool Empty()
const;
42181 bool ShowSegment(
SegmentKey & out_segment)
const;
42199 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
42340 bool Empty()
const;
42402 bool ShowSegment(
SegmentKey & out_segment)
const;
42451 bool Empty()
const;
42483 bool ShowSegment(
SegmentKey & out_segment)
const;
42561 # pragma warning(pop)
Type ObjectType() const
Definition: hps.h:39028
Rotation
Definition: hps.h:1580
Type ObjectType() const
Definition: hps.h:26191
bool Empty() const
Definition: hps.h:6712
CameraPoint(Point const &in_point)
Definition: hps.h:5663
Alignment
Definition: hps.h:1513
Space
Definition: hps.h:546
WindowPoint Location
Location in window space of the mouse cursor.
Definition: hps.h:40735
Channel
Definition: hps.h:930
Type ObjectType() const
Definition: hps.h:23441
Handedness
Definition: hps.h:1261
ColorSource
Definition: hps.h:1906
Type ObjectType() const
Definition: hps.h:16558
Type ObjectType() const
Definition: hps.h:35350
Event(intptr_t in_channel=0)
Definition: hps.h:6016
Type ObjectType() const
Definition: hps.h:42253
Cuboid_3D(Point_3D< F > const &in_min, Point_3D< F > const &in_max)
Definition: hps.h:3693
float alpha
Definition: hps.h:4217
Type ObjectType() const
Definition: hps.h:34957
bool operator==(Touch const &in_that) const
Definition: hps.h:6306
Both cylinder ends will be capped.
Search for all attributes, geometry, segments, includes and includers.
void Shift(bool in_state)
Definition: hps.h:40176
Info::Code code
The error code for this ErrorEvent.
Definition: hps.h:39960
Type ObjectType() const
Definition: hps.h:37373
Type ObjectType() const
Definition: hps.h:33437
Type ObjectType() const
Definition: hps.h:21251
Type ObjectType() const
Definition: hps.h:22969
Type ObjectType() const
Definition: hps.h:23715
Action
Definition: hps.h:40318
Orientation
Definition: hps.h:522
Code
Definition: hps.h:127
Definition: sprk_exchange.h:43
Algorithm
Definition: hps.h:1316
Multiline strings will be left justfied.
Type ObjectType() const
Definition: hps.h:14441
virtual bool Equals(StandAloneWindowEvent const &in_that) const
Definition: hps.h:40015
Type ObjectType() const
Definition: hps.h:8196
Type ObjectType() const
Definition: hps.h:27419
Event * Clone() const
Definition: hps.h:39858
MouseEvent(Action in_action, float in_wheel_delta, WindowPoint in_location=WindowPoint(0, 0, 0), ModifierKeys in_modifier=ModifierKeys(), size_t in_click_count=0)
Definition: hps.h:40652
virtual HandleResult Handle(Event const *in_event)
Definition: hps.h:39646
ImportStatusEvent()
Definition: hps.h:40088
Type ObjectType() const
Definition: hps.h:20868
Type ObjectType() const
Definition: hps.h:35132
Type ObjectType() const
Definition: hps.h:25214
virtual bool Equals(TouchEvent const &in_that) const
Definition: hps.h:40383
Type ObjectType() const
Definition: hps.h:29420
Type ObjectType() const
Definition: hps.h:24845
Type ObjectType() const
Definition: hps.h:11131
A unitless linear scaling factor. A value of 2.0 will cause markers to be rendered twice as large...
The clip region is specified in world coordinated.
ErrorEvent(char const *in_message, Info::Code in_code)
Definition: hps.h:39907
void SetKeyboardCodes(size_t in_keyboardcode_count, KeyboardCode const in_keyboardcodes[])
Definition: hps.h:40841
Type ObjectType() const
Definition: hps.h:36824
ObjectPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5560
InnerWindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5808
Driver
Definition: hps.h:147
Type ObjectType() const
Definition: hps.h:40881
static HPS_INLINE bool IsInfinite(float const &a)
Definition: hps.h:2134
Type ObjectType() const
Definition: hps.h:38172
CappingLevel
Definition: hps.h:1712
Type ObjectType() const
Definition: hps.h:22696
Type ObjectType() const
Definition: hps.h:34885
Object space units ignoring any scaling components in modelling matrices.
Type ObjectType() const
Definition: hps.h:12269
Type ObjectType() const
Definition: hps.h:40959
Type ObjectType() const
Definition: hps.h:19997
Type ObjectType() const
Definition: hps.h:13286
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5420
Type ObjectType() const
Definition: hps.h:28204
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid) const
Definition: hps.h:3800
KeyboardEvent(KeyboardEvent::Action in_action, KeyboardCodeArray const &in_keyboardcodes, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:40780
static ModifierKeys KeyMeta()
Definition: hps.h:40235
Type ObjectType() const
Definition: hps.h:34620
Visualize will perform runtime query of the 3D capabilities of the Operating System and graphics card...
Type ObjectType() const
Definition: hps.h:35999
Cuboid_3D(Cuboid_3D< D > const &that)
Definition: hps.h:3679
Type ObjectType() const
Definition: hps.h:38344
Type ObjectType() const
Definition: hps.h:22894
Type ObjectType() const
Definition: hps.h:34191
Type ObjectType() const
Definition: hps.h:16267
Type ObjectType() const
Definition: hps.h:37413
Time GetTimeStamp() const
Definition: hps.h:6038
Type ObjectType() const
Definition: hps.h:21729
NormalizedPoint(Point const &in_point)
Definition: hps.h:5713
Type ObjectType() const
Definition: hps.h:23243
Event * Clone() const
Definition: hps.h:39675
static HPS_INLINE Cuboid_3D Invalid()
Definition: hps.h:3728
Renderer
Definition: hps.h:1561
Type ObjectType() const
Definition: hps.h:33173
KeyboardEvent()
Definition: hps.h:40756
Type ObjectType() const
Definition: hps.h:7087
HPS_INLINE bool Contains(Cuboid_3D const &contained) const
Definition: hps.h:3908
ObjectPoint(Point const &in_point)
Definition: hps.h:5563
Type ObjectType() const
Definition: hps.h:17145
Object space units ignoring any scaling components in modelling matrices.
Point_3D< F > min
Definition: hps.h:3663
StandAloneWindowEvent(Event const &in_event)
Definition: hps.h:39989
static ModifierKeys KeyAlt()
Definition: hps.h:40231
bool IsConsumable() const
Definition: hps.h:6041
MaterialPreference
Definition: hps.h:1729
KeyboardEvent(KeyboardEvent::Action in_action, size_t in_keyboardcode_count, KeyboardCode const in_keyboardcodes[], ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:40769
Mobility
Definition: hps.h:188
Type ObjectType() const
Definition: hps.h:12779
ScreenRangePoint(Point const &in_point)
Definition: hps.h:5761
InterpolationAlgorithm
Definition: hps.h:1496
Fill
Definition: hps.h:1897
Cuboid_3D(Rectangle const &that)
Definition: hps.h:3716
Type ObjectType() const
Definition: hps.h:26696
Type ObjectType() const
Definition: hps.h:18638
char At(size_t in_index) const
Definition: hps.h:6755
bool HasAny(ModifierKeys const &in_keys) const
Definition: hps.h:40171
Type ObjectType() const
Definition: hps.h:35012
ReferenceFrame
Definition: hps.h:1528
Type ObjectType() const
Definition: hps.h:16474
GreekingUnits
Definition: hps.h:1615
Type ObjectType() const
Definition: hps.h:11681
InnerConeUnits
Definition: hps.h:471
InnerPixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5857
KeyPath & Append(Key const &in_key)
UpdateCompletedEvent()
Definition: hps.h:40065
OuterConeUnits
Definition: hps.h:457
Type ObjectType() const
Definition: hps.h:18422
Type ObjectType() const
Definition: hps.h:39496
Type ObjectType() const
Definition: hps.h:38441
Type ObjectType() const
Definition: hps.h:13882
Type ObjectType() const
Definition: hps.h:32676
void SetKeyboardCodes(KeyboardCodeArray const &in_keyboardcodes)
Definition: hps.h:40848
Type ObjectType() const
Definition: hps.h:26090
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:40407
Type ObjectType() const
Definition: hps.h:12152
Type ObjectType() const
Definition: hps.h:24427
Type ObjectType() const
Definition: hps.h:35463
Channel
Definition: hps.h:889
Info::Code code
The warning code for this WarningEvent.
Definition: hps.h:39889
AreaUnits
Definition: hps.h:1442
Definition: sprk_publish.h:42
HPS_INLINE F Volume() const
Definition: hps.h:3770
Type ObjectType() const
Definition: hps.h:11504
Type ObjectType() const
Definition: hps.h:33793
Action
Definition: hps.h:39971
Type ObjectType() const
Definition: hps.h:13720
Type ObjectType() const
Definition: hps.h:41444
Type ObjectType() const
Definition: hps.h:26797
size_t TapCount
Number of taps for this Touch.
Definition: hps.h:6321
Type ObjectType() const
Definition: hps.h:36942
Type ObjectType() const
Definition: hps.h:33310
TouchEvent(Action in_action, TouchArray const &in_touches, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:40340
void Merge(size_t count, Point_3D< F > const *points)
Definition: hps.h:3866
Border
Definition: hps.h:249
UpdateControl
Definition: hps.h:168
bool HasAll(ModifierKeys const &in_keys) const
Definition: hps.h:40166
Type ObjectType() const
Definition: hps.h:22466
virtual bool Equals(KeyboardEvent const &in_that) const
Definition: hps.h:40817
Type ObjectType() const
Definition: hps.h:20793
WarningEvent(Event const &in_event)
Definition: hps.h:39840
Type ObjectType() const
Definition: hps.h:11007
The geometry inside the clip region is drawn. Everything outside of it is clipped.
Default
Definition: hps.h:1916
static ModifierKeys KeyShift()
Definition: hps.h:40223
Type ObjectType() const
Definition: hps.h:27930
Shape
Definition: hps.h:1058
bool IsValid() const
Definition: hps.h:6705
Cuboid_3D()
Definition: hps.h:3671
ErrorEvent(Event const &in_event)
Definition: hps.h:39911
size_t GetWStrLength() const
Definition: hps.h:6734
Event * Clone() const
Definition: hps.h:39740
Type ObjectType() const
Definition: hps.h:10598
AppendMode
Definition: hps.h:317
static void Free(void *in_pointer)
HPS_INLINE void Merge(Point_3D< F > const &point)
Definition: hps.h:3851
void Meta(bool in_state)
Definition: hps.h:40188
PixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5956
Type ObjectType() const
Definition: hps.h:14150
UpdateStatus
Definition: hps.h:157
HPS_INLINE bool IsValid() const
Definition: hps.h:3721
Type ObjectType() const
Definition: hps.h:37525
Action action
The action for this StandAloneWindowEvent.
Definition: hps.h:40036
Quality
Definition: hps.h:1042
ResolutionUnits
Definition: hps.h:41714
TimerTickEvent(Event const &in_event)
Definition: hps.h:39665
Component
Definition: hps.h:337
WindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5907
Type ObjectType() const
Definition: hps.h:11768
Default
Definition: hps.h:1870
Type ObjectType() const
Definition: hps.h:10228
bool Equals(GlyphPoint const &in_that) const
Definition: hps.h:4965
bool Shift() const
Definition: hps.h:40148
SizeToleranceUnits
Definition: hps.h:1602
Type ObjectType() const
Definition: hps.h:37649
HPS_INLINE bool Contains(Point_3D< F > const &contained, F epsilon) const
Definition: hps.h:3937
Cap
Definition: hps.h:1821
Point_3D< F > max
Definition: hps.h:3665
Type ObjectType() const
Definition: hps.h:7167
Type ObjectType() const
Definition: hps.h:42024
Type ObjectType() const
Definition: hps.h:42132
MouseEvent()
Definition: hps.h:40634
Type ObjectType() const
Definition: hps.h:11609
Type ObjectType() const
Definition: hps.h:16176
Type ObjectType() const
Definition: hps.h:34236
Material Texture Channel.
static const float Infinity
Definition: hps.h:2129
InsetBehavior
Definition: hps.h:1802
Type ObjectType() const
Definition: hps.h:24353
static HPS_INLINE bool IsNAN(float const &a)
Definition: hps.h:2142
Type ObjectType() const
Definition: hps.h:13174
Type ObjectType() const
Definition: hps.h:26390
WindowPoint Location
Location in window space for this Touch.
Definition: hps.h:6320
Type ObjectType() const
Definition: hps.h:34426
Type ObjectType() const
Definition: hps.h:36688
HPS_INLINE void Merge(Cuboid_3D const &cuboid)
Definition: hps.h:3830
Algorithm
Definition: hps.h:1430
Decimation
Definition: hps.h:999
Granularity
Definition: hps.h:1351
Parameterization
Definition: hps.h:37056
Search the current segment only.
KeyboardEvent(Event const &in_event)
Definition: hps.h:40789
ClipOperation
Definition: hps.h:1290
Type ObjectType() const
Definition: hps.h:8448
Method
Definition: hps.h:1420
Type ObjectType() const
Definition: hps.h:25830
Parameterization
Definition: hps.h:944
FocusLostEvent()
Definition: hps.h:40044
CuttingLevel
Definition: hps.h:1721
Channel
Definition: hps.h:910
HandleResult
Definition: hps.h:39636
bool operator!=(GlyphPoint const &in_that) const
Definition: hps.h:4977
UTF8 message
The error message for this ErrorEvent.
Definition: hps.h:39959
Value
Definition: hps.h:1401
static HPS_INLINE bool IsAbnormal(float const &a)
Definition: hps.h:2150
Type ObjectType() const
Definition: hps.h:25346
Event * Clone() const
Definition: hps.h:40052
virtual bool Equals(MouseEvent const &in_that) const
Definition: hps.h:40688
ErrorEvent()
Definition: hps.h:39898
Justification
Definition: hps.h:1536
The vertex colors applied to faces.
Type ObjectType() const
Definition: hps.h:13544
An InvalidOperationException is thrown when an operation is not supported on the current platform...
Definition: hps.h:5438
ErrorEvent(char const *in_message)
Definition: hps.h:39902
FrameSize
Definition: hps.h:199
Justification
Definition: hps.h:1838
Type ObjectType() const
Definition: hps.h:11329
Type ObjectType() const
Definition: hps.h:19279
Type ObjectType() const
Definition: hps.h:21560
Type ObjectType() const
Definition: hps.h:8243
Type ObjectType() const
Definition: hps.h:35953
Type ObjectType() const
Definition: hps.h:34140
GreekingMode
Definition: hps.h:1627
Type ObjectType() const
Definition: hps.h:19789
KeyboardCodeArray KeyboardCodes
Array of keyboard codes for this KeyboardEvent.
Definition: hps.h:40853
Operation
Definition: hps.h:440
Type ObjectType() const
Definition: hps.h:36533
Type
Definition: hps.h:1984
WorldPoint(Point const &in_point)
Definition: hps.h:5613
TouchArray Touches
Array of Touches for this TouchEvent.
Definition: hps.h:40447
Type ObjectType() const
Definition: hps.h:9427
static HPS_INLINE bool Equals(float const &a, float const &b, int tolerance=32)
Definition: hps.h:2421
Type ObjectType() const
Definition: hps.h:6552
TouchEvent(Event const &in_event)
Definition: hps.h:40355
void SetTouches(TouchArray const &in_touches)
Definition: hps.h:40441
friend bool operator!=(char const *in_left, UTF8 const &in_right)
Definition: hps.h:6837
Relation
Definition: hps.h:363
Action
Definition: hps.h:40748
ChannelMapping
Definition: hps.h:1013
Type ObjectType() const
Definition: hps.h:22078
IOResult result
Enumeration indicating the category of the exception.
Definition: hps.h:5455
Type ObjectType() const
Definition: hps.h:37991
Type ObjectType() const
Definition: hps.h:38630
bool Alt() const
Definition: hps.h:40156
ToleranceUnits
Definition: hps.h:346
Type ObjectType() const
Definition: hps.h:12079
SizeUnits
Definition: hps.h:1789
Type
Definition: hps.h:2001
The vertex colors applied to faces.
RelationTest
Definition: hps.h:373
Type
Definition: hps.h:308
Type ObjectType() const
Definition: hps.h:14294
Behavior
Definition: hps.h:555
Ambient Occulsion Quality.
Type ObjectType() const
Definition: hps.h:6627
KeyboardEvent::Action CurrentAction
The action for the keyboard codes for this KeyboardEvent.
Definition: hps.h:40854
Type ObjectType() const
Definition: hps.h:18188
An InvalidLicenseException is thrown when trying to run Visualize with an invalid license...
Definition: hps.h:5429
float blue
Definition: hps.h:4216
A grid of lines will be drawn in place of characters below the greeking limit.
Type
Definition: hps.h:413
Type ObjectType() const
Definition: hps.h:20568
friend bool operator!=(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:6855
PixelPoint(Point const &in_point)
Definition: hps.h:5959
Type ObjectType() const
Definition: hps.h:6081
Type ObjectType() const
Definition: hps.h:6930
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:40714
Type ObjectType() const
Definition: hps.h:21129
Type ObjectType() const
Definition: hps.h:21009
Percentage of the requested font size defining the lower limit on the smallest font size that can be ...
Type ObjectType() const
Definition: hps.h:34379
Type ObjectType() const
Definition: hps.h:28073
Type ObjectType() const
Definition: hps.h:23514
Type ObjectType() const
Definition: hps.h:38270
Type ObjectType() const
Definition: hps.h:20434
MouseEvent::Action CurrentAction
The action for this MouseEvent.
Definition: hps.h:40734
Event * Clone() const
Definition: hps.h:40102
bool operator==(GlyphPoint const &in_that) const
Definition: hps.h:4971
Type ObjectType() const
Definition: hps.h:33707
Type ObjectType() const
Definition: hps.h:39605
Alignment and justification will be defined relative to a screen-facing box around the text...
Type ObjectType() const
Definition: hps.h:15325
Infinite line which extends infinitely in both directions along a vector.
intptr_t GetChannel() const
Definition: hps.h:6035
Type ObjectType() const
Definition: hps.h:8801
Algorithm
Definition: hps.h:1343
Type ObjectType() const
Definition: hps.h:30466
Type ObjectType() const
Definition: hps.h:36985
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3788
Driver
Definition: hps.h:41858
SizeUnits
Definition: hps.h:1657
StandAloneWindowEvent()
Definition: hps.h:39980
Type ObjectType() const
Definition: hps.h:35532
Type ObjectType() const
Definition: hps.h:33545
Type ObjectType() const
Definition: hps.h:11917
Type ObjectType() const
Definition: hps.h:10748
virtual bool Equals(WarningEvent const &in_that) const
Definition: hps.h:39867
MouseEvent(Action in_action, WindowPoint in_location, MouseButtons in_button=MouseButtons(), ModifierKeys in_modifier=ModifierKeys(), size_t in_click_count=0)
Definition: hps.h:40642
An InvalidObjectException is thrown when a user tries to interact with an object that either is unini...
Definition: hps.h:5401
Type ObjectType() const
Definition: hps.h:16985
Level
Definition: hps.h:1334
bool Equals(ModifierKeys const &in_that) const
Definition: hps.h:40121
void Control(bool in_state)
Definition: hps.h:40180
Type ObjectType() const
Definition: hps.h:41642
Type ObjectType() const
Definition: hps.h:17696
HPS_INLINE bool Contains(Point_3D< F > const &contained) const
Definition: hps.h:3922
UTF8 message
The warning message for this WarningEvent.
Definition: hps.h:39888
The base class of all HPS exceptions.
Definition: hps.h:5393
RegionAlignment
Definition: hps.h:1636
TouchEvent(Action in_action, size_t in_touch_count, Touch const in_touches[], ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:40349
Event * Clone() const
Definition: hps.h:40679
Type ObjectType() const
Definition: hps.h:20717
void Invalidate()
Definition: hps.h:3733
Quaternion Spline(Quaternion const &in_previous, Quaternion const &in_next) const
Definition: hps.h:4712
IOException(char const *in_info, IOResult in_result)
Definition: hps.h:5452
UpdateCompletedEvent(Time in_update_time)
Definition: hps.h:40068
Type ObjectType() const
Definition: hps.h:33033
Type ObjectType() const
Definition: hps.h:38867
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:6028
char const * GetBytes() const
Definition: hps.h:6741
virtual intptr_t Freshen() const
Definition: hps.h:40726
Type ObjectType() const
Definition: hps.h:34488
float green
Definition: hps.h:4215
Action
Definition: hps.h:40623
The vertex colors applied to faces.
SizeUnits
Definition: hps.h:1681
Type ObjectType() const
Definition: hps.h:9832
Type ObjectType() const
Definition: hps.h:26462
Type ObjectType() const
Definition: hps.h:24032
Type ObjectType() const
Definition: hps.h:23788
static void * Allocate(size_t in_bytes, bool in_clear_memory=true)
Type ObjectType() const
Definition: hps.h:37037
Type ObjectType() const
Definition: hps.h:24155
InnerPixelPoint(Point const &in_point)
Definition: hps.h:5860
Type ObjectType() const
Definition: hps.h:41902
NormalizedPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5710
Touch(TouchID in_id, WindowPoint const &in_location, size_t in_tap_count=1)
Definition: hps.h:6300
static const float NegativeInfinity
Definition: hps.h:2131
HighlightEvent(Event const &in_event)
Definition: hps.h:39723
friend bool operator==(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:6846
SizeUnits
Definition: hps.h:1462
Type ObjectType() const
Definition: hps.h:12355
Type ObjectType() const
Definition: hps.h:20175
MouseButtons CurrentButton
If the action involves a button, this is the button.
Definition: hps.h:40736
Type ObjectType() const
Definition: hps.h:10053
InnerWindowPoint(Point const &in_point)
Definition: hps.h:5811
GatheringLevel
Definition: hps.h:1737
Type ObjectType() const
Definition: hps.h:28283
Cuboid_3D(size_t count, Point_3D< F > const *points)
Definition: hps.h:3700
FrameOptions
Definition: hps.h:208
Type ObjectType() const
Definition: hps.h:34329
Space
Definition: hps.h:8154
void Alt(bool in_state)
Definition: hps.h:40184
KeyboardEvent(KeyboardEvent::Action in_action, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:40761
Type ObjectType() const
Definition: hps.h:36260
Type
Definition: hps.h:243
bool operator!=(Touch const &in_that) const
Definition: hps.h:6314
Type
Definition: hps.h:431
Type ObjectType() const
Definition: hps.h:41181
Type ObjectType() const
Definition: hps.h:42434
Type ObjectType() const
Definition: hps.h:37237
Type ObjectType() const
Definition: hps.h:42323
Type ObjectType() const
Definition: hps.h:32764
WorldPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5610
Type ObjectType() const
Definition: hps.h:8991
Type ObjectType() const
Definition: hps.h:42520
friend bool operator==(char const *in_left, UTF8 const &in_right)
Definition: hps.h:6828
void SetTouches(size_t in_touch_count, Touch const in_touches[])
Definition: hps.h:40434
Event * Clone() const
Definition: hps.h:40374
virtual bool Equals(ErrorEvent const &in_that) const
Definition: hps.h:39938
Event * Clone() const
Definition: hps.h:40006
size_t GetLength() const
Definition: hps.h:6726
Type ObjectType() const
Definition: hps.h:20521
Type ObjectType() const
Definition: hps.h:26020
Type
Definition: hps.h:1119
Type ObjectType() const
Definition: hps.h:8909
bool None() const
Definition: hps.h:40144
size_t ClickCount
The number of clicks received.
Definition: hps.h:40738
virtual intptr_t Freshen() const
Definition: hps.h:6032
void Reset()
Definition: hps.h:6721
Type ObjectType() const
Definition: hps.h:36771
Type ObjectType() const
Definition: hps.h:23169
Type ObjectType() const
Definition: hps.h:38971
SizeUnits
Definition: hps.h:1590
Event * Clone() const
Definition: hps.h:39929
MouseEvent(Event const &in_event)
Definition: hps.h:40657
virtual bool Empty() const
Definition: hps.h:5493
Join
Definition: hps.h:1812
HPS_INLINE void Merge(Sphere_3D< F > const &sphere)
Definition: hps.h:3844
Modifier
Definition: hps.h:1849
TouchEvent(Action in_action, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:40332
HighlightEvent()
Definition: hps.h:39707
virtual Type ObjectType() const
Definition: hps.h:5489
Type ObjectType() const
Definition: hps.h:13367
TouchEvent::Action CurrentAction
The action for the touches of this TouchEvent.
Definition: hps.h:40446
Type
Definition: hps.h:566
virtual intptr_t Freshen() const
Definition: hps.h:39690
Background
Definition: hps.h:224
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid) const
Definition: hps.h:3777
static ModifierKeys KeyControl()
Definition: hps.h:40227
Type ObjectType() const
Definition: hps.h:17908
Type ObjectType() const
Definition: hps.h:34742
ScreenRangePoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5758
Type ObjectType() const
Definition: hps.h:38763
StandAloneWindowEvent(Action in_action)
Definition: hps.h:39985
Mode
Definition: hps.h:1702
Event * Clone() const
Definition: hps.h:40074
HPS_INLINE Cuboid_3D & Expand(F border)
Definition: hps.h:3981
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3812
Type
Definition: hps.h:869
HPS_INLINE Vector_3D< F > Diagonal() const
Definition: hps.h:3765
Type ObjectType() const
Definition: hps.h:11826
Type ObjectType() const
Definition: hps.h:31523
Type ObjectType() const
Definition: hps.h:36869
Type ObjectType() const
Definition: hps.h:41288
Type ObjectType() const
Definition: hps.h:41037
HPS_INLINE void Generate_Cuboid_Points(Point_3D< F > *points) const
Definition: hps.h:3751
Type ObjectType() const
Definition: hps.h:36044
Type ObjectType() const
Definition: hps.h:11975
Type ObjectType() const
Definition: hps.h:17451
Mode
Definition: hps.h:1755
Event * Clone() const
Definition: hps.h:40808
Tiling
Definition: hps.h:972
HPS_INLINE Cuboid_3D & Union(Cuboid_3D const &cuboid)
Definition: hps.h:3966
WindowPoint(Point const &in_point)
Definition: hps.h:5910
Transform
Definition: hps.h:1545
Type ObjectType() const
Definition: hps.h:36358
A unitless linear scaling factor. A value of 2.0 will cause edges to be rendered twice as thick...
Grid composed of quadrilaterals.
Type ObjectType() const
Definition: hps.h:37696
ModifierKeys()
Definition: hps.h:40116
Preference
Definition: hps.h:1570
Type ObjectType() const
Definition: hps.h:24707
Capping
Definition: hps.h:511
Type ObjectType() const
Definition: hps.h:34560
TouchEvent()
Definition: hps.h:40326
Interpolation
Definition: hps.h:988
Type ObjectType() const
Definition: hps.h:19550
WarningEvent(char const *in_message)
Definition: hps.h:39831
Type ObjectType() const
Definition: hps.h:20321
Modifiers
Definition: hps.h:40241
Component
Definition: hps.h:503
Type ObjectType() const
Definition: hps.h:35050
Type ObjectType() const
Definition: hps.h:6417
Type ObjectType() const
Definition: hps.h:21991
HPS_INLINE Cuboid_3D & Intersect(Cuboid_3D const &cuboid)
Definition: hps.h:3951
Type ObjectType() const
Definition: hps.h:41750
Type ObjectType() const
Definition: hps.h:21781
Format
Definition: hps.h:36222
WarningEvent()
Definition: hps.h:39827
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:39684
Touch()
Definition: hps.h:6294
Component
Definition: hps.h:393
A unitless linear scaling factor. A value of 2.0 will cause lines to be rendered twice as thick...
float red
Definition: hps.h:4214
ClipSpace
Definition: hps.h:1298
Control & operator=(Control &&in_that)
Definition: hps.h:5546
WarningEvent(char const *in_message, Info::Code in_code)
Definition: hps.h:39836
Type ObjectType() const
Definition: hps.h:13472
SizeUnits
Definition: hps.h:41707
virtual void Reset()
Definition: hps.h:39628
Type ObjectType() const
Definition: hps.h:10863
bool Meta() const
Definition: hps.h:40160
HPS_INLINE Cuboid_3D & Contract(F border)
Definition: hps.h:3993
TimerTickEvent()
Definition: hps.h:39656
Type ObjectType() const
Definition: hps.h:21464
RenderingAlgorithm
Definition: hps.h:260
EmergencyHandler()
Definition: hps.h:39171
CameraPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5660
TouchID ID
TouchID for this Touch.
Definition: hps.h:6319
Type ObjectType() const
Definition: hps.h:10429
Type ObjectType() const
Definition: hps.h:32465
HandednessOptimization
Definition: hps.h:354
Projection
Definition: hps.h:1380
Control(Control &&in_that)
Definition: hps.h:5541
bool Control() const
Definition: hps.h:40152
Type ObjectType() const
Definition: hps.h:33928
Overlay
Definition: hps.h:1270
Type ObjectType() const
Definition: hps.h:37105
Status
Definition: hps.h:6008
Type ObjectType() const
Definition: hps.h:34058
Type ObjectType() const
Definition: hps.h:6499
float WheelDelta
If the action involves the mouse wheel, this is the amount the wheel moved. It is positive if the mou...
Definition: hps.h:40737
Type ObjectType() const
Definition: hps.h:41124