hc_proto.h File Reference

Go to the source code of this file.

Functions

void HC_Abort_Program (char const *message)
 Function to create a map linking PrcIds and A3DEntities. More...
 
void HC_Append_Modelling_Matrix (float const array[])
 Allows direct manipulation of the matrix transform applied against all picture elements and subsegments in a segment. More...
 
void HC_Append_Texture_Matrix (float const array[])
 Allows direct manipulation of the matrix transform applied against all shell and mesh (u, v, w) vertex parameters and subsegments in a segment. More...
 
void HC_Apply_Attribute_Filter (Key key, char const *filter)
 
void HC_Begin_Alias_Search (void)
 These routines recall the name of each alias. More...
 
int HC_Begin_Buffered_Selection (char const *start_name, double left, double right, double bottom, double top, char const *options)
 
void HC_Begin_Callback_Name_Search (void)
 Finds the names of all previously defined callback routines. More...
 
void HC_Begin_Color_Name_Search (void)
 These routines recall all the defined color names. More...
 
void HC_Begin_Contents_Search (char const *segment, char const *filter)
 These routines are used to "dump" the contents of a segment or certain types of geometry. More...
 
void HC_Begin_Decimate_Shell (Key key)
 
void HC_Begin_Error_Handler_Search ()
 Finds all currently defined error handlers. More...
 
void HC_Begin_Exit_Handler_Search ()
 Finds all the currently defined exit handlers. More...
 
void HC_Begin_Font_Search (char const *display, char const *filter)
 Finds the names of all the fonts available on a particular device. More...
 
void HC_Begin_Glyph_Search (void)
 These routines recall all the defined glyph names. More...
 
void HC_Begin_Highlight_Search (int count, Key const keys[], char const *list)
 Searches for all highlights. More...
 
void HC_Begin_Line_Style_Search (void)
 These routines recall all the defined line style names. More...
 
void HC_Begin_Local_Texture_Search (void)
 Begins a texture search on the currently open segment. More...
 
void HC_Begin_Named_Style_Search (void)
 Used to locate all named styles previously defined by Define_Named_Style(). More...
 
void HC_Begin_Open_Item_Search (void)
 Returns the keys to all currently open segments or geometric primitives. More...
 
void HC_Begin_Open_Segment_Search (void)
 Returns the pathnames of all open segments. More...
 
void HC_Begin_Segment_Search (char const *segspec)
 Finds all segments matching a search specification. More...
 
void HC_Begin_Shader_Search (void)
 These routines recall the name of each shader. More...
 
void HC_Begin_Shape_Search (void)
 
void HC_Begin_Shell_Selection (void)
 Begins a mode of operation whereby calls to Compute_Selection_By_Shell cache intermediate data in order to speed up successive computations. More...
 
void HC_Begin_Texture_Search (void)
 These routines recall all the defined texture names. More...
 
void HC_Bring_To_Front (char const *segment)
 
void HC_Bring_To_Front_By_Key (Key key)
 Similar to Bring_To_Front(), but operates on an object referenced by an HC_KEY. More...
 
bool HC_Check_Double_Precision (Key key, char const *options)
 
void HC_Close_Edge (void)
 Closes the session that began with an opening call to Open_Edge(). More...
 
void HC_Close_Face (void)
 Closes the session that began with an opening call to Open_Face(). More...
 
void HC_Close_Geometry (void)
 Closes the session that began with an opening call to Open_Geometry(). More...
 
void HC_Close_LOD (void)
 Closes the session that began with an opening call to Open_LOD(). More...
 
void HC_Close_Region (void)
 Closes the session that began with an opening call to Open_Region(). More...
 
void HC_Close_Segment (void)
 Closes the currently open segment. More...
 
void HC_Close_Trim (void)
 Closes the session that began with an opening call to Open_Trim(). More...
 
void HC_Close_Vertex (void)
 Closes the session that began with an opening call to Open_Vertex(). More...
 
int HC_Collect_Area_Samples (double left, double right, double bottom, double top)
 Gathers all objects that have been drawn in the selection area, and prepares them to be returned to the user. More...
 
void HC_Commit_Proxy (Key key, const char *options)
 
Key HC_Compute_Boolean_Shell (int target_pcount, Point const target_points[], Vector const target_normals[], int target_flist_length, int const target_face_list[], int tool_pcount, Point const tool_points[], Vector const tool_normals[], int tool_flist_length, int const tool_face_list[], char const *options)
 Performs one of several boolean operations on two shells. IMPORTANT NOTE: This routine is primarily meant to provide a reasonable visual representation of the boolean result, and has limititions covered in the NOTES section which prevent this routine from being relied on to produce manifold shell results. The routine is provided AS-IS. More...
 
Key HC_Compute_Boolean_Shell2 (int in_pt_count_target, Point const in_pts_target[], Vector const in_normals_target[], int in_flist_len_target, int const in_flist_target[], int in_pt_count_tool, Point const in_pts_tool[], Vector const in_normals_tool[], int in_flist_len_tool, int const in_flist_tool[], char const *option_string, RGB const *in_color1, RGB const *in_color2, unsigned char const in_vis1[], unsigned char const in_vis2[])
 
Key HC_Compute_Capping_Shell (int shell_count, Key const shell_list[], float const plane[])
 Creates a shell in the currently open segment that contains an exact copy of the cap geometry that a plane would make when applied to the provided shells. More...
 
bool HC_Compute_Circumcuboid (char const *segment, Point *min, Point *max)
 Returns points defining a cuboid that circumscribes the geometry within a segment. More...
 
bool HC_Compute_Circumcuboid_By_Key (Key key, Point *min, Point *max)
 Similar to Compute_Circumcuboid(), but operates on an object referenced by an HC_KEY. More...
 
bool HC_Compute_Circumsphere (char const *segment, Point *center, float *radius)
 Returns points defining a sphere that circumscribes the geometry within a segment. More...
 
bool HC_Compute_Circumsphere_By_Key (Key key, Point *center, float *radius)
 Similar to Compute_Circumsphere(), but operates on an object referenced by an HC_KEY. More...
 
bool HC_Compute_Color (char const *name, char const *out_type, RGB *out_value)
 Allows access to the color-conversion routines used internally in HOOPS. More...
 
bool HC_Compute_Color_By_Value (char const *in_type, RGB const *in_value, char const *out_type, RGB *out_value)
 Similar to Compute_Color(), but operates with a color values rather than names or map indices. More...
 
void HC_Compute_Convex_Hull (int pcount, Point const points[], int *fcount, int face_list[])
 Given a set of points, determines the set of faces that minimally bind all the points. More...
 
bool HC_Compute_Coordinates (char const *segment, char const *in_system, Point const *in_position, char const *out_system, Point *out_position)
 Converts positions back and forth among the various coordinate systems. More...
 
bool HC_Compute_Coordinates_By_Path (int count, Key const keys[], char const *in_system, Point const *in_position, char const *out_system, Point *out_position)
 Similar to Compute_Coordinates(), but concatenates the matrices along a segment path rather than the currently open segment. More...
 
void HC_Compute_Cross_Product (Vector const *vector1, Vector const *vector2, Vector *out_vector)
 Computes the cross product of two vectors. More...
 
double HC_Compute_Dot_Product (Vector const *vector1, Vector const *vector2)
 Takes two 3-D vectors and computes their scalar dot-product.
More...
 
void HC_Compute_Face_Neighborhood (Key shell_key, int face_index, int *count, int neighbors[])
 Returns the indices of the faces within a shell that share an edge with the specified face. More...
 
void HC_Compute_Face_Neighborhood_Si (Key shell_key, int face_index, int *count)
 Returns the number of faces within a shell that share an edge with the specified face. More...
 
void HC_Compute_Identity_Matrix (float out_matrix[])
 
int HC_Compute_Intersect_Polyline (int pcount1, Point const points1[], int flist_length3, int const face_list1[], int pcount2, Point const points2[], int flist_length2, int const face_list2[], int *polyline_count, int polyline_lengths[], int *polyline_points_count, Point polyline_points[])
 Calculates the polyline of intersection between the faces of one shell and those of another. If the two shells do not exist, this function returns false. More...
 
void HC_Compute_Matrix_Adjoint (float const matrix[], float out_matrix[])
 
double HC_Compute_Matrix_Determinant (float const matrix[])
 
bool HC_Compute_Matrix_Inverse (float const matrix[], float out_matrix[])
 
void HC_Compute_Matrix_Product (float const matrix1[], float const matrix2[], float out_matrix[])
 
void HC_Compute_Minimized_Shell (int in_point_count, Point const in_points[], int in_face_list_length, int const in_face_list[], char const *option_string, int *out_point_count, Point out_points[], int *out_face_list_length, int out_face_list[], int vertex_mapping[], int face_mapping[])
 
bool HC_Compute_Normalized_Matrix (float const matrix[], float out_matrix[])
 
bool HC_Compute_Normalized_Vector (Vector const *vector, Vector *out_vector)
 
void HC_Compute_Offaxis_Rotation (double x, double y, double z, double theta, float out_matrix[])
 
void HC_Compute_Offcenter_Rotation (double alpha, double beta, double theta, double x, double y, double z, float out_matrix[])
 
void HC_Compute_Optimized_Shell (int pcount, Point const points[], Vector const normals[], int flist_length, int const face_list[], char const *options, int *new_pcount, Point new_points[], int *new_flist_length, int new_face_list[], int point_mapping_list[], int face_mapping_list[])
 Performs one of several computations to prepare shell data for improved rendering performance. The default computation is to remove redundant vertices and degenerate faces. More...
 
void HC_Compute_Pline_From_Crv_Size (Key key, char const *options, int *pcount)
 Calculates and returns a the size of the tesselated curve, for use in a later call to Compute_Polyline_From_Curve. More...
 
bool HC_Compute_Point_Inside_Shell (Point const *test_point, int point_count, Point const points[], int face_list_length, int const face_list[])
 Tests whether a given point is inside a shell, which is assumed to be a closed surface. More...
 
bool HC_Compute_Point_On_Shell (Point const *test_point, double tolerance, int point_count, Point const points[], int face_list_length, int const face_list[])
 Tests whether a given point is on the surface of a shell. More...
 
int HC_Compute_Points_Distance_F_S2 (int test_pcount, Point const test_pt[], double tolerance, int point_count1, Point const points1[], int face_list_length3, int const face_list1[], const char *options, float results[], int face_results[])
 
int HC_Compute_Points_Distance_F_Sh (int test_point_count, Point const test_points[], double tolerance, int point_count, Point const points[], int face_list_length, int const face_list[], const char *options, float results[])
 Calculates the closest distance between a given set of points and a shell. More...
 
void HC_Compute_Points_Inside_Shell (int test_point_count, Point const test_points[], Vector const test_points_vectors[], int point_count, Point const points[], int face_list_length, int const face_list[], char const *options, int results[])
 Tests whether a given set of points reside within, on, or outside the volume defined by a shell. More...
 
int HC_Compute_Points_On_Shell (int test_point_count, Point const test_points[], double tolerance, int point_count, Point const points[], int face_list_length, int const face_list[], int results[])
 Tests, within a certain tolerance, whether a given set of points reside on the surface of a shell. More...
 
bool HC_Compute_Polygon_Normal (int count, Point const points[], char const *hand, Vector *out_vector)
 
bool HC_Compute_Polygon_Plane (int count, Point const points[], char const *hand, Plane *out_plane)
 
bool HC_Compute_Polyline_From_Curve (Key key, char const *options, int *pcount, Point points[])
 Calculates and returns a tesselated version of a specified curve. More...
 
void HC_Compute_Rotation_Matrix (double alpha, double beta, double theta, float out_matrix[])
 
void HC_Compute_Scale_Matrix (double x, double y, double z, float out_matrix[])
 
void HC_Compute_Screen_Extent (char const *segment, char const *options, float *left, float *right, float *bottom, float *top)
 Calculates a screen-space box that fully encloses the segment referred to by the supplied segment path. More...
 
void HC_Compute_Screen_Extent_By_Key (Key segKey, char const *options, float *left, float *right, float *bottom, float *top)
 Similar to Compute_Screen_Extent(), but operates on an object referenced by an HC_KEY. More...
 
void HC_Compute_Screen_Extent_By_Pat (int count, Key const keys[], char const *options, float *left, float *right, float *bottom, float *top)
 Similar to Compute_Screen_Extent(), but concatenates the matrices along a segment path rather than the currently open segment. More...
 
int HC_Compute_Selection (char const *display, char const *start_seg, char const *action, double x, double y)
 Forces the explicit computation and generation of selection events. More...
 
int HC_Compute_Selection_By_Area (char const *display, char const *start_seg, char const *action, double left, double right, double bottom, double top)
 Similar to Compute_Selection(), but operates on a rectangular area. More...
 
int HC_Compute_Selection_By_Key (char const *action, char const *start_seg, Key key, float const matrix[])
 Forces a selection event between a supplied shell, as referenced by a key, and a specified portion of a segment tree. More...
 
int HC_Compute_Selection_By_Polygon (char const *display, char const *start_seg, char const *action, int pcount, Point const points[])
 Similar to Compute_Selection(), but operates on a polygonal area. More...
 
int HC_Compute_Selection_By_Polylin (char const *display, char const *start_seg, char const *action, int pcount, Point const points[])
 Similar to Compute_Selection(), but operates on polyline intersections. More...
 
int HC_Compute_Selection_By_Ray (char const *action, char const *start_seg, Point const *start_point, Vector const *direction)
 Forces a selection event between a supplied ray and all polyhedron-based objects within a specified portion of a segment tree. More...
 
int HC_Compute_Selection_By_Sh_W_Op (char const *action, char const *start_seg, int point_count, Point const points[], int face_list_length, int const face_list[], char const *options)
 Allows users to set additional criteria that should be considered when performing a selection event between the supplied shell and a specified portion of a segment tree. More...
 
int HC_Compute_Selection_By_Shell (char const *action, char const *start_seg, int point_count, Point const points[], int face_list_length, int const face_list[])
 Forces a selection event between the supplied shell and a specified portion of a segment tree. More...
 
int HC_Compute_Selection_By_Swept_2 (char const *action, char const *start_seg, Key shellkey, int sweepcount, float const matrices[], char const *options, float bounding_box[])
 Similar to Compute_Selection_By_Swept_Shell(), but takes an extra parameter which receives a bounding box of the collision volume. More...
 
int HC_Compute_Selection_By_Swept_S (char const *action, char const *start_seg, Key shellkey, int number_of_sweeps, float const matrices[], char const *options)
 Forces a selection event between the volume created by a shell moving along a path and a specified portion of a segment tree. More...
 
int HC_Compute_Selection_By_Volume (char const *display, char const *start_seg, char const *action, double left, double right, double bottom, double top, double hither, double yon)
 Similar to Compute_Selection(), but operates on a cuboid volume. More...
 
float HC_Compute_Selection_Dist_By_Sh (char const *action, char const *start_segment, int pcount, Point const points[], int flist_length, int const faces[], const char *options)
 Computes the closest distance between the specified shell and another geometric primitive within a HOOPS segment tree. More...
 
void HC_Compute_Shell_Enclosure (int point_count1, Point const points1[], int face_list_length3, int const face_list1[], int point_count2, Point const points2[], int face_list_length2, int const face_list2[], char *result)
 Classifies the relationship between the first shell and the second: "in", "out", and "clash". More...
 
Key HC_Compute_Subshell (Key source, int keep_fcount, const int keep_faces[], int keep_pcount, const int keep_pts1[], const int keep_pts2[], int face_map[], int pts_map[])
 Creates a subshell from the source shell or mesh in the currently open segment and subject to the specified criteria. More...
 
Key HC_Compute_Swept_Shell (Key shellkey, Vector const *direction_in, Key *front_key, Key *back_key, Key *side_key, char const *options)
 Sweeps an existing shell along a defined path to create new shells that containes the swept volume. More...
 
void HC_Compute_Swept_Shell_Along_P (Key shellkey, int number_of_sweeps, float const matrices[], char const *options)
 Creates a new set of shells by sweeping a shell along a path. More...
 
void HC_Compute_Text16_From_Text (char const *intext, char const *encoding, int *outcount, unsigned short outtext16[])
 Converts from integer-array representations of 16-bit characters to string representations. More...
 
bool HC_Compute_Text_Extent (char const *segment, char const *text, float *xsize, float *ysize)
 Finds out what the dimensions are for a given text string. More...
 
bool HC_Compute_Text_Extent_By_Key (Key key, float *xfrac, float *yfrac)
 Similar to Compute_Text_Extent(), but operates on text referenced by an HC_KEY. More...
 
bool HC_Compute_Text_Extent_By_Path (int count, Key const keys[], char const *text, float *xfrac, float *yfrac)
 Similar to Compute_Text_Extent(), but concatenates the matrices along a segment path rather than the currently open segment. More...
 
bool HC_Compute_Text_Extent_Enc_Path (int count, Key const keys[], char const *encoding, void const *text, float *xfrac, float *yfrac)
 Similar to Compute_Text_Extent_By_Path(), but operates on encoded text rather that Latin1 text. More...
 
bool HC_Compute_Text_Extent_With_Enc (char const *segment, char const *encoding, void const *text, float *xfrac, float *yfrac)
 Similar to Compute_Text_Extent() but operates on encoded text rather than Latin1 text. More...
 
void HC_Compute_Text_From_Text16 (int incount, unsigned short const intext16[], char const *encoding, char *outtext)
 Converts from string to integer-array representations of 16-bit characters. More...
 
bool HC_Compute_Text_Metrics (int count, Key const *keys, char const *encoding, void const *text, char const *options, int *size, float values[])
 
bool HC_Compute_Text_Metrics_Size (int count, Key const *keys, char const *encoding, void const *text, char const *options, int *size)
 
void HC_Compute_Text_Outline (char const *segment, char const *text, int *pcount, Point points[], int *flist_length, int face_list[])
 Calculates a polyhedral representation of the given text glyphs. More...
 
void HC_Compute_Text_Outline_By_Key (Key key, int *pcount, Point points[], int *flist_length, int face_list[])
 Similar to Compute_Text_Outline(), but operates on an object referenced by an HC_KEY. More...
 
void HC_Compute_Text_Outline_By_Path (int count, Key const keys[], char const *text, int *pcount, Point points[], int *flist_length, int face_list[])
 Similar to Compute_Text_Outline(), but concatenates the matrices along a segment path rather than the specified segment. More...
 
void HC_Compute_Text_Outline_Size (char const *segment, char const *text, int *pcount, int *flist_length)
 Finds out the size of the text outline. This is useful for determining the size of the points array needed to store incoming data from Compute_Text_Outline(). More...
 
void HC_Compute_Text_Outline_Size_By (Key key, int *pcount, int *flist_length)
 Similar to Compute_Text_Outline_Size(), but enables the user to pass in a key for the desired text object. More...
 
void HC_Compute_Text_Outline_Size_Pa (int count, Key const keys[], char const *text, int *pcount, int *flist_length)
 Similar to Compute_Text_Outline(), but concatenates the matrices along a segment path rather than the specified segment. More...
 
void HC_Compute_Text_Outline_Size_Wi (char const *segment, char const *encoding, void const *etext, int *pcount, int *flist_length)
 Similar to Compute_Text_Outline_Size(), but operates on encoded text rather than Latin1 text. More...
 
void HC_Compute_Text_Outline_With_En (char const *segment, char const *encoding, void const *etext, int *pcount, Point points[], int *flist_length, int face_list[])
 Similar to Compute_Text_Outline(), but operates on encoded text rather than Latin1 text. More...
 
bool HC_Compute_Transform (char const *segment, char const *in_system, char const *out_system, float matrix[])
 Converts positions back and forth among the various coordinate systems. More...
 
bool HC_Compute_Transform_By_Path (int count, Key const keys[], char const *in_system, char const *out_system, float matrix[])
 Similar to Compute_Transform(), but concatenates the matrices along a segment path rather than the currently open segment. More...
 
bool HC_Compute_Transformed_Plane (Plane const *plane, float const matrix[], Plane *out_plane)
 Applies a user-defined transform to a single plane. More...
 
bool HC_Compute_Transformed_Planes (int count, Plane const planes[], float const matrix[], Plane out_planes[])
 Applies a user-defined transform to a group of planes. More...
 
void HC_Compute_Transformed_Points (int count, Point const points[], float const matrix[], Point out_points[])
 Applies a user-specified transform to any number of points. More...
 
void HC_Compute_Translation_Matrix (double x, double y, double z, float out_matrix[])
 
void HC_Compute_Triangulation (Point const points[], int flist_length, int const face_list[], int *tlist_length, int triangle_list[])
 Provides a triangle based tesselation of a HOOPS Shell which can contain facets which have more than 3 edges. More...
 
void HC_Compute_Triangulation_Size (Point const points[], int flist_length, int const face_list[], int *tlist_length)
 Similar to Compute_Triangulation(), but returns triangle list size for use in allocating space for triangle_list. More...
 
double HC_Compute_Vector_Angle (Vector const *vector, Vector const *vector2)
 
double HC_Compute_Vector_Length (Vector const *vector)
 
Key HC_Conditional_Include (char const *include, char const *condition)
 
Key HC_Conditional_Include_By_Key (Key seg_key, char const *condition)
 Similar to Conditional_Include(), but accepts a key rather than a pathname to identify the segment to be included. More...
 
Key HC_Conditional_Include_Key_By_Ke (Key key, char const *condition, Key includer_key)
 Similar to Conditional_Include_By_Key(), but inserts the include into the segment associated with the passed key. More...
 
Key HC_Conditional_Named_Style (char const *style_name, char const *condition)
 
Key HC_Conditional_Named_Style_By_Key (Key target_segment, char const *style_name, char const *condition)
 
Key HC_Conditional_Reference (char const *segname, char const *condition)
 Directs HOOPS to create a reference to some geometry when processing a segment, subject to meeting the conditions set on the segment in a previous call to Set_Conditions(). More...
 
Key HC_Conditional_Reference_By_Key (Key geom_key, char const *condition)
 Similar to Conditional_Reference(), but references a particular item, rather than a segment and all of its contents. More...
 
Key HC_Conditional_Style (char const *style, char const *conditions)
 Similar to Style_Segment(), but uses a list of conditions that must be satisfied in order for the inclusion to apply. More...
 
Key HC_Conditional_Style_By_Key (Key seg_key, char const *conditions)
 Similar to Conditional_Style(), but accepts a key rather than a pathname to identify the segment to be styled. More...
 
void HC_Control_Update (char const *segment, char const *options)
 Controls the amount of redrawing for the subsequent update. More...
 
void HC_Control_Update_Area (char const *segment, double left, double right, double bottom, double top, char const *options)
 Similar to Control_Update(), but operates on the objects within a defined window area. More...
 
void HC_Control_Update_Area_By_Key (Key key, double left, double right, double bottom, double top, char const *options)
 Similar to Control_Update_Area(), but operates on an object referenced by an HC_KEY. More...
 
void HC_Control_Update_By_Key (Key key, char const *options)
 Similar to Control_Update(), but operates on an object referenced by an HC_KEY. More...
 
bool HC_Convert_Precision (Key key, char const *options)
 
Key HC_Copy_Geometry (Key key, char const *segment)
 Copies the geometry referred to by key to the given segment. More...
 
Key HC_Copy_Segment (char const *old_seg_name, char const *new_seg_name)
 Completely duplicates a segment. More...
 
Key HC_Copy_Segment_With_Mapping (char const *source_seg, char const *destination, int count, Key const interesting_keys[], Key copied_keys[])
 Allows the user to provide a list of keys from the segment to be copied, and returns a list of corresponding keys from the resulting copied segment. More...
 
Key HC_Create_Proxy (Key key)
 
Key HC_Create_Segment (char const *segment)
 Brings a segment into existence without opening it. More...
 
Key HC_Create_Segment_Key_By_Key (Key parent_segment, char const *child_segment_name)
 Similar to Create_Segment(), but inserts a new segment into the segment associated with the passed key. More...
 
void HC_Create_Trim_Collection (void)
 Creates a trim collection object without opening it or otherwise defining it. More...
 
void HC_DAppend_Modelling_Matrix (double const array[])
 Similar to Append_Modelling_Matrix(), but accepts double-precision data. More...
 
Key HC_DCompute_Boolean_Shell (int in_pt_count_target, DPoint const in_pts_target[], Vector const in_normals_target[], int in_flist_len_target, int const in_flist_target[], int in_pt_count_tool, DPoint const in_pts_tool[], Vector const in_normals_tool[], int in_flist_len_tool, int const in_flist_tool[], char const *option_string, RGB const *in_color1, RGB const *in_color2, unsigned char const in_vis1[], unsigned char const in_vis2[])
 Similar to Compute_Boolean_Shell(), but accepts and returns double-precision values. More...
 
bool HC_DCompute_Circumcuboid (char const *segment, DPoint *min, DPoint *max)
 Similar to Compute_Circumcuboid, but accepts double-precision parameters. More...
 
bool HC_DCompute_Circumcuboid_By_Key (Key key, DPoint *min, DPoint *max)
 Similar to Compute_Circumcuboid_By_Key(), but operates on double-precision data. More...
 
bool HC_DCompute_Circumsphere (char const *segment, DPoint *center, double *radius)
 Similar to Compute_Circumsphere(), but operates on double-precision data. More...
 
bool HC_DCompute_Circumsphere_By_Key (Key key, DPoint *center, double *radius)
 Similar to Compute_Circumsphere_By_Key(), but operates on double-precision data. More...
 
bool HC_DCompute_Coordinates (char const *segment, char const *in_system, DPoint const *in_position, char const *out_system, DPoint *out_position)
 Similar to Compute_Coordinates(), but returns double-precision values for position. More...
 
bool HC_DCompute_Coordinates_By_Path (int count, Key const keys[], char const *in_system, DPoint const *in_position, char const *out_system, DPoint *out_position)
 Similar to Compute_Coordinates_By_Path(), but operates on double-precision data. More...
 
void HC_DCompute_Cross_Product (DVector const *vector1, DVector const *vector2, DVector *out_vector)
 Similar to Compute_Cross_Product, but operates on double-precision data. More...
 
double HC_DCompute_Dot_Product (DVector const *vector1, DVector const *vector2)
 Similar to Compute_Dot_Product, but operates on double-precision data. More...
 
void HC_DCompute_Identity_Matrix (double out_matrix[])
 Similar to Compute_Identity_Matrix(), but operates on double-precision data. More...
 
int HC_DCompute_Intersect_Polyline (int pcount1, DPoint const points1[], int flist_length3, int const face_list1[], int pcount2, DPoint const points2[], int flist_length2, int const face_list2[], int *polyline_count, int polyline_lengths[], int *polyline_points_count, DPoint polyline_points[])
 Similar to Compute_Intersect_Polyline(), but operates on double-precision data. More...
 
void HC_DCompute_Matrix_Adjoint (double const matrix[], double out_matrix[])
 Similar to Compute_Matrix_Adjoint(), but operates on double-precision data. More...
 
double HC_DCompute_Matrix_Determinant (double const matrix[])
 Similar to Compute_Matrix_Determinant(), but operates on double-precision data. More...
 
bool HC_DCompute_Matrix_Inverse (double const matrix[], double out_matrix[])
 Similar to Compute_Matrix_Inverse(), but operates on double-precision data. More...
 
void HC_DCompute_Matrix_Product (double const matrix1[], double const matrix2[], double out_matrix[])
 Similar to Compute_Matrix_Product(), but operates on double-precision data. More...
 
bool HC_DCompute_Normalized_Matrix (double const matrix[], double out_matrix[])
 Similar to Compute_Normalized_Matrix, but operates on double-precision data. More...
 
bool HC_DCompute_Normalized_Vector (DVector const *vector, DVector *out_vector)
 
void HC_DCompute_Offaxis_Rotation (double x, double y, double z, double theta, double out_matrix[])
 Similar to Compute_Offaxis_Rotation, but operates on double-precision data. More...
 
void HC_DCompute_Offcenter_Rotation (double alpha, double beta, double theta, double x, double y, double z, double out_matrix[])
 Similar to Compute_Offcenter_Rotation, but operates on double-precision data. More...
 
void HC_DCompute_Optimized_Shell (int pcount, DPoint const points[], Vector const normals[], int flist_length, int const face_list[], char const *options, int *new_pcount, DPoint new_points[], int *new_flist_length, int new_face_list[], int point_mapping_list[], int face_mapping_list[])
 Similar to Compute_Optimized_Shell(), but computes and returns double-precision values. More...
 
void HC_DCompute_Pline_From_Crv_Size (Key key, char const *options, int *pcount)
 Similar to Compute_Polyline_From_Curve, but operates on double-precision data. More...
 
bool HC_DCompute_Point_Inside_Shell (DPoint const *test_point, int point_count, DPoint const points[], int face_list_length, int const face_list[])
 Similar to Compute_Point_Inside_Shell, but operates on double-precision data. More...
 
bool HC_DCompute_Point_On_Shell (DPoint const *test_point, double tolerance, int point_count, DPoint const points[], int face_list_length, int const face_list[])
 Similar to Compute_Point_On_Shell, but operates on double-precision data. More...
 
int HC_DCompute_Points_Distance_F_S (int test_point_count, DPoint const test_points[], double tolerance, int point_count, DPoint const points[], int face_list_length, int const face_list[], const char *options, double results[])
 Similar to Compute_Points_Distance_From_Shell, but operates on double-precision data. More...
 
int HC_DCompute_Points_Distance_FS2 (int test_pcount, DPoint const test_pt[], double tolerance, int point_count1, DPoint const points1[], int face_list_length3, int const face_list1[], const char *options, double results[], int face_results[])
 
void HC_DCompute_Points_Inside_Shell (int test_point_count, DPoint const test_points[], DVector const test_points_vectors[], int point_count, DPoint const points[], int face_list_length, int const face_list[], char const *options, int results[])
 
int HC_DCompute_Points_On_Shell (int test_point_count, DPoint const test_points[], double tolerance, int point_count, DPoint const points[], int face_list_length, int const face_list[], int results[])
 Similar to Compute_Points_On_Shell, but operates on double-precision data. More...
 
bool HC_DCompute_Polygon_Normal (int count, DPoint const points[], char const *hand, DVector *out_vector)
 Similar to Compute_Polygon_Normal, but operates on double-precision data. More...
 
bool HC_DCompute_Polygon_Plane (int count, DPoint const points[], char const *hand, DPlane *out_plane)
 Similar to Compute_Polygon_Plane, but operates on double-precision data. More...
 
bool HC_DCompute_Polyline_From_Curve (Key key, char const *options, int *pcount, DPoint points[])
 Similar to Compute_Polyline_From_Curve(), but operates on double-precision data. More...
 
void HC_DCompute_Rotation_Matrix (double alpha, double beta, double theta, double out_matrix[])
 Similar to Compute_Rotation_Matrix(), but operates on double-precision data. More...
 
void HC_DCompute_Scale_Matrix (double x, double y, double z, double out_matrix[])
 Similar to Compute_Scale_Matrix, but operates on double-precision data. More...
 
int HC_DCompute_Selection_By_Key (char const *action, char const *start_seg, Key key, double const matrix[])
 
int HC_DCompute_Selection_By_Ray (char const *action, char const *start_seg, DPoint const *start_point, DVector const *direction)
 Similar to Compute_Selection_By_Ray(), but operates on double-precision data. More...
 
int HC_DCompute_Selection_By_Sh_W_O (char const *action, char const *start_seg, int point_count, DPoint const points[], int face_list_length, int const face_list[], char const *options)
 Similar to Compute_Selection_By_Shell_With_Options(), but operates on double-precision data. More...
 
int HC_DCompute_Selection_By_Shell (char const *action, char const *start_seg, int point_count, DPoint const points[], int face_list_length, int const face_list[])
 Similar to Compute_Selection_By_Shell(), but operates on double-precision data. More...
 
int HC_DCompute_Selection_By_Swpt_2 (char const *action, char const *start_seg, Key shellkey, int sweepcount, double const matrices[], char const *options, double bounding_box[])
 Similar to Compute_Selection_By_Swept_Shell2(), but operates on double-precision data. More...
 
int HC_DCompute_Selection_By_Swpt_S (char const *action, char const *start_seg, Key shellkey, int number_of_sweeps, double const matrices[], char const *options)
 Similar to Compute_Selection_By_Swept_Shell(), but operates on double-precision data. More...
 
double HC_DCompute_Selection_Dist_By_S (char const *action, char const *start_segment, int pcount, DPoint const points[], int flist_length, int const faces[], const char *options)
 Similar to Compute_Selection_Distance_By_Shell(), but operates on double-precision data. More...
 
void HC_DCompute_Shell_Enclosure (int point_count1, DPoint const points1[], int face_list_length3, int const face_list1[], int point_count2, DPoint const points2[], int face_list_length2, int const face_list2[], char *result)
 
Key HC_DCompute_Swept_Shell (Key shellkey, DVector const *direction_in, Key *front_key, Key *back_key, Key *side_key, char const *options)
 Similar to Compute_Swept_Shell(), but operates on double-precision data. More...
 
void HC_DCompute_Swept_Shell_Along_P (Key shellkey, int number_of_sweeps, double const matrices[], char const *options)
 Similar to Compute_Swept_Shell_Along_Path(), but operates on double-precision data. More...
 
bool HC_DCompute_Transform (char const *segment, char const *in_system, char const *out_system, double matrix[])
 Similar to Compute_Transform(), but operates on double-precision data. More...
 
bool HC_DCompute_Transform_By_Path (int count, Key const keys[], char const *in_system, char const *out_system, double matrix[])
 Similar to Compute_Transform_By_Path(), but operates on double-precision data. More...
 
bool HC_DCompute_Transformed_Plane (DPlane const *plane, double const matrix[], DPlane *out_plane)
 Similar to Compute_Transformed_Plane(), but operates on double-precision data. More...
 
bool HC_DCompute_Transformed_Planes (int count, DPlane const planes[], double const matrix[], DPlane out_planes[])
 Applies a user-defined transform to a group of planes. More...
 
void HC_DCompute_Transformed_Points (int count, DPoint const points[], double const matrix[], DPoint out_points[])
 Similar to Compute_Transformed_Points() but accepts and returns double-precision values. More...
 
void HC_DCompute_Translation_Matrix (double x, double y, double z, double out_matrix[])
 Similar to Compute_Translation_Matrix(), but operates on double-precision data. More...
 
double HC_DCompute_Vector_Angle (DVector const *vector, DVector const *vector2)
 Similar to Compute_Vector_Angle(), but operates on double-precision data. More...
 
double HC_DCompute_Vector_Length (DVector const *vector)
 Similar to Compute_Vector_Length(), but operates on double-precision data. More...
 
void HC_DDolly_Camera (double x, double y, double z)
 Similar to Dolly_Camera(), but operates on double-precision cameras. More...
 
Key HC_Decimate_Shell (int quality_percent, char const *options)
 
void HC_DEdit_Circle (Key key, DPoint const *point1, DPoint const *point2, DPoint const *point3)
 Similar to Edit_Circle(), but operates on double-precision data. More...
 
void HC_DEdit_Circle_By_Radius (Key key, DPoint const *center, double radius, DVector const *vector)
 Similar to Edit_Circle_By_Radius(), but operates on double-precision data. More...
 
void HC_DEdit_Circular_Arc (Key key, DPoint const *point1, DPoint const *point2, DPoint const *point3)
 Similar to Edit_Circular_Arc(), but operates on double-precision data. More...
 
void HC_DEdit_Circular_Chord (Key key, DPoint const *point1, DPoint const *point2, DPoint const *point3)
 Similar to Edit_Circular_Chord(), but operates on double-precision data. More...
 
void HC_DEdit_Circular_Wedge (Key key, DPoint const *point1, DPoint const *point2, DPoint const *point3)
 Similar to Edit_Circular_Wedge(), but operates on double-precision data. More...
 
void HC_DEdit_Cutting_Plane (Key key, double a, double b, double c, double d)
 Similar to Edit_Cutting_Plane(), but operates on double-precision data. More...
 
void HC_DEdit_Cutting_Section (Key key, int ioffset, int ndelete, int insert, DPlane const iplanes[])
 Similar to Edit_Cutting_Section(), but operates on double-precision data. More...
 
void HC_DEdit_Cylinder (Key key, DPoint const *p1, DPoint const *p2, double radius, char const *cap)
 Similar to Edit_Cylinder(), but operates on double-precision data. More...
 
void HC_DEdit_Ellipse (Key key, DPoint const *center, DPoint const *major, DPoint const *minor)
 Similar to Edit_Ellipse(), but operates on double-precision data. More...
 
void HC_DEdit_Elliptical_Arc (Key key, DPoint const *center, DPoint const *major, DPoint const *minor, double start, double end)
 Similar to Edit_Elliptical_Arc(), but operates on double-precision data. More...
 
void HC_DEdit_Grid (Key key, char const *type, DPoint const *origin, DPoint const *ref1, DPoint const *ref2, int count1, int count2)
 Similar to Edit_Grid(), but operates on double-precision data. More...
 
void HC_DEdit_Infinite_Line (Key key, double xa, double ya, double za, double xb, double yb, double zb)
 Similar to Edit_Infinite_Line(), but operates on double-precision data. More...
 
void HC_DEdit_Infinite_Ray (Key key, double xa, double ya, double za, double xb, double yb, double zb)
 
void HC_DEdit_Line (Key key, double xa, double ya, double za, double xb, double yb, double zb)
 Similar to Edit_Line(), but operates on double-precision data. More...
 
void HC_DEdit_Marker (Key key, double x, double y, double z)
 Similar to Edit_Marker(), but operates on double-precision data. More...
 
void HC_DEdit_Mesh (Key key, int row_offset, int column_offset, int row_count, int column_count, DPoint const points[])
 Similar to Edit_Mesh(), but can operate on double-precision geometry represented by key, and returns double-precision values for points. More...
 
void HC_DEdit_NURBS_Curve (Key key, int cp_offset, int knot_offset, int cp_count, int knot_count, DPoint const control_points[], float const weights[], float const knots[])
 Similar to Edit_NURBS_Curve() but accepts double-precision values. More...
 
void HC_DEdit_NURBS_Surface (Key key, int cp_offset, int weights_offset, int u_knot_offset, int v_knot_offset, int cp_replace_count, int weights_replace_count, int u_knot_replace_count, int v_knot_replace_count, DPoint const points[], float const weights[], float const u_knots[], float const v_knots[])
 Similar to Edit_NURBS_Surface(), but accepts double-precision parameters. More...
 
void HC_DEdit_NURBS_Surface_Points (Key key, int cp_offset, int cp_replace_count, DPoint const points[])
 Similar to Edit_NURBS_Surface_Points(), but accepts double-precision parameters. More...
 
void HC_DEdit_PolyCylinder (Key key, int p_count, DPoint const pts[], int r_count, double const radii[], char const *capping)
 Similar to Edit_PolyCylinder(), but operates on double-precision data. More...
 
void HC_DEdit_PolyCylinder_Points (Key key, int offset, int delete_count, int insert_count, DPoint const points[])
 Similar to Edit_PolyCylinder_Points, but operates on double-precision data. More...
 
void HC_DEdit_PolyCylinder_Radii (Key key, int offset, int delete_count, int insert_count, double const radii[])
 Similar to Edit_PolyCylinder_Radii, but operates on double-precision data. More...
 
void HC_DEdit_PolyCylinder_With_Basis (Key key, int p_count, DPoint const pts[], int r_count, double const radii[], char const *capping, DVector const basis[])
 Similar to Edit_PolyCylinder_With_Basis, but operates on double-precision data. More...
 
void HC_DEdit_Polygon (Key key, int offset, int ndelete, int insert, DPoint const points[])
 Similar to Edit_Polygon(), but accepts double-precision values. More...
 
void HC_DEdit_Polyline (Key key, int offset, int ndelete, int insert, DPoint const points[])
 Similar to Edit_Polyline(), but accepts double-precision values. More...
 
void HC_DEdit_Shell_Points (Key key, int ioffset, int ndelete, int insert, DPoint const points[])
 Similar to Edit_Shell_Points(), but accepts double-precision values. More...
 
void HC_DEdit_Sphere (Key key, DPoint const *center, double radius, DVector const *axis, DVector const *ortho)
 Similar to Edit_Sphere(), but operates on double-precision data. More...
 
void HC_DEdit_Text_Leader (Key key, double x, double y, double z, char const *options)
 
void HC_Define_Alias (char const *name, char const *expansion)
 Permits a "shorthand" name to be used in place of a longer proper name of a segment. More...
 
void HC_Define_Callback_Name (char const *name, Void_Routine callback)
 Defines a unique name as a legal callback. More...
 
void HC_Define_Color_Name (char const *name, char const *er_name, char const *ish_name, char const *definition)
 Adds a new color name (for example, "VERMILION") to the existing colors in the system's tables (for example, "RED"). More...
 
void HC_Define_Driver_Config (char const *driver, char const *id, char const *version, char const *config)
 Sets up driver device-dependent configuration. More...
 
void HC_Define_Error_Handler (Void_Routine handler)
 Creates a legal name for an error handler that captures HOOPS error reports. More...
 
void HC_Define_Exit_Handler (Void_Routine handler)
 Allows the program a chance to "clean up" upon termination. More...
 
void HC_Define_Font (char const *name, char const *options, int data_length, char const data[])
 Describes a specific set of simple geometry to be used as the actual shapes when drawing text characters. More...
 
void HC_Define_Font_By_Reference (char const *name, char const *options, int data_length, char const data[])
 Similar to Define_Font(), but avoids creating an internal copy of the font within HOOPS memory. More...
 
void HC_Define_Geometry_Highlight (int count, Key const keys[], char const *style, char const *options, int elements_count, int const offset1[], int const offset2[], int const offset3[])
 Specifies a method of highlighting a subpart of an item. More...
 
void HC_Define_Glyph (char const *name, int data_size, char const data[])
 Describes a set of simple geometries which can be later used to define a custom marker, edge, or line style. More...
 
void HC_Define_Highlight (int count, Key const keys[], char const *style, char const *options)
 Specifies a method of highlighting an item.
More...
 
void HC_Define_Image_Glyph (const char *name, const char *definition)
 
void HC_Define_Line_Style (char const *name, char const *definition)
 Allows the user to create a custom line style using a combination of lines, blanks, glyphs, and attributes. More...
 
void HC_Define_Local_Texture (char const *texture_name, char const *definition)
 Define a texture on the currently open segment. More...
 
void HC_Define_Named_Style (char const *style_name, char const *source_segment)
 Defines a name that can be used to draw other segments in the style of the source. More...
 
void HC_Define_Named_Style_By_Key (char const *style_name, Key style_segment_key)
 
void HC_Define_Shader (char const *name, char const *options, char const *shader_source)
 Defines a section of code that will be injected into the HOOPS 3DF pixel shader. More...
 
void HC_Define_Shape (char const *name, int data_size, float const data[])
 Defines a shape to be used for the background of a text annotation. More...
 
void HC_Define_System_Options (char const *list)
 Controls non-graphics system behavior. More...
 
void HC_Define_Texture (char const *texture_name, char const *definition)
 Assigns a name to a set of texture mapping options. More...
 
void HC_Delete_By_Key (Key key)
 Throws away a segment identified by key rather than by name, or throws away a particular geometry item. More...
 
void HC_Delete_Segment (char const *segment)
 Throws away a segment when you no longer need it. Can also be used to shut down a display. More...
 
void HC_Delete_Specific_Shell_Faces (Key key, int count, int const indices[])
 Removes a particular face from the facelist of a particular shell. More...
 
void HC_Delete_Specific_Shell_Points (Key key, int count, int const indices[])
 Removes a specified set of points from the pointlist of a particular shell. More...
 
void HC_Delete_Trim (int index)
 Deletes a trim object from the trim list. More...
 
void HC_Determine_Highlight_Status (int count, Key const keys[], int results[], char const *list)
 Determines if a particular key path invokes highlights. More...
 
bool HC_DFilter_Circumcuboid (char const *segment, char const *options, DPoint *min, DPoint *max)
 Similar to Filter_Circumcuboid(), but operates on double-precision data. More...
 
bool HC_DFilter_Circumcuboid_By_Key (Key segKey, char const *options, DPoint *min, DPoint *max)
 Similar to Filter_Circumcuboid(), but operates on an object referenced by an HC_KEY. More...
 
bool HC_DFilter_Circumcuboid_By_Path (int count, Key const keys[], char const *options, DPoint *min, DPoint *max)
 Similar to Filter_Circumcuboid_By_Path(), but operates on double-precision data. More...
 
bool HC_DFilter_Circumsphere (char const *segment, char const *options, DPoint *center, double *radius)
 Similar to Filter_Circumsphere(), but operates on double-precision data. More...
 
bool HC_DFilter_Circumsphere_By_Key (Key segKey, char const *options, DPoint *center, double *radius)
 Similar to Filter_Circumsphere_By_Key(), but operates on double-precision data. More...
 
bool HC_DFilter_Circumsphere_By_Path (int count, Key const keys[], char const *options, DPoint *center, double *radius)
 Similar to Filter_Circumsphere_By_Path(), but operates on double-precision data. More...
 
Key HC_DInsert_Area_Light (int count, DPoint const points[], char const *listptr)
 Similar to Insert_Area_Light, but operates on double-precision data. More...
 
Key HC_DInsert_Circle (DPoint const *point1, DPoint const *point2, DPoint const *point3)
 Similar to Insert_Circle(), but accepts parameters of type double for increased precision. More...
 
Key HC_DInsert_Circle_By_Radius (DPoint const *center, double radius, DVector const *normal)
 
Key HC_DInsert_Circular_Arc (DPoint const *point1, DPoint const *point2, DPoint const *point3)
 Similar to Insert_Circular_Arc(), but accepts parameters of type double for increased precision. More...
 
Key HC_DInsert_Circular_Chord (DPoint const *point1, DPoint const *point2, DPoint const *point3)
 Similar to Insert_Circular_Chord(), but accepts parameters of type double for increased precision. More...
 
Key HC_DInsert_Circular_Wedge (DPoint const *point1, DPoint const *point2, DPoint const *point3)
 Similar to Insert_Circular_Wedge, but accepts parameters of type double for increased precision. More...
 
Key HC_DInsert_Compressed_Image (double x, double y, double z, char const *format, int width, int height, int size, void const *data)
 
Key HC_DInsert_Cutting_Plane (double a, double b, double c, double d)
 Similar to Insert_Cutting_Plane(), but accepts parameters of type double for increased precision. More...
 
Key HC_DInsert_Cutting_Section (int count, DPlane const planes[])
 Similar to Insert_Cutting_Section(), but operates on double-precision data. More...
 
Key HC_DInsert_Cylinder (DPoint const *center_point_1, DPoint const *center_point_2, double radius, char const *cap)
 Similar to Insert_Cylinder(), but accepts parameters of type double for increased precision. More...
 
Key HC_DInsert_Ellipse (DPoint const *center, DPoint const *major, DPoint const *minor)
 Similar to Insert_Ellipse(), but accepts parameters of type double for increased precision. More...
 
Key HC_DInsert_Elliptical_Arc (DPoint const *center, DPoint const *major, DPoint const *minor, double start, double end)
 Similar to Insert_Elliptical_Arc(), but accepts parameters of type double for increased precision. More...
 
Key HC_DInsert_Grid (char const *type, DPoint const *origin, DPoint const *ref1, DPoint const *ref2, int count1, int count2)
 Similar to Insert_Grid(), but accepts parameters of type double for increased precision. More...
 
Key HC_DInsert_Image (double x, double y, double z, char const *format, int width, int height, const void *data)
 Similar to Insert_Image(), but accepts parameters of type double for increased precision. More...
 
Key HC_DInsert_Image_By_Ref (double x, double y, double z, char const *format, int width, int height, const void *data)
 Similar to Insert_Image_By_Ref(), but operates on double-precision data. More...
 
Key HC_DInsert_Infinite_Line (double xa, double ya, double za, double xb, double yb, double zb)
 Similar to Insert_Infinite_Line() but accepts parameters of type double for increased precision. Unlike Insert_Infinite_Line, the parameters are not truncated. More...
 
Key HC_DInsert_Infinite_Ray (double xa, double ya, double za, double xb, double yb, double zb)
 Similar to Insert_Infinite_Ray() but accepts parameters of type double for increased precision. Unlike Insert_Infinite_Ray, the parameters are not truncated. More...
 
Key HC_DInsert_Ink (double x, double y, double z)
 Similar to Insert_Ink() but accepts parameters of type double for increased precision. Unlike Insert_Ink, the parameters are not truncated. More...
 
Key HC_DInsert_Line (double xa, double ya, double za, double xb, double yb, double zb)
 Similar to Insert_Line(), but accepts parameters of type double for increased precision. Unlike Insert_Line, the parameters are not truncated. More...
 
Key HC_DInsert_Local_Light (double x, double y, double z)
 Similar to Insert_Local_Light(), but accepts parameters of type double for increased precision. Unlike Insert_Local_Light, the parameters are not truncated. More...
 
Key HC_DInsert_Marker (double x, double y, double z)
 Similar to Insert_Marker(), but accepts parameters of type double for increased precision. Unlike Insert_Marker, the parameters are not truncated. More...
 
Key HC_DInsert_Mesh (int rows, int columns, DPoint const points[])
 Similar to Insert_Mesh(), but accepts parameters of type double for increased precision. Unlike Insert_Marker, the parameters are not truncated. More...
 
Key HC_DInsert_Mesh_By_Ref (int rows, int columns, DPoint const points[])
 Similar to Insert_Mesh_By_Ref(), but operates on double-precision data. More...
 
Key HC_DInsert_NURBS_Curve (int degree, int cpcount, DPoint const control_points[], float const weights[], float const knots[], double start_u, double end_u)
 
Key HC_DInsert_NURBS_Surface (int u_degree, int v_degree, int u_count, int v_count, DPoint const points[], float const weights[], float const u_knots[], float const v_knots[])
 Similar to Insert_NURBS_Surface(), but accepts parameters of type double for increased precision. Unlike Insert_NURBS_Surface, the parameters are not truncated. More...
 
Key HC_DInsert_PolyCylinder (int p_count, DPoint const pts[], int r_count, double const radii[], char const *capping)
 Similar to Insert_PolyCylinder(), but operates on double-precision data. More...
 
Key HC_DInsert_Polygon (int count, DPoint const points[])
 Similar to Insert_Polygon(), but accepts double-precision values for points. More...
 
Key HC_DInsert_Polyline (int count, DPoint const points[])
 Similar to Insert_Polyline(), but accepts double-precision values for points. More...
 
Key HC_DInsert_Shell (int point_count, DPoint const points[], int face_list_length, int const face_list[])
 Similar to Insert_Shell() but accepts double-precision values for points. More...
 
Key HC_DInsert_Shell_By_Ref (int pcount, DPoint const points[], int flist_length, int const face_list[])
 Similar to Insert_Shell_By_Ref(), but operates on double-precision data. More...
 
Key HC_DInsert_Shell_By_Tristrips (int pcount, DPoint const points[], int tristrips_length, int const tristrips[], int face_indices_length, int const face_indices[])
 Similar to Insert_Shell_By_Tristrips(), but operates on double-precision data. More...
 
Key HC_DInsert_Sphere (DPoint const *center, double radius, DVector const *axis, DVector const *ortho)
 Similar to Insert_Sphere(), but operates on double-precision data. More...
 
Key HC_DInsert_Spot_Light (DPoint const *position, DPoint const *target, char const *list)
 Similar to Insert_Spot_Light(), but accepts double-precision values for points. More...
 
Key HC_DInsert_Text (double x, double y, double z, char const *text)
 Similar to Insert_Text(), but accepts parameters of type double for increased precision. Unlike Insert_Text, the parameters are not truncated. More...
 
Key HC_DInsert_Text_Leader (Key ownerkey, double x, double y, double z, char const *options)
 Inserts a leader line with double precision parameters. Unlike Insert_Text_Leader, these parameters will not be truncated. More...
 
Key HC_DInsert_Text_With_Encoding (double x, double y, double z, char const *encoding, void const *text)
 Similar to Insert_Text_With_Encoding() but accepts double-precision values. More...
 
void HC_DMove_Image (Key key, double x, double y, double z)
 Similar to Move_Image() but operates on double-precision parameter values. More...
 
void HC_Dolly_Camera (double right, double up, double in)
 One of a set of routines to manipulate one's point of view. "Dolly" moves the "camera" left and right, up and down, or in and out. More...
 
void HC_DOrbit_Camera (double horiz, double vert)
 Similar to Orbit_Camera(), but operates on double-precision cameras. More...
 
void HC_DPan_Camera (double horiz, double vert)
 Similar to Pan_Camera(), but operates on double-precision data. More...
 
int HC_DPShow_Net_Camera (int key_count, Key const path_keys[], DPoint *position, DPoint *target, DVector *up, double *width, double *height, char *projection)
 Similar to PShow_Net_Camera(), but operates on double-precision cameras. More...
 
int HC_DPShow_Net_Camera_By_Volume (int count, Key const keys[], char *proj, double *xmin, double *xmax, double *ymin, double *ymax)
 Similar to PShow_Net_Camera_By_Volume(), but operates on double-precision cameras. More...
 
int HC_DPShow_Net_Camera_Field (int key_count, Key const path_keys[], double *width, double *height)
 Similar to PShow_Net_Camera_Field(), but operates on double-precision cameras. More...
 
int HC_DPShow_Net_Camera_Position (int key_count, Key const path_keys[], double *x, double *y, double *z)
 Similar to PShow_Net_Camera_Position(), but operates on double-precision cameras. More...
 
int HC_DPShow_Net_Camera_Target (int key_count, Key const path_keys[], double *x, double *y, double *z)
 Similar to PShow_Net_Camera_Target(), but operates on double-precision cameras. More...
 
int HC_DPShow_Net_Camera_Up_Vector (int key_count, Key const path_keys[], double *x, double *y, double *z)
 Similar to PShow_Net_Camera_Up_Vector(), but operates on double-precision cameras. More...
 
int HC_DPShow_Net_Clip_Region (int count, Key const keys[], int *loopCount, int loopSizeArray[], DPoint points[], char *spec)
 Like PShow_Net_Clip_Region, but operates on double-precision data. More...
 
int HC_DPShow_Net_Clip_Region_Size (int count, Key const keys[], int *loopCount, int *totalPointCount, char *spec)
 Similar to PShow_Clip_Region_Size(), but operates on double-precision data. More...
 
int HC_DPShow_Net_Modelling_Matrix (int key_count, Key const path_keys[], double matrix[])
 Similar to PShow_Net_Modelling_Matrix(), but operates on double-precision modelling matrices. More...
 
void HC_DRoll_Camera (double angle)
 Similar to Roll_Camera(), but operates on double-precision data. More...
 
void HC_DRotate_Object (double theta, double phi, double psi)
 Similar to Rotate_Object(), but operates on double-precision data. More...
 
void HC_DRotate_Object_Offaxis (double x, double y, double z, double theta)
 Similar to Rotate_Object_Offaxis(), but operates on double-precision data. More...
 
void HC_DScale_Object (double x, double y, double z)
 Similar to Scale_Object(), but operates on double-precision data. More...
 
void HC_DSet_Bounding_Cuboid (DPoint const *min, DPoint const *max)
 Similar to Set_Bounding_Cuboid(), but operates on double-precision data. More...
 
void HC_DSet_Bounding_Sphere (DPoint const *center, double radius)
 Similar to Set_Bounding_Sphere(), but operates on double-precision data. More...
 
void HC_DSet_Camera (DPoint const *position, DPoint const *target, DVector const *up, double width, double height, char const *projection)
 Similar to Set_Camera(), but operates on double-precision parameter values. More...
 
void HC_DSet_Camera_By_Volume (char const *proj, double xmin, double xmax, double ymin, double ymax)
 Similar to Set_Camera_By_Volume(), but accepts double-precision parameters and operates on double-precision cameras. More...
 
void HC_DSet_Camera_Field (double width, double height)
 Similar to Set_Camera_Field(). This command should be used in conjunction with other double-precision Set_Camera functions. More...
 
void HC_DSet_Camera_Position (double x, double y, double z)
 Similar to Set_Camera_Position(), but operates on double-precision cameras. More...
 
void HC_DSet_Camera_Target (double x, double y, double z)
 Similar to Set_Camera_Target(). This command should be used in conjunction with other double-precision Set_Camera functions. More...
 
void HC_DSet_Camera_Up_Vector (double x, double y, double z)
 Similar to Set_Camera_Up_Vector(). This command should be used in conjunction with other double-precision Set_Camera functions. More...
 
void HC_DSet_Circular_Center (double x, double y, double z)
 Similar to Set_Circular_Center(), but operates on double-precision circular geometry. More...
 
void HC_DSet_Circular_Center_By_Key (Key key, double x, double y, double z)
 Similar to Set_Circular_Center_By_Key(), but operates on double-precision circular geometry. More...
 
void HC_DSet_Complex_Clip_Region (int loops, int const lengths[], DPoint const points[], char const *options)
 Similar to Set_Complex_Clip_Region(), but takes double-precision precision points. More...
 
void HC_DSet_Modelling_Matrix (double const matrix[])
 Similar to Set_Modelling_Matrix(), but operates on double-precision matrices. More...
 
void HC_DSet_Polygonal_Clip_Region (int count, DPoint const points[], char const *options)
 Similar to Set_Polygonal_Clip_Region(), but operates on double-precision data. More...
 
void HC_DSet_Text_Region (int pCount, DPoint const points[], char const *options)
 Similar to Set_Text_Region, but operates on double-precision data. More...
 
void HC_DShow_Area_Light (Key key, int *ucount, DPoint upoints[], char *listptr)
 Similar to Show_Area_Light, but operates on double-precision data. More...
 
bool HC_DShow_Bounding_Cuboid (DPoint *min, DPoint *max)
 Similar to Show_Bounding_Cuboid(), but operates on double-precision data. More...
 
bool HC_DShow_Bounding_Cuboid_By_Key (Key key, DPoint *min, DPoint *max)
 Similar to Show_Bounding_Cuboid_By_Key(), but operates on double-precision data. More...
 
bool HC_DShow_Bounding_Sphere (DPoint *center, double *radius)
 Similar to Show_Bounding_Sphere(), but operates on double-precision data. More...
 
bool HC_DShow_Bounding_Sphere_By_Key (Key key, DPoint *center, double *radius)
 Similar to Show_Bounding_Sphere_By_Key(), but operates on double-precision data. More...
 
void HC_DShow_Camera (DPoint *position, DPoint *target, DVector *up, double *width, double *height, char *projection)
 Similar to Show_Camera() but accepts double-precision values. This command should be used in conjunction with other double-precision Set_Camera functions. More...
 
void HC_DShow_Camera_By_Volume (char *proj, double *xmin, double *xmax, double *ymin, double *ymax)
 Similar to Show_Camera_By_Volume(), but operates on double-precision cameras. More...
 
void HC_DShow_Camera_Field (double *width, double *height)
 Similar to Show_Camera_Field(). This command should be used in conjunction with the other double-precision Set_Camera functions. More...
 
void HC_DShow_Camera_Position (double *x, double *y, double *z)
 Similar to Show_Camera_Position(). This command should be used in conjunction with other double-precision Set_Camera functions. More...
 
void HC_DShow_Camera_Target (double *x, double *y, double *z)
 Similar to Show_Camera_Target(). This command should be used in conjunction with other double-precision Set_Camera functions. More...
 
void HC_DShow_Camera_Up_Vector (double *x, double *y, double *z)
 Similar to Show_Camera_Up_Vector(). This command should be used in conjunction with the other double-precision Set_Camera functions. More...
 
void HC_DShow_Circle (Key key, DPoint *point1, DPoint *point2, DPoint *point3)
 Similar to Show_Circle(), but returns double-precision values. More...
 
void HC_DShow_Circle_By_Radius (Key key, DPoint *center, double *radius, DVector *normal)
 Similar to Show_Circle_By_Radius, but returns double-precision values. More...
 
void HC_DShow_Circular_Arc (Key key, DPoint *point1, DPoint *point2, DPoint *point3)
 Similar to Show_Circular_Arc(), but returns double-precision values. More...
 
bool HC_DShow_Circular_Center (Key key, double *x, double *y, double *z)
 Similar to Show_Circular_Center(), but operates on double-precision data. More...
 
void HC_DShow_Circular_Chord (Key key, DPoint *point1, DPoint *point2, DPoint *point3)
 Similar to Show_Circular_Chord(), but returns double-precision values. More...
 
void HC_DShow_Circular_Wedge (Key key, DPoint *point1, DPoint *point2, DPoint *point3)
 Similar to Show_Circular_Wedge(), but returns double-precision values. More...
 
void HC_DShow_Clip_Region (int *loopCount, int loopSizeArray[], DPoint points[], char *options)
 Similar to Show_Clip_Region(), but returns double-precision data. More...
 
void HC_DShow_Clip_Region_Size (int *loopCount, int *totalPointCount, char *options)
 
void HC_DShow_Compressed_Image (Key key, double *x, double *y, double *z, char *format, int *width, int *height, int *size, void *data)
 Similar to Show_Compressed_Image(), but operates on double-precision data. More...
 
void HC_DShow_Cutting_Plane (Key key, double *a, double *b, double *c, double *d)
 Similar to Show_Cutting_Plane(), but returns double-precision values. More...
 
void HC_DShow_Cutting_Section (Key key, int *count, DPlane planes[])
 Similar to Show_Cutting_Section(), but operates on double-precision cutting sections. More...
 
void HC_DShow_Cylinder (Key key, DPoint *p1, DPoint *p2, double *radius, char *cap)
 Similar to Show_Cylinder(), but operates on double-precision data. More...
 
void HC_DShow_Ellipse (Key key, DPoint *center, DPoint *major, DPoint *minor)
 Similar to Show_Ellipse(), but returns double-precision values. More...
 
void HC_DShow_Elliptical_Arc (Key key, DPoint *center, DPoint *major, DPoint *minor, float *start, float *end)
 Similar to Show_Elliptical_Arc(), but returns double-precision values. More...
 
void HC_DShow_Grid (Key key, char *type, DPoint *origin, DPoint *ref1, DPoint *ref2, int *count1, int *count2)
 Similar to Show_Grid(), but returns double-precision values. More...
 
void HC_DShow_Image (Key key, double *x, double *y, double *z, char *format, int *width, int *height, void *data)
 Similar to Show_Image(), but returns double-precision values. More...
 
void HC_DShow_Image_Size (Key key, double *x, double *y, double *z, char *format, int *width, int *height)
 Similar to Show_Image_Size(), but operates on double-precision data. More...
 
void HC_DShow_Infinite_Line (Key key, double *xa, double *ya, double *za, double *xb, double *yb, double *zb)
 Similar to Show_Infinite_Line(), but operates on double-precision data. More...
 
void HC_DShow_Infinite_Ray (Key key, double *xa, double *ya, double *za, double *xb, double *yb, double *zb)
 Similar to Show_Infinite_Ray(), but returns double-precision values. More...
 
int HC_DShow_Intersect_Polyline_Size (int pcount1, DPoint const points1[], int flist_length3, int const face_list1[], int pcount2, DPoint const points2[], int flist_length2, int const face_list2[], int *polyline_count, int *polyline_points_count)
 
void HC_DShow_Line (Key key, double *xa, double *ya, double *za, double *xb, double *yb, double *zb)
 Similar to Show_Line(), but returns double-precision values. More...
 
void HC_DShow_Local_Light (Key key, double *x, double *y, double *z)
 Similar to Show_Local_Light(), but returns double-precision values. More...
 
void HC_DShow_Marker (Key key, double *x, double *y, double *z)
 Similar to Show_Marker, but returns double-precision values. More...
 
void HC_DShow_Mesh (Key key, int *rows, int *columns, DPoint points[])
 Similar to Show_Mesh(), but returns double-precision values. More...
 
void HC_DShow_Modelling_Matrix (double matrix[])
 Similar to Show_Modelling_Matrix(), but operates on double-precision matrices. More...
 
void HC_DShow_NURBS_Curve (Key key, int *degree, int *cp_count, DPoint points[], float weights[], float knots[], float *start_u, float *end_u)
 Similar to Show_NURBS_Curve, but operates on double-precision values. More...
 
void HC_DShow_NURBS_Surface (Key key, int *u_degree, int *v_degree, int *u_count, int *v_count, DPoint points[], float weights[], float u_knots[], float v_knots[])
 Similar to Show_NURBS_Surface() but operates on double-precision values. More...
 
void HC_DShow_Partial_Mesh (Key key, int row_offset, int col_offset, int row_count, int col_count, DPoint points[])
 
void HC_DShow_Partial_Polygon (Key key, int offset, int request, DPoint points[])
 
void HC_DShow_Partial_Polyline (Key key, int offset, int request, DPoint points[])
 
void HC_DShow_Partial_Shell (Key key, int voffset, int vcnt, DPoint points[], int foffset, int fcnt, int *flist_length, int face_list[])
 
void HC_DShow_PolyCylinder (Key key, int *p_count, DPoint pts[], int *r_count, double radii[], char *capping)
 Similar to Show_PolyCylinder(), but operates on double-precision data. More...
 
void HC_DShow_Polygon (Key key, int *count, DPoint points[])
 Similar to Show_Polygon(), but returns double-precision values. More...
 
void HC_DShow_Polyline (Key key, int *count, DPoint points[])
 Similar to Show_Polyline(), but returns double-precision data. More...
 
int HC_DShow_Selection_Position (float *window_x, float *window_y, float *window_z, double *camera_x, double *camera_y, double *camera_z)
 Similar to Show_Selection_Position(), but operates on double-precision data. More...
 
void HC_DShow_Selection_Source_Elem (int *vertex, int *edge, int *face, DPoint *hit_location)
 Similar to Show_Selection_Source_Element(), but operates on double-precision data. More...
 
void HC_DShow_Shell (Key key, int *point_countp, DPoint points[], int *face_list_lengthp, int face_list[])
 Similar to Show_Shell(), but returns double-precision values. More...
 
void HC_DShow_Shell_By_Tristrips (Key key, int *point_countp, DPoint points[], int *tristrip_list_lengthp, int tristrip_list[], int *face_indices_lengthp, int face_indices[])
 Similar to Show_Shell_By_Tristrips(), but operates on double-precision data. More...
 
void HC_DShow_Sphere (Key key, DPoint *center, double *radius, DVector *axis, DVector *ortho)
 Similar to Show_Sphere(), but returns double-precision data. More...
 
void HC_DShow_Spot_Light (Key key, DPoint *position, DPoint *target, char *list)
 Similar to Show_Spot_Light(), but returns double-precision values. More...
 
void HC_DShow_Text (Key key, double *x, double *y, double *z, char *text)
 Similar to Show_Text(), but returns double-precision values. More...
 
void HC_DShow_Text_Leader (Key key, double *x, double *y, double *z, char *options)
 
void HC_DShow_Text_Region (int *count, DPoint points[], char *options)
 
void HC_DShow_Text_With_Encoding (Key key, double *x, double *y, double *z, char *encoding, void *text)
 Similar to Show_Text_With_Encoding(), but returns double-precision values. More...
 
void HC_DTranslate_Object (double x, double y, double z)
 Similar to Translate_Object(), but operates on double-precision data. More...
 
intptr_t HC_Dump_Memory_Profile (char const *which)
 
void HC_DZoom_Camera (double zoom)
 Similar to Zoom_Camera, but operates on a double precision camera. More...
 
void HC_Edit_Circle (Key key, Point const *point1, Point const *point2, Point const *point3)
 Generates a flat, infinitely thin, colored-in circular object. More...
 
void HC_Edit_Circle_By_Radius (Key key, Point const *center, double radius, Vector const *vector)
 Generates a flat, infinitely thin, colored-in circular object. More...
 
void HC_Edit_Circular_Arc (Key key, Point const *point1, Point const *point2, Point const *point3)
 Modifies a circular arc as it sits in the database. More...
 
void HC_Edit_Circular_Chord (Key key, Point const *point1, Point const *point2, Point const *point3)
 Edits a circular chord as it sits in the database. More...
 
void HC_Edit_Circular_Wedge (Key key, Point const *point1, Point const *point2, Point const *point3)
 Edits a circular wedge as it sits in the database. More...
 
void HC_Edit_Cutting_Plane (Key key, double a, double b, double c, double d)
 Modifies a cutting plane as it exists in the database. More...
 
void HC_Edit_Cutting_Section (Key key, int ioffset, int ndelete, int insert, Plane const iplanes[])
 Modifies a cutting section as it exists in the database. More...
 
void HC_Edit_Cylinder (Key key, Point const *p1, Point const *p2, double radius, char const *cap)
 Edits a cylinder object as it sits in the database without deleting and reinserting. More...
 
void HC_Edit_Ellipse (Key key, Point const *center, Point const *major, Point const *minor)
 Edits an ellipse as it sits in the database. More...
 
void HC_Edit_Elliptical_Arc (Key key, Point const *center, Point const *major, Point const *minor, double start, double end)
 Edits an elliptical arc as it sits in the database. More...
 
void HC_Edit_Grid (Key key, char const *type, Point const *origin, Point const *ref1, Point const *ref2, int count1, int count2)
 Edits a grid object as it sits in the database. More...
 
void HC_Edit_Image (Key key, int xoffset, int yoffset, int xcount, int ycount, const void *data)
 Modifies one, some, or all the pixel values in a previously-inserted image. More...
 
void HC_Edit_Image_Options (Key image_key, char const *options)
 Modifies the the options associated with a specific image. More...
 
void HC_Edit_Infinite_Line (Key key, double xa, double ya, double za, double xb, double yb, double zb)
 Modifies an existing infinite line. More...
 
void HC_Edit_Infinite_Ray (Key key, double xa, double ya, double za, double xb, double yb, double zb)
 Modifies an existing infinite ray. More...
 
void HC_Edit_Line (Key key, double xa, double ya, double za, double xb, double yb, double zb)
 Edits a line object as it sits in the database, without deleting and reinserting. More...
 
void HC_Edit_Marker (Key key, double x, double y, double z)
 Edits a marker object as it sits in the database. More...
 
void HC_Edit_Mesh (Key key, int row_offset, int column_offset, int row_count, int column_count, Point const points[])
 Modifies one, some, or all of the vertex values in a previously-inserted mesh. More...
 
void HC_Edit_NURBS_Curve (Key key, int cp_offset, int knot_offset, int cp_count, int knot_count, Point const control_points[], float const weights[], float const knots[])
 Modifies the control points, weights, and/or knots of a previously-inserted NURBS curve. More...
 
void HC_Edit_NURBS_Surface (Key key, int cp_offset, int weights_offset, int u_knot_offset, int v_knot_offset, int cp_replace_count, int weights_replace_count, int u_knot_replace_count, int v_knot_replace_count, Point const points[], float const weights[], float const u_knots[], float const v_knots[])
 Edits the properties of an existing NURBS surface. More...
 
void HC_Edit_NURBS_Surface_Knots (Key key, int u_knot_offset, int v_knot_offset, int u_knot_replace_count, int v_knot_replace_count, float const u_knots[], float const v_knots[])
 Edits only the knots of in a NURBS surface. More...
 
void HC_Edit_NURBS_Surface_Points (Key key, int cp_offset, int cp_replace_count, Point const points[])
 Edits only the control points in a NURBS surface. More...
 
void HC_Edit_NURBS_Surface_Weights (Key key, int weights_offset, int weights_replace_count, float const weights[])
 Edits only the weights in a NURBS surface. More...
 
void HC_Edit_PolyCylinder (Key key, int p_count, Point const pts[], int r_count, float const radii[], char const *capping)
 Edits a polycylinder as it sits in the database, without deleting and reinserting. More...
 
void HC_Edit_PolyCylinder_Points (Key key, int offset, int delete_count, int insert_count, Point const points[])
 Edits an existing polycylinder by inserting or deleting its points. More...
 
void HC_Edit_PolyCylinder_Radii (Key key, int offset, int delete_count, int insert_count, float const radii[])
 Edits an existing polycylinder by inserting or deleting its points. More...
 
void HC_Edit_PolyCylinder_With_Basis (Key key, int p_count, Point const pts[], int r_count, float const radii[], char const *capping, Vector const basis[])
 Edits the polycylinder's points, radii, and vector basis. More...
 
void HC_Edit_Polygon (Key key, int offset, int ndelete, int insert, Point const points[])
 Adjusts the boundary of a previously declared polygon. More...
 
void HC_Edit_Polyline (Key key, int offset, int ndelete, int insert, Point const points[])
 Adjusts the contents of a previously declared polyline. More...
 
void HC_Edit_Shell_Faces (Key key, int offset, int ndelete, int ilist_length, int const insert_list[])
 Creates or deletes faces in a previously declared shell. More...
 
void HC_Edit_Shell_Points (Key key, int offset, int ndelete, int insert, Point const points[])
 Changes or deletes vertex points of a previously declared shell, or adds new points. More...
 
void HC_Edit_Sphere (Key key, Point const *center, double radius, Vector const *axis, Vector const *ortho)
 Edits a sphere object as it sits in the database without deleting and re-inserting. More...
 
void HC_Edit_Text (Key key, int row, int column, int erase, int ndelete, char const *new_text)
 Manipulate the characters in a previously defined string. More...
 
void HC_Edit_Text_Leader (Key key, double x, double y, double z, char const *options)
 
void HC_End_Alias_Search (void)
 Terminates the alias search sequence and frees any involved memory. More...
 
void HC_End_Buffered_Selection ()
 Ends the selection process for the current buffered selection event. that was previously started using Begin_Buffered_Selection. More...
 
void HC_End_Callback_Name_Search (void)
 Terminates the callback name search sequence and frees any involved memory. More...
 
void HC_End_Color_Name_Search (void)
 Terminates the color name search sequence and frees any involved memory. More...
 
void HC_End_Contents_Search (void)
 Terminates the object search sequence and frees any involved memory. More...
 
void HC_End_Decimate_Shell (void)
 
void HC_End_Error_Handler_Search ()
 Terminates the error handler search sequence and frees any memory involved. More...
 
void HC_End_Exit_Handler_Search ()
 Terminates the exit handler search sequence and frees any memory involved . More...
 
void HC_End_Font_Search (void)
 Terminates the font search sequence and frees any involved memory. More...
 
void HC_End_Glyph_Search (void)
 Terminates the glyph search sequence and frees any involved memory. More...
 
void HC_End_Highlight_Search (void)
 Discards any remaining results from this search. More...
 
void HC_End_Line_Style_Search (void)
 Terminates the line style search sequence and frees any involved memory. More...
 
void HC_End_Named_Style_Search (void)
 Terminates a named style search sequence and frees any involved memory. More...
 
void HC_End_Open_Item_Search (void)
 Terminates the open item search sequence, and frees any involved memory. More...
 
void HC_End_Open_Segment_Search (void)
 Terminates the segment search sequence and frees any involved memory. More...
 
void HC_End_Segment_Search (void)
 Terminates the segment search sequence and frees any involved memory. More...
 
void HC_End_Shader_Search (void)
 Terminates the shader search sequence and frees any involved memory. More...
 
void HC_End_Shape_Search (void)
 
void HC_End_Shell_Selection (void)
 Terminates the shell selection sequence and frees any involved memory.. More...
 
void HC_End_Texture_Search (void)
 Terminates the texture search sequence and frees any involved memory. More...
 
bool HC_Evaluate_Condition (const char *expression, const char *conditions)
 
void HC_Exit_Program (void)
 Calls the defined exit handlers, and exits to the operating system with a normal status. More...
 
bool HC_Filter_Circumcuboid (char const *segment, char const *options, Point *min, Point *max)
 Determines the bounding cuboid for a particular segment, based on visibility settings in the segment tree. More...
 
bool HC_Filter_Circumcuboid_By_Key (Key segKey, char const *options, Point *min, Point *max)
 Similar to Filter_Circumcuboid(), but operates on an object referenced by an HC_KEY. More...
 
bool HC_Filter_Circumcuboid_By_Path (int count, Key const keys[], char const *options, Point *min, Point *max)
 Similar to Filter_Circumcuboid(), but operates on a keypath instead of a single segment. More...
 
bool HC_Filter_Circumsphere (char const *segment, char const *options, Point *center, float *radius)
 Determines the bounding sphere for a particular segment, based on visibility settings in the tree. More...
 
bool HC_Filter_Circumsphere_By_Key (Key segKey, char const *options, Point *center, float *radius)
 Similar to Filter_Circumsphere(), but operates on an object referenced by an HC_KEY. More...
 
bool HC_Filter_Circumsphere_By_Path (int count, Key const keys[], char const *options, Point *center, float *radius)
 Similar to Filter_Circumsphere(), but operates on a keypath instead of a single segment. More...
 
bool HC_Find_Alias (char *alias)
 Retrieves the alias names, one at a time. The function returns false when all aliases have been returned. More...
 
bool HC_Find_Callback_Name (char *name)
 Retrieves the callback names, one at a time. The function returns false when all aliases have been returned. More...
 
bool HC_Find_Color_Name (char *name, char *er_name, char *ish_name)
 Retrieves the color names, one at a time. The function returns false when all color names have been returned. More...
 
bool HC_Find_Contents (char *type, Key *key)
 Retrieves the object keys, one at a time. The function returns false when all objects have been returned. More...
 
bool HC_Find_Contents_Original_Key (char *type, Key *key)
 If keys have been renumbered, this function retrieves the original object keys, one at a time. The function returns false when all objects have been returned. More...
 
bool HC_Find_Error_Handler (Void_Routine *handler)
 Retrieves the address of the registered error handlers one at a time. More...
 
bool HC_Find_Exit_Handler (Void_Routine *handler)
 Retrieves the font names, one at a time. The function returns false when all aliases have been returned. More...
 
bool HC_Find_Font (char *name)
 Retrieves the font names, one at a time. The function returns false when all aliases have been returned. More...
 
bool HC_Find_Glyph (char *name)
 Retrieves the glyph names, one at a time. The function returns false when all glyphs have been returned. More...
 
bool HC_Find_Highlight (int *count, Key keys[], char *options)
 Returns the next highlight that was collected. More...
 
bool HC_Find_Line_Style (char *name)
 Retrieves the line style names, one at a time. The function returns false when all line styles have been returned. More...
 
bool HC_Find_Named_Style (char *style_name)
 Retrieves the style names, one at a time. The function returns false when all objects have been returned. More...
 
bool HC_Find_Next_Sample (int *key_count, Key keys[], int *offset1, int *offset2, int *offset3)
 Allows you to inspect the next item in the list of items found by Collect_Area_Samples. More...
 
bool HC_Find_Open_Item (Key *key, char *type, int *offset1, int *offset2)
 Retrieves the open items in a segment tree, one at a time. The function returns false when all items have been returned. More...
 
bool HC_Find_Open_Segment (char *segment)
 Retrieves the segments, one at a time. The function returns false when all segments have been returned. More...
 
bool HC_Find_Related_Selection (void)
 Allows you to inspect the "next best" geometry item with the current Selection Event. More...
 
bool HC_Find_Segment (char *segment)
 Retrieves the segment names, one at a time. The function returns false when all segments have been returned. More...
 
bool HC_Find_Shader (char *sname)
 Retrieves the shader names, one at a time. The function returns false when all shaders have been returned. More...
 
bool HC_Find_Shape (char *name)
 
bool HC_Find_Texture (char *name)
 Retrieves the texture names, one at a time. The function returns false when all textures have been returned. More...
 
void HC_Flush_Attributes (char const *segment)
 Flushes attributes from a segment but leaves styles, geometry, segments, and subsegments. More...
 
void HC_Flush_By_Key (Key key)
 Throws away the contents of a geometric primitive or a segment but leaves the structure intact. More...
 
void HC_Flush_Contents (char const *segment, char const *filter)
 Empties some or all of the drawing primitives, attributes, or subsegments from a segment. More...
 
void HC_Flush_Geometry (char const *segment)
 Flushes just geometry from a segment but leaves attributes, styles, segments, and subsegments. More...
 
int HC_Gather_Capping_Geometry (int key_count, Key const path_keys[], Key cut_key, char const *options)
 Collects capping geometry generated by cutting planes. Geometry is deposited into the currently open segment. The capping faces are delivered in the form of shells, and edges are delivered as polylines. More...
 
Key HC_Generate_Edges (Key geom, char const *options)
 Generates a set of shell/mesh edges and inserts them into the HOOPS segment tree. More...
 
void HC_Generate_Error (int level, int category, int specific, char const *buf1, char const *buf2, char const *buf3)
 Injects an error into HOOPS 3DF. More...
 
Key HC_Generate_Poly_From_Geometry (Key geom, char const *options)
 Generates a polyline based on a specified curve. More...
 
Key HC_Generate_Shell_From_Geometry (Key geom, char const *options)
 
Key HC_Include_Segment (char const *include)
 Leaves a note for the system directing it to grab a copy of another segment whenever the current one is displayed. More...
 
Key HC_Include_Segment_By_Key (Key seg_key)
 Similar to Include_Segment(), but operates on an object referenced by an HC_KEY. More...
 
Key HC_Include_Segment_Key_By_Key (Key key, Key includer_key)
 Similar to Include_Segment_By_Key(), but inserts the include into a the segment associated with the passed key. More...
 
Key HC_Insert_Area_Light (int count, Point const points[], char const *listptr)
 Inserts an area light. More...
 
Key HC_Insert_Circle (Point const *point1, Point const *point2, Point const *point3)
 Generates a flat, infinitely thin, filled circle. More...
 
Key HC_Insert_Circle_By_Radius (Point const *center, double radius, Vector const *normal)
 Generates a flat, infinitely thin, colored-in circular object. More...
 
Key HC_Insert_Circular_Arc (Point const *point1, Point const *point2, Point const *point3)
 Generates a portion of the circumference of a circle. More...
 
Key HC_Insert_Circular_Chord (Point const *point1, Point const *point2, Point const *point3)
 Generates a polygon describing a portion of a circle. More...
 
Key HC_Insert_Circular_Wedge (Point const *point1, Point const *point2, Point const *point3)
 Generates a wedge shaped polygon representing a portion of a circle. More...
 
Key HC_Insert_Compressed_Image (double x, double y, double z, char const *format, int width, int height, int size, void const *data)
 Inserts a compressed pixel-based image in the HOOPS database. More...
 
Key HC_Insert_Cutting_Plane (double a, double b, double c, double d)
 Creates a special geometric object that "cuts away" part of the normal scene. More...
 
Key HC_Insert_Cutting_Section (int count, Plane const planes[])
 Creates a special piece of geometry which "cuts away" a portion of the scene. More...
 
Key HC_Insert_Cylinder (Point const *center_point_1, Point const *center_point_2, double radius, char const *cap)
 Inserts a cylinder into the currently open segment. More...
 
Key HC_Insert_Distant_Light (double di, double dj, double dk)
 Inserts a distant point source of light into your scene. More...
 
Key HC_Insert_Ellipse (Point const *center, Point const *major, Point const *minor)
 Generates a flat, infinitely thin, colored-in elliptical object. More...
 
Key HC_Insert_Elliptical_Arc (Point const *center, Point const *major, Point const *minor, double start, double end)
 Generates a portion of the perimeter of an ellipse. More...
 
Key HC_Insert_Grid (char const *type, Point const *origin, Point const *ref1, Point const *ref2, int count1, int count2)
 Generates a flat array of edges, faces, and/or markers. More...
 
Key HC_Insert_Image (double x, double y, double z, char const *format, int width, int height, const void *data)
 Inserts a pixel-based image in the HOOPS Visualize database. More...
 
Key HC_Insert_Image_By_Ref (double x, double y, double z, char const *format, int width, int height, const void *data)
 Similar to Insert_Image(), but does not create a copy of the image data within HOOPS. More...
 
Key HC_Insert_Infinite_Line (double xa, double ya, double za, double xb, double yb, double zb)
 Adds an infinitely long line to the currently open segment. More...
 
Key HC_Insert_Infinite_Ray (double xa, double ya, double za, double xb, double yb, double zb)
 Adds an infinitely long line to the currently open segment. More...
 
Key HC_Insert_Ink (double x, double y, double z)
 Utility routine to extend the "currently-being-inked-in" polyline. More...
 
Key HC_Insert_Line (double xa, double ya, double za, double xb, double yb, double zb)
 Adds a simple line segment to the current graphics segment. More...
 
Key HC_Insert_Local_Light (double x, double y, double z)
 Inserts an omni-directional "point" source of light into your scene. More...
 
Key HC_Insert_Marker (double x, double y, double z)
 Inserts a single marker symbol at the specified location in your scene. More...
 
Key HC_Insert_Mesh (int rows, int columns, Point const points[])
 Puts a rectangular array of faces into the database. More...
 
Key HC_Insert_Mesh_By_Ref (int rows, int columns, Point const points[])
 
Key HC_Insert_NURBS_Curve (int degree, int cpcount, Point const control_points[], float const weights[], float const knots[], double start_u, double end_u)
 
Key HC_Insert_NURBS_Surface (int u_degree, int v_degree, int u_count, int v_count, Point const points[], float const weights[], float const u_knots[], float const v_knots[])
 Generates a Non-Uniform Rational B-Spline (NURBS) surface. More...
 
Key HC_Insert_PolyCylinder (int p_count, Point const pts[], int r_count, float const radii[], char const *capping)
 Create a polycylinder from a 3D array of points and an array of radii. More...
 
Key HC_Insert_Polygon (int count, Point const points[])
 Generates a simple flat, infinitely thin, colored-in object. More...
 
Key HC_Insert_Polyline (int count, Point const points[])
 Generates a connected chain of line segments. Can be used to approximate arcs. More...
 
Key HC_Insert_Shell (int pcount, Point const points[], int flist_length, int const face_list[])
 Generates an object that is an arbitrarily-connected collection of arbitrary polygonal facets. More...
 
Key HC_Insert_Shell_By_Ref (int pcount, Point const points[], int flist_length, int const face_list[])
 
Key HC_Insert_Shell_By_Tristrips (int pcount, Point const points[], int tristrips_length, int const tristrips[], int face_indices_length, int const face_indices[])
 Generates an object that is an arbitrarily-connected collection of arbitrary polygonal facets. More...
 
Key HC_Insert_Shell_From_Region (Key key1, int region, char const *options)
 Creates a new shell containing the points and faces (and any associated attributes) in an existing shell region. More...
 
Key HC_Insert_Sphere (Point const *center, double radius, Vector const *axis, Vector const *ortho)
 Generates a sphere. More...
 
Key HC_Insert_Spot_Light (Point const *position, Point const *target, char const *list)
 Inserts a directional "point" source of light into your scene. More...
 
Key HC_Insert_String_Cursor (Key text_key, int row, int column)
 Places a cursor into a text string. More...
 
Key HC_Insert_Text (double x, double y, double z, char const *text)
 Puts lettering into the current segment, and thence into the picture. More...
 
Key HC_Insert_Text_Leader (Key ownerkey, double x, double y, double z, char const *options)
 Inserts a leader line. More...
 
Key HC_Insert_Text_With_Encoding (double x, double y, double z, char const *encoding, void const *text)
 Similar to Insert_Text(), but operates with encoded text rather than Latin1 text. More...
 
Key HC_Insert_Unicode_Text (double x, double y, double z, unsigned short const text[])
 Insert encoded text as an array of short integers. More...
 
int HC_Inspect_Proxies (Key out_keys[], int n_out_keys)
 
intptr_t HC_Memory_Usage_By_Key (Key key, char const *which)
 
void HC_Modify_Color_Map (int offset, char const *colors)
 Changes the array of colors which are used when displaying Images, or "by index", color attributes. More...
 
void HC_Modify_Color_Map_By_Value (int offset, char const *color_space, int count, RGB const values[])
 Similar to Modify_Color_Map() but operates with a color values rather than names or map indices. More...
 
void HC_Move_By_Key (Key key, char const *newowner)
 Moves a single geometric primitive or segment from one segment to another. More...
 
void HC_Move_Distant_Light (Key key, double di, double dj, double dk)
 Changes the location, in object space, of a previously-inserted "distant light". More...
 
void HC_Move_Image (Key key, double x, double y, double z)
 Changes the location, in object space, of a previously-inserted Image. Double-precision parameters, if passed to this function, are truncated during calculations. More...
 
void HC_Move_Key_By_Key (Key key, Key newowner)
 Moves a single geometric primitive or segment from one segment to another. Locally renumbered keys require the parent segment to be open in order to resolve them. More...
 
void HC_Move_Light_Position (Key key, double x, double y, double z)
 Changes the location, in object space, of a previously inserted "local light" or "spot light". More...
 
void HC_Move_Light_Target (Key key, double x, double y, double z)
 Changes the location towards which a previously inserted "spot light" shines in user coordinates. More...
 
void HC_Move_Segment (char const *old_seg_name, char const *new_seg_name)
 Changes the name of a segment, and/or moves it somewhere else in the segment tree. More...
 
void HC_Move_String_Cursor (Key key, int row, int column)
 Changes the position of a previously created String Cursor. More...
 
void HC_Move_Text (Key key, double x, double y, double z)
 Changes the location, in object space, of a previously-inserted Text item. More...
 
void HC_MSet_Character_Attributes (Key key, int offset, int count, char const *options)
 Allows developers to set text attributes on a per-character basis within a text string. More...
 
void HC_MSet_Face_Colors_By_FIndex (Key key, char const *type, int offset, int count, float const findices[])
 Sets the drawing attributes on a contiguous range of shell or mesh faces speedily. More...
 
void HC_MSet_Face_Colors_By_Value (Key key, char const *type, int offset, char const *color_space, int count, RGB const values[])
 Sets the drawing attributes on a contiguous range of shell or mesh faces speedily. More...
 
void HC_MSet_Face_Normals (Key key, int offset, int count, Vector const *normals)
 Speedily sets the drawing attributes on a large number of shell or mesh faces. More...
 
void HC_MSet_Face_Regions (Key key, int first_face, int face_count, int const regions[])
 Maps a specified range of faces to a given set of regions. More...
 
void HC_MSet_Face_Visibilities (Key key, int offset, int count, char const settings[])
 Sets the visibility of a range of faces at once. More...
 
void HC_MSet_Region_Faces (Key key, int region, int first_face, int face_count)
 Adds a specified range of shell faces to the specified region without requiring open geometry or regions. More...
 
void HC_MSet_Spec_Face_Col_By_FIndex (Key key, int count, int const indices[], float const findices[])
 Sets the drawing attributes on an arbitrary set of shell or mesh faces speedily. More...
 
void HC_MSet_Spec_Face_Col_By_Value (Key key, int count, int const indices[], char const *color_space, RGB const values[])
 Sets the drawing attributes on an arbitrary set of shell or mesh faces speedily. More...
 
void HC_MSet_Spec_Vert_Col_By_FIndex (Key key, char const *types, int count, int const offsets[], float const indices[])
 Sets the color on an arbitrary set of shell, mesh, or polycylinder vertices. More...
 
void HC_MSet_Spec_Vert_Col_By_Value (Key key, char const *types, int count, int const offsets[], char const *color_space, RGB const values[])
 Sets the color on an arbitrary set of shell, mesh, or polycylinder vertices. More...
 
void HC_MSet_Spec_Vertex_Parameters (Key key, int count, int const indices[], int number_parameters, float const user_parameters[])
 Sets the parameter values for a specific set of vertices on shell, mesh, or polycylinder. More...
 
void HC_MSet_Specific_Edge_Vis (Key key, int count, int const indices1[], int const indices2[], char const settings[])
 Sets per-edge visibility settings on multiple edges at once. This overrides the visibility settings inherited from the segment-level. More...
 
void HC_MSet_Specific_Face_Normals (Key key, int count, int const indices[], Vector const normals[])
 Speedily sets the normal values for a specific faces on a shell or mesh faces. More...
 
void HC_MSet_Specific_Face_Vis (Key key, int count, int const indices[], char const settings[])
 Sets the visibility of a list of specific of faces at once. More...
 
void HC_MSet_Specific_Vertex_Normals (Key key, int count, int const indices[], Vector const normals[])
 Speedily sets the normal values a set of faces on a large number of shell, mesh, or polycylinder vertices. More...
 
void HC_MSet_Specific_Vertex_Vis (Key key, int count, int const indices[], char const settings[])
 Sets per-vertex visibility settings on several individual vertices at once. This overrides the visibility settings inherited from the segment-level. More...
 
void HC_MSet_Vertex_Colors_By_FIndex (Key key, char const *types, int offset, int count, float const findices[])
 Sets the color on a contiguous range of shell, mesh, or polycylinder vertices. More...
 
void HC_MSet_Vertex_Colors_By_Value (Key key, char const *types, int offset, char const *color_space, int count, RGB const values[])
 Sets the color on a contiguous range of shell, mesh, or polycylinder vertices. More...
 
void HC_MSet_Vertex_Colors_By_Value4 (Key key, char const *geometry, int offset, char const *color_space, int count, RGBA const values[])
 Sets the color on a contiguous range of shell, mesh, or polycylinder vertices. More...
 
void HC_MSet_Vertex_Normals (Key key, int offset, int count, Vector const normals[])
 Speedily sets the drawing attributes on a large number of shell, mesh, or polycylinder vertices. More...
 
void HC_MSet_Vertex_Parameters (Key key, int offset, int pcount, int number, float const parameters[])
 Speedily sets the drawing attributes on a large number of shell, mesh, or polycylinder vertices. More...
 
void HC_MSet_Vertex_Visibilities (Key key, int offset, int count, char const settings[])
 Sets per-vertex visibility settings of a range of vertices at once. This overrides the visibility settings inherited from the segment-level. More...
 
void HC_MShow_Character_Attributes (Key key, int offset, int count, char *options)
 Returns attributes from a given text string on a per-character basis. More...
 
void HC_MShow_Face_Colors_By_FIndex (Key key, int offset, int count, float findices[])
 Returns face color settings from a contiguous range of faces without having to open geometry. More...
 
void HC_MShow_Face_Colors_By_Value (Key key, int offset, int count, RGB rgb[])
 Returns face color settings from a contiguous range of faces without having to open geometry. More...
 
int HC_MShow_Face_Colors_With_Ex (Key key, char const *geometry, int offset, int count, char result_type[], float index_colors[], RGB rgb_colors[])
 Returns face color settings from a range of faces without having to open each face. More...
 
void HC_MShow_Face_Normals (Key key, int offset, int count, Vector normals[])
 Returns the normals set on the faces of some geometry without having to open each face. More...
 
int HC_MShow_Face_Normals_W_Ex (Key key, int offset, int count, char existence[], Vector normals[])
 Returns the normal settings for a range of faces without having to open each face. More...
 
void HC_MShow_Face_Regions (Key key, int *face_count, int regions[])
 Show the regions defined for a given shell without requiring open geometry. More...
 
void HC_MShow_Face_Regions_Count (Key key, int *face_count)
 Finds the number of face regions in a shell. This is useful for determining the size of the data structure needed for regions. More...
 
int HC_MShow_Face_Vis_W_Ex (Key key, int offset, int count, char existence[], char visibilities[])
 Shows the visibility settings for a range of faces. More...
 
void HC_MShow_Face_Visibilities (Key key, int offset, int count, char settings[])
 
void HC_MShow_Net_Face_Normals (Key key, int offset, int count, Vector normals[])
 Similar to MShow_Face_Normals(), but returns the net effective normals set on the faces of some geometry. More...
 
void HC_MShow_Net_Vertex_Normals (Key key, int offset, int count, Vector normals[])
 
void HC_MShow_Partial_Face_Regions (Key key, int first_face, int face_count, int regions[])
 
void HC_MShow_Region_Faces (Key key, int region, int *face_count, int faces[])
 
void HC_MShow_Region_Faces_Count (Key key, int region, int *face_count)
 
void HC_MShow_Spec_Face_Col_By_FInd (Key key, int count, int const indices[], float findices[])
 Returns face color settings from an arbitrary set of faces without having to open geometry. More...
 
void HC_MShow_Spec_Face_Col_By_Value (Key key, int count, int const indices[], RGB rgb[])
 Returns face color settings from an arbitrary set of faces without having to open geometry. More...
 
int HC_MShow_Spec_Face_Colors_W_Ex (Key key, char const *geometry, int count, int const faces[], char result_type[], float index_colors[], RGB rgb_colors[])
 Returns face color settings from an arbitrary set of faces without having to open each face. More...
 
int HC_MShow_Spec_Face_Normals_W_Ex (Key key, int count, int const indices[], char existence[], Vector normals[])
 Returns the normal settings from an arbitrary set of faces without having to open each face. More...
 
int HC_MShow_Spec_Face_Vis_W_Ex (Key key, int count, int const indices[], char existence[], char visibilities[])
 Returns the visibility settings from an arbitrary set of faces without having to open each face. More...
 
void HC_MShow_Spec_Vert_Col_By_FInd (Key key, char const *type, int pcount, int const offsets[], float indices[])
 
void HC_MShow_Spec_Vert_Col_By_Value (Key key, char const *type, int count, int const offsets[], RGB rgb[])
 
int HC_MShow_Spec_Vert_Colors_W_Ex (Key key, char const *geometry, int count, int const vertices[], char result_type[], float index_colors[], RGB rgb_colors[], RGBA rgba_colors[])
 
int HC_MShow_Spec_Vert_Normals_W_Ex (Key key, int count, int const indices[], char existence[], Vector normals[])
 
void HC_MShow_Spec_Vertex_Parameters (Key key, int count, int const indices[], int *number_parameters, float user_parameters[])
 
int HC_MShow_Spec_Vertex_Params_W_E (Key key, int count, int const specific_vertices[], char existence[], int *param_width, float user_parameters[])
 
int HC_MShow_Spec_Vertex_Vis_W_Ex (Key key, int count, int const indices[], char existence[], char visibilities[])
 
void HC_MShow_Specific_Edge_Vis (Key key, int count, int const indices1[], int const indices2[], char settings[])
 
void HC_MShow_Specific_Face_Normals (Key key, int count, int const indices[], Vector normals[])
 Shows the normal values for a list of faces. More...
 
void HC_MShow_Specific_Face_Vis (Key key, int count, int const indices[], char settings[])
 Similar to MShow_Specific_Face_Visibilities() which shows the visibility settings for a precise list of faces. More...
 
void HC_MShow_Specific_Vert_Normals (Key key, int count, int const indices[], Vector normals[])
 
void HC_MShow_Specific_Vertex_Vis (Key key, int count, int const indices[], char settings[])
 
void HC_MShow_Vertex_Colors_By_FInd (Key key, char const *type, int offset, int pcount, float indices[])
 
void HC_MShow_Vertex_Colors_By_Value (Key key, char const *type, int offset, int count, RGB rgb[])
 
int HC_MShow_Vertex_Colors_With_Ex (Key key, char const *geometry, int offset, int count, char result_type[], float index_colors[], RGB rgb_colors[], RGBA rgba_colors[])
 
void HC_MShow_Vertex_Normals (Key key, int offset, int count, Vector normals[])
 
int HC_MShow_Vertex_Normals_W_Ex (Key key, int offset, int count, char existence[], Vector normals[])
 
void HC_MShow_Vertex_Parameter_Size (Key key, int *number)
 
void HC_MShow_Vertex_Parameters (Key key, int offset, int pcount, int *number, float params[])
 
int HC_MShow_Vertex_Parameters_W_Ex (Key key, int offset, int count, char existence[], int *param_width, float user_parameters[])
 
int HC_MShow_Vertex_Vis_W_Ex (Key key, int offset, int count, char existence[], char visibilities[])
 
void HC_MShow_Vertex_Visibilities (Key key, int offset, int count, char settings[])
 
void HC_MUnSet_Character_Attributes (Key key, int offset, int count, char const *options)
 Un-sets text attributes established in a previous call to MSet_Character_Attributes. More...
 
void HC_MUnSet_Face_Colors (Key key, int offset, int count)
 Removes color settings from a contiguous range of faces. More...
 
void HC_MUnSet_Face_Normals (Key key, int offset, int count)
 Removes the normal values for a range of faces at once. This allows the shell or mesh to inherit segment-level normal value settings. More...
 
void HC_MUnSet_Face_Visibilities (Key key, int offset, int count)
 Removes the per-face visibility settings of a range of faces at once. This allows the shell or mesh to inherit segment-level visibility settings. More...
 
void HC_MUnSet_Spec_Face_Colors (Key key, int count, int const faces[])
 Removes vertex-specific color settings from an arbitrary set of faces. More...
 
void HC_MUnSet_Spec_Vert_Parameters (Key key, int count, int const indices[])
 Unsets the parameter values for a specific set of vertices on shell, mesh, or polycylinder. More...
 
void HC_MUnSet_Spec_Vertex_Colors (Key key, int count, int const offsets[])
 Removes vertex-specific color settings from a set of vertices with arbitrary offsets. More...
 
void HC_MUnSet_Spec_Vertex_Colors2 (Key key, char const *type, int count, int const indices[])
 Removes vertex-specific color settings from a set of vertices with arbitrary offsets based on type. More...
 
void HC_MUnSet_Specific_Edge_Vis (Key key, int count, int const indices1[], int const indices2[])
 Removes per-edge visibility settings on multiple edges at once. This allows the shell or mesh to inherit segment-level visibility settings. More...
 
void HC_MUnSet_Specific_Face_Normals (Key key, int count, int const indices[])
 Removes the normal values for a set of specific faces at once. This allows the shell or mesh to inherit segment-level normal value settings. More...
 
void HC_MUnSet_Specific_Face_Vis (Key key, int count, int const indices[])
 Removes the per-face visibility settings of a list of faces at once. This allows the shell or mesh to inherit segment-level visibility settings. More...
 
void HC_MUnSet_Specific_Vert_Normals (Key key, int count, int const indices[])
 Speedily unsets the normal values a set of faces on a large number of shell, mesh, or polycylinder vertices. More...
 
void HC_MUnSet_Specific_Vertex_Vis (Key key, int count, int const indices[])
 Removes per-vertex visibility settings on several individual vertices at once. This allows the shell or mesh to inherit segment-level visibility settings. More...
 
void HC_MUnSet_Vertex_Colors (Key key, int offset, int count)
 Removes vertex-specific color settings from a range of vertices with adjacent offsets. More...
 
void HC_MUnSet_Vertex_Colors2 (Key key, char const *type, int offset, int count)
 Removes vertex-specific color settings from a range of vertices with adjacent offsets based on type. More...
 
void HC_MUnSet_Vertex_Normals (Key key, int offset, int count)
 Speedily unsets the normal values a range of faces on a large number of shell, mesh, or polycylinder vertices. More...
 
void HC_MUnSet_Vertex_Parameters (Key key, int offset, int count)
 Unsets the drawing attributes on a large number of shell, mesh, or polycylinder vertices. More...
 
void HC_MUnSet_Vertex_Visibilities (Key key, int offset, int count)
 Removes per-vertex visibility settings of a range of vertices at once. This allows the shell or mesh to inherit segment-level visibility settings. More...
 
Key HC_Named_Style_Segment (char const *style_name)
 Requests that the current segment be drawn in the style of the segment associated with the given name. More...
 
Key HC_Named_Style_Segment_By_Key (Key target_segment, char const *style_name)
 Similar to Named_Style_Segment() but operates on a key rather than an open segment. More...
 
void HC_Open_Edge (int offset1, int offset2)
 Prepares an edge within a shell or mesh for the local overriding of drawing attributes. More...
 
void HC_Open_Face (int id)
 Prepares a face within a shell or mesh for the local overriding of drawing attributes. More...
 
void HC_Open_Geometry (Key key)
 Readies an item of geometry – in particular a shell or a mesh – or a light to receive local attributes. More...
 
void HC_Open_LOD (int level)
 Allows user to open a LOD representation for the purpose of manually inserting a LOD. More...
 
void HC_Open_Region (int region)
 Prepares a defined shell region for modification. More...
 
Key HC_Open_Segment (char const *segment)
 Readies a segment to receive drawing commands. (Also useful when several attributes all need changing at once.) More...
 
void HC_Open_Segment_By_Key (Key key)
 Similar to Open_Segment(), but operates on an object referenced by an HC_KEY. More...
 
Key HC_Open_Segment_Key_By_Key (Key parent_segment, char const *child_segment_name)
 Similar to Open_Segment(), but opens a child segment under parent_segment instead of the currently opened segment. More...
 
void HC_Open_Trim (int offset)
 Readies an item on the trim list for editing or querying. More...
 
void HC_Open_Vertex (int offset)
 Prepares a vertex within a shell, mesh, or polycylinder for the local overriding of drawing attributes. More...
 
void HC_Optimize_Segment_Tree (char const *segname, char const *option_string)
 Traverses the specified segment tree and makes modifications within it to try to improve rendering performance. More...
 
void HC_Optimize_Segment_Tree_By_Key (Key segkey, char const *option_string)
 Similar to Optimize_Segment_Tree(), but operates on a segme. More...
 
void HC_Orbit_Camera (double theta, double phi)
 Walks the viewer's point of view around the object being looked at. More...
 
void HC_Pan_Camera (double theta, double phi)
 Sweeps the camera across its current scene. More...
 
bool HC_Parse_String (char const *string, char const *delimiter, int offset, char *token)
 A utility routine for extracting delimited strings from longer strings. More...
 
void HC_Pause (void)
 Updates the screen, suspends the program, and allows the user to have a look at the screen while it waits for a button to be pushed. More...
 
void HC_Print_Version (void)
 Prints out the version number of the HOOPS you're using. More...
 
bool HC_PShow_Net_Callback (int key_count, Key const path_keys[], char *callbacks)
 Returns the net effective callback settings along a path of segments specified by an array of HC_KEY's. More...
 
int HC_PShow_Net_Camera (int key_count, Key const path_keys[], Point *position, Point *target, Vector *up, float *width, float *height, char *projection)
 Returns the net effective setting along a discrete segment path. More...
 
int HC_PShow_Net_Camera_By_Volume (int count, Key const keys[], char *proj, float *xmin, float *xmax, float *ymin, float *ymax)
 Similar to Show_Camera_By_Volume(), but returns the net effective camera along a discrete segment path. More...
 
int HC_PShow_Net_Camera_Field (int key_count, Key const path_keys[], float *width, float *height)
 Returns the net effective setting along a discrete segment path. More...
 
bool HC_PShow_Net_Camera_Near_Limit (int count, Key const keys[], float *limit)
 Populates the wlimit with the net effective near camera limit value along a path of segments specified by an array of HC_KEY's. Returns true if the near limit was set locally on this segment. More...
 
int HC_PShow_Net_Camera_Position (int key_count, Key const path_keys[], float *x, float *y, float *z)
 Returns the net effective setting along a discrete segment path. More...
 
int HC_PShow_Net_Camera_Projection (int key_count, Key const path_keys[], char *projection)
 Returns the net effective setting along a discrete segment path specified with a set of keys. More...
 
int HC_PShow_Net_Camera_Target (int key_count, Key const path_keys[], float *x, float *y, float *z)
 Returns the net effective setting along a specified path of keys rather than the local one. More...
 
int HC_PShow_Net_Camera_Up_Vector (int key_count, Key const path_keys[], float *x, float *y, float *z)
 Returns the net effective setting along a discrete segment path. More...
 
int HC_PShow_Net_Clip_Region (int count, Key const keys[], int *loopCount, int loopSizeArray[], Point points[], char *spec)
 Returns all the clip regions found on the key path passed to the function. More...
 
int HC_PShow_Net_Clip_Region_Size (int count, Key const keys[], int *loopCount, int *totalPointCount, char *spec)
 Similar to Show_Clip_Region_Size(), but returns the net effective value of the attribute(s) along a path of segments specified by an array of HC_KEYs. More...
 
bool HC_PShow_Net_Color (int count, Key const keys[], char *color_spec)
 Similar to Show_Color(), but returns the net effective settings along a discrete path of segments. More...
 
bool HC_PShow_Net_Color_Map (int key_count, Key const path_keys[], char *colors)
 
bool HC_PShow_Net_Color_Map_By_Value (int key_count, Key const path_keys[], char *color_space, int *count, RGB values[])
 Similar to Show_Color_Map_By_Value(), but returns the net effective setting along a discrete segment path. More...
 
bool HC_PShow_Net_Color_Map_Count (int key_count, Key const path_keys[], int *count)
 Similar to Show_Color_Map_Count(), but returns the net effective value of the attribute(s) along a path of segments specified by an array of HC_KEY's. More...
 
bool HC_PShow_Net_Color_Map_Length (int count, Key const keys[], int *value)
 Similar to Show_Color_Map(), but returns the net effective setting along a discrete segment path. More...
 
bool HC_PShow_Net_Conditions (int count, Key const keys[], char *options)
 Similar to Show_Conditions() but returns the net effective settings along a discrete segment path. More...
 
bool HC_PShow_Net_Conditions_Length (int count, Key const keys[], int *length)
 Similar to Show_Conditions_Length() but shows the net effective length along a discrete segment path. More...
 
bool HC_PShow_Net_Driver_Options (int key_count, Key const path_keys[], char *list)
 Similar to Show_Driver_Options(), but returns the net effective settings along a discrete segment path. More...
 
bool HC_PShow_Net_Edge_Pattern (int key_count, Key const path_keys[], char *pattern)
 Similar to Show_Edge_Pattern(), but returns the net effective setting along a discrete segment path. More...
 
bool HC_PShow_Net_Edge_Pattern_Exp (int count, Key const keys[], char *pattern)
 Similar to Show_Edge_Pattern_Explicit(), but returns the net effective setting along a discrete path of segments. More...
 
bool HC_PShow_Net_Edge_Weight (int key_count, Key const path_keys[], float *weight)
 Similar to Show_Edge_Weight(), but returns the net effective setting along a discreet segment path. More...
 
bool HC_PShow_Net_Explicit_Color (int keycount, Key const pathkeys[], char const *type, char const *channel, float rgb[], char *texture, char *options)
 Similar to Show_Explicit_Color(), but shows the net effective settings along a discrete segment path. More...
 
bool HC_PShow_Net_Face_Pattern (int key_count, Key const path_keys[], char *pattern)
 Similar to Show_Face_Pattern(), but returns the net effective setting rather than the local one. More...
 
bool HC_PShow_Net_Glyph (int count, Key const keys[], char const *name, char *definition)
 Similar to Show_Glyph(), but returns the net effective value along a discrete segment path. More...
 
bool HC_PShow_Net_Glyph_Size (int count, Key const keys[], char const *name, int *size)
 Similar to Show_Glyph_Size(), but returns the net effective value along a discrete segment path. More...
 
bool HC_PShow_Net_Handedness (int key_count, Key const path_keys[], char *value)
 Similar to Show_Handedness(), but returns the net effective setting along a discrete segment path. More...
 
bool HC_PShow_Net_Heuristics (int key_count, Key const path_keys[], char *list)
 Similar to Show_Heuristics(), but returns the net effective settings along a discrete segment path. More...
 
bool HC_PShow_Net_Line_Pattern (int key_count, Key const path_keys[], char *pattern)
 Similar to Show_Line_Pattern(), but returns the net effective setting along a discrete segment path. More...
 
bool HC_PShow_Net_Line_Pattern_Exp (int count, Key const keys[], char *pattern)
 Similar to Show_Line_Pattern_Explicit(), but returns the net effective setting along a discrete path of segments. More...
 
bool HC_PShow_Net_Line_Style (int count, Key const keys[], char const *name, char *definition)
 Similar to Show_Line_Style(), but returns the net effective value along a discrete segment path. More...
 
bool HC_PShow_Net_Line_Style_Size (int count, Key const keys[], char const *name, int *size)
 Similar to Show_Line_Style_Size(), but returns the net effective value along a discrete segment path. More...
 
bool HC_PShow_Net_Line_Weight (int key_count, Key const path_keys[], float *weight)
 Similar to Show_Line_Weight(), but returns the net effective setting along a discrete segment path. More...
 
bool HC_PShow_Net_Marker_Size (int key_count, Key const path_keys[], float *size)
 Similar to Show_Marker_Size(), but returns the net effective setting along a discrete segment path. More...
 
bool HC_PShow_Net_Marker_Symbol (int key_count, Key const path_keys[], char *symbol)
 Similar to Show_Marker_Symbol(), but returns the net effective setting along a discrete segment path. More...
 
int HC_PShow_Net_Modelling_Matrix (int key_count, Key const path_keys[], float matrix[])
 Similar to Show_Modelling_Matrix(), but returns the net effective value along a discrete segment path. More...
 
Key HC_PShow_Net_Named_Style (int count, Key const path_keys[], char const *style_name, char *style_segment_name)
 Similar to Show_Named_Style(), but returns the net effective value along a discrete segment path. More...
 
bool HC_PShow_Net_PBR_Material (int count, Key const *keys, char *base_color_map, char *normal_map, char *emissive_map, char *metalness_map, int *metalness_map_channel, char *roughness_map, int *roughness_map_channel, char *occlusion_map, int *occlusion_map_channel, RGBA *base_color_factor, float *normal_factor, float *metalness_factor, float *roughness_factor, float *occlusion_factor, float *alpha_factor, char *options)
 Shows the net physically-based rendering material on a segment with the attributes specified, according to the key path. More...
 
bool HC_PShow_Net_Rendering_Options (int key_count, Key const path_keys[], char *list)
 Similar to Show_Rendering_Options() but returns the net settings along a discrete path. More...
 
bool HC_PShow_Net_Selectability (int key_count, Key const path_keys[], char *list)
 Similar to Show_Selectability() but returns the net settings along a discrete path. More...
 
bool HC_PShow_Net_Shader (int count, Key const keys[], char const *name, char *output, char *shader_source)
 Similar to Show_Shader(), but returns the net effective value along a discrete segment path. More...
 
bool HC_PShow_Net_Shape (int count, Key const keys[], char const *name, float *definition)
 
bool HC_PShow_Net_Shape_Size (int count, Key const keys[], char const *name, int *size)
 
bool HC_PShow_Net_Text_Alignment (int key_count, Key const path_keys[], char *locater)
 Similar to Show_Text_Alignment(), but returns the net effective setting along a discrete segment path. More...
 
bool HC_PShow_Net_Text_Font (int key_count, Key const path_keys[], char *options)
 Similar to Show_Text_Font(), but returns the net effective settings along a discrete segment path. More...
 
bool HC_PShow_Net_Text_Path (int key_count, Key const path_keys[], float *x, float *y, float *z)
 Similar to Show_Text_Path(), but returns the net effective setting along a discrete segment path. More...
 
bool HC_PShow_Net_Text_Spacing (int key_count, Key const path_keys[], float *spacing)
 Similar to Show_Text_Spacing(), but returns the net effective setting along a discrete segment path. More...
 
bool HC_PShow_Net_Texture (int count, Key const keys[], char const *name, char *output, Key *out_image)
 Returns the net effective texture definition and image instead of the local one. More...
 
bool HC_PShow_Net_Texture_Matrix (int key_count, Key const path_keys[], float matrix[])
 Similar to Show_Texture_Matrix(), but returns the net effective matrix along a discrete segment path. More...
 
bool HC_PShow_Net_Unicode_Opt_Length (int key_count, Key const path_keys[], int *length)
 Returns the net effective value of the length along a path of segments specified by an array of HC_KEY's. More...
 
bool HC_PShow_Net_Unicode_Options (int key_count, Key const path_keys[], unsigned short *options)
 Similar to Show_Unicode_Options(), but returns the net effective value of the attribute(s) along a path of segments specified by an array of HC_KEY's. More...
 
bool HC_PShow_Net_User_Index_Count (int key_count, Key const keys[], int *count)
 Similar to Show_User_Index_Count(), but returns the net effective size rather than the local one. More...
 
bool HC_PShow_Net_User_Indices (int key_count, Key const path_keys[], int *count, long *indices, void **values)
 Similar to Show_User_Indices(), but returns the net effective settings along a discrete segment path. More...
 
bool HC_PShow_Net_User_Opt_Length (int key_count, Key const path_keys[], int *length)
 Finds the net effective value of the length along a path of segments specified by an array of HC_KEY's. More...
 
bool HC_PShow_Net_User_Options (int key_count, Key const path_keys[], char *list)
 Similar to Show_User_Options(), but returns the net effective settings along a discrete segment path. More...
 
bool HC_PShow_Net_User_Value (int key_count, Key const path_keys[], intptr_t *data)
 
bool HC_PShow_Net_Var_Edge_Weight (int count, Key const keys[], char *weight)
 Similar to Show_Variable_Edge_Weight(), but returns the net effective setting along a discrete segment path. More...
 
bool HC_PShow_Net_Var_Line_Weight (int count, Key const keys[], char *weight)
 Similar to Show_Variable_Line_Weight(), but returns the net effective setting along a discrete segment path. More...
 
bool HC_PShow_Net_Var_Marker_Size (int count, Key const keys[], char *size)
 Similar to Show_Variable_Marker_Size(), but returns the net effective setting along a discrete segment path. More...
 
bool HC_PShow_Net_Visibility (int key_count, Key const path_keys[], char *list)
 Similar to Show_Visibility(), but returns the net effective settings along a discreet segment path. More...
 
bool HC_PShow_Net_Window (int key_count, Key const path_keys[], float *left, float *right, float *bottom, float *top)
 Similar to Show_Window() but returns the net effective setting along a discrete segment path. More...
 
bool HC_PShow_Net_Window_Frame (int key_count, Key const path_keys[], char *flag)
 Similar to Show_Window_Frame(), but returns the net effective setting along a discrete segment path. More...
 
bool HC_PShow_Net_Window_Pattern (int key_count, Key const path_keys[], char *pattern)
 Similar to Show_Window_Pattern(), but returns the net effective setting along a discrete segment path. More...
 
bool HC_PShow_Net_Window_With_Options (int key_count, Key const path_keys[], float *left, float *right, float *bottom, float *top, char *list)
 
bool HC_PShow_One_Net_Callback (int count, Key const keys[], char const *callback_point, char *callback_name)
 Similar to PShow_Callback, but returns the net effective setting of a single callback along a path of segments specified by an array of HC_KEY's. More...
 
bool HC_PShow_One_Net_Callback_WD (int count, Key const keys[], char const *callback_point, char *callback, void **data)
 Returns the net effective setting of a single callback along a path of segment specified by an array of HC_KEY's. More...
 
bool HC_PShow_One_Net_Color (int count, Key const keys[], char const *type, char *color)
 Similar to Show_One_Color(), but returns the net effective value of a single attribute along a path of segments specified by an array of HC_KEY's. More...
 
bool HC_PShow_One_Net_Color_By_Index (int count, Key const keys[], char const *type, int *index)
 Similar to Show_One_Color(), but returns the net effective value of a single attribute along a path of segments specified by an array of HC_KEY's. More...
 
bool HC_PShow_One_Net_Color_By_Value (int count, Key const keys[], char const *type, char *color_space, float *a, float *b, float *c)
 Similar to Show_One_Color(), but returns the net effective value of a single attribute along a path of segments specified by an array of HC_KEY's. More...
 
bool HC_PShow_One_Net_Color_Map (int count, Key const keys[], int offset, char *color)
 Similar to Show_One_Color_Map(), but returns the net effective value of a single attribute along a path of segments specified by an array of HC_KEY's. More...
 
bool HC_PShow_One_Net_Color_Map_By_V (int count, Key const keys[], int offset, char *color_space, float *x, float *y, float *z)
 Similar to Show_One_Color_Map(), but returns the net effective value of a single attribute along a path of segments specified by an array of HC_KEY's. Operates with a color values rather than names or map indices. More...
 
bool HC_PShow_One_Net_Condition (int count, Key const keys[], char const *condition, char *options)
 Similar to Show_One_Condition() but returns the net effective value along a discrete segment path. More...
 
bool HC_PShow_One_Net_Driver_Option (int count, Key const keys[], char const *type, char *value)
 Show_One_Driver_Option() but returns the net settings along a discrete path. More...
 
bool HC_PShow_One_Net_Heuristic (int count, Key const keys[], char const *type, char *value)
 Similar to Show_One_Heuristic() but returns the net settings along a discrete path. More...
 
bool HC_PShow_One_Net_Rendering_Opti (int count, Key const keys[], char const *type, char *value)
 Similar to Show_One_Rendering_Option() but returns the net settings along a discrete path. More...
 
bool HC_PShow_One_Net_Selectability (int count, Key const keys[], char const *type, char *value)
 Similar to Show_One_Selectability() but returns the net settings along a discrete path. More...
 
bool HC_PShow_One_Net_Shader_Option (int count, Key const keys[], char const *name, char const *opt, char *output)
 Returns the value of the requested option set for a specific shader. More...
 
bool HC_PShow_One_Net_Text_Font (int count, Key const keys[], char const *type, char *value)
 Similar to Show_One_Text_Font() but returns the net settings along a discrete path. More...
 
bool HC_PShow_One_Net_Texture (int count, Key const keys[], char const *name, char const *opt, char *output)
 Similar to Show_One_Net_Texture(), but calculates the net effective value of a specific setting on the requested texture definition along a discrete segment path.. More...
 
bool HC_PShow_One_Net_Uni_Opt_Len (int count, Key const keys[], unsigned short const *which, int *length)
 Similar to PShow_Net_Unicode_Opt_Length(), but returns the net effective value of a single attribute along a path of segments specified by an array of HC_KEY's. More...
 
bool HC_PShow_One_Net_Unicode_Opt (int key_count, Key const keys[], unsigned short const *requested_option, unsigned short *options)
 Similar to Show_Unicode_Options(), but returns the net effective value of a single attribute along a path of segments specified by an array of HC_KEY's. More...
 
long HC_PShow_One_Net_User_Data (int count, Key const keys[], intptr_t index, void *data, long data_length)
 Similar to Show_One_User_Data() but returns the net effective settings along a discrete segment path. More...
 
bool HC_PShow_One_Net_User_Index (int count, Key const keys[], long index, void **value)
 Similar to Show_One_Net_User_Index() but returns the net settings along a discrete path. More...
 
bool HC_PShow_One_Net_User_Opt_Len (int count, Key const keys[], char const *which, int *length)
 Similar to Show_One_User_Option() but returns the net settings along a discrete path. More...
 
bool HC_PShow_One_Net_User_Option (int count, Key const keys[], char const *type, char *value)
 
bool HC_PShow_One_Net_Visibility (int count, Key const keys[], char const *type, char *value)
 Similar to Show_One_Visibility() but returns the net settings along a discrete path. More...
 
int HC_QShow_Existence (char const *segment, char const *filter)
 Similar to Show_Existence(), but operates on a given segment rather than the currently open one. More...
 
int HC_QShow_Existence_Unicode (char const *segment, unsigned short const *filter)
 Similar to Show_Existence_Unicode(), but operates on a given segment rather than the currently open one. More...
 
bool HC_Read_Metafile (char const *file, char const *segment, char const *options)
 Reads a metafile into a segment from a file. More...
 
void HC_Record_Instance_Handle (void const *handle)
 Registers the instance of the application with the HOOPS dynamic link library. More...
 
void HC_Record_Profile_Source (char const *section, char const *filename)
 Identifies the INI file name and section to use for evaluating profile strings. More...
 
Key HC_Reference_Geometry (char const *segname)
 Directs HOOPS to create a reference to some geometry when processing a segment. More...
 
Key HC_Reference_Geometry_By_Key (Key geom_key)
 Similar to Reference_Geometry(), but references a particular item, rather than a segment and all of its contents. More...
 
Key HC_Reference_Geometry_Key_By_Ke (Key target_segment, Key reference_key)
 Similar to Reference_Geometry(), but operates on the segment identified by target_segment instead of the currently open segment. More...
 
void HC_Regenerate_LOD (char const *segment, char const *options)
 Throws away any existing LODs in the provided segment tree and regenerates them according to the supplied options. More...
 
void HC_Regenerate_LOD_By_Key (Key segKey, char const *options)
 Similar to Regenerate_LOD(), but operates on an object referenced by an HC_KEY. More...
 
void HC_Relinquish_Memory (void)
 Returns temporary memory (kept internally by HOOPS) to the system. More...
 
void HC_Rename_Segment (char const *old_seg_name, char const *new_seg_name)
 Changes the name of a segment, and/or moves it somewhere else in the segment tree. More...
 
void HC_Rename_Segment_By_Key (Key key, char const *new_seg_name)
 
Key HC_Renumber_Key (Key oldkey, Key newkey, char const *scope)
 Changes the key for a segment, include, style, or piece of geometry to a value more useful to your program. More...
 
void HC_Report_Error (int category, int specific, int severity, int msgc, char const *const *msgv, int stack_c, char const *const *stack_v)
 Performs the default HOOPS error printing/displaying. More...
 
void HC_Reset_System (void)
 Performs a complete master reset of the HOOPS system. More...
 
void HC_Restart_Ink (void)
 Makes sure that the next Insert_Ink request in the current segment starts a brand-new line. More...
 
void HC_Reverse_Contents_Search (void)
 
void HC_Roll_Camera (double theta)
 Pinwheels the user's point of view around the viewing axis. More...
 
void HC_Rollback_Ink (int count)
 Removes vertices added to a polyline via Insert_Ink(). More...
 
void HC_Rotate_Object (double theta, double phi, double psi)
 Moves the represented object about its X-, Y-, or Z-axis. More...
 
void HC_Rotate_Object_Offaxis (double x, double y, double z, double theta)
 Moves the represented object about an arbitrary axis. More...
 
void HC_Rotate_Texture (double theta, double phi, double psi)
 Moves the represented texture about its U-, V-, or W-axis. More...
 
void HC_Rotate_Texture_Offaxis (double x, double y, double z, double theta)
 Rotates the represented texture coordinates (vertex parameters) about an arbitrary axis. More...
 
void HC_Scale_Object (double x, double y, double z)
 Enlarges or reduces objects within the user data space. Not to be confused with Zoom_Camera. More...
 
void HC_Scale_Texture (double u, double v, double w)
 Gives the appearance of enlarging or reducing the size of a surface's texture map by scaling the referenced (u, v, w) vertex parameters. More...
 
void HC_Scroll_Text (Key key, int left_scroll, int up_scroll)
 To shift text around as you would on a scrolling alphanumeric terminal screen. More...
 
void HC_Set_Bounding_Cuboid (Point const *min, Point const *max)
 Specifies the cuboid used by HOOPS to circumscribe the geometry within a segment. More...
 
void HC_Set_Bounding_Sphere (Point const *center, double radius)
 Specifies the sphere used by HOOPS to circumscribe the geometry within a segment. More...
 
void HC_Set_Callback (char const *callbacks)
 Establishes a procedural link between HOOPS database traversal and immediate mode rendering. More...
 
void HC_Set_Callback_With_Data (char const *callback, void const *data)
 Allows the user to provide a pointer to some data that will be accessible from a callback. The data is accessible via a call to HIC_Show_Callback_Data from within the callback function. More...
 
void HC_Set_Camera (Point const *position, Point const *target, Vector const *up, double width, double height, char const *projection)
 Allows the complete specification of the viewing camera's position, orientation, and field of view. More...
 
void HC_Set_Camera_By_Volume (char const *projection, double xmin, double xmax, double ymin, double ymax)
 Sets up the Camera so that the screen will show one simple rectangular box extracted from the infinite user data space. More...
 
void HC_Set_Camera_Field (double width, double height)
 After the viewing "camera" has been positioned, adjusts the width or height of the total field of view. More...
 
void HC_Set_Camera_Near_Limit (double wlimit)
 Controls the near camera plane setting. More...
 
void HC_Set_Camera_Position (double x, double y, double z)
 Sets up your viewing tripod within the framework of the scene you've created. More...
 
void HC_Set_Camera_Projection (char const *type)
 Lets you control how your 3-dimensional scene is to be converted to 2 dimensions for viewing. More...
 
void HC_Set_Camera_Target (double x, double y, double z)
 Determines what your viewing camera is looking at. More...
 
void HC_Set_Camera_Up_Vector (double x, double y, double z)
 Given a "camera" position and target, which define a line of sight, the "up vector" defines how much the camera is tilted. More...
 
void HC_Set_Circular_Center (double x, double y, double z)
 Allows the user to override the calculated center point for circle-based geometries such as circles, circular wedges, arcs, and chords. More...
 
void HC_Set_Circular_Center_By_Key (Key key, double x, double y, double z)
 Similar to Set_Circular_Center(), but operates on a piece of geometry identified by a key.
More...
 
void HC_Set_Color (char const *color_spec)
 Changes the color to be used when rendering the contents of a segment. Can also be used to select surface properties for use in lighting mode, and for special texture mapping effects. More...
 
void HC_Set_Color_By_FIndex (char const *types, double findex)
 This is a specialized version of Set_Color_By_Index for use with false-colored pictures. More...
 
void HC_Set_Color_By_Index (char const *types, int index)
 Changes the color to be used when rendering the contents of a segment. The color is defined indirectly, as a reference to the Color Map attribute. More...
 
void HC_Set_Color_By_Value (char const *types, char const *colorspace, double a, double b, double c)
 Changes the color to be used when rendering the contents of a segment. The color is defined numerically rather than by quoted-string. More...
 
void HC_Set_Color_Map (char const *colors)
 Sets up the colors to be used when displaying images or "by index" color attributes. More...
 
void HC_Set_Color_Map_By_Value (char const *color_space, int count, RGB const values[])
 Similar to Set_Color_Map(), but operates with a color values rather than names or map indices. More...
 
void HC_Set_Complex_Clip_Region (int loops, int const lengths[], Point const points[], char const *options)
 Defines a complex clip region in the segment tree. More...
 
void HC_Set_Conditional_Action (char const *options, char const *condition)
 Allows the user to associated specific action(s) with a set of conditions. More...
 
void HC_Set_Conditions (char const *list)
 Allows the user to set conditions on a segment that will be used to determine whether or not a Conditional Style or Conditional Include should be applied. More...
 
void HC_Set_Default_Glyphs ()
 Defines all default glyphs in the currently open segment. More...
 
void HC_Set_Default_Glyphs_By_Key (Key target_segment)
 Similar to Set_Default_Glyphs() but operates on a key rather than an open segment. More...
 
void HC_Set_Default_Line_Styles ()
 Defines all default line styles in the currently open segment. More...
 
void HC_Set_Default_Line_Styles_By_K (Key target_segment)
 Similar to Set_Default_Line_Styles() but operates on a key rather than an open segment. More...
 
void HC_Set_Default_Shapes ()
 
void HC_Set_Default_Shapes_By_Key (Key target_segment)
 
void HC_Set_Driver_Options (char const *list)
 Provides information to the system about a variety of special device-specific display options. More...
 
void HC_Set_Edge_Pattern (char const *pattern)
 Applies a pattern of dots and dashes, or whatever, to the edges of polygons, circles, ellipses, shells, and meshes. More...
 
void HC_Set_Edge_Pattern_Explicit (char const *pattern)
 Applies line style and inner joins options to the edges of polygons, circles, ellipses, shells, and meshes. More...
 
void HC_Set_Edge_Weight (double weight)
 Makes the edges of polygons, circles, ellipses, shells, and meshes broader or narrower than normal. More...
 
void HC_Set_Explicit_Color (char const *type, char const *channel, Point const *rgb, char const *texture, char const *options)
 Allows the specific channel, RGB, and texture components of a color definition to be set separately. More...
 
void HC_Set_Face_Pattern (char const *pattern)
 Allows a pattern to be applied to surfaces in the scene. More...
 
void HC_Set_Faces (int first_face, int face_count)
 Adds a specified range of shell faces to an open region. More...
 
void HC_Set_Geometry_Options (Key key, const char *list)
 Allows users to make geometry-specific settings on a variety of 3dGS geometric primitives. More...
 
void HC_Set_Handedness (char const *value)
 Changes the Cartesian world coordinate system from "left-handed" to "right-handed" and back again. More...
 
void HC_Set_Heuristics (char const *list)
 Gives hints to the system about good short cuts to take during program execution. More...
 
void HC_Set_Line_Pattern (char const *pattern)
 Applies a pattern of dashes and dots to lines and polylines. More...
 
void HC_Set_Line_Pattern_Explicit (char const *pattern)
 Applies line style, caps, joins and arrow options on a line or polyline to be set directly. More...
 
void HC_Set_Line_Weight (double weight)
 Makes simple lines and polylines broader or narrower than normal. More...
 
void HC_Set_Marker_Size (double weight)
 Makes marker symbols larger or smaller than usual. More...
 
void HC_Set_Marker_Symbol (char const *symbol)
 Changes the screen icon used to represent graphical "markers" in the scene. More...
 
void HC_Set_Modelling_Matrix (float const matrix[])
 Allows direct manipulation of the transformation that is applied against all the picture elements in a segment. More...
 
void HC_Set_Normal (double x, double y, double z)
 Forces the normal vector at a vertex, edge, or face to a particular value. More...
 
void HC_Set_Parameter (int number, float const parameters[])
 Defines texture mapping coordinates for a previously opened Shell or Mesh vertex. More...
 
void HC_Set_PBR_Material (char const *base_color_map, char const *normal_map, char const *emissive_map, char const *metalness_map, int metalness_map_channel, char const *roughness_map, int roughness_map_channel, char const *occlusion_map, int occlusion_map_channel, RGBA const *base_color_factor, float normal_factor, float metalness_factor, float roughness_factor, float occlusion_factor, float alpha_factor, char const *options)
 
void HC_Set_Polygonal_Clip_Region (int count, Point const points[], char const *options)
 Defines a polygonal region in the segment tree, where all geometry within and beneath that segment will be drawn either clipped to that region or masked out. More...
 
void HC_Set_Priority (Key key, int priority)
 Overrides the default drawing priority automatically assigned by HOOPS. More...
 
void HC_Set_Region (int region)
 Adds an open face to the specified region. More...
 
void HC_Set_Rendering_Options (char const *list)
 Allows you to control how carefully and accurately your scene is drawn, and to enable several special drawing effects. More...
 
void HC_Set_Selectability (char const *list)
 Allows you to make part of your picture sensitive or insensitive to being "selected" by the user. More...
 
void HC_Set_Streaming_Mode (char const *flag)
 Allows a segment to be dealt with in a "stream-of-consciousness" mode, in which setting an attribute only affects the drawing primitives that are inserted subsequently. More...
 
void HC_Set_Text_Alignment (char const *locater)
 Determines where in each chunk of text the "reference point" is to fall. More...
 
void HC_Set_Text_Font (char const *list)
 Chooses the character style to use for text. More...
 
void HC_Set_Text_Path (double x, double y, double z)
 Allows you to alter the direction in which text strings run. More...
 
void HC_Set_Text_Region (int pCount, Point const points[], char const *options)
 Allows the user to define a region into which the currently open text string will be fitted. More...
 
void HC_Set_Text_Size (double ivalue)
 
void HC_Set_Text_Spacing (double spacing)
 Allows you to space out or squeeze the text strings in a segment. More...
 
void HC_Set_Texture_Matrix (float const matrix[])
 Allows direct specification of the transformation that is applied against all vertex parameters in the segment's scope. More...
 
void HC_Set_Trim_Operation (int index, char const *operation)
 Sets the trim operation associated with a particular object in the trim list. More...
 
void HC_Set_Unicode_Options (unsigned short const *options)
 Stores a double byte character string in the currently opened segment. More...
 
void HC_Set_User_Data (intptr_t index, void const *data, long data_length)
 This function allows the user to associate binary data with a segment or piece of geometry in the database. More...
 
void HC_Set_User_Index (long index, void const *data)
 Associates a segment with an index into a user-defined array of option strings. More...
 
void HC_Set_User_Options (char const *list)
 Allows you to create new "attributes" of your own choosing. More...
 
void HC_Set_User_Value (intptr_t data)
 
void HC_Set_Variable_Edge_Weight (char const *weight)
 Defines weights for edges that scale in a similar manner to other geometric primitives. More...
 
void HC_Set_Variable_Line_Weight (char const *weight)
 Defines weights for lines that scale in a similar manner to other geometric primitives. More...
 
void HC_Set_Variable_Marker_Size (char const *size)
 Defines marker sizes that scale in a similar manner to other geometric primitives. More...
 
void HC_Set_Visibility (char const *list)
 Allows another level of control in determining whether a segment is visible. Useful for flicking graphics on and off without disturbing their place in the segment tree. More...
 
void HC_Set_Window (double left, double right, double bottom, double top)
 Limits the amount of the screen (or the containing Window) to be used by the referenced segment upon display. More...
 
void HC_Set_Window_Frame (char const *flag)
 Causes the system to automatically delineate any windows encountered. More...
 
void HC_Set_Window_Pattern (char const *pattern)
 Specifies the patterned texture to use for window backgrounds. More...
 
void HC_Set_Window_With_Options (double left, double right, double bottom, double top, char const *list)
 
void HC_Show_Alias (char const *alias, char *expansion)
 Returns the expansion of a given alias. More...
 
void HC_Show_Alias_Count (int *count)
 Finds out how many aliases will be returned. This is useful for determining the size of a data structure needed to store incoming items. More...
 
void HC_Show_Area_Light (Key key, int *ucount, Point upoints[], char *listptr)
 Shows the points and options associated with the area light of the given key. More...
 
void HC_Show_Area_Light_Count (Key key, int *count, char *listptr)
 
bool HC_Show_Attribute_Filter (Key key, char *filter)
 
bool HC_Show_Attribute_Filter_Length (Key key, int *filter_length)
 
bool HC_Show_Bounding_Cuboid (Point *min, Point *max)
 Returns the cuboid used by HOOPS to circumscribe the geometry within a segment. More...
 
bool HC_Show_Bounding_Cuboid_By_Key (Key key, Point *min, Point *max)
 Similar to Show_Bounding_Cuboid(), but operates on an object referenced by an HC_KEY. More...
 
void HC_Show_Bounding_Info (char *list)
 Identifies which type of bounding volume HOOPS is using to circumscribe geometry. More...
 
void HC_Show_Bounding_Info_By_Key (Key key, char *list)
 Similar to Show_Bounding_Info(), but operates on an object referenced by an HC_KEY. More...
 
bool HC_Show_Bounding_Sphere (Point *center, float *radius)
 Returns the sphere used by HOOPS to circumscribe the geometry within a segment. More...
 
bool HC_Show_Bounding_Sphere_By_Key (Key key, Point *center, float *radius)
 Similar to Show_Bounding_Sphere(), but operates on an object referenced by an HC_KEY. More...
 
void HC_Show_Button (char *button)
 Returns the name of the button that initiated the current event. More...
 
void HC_Show_Button_Source (char *keyboard, char *button, int *status)
 Returns the keyboard-device segment and the button specification that gave rise to the current button event. More...
 
void HC_Show_Callback (char *callbacks)
 Returns the name of a procedural link between HOOPS database traversal and immediate mode rendering. More...
 
void HC_Show_Callback_Name (char const *name, Void_Routine *callback)
 Shows the definition of a callback name. More...
 
void HC_Show_Callback_Name_Count (int *count)
 Finds out how many callback names will be returned. This is useful for determining the size of a data structure needed to store incoming items. More...
 
void HC_Show_Camera (Point *position, Point *target, Vector *up, float *width, float *height, char *projection)
 Returns the complete specification of the viewing camera's position, orientation, and field of view. More...
 
void HC_Show_Camera_By_Volume (char *projection, float *xmin, float *xmax, float *ymin, float *ymax)
 Returns the simple rectangular box in user data space as set in a previous call to Set_Camera_By_Volume(). More...
 
void HC_Show_Camera_Field (float *width, float *height)
 Returns the viewing camera's field of view. More...
 
bool HC_Show_Camera_Near_Limit (float *limit)
 Returns information about the camera near limit. More...
 
void HC_Show_Camera_Position (float *x, float *y, float *z)
 Returns the viewing camera's position. More...
 
void HC_Show_Camera_Projection (char *projection)
 Returns the viewing camera's projection. More...
 
void HC_Show_Camera_Target (float *x, float *y, float *z)
 Returns the viewing camera's target. More...
 
void HC_Show_Camera_Up_Vector (float *x, float *y, float *z)
 Returns the viewing camera's up-vector. More...
 
void HC_Show_Character_Attribute_Cou (Key key, int *count)
 Returns the number of characters in a given text string that have per-character attributes. More...
 
void HC_Show_Circle (Key key, Point *point1, Point *point2, Point *point3)
 Returns the three points used to define the circle, as referenced by a key. More...
 
void HC_Show_Circle_By_Radius (Key key, Point *center, float *radius, Vector *normal)
 Returns the center, radius and normal values used to define the circle, as referenced by a key. More...
 
void HC_Show_Circular_Arc (Key key, Point *point1, Point *point2, Point *point3)
 Returns the three points used to define the circular arc, as referenced by a key. More...
 
bool HC_Show_Circular_Center (Key key, float *x, float *y, float *z)
 Returns the center point of a given circle-based primitive. More...
 
void HC_Show_Circular_Chord (Key key, Point *point1, Point *point2, Point *point3)
 Returns the three points used to define the circular chord, as referenced by a key. More...
 
void HC_Show_Circular_Wedge (Key key, Point *point1, Point *point2, Point *point3)
 Returns the three points used to define the circular wedge, as referenced by a key. More...
 
void HC_Show_Clip_Region (int *loopCount, int loopSizeArray[], Point points[], char *options)
 Show the clip region settings on the currently open segment. More...
 
void HC_Show_Clip_Region_Size (int *loopCount, int *totalPointCount, char *options)
 Finds the size of a clip region. Use this function to determine the size of the data structure that must hold points in preparation for calling ShowClipRegion. More...
 
void HC_Show_Color (char *color_spec)
 Returns the named color(s) used to render the contents of the currently open segment. More...
 
void HC_Show_Color_By_Index (char *types, int *index)
 Returns the color map indices used to render the contents of the currently open segment. More...
 
void HC_Show_Color_By_Value (char *types, char *colorspace, float *a, float *b, float *c)
 Returns the numerically-defined colors of objects in the currently open segment. More...
 
void HC_Show_Color_Map (char *colors)
 Returns the color map that has been set on the currently open segment by a previous call to Set_Color_Map(). More...
 
void HC_Show_Color_Map_By_Value (char *color_space, int *count, RGB values[])
 Returns the color map that has been set on the currently open segment by a previous call to Set_Color_Map_By_Value(). More...
 
void HC_Show_Color_Map_Count (int *count)
 Shows the number of entries in the current virtual color map. More...
 
void HC_Show_Color_Map_Length (int *value)
 Returns the size of the color map that has been set on the currently open segment. More...
 
void HC_Show_Color_Name (char const *color, char *definition)
 Shows the definition of a color. More...
 
void HC_Show_Color_Name_Count (int *count)
 Finds out how many color names will be returned. This is useful for determining the size of a data structure needed to store incoming items. More...
 
void HC_Show_Compressed_Image (Key key, float *x, float *y, float *z, char *format, int *width, int *height, int *size, void *data)
 Returns the pixel data associated with provided image key. This API should only be used if the underlying image data is in a compressed form. More...
 
void HC_Show_Compressed_Image_Size (Key key, char *format, int *width, int *height, int *size)
 Finds the size of a particular image, This is useful in determining the size of the data structure that must hold data More...
 
void HC_Show_Cond_Action_Types (char *action_types)
 Shows all actions set in the current segment. More...
 
void HC_Show_Conditional_Include (Key key, char *pathname, char *conditions)
 Returns the pathname and valid conditions that have been established by a previous call to Conditional_Include(). More...
 
void HC_Show_Conditional_Named_Style (Key style_key, char *style_name, char *condition)
 
Key HC_Show_Conditional_Reference (Key reference_key, char *conditions)
 Returns the identifier of the original geometry or segment, and the conditions for the reference, for a particular reference key. More...
 
void HC_Show_Conditional_Style (Key key, char *pathname, char *conditions)
 Returns the pathname and valid conditions that have been established by a previous call to Conditional_Style(). More...
 
void HC_Show_Conditions (char *list)
 Returns the conditions that have been set on the currently open segment during a previous call to Set_Conditions(). More...
 
void HC_Show_Conditions_Length (int *length)
 Determines string length for proper buffer allocation on a call to Show_Conditions(). More...
 
void HC_Show_Contents_Count (int *count)
 Finds out how many objects will be returned. This is useful for determining the size of a data structure needed to store incoming items. More...
 
void HC_Show_Cutting_Plane (Key key, float *a, float *b, float *c, float *d)
 Returns the the coefficients used to define the cutting plane, as referenced. More...
 
void HC_Show_Cutting_Section (Key key, int *count, Plane planes[])
 Returns the array of coefficients used to define a cutting section. More...
 
void HC_Show_Cutting_Section_Count (Key key, int *count)
 Returns the number of plane-defining quadruplets in planes. More...
 
void HC_Show_Cylinder (Key key, Point *p1, Point *p2, float *radius, char *cap)
 Returns the previous definition of a cylinder, as referenced by a key. More...
 
void HC_Show_Device_Info (char const *driver, char const *item, char *data)
 Returns selected information about the physical device. More...
 
void HC_Show_Device_Info_By_Key (Key key, char const *item, char *data)
 Similar to Show_Device_Info(), but the driver segment is identified by a key instead of by name. More...
 
void HC_Show_Distant_Light (Key key, float *di, float *dj, float *dk)
 Returns the direction of a "distant light", as referenced by a key. More...
 
void HC_Show_Driver_Options (char *list)
 Returns a list of the driver options that have been set on the currently open segment. More...
 
void HC_Show_Edge_Pattern (char *pattern)
 Returns the edge pattern that has been set on the currently open segment. More...
 
void HC_Show_Edge_Pattern_Explicit (char *pattern)
 Returns the explicit edge pattern that has been set on the currently open segment. More...
 
void HC_Show_Edge_Weight (float *weight)
 Returns the edge weight that has been set on the currently open segment. More...
 
void HC_Show_Ellipse (Key key, Point *center, Point *major, Point *minor)
 Returns the three points used to define the ellipse, as referenced by a key. More...
 
void HC_Show_Elliptical_Arc (Key key, Point *center, Point *major, Point *minor, float *start, float *end)
 Returns the three points and two distances used to define the elliptical arc referenced by a key. More...
 
bool HC_Show_Environment (char const *variable, char *value)
 Allows you to retrieve information from the operating system environment of your running program. More...
 
bool HC_Show_Error (char *severity, int *category, int *severity_level)
 Shows whether a severe error was generated during the previous HOOPS call and returns the error components if true. More...
 
void HC_Show_Error_Handler_Count (int *count)
 Finds out how many error handlers will be returned. More...
 
int HC_Show_Existence (char const *filter)
 A utility routine to determine how much of something exists within a segment, or if it exists at all. More...
 
int HC_Show_Existence_By_Key (Key key, char const *filter)
 Similar to Show_Existence(), but operates on an object referenced by an HC_KEY. More...
 
int HC_Show_Existence_Unicode (unsigned short const *filter)
 A utility routine used to determine whether one or more unicode user options exist within a segment. More...
 
int HC_Show_Existence_Unicode_By_K (Key key, unsigned short const *filter)
 Similar to Show_Existence_Unicode(), but operates on an object referenced by an HC_KEY. More...
 
void HC_Show_Exit_Handler_Count (int *count)
 Finds out how many exit handlers will be returned. More...
 
void HC_Show_Explicit_Color (char const *type, char const *channel, float rgb[], char *texture, char *options)
 Returns the various components of a color definition. More...
 
void HC_Show_Face_Pattern (char *pattern)
 Returns the face pattern that has been set on the currently open segment. More...
 
void HC_Show_Faces (int *face_count, int faces[])
 Show faces associated with the currently open region. More...
 
void HC_Show_Faces_Count (int *face_count)
 Finds the number of faces in a given region. This is useful in determining the size of the data structure that must holds faces More...
 
void HC_Show_Font (char const *name, char *options, int *data_length, char *data)
 Describes a specific set of simple geometry to be used as the actual shapes when drawing text characters. More...
 
void HC_Show_Font_Count (int *count)
 Finds out how many font names will be returned. This is useful for determining the size of a data structure needed to store incoming items. More...
 
void HC_Show_Font_Info (char const *driver, char const *name, char const *item, char *data)
 Returns selected information about the specified font. More...
 
void HC_Show_Font_Info_By_Path (int count, Key const keys[], char const *font, char const *item, char *data)
 Similar to Show_Font_Info(), but returns the net effective font information along a discrete segment path. More...
 
void HC_Show_Font_Size (char const *name, char *options, int *data_length)
 Finds the size in bytes of a particular font. This is useful in determining the size of the data structure that must hold data More...
 
void HC_Show_Geometry_Options (Key key, char *list)
 Shows options that have been attached to geometry by Set_Geometry_Options. More...
 
void HC_Show_Geometry_Pointer (Key key, const char *data_type, void *value)
 Retrieves a pointer to the internal data structure of the object identified by key. More...
 
void HC_Show_Glyph (char const *name, char *data)
 Returns the definition of a glyph as established by a previous call to Define_Glyph(). More...
 
void HC_Show_Glyph_Count (int *count)
 Finds out how many glyphs will be returned. This is useful for determining the size of a data structure needed to store incoming items. More...
 
void HC_Show_Glyph_Size (char const *name, int *data_size)
 Finds the size in bytes of a particular glyph. This is useful in determining the size of the structure that must hold data. More...
 
void HC_Show_Grid (Key key, char *type, Point *origin, Point *ref1, Point *ref2, int *count1, int *count2)
 Retrieves the original definition of a grid. More...
 
void HC_Show_Handedness (char *value)
 Returns the type of Cartesian coordinate system that has been set on the currently open segment. More...
 
void HC_Show_Heuristics (char *list)
 Returns the heuristic settings that have been made on the currently open segment. More...
 
void HC_Show_Highlight_Count (int *count, int *max_length)
 Returns the number of distinct highlights collected, and the maximum number of keys that will be returned in the results to Find_Highlight(). More...
 
void HC_Show_Image (Key key, float *x, float *y, float *z, char *format, int *width, int *height, void *data)
 Returns the rectangular array of pixel data, as referenced by a key. More...
 
int HC_Show_Image_Bytes_Per_Pixel (Key key)
 
void HC_Show_Image_Format (Key key, char *format)
 Returns the underlying format of the raster data in the provided image. More...
 
void HC_Show_Image_Name (Key key, char *name)
 Returns the name associated with an image key. More...
 
void HC_Show_Image_Size (Key key, float *x, float *y, float *z, char *format, int *width, int *height)
 Finds the size of a particular image, This is useful in determining the size of the data structure that must hold data More...
 
Key HC_Show_Include_Segment (Key key, char *pathname)
 Returns the segment that is referenced by an inclusion. More...
 
void HC_Show_Infinite_Line (Key key, float *xa, float *ya, float *za, float *xb, float *yb, float *zb)
 Returns the vector of points that define an infinite line, as referenced by a key. More...
 
void HC_Show_Infinite_Ray (Key key, float *xa, float *ya, float *za, float *xb, float *yb, float *zb)
 Returns the vector of points that define an infinite ray, as referenced by a key. The key might come from Show_Selection_Element() or Find_Contents(), or it might have been saved during a previous call to Insert_Infinite_Ray(). More...
 
int HC_Show_Intersect_Polyline_Size (int pcount1, Point const points1[], int flist_length3, int const face_list1[], int pcount2, Point const points2[], int flist_length2, int const face_list2[], int *polyline_count, int *polyline_points_count)
 Finds the size of the intersecting polyline. This is useful for determining the size of a data structure needed to store the polyline returned by Compute_Intersect_Polyline(). More...
 
void HC_Show_Key_Status (Key key, char *status)
 Helps to maintain lists of valid keys. More...
 
void HC_Show_Key_Type (Key key, char *type)
 Returns the type of object referenced by a key. More...
 
void HC_Show_Line (Key key, float *xa, float *ya, float *za, float *xb, float *yb, float *zb)
 Returns the endpoints of the line, as referenced by a key. More...
 
void HC_Show_Line_Pattern (char *pattern)
 Returns the line pattern that has been set on the currently open segment. More...
 
void HC_Show_Line_Pattern_Explicit (char *pattern)
 Returns the explicit line pattern that has been set on the currently open segment. More...
 
void HC_Show_Line_Style (char const *style, char *definition)
 Returns the line style that has been set on the currently open segment. More...
 
void HC_Show_Line_Style_Count (int *count)
 Finds out how many line styles will be returned. This is useful for determining the size of a data structure needed to store incoming items. More...
 
void HC_Show_Line_Style_Size (char const *style, int *size)
 Returns the size of the line style that has been set on the currently open segment. More...
 
void HC_Show_Line_Weight (float *weight)
 Returns the line weight that has been set on the currently open segment. More...
 
void HC_Show_Local_Light (Key key, float *x, float *y, float *z)
 Returns the position of a "local light", as referenced by a key. More...
 
void HC_Show_Local_Texture (char const *texture_name, char *definition)
 Retrieves a texture definition from the currently open segment. More...
 
void HC_Show_Location (float *x, float *y)
 Returns the raw 2-D position that was indicated by the user. More...
 
void HC_Show_Location_Source (char *locater, char *display, char *action, int *status)
 Returns the locater-device segment and the user action that gave rise to the current location event. More...
 
void HC_Show_LOD_Type (Key key, int level, char *type)
 Determines whether a given LOD level exists, and if so, its type. More...
 
void HC_Show_Marker (Key key, float *x, float *y, float *z)
 Returns the position of a marker, as referenced by a key. More...
 
void HC_Show_Marker_Size (float *size)
 Returns the marker scale that has been set on the currently open segment. More...
 
void HC_Show_Marker_Symbol (char *symbol)
 Returns the marker symbol that has been set on the currently open segment. More...
 
void HC_Show_Memory_Usage (long *allocated, long *in_use)
 Tells your program how much memory is being used for graphics data storage. More...
 
void HC_Show_Mesh (Key key, int *rows, int *columns, Point points[])
 Returns the previous definition of a mesh, as referenced by a key. More...
 
void HC_Show_Mesh_Size (Key key, int *rows, int *columns)
 Finds the size of a given mesh. This is usefule in determining the size of the data structure that must hold points More...
 
void HC_Show_Modelling_Matrix (float matrix[])
 Returns the modelling matrix that has been set on the currently open segment. More...
 
Key HC_Show_Named_Style (char const *style_name, char *style_source)
 Returns the segment path of a named style established by a previous call to Define_Named_Style(). More...
 
void HC_Show_Named_Style_Count (int *count)
 Returns the number of named styles established by previous calls to Define_Named_Style(). More...
 
void HC_Show_Named_Style_Segment (Key style_key, char *style_name)
 Returns the name of a named style previously defined by Define_Named_Style(). More...
 
void HC_Show_Net_Normal (float *x, float *y, float *z)
 Similar to Show_Normal(), but returns the net effective normal rather than the local one. More...
 
void HC_Show_Normal (float *x, float *y, float *z)
 Returns the normal for the currently open vertex or face. More...
 
void HC_Show_NURBS_Curve (Key key, int *degree, int *cp_count, Point points[], float weights[], float knots[], float *start_u, float *end_u)
 Returns the previous definition of a NURBS curve, as referenced by a key. More...
 
void HC_Show_NURBS_Curve_Size (Key key, int *degree, int *cp_count, int *weight_count, int *knot_count)
 Finds the size of a given NURBS curve. This is useful in determining the size of the data structure that must hold points More...
 
void HC_Show_NURBS_Surface (Key key, int *u_degree, int *v_degree, int *u_count, int *v_count, Point points[], float weights[], float u_knots[], float v_knots[])
 
void HC_Show_NURBS_Surface_Size (Key key, int *u_degree, int *v_degree, int *u_count, int *v_count, int *weights_count, int *u_knots_count, int *v_knots_count)
 Returns the definition of an existing NURBS surface, as referenced by a key. More...
 
void HC_Show_One_Callback (char const *callback_point, char *callback_name)
 Similar to Show_Callback(), but returns the setting of a single callback point in the currently open segment. More...
 
void HC_Show_One_Callback_With_Data (char const *callback_point, char *callback, void **data)
 Retrieves the data pointer that was passed in during a previous call to Set_Callback_With_Data(). More...
 
void HC_Show_One_Character_Attribute (Key key, int offset, char const *which, char *options)
 Returns one per-character attribute setting from a given text string. More...
 
void HC_Show_One_Color (char const *type, char *color)
 Returns the color value for one particular type of geometry. More...
 
void HC_Show_One_Color_By_Index (char const *type, int *index)
 Similar to Show_One_Color(), but returns the value of a single attribute in the currently open segment. More...
 
bool HC_Show_One_Color_By_Value (char const *type, char *color_space, float *a, float *b, float *c)
 Similar to Show_One_Color(), but returns the value of a single attribute in the currently open segment. Operates with a color values rather than names or map indices. More...
 
void HC_Show_One_Color_Map (int offset, char *color)
 Shows a single entry in the current virtual color map. More...
 
void HC_Show_One_Color_Map_By_Value (int offset, char *color_space, float *a, float *b, float *c)
 Similar to Show_One_Color_Map(), but returns the value of a single attribute in the currently open segment. More...
 
void HC_Show_One_Condition (char const *condition, char *value)
 Similar to Show_Conditions() but returns the value of a single option rather than the entire list. More...
 
void HC_Show_One_Conditional_Action (char const *action_type, char *options, char *condition)
 Shows the options and conditions for the specified action. More...
 
void HC_Show_One_Driver_Option (char const *type, char *value)
 Similar to Show_Driver_Options() but returns a single option rather than the entire set. More...
 
void HC_Show_One_Heuristic (char const *type, char *value)
 Similar to Show_Heuristics() but returns a single setting, rather than the entire set. More...
 
void HC_Show_One_Rendering_Option (char const *type, char *value)
 Similar to Show_Rendering_Options() but returns a single setting, rather than the entire set. More...
 
void HC_Show_One_Selectability (char const *type, char *value)
 Similar to Show_Selectability() but returns a single setting, rather than the entire set. More...
 
void HC_Show_One_System_Option (char const *type, char *value)
 Similar to Show_System_Options(), but returns the value of a single attribute in the currently open segment. More...
 
void HC_Show_One_Text_Font (char const *type, char *value)
 Similar to Show_Text_Font() but returns a single setting, rather than the entire set. More...
 
void HC_Show_One_Uni_Option_Length (unsigned short const *text, int *length)
 Similar to PShow_Net_Unicode_Opt_Length(), but returns the value of a single attribute in the currently open segment. More...
 
void HC_Show_One_Unicode_Option (unsigned short const *requestedOption, unsigned short *options)
 Similar to Show_Unicode_Options(), but returns the value of a single attribute in the currently open segment. More...
 
long HC_Show_One_User_Data (intptr_t index, void *data, long data_length)
 Returns the user data that has been set on the currently open segment and associated with a specific unique index. More...
 
bool HC_Show_One_User_Index (long index, void **value)
 Similar to Show_User_Index() but returns a single setting, rather than the entire set. More...
 
void HC_Show_One_User_Option (char const *type, char *value)
 Similar to Show_User_Options() but returns a single setting, rather than the entire set. More...
 
void HC_Show_One_User_Option_Length (char const *which, int *length)
 Similar to Show_User_Options_Length(), but returns the value of a single attribute in the currently open segment. More...
 
void HC_Show_One_Visibility (char const *type, char *value)
 Similar to Show_Visibility() but returns a single setting, rather than the entire set. More...
 
void HC_Show_Open_Item_Count (int *count)
 Finds out how many items will be returned. This is useful for determining the size of a data structure needed to store incoming items. More...
 
void HC_Show_Open_Segment_Count (int *count)
 Finds out how many segments will be returned. This is useful for determining the size of a data structure needed to store incoming items. More...
 
void HC_Show_Optimized_Mapping (char const *segname, char const *direction, Key in_owner, Key in_key, int in_region, Key *out_owner, Key *out_key, int *out_region)
 Allows a user to map a piece of geometry between an old segment tree and a new segment tree (or vice-versa) that has been generated during a call to Optimize_Segment_Tree(). More...
 
Key HC_Show_Original_Key (Key key)
 Returns the original (non-renumbered) version of a key.
More...
 
Key HC_Show_Owner (char const *segment, char *owner)
 Returns the segment which contains a given segment or which contains an item with a given key. More...
 
Key HC_Show_Owner_By_Key (Key key, char *owner)
 Similar to Show_Owner(), but operates on an object referenced by an HC_KEY. More...
 
Key HC_Show_Owner_Original_Key (Key key)
 Similar to Show_Owner() but returns the non-renumber key of the owning segment. More...
 
void HC_Show_Parameter (int *size, float list[])
 Returns the parameters that have been set on the currently open vertex. More...
 
void HC_Show_Parameter_Size (int *size)
 Returns the size of the list array. Always three (3) for now. More...
 
void HC_Show_Partial_Image (Key key, int xpos, int ypos, int xlen, int ylen, void *data)
 Returns a user-specified rectangular array of pixel data, as referenced by a key. More...
 
void HC_Show_Partial_Mesh (Key key, int row_offset, int col_offset, int row_count, int col_count, Point points[])
 Returns a portion of the previous definition of a mesh, as referenced by a key. More...
 
void HC_Show_Partial_Polygon (Key key, int offset, int request, Point points[])
 Returns a portion of the vector of points along the edge of a given polygon, as referenced by a key. More...
 
void HC_Show_Partial_Polyline (Key key, int offset, int request, Point points[])
 Returns a portion of the vector of points along a given polyline, as referenced by a key. More...
 
void HC_Show_Partial_Shell (Key key, int voffset, int vcnt, Point points[], int foffset, int fcnt, int *flist_length, int face_list[])
 Returns a portion of the previous definition of a shell, as referenced by a key. More...
 
void HC_Show_Partial_Shell_Size (Key key, int foffset, int fcnt, int *flist_length)
 Finds the size of a portion of a shell. This is useful in determining the size of the data structure that must hold the points and face_list arrays in Show_Partial_Shell(). More...
 
void HC_Show_Pathname_Expansion (char const *pathname, char *expansion)
 Identifies the full absolute pathname corresponding to a relative pathname. More...
 
bool HC_Show_PBR_Material (char *base_color_map, char *normal_map, char *emissive_map, char *metalness_map, int *metalness_map_channel, char *roughness_map, int *roughness_map_channel, char *occlusion_map, int *occlusion_map_channel, RGBA *base_color_factor, float *normal_factor, float *metalness_factor, float *roughness_factor, float *occlusion_factor, float *alpha_factor, char *options)
 Shows a physically-based rendering material on a segment with the attributes specified. More...
 
void HC_Show_PolyCylinder (Key key, int *p_count, Point pts[], int *r_count, float radii[], char *capping)
 Returns the previous definition of a polycylinder, as referenced by a key. More...
 
void HC_Show_PolyCylinder_Counts (Key key, int *p_count, int *r_count, char *capping)
 Finds the number of items in a given polycylinder. This is useful in determining the size of the data structure that holds pts More...
 
void HC_Show_Polygon (Key key, int *count, Point points[])
 Returns the vector of points along the edge of the polygon referenced by a key. More...
 
void HC_Show_Polygon_Count (Key key, int *count)
 Finds the number of points in a given polygon. This is useful in determining the size of the data structure that must hold points More...
 
void HC_Show_Polyline (Key key, int *count, Point points[])
 Returns the vector of points along the polyline, as referenced by a key. More...
 
void HC_Show_Polyline_Count (Key key, int *count)
 Finds the number of points in a given polyline. This is useful in determining the size of the data structure that must hold points More...
 
bool HC_Show_Priority (Key key, int *priority)
 Returns the drawing priority corresponding to the given key. More...
 
void HC_Show_Priority_Range (Key key, int *low, int *high)
 Returns the lowest and highest priority subsegments within a segment identified by key. More...
 
Key HC_Show_Reference_Geometry (Key reference_key)
 Returns the identifier of the original geometry or segment referenced by a particular reference key. More...
 
void HC_Show_Reference_Geometry_Filt (Key key, char *filter)
 
void HC_Show_Reference_Keys (Key key, int *count, Key keys[])
 Returns a list of keys that a given segment references. More...
 
void HC_Show_Reference_Keys_Count (Key key, int *count)
 Returns the number of references that a given segment references. More...
 
void HC_Show_Region (int region[])
 Show the region associated with the currently open face. More...
 
void HC_Show_Region_Range (Key key, int *lowest, int *highest)
 Return the range of region numbers associated with a given shell. More...
 
void HC_Show_Rendering_Options (char *list)
 Returns a list of the rendering options that have been set on the currently open segment. More...
 
Key HC_Show_Renumbered_Key (Key key, char *status)
 Returns the key value of an object after it was renumbered. More...
 
int HC_Show_Sample_Max_Length ()
 Returns the maximum number of keys that will be returned by a call to Find_Next_Sample. More...
 
Key HC_Show_Segment (Key key, char *pathname)
 Returns the segment name corresponding to the given key. More...
 
void HC_Show_Segment_Count (int *count)
 Finds out how many segments will be returned. This is useful for determining the size of a data structure needed to store incoming items. More...
 
Key HC_Show_Segment_Name (Key key, char *name)
 
int HC_Show_Segment_Name_Length (Key key)
 
void HC_Show_Selectability (char *list)
 Returns a list of the selectability options that have been set on the currently open segment. More...
 
void HC_Show_Selection (char *segment)
 Returns the name of the segment that was selected by the user. More...
 
void HC_Show_Selection_Element (Key *key, int *offset1, int *offset2, int *offset3)
 Returns the key of the database element that was selected by the user, plus an offset within that element. More...
 
void HC_Show_Selection_Elements (Key *key, int *count, int vertex1[], int vertex2[], int faces[])
 Returns the key of the database element that was selected by the user, plus arrays of offsets describing the selected item's sub-elements. More...
 
void HC_Show_Selection_Elements_Coun (Key *key, int *count)
 Finds the number of elements in a particular item in a selection list. This is useful in determining the object type of the selection object. More...
 
void HC_Show_Selection_Item (Key *key, int *offset1, int *offset2)
 
void HC_Show_Selection_Keys (int *count, Key keys[])
 Returns the key of the item that was selected by the user, and the keys for all the segments in the path to that item. More...
 
void HC_Show_Selection_Keys_Count (int *count)
 Finds the number of keys for a given selection. This is useful in determining the size of the data structure that must hold keys More...
 
void HC_Show_Selection_Location (float *xw, float *yw, float *xc, float *yc, float *zc)
 
void HC_Show_Selection_Original_Key (Key *key)
 Returns the original HOOPS key to a renumbered selection object. More...
 
void HC_Show_Selection_Original_Keys (int *count, Key key[])
 Returns an array of original HOOPS keys that delineate the ownership of the selection object. More...
 
void HC_Show_Selection_Pathname (char *segment)
 Returns the fully-qualified name of the segment that was selected by the user. More...
 
int HC_Show_Selection_Position (float *window_x, float *window_y, float *window_z, float *camera_x, float *camera_y, float *camera_z)
 Shows the position that has just been used to select something. The position is returned in terms of both window coordinates and world coordinates. More...
 
void HC_Show_Selection_Source (char *locater, char *picture, char *action, int *status)
 Returns the locater-device segment, the picture segment, and the user action that gave rise to the current selection event. More...
 
void HC_Show_Selection_Source_Elem (int *vertex, int *edge, int *face, Point *hit_location)
 Returns the location on a shell where a hit would occur if that shell was moved along the vector to the nearest piece of geometry. More...
 
void HC_Show_Shader (char const *name, char *definition, char *shader_source)
 Returns the options and source associated with the shader whose name was passed. More...
 
void HC_Show_Shape (char const *name, float *data)
 
void HC_Show_Shape_Count (int *count)
 
void HC_Show_Shape_Size (char const *name, int *data_size)
 
void HC_Show_Shell (Key key, int *pcount, Point points[], int *flist_length, int face_list[])
 Returns the previous definition of a shell, as referenced by a key. More...
 
void HC_Show_Shell_By_Tristrips (Key key, int *pcount, Point points[], int *tristrips_length, int tristrips[], int *face_indices_length, int face_indices[])
 Returns the previous definition of a shell, as referenced by a key. More...
 
void HC_Show_Shell_By_Tristrips_Size (Key key, int *pcount, int *tristrips_length, int *face_indices_length)
 Finds the size of a shell that has been inserted by tristrips. This is useful in determining the size of the data structures that must hold points, tristrips, and face_indices. More...
 
void HC_Show_Shell_Face_Count (Key key, int *face_count)
 Returns the number of faces in the shell in constant time. More...
 
void HC_Show_Shell_Size (Key key, int *pcount, int *flist_length)
 Finds the size of a given shell. This is useful in determining the size of the data structures that must hold points and face_list More...
 
void HC_Show_Shell_Tristrip_Count (Key key, int *tristrip_count)
 Returns the tristrip count for a shell after it has been prepared for rendering. More...
 
bool HC_Show_Snapshot (const char *display, int *width, int *height, void *image_data)
 Takes a snapshot of the scene. More...
 
void HC_Show_Sphere (Key key, Point *center, float *radius, Vector *axis, Vector *ortho)
 Returns the parameters of a sphere, as defined in a previous call to Insert_Sphere(). More...
 
void HC_Show_Spot_Light (Key key, Point *position, Point *target, char *list)
 Returns a full description of the "spot light" referenced by a key. More...
 
void HC_Show_Streaming_Mode (char *flag)
 Returns the streaming mode that has been set on the currently open segment. More...
 
void HC_Show_String (char *text)
 Returns the text string that caused the current string-input event. More...
 
void HC_Show_String_Count (int *count)
 Finds the number of characters in the string the user has just finished typing in. More...
 
void HC_Show_String_Cursor (Key key, Key *text_key, int *row, int *col)
 Retrieves the key of the owning text, and position within that text, of a previously defined string cursor. More...
 
void HC_Show_String_Length (int *length)
 Finds the number of bytes in the string the user has just finished typing in. More...
 
void HC_Show_String_Source (char *keyboard, Key *cursor_key)
 Returns the keyboard-device segment and cursor that gave rise to the current string event. More...
 
void HC_Show_String_With_Encoding (char *encoding, void *text)
 Similar to Show_String(), but operates on encoded text rather than Latin1 text. More...
 
Key HC_Show_Style_Segment (Key key, char *pathname)
 Returns the segment that is referenced by a style inclusion. More...
 
bool HC_Show_System_Info (char const *type, char *value)
 Provides information on the capabilities of the HOOPS library in use. More...
 
void HC_Show_System_Options (char *list)
 Examines the current list of debugging/control "system options". More...
 
void HC_Show_Text (Key key, float *x, float *y, float *z, char *text)
 Returns the position, size, and contents of a previously defined text string, as referenced by a key. More...
 
void HC_Show_Text_Alignment (char *locater)
 Returns the text alignment settings that have been made on the currrently open segment. More...
 
void HC_Show_Text_Count (Key key, int *count)
 Finds the number of characters in a given text string, as reference by a key. More...
 
void HC_Show_Text_Encoding (Key key, char *encoding)
 Finds the type of encoding with which a particular string was inserted, as referenced by a key. More...
 
void HC_Show_Text_Font (char *options)
 Returns the font settings that have been made on the currrently open segment. More...
 
void HC_Show_Text_Leader (Key key, float *x, float *y, float *z, char *options)
 
void HC_Show_Text_Length (Key key, int *length)
 Finds the number of bytes in a given text string, as referenced by a key. More...
 
void HC_Show_Text_Path (float *x, float *y, float *z)
 Returns the text path that has been set on the currrently open segment. More...
 
void HC_Show_Text_Region (int *count, Point points[], char *options)
 Show the text region settings on the currently open text string. More...
 
void HC_Show_Text_Region_Count (int *count)
 Finds the number of points in a text region. This is useful in determining the size of the data structure that must hold points More...
 
void HC_Show_Text_Size (float *value)
 
void HC_Show_Text_Spacing (float *spacing)
 Returns the text spacing that has been set on the currrently open segment. More...
 
void HC_Show_Text_With_Encoding (Key key, float *x, float *y, float *z, char *encoding, void *text)
 Similar to Show_Text, but operates on encoded text rather than Latin1 text. More...
 
void HC_Show_Texture (char const *texture, char *definition)
 Shows the definition of a texture. More...
 
void HC_Show_Texture_Count (int *count)
 Finds out how many textures will be returned. This is useful for determining the size of a data structure needed to store incoming items. More...
 
void HC_Show_Texture_Matrix (float matrix[])
 Returns the transformation that has been set against all vertex parameters in the scope of the currently open segment. More...
 
void HC_Show_Time (float *time)
 Returns the time elapsed in the current program execution. More...
 
void HC_Show_Trim_Count (int *count)
 Returns the number of objects in the trim list of the currently open NURBS surface or trim collection. More...
 
void HC_Show_Trim_Curve (int index, int *degree, int *cp_count, float points[], float weights[], float knots[], float *start_u, float *end_u)
 Returns the definition of an existing NURBS curve trim object. More...
 
void HC_Show_Trim_Curve_Count (int index, int *degree, int *cp_count, int *w_count, int *knot_count)
 Finds the number of points in a trim curve. This is useful in determining the size of the data structure that must hold points More...
 
void HC_Show_Trim_Operation (int index, char *operation)
 Shows the type of trimming currently associated with an object in the trim list. More...
 
void HC_Show_Trim_Poly (int index, int *count, float points[])
 Returns the definition of an existing trimming polyline. More...
 
void HC_Show_Trim_Poly_Count (int index, int *count)
 Finds the number of points in a a trim polyline. This is useful in determining the size of the data structure that must hold points More...
 
void HC_Show_Trim_Type (int index, char *trim_type)
 Returns the type of an object on the trim list of the currently open NURBS surface or trim collection. More...
 
void HC_Show_Unicode_Options (unsigned short *options)
 Show the unicode user options string stored on the currently open segment. More...
 
void HC_Show_Unicode_Options_Length (int *length)
 Determines string length for proper buffer allocation on a call to Show_Unicode_Options. More...
 
void HC_Show_Unicode_Text (Key key, float *x, float *y, float *z, unsigned short text[])
 Returns the position, size, and contents of a previously-defined unicode text string, as referenced by a key. More...
 
long HC_Show_User_Data_Indices (intptr_t data_indices[], long data_indices_count)
 Returns the list of user data indices associated with the current segment. More...
 
void HC_Show_User_Index_Count (int *count)
 Returns the size of the indices array. More...
 
void HC_Show_User_Indices (int count[], long indices[], void **values)
 Returns the user indices and values that have been set on the currently open segment by a previous call or calls to Set_User_Index(). More...
 
void HC_Show_User_Options (char *list)
 Returns the user options that have been set on the currently open segment. More...
 
void HC_Show_User_Options_Length (int *length)
 Determines string length for proper buffer allocation on a call to Show_User_Options. More...
 
void HC_Show_User_Value (intptr_t *data)
 
void HC_Show_Variable_Edge_Weight (char *weight)
 Show the current variable edge weight setting. More...
 
void HC_Show_Variable_Line_Weight (char *weight)
 Show the current variable line weight setting. More...
 
void HC_Show_Variable_Marker_Size (char *size)
 Show the current variable marker size setting. More...
 
void HC_Show_Visibility (char *list)
 Returns the visibility settings for the currently open segment. More...
 
void HC_Show_Wakeup (float *time)
 Returns the time specification of the current wakeup event. More...
 
void HC_Show_Window (float *left, float *right, float *bottom, float *top)
 Returns the amount of screen used by the currently open segment upon display. More...
 
void HC_Show_Window_Frame (char *flag)
 Returns the window frame visibility setting. More...
 
void HC_Show_Window_Pattern (char *pattern)
 Returns the window pattern set on the currently open segment. More...
 
void HC_Show_Window_With_Options (float *left, float *right, float *bottom, float *top, char *list)
 
Key HC_Style_Segment (char const *style)
 "Styles" the currently open segment to be drawn in the style of the referenced ones. More...
 
Key HC_Style_Segment_By_Key (Key seg_key)
 Similar to Style_Segment(), but operates on a style referenced by an HC_KEY. More...
 
Key HC_Style_Segment_Key_By_Key (Key target_segment, Key style_segment)
 Similar to Style_Segment(), but styles a segment identified by target_segment. More...
 
void HC_Translate_Object (double x, double y, double z)
 Moves objects about within the user data space. More...
 
void HC_Translate_Texture (double u, double v, double w)
 Moves texture images about on the surface of texture mapped shells and meshes by transforming their (u, v, w) vertex parameters. More...
 
void HC_Trim_NURBS_Surface_By_Curve (int degree, int cpcount, float const control_points[], float const weights[], float const knots[], double start_u, double end_u)
 Inserts a NURBS curve into the trim list and applies the trim to a surface. More...
 
void HC_Trim_NURBS_Surface_By_Poly (int cpcount, float const points[])
 Inserts a polyline into the trim list and applies the trim to a surface. More...
 
void HC_UnDefine_Alias (char const *name)
 Removes all settings established by a previous call to Define_Alias(). More...
 
void HC_UnDefine_Callback_Name (char const *name)
 Removes all settings established by a previous call to Define_Callback_Name(). More...
 
void HC_UnDefine_Color_Name (char const *name)
 Removes all settings established by a previous call to Define_Color_Name(). More...
 
void HC_UnDefine_Error_Handler (Void_Routine handler)
 Removes all settings established by a previous call to Define_Error_Handler(). More...
 
void HC_UnDefine_Exit_Handler (Void_Routine handler)
 Removes all settings established by a previous call to Define_Exit_Handler(). More...
 
void HC_UnDefine_Font (char const *name)
 Removes all settings established by a previous call to Define_Font(). More...
 
int HC_UnDefine_Geometry_Highlight (int count, Key const keys[], char const *style, char const *options, int elements_count, int const offset1[], int const offset2[], int const offset3[])
 UnDefines an existing geometry highlight. More...
 
void HC_UnDefine_Glyph (char const *name)
 Removes the glyph definintion established in a previous call to Define_Glyph(). More...
 
int HC_UnDefine_Highlight (int count, Key const keys[], char const *style, char const *options)
 UnDefines an existing highlight. More...
 
void HC_UnDefine_Line_Style (char const *name)
 Removes a custom line style established by a previous call to Define_Line_Style(). More...
 
void HC_UnDefine_Local_Texture (char const *texture_name)
 Remove a texture definition on the currently open segment. More...
 
void HC_UnDefine_Named_Style (char const *style_name)
 Removes a named style definintion established by a previous call to Define_Named_Style. More...
 
void HC_UnDefine_Shader (char const *iname)
 Removes the shader code associated with the passed name. More...
 
void HC_UnDefine_Shape (char const *name)
 Deletes the shape definition, frees any memory allocated to the shape object, and triggers a redraw on any dependent scene elements. More...
 
void HC_UnDefine_Texture (char const *texture_name)
 Removes all settings established by a previous call to Define_Texture(). More...
 
void HC_UnSet_Bounding_Volume (void)
 Forces HOOPS to recalculate the bounding volume used by HOOPS to circumscribe the geometry within a segment. More...
 
void HC_UnSet_Callback (void)
 Removes all settings established by a previous call to Set_Callback(). More...
 
void HC_UnSet_Camera (void)
 Removes all settings established by a previous call to Set_Camera(). More...
 
void HC_UnSet_Camera_Near_Limit (void)
 Removes the hither camera plane value set by a previous call to Set_Camera_Limit().
More...
 
void HC_UnSet_Clip_Region (void)
 Removes all clip regions set by a previous call to Set_Polygonal_Clip_Region() More...
 
void HC_UnSet_Color (void)
 Removes all settings established by a previous call to Set_Color() from the current level of the segment tree, causing the current segment to inherit its color properties from its parent. More...
 
void HC_UnSet_Color_Map (void)
 Removes all settings established by a previous call to Set_Color_Map(). More...
 
void HC_UnSet_Conditional_Actions (void)
 Removes all the actions in the current segment. More...
 
void HC_UnSet_Conditions (void)
 Removes all the conditions established by a previous call to Set_Conditions(). More...
 
void HC_UnSet_Driver_Options (void)
 Removes all settings established by a previous call to Set_Driver_Options(). More...
 
void HC_UnSet_Edge_Pattern (void)
 Removes all settings established by a previous call to Set_Edge_Pattern(). More...
 
void HC_UnSet_Edge_Weight (void)
 Removes all settings established by a previous call to Set_Edge_Weight(). More...
 
void HC_UnSet_Face_Pattern (void)
 Removes all settings established by a previous call to Set_Face_Pattern(). More...
 
void HC_UnSet_Handedness (void)
 Removes all settings established by a previous call to Set_Handedness(). More...
 
void HC_UnSet_Heuristics (void)
 Removes all settings established by a previous call to Set_Heuristics(). More...
 
void HC_UnSet_Line_Pattern (void)
 Removes all settings established by a previous call to Set_Line_Pattern(). More...
 
void HC_UnSet_Line_Weight (void)
 Removes all settings established by a previous call to Set_Line_Weight(). More...
 
void HC_UnSet_Marker_Size (void)
 Removes all settings established by a previous call to Set_Marker_Size(). More...
 
void HC_UnSet_Marker_Symbol (void)
 Removes all settings established by a previous call to Set_Marker_Symbol(). More...
 
void HC_UnSet_Modelling_Matrix (void)
 Removes all settings established by a previous call to Set_Modelling_Matrix(). More...
 
void HC_UnSet_Normal (void)
 Removes all settings established by a previous call to Set_Normal(). More...
 
void HC_UnSet_One_Callback (char const *callback)
 Removes a given callback setting established by a previous call to Set_Callback(), rather than all settings. More...
 
void HC_UnSet_One_Color (char const *which)
 Removes a given setting established by a previous call to Set_Color(), rather than all settings. This effectively causes the current segment to inherit its color properties from its parent. More...
 
void HC_UnSet_One_Condition (char const *condition)
 Removes a given condition established by a previous call to Set_Conditions(). More...
 
void HC_UnSet_One_Conditional_Action (char const *which)
 Removes a given action established by a previous call to Set_Conditional_Actions(). More...
 
void HC_UnSet_One_Driver_Option (char const *which)
 Removes a given setting established by a previous call to Set_Driver_Options(), rather than all settings. More...
 
void HC_UnSet_One_Heuristic (char const *which)
 Removes a given setting established by a previous call to Set_Heuristics(), rather than all settings. More...
 
void HC_UnSet_One_Rendering_Option (char const *which)
 Removes a given setting established by a previous call to Set_Rendering_Options(), rather than all settings. More...
 
void HC_UnSet_One_Selectability (char const *which)
 Removes a given setting established by a previous call to Set_Selectability(), rather than all settings. More...
 
void HC_UnSet_One_Text_Font (char const *which)
 Removes a given setting established by a previous call to Set_Text_Font(), rather than all settings. More...
 
void HC_UnSet_One_Unicode_Option (unsigned short const *which)
 Removes a given setting established by a previous call to Set_Unicode_Options(), rather than all settings. More...
 
void HC_UnSet_One_User_Data (intptr_t index)
 This function unsets binary user data associated with a segment or piece of geometry in the database. More...
 
void HC_UnSet_One_User_Index (long index)
 Removes a given setting established by a previous call to Set_User_Options(), rather than all settings. More...
 
void HC_UnSet_One_User_Option (char const *which)
 Removes a given setting established by a previous call to Set_User_Options(), rather than all settings. More...
 
void HC_UnSet_One_Visibility (char const *which)
 Removes a given setting established by a previous call to Set_Visibility(), rather than all settings. More...
 
void HC_UnSet_Parameter (void)
 Removes all settings established by a previous call to Set_Parameter(). More...
 
void HC_UnSet_PBR_Material ()
 
void HC_UnSet_Priority (Key key)
 
void HC_UnSet_Rendering_Options (void)
 Removes all settings established by a previous call to Set_Rendering_Options(). More...
 
void HC_UnSet_Selectability (void)
 Removes all settings established by a previous call to Set_Selectability(). More...
 
void HC_UnSet_Streaming_Mode (void)
 Removes all settings established by a previous call to Set_Streaming_Mode(). More...
 
void HC_UnSet_Text_Alignment (void)
 Removes all settings established by a previous call to Set_Text_Alignment(). More...
 
void HC_UnSet_Text_Font (void)
 Removes all settings established by a previous call to Set_Text_Font(). More...
 
void HC_UnSet_Text_Path (void)
 Removes all settings established by a previous call to Set_Text_Path(). More...
 
void HC_UnSet_Text_Region (void)
 Removes all settings established by a previous call to Set_Text_Region(). More...
 
void HC_UnSet_Text_Spacing (void)
 Removes all settings established by a previous call to Set_Text_Spacing(). More...
 
void HC_UnSet_Texture_Matrix (void)
 Removes all settings established by a previous call to Set_Texture_Matrix(). More...
 
void HC_UnSet_Unicode_Options (void)
 Removes all settings established by a previous call to Set_Unicode_Options(). More...
 
void HC_UnSet_User_Data (void)
 
void HC_UnSet_User_Indices (void)
 
void HC_UnSet_User_Options (void)
 Removes all settings established by a previous call to Set_User_Options(). More...
 
void HC_UnSet_User_Value (void)
 
void HC_UnSet_Visibility (void)
 Removes all settings established by a previous call to Set_Visibility(). More...
 
void HC_UnSet_Window (void)
 Removes all settings established by a previous call to Set_Window(). More...
 
void HC_UnSet_Window_Frame (void)
 Removes all settings established by a previous call to Set_Window_Frame(). More...
 
void HC_UnSet_Window_Pattern (void)
 Removes all settings established by a previous call to Set_Window_Pattern(). More...
 
bool HC_Update_Display (void)
 Makes sure that external appearances are up-to-date with respect to the internal definitions. More...
 
bool HC_Update_Display_Timed (double time)
 Executes Update_Display and returns true if completed within a given interval. More...
 
bool HC_Update_One_Display (char const *segment)
 Executes Update_Display on a single driver instance. More...
 
bool HC_Update_One_Display_Timed (char const *segment, double time)
 Limit the amount of time allowed for an update. More...
 
bool HC_Write_Metafile (char const *segment, char const *file, char const *options)
 Writes the information in a segment out into a disk file. More...
 
void HC_Zoom_Camera (double zoom)
 Narrows or enlarges the viewing field of the camera. More...
 

Function Documentation

◆ HC_Abort_Program()

void HC_Abort_Program ( char const *  message)

Function to create a map linking PrcIds and A3DEntities.

Parameters
message- A quoted string, or a string variable containing your error message. An empty string is permissible.

Prints an error message. Calls the defined exit handlers. Exits to the operating system with a final error status.

DETAILS

Provides an orderly way to terminate execution upon the discovery of an error.
A standard HOOPS fatal error sequence is initiated. First, the currently defined error handlers are called. The list presented * * includes Report_Error() (unless you've specified otherwise), which causes message to be printed out where the user can * see it. Then, the currently defined exit handlers are called, usually including Reset_System() . Finally, the operating system * is called, with an "error" exit status, to terminate program execution.

See also
HC_Exit_Program, HC_Define_Exit_Handler, HC_Define_Error_Handler, HC_Report_Error

◆ HC_Append_Modelling_Matrix()

void HC_Append_Modelling_Matrix ( float const  array[])

Allows direct manipulation of the matrix transform applied against all picture elements and subsegments in a segment.

Parameters
array- Transform matrix provided by the user. Passed by reference in all languages. May need to be transposed in languages other than C.

DETAILS

Appends the explicitly provided transformation to the cumulative modelling transform of the currently open segment, or to the named segment(s). The visual effect is that of the scene as it was, then this change. (The old array is multiplied on the left by this new array.)
Use this routine only if your program organizes and keeps track of the net transformations applied to your objects.

NOTES

The array should be stored so the column varies faster than the row as you proceed through consecutive memory locations. In C and Pascal, the first index of the array is usually the row index and the second index is the column.

If there was no previous transform, this operation becomes a plain Set_Modelling_Matrix().
The first, second, and third rows of the fourth column of array must be zero - no "perspective" transformation is allowed. The fourth row of the fourth column is usually 1.0 (it must not be zero.)

RESTRICTIONS

See also
HC_Set_Modelling_Matrix, HC_Rotate_Object, HC_Translate_Object, HC_Scale_Object, HC_Set_Camera, HC_Orbit_Camera.

◆ HC_Append_Texture_Matrix()

void HC_Append_Texture_Matrix ( float const  array[])

Allows direct manipulation of the matrix transform applied against all shell and mesh (u, v, w) vertex parameters and subsegments in a segment.

Parameters
array- Transform matrix provided by the user. Passed by reference always. May need to be transposed in languages other than C.

DETAILS

Appends the explicitly provided transformation to the cumulative texture transform of the currently open segment, or to the named segment(s). The visual effect is that of the scene as it was, then this change. (The old array is multiplied on the left by the new array.)
Use this routine if your program organizes and keeps track of the net transformations applied to your vertex parameters.

NOTES

The array should be stored so the column varies faster than the row as you proceed through consecutive memory locations. In C and Pascal, the first index of the array is usually the row index and the second index is the column.
If there was no previous transform, this operation becomes a plain Set_Texture_Matrix() .
The fourth row of the fourth column is usually 1.0 (it must not be zero.)

RESTRICTIONS

See also
HC_Set_Texture_Matrix, HC_Rotate_Texture, HC_Translate_Texture, HC_Scale_Texture.

◆ HC_Apply_Attribute_Filter()

void HC_Apply_Attribute_Filter ( Key  key,
char const *  filter 
)

◆ HC_Begin_Alias_Search()

void HC_Begin_Alias_Search ( void  )

These routines recall the name of each alias.

DETAILS

This set of routines allows the user to "dump" all the aliases that exist in the database. It returns both the user defined aliases and those defined by the system (e.g.: "?include library"). It returns only the aliases names - to find out what their expansions are use Show_Alias(). For example:

Begin_Alias_Search ()
while (Find_Alias (alias)) {
Show_Alias (alias, def)
print (alias, def)
}
End_Alias_Search ()

prints all the known aliases names and their definitions. Begin_Alias_Search() initiates the search for each alias name.
Show_Alias_Count() finds out how many aliases will be returned. This is useful for determining the size of a data structure needed to store incoming items.
Find_Alias() retrieves the alias names, one at a time. The function returns false when all aliases have been returned.
End_Alias_Search() terminates the sequence and frees any involved memory.

NOTES

If an alias search is in progress and an alias becomes undefined (via UnDefine_Alias() ), it will not be returned by subsequent calls to Find_Alias(). If an alias is added, it will not be returned until the next alias search begins.
Show_Alias_Count() is only valid between Begin_Alias_Search() and End_Alias_Search(). It will always return the total number of aliases defined not the remaining number of aliases.
Alias searches can be nested. A user program can call Begin_Alias_Search() and look at the defined aliases without interfering with an alias search, which might have been activated by another portion of the program. When End_Alias_Search() is called, the previously active alias search (if any) becomes current.

RESTRICTIONS

See also
HC_Show_Alias, HC_Define_Alias, HC_Show_Pathname_Expansion

◆ HC_Begin_Buffered_Selection()

int HC_Begin_Buffered_Selection ( char const *  start_name,
double  left,
double  right,
double  bottom,
double  top,
char const *  options 
)

◆ HC_Begin_Callback_Name_Search()

void HC_Begin_Callback_Name_Search ( void  )

Finds the names of all previously defined callback routines.

DETAILS

These routines are used to find all the callback name definitions existing within the database. For example,

Begin_Callback_Name_Search ()
while (Find_Callback_Name (name))
print (name)
End_Callback_Name_Search ()

prints all the known callback definitions. Begin_Callback_Name_Search() initiates the search for callback name definitions. If you need to know how many callback definitions will be returned (possibly to allocate a sufficiently large data structure to hold the results), call Show_Callback_Name_Count() after initiating the search.
Find_Callback_Name() returns the names, one by one. This function returns false when all the definitions have been returned.

End_Callback_Name_Search() terminates the search. This last step can be done anytime after initiating the search.

NOTES

If a callback search is in progress and a callback becomes undefined (via UnDefine_Callback_Name() ), it will not be returned by subsequent calls to Find_Callback_Name() . If a callback definition is added, it will not be returned until the next callback search is initiated.

Show_Callback_Name_Count() is only valid between Begin_Callback_Name_Search() and End_Callback_Name_Search() . It will always return the total number of callback names, not the remaining number of definitions.

Callback name searches can be nested. A user program can call Begin_Callback_Name_Search() and look at the defined callbacks without interfering with a callback search, which might be in progress. When
End_Callback_Name_Search() is called, the previously active callback search is resumed.

See also
HC_Define_Callback_Name, HC_Show_Callback_Name.

◆ HC_Begin_Color_Name_Search()

void HC_Begin_Color_Name_Search ( void  )

These routines recall all the defined color names.

DETAILS

These routines are used to find all the color definitions in the database. For example,

Begin_Color_Name_Search ()
while (Find_Color_Name (first, second, third)
print (first, second, third)
End_Color_Name_Search ()

prints all the known names, in the style in which they were originally defined. Begin_Color_Name_Search() initiates the search for color names.
If you need to know how many color definitions will be returned (possibly for allocating a data structure to hold them) call Show_Color_Name_Count() after initiating the search.
Find_Color_Name() returns the names (one set at a time). The function returns false when all color names have been returned.
End_Color_Name_Search() terminates the process and frees any involved memory. This last step can be done any time after the initial call to Begin_Color_Name_Search().

NOTES

If you want to examine the color name definitions, call Parse_String() (to take out the commas) on the results of Find_Color_Name(). Then call Show_Color_Name() on each name.
After calling Begin_Color_Name_Search(), if a color becomes undefined (via
UnDefine_Color_Name() ), subsequent calls to Find_Color_Name() will not return it. If a color is redefined, the new definition will be returned. If a new color is defined, it will not be returned in this search sequence.
Show_Color_Name_Count() is only valid between Begin_Color_Name_Search() and End_Color_Name_Search() . It will always return the total number of colors defined, not the remaining number of color definitions.
Color name searches can be nested. A user program can call Begin_Color_Name_Search() and look at the defined color names without interfering with a color name search, which might have been activated by another portion of the program. When End_Color_Name_Search() is called, the previously active color name search (if any) becomes current.

See also
HC_Define_Color_Name, HC_Show_Color_Name, HC_Parse_String

◆ HC_Begin_Contents_Search()

void HC_Begin_Contents_Search ( char const *  segment,
char const *  filter 
)

These routines are used to "dump" the contents of a segment or certain types of geometry.

Parameters
segment- A string specifying the location(s) of the search.
filter- List of the types of objects you 're interested in.

DETAILS

Many user applications must manipulate the geometry in the database to perform some type of analysis. For example, if a program needs to calculate the areas of all polygons in a segment, it would need to know the coordinates of the points in each polygon. A contents search (specifically, Find_Contents()) can be used to retrieve the keys of all of the polygons, and then Show_Polygon() can be used to extract the points.

In a contents search, Begin_Contents_Search() initiates and defines the search. Only the types specified in filter are used in the search (see below), and only the segment or geometry specified in segment are checked.

Show_Contents_Count() determines the number of entities returned. This is useful for determining the size of a data structure needed to store the incoming items.

Find_Contents() returns entities, one at a time, from the selected segment or geometry. Find_Contents returns a type (i.e. "window frame") and, if appropriate, a key. (Geometry, segments, includes, and styles have keys. Attributes do not have keys.) The return value is false when all items have been returned.

End_Contents_Search() terminates the search sequence.

As with the other search routines, Begin_Contents_Search() operations can be nested. This feature can be used, for example, to "walk the tree" as sub-segments are encountered. A call to End_Contents_Search() terminates the current search context (segment specification and filter) and reactivates the previously active context (if any).

The segment parameter can take a number of valid location specifications including aliases, wildcards, and paths, as explained in the HOOPS/3dGS Programming Guide section on Segment-Name Syntax. The following are examples of valid usage:

  • "." Searches the currently open segment.
  • ".." Searches the parent of the currently open segment.
  • "..." Searches the currently open segment and its child segments.
  • "...." Searches the currently open segment, its children, and any include segments below the current segment.
  • "?picture/model" Searches the segment "model".
  • "?picture/model/..." searches the segment named 'model' and all of its subsegments.
  • "?picture/model/...." Searches the segment named 'model', all of its children, and any include segments below 'model'.
  • "/.../model*" Searches all segments in the entire tree starting with 'model', but not their subsegments.

The filter parameter specifies the types of objects that will be returned by later calls to Find_Contents(). The types are passed in a list of the form "type, type...", where each type is one of the following:

  • Geometry that can be inserted such as "images, lights, lines, markers, meshes, polygons, polylines, shells, string cursors, text".
  • One of the attributes that can be set such as "color", "marker size", "color map", "streaming mode", etc. Attribute filters may be refined by adding sub-options to the string, such as "color=(lines)", "user options = cost" or "visibility=faces".
  • The word "geometry" matches all types of geometry.
  • The word "attributes" matches all attributes.
  • The word "style" matches style references.
  • The types "segment" and "include" match, respectively, child segments and "include references" to segments.
  • The word "subsegment" matches "segment" and "include".
  • The word "inked line" selects the "currently being inked in" polyline (if any).
  • The word "ordered" returns only geometry brought to the front by Bring_To_Front() . The items are returned in drawing order. Successively returned items are drawn on top of previously returned items when the scene is updated.
  • The word "everything", matches all types.
  • The word "self", matches the subsegments themselves in a recursive search. This differs from the "subsegment" keyword in that it returns the parent instead of the children.
  • Any of the above types with "no" in front of them. For example: "everything, no geometry, no windows, no color maps" selects all types except windows, color maps, and all types of geometry. If specifications overlap (as in "geometry, no lines"), the last specification wins.
  • The word "hardware resources" matches display lists, textures, and vertex arrays that exist on the video card's cache.
  • The word "follow references" means the search will dig through references as part of the search. Without it, you'd have to search for references explicitly, find what they're pointing at and do a new search there.

The plural "s" after each type is optional. The types can be in any combination of upper and lowercase. Leading and trailing blanks are not significant. A blank string is equivalent to "everything".
Additional types (meanings should be self-explanatory) accepted by this function are:

"distant light", "local light", "spot light", "area light", "includer", "styler", "style", "color", "callback", "camera", "clip region", "handedness", "selectability", "visibility", "window", "window frame", "color map", "driver", "driver options", "edge pattern", "edge weight", "face pattern", "heuristics", "line pattern", "line weight", "marker size", "marker symbol", "metafile", "modelling matrix", "rendering options", "text alignment", "text font", "text leader", "text path", "text spacing", "texture matrix", "user value", "window pattern", "texture definition", "local texture", "glyph definition", "line pattern definition", "line style definition", "condition", "streaming mode", "circle", "circular arc", "circular chord", "circular wedge", "cutting plane", "cutting section", "light", "ellipse", "elliptical arc", "grid", "line", "marker", "mesh", "image", "pixel array", "polyline", "polygon", "shell", "string cursor", "text", "nurbs curve", "nurbs surface", "cylinder", "polycylinder", "sphere", "include", "reference geometry", "user options"

The following code example sums the areas of all polygons in all segments that contain the word "plate". It assumes the existence of a user written function that returns the area of a polygon given its key.

sum = 0.0
Begin_Contents_Search ("/...*plate*", "polygons")
while (Find_Contents (type, poly))
sum = sum + polygon_area(poly)
End_Contents_Search ()

(The "type" variable in this example will always be given the value "polygon".)
The segment name passed to Begin_Contents_Search() can contain wildcards, a list of segments or both. In this case, subsequent calls to Find_Contents() do not distinguish which segment contains each object. Use Show_Owner_By_Key() to determine this. Also, when multiple segments are specified, the type "ordered" does not distinguish which objects in the segments will be drawn first.
The returned types are entirely lowercase and singular, for example: "line", "selectability", "polygon". Normally, you would look at the type and make other calls ( Show_Visibility() , Show_Polyline() , etc.) to get more details about the object whose key was returned.

NOTES

If an object satisfying the target specification is deleted while a segment search is in progress, it will not be returned by Find_Contents() . If a segment is renamed, the new name will be returned. If geometry is moved to a new segment, its key will be returned even if the new segment name no longer matches the original search specification. If an object is created after a call to Begin_Contents_Search(), it will not be returned in the current sequence of Find_Contents() calls.
Show_Contents_Count() is only valid between Begin_Contents_Search() and End_Contents_Search(). It will always return the total number of items not the remaining number of items.
The inked line returned from a streaming segment will contain only the portion added since the last "Set" command changed any attribute in that segment.
"When "hardware resources" are found by Begin_Contents_Search, Find_Contents always return -1. In other words, hardware resources have no keys associated with them. Shells and Meshes can be opened and have their "hardware resources" flushed, but all other types of geometry (e.g. lines, polylines polycylinders and images) must have their "hardware resources" flushed from either their owning segment or some segment above.

See also
HC_Begin_Segment_Search, HC_Show_Existence, HC_Show_Key_Type, HC_Show_Segment, HC_Show_Owner, HC_Show_Polyline, HC_Show_Shell, HC_Show_Marker.

◆ HC_Begin_Decimate_Shell()

void HC_Begin_Decimate_Shell ( Key  key)

◆ HC_Begin_Error_Handler_Search()

void HC_Begin_Error_Handler_Search ( )

Finds all currently defined error handlers.

DETAILS

An error handler search allows you to find all the error handlers that currently registered.
Begin_Error_Handler_Search() initiates the search.
Show_Error_Handler_Count() returns the number of error handlers found.
Find_Error_Handler() returns a function pointer, one at a time, to each of the registered error handlers.
End_Error_Handler_Search() terminates the search sequence.

Below is a code sample of how you might use these error handler search functions:

extern "C" {
typedef void (*him_function)(HC_ANY_ARGS);
}
#define HIM_FUNCTION(function) (him_function)(function)
...
HC_Begin_Error_Handler_Search();
{
int count = 0;
void (*func)(HC_ANY_ARGS);
while (HC_Find_Error_Handler(&func)) {
if (HIM_FUNCTION(func) == HIM_FUNCTION(MyErrorHandler)) {
AfxMessageBox(_T("Found my error handler!"));
}
}
}

NOTES

Show_Error_Handler_Count() and Find_Error_Handler() are only valid between Begin_Error_Handler_Search() and End_Handler_Search().

See also
HC_Define_Error_Handler

◆ HC_Begin_Exit_Handler_Search()

void HC_Begin_Exit_Handler_Search ( )

Finds all the currently defined exit handlers.

DETAILS

An exit handler search allows you to find out what exit handlers are currently registered to the system.
Begin_Exit_Handler_Search() initiates and defines the search.

Show_Exit_Handler_Count() return the number of exit handlers found.
Find_Exit_Handler() returns a function pointer , one at a time, to each of the registered exit handler.
End_Exit_Handler() terminates the search sequence.
Below is a code sample of how you might use these exit handler search functions:

#define HIM_FUNCTION(function) (him_function)(function)
....
{
int count = 0;
void (*func)(HC_ANY_ARGS);
while (HC_Find_Exit_Handler(&func)) {
if (HIM_FUNCTION(func) == HIM_FUNCTION(MyExitHandler)) {
AfxMessageBox(_T("Found my exit handler!"));
}
}
}

NOTES

Show_Exit_Handler_Count() and Find_Exit_Handler() are only valid between calls to Begin_Exit_Handler_Search() and End_Exit_Handler_Search().

See also
HC_Define_Exit_Handler

◆ HC_Begin_Font_Search()

void HC_Begin_Font_Search ( char const *  display,
char const *  filter 
)

Finds the names of all the fonts available on a particular device.

Parameters
display- Name of the segment connected to the display of interest. Often "?Picture" or "?Hardcopy".
filter- A list of restrictions on the fonts of interest.

DETAILS

A font search allows you to find out what fonts are available on a given display.
Begin_Font_Search() initiates and defines the search. Only the types specified in filter are searched for (see below).
Show_Font_Count() determines the number of font names returned. This is useful for determining the size of a data structure needed to store the incoming items.
Find_Font() returns names, one at a time, from the selected display. The return value becomes false when all items have been returned.
End_Font_Search() terminates the search sequence. As with the other search routines, the Begin_Font_Search() operations can be nested.
The following choices are available for filter:
"Generic" tells you which of the generic font names (see Set_Text_Font() ) are available—in at least one size.
"Specific" tells you which individual fonts are available, with the names coming back in the style of the local system (for example, the operating system).
"Defined" tells you which user defined fonts are available, with the names coming back in the previously defined form.
"Family" or "families" tells you which name the system, or HOOPS, has picked to refer to the available sizes of a single typeface.
Any combination of choices can be given. Separate by commas. Uppercase versus lowercase is not important.
If you need more than the name of a font, call Show_Font_Info() to get additional details.
A simple coding example is:

Begin_Font_Search ("?Picture", "generic")
while (Find_Font (name))
print ("Yes,?Picture has: ", name)
End_Font_Search ()

NOTES

If the device is not operating, Begin_Font_Search() might force a call to Update_Display() to get it started. See the note at the bottom of Show_Device_Info() for more information.
Show_Font_Count() is only valid between Begin_Font_Search() and End_Font_Search(). It will always return the total number of items, not the remaining number of items.

See also
HC_Define_Font, HC_Show_Font, HC_Show_Font_Info, HC_Set_Text_Font, HC_Show_Device_Info.

◆ HC_Begin_Glyph_Search()

void HC_Begin_Glyph_Search ( void  )

These routines recall all the defined glyph names.

DETAILS

These routines are used to find all of the glyph definitions that exist in the database. For example,

Begin_Glyph_Search ()
while (Find_Glyph (the_name))
Show_Glyph(the_name, definition)
End_Glyph_Search ()

retrieves all the known names, in the style in which they were originally defined. If you need to know how many glyph definitions will be returned (possibly for allocating a data structure to hold them) call Show_Glyph_Count() after initiating the search.

Find_Glyph() returns the names (one at a time). The function returns false when all glyph names have been returned.

End_Glyph_Search() terminates the process and frees any involved memory. This last step can be done any time after the initial call to Begin_Glyph_Search().

NOTES

If you want to examine the glyph name definitions, call Show_Glyph() on the results of Find_Glyph() .

After calling Begin_Glyph_Search(), if a glyph becomes undefined (via UnDefine_Glyph()), subsequent calls to Find_Glyph() will not return it. If a glyph is redefined, the new definition will be returned. If a new glyph is defined, it will not be returned in this search sequence.
Show_Glyph_Count() is only valid between Begin_Glyph_Search() and End_Glyph_Search(). It will always return the total number of glyphs defined as opposed to the remaining number of glyph definitions.
Glyph name searches can be nested. A user program can call Begin_Glyph_Search() and look at the defined glyph names without interfering with a glyph name search that might already have been activated by another portion of the program. When End_Glyph_Search() is called, the previously active glyph name search (if any) becomes current.

See also
HC_Define_Glyph, HC_Show_Glyph, HC_Parse_String

◆ HC_Begin_Highlight_Search()

void HC_Begin_Highlight_Search ( int  count,
Key const  keys[],
char const *  list 
)

Searches for all highlights.

Parameters
countLength of 'keys' array in parameter 2. Set count to zero if no path filtering is desired; otherwise the specified key path will be used to filter the results.
keysAn array of HC_KEYs defining an unambiguous path to the highlighted object. Set keys to zero if count is zero and no path filtering is desired.
listlist of styles, drawing mode, or passive/active highlight. See DETAILS section below.

DETAILS

Using the list parameter, the following filters can be applied to the highlight search:

  • style = (style name,...)
    • only collects highlights which match one of the specified style names
  • quick moves [=(off | inplace | overlay | spriting,...)]
    • only collect highlights which match one of the specified drawing modes; if no modes are specified (i.e., simply "quick moves"), (overlay,spriting) is assumed
  • passive = on | off
    • only highlights matching the specified passive state are collected
  • path match [= exact | above | below]
    • may be used to indicate whether the search only matches the path exactly (the default), matches highlights at or above the target along the path, or at or below the target along the path.
See also
HC_Define_Highlight()

◆ HC_Begin_Line_Style_Search()

void HC_Begin_Line_Style_Search ( void  )

These routines recall all the defined line style names.

DETAILS

These routines are used to find all of the line style definitions that exist in the database. For example,

Begin_Line_Style_Search ()
while (Find_Line_Style (the_name))
Show_Line_Style(the_name, definition)
End_Line_Style_Search ()

retrieves all the known names, in the style in which they were originally defined. If you need to know how many line style definitions will be returned (possibly for allocating a data structure to hold them) call Show_Line_Style_Count() after initiating the search.

Find_Line_Style() returns the names (one at a time). The function returns false when all line style names have been returned.

End_Line_Style_Search() terminates the process and frees any involved memory. This last step can be done any time after the initial call to Begin_Line_Style_Search().

NOTES

If you want to examine the line style name definitions, call Show_Line_Style() on the results of Find_Line_Style() .

After calling Begin_Line_Style_Search() , if a line style becomes undefined (via UnDefine_Line_Style() ), subsequent calls to Find_Line_Style() will not return it. If a line style is redefined, the new definition will be returned. If a new line style is defined, it will not be returned in this search sequence.
Show_Line_Style_Count() is only valid between Begin_Line_Style_Search() and End_Line_Style_Search() . It will always return the total number of line styles defined as opposed to the remaining number of line style definitions.
Line_Style name searches can be nested. A user program can call Begin_Line_Style_Search() and look at the defined line style names without interfering with a line style name search that might already have been activated by another portion of the program. When End_Line_Style_Search() is called, the previously active line style name search (if any) becomes current.

See also
HC_Define_Line_Style, HC_Show_Line_Style, HC_Parse_String

◆ HC_Begin_Local_Texture_Search()

void HC_Begin_Local_Texture_Search ( void  )

Begins a texture search on the currently open segment.

DETAILS

Begin_Local_Texture_Search() is similar to Begin_Texture_Search() , but operates only on the currently open segment. To find all textures with this function, use the following method:

HC_Begin_Contents_Search("/...", "segments");
while (HC_Find_Contents(type, &segKey)) {
HC_Show_Segment (segKey, pathname);
HC_Begin_Contents_Search (".", "attributes");
while (HC_Find_Contents(type, &tempKey)){
if (!strcmp (type, "texture definitions")) {
HC_Show_Texture_Count(&texture_count);
HC_Find_Texture (texture_name);
}
}
}

NOTES

This behaves in a very similar fashion to Begin_Texture_Search() except that it only looks for locally defined textures. Also, since local textures are connected to a segment you must provide a segment from which the search should begin.

See also
HC_Begin_Texture_Search

◆ HC_Begin_Named_Style_Search()

void HC_Begin_Named_Style_Search ( void  )

Used to locate all named styles previously defined by Define_Named_Style().

See also
HC_Define_Named_Style().

◆ HC_Begin_Open_Item_Search()

void HC_Begin_Open_Item_Search ( void  )

Returns the keys to all currently open segments or geometric primitives.

DETAILS

These routines are used to find all the primitives (segments and geometry) that have been opened but not closed. A call to Begin_Open_Item_Search() initiates the process. Each call to Find_Open_Item() returns the key of a single open item. Once Begin_Open_Item_Search() is called, Show_Open_Item_Count() can be used to return the total number of open items.

If the open item is an edge, offset1 and offset2 will contain the vertex indices at either end of the edge. If the open item is a vertex, face, LOD, region, or trim, offset1 will contain the appropriate index.

NOTES

It is legal to use these routines with no segments open: the first call to Find_Open_Item() will just return false. Once Begin_Open_Item_Search() is called, all currently open items will be returned by Find_Open_Item() even if they are closed in the meantime. However, if any open items are closed and then deleted, they will not be returned. Any open segments that are renamed will be returned with the new name.
Show_Open_Item_Count() is only valid between Begin_Open_Item_Search() and End_Open_Item_Search(). It will always return the total number of open items, not the remaining number of open items.

See also
HC_Begin_Contents_Search, HC_Begin_Segment_Search, HC_Begin_Open_Segment_Search

◆ HC_Begin_Open_Segment_Search()

void HC_Begin_Open_Segment_Search ( void  )

Returns the pathnames of all open segments.

DETAILS

These routines are used to indicate all the segments that have been opened but not closed. A call to Begin_Open_Segment_Search() initiates the process. Each call to Find_Open_Segment() returns the pathname of a single open segment starting with the currently open segment (the most recently opened segment) and ending with the least recently opened segment. End_Open_Segment_Search() terminates the sequence and allows another series of open segment searches to be initiated.
Once Begin_Open_Segment_Search() is called, Show_Open_Segment_Count() can be used to return the total number of open segments. This routine is useful for sizing an array large enough to hold all the pathnames returned by a sequence of calls to Find_Open_Segment() .

NOTES

You can use these routines with no segments open. The first call to Find_Open_Segment() will just return false.
Once Begin_Open_Segment_Search() is called, all currently open segments will be returned by Find_Open_Segment() even if they are closed in the meantime. However, if any open segments are closed and then deleted, they will not be returned. Any open segments that are renamed will be returned with the new name.
Show_Open_Segment_Count() is only valid between Begin_Open_Segment_Search() and End_Open_Segment_Search() . It will always return the total number of open segments, not the remaining number of open segments.
Open segment searches can be nested. A user program can call Begin_Open_Segment_Search() and look at the open segments without interfering with an open segment search, which might have been activated by another portion of the program. When End_Open_Segment_Search() is called, the previously active open segment search (if any) becomes current.

See also
HC_Begin_Contents_Search, HC_Begin_Segment_Search, HC_Open_Segment.

◆ HC_Begin_Segment_Search()

void HC_Begin_Segment_Search ( char const *  segspec)

Finds all segments matching a search specification.

Parameters
segspec- A specification, often including wildcards, of the segment(s) to be searched for. Passed by reference always

DETAILS

The segment search routines provide the ability to determine the current segment structure of the database.
Begin_Segment_Search() initiates the search by specifying where to start looking for segments.
Show_Segment_Count() lets a program anticipate how many segments names will be returned from a sequence of calls to Find_Segment() in order that sufficient space may be allocated to receive them. Count is the total number of matching segments.
Find_Segment() is the routine that returns, one at a time, the segments which matched the specification given in Begin_Segment_Search(). When all segments have been returned, its function value becomes false.
End_Segment_Search() terminates the search sequence and reactivates any previously active segment search.
The segspec parameter can take a number of valid segment name specifications including aliases, wildcards, and paths, as explained in the HOOPS/3dGS programming guide section 1.2.6 "Segment-Name Syntax". Wildcards in the segment specification will typically match more than one segment in the database. The following examples are valid usages:

  • "*" Returns the currently open segment and all children, but no grandchildren.
  • "." Returns the currently open segment.
  • ".." Returns the parent of the currently open segment.
  • "..." Returns the currently open segment, and all subsegments.
  • "...." Returns the currently open segment, all subsegments, and any include segments below the current segment.
  • "?picture/model" Returns the segment "model".
  • "?picture/model/.." Returns "?picture".
  • "?picture/model/..." Returns the segment named 'model' and all of its subsegments.
  • "?picture/model/...." Returns the segment named 'model', all of its children, and any include segments below 'model'.
  • "/.../model*" Returns all segments in the entire tree starting with 'model', but not their subsegments.
  • "/.../model/...." Searches all segments in the entire tree named 'model', their children, and any include segments below them.

The Begin_Segment_Search() operations can be nested. This allows a program to "walk the tree" as in the following recursive example (written in C) which prints the names of all the children in the subtree of a given segment:

level = 0
print_children (segment) {
Open_Segment (segment)
Begin_Segment_Search ("*")
while (Find_Segment (child)) {
Parse_String (child, "/", -1, pathname)
print (level, pathname)
level = level + 1
print_children (pathname)
level = level - 1
}
End_Segment_Search ()
Close_Segment ()
}

This example could also have been written using the "contents search" routines, replacing "Begin_Segment_Search ("*")" with "Begin_Contents_Search (".", "segments")", and so on.

NOTES

If no segments are found that match the specification, the first call to Find_Segment() returns false.
If a search is in progress and a segment satisfying the target specification is deleted, it will not be returned by subsequent calls to Find_Segment() . If a segment is renamed, the new name will be returned. If a segment is created, it will not be returned in the current sequence of Find_Segment() calls.
Show_Segment_Count() must be called between Begin_Segment_Search() and End_Segment_Search() . It will always return the total number of segments, not the remaining number of segments.

See also
HC_Begin_Contents_Search, HC_Begin_Open_Segment_Search, HC_Show_Existence, HC_Open_Segment.

◆ HC_Begin_Shader_Search()

void HC_Begin_Shader_Search ( void  )

These routines recall the name of each shader.

DETAILS

This set of routines allows the user to "dump" all the shaders that exist in the database. It returns only the shader names. To find the details for each shader use Show_Shader() . For example

Begin_Shader_Search ()
while (Find_Shader (shader))
{
Show_Shader (shader, def, source)
print (shader, def, source)
}
End_Shader_Search ()

...prints all the known shader names, their options and source. Begin_Shader_Search() initiates the search for each shader name.
Find_Shader() retrieves the shader names, one at a time. The function returns false when all shaders have been returned.
End_Shader_Search() terminates the sequence and frees any involved memory.

NOTES

If a shader search is in progress and an shader becomes undefined via UnDefine_Shader(), it will not be returned by subsequent calls to Find_Shader(). If a shader is added, it will not be returned until the next shader search is begun.

See also
HC_Show_Shader, HC_Define_Shader

◆ HC_Begin_Shape_Search()

void HC_Begin_Shape_Search ( void  )

◆ HC_Begin_Shell_Selection()

void HC_Begin_Shell_Selection ( void  )

Begins a mode of operation whereby calls to Compute_Selection_By_Shell cache intermediate data in order to speed up successive computations.

DETAILS

In calling Begin_Shell_Selection() , the user is making a promise not to make any important changes to the "environment" segment tree that is used during Compute_Selection_By_Shell (see Compute_Selection() ). In particular, the user must not move, edit, or delete geometry. Changes to most attributes (e.g. colors, textures, normals) are fine, but not to those which impact the world-space locations of the objects in the "environment" segment tree (like, for example, Set_Modelling_Matrix and/or Scale_Object could). The consequences of violating these restrictions range from potentially incorrect answers for moves and edits, to a crash if pieces of the environment have been removed. On the positive side, however, the performance benefits of not having to tear down and rebuild the spatial data structures on every successive calculation can be significant.

NOTES

In addition to bringing the user out fo the optimized shell selection mode, End_Shell_Selection() frees all associated memory. This can be time-consuming, since collision detection by nature is memory-intensive. Remember, though, that memory is freed back into HOOPS' memory allocation pool, not the system's.
Performance benefits only apply if the same start segment is used for multiple calls to Compute_Selection_By_Shell.

See also
HC_Compute_Selection_By_Shell, HC_Compute_Selection_By_Ray

◆ HC_Begin_Texture_Search()

void HC_Begin_Texture_Search ( void  )

These routines recall all the defined texture names.

DETAILS

These routines are used to find all of the texture definitions that exist in the database. For example,

Begin_Texture_Search ()
while (Find_Texture (the_name))
Show_Texture(the_name, definition)
End_Texture_Search ()

retrieves all the known names, in the style in which they were originally defined. If you need to know how many texture definitions will be returned (possibly for allocating a data structure to hold them) call Show_Texture_Count() after initiating the search.

Find_Texture() returns the names (one at a time). The function returns false when all texture names have been returned.
End_Texture_Search() terminates the process and frees any involved memory. This last step can be done any time after the initial call to Begin_Texture_Search() .

NOTES

If you want to examine the texture name definitions, call Show_Texture() on the results of Find_Texture() .

After calling Begin_Texture_Search() , if a texture becomes undefined (via UnDefine_Texture() ), subsequent calls to Find_Texture() will not return it. If a texture is redefined, the new definition will be returned. If a new texture is defined, it will not be returned in this search sequence.
Show_Texture_Count() is only valid between Begin_Texture_Search() and End_Texture_Search() . It will always return the total number of textures defined as opposed to the remaining number of texture definitions.
Texture name searches can be nested. A user program can call Begin_Texture_Search() and look at the defined texture names without interfering with a texture name search that might already have been activated by another portion of the program. When End_Texture_Search() is called, the previously active texture name search (if any) becomes current.

See also
HC_Define_Texture, HC_Show_Texture, HC_Parse_String.

◆ HC_Bring_To_Front()

void HC_Bring_To_Front ( char const *  segment)
Parameters
segment- Name of the segment(s) to be shuffled forward.
Deprecated:
This function has been deprecated. It is superseded by setting the hsra rendering option to priority.

DETAILS

This function forces a particular drawing order onto a collection of geometric primitives. Since it does not change depth values, however, it has only minor effects on scenes with hidden surface removal algorithms (e.g. z-buffer, the default).
If the subject of a call to Bring_To_Front() , specified either by key or by name, is a segment that has a Window attribute, then you're effectively asking to rearrange windows. A windowed segment that lies within a windowed segment is always drawn "on top" of the containing window. But when windowed segments lie side-by-side in the segment tree—when neither window is the owner of the other—the situation becomes ambiguous. If such windows don't overlap no problem arises. If they do overlap, Bring_To_Front() allows for making a choice. Set_Window() automatically calls Bring_To_Front() for each newly-created window, so the default is "newest in front." You might make an explicit call when, for example, the user's interest has shifted from one window to another. This is often indicated by some action such as touching a rear window. In summary, Bring_To_Front() can be used to specify the precedence of overlapping sibling windows.
If, on the other hand, the subject of a call to Bring_To_Front() is something other than a windowed segment—if it's geometry or a non-windowed segment—then you're forcing a particular drawing order onto the system. You would do this if you want to manually describe what's to have the appearance of being in front. Forcing a drawing order is sometimes more efficient than using the system's hidden-surface algorithm. It might be suitable for a paint program in which the user selects precedence, or useful for putting "annotations" on a scene that is otherwise all hidden-surfaced. You should not use Bring_To_Front() if you don't really care about the ordering. The system works more efficiently if it is permitted to order objects as it pleases.
Using Bring_To_Front() on 3-D geometry and nonwindowed segments only works within those segments where the "hidden surfaces" heuristic is not in effect. Hidden surfaces take priority over bring-to-front. So, to mix hidden-surface items and bring-to-front items in the same scene, do something like the following:

Open_Segment ("window")
Set_Heuristics ("no hidden surfaces")
Open_Segment ("A")
Set_Heuristics ("hidden surfaces")
// regular hidden-surface picture, as needed
Close_Segment ()
Open_Segment ("B")
Set_Heuristics ("hidden surfaces")
// regular hidden-surface picture, as needed
Close_Segment ()
// now make "A" completely in front of "B"...
Bring_To_Front ("A")
Close_Segment ()

Note that "A" or "B" could have elected to continue with "no hidden surfaces". It might also make sense, depending on what "A" and "B" are, to turn off lighting visibility in one or the other. In addition, Bring_To_Front() can only be applied to siblings "A" versus "B." Bring_To_Front() does not apply to parent-child relationships.

NOTES

If the object of the bring-to-front is a non-windowed segment or an include reference, the effect is of bringing forward that collection of geometry as a whole.
This function can help resolve situations that arise with z-buffering where two surfaces have identical depth values but it is known which is supposed to be on top. For example, highlighting can be done this way, by drawing an extra copy with different attributes. This, combined with Control_Update() can be a powerful technique to highlight and de-highlight subsets of shells without ever incurring full updates.
Once something has been brought-to-front there is no simple way to put it back where it was. More objects can be put in front of the first, though, and the system will remember the entire ordering.
If the wildcard construction is used on Bring_To_Front() (segment) and there are conflicts, the system's choice of who really gets to be the one in front will not be predictable.
Entities within a streaming-mode segment can not be "brought-to-front".
Bring_To_Front() only works on the local level of the segment tree. If window A contains window B which contains window C, a bring-to-front of C will make C the foremost of all the windows within B. It won't make B foremost of the windows within A. If you want that to be true say so, separately.

RESTRICTIONS

If polygons are displayed with no explicit drawing order (without hidden surfaces and without an explicit Bring_To_Front() ) and a "scoped" refresh happens (for example, a window-system window is removed from on top of half the HOOPS scene), the scoped refresh may redraw its part of the scene in a different order than the original. This causes an obvious suture line.

See also
HC_Set_Window, HC_Set_Heuristics, HC_Set_Streaming_Mode, HC_Set_Camera, HC_Set_Visibility.

◆ HC_Bring_To_Front_By_Key()

void HC_Bring_To_Front_By_Key ( Key  key)

Similar to Bring_To_Front(), but operates on an object referenced by an HC_KEY.

Parameters
key- Open_Segment() , or any Insert routine.
Deprecated:
This function is deprecated.
See also
HC_Bring_To_Front()

◆ HC_Check_Double_Precision()

bool HC_Check_Double_Precision ( Key  key,
char const *  options 
)
Parameters
key- the key that will be checked for single or double precision
options- the options string, only used if 'key' is a segment key (see details, below)
Returns
true if the input key represents a double-precision entity, false otherwise.

DETAILS

This function is used to determine whether the entity represented by key is a double or single-precision entity. If key is a segment key, you can use the options string to tell what segment attribute you are specifically interested in. Valid options are "camera", "modelling matrix", "clip region", and "bounding".

See also
HC_Convert_Precision

◆ HC_Close_Edge()

void HC_Close_Edge ( void  )

Closes the session that began with an opening call to Open_Edge().

See also
HC_Open_Edge()

◆ HC_Close_Face()

void HC_Close_Face ( void  )

Closes the session that began with an opening call to Open_Face().

See also
HC_Open_Face()

◆ HC_Close_Geometry()

void HC_Close_Geometry ( void  )

Closes the session that began with an opening call to Open_Geometry().

See also
HC_Open_Geometry()

◆ HC_Close_LOD()

void HC_Close_LOD ( void  )

Closes the session that began with an opening call to Open_LOD().

See also
HC_Open_LOD()

◆ HC_Close_Region()

void HC_Close_Region ( void  )

Closes the session that began with an opening call to Open_Region().

See also
HC_Open_Region()

◆ HC_Close_Segment()

void HC_Close_Segment ( void  )

Closes the currently open segment.

DETAILS

Closes the currently open segment (i.e., the most recently opened segment), which is then no longer ready and available for "Insert" and "Set" operations. If there was a previously open segment, that segment becomes current once again. There must (eventually) be a matching Close_Segment() for every Open_Segment() , but in between as many Open's and Close's and even Update's as you please can occur.

See also
HC_Open_Segment, HC_Rename_Segment, HC_Flush_Contents, HC_Reset_System

◆ HC_Close_Trim()

void HC_Close_Trim ( void  )

Closes the session that began with an opening call to Open_Trim().

See also
HC_Open_Trim()

◆ HC_Close_Vertex()

void HC_Close_Vertex ( void  )

Closes the session that began with an opening call to Open_Vertex().

See also
HC_Open_Vertex()

◆ HC_Collect_Area_Samples()

int HC_Collect_Area_Samples ( double  left,
double  right,
double  bottom,
double  top 
)

Gathers all objects that have been drawn in the selection area, and prepares them to be returned to the user.

Parameters
left- The left bound of the selection point, in window coordinates.
right- The right bound of the selection point, in window coordinates.
bottom- The bottom bound of the selection point, in window coordinates.
top- The top bound of the selection point, in window coordinates.
Returns
The number of unique selection items found in the selection region, as determined by the selection 'options'.

DETAILS

This routine will gather all objects that have been drawn in the specified selection area and prepare them to be returned to the user. The objects that have been drawn in the specified selection area correspond with what is currently visible on screen. After calling this function, Find_Next_Sample should be used to iterate through the list of selected items and obtain more detailed information about each one.
The parameters describe a rectangle where the selection should be processed. This would be a small region around the point that the end-user clicked on, or a selection box (area). Note that to specify a single pixel, use the same value for 'left' and 'right', as well as 'top' and 'bottom'.

Any calls to this routine will obtain results from the 'current' selection buffer, which is the one created by the most recent call to Begin_Buffered_Selection. If you wish to perform a selection after editing the scene in some way, remember to first call End_Buffered_Selection, and then once again call Begin_Buffered_Selection to begin a new buffered selection process.

If there was no valid selection buffer the function will return -1. (For example, maybe there was not a prevoius call to Begin_Buffered_Selection, or the hardware doesn't support the buffered selection capability.)

NOTES

The "related selection limit" Heuristic does not apply. Collect_Area_Samples returns all the items in the specified area, and then they should be interated through.
The 'selection proximity' Driver_Option does not apply. If you wish to perform an 'aperture' select, for example, as a result of the end-user doing a 'single click/point select' on an entity such as a polyline, but wish to give the user some level of flexibility so that they don't have to select precisely on the visible pixel(s) of the polyline, you should pass in a small box region as the selection region. For example, if you want to collect samples for a .5cm square box, you would first obtain "resolution" info from Show_Device_Info, calculate the # of pixels/cm, and then use Compute_Coordinates to convert from 'pixels' to 'window' coordinates (using the window coordinates for Collect_Area_Samples).

There is a subtle implication of selecting on what is visible on the screen: if you happen to pass in a single pixel as the 'selection region' and that falls between the dashes in a dashed line, note that the line would not get selected.

RESTRICTIONS

Currently, samples can only be requested for the specified rectangular region. It is possible that support for non-rectangular selections could be added in the future (such as polyline or polygon).

See also
HC_Begin_Buffered_Selection, HC_End_Buffered_Selection, HC_Find_Next_Sample, HC_Show_Sample_Max_Length

◆ HC_Commit_Proxy()

void HC_Commit_Proxy ( Key  key,
const char *  options 
)

◆ HC_Compute_Boolean_Shell()

Key HC_Compute_Boolean_Shell ( int  target_pcount,
Point const  target_points[],
Vector const  target_normals[],
int  target_flist_length,
int const  target_face_list[],
int  tool_pcount,
Point const  tool_points[],
Vector const  tool_normals[],
int  tool_flist_length,
int const  tool_face_list[],
char const *  options 
)

Performs one of several boolean operations on two shells. IMPORTANT NOTE: This routine is primarily meant to provide a reasonable visual representation of the boolean result, and has limititions covered in the NOTES section which prevent this routine from being relied on to produce manifold shell results. The routine is provided AS-IS.

Parameters
target_pcount- Number of valid points in targetpoints.
target_points- Vector of x-y-z triplets for the coordinates of the vertices that could be used to build the target shell. (A simple N = 3 array can also be used) Passed by reference always.
target_normals- Sequential list of vertex normals of the target shell, x-y-z triplets. It is legal to pass NULL for this parameter, in which case normal information will be ignored. Passed by reference always.
target_flist_length- Total number of integers in targetface_list
target_face_list- Encoded description of how to connect the points to build the faces of the target shell. Passed by reference always.
tool_pcount- Number of valid points in toolpoints.
tool_points- Vector of x-y-z triplets for the coordinates of the vertices that could be used to build the tool shell. (A simple N = 3 array can also be used) Passed by reference always.
tool_normals- Sequential list of vertex normals of the tool shell, x-y-z triplets. It is legal to pass NULL for this parameter, in which case normal information will be ignored. Passed by reference always.
tool_flist_length- Total number of integers in toolface_list.
tool_face_list- Encoded description of how to connect the points to build the faces of the tool shell. Passed by reference always.
options- A quoted string or a string variable containing a list of desired options. Passed by reference always.
Returns
key

DETAILS

This function takes the definitions for two manifold shells and performs one of three boolean operations on those shells. The result is a new shell that gets inserted into the currently open segment. Valid choices for options include the following:

boolean type = [subtract | union | intersect]

Tells 3dGS which specific type of boolean operation to perform on the supplied shells. In the event of a union or an intersection, the order of target and tool does not matter. However, in the case of a subtraction the tool will be subtracted from the target shell.

plane coefficient = [float]

This value is used in the internal logic for determining the boolean result. Changing the value based on the scale of the object can give better results. For both the single and double precision version, the default setting is "plane coefficient = 0.000001".

plane tolerance = [float]

This value is used in the internal logic for determining the boolean result. Changing the value based on the scale of the object can give better results. The default setting is "plane tolerance = 0.0003" for the single precision version. For the double precision version, the default setting is "plane tolerance = 0.000001".

plane merge tolerance = [float]

This value is used in the internal logic for determining the boolean result. Changing the value based on the scale of the object can give better results. The default setting is "plane merge tolerance = 0.0003" for the single precision version. For the double precision version, the default setting is "plane merge tolerance = 0.000001".

target handedness = [left|right]

The polygon handedness of the target shell. If not specified, "left" handedness is assumed.

tool handedness = [left|right]

The polygon handedness of the tool shell. If not specified, "left" handedness is assumed.

RESTRICTIONS

This function will perform a Compute_Optimized_Shell() on the resulting boolean shell data before placing it in the currently open segment. The shell will have left polygon handedness. The user may need to delete the tools and target in their scene depending on the intended behavior.
The two shells that participate in the boolean operation must be closed and manifold bodies. There cannot be overlapping facets or other inconsistencies in the data. You must have consistent handedness in each input shell (though each shell can have it's own handedness, e.g., the target can have right handedness and the tool can have left handedness) and you must specify the handedness in the options if it differs from the defaults, otherwise one can get unexpected results. The input shells must only contain convex faces.

The faces of the target and tool shells should not be co-planar.

NOTES

The resulting shell of the Compute_Boolean_Shell() function may contain an excessive number of triangles in the region where the target and tool meet. If the boolean functionality is used for continuous surface removal (for example, recursive use of the boolean operation result as the input value for a subsequent boolean operation), this effect may become exacerbated.

Due to the nature of the algorithm, very small triangles may be produced which can lead to precision problems, such as missing faces or faces with wrong handedness. In extreme cases, these precision problems can lead to the creation of extraneous triangles.

See also
HC_Insert_Shell

◆ HC_Compute_Boolean_Shell2()

Key HC_Compute_Boolean_Shell2 ( int  in_pt_count_target,
Point const  in_pts_target[],
Vector const  in_normals_target[],
int  in_flist_len_target,
int const  in_flist_target[],
int  in_pt_count_tool,
Point const  in_pts_tool[],
Vector const  in_normals_tool[],
int  in_flist_len_tool,
int const  in_flist_tool[],
char const *  option_string,
RGB const *  in_color1,
RGB const *  in_color2,
unsigned char const  in_vis1[],
unsigned char const  in_vis2[] 
)

◆ HC_Compute_Capping_Shell()

Key HC_Compute_Capping_Shell ( int  shell_count,
Key const  shell_list[],
float const  plane[] 
)

Creates a shell in the currently open segment that contains an exact copy of the cap geometry that a plane would make when applied to the provided shells.

Parameters
shell_count- Number of shells in the shell list array.
shell_list- List of shells for which the cap(s) will be generated.
plane- An array of four floats that define the cap plane.
Returns
cap_key - The key to the shell that will contain the capping geometry.

DETAILS

This function allows developers to access the cap geometry that 3dGS creates when cutting planes are inserted into the scene and capping geometry is turned on. The capping geometry is returned as a single shell and is inserted into the currently open segment. Users must ensure that there is a valid open segment before calling this function.

NOTES

This function does not apply any modelling transforms to the supplied shells. Users must translate the shells into world space to ensure correct results. Also, the shell provided is a copy of the capping geometry and so the deletion and/or modification of the returned shell will not affect the caps in the scene.

RESTRICTIONS

This interface currently supports shell generation for cutting planes only. This function must operate on manifold shells. Non-manifold shells will not work.

See also
HC_Insert_Shell, HC_Insert_Cutting_Plane, HC_Insert_Cutting_Section

◆ HC_Compute_Circumcuboid()

bool HC_Compute_Circumcuboid ( char const *  segment,
Point *  min,
Point *  max 
)

Returns points defining a cuboid that circumscribes the geometry within a segment.

Parameters
segment- Segment name to use for the calculation.
min- The lower-most nearest diagonal point (xmin,ymin,zmin) of the cuboid to encompass the geometry contained within the segment. Returned to user. Passed by reference in all languages.
max- The upper-most distant diagonal point (xmax,ymax,zmax) of the cuboid to encompass the geometry contained within the segment. Returned to user. Passed by reference in all languages.
Returns
success

DETAILS

This function returns the axis-aligned bounding cuboid associated with a database entity. The bounding volume returned is computed on demand—it does not reflect the bounding volume stored at the segment, if any. The routine, Show_Bounding_Cuboid() , can be used for that purpose. The volume returned is expressed in oru.
Compute_Circumcuboid, the standard variant, allows only for segments. The By_Key variant, however, allows for keys that refer to any sort of geometry (in addition to segments). The standard variant allows for the normal wildcards associated with a segment specification.
The By_Key variant will fail if the specified key in variant does not refer to anything valid. The standard variant will fail if the specified segment in the does not match at least one segment, or all matched segments are empty of any geometry.
Transform-dependent geometry (e.g. markers, text) contributes only its insertion point. A reasonable way to handle markers would be to add a small pad to the min and max result. Special handling is needed to account for text, however. HOOPS/MVO (distributed as open source) contains a good example of that special handling (hint: it involves Compute_Text_Extent() ).

NOTES

Temporary geometry created "on the fly" in the midst of I.M. callbacks will never contribute to any bounding volumes. The computed bounding volume will be with respect to geometry that has been inserted into the database. When called on a large segment tree, this function can become expensive, so use sparingly.

See also
HC_Compute_Circumsphere, HC_Compute_Coordinates, HC_Compute_Transform, HC_Show_Bounding_Info, HC_Show_Bounding_Cuboid,

◆ HC_Compute_Circumcuboid_By_Key()

bool HC_Compute_Circumcuboid_By_Key ( Key  key,
Point *  min,
Point *  max 
)

Similar to Compute_Circumcuboid(), but operates on an object referenced by an HC_KEY.

Parameters
key- Key of the segment used for the calculation.
min- The lower-most nearest diagonal point (xmin, ymin, zmin) of the cuboid to encompass the geometry contained within the segment. Returned to user. Passed by reference in all languages.
max- The upper-most distant diagonal point (xmax, ymax, zmax) of the cuboid to encompass the geometry contained within the segment. Returned to user. Passed by reference in all languages.
Returns
success
See also
HC_Compute_Circumcuboid()

◆ HC_Compute_Circumsphere()

bool HC_Compute_Circumsphere ( char const *  segment,
Point *  center,
float *  radius 
)

Returns points defining a sphere that circumscribes the geometry within a segment.

Parameters
segment- Segment name to use for the calculation.
center- The center position of a sphere that encompasses the geometry contained within the segment. Returned to user. Passed by reference in all languages.
radius- The radius length of the encompassing sphere. Returned to user. Passed by reference in all languages.
Returns
success

DETAILS

The volume for Compute_Circumsphere() is a sphere instead of a cuboid. For more information refer to the discussion for Compute_Circumcuboid() .

See also
HC_Compute_Circumcuboid, HC_Compute_Coordinates, HC_Compute_Transform, HC_Show_Bounding_Info, HC_Show_Bounding_Cuboid, HC_Show_Bounding_Sphere.

◆ HC_Compute_Circumsphere_By_Key()

bool HC_Compute_Circumsphere_By_Key ( Key  key,
Point *  center,
float *  radius 
)

Similar to Compute_Circumsphere(), but operates on an object referenced by an HC_KEY.

Parameters
key- Key of the segment or geometry to be used for the calculation.
center- The center position of a sphere that encompasses the geometry contained within the segment. Returned to user. Passed by reference in all languages.
radius- The radius length of the encompassing sphere. Returned to user. Passed by reference in all languages.
Returns
success
See also
HC_Compute_Circumsphere()

◆ HC_Compute_Color()

bool HC_Compute_Color ( char const *  name,
char const *  out_type,
RGB *  out_value 
)

Allows access to the color-conversion routines used internally in HOOPS.

Parameters
name- A color-by-name color specification, in the style of Set_Color() .
out_type- Special constant—either "HLS", "HSV", "HIC", or "RGB". The constant is a quoted string. Uppercase versus lowercase is not significant.
out_value- A color triple that represents hue, lightness, and saturation, or red, green, and blue, etc., depending on the values of in_type and out_type. Returned to user. Passed by reference in all languages.
Returns
true if it succeeds in turning the input color string into a color value in the format specified by out_type; otherwise, it returns false.

DETAILS

These routines allow access to the internal color conversion routines used by HOOPS in the normal processing of Set_Color() and Set_Color_By_Value() . Compute_Color() takes a normal HOOPS color name, such as "pinkish purple" and returns the numeric equivalent in the selected color space. Compute_Color_By_Value() takes a numeric color in one color space and converts it to the equivalent color in another color space.

NOTES

Not all colors that can be represented in the HLS, HSV and HIC color space have an exact equivalent RGB value. For colors that can't be represented, the nearest legal RGB value is returned instead.

If in_type or out_type are not legitimate an error is signalled. Other errors are not signalled and are returned in the success flag.

The final RGB values passed to the device usually have a gamma correction applied—these routines do not include gamma correction.

See also
HC_Set_Color, HC_Set_Color_By_Value, HC_Define_Color_Name.

◆ HC_Compute_Color_By_Value()

bool HC_Compute_Color_By_Value ( char const *  in_type,
RGB const *  in_value,
char const *  out_type,
RGB *  out_value 
)

Similar to Compute_Color(), but operates with a color values rather than names or map indices.

Parameters
in_type- Special constant—either "HLS", "HSV", "HIC", or "RGB". The constant is a quoted string. Uppercase versus lowercase is not significant.
in_value- A color triple that represents hue, lightness, and saturation, or red, green, and blue, etc., depending on the values of in_type and out_type. Passed by reference in all languages.
out_type- Special constant—either "HLS", "HSV", "HIC", or "RGB". The constant is a quoted string. Uppercase versus lowercase is not significant.
out_value- A color triple that represents hue, lightness, and saturation, or red, green, and blue, etc., depending on the values of in_type and out_type. Returned to user. Passed by reference in all languages.
Returns
true if the function succeeds in turning the input color string into a color value in the format specified by out_type; otherwise, it returns false.
See also
HC_Compute_Color()

◆ HC_Compute_Convex_Hull()

void HC_Compute_Convex_Hull ( int  pcount,
Point const  points[],
int *  fcount,
int  face_list[] 
)

Given a set of points, determines the set of faces that minimally bind all the points.

Parameters
pcount- Number of valid points in points.
points- Vector of x-y-z triplets for the coordinates of the vertices. (A simple N*3 can also be used.) Passed by reference always.
fcount- Total number of integers returned in face_list. Passed by reference always. Returned to user.
face_list- Encoded description of how to connect the points to build the faces of the hull. Same format as in Insert_Shell() . Passed by reference always. Returned to user. Potentially up to 8*pcount*sizeof(int) in length.

DETAILS

A "hull", as used here, is a closed wrapper around a set of points. The hull is a simple polyhedron, its vertices are chosen only from the set of points, and all the points end up either on the surface or within the hull.
For all but the simplest sets of points there are many possible hulls. However, disregarding degeneracies (coplanar/colinear points), there is only one possible convex hull surrounding any given set of points. Compute_Convex_Hull() computes this shape. The input is a list of points. The output is a face connectivity list suitable for passing to Insert_Shell() .
Compute_Convex_Hull() only produces convex figures, by definition. However, there is nothing preventing you from artificially moving one of the points inward to form a concave figure after Compute_Convex_Hull() returns. Likewise, Compute_Convex_Hull() only produces closed figures, by definition. There is nothing preventing you from artificially removing one or more of the faces to form an open shell afterwards.

NOTES

The variable, face_list_length, is the number of entries in face_list that the system has used up. face_list_length is returned to you. It is not the total available space you're passing in. The system assumes your face_list is "big enough" to hold any possible result. Allow for at least 8*pcount*sizeof(int) in face_list – in other words, the new face list contains up to 2*pcount triangles.
The algorithm used is O(n squared). In other words, it's going to take a while.
Not all the points will necessarily be mentioned in the face_list. Depending on the shape of your object, many points might be completely interior to the hull and thus unconnected.
Another definition of "convex hull" is "the surface of the smallest area that encloses a set of points".

See also
HC_Compute_Coordinates, HC_Insert_Shell

◆ HC_Compute_Coordinates()

bool HC_Compute_Coordinates ( char const *  segment,
char const *  in_system,
Point const *  in_position,
char const *  out_system,
Point *  out_position 
)

Converts positions back and forth among the various coordinate systems.

Parameters
segment- The name of a segment that provides the Window, Camera, and/or Driver attributes for the conversion.
in_system- Special constants for the input and output coordinate spaces. See below for details.
in_position- A 3-D coordinate position in the in_system coordinate space. Passed by reference in all languages.
out_system- Special constants for the input and output coordinate spaces. See below for details.
out_position- A 3-D coordinate position in the out_system coordinate space. Passed by reference in all languages. Returned to user.
Returns
success

DETAILS

This routine examines the attributes present on segment and its owners and allows you to convert from in_system coordinates to out_system coordinates.

The in_system and out_system parameters to Compute_Coordinates() can include one of the following:

local window

The value is in terms of the local window for segment. (The Z coordinate is usually zero.)
outer window

The value is in terms of the outermost window for segment. ("Outermost" refers to the first segment going up from segment, which has a Driver attribute.)
screen range

The value is in window coordinates units based on the value of the screen range in Set_Rendering_Options() set on the segment. If no screen range is set, this is the equivalent to local window.
local pixels

The value is measured in screen pixels within the local window on segment. The upper-left of the window is pixel (0, 0). The pixels go down and to the right. (The Z coordinate is usually zero.)
outer pixels

The value is in terms of pixels within the outermost window on segment.
projection

The value is in projection space (Normalized device coordinates) and maps directly to the window.
viewpoint

A coordinate system based on the position of the observer (camera). The origin is at the camera position. The viewing direction is the Z-axis and the camera up vector is the Y-axis.
world

The value is in normal world coordinates (the coordinate system in which the camera is positioned; the coordinates of geometry after modelling matrices have been applied, but before projecting through a camera into a window.) A window Z value of zero maps to the current camera "target" plane.
camera

The coordinate system used in calls to Set_Camera_Position() . A synonym for world coordinates.
object

The value is in the coordinate system that real geometry lives in. This is similar to "world" coordinates, but does not includes the Modelling Matrices, if any.

NOTES

If a conversion is ambiguous (one of the matrices is singular), the system will choose arbitrarily among the valid possibilities. If a conversion is impossible (the point is on top of or behind a perspective camera), a false function status will be returned and out_position will be unchanged.

Window Z coordinates are described at length under Show_Selection_Position() .

To generate the world coordinates of an eye-ray, given window or pixel coordinates, call this routine twice with two different window or pixel Z coordinates.

If you have many points to transform it is more efficient to call Compute_Transform() to get a transform matrix. Then call Compute_Transformed_Points() to do all the points at once. If you have just one or a couple points to transform, Compute_Coordinates() is more efficient because it doesn't need to build the matrix.

RESTRICTIONS

The Compute_XXX() routines that require information about display drivers, do not work if they are called from an included segment. Display information must be associated with a window to return information about the display.

Calling Compute_XXX() routines to obtain data associated with a display, generates an update. On most devices, this poses no problem. However, for hardcopy devices such as Postscript or CGM, this can generate a blank page. To avoid this problem, applications often open a temporary driver subsegment. The application calls the compute routine, and retains the computed information, and then discards the temporary driver subsegment.

See also
HC_Compute_Transform, HC_Show_Selection_Position, HC_Show_Polyline, HC_Show_Shell.

◆ HC_Compute_Coordinates_By_Path()

bool HC_Compute_Coordinates_By_Path ( int  count,
Key const  keys[],
char const *  in_system,
Point const *  in_position,
char const *  out_system,
Point *  out_position 
)

Similar to Compute_Coordinates(), but concatenates the matrices along a segment path rather than the currently open segment.

Parameters
count- The size of the keys array
keys- The array of keys starting with the owning segment and following
long all the way back to the root segment or other desired segment.
in_system- Special constants for the input and output coordinate spaces. See below for details.
in_position- A 3-D coordinate position in the in_system coordinate space. Passed by reference in all languages.
out_system- Special constants for the input and output coordinate spaces. See below for details.
out_position- A 3-D coordinate position in the out_system coordinate space. Passed by reference in all languages. Returned to user.
Returns
success
See also
HC_Compute_Coordinates()

◆ HC_Compute_Cross_Product()

void HC_Compute_Cross_Product ( Vector const *  vector1,
Vector const *  vector2,
Vector *  out_vector 
)

Computes the cross product of two vectors.

Parameters
vector1- input 3D vectors.
vector2- input 3D vectors.
out_vector- output 3D vector returned to the caller. Can point to the same place as vector1 or vector2

DETAILS

Compute_Cross_Product() takes two 3-D vectors and computes their vector cross-product.

NOTES

For a bit of linear algebra review, the way to compute a cross product is to calculate the determinant of the following matrix:

| i j k |
| x1 y1 z1 |
| x2 y2 z2 |

Where i, j, and k are the unit vectors along the X, Y, and Z axes, respectively. That works out to be equal to

i*(y1*z2 - z1*y2) - j*(x1*z2 - z1*x2) + k*(x1*y2 - y1*x2)

The result is always perpendicular to both inputs, and of length equal to the length(vector1) * length(vector2) * sin(angle between vector1 and vector2). The order of the inputs matters. Switching the inputs will reverse the result.

See also
HC_Compute_Coordinates, HC_Compute_Dot_Product

◆ HC_Compute_Dot_Product()

double HC_Compute_Dot_Product ( Vector const *  vector1,
Vector const *  vector2 
)

Takes two 3-D vectors and computes their scalar dot-product.

Parameters
vector1- Input 3D vector.
vector2- Input 3D vector.
Returns
value
See also
HC_Compute_Coordinates, HC_Compute_Cross_Product

◆ HC_Compute_Face_Neighborhood()

void HC_Compute_Face_Neighborhood ( Key  shell_key,
int  face_index,
int *  count,
int  neighbors[] 
)

Returns the indices of the faces within a shell that share an edge with the specified face.

Parameters
shell_key- Key to the shell in which the faces reside.
face_index- The index of the face within the shell's facelist for which to calculate the neighbors.
count- Number of faces that share an edge with the supplied face. Passed by reference. Returned to caller.
neighbors- Array of indices into the shell's facelist, specifying the faces that share an edge with the supplied face. Passed by reference. Returned to caller.

DETAILS

Developers can use this API to determine the facets within a shell that are connected. This can often be used to help determine the features within a particular shell.

RESTRICTIONS

The API will not return faces that share an edge with more than one other face. Also, this API is only supported for shell geometry.

See also
HC_Show_Shell, HC_Generate_Shell_From_Geometry

◆ HC_Compute_Face_Neighborhood_Si()

void HC_Compute_Face_Neighborhood_Si ( Key  shell_key,
int  face_index,
int *  count 
)

Returns the number of faces within a shell that share an edge with the specified face.

Parameters
shell_key- Key to the shell in which the faces reside.
face_index- The index of the face within the shell's facelist for which to calculate the neighbors.
count- Number of faces that share an edge with the supplied face. Passed by reference. Returned to caller.

DETAILS

Returns the size of the data structure that is needed as input to Compute_Face_Neighborhood().

See also
HC_Show_Shell, HC_Generate_Shell_From_Geometry

◆ HC_Compute_Identity_Matrix()

void HC_Compute_Identity_Matrix ( float  out_matrix[])
Parameters
out_matrix- Output transformation matrix, returned to the caller.

DETAILS

Compute_Identity_Matrix() produces a matrix that represents "no transformation". It can be useful when program logic always assumes a previous transformation exists. The output array is always filled with [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1].

See also
HC_Set_Modelling_Matrix

◆ HC_Compute_Intersect_Polyline()

int HC_Compute_Intersect_Polyline ( int  pcount1,
Point const  points1[],
int  flist_length3,
int const  face_list1[],
int  pcount2,
Point const  points2[],
int  flist_length2,
int const  face_list2[],
int *  polyline_count,
int  polyline_lengths[],
int *  polyline_points_count,
Point  polyline_points[] 
)

Calculates the polyline of intersection between the faces of one shell and those of another. If the two shells do not exist, this function returns false.

Parameters
pcount1- the number of points in the first shell
points1- the points array for the first shell
flist_length3- the length of the face lists for the first shell
face_list1- The face lists of the first shell, in the same coded format as defined in the documentation for Insert_Shell()
pcount2- the number of points in the second shell
points2- the points array for the second shell
flist_length2- the length of the face lists for the second shell
face_list2- The face lists of the second shell
polyline_count- The number of distinct polylines along which the shells intersect. Passed by reference always. Returned to user.
polyline_lengths- Array contains polyline_count entries. For each polyline, the corresponding value in this array specifies its length. Passed by reference always. Returned to user.
polyline_points_count- The total number of points in all polylines. Passed by reference always. Returned to user.
polyline_points- Vector of x-y-z triplets for the coordinates along the polylines. Passed by reference always. Returned to user.
Returns
found

DETAILS

This function takes two shells (as defined by the point clouds and face lists by which they would be inserted), and returns to the user a list of polylines along which they intersect. The calculation takes the lines along which any of the first shell's faces intersect with any of the second's, and merges them into as few polylines as possible.
The list of polylines is designated with two arrays. The first, an array of integers, specifies the length of each polyline. The second, an array of x-y-z triplets, is the combined array of vertices. Each of these two arrays has an associated length.
For example, two squares might be represented as the following (not that we'd typically expect a polyline of intersection to look like this):

  • polyline_count = 2
  • polyline_lengths = {5, 5}
  • polyline_points_count = 10
  • polyline_points = { { 0, 0, 0 }, { 0, 1, 0 }, { 1, 1, 0 }, { 1, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0,-1, 0 }, { -1,-1, 0 }, { -1, 0, 0 }, { 0, 0, 0 } }

Since both polyline_lengths and polyline_points are arrays that are copied into user supplied calls by refeference, it is strongly recommended that Show_Intersect_Polyline_Size() be called first to know how much memory to allocate.

NOTES

Holes in faces (a.k.a negative faces) are not (at least not yet) supported, nor are concave faces. This operation is defined for shells only (e.g. no NURBS surfaces, polycylinders or meshes).
polyline_points_count will always be equal to the sum of all entries in polyline_lengths.
This function is by nature expensive, and so should be used sparingly. Additionally, Compute_Selection_By_Shell() should be used to first figure out if the two shells do in fact collide. Since the intersect polyline size cannot be known until after the polyline has been calculated, Show_Intersect_Polyline_Size() (if used, that is) ends up doing the real work. It caches its results, however, in anticipation of a Compute_Intersect_Polyline() call. The result is that Show_Intersect_Polyline_Size() followed by Compute_Intersect_Polyline() costs very little additional computation relative to a simple Compute_Intersect_Polyline() .
If the two shells in question have also been inserted into HOOPS, Show_Geometry_Pointer() can in avoid copying of arrays that would otherwise be required by Show_Shell.

See also
HC_Compute_Selection, HC_Show_Geometry_Pointer, HC_Show_Shell, HC_Compute_Transformed_Points, HC_PShow_Net_Modelling_Matrix.

◆ HC_Compute_Matrix_Adjoint()

void HC_Compute_Matrix_Adjoint ( float const  matrix[],
float  out_matrix[] 
)
Parameters
matrix- Input transformation matrix.
out_matrix- Output transformation matrix, returned to the caller. Can point to the same place as matrix.

DETAILS

Compute_Matrix_Adjoint() takes a general 4x4 transformation and computes its adjoint. The adjoint of a matrix is similar to the inverse of the matrix—the adjoint divided by the determinant gives the inverse. The adjoint is sometimes used in place of the inverse because it's easier to compute and is never singular.

See also
HC_Compute_Coordinates, HC_Compute_Matrix_Inverse, HC_Compute_Transform, HC_Compute_Transformed_Plane, HC_Set_Modelling_Matrix, HC_Show_Device_Info

◆ HC_Compute_Matrix_Determinant()

double HC_Compute_Matrix_Determinant ( float const  matrix[])
Parameters
matrix- Input transformation matrix.
Returns
value

DETAILS

Compute_Matrix_Determinant() takes a general 4x4 transformation and computes its determinant. If the determinant is zero, the matrix is singular.

See also
HC_Compute_Coordinates, HC_Compute_Matrix_Inverse, HC_Compute_Normalized_Matrix, HC_Compute_Transform, HC_Set_Modelling_Matrix, HC_Show_Device_Info

◆ HC_Compute_Matrix_Inverse()

bool HC_Compute_Matrix_Inverse ( float const  matrix[],
float  out_matrix[] 
)
Parameters
matrix- Input transformation matrix.
out_matrix- Output transformation matrix, returned to the caller. Can point to the same place as matrix.
Returns
success

DETAILS

Compute_Matrix_Inverse() takes a general 4x4 transformation and computes its inverse. If the matrix is singular, the out_matrix will be unchanged and false will be returned.

NOTES

If the matrix is singular, Compute_Matrix_Determinant() would return zero. The adjoint (see Compute_Matrix_Adjoint() ) is similar and will always be defined, even for singular matrices. Consider using that instead where applicable.

See also
HC_Compute_Coordinates, HC_Compute_Matrix_Determinant, HC_Compute_Matrix_Adjoint, HC_Compute_Transform, HC_Set_Modelling_Matrix, HC_Show_Device_Info

◆ HC_Compute_Matrix_Product()

void HC_Compute_Matrix_Product ( float const  matrix1[],
float const  matrix2[],
float  out_matrix[] 
)
Parameters
matrix1- First input transformation matrix.
matrix2- Second input transformation matrix.
out_matrix- Output transformation matrix, returned to the caller. Can point to the same place as matrix1 or matrix2

DETAILS

Compute_Matrix_Product() takes two general 4x4 transformation matrices (from routines such as Compute_Rotation_Matrix() ) and computes their product. For compatibility with Compute_Transformed_Points(), specify the "inner" transformations (e.g., modelling matrices) on the left (as matrix1) and "outer" transformations (e.g., cameras, windows) on the right (as matrix2).
Given:

Compute_Matrix_Product(A, B, C);

C = AB

The result is that the following are equivalent:

1) Append_Modelling_Matrix(A);

followed by

Append_Modelling_Matrix(B);

2) Append_Modelling_Matrix(C);

See also
HC_Compute_Coordinates, HC_Compute_Transform, HC_Set_Modelling_Matrix, HC_Show_Device_Info

◆ HC_Compute_Minimized_Shell()

void HC_Compute_Minimized_Shell ( int  in_point_count,
Point const  in_points[],
int  in_face_list_length,
int const  in_face_list[],
char const *  option_string,
int *  out_point_count,
Point  out_points[],
int *  out_face_list_length,
int  out_face_list[],
int  vertex_mapping[],
int  face_mapping[] 
)

◆ HC_Compute_Normalized_Matrix()

bool HC_Compute_Normalized_Matrix ( float const  matrix[],
float  out_matrix[] 
)
Parameters
matrix- Input transformation matrix.
out_matrix- Output transformation matrix, returned to the caller. Can point to the same place as matrix.
Returns
success

DETAILS

Compute_Normalized_Matrix() takes a general 4x4 transformation and divides by its determinant. If the input matrix is singular, the out_matrix will be unchanged and false will be returned.

NOTES

If the matrix is singular, Compute_Matrix_Determinant() would return zero.

See also
HC_Compute_Coordinates, HC_Compute_Matrix_Determinant, HC_Compute_Transform, HC_Set_Modelling_Matrix, HC_Show_Device_Info

◆ HC_Compute_Normalized_Vector()

bool HC_Compute_Normalized_Vector ( Vector const *  vector,
Vector *  out_vector 
)
Parameters
vector- Input 3D vector.
out_vector- Output 3D vector returned to the caller. Can point to the same place as vector .
Returns
success

DETAILS

Compute_Normalized_Vector() takes a 3-D vector and divides by its length. If the vector is all zeroes, false will be returned.

See also
HC_Compute_Coordinates, HC_Compute_Transform, HC_Set_Modelling_Matrix, HC_Show_Device_Info

◆ HC_Compute_Offaxis_Rotation()

void HC_Compute_Offaxis_Rotation ( double  x,
double  y,
double  z,
double  theta,
float  out_matrix[] 
)
Parameters
x- X coordinate of the vector that specifies the axis of rotation
y- Y coordinate of the vector that specifies the axis of rotation
z- Z coordinate of the vector that specifies the axis of rotation
theta- Angle of rotation.
out_matrix- Output transformation matrix. Returned to caller.

DETAILS

Compute_Offaxis_Rotation() produces a matrix that represents a rotation about an arbitrary axis passing through the origin.

See also
HC_Compute_Offcenter_Rotation, HC_Set_Modelling_Matrix

◆ HC_Compute_Offcenter_Rotation()

void HC_Compute_Offcenter_Rotation ( double  alpha,
double  beta,
double  theta,
double  x,
double  y,
double  z,
float  out_matrix[] 
)
Parameters
alpha- Angle of rotation about the X axis.
beta- Angle of rotation about the Y axis.
theta- Angle of rotation about the Z axis.
x- X coordinate of the centroid of rotation
y- Y coordinate of the centroid of rotation
z- Z coordinate of the centroid of rotation
out_matrix- Output transformation matrix, returned to the caller.

DETAILS

Compute_Offcenter_Rotation() produces a matrix representing a rotation about an arbitrary center of rotation. This essentially consists of a translation of (-x,-y,-z) to the origin. The translation uses a rotation of alpha degrees about the X axis, a rotation of beta degrees about the Y, and a rotation of theta degrees about the Z. Then it does a translation back to (x, y, z).

See also
HC_Compute_Offaxis_Rotation, HC_Set_Modelling_Matrix

◆ HC_Compute_Optimized_Shell()

void HC_Compute_Optimized_Shell ( int  pcount,
Point const  points[],
Vector const  normals[],
int  flist_length,
int const  face_list[],
char const *  options,
int *  new_pcount,
Point  new_points[],
int *  new_flist_length,
int  new_face_list[],
int  point_mapping_list[],
int  face_mapping_list[] 
)

Performs one of several computations to prepare shell data for improved rendering performance. The default computation is to remove redundant vertices and degenerate faces.

Parameters
pcount- Number of valid points in points.
points- Vector of x-y-z triplets for the coordinates of the vertices that could be used to build the shell. (A simple N = 3 array can also be used.) Passed by reference always.
normals- Sequential list of vertex normals, x-y-z triplets. It is legal to pass NULL for this parameter, in which case normal information will be ignored. If non-NULL, however, the normals are assumed to be normalized to length 1. Passed by reference always.
flist_length- Total number of integers in face_list.
face_list- Encoded description of how to connect the points to build the faces of the shell. Passed by reference always.
options- A quoted string or a string variable containing a list of desired options. Passed by reference always.
new_pcount- Number of valid points in new_points after computation. Returned to caller. Passed by reference always.
new_points- Vector of x-y-z triplets for the coordinates of the non-redundant vertices that could be used to build the shell. (A simple N = 3 array can also be used.) Returned to caller. Passed by reference always.
new_flist_length- Total number of integers in computed new_face_list. Returned to caller. Passed by reference always.
new_face_list- Encoded description of how to connect the points to build the faces of the computed shell. Returned to caller. Passed by reference always.
point_mapping_list- Mapping of vertices from the original point list to the vertices in the new (computed) point list. In other words, for each old vertex i, point_mapping_list[i] represents the vertex in the new shell to which it has moved. Eliminated points are mapped to -1. Returned to caller. Passed by reference always.
face_mapping_list- Mapping of faces from the original face list to the new (computed) face list. In other words, for each old face j, face_mapping_list[j] represents the vertex in the new shell to which it has moved. Eliminated faces are mapped to -1. Returned to caller. Passed by reference always.

DETAILS

The HOOPS routine Insert_Shell() accepts a set of points, an encoded description of how to connect the points to form the faces of a shell. Insert_Shell() performs no interrogation of the data received. It has no provision for eliminating redundant points nor for ignoring disconnected points. Compute_Optimized_Shell() accepts data normally used to insert a shell and returns a new set of data with redundancies and discontinuities removed. This new data can then be used to insert a shell. The arrays point_mapping_list and face_mapping_list are available to help you refer to the new data, if given indices to the original data.

Programs designed to work with geometric modelers often receive geometry in a stream. This means they cannot ascertain the overall connectedness of a shell's faces. For instance, to define a diagonally-split quadrilateral using two faces, one needs only four vertices, with two of them referenced twice. While it is geometrically correct to redefine the "re-used" vertices, for a total of six, face-connectivity information is lost. This is because duplicated points, though equivalent, are still distinct—each face has its "own" vertices. Compute_Optimized_Shell() recaptures the connectivity by eliminating the duplicated vertices and forcing faces to share the remaining unique vertices.

Faces that refer to fewer than three unique vertices are eliminated.

Since shells are arbitrary collections of faces, Compute_Optimized_Shell() can be used to convert a group of polygons into a coherent shell. The advantage is less data must be sent to HOOPS. Performance is improved since fewer points must be transformed and clipped.

Compute_Optimized_Shell() does not allocate memory for you. All arrays passed to it must contain adequate storage.

The following choices are recognized for options:
fix handedness

This option is a convenience for converting a minority of faces to the handedness comprising the majority.
Determines the handedness of the majority of faces, and reverses the winding of the minority faces. Returns facelist data to the caller. Shell data is modified in no other way. Mutually exclusive to options "fix handedness", "skin", and "lod".

This option will also fix the special winding of holes (and nested holes) in shell faces also. A limitation of fixing face handedness is that we cannot do better than the "majority wins" method for the general case.

reverse handedness

This option is a convenience for reversing the winding of shell faces if the option "fix handedness" gives you an inside-out shell and you prefer not to change the appearance with the Heuristic "polygon handedness".

Reverses the winding of each face in the facelist provided. Returns facelist data to the caller. Shell data is modified in no other way. Mutually exclusive to options "fix handedness", "skin", and "lod".

It should not be necessary to pass in point data.
[no] [level of detail | lod] [ = xx% ]

Causes Compute_Optimized_Shell to abandon the normal redundant-vertices calculation in favor of calculating a Level of Detail (LOD). Any other choice will cause the shell to be reduced using shell simplification instead of the standard code path. The default reduction when LOD is turned on is 50%. If a percentage is specified in the form of xx%, the number of triangles in the model will be reduced to to the given percentage of the original model. The options "skin" and "lod" are mutually exclusive.

The new point count is guaranteed not to be larger than the original, so the original length can be used as upper bounds for allocation. The same goes for the facelist if the input is triangles. If quads (or polygons of higher order) are provided, then the output facelist may be larger. This is because our LOD algorithm outputs triangles only.

With quad input and level of detail = 100%, we will output double the faces. Triangle faces have 4/5 the number of integers that quad faces do, so we don't need to double the facelist alloc size, rather multiply it by 1.6. This factor shrinks by user-provided level of detail. For example, with quad face input and level of detail = 75%, the new facelist alloc size becomes 1.6*0.75 = 1.2x original.

Generally, for turning n-gon data into a LOD shell with level of detail x, you are safe if you alloc an array of size (Original_FaceList_Length * 4*(n-2)/(n+1) * x).

Alternatively, you can safely run Optimize twice – first just to generate the facelist length (no array passed in), next with the array after your accurately sized alloc. This, however will take more cpu time.

Not set by default.
lod algorithm = [fast | nice]

Use the fast-LOD algorithm, with some visual quality degradation, or the "nice" LOD algorithm, with extra generation time but a better representation. Default is "fast". Default is "fast", but only applies if the "lod" option is used.
[no] orphan elimination

If this option is set, points that are not referenced by any face are removed. The default is "orphan elimination".
[no] skin

Particularly geared towards the needs of the finite element analysis community, this option causes Compute_Optimized_Shell() to abandon its normal goal of merging nearby vertices in favor of extracting the exterior surface from shells that also have interior vertices and faces. This special computation mode works its magic by looking for pairs of faces that reference 3 or more of the same vertex indices. If coincident vertices are not shared for adjacent faces, this computation will not do anything (though running the standard form of Compute_Optimized_Shell() on the data first would solve that problem. The options, "skin" and "lod" are mutually exclusive. When "skin" mode is used only "orphan elimination" has any meaning – the rest are ignored. As usual, the new face list length and new point count are guaranteed not to be larger than the original, so the original lengths can be used as upper bounds for allocation. Not set by default.
[no] tolerance [= nnn oru / nnn % fru]

"Tolerance" controls the identification of duplicate points. If a specification is given in object-relative units (oru), then the points that are separated by a distance less than this value are considered equal.

Often, one cannot ascertain a "good" value for an object-relative tolerance. In this case, specify the tolerance using "feature-relative units (fru)". Feature size is defined to be the smallest non-zero distance between any two adjacent vertices on any face. It is calculated internally by Compute_Optimized_Shell() , and is constant for the entire collection of faces. The feature-relative tolerance is expressed as a percentage of this minimum distance. A setting less than "tolerance = 100% fru" guarantees that unequal vertices on a single face won't be eliminated.

"No tolerance" is the same as "tolerance = 0 oru".

The default is "no tolerance".
[no] normal tolerance [= nnn deg / nnn rad / nnn]

"Normal Tolerance" also controls the identification of duplicate points. Points which have an angular difference greater than the specified normal tolerance are assumed to be unique.

"no normal tolerance" is the same as "normal tolerance = 0 deg".

The default is "no normal tolerance".

[no] collapsible [= <defined callbackname>]

This option enables the user to replace the default distance measure, euclidian distance, with their own function to determine whether any given two nearby points should be merged or not. While it was originally designed to accept normals as its primary information, any sort of pointer that is passed as normals in the call to Compute_Optimized_Shell will be passed through to the callback.

NOTES

If you are not interested in the mapping lists, pass a null pointer for either the point_mapping_list or the face_mapping_list. If you are not interested in using normal information as a criterion for collapsing points, pass a null pointer for normals.
This function replaces Compute_Minimized_Shell() , which is now obsolete.
It is not legal to pass the same pointer for both input and output.
EXAMPLES
The following example demonstrates passing a struct pointer in place of normals.

typedef struct {
// contents of this structure are unrestricted
float myparam1, myparam2;
} optimized_shell_passthru;
// returns 1 if points a and b are collapsible --
// 0 if points a and b are not collapsible
int are_collapsible_callback (
void *pts_in,
void *norms_in,
int a,
int b,
double tolerance_squared,
double normal_distance_squared )
{
optimized_shell_passthru *info= (optimized_shell_passthru *) norms_in;
// use info to do any test here, and return the result
}
// and this is how the function is called
optimized_shell_passthru info = { a, b, etc. };
HC_Define_Callback_Name( "are_collapsible_callback", are_collapsible_callback );
in_point_count, in_points,
(void *)(&info),
in_face_list_length, in_face_list,
"collapsible = are_collapsible_callback",
&out_point_count, out_points,
&out_face_list_length, out_face_list,
vertex_mapping, face_mapping
);

The following example demonstrates using the vertex_mapping array to copy attributes from the old shell to the new one. Two things to note from this example:

  • a) that the check for "vertex_mapping >= 0" really is necessary, since unreferenced vertices from the original shell have vertex_mapping entries set to "-1"; and
  • b) that performance could be improved if the normals from the original shell were available a priori in an array so that the vertices did not have to be individually opened.
  • c) vertices in the new shell can potentially be touched more than once.
HC_Show_Shell( old_key, &point_count, points, &face_list_length, face_list );
&point_count, points, NULL,
&face_list_length, face_list,
"",
&new_point_count, new_points,
&new_face_list_length, new_face_list,
vertex_mapping, face_mapping
);
new_key = HC_Insert_Shell( new_point_count, new_points, new_face_list_length, new_face_list );
for( i = 0 ; i < point_count ; i++ ) {
HC_Open_Geometry( old_key );
HC_Show_Normal( &x, &y, &z );
if( vertex_mapping[i] >= 0 ) {
HC_Open_Geometry( new_key );
HC_Open_Vertex( vertex_mapping[i] );
HC_Set_Normal( x, y, z );
}
}
See also
HC_Insert_Shell, HC_Show_Shell, HC_Show_Shell_Size.

◆ HC_Compute_Pline_From_Crv_Size()

void HC_Compute_Pline_From_Crv_Size ( Key  key,
char const *  options,
int *  pcount 
)

Calculates and returns a the size of the tesselated curve, for use in a later call to Compute_Polyline_From_Curve.

Parameters
key- Key to a particular curve. Valid curves include circles, circular chords, circular wedges, circular arcs, ellipses, elliptical arcs and NURBS curves.
options- Tesselation options.
pcount- Number of points in the polyline. Passed by reference. Returned to user.
See also
HC_Compute_Polyline_From_Curve, HC_Insert_Polyline, HC_Edit_Polyline, HC_Insert_Circle, HC_Insert_Circular_Arc, HC_Insert_Ellipse, HC_Insert_Elliptical_Arc, HC_Insert_NURBS_Curve

◆ HC_Compute_Point_Inside_Shell()

bool HC_Compute_Point_Inside_Shell ( Point const *  test_point,
int  point_count,
Point const  points[],
int  face_list_length,
int const  face_list[] 
)

Tests whether a given point is inside a shell, which is assumed to be a closed surface.

Parameters
test_point- point to test. passed by reference.
point_count- number of points in the shell that may enclose point
points- Vector of x-y-z triplets for the coordinates of the vertices to be used to build the shell. (A simple N x 3 array may also be used). Passed by reference always.
face_list_length- size of the array of integers that defines the faces in face_list
face_list- Encoded description of how to connect the points to build the faces of the shell (see Insert_Shell() ).
Returns
success

DETAILS

HC_Compute_Point_Inside_Shell returns true if test_point is inside the shell, and false otherwise.

NOTES

This function assumes that the shell is a closed surface. If it is not closed, correct results are not guaranteed.

See also
HC_Insert_Shell, HC_Show_Shell, HC_Compute_Selection_By_Shell

◆ HC_Compute_Point_On_Shell()

bool HC_Compute_Point_On_Shell ( Point const *  test_point,
double  tolerance,
int  point_count,
Point const  points[],
int&#