hc_proto.h

Content

Macro definitions

HC_PROTO_DEFINED

Functions

`HC_Abort_Program()`	Function to create a map linking PrcIds and A3DEntities.
`HC_Append_Modelling_Matrix()`	Allows direct manipulation of the matrix transform applied against all picture elements and subsegments in a segment.
`HC_DAppend_Modelling_Matrix()`	Similar to Append_Modelling_Matrix(), but accepts double-precision data.
`HC_Append_Texture_Matrix()`	Allows direct manipulation of the matrix transform applied against all shell and mesh (u, v, w) vertex parameters and subsegments in a segment.
`HC_Begin_Alias_Search()`	These routines recall the name of each alias.
`HC_Begin_Callback_Name_Search()`	Finds the names of all previously defined callback routines.
`HC_Begin_Color_Name_Search()`	These routines recall all the defined color names.
`HC_Begin_Contents_Search()`	These routines are used to “dump” the contents of a segment or certain types of geometry.
`HC_Begin_Font_Search()`	Finds the names of all the fonts available on a particular device.
`HC_Begin_Glyph_Search()`	These routines recall all the defined glyph names.
`HC_Begin_Line_Style_Search()`	These routines recall all the defined line style names.
`HC_Begin_Open_Segment_Search()`	Returns the pathnames of all open segments.
`HC_Begin_Segment_Search()`	Finds all segments matching a search specification.
`HC_Begin_Shader_Search()`	These routines recall the name of each shader.
`HC_Begin_Shape_Search()`
`HC_Begin_Texture_Search()`	These routines recall all the defined texture names.
`HC_Begin_Local_Texture_Search()`	Begins a texture search on the currently open segment.
`HC_Bring_To_Front()`
`HC_Bring_To_Front_By_Key()`	Similar to Bring_To_Front(), but operates on an object referenced by an HC_KEY.
`HC_Close_Edge()`	Closes the session that began with an opening call to Open_Edge().
`HC_Close_Face()`	Closes the session that began with an opening call to Open_Face().
`HC_Close_Geometry()`	Closes the session that began with an opening call to Open_Geometry().
`HC_Close_LOD()`	Closes the session that began with an opening call to Open_LOD().
`HC_Close_Region()`	Closes the session that began with an opening call to Open_Region().
`HC_Close_Segment()`	Closes the currently open segment.
`HC_Close_Vertex()`	Closes the session that began with an opening call to Open_Vertex().
`HC_Compile_Shader()`	Defines a section of code that will be injected into HOOPS 3DF shaders.
`HC_Compute_Circumcuboid()`	Returns points defining a cuboid that circumscribes the geometry within a segment.
`HC_Compute_Circumcuboid_By_Key()`	Similar to Compute_Circumcuboid(), but operates on an object referenced by an HC_KEY.
`HC_Compute_Circumsphere()`	Returns points defining a sphere that circumscribes the geometry within a segment.
`HC_Compute_Circumsphere_By_Key()`	Similar to Compute_Circumsphere(), but operates on an object referenced by an HC_KEY.
`HC_DCompute_Circumcuboid()`	Similar to Compute_Circumcuboid, but accepts double-precision parameters.
`HC_DCompute_Circumcuboid_By_Key()`	Similar to Compute_Circumcuboid_By_Key(), but operates on double-precision data.
`HC_DCompute_Circumsphere()`	Similar to Compute_Circumsphere(), but operates on double-precision data.
`HC_DCompute_Circumsphere_By_Key()`	Similar to Compute_Circumsphere_By_Key(), but operates on double-precision data.
`HC_Compute_Color()`	Allows access to the color-conversion routines used internally in HOOPS.
`HC_Compute_Color_By_Value()`	Similar to Compute_Color(), but operates with a color values rather than names or map indices.
`HC_Compute_Convex_Hull()`	Given a set of points, determines the set of faces that minimally bind all the points.
`HC_Compute_Coordinates()`	Converts positions back and forth among the various coordinate systems.
`HC_Compute_Coordinates_By_Path()`	Similar to Compute_Coordinates(), but concatenates the matrices along a segment path rather than the currently open segment.
`HC_Compute_Cross_Product()`	Computes the cross product of two vectors.
`HC_DCompute_Cross_Product()`	Similar to Compute_Cross_Product, but operates on double-precision data.
`HC_Compute_Dot_Product()`	Takes two 3-D vectors and computes their scalar dot-product.
`HC_DCompute_Dot_Product()`	Similar to Compute_Dot_Product, but operates on double-precision data.
`HC_Compute_Identity_Matrix()`
`HC_DCompute_Identity_Matrix()`	Similar to Compute_Identity_Matrix(), but operates on double-precision data.
`HC_Compute_Matrix_Adjoint()`
`HC_DCompute_Matrix_Adjoint()`	Similar to Compute_Matrix_Adjoint(), but operates on double-precision data.
`HC_Compute_Matrix_Determinant()`
`HC_DCompute_Matrix_Determinant()`	Similar to Compute_Matrix_Determinant(), but operates on double-precision data.
`HC_Compute_Matrix_Inverse()`
`HC_DCompute_Matrix_Inverse()`	Similar to Compute_Matrix_Inverse(), but operates on double-precision data.
`HC_Compute_Matrix_Product()`
`HC_DCompute_Matrix_Product()`	Similar to Compute_Matrix_Product(), but operates on double-precision data.
`HC_Compute_Minimized_Shell()`
`HC_Compute_Normalized_Matrix()`
`HC_DCompute_Normalized_Matrix()`	Similar to Compute_Normalized_Matrix, but operates on double-precision data.
`HC_Compute_Normalized_Vector()`
`HC_DCompute_Normalized_Vector()`
`HC_Compute_Offaxis_Rotation()`
`HC_DCompute_Offaxis_Rotation()`	Similar to Compute_Offaxis_Rotation, but operates on double-precision data.
`HC_Compute_Offcenter_Rotation()`
`HC_DCompute_Offcenter_Rotation()`	Similar to Compute_Offcenter_Rotation, but operates on double-precision data.
`HC_Compute_Optimized_Shell()`	Performs one of several computations to prepare shell data for improved rendering performance. The default computation is to remove redundant vertices and degenerate faces.
`HC_Compute_Capping_Shell()`	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.
`HC_Compute_Boolean_Shell()`	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.
`HC_Compute_Polygon_Normal()`
`HC_DCompute_Polygon_Normal()`	Similar to Compute_Polygon_Normal, but operates on double-precision data.
`HC_Compute_Polygon_Plane()`
`HC_DCompute_Polygon_Plane()`	Similar to Compute_Polygon_Plane, but operates on double-precision data.
`HC_Compute_Rotation_Matrix()`
`HC_DCompute_Rotation_Matrix()`	Similar to Compute_Rotation_Matrix(), but operates on double-precision data.
`HC_Compute_Scale_Matrix()`
`HC_DCompute_Scale_Matrix()`	Similar to Compute_Scale_Matrix, but operates on double-precision data.
`HC_Compute_Selection()`	Forces the explicit computation and generation of selection events.
`HC_Compute_Selection_By_Area()`	Similar to Compute_Selection(), but operates on a rectangular area.
`HC_Compute_Selection_By_Polygon()`	Similar to Compute_Selection(), but operates on a polygonal area.
`HC_Compute_Selection_By_Polylin()`	Similar to Compute_Selection(), but operates on polyline intersections.
`HC_Compute_Selection_By_Volume()`	Similar to Compute_Selection(), but operates on a cuboid volume.
`HC_Compute_Text16_From_Text()`	Converts from integer-array representations of 16-bit characters to string representations.
`HC_Compute_Text_Extent()`	Finds out what the dimensions are for a given text string.
`HC_Compute_Text_Extent_By_Key()`	Similar to Compute_Text_Extent(), but operates on text referenced by an HC_KEY.
`HC_Compute_Text_Extent_By_Path()`	Similar to Compute_Text_Extent(), but concatenates the matrices along a segment path rather than the currently open segment.
`HC_Compute_Text_Extent_Enc_Path()`	Similar to Compute_Text_Extent_By_Path(), but operates on encoded text rather that Latin1 text.
`HC_Compute_Text_Extent_With_Enc()`	Similar to Compute_Text_Extent() but operates on encoded text rather than Latin1 text.
`HC_Compute_Text_Metrics()`
`HC_Compute_Text_Metrics_Size()`
`HC_Compute_Text_From_Text16()`	Converts from string to integer-array representations of 16-bit characters.
`HC_Compute_Text_Outline()`	Calculates a polyhedral representation of the given text glyphs.
`HC_Compute_Text_Outline_By_Key()`	Similar to Compute_Text_Outline(), but operates on an object referenced by an HC_KEY.
`HC_Compute_Text_Outline_Size()`	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().
`HC_Compute_Text_Outline_Size_By()`	Similar to Compute_Text_Outline_Size(), but enables the user to pass in a key for the desired text object.
`HC_Compute_Text_Outline_Size_Wi()`	Similar to Compute_Text_Outline_Size(), but operates on encoded text rather than Latin1 text.
`HC_Compute_Text_Outline_With_En()`	Similar to Compute_Text_Outline(), but operates on encoded text rather than Latin1 text.
`HC_Compute_Text_Outline_By_Path()`	Similar to Compute_Text_Outline(), but concatenates the matrices along a segment path rather than the specified segment.
`HC_Compute_Text_Outline_Size_Pa()`	Similar to Compute_Text_Outline(), but concatenates the matrices along a segment path rather than the specified segment.
`HC_Compute_Transform()`	Converts positions back and forth among the various coordinate systems.
`HC_DCompute_Transform()`	Similar to Compute_Transform(), but operates on double-precision data.
`HC_Compute_Transform_By_Path()`	Similar to Compute_Transform(), but concatenates the matrices along a segment path rather than the currently open segment.
`HC_DCompute_Transform_By_Path()`	Similar to Compute_Transform_By_Path(), but operates on double-precision data.
`HC_Compute_Transformed_Plane()`	Applies a user-defined transform to a single plane.
`HC_DCompute_Transformed_Plane()`	Similar to Compute_Transformed_Plane(), but operates on double-precision data.
`HC_Compute_Transformed_Planes()`	Applies a user-defined transform to a group of planes.
`HC_DCompute_Transformed_Planes()`	Applies a user-defined transform to a group of planes.
`HC_Compute_Transformed_Points()`	Applies a user-specified transform to any number of points.
`HC_Compute_Translation_Matrix()`
`HC_DCompute_Translation_Matrix()`	Similar to Compute_Translation_Matrix(), but operates on double-precision data.
`HC_Compute_Vector_Length()`
`HC_DCompute_Vector_Length()`	Similar to Compute_Vector_Length(), but operates on double-precision data.
`HC_Control_Update()`	Controls the amount of redrawing for the subsequent update.
`HC_Control_Update_Area()`	Similar to Control_Update(), but operates on the objects within a defined window area.
`HC_Control_Update_Area_By_Key()`	Similar to Control_Update_Area(), but operates on an object referenced by an HC_KEY.
`HC_Control_Update_By_Key()`	Similar to Control_Update(), but operates on an object referenced by an HC_KEY.
`HC_Convert_Precision()`
`HC_Define_Alias()`	Permits a “shorthand” name to be used in place of a longer proper name of a segment.
`HC_Define_Callback_Name()`	Defines a unique name as a legal callback.
`HC_Define_Color_Name()`	Adds a new color name (for example, “VERMILION”) to the existing colors in the system’s tables (for example, “RED”).
`HC_Define_Driver_Config()`	Sets up driver device-dependent configuration.
`HC_Define_Error_Handler()`	Creates a legal name for an error handler that captures HOOPS error reports.
`HC_Define_Exit_Handler()`	Allows the program a chance to “clean up” upon termination.
`HC_Define_Font()`	Describes a specific set of simple geometry to be used as the actual shapes when drawing text characters.
`HC_Define_Font_By_Reference()`	Similar to Define_Font(), but avoids creating an internal copy of the font within HOOPS memory.
`HC_Define_Glyph()`	Describes a set of simple geometries which can be later used to define a custom marker, edge, or line style.
`HC_Define_Image_Glyph()`
`HC_Define_Line_Style()`	Allows the user to create a custom line style using a combination of lines, blanks, glyphs, and attributes.
`HC_Define_Shape()`	Defines a shape to be used for the background of a text annotation.
`HC_Define_System_Options()`	Controls non-graphics system behavior.
`HC_Define_Texture()`	Assigns a name to a set of texture mapping options.
`HC_Define_Local_Texture()`	Define a texture on the currently open segment.
`HC_Define_Shader()`	Defines a section of code that will be injected into HOOPS 3DF shaders.
`HC_Delete_By_Key()`	Throws away a segment identified by key rather than by name, or throws away a particular geometry item.
`HC_Delete_Segment()`	Throws away a segment when you no longer need it. Can also be used to shut down a display.
`HC_Dolly_Camera()`	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.
`HC_Dump_Memory_Profile()`
`HC_Edit_Image()`	Modifies one, some, or all the pixel values in a previously-inserted image.
`HC_Edit_Image_Options()`	Modifies the the options associated with a specific image.
`HC_Edit_Mesh()`	Modifies one, some, or all of the vertex values in a previously-inserted mesh.
`HC_Edit_NURBS_Curve()`	Modifies the control points, weights, and/or knots of a previously-inserted NURBS curve.
`HC_Edit_Polygon()`	Adjusts the boundary of a previously declared polygon.
`HC_Edit_Polyline()`	Adjusts the contents of a previously declared polyline.
`HC_Edit_Shell_Faces()`	Creates or deletes faces in a previously declared shell.
`HC_Edit_Shell_Points()`	Changes or deletes vertex points of a previously declared shell, or adds new points.
`HC_Edit_Text()`	Manipulate the characters in a previously defined string.
`HC_Edit_Text_Leader()`
`HC_End_Alias_Search()`	Terminates the alias search sequence and frees any involved memory.
`HC_End_Callback_Name_Search()`	Terminates the callback name search sequence and frees any involved memory.
`HC_End_Color_Name_Search()`	Terminates the color name search sequence and frees any involved memory.
`HC_End_Contents_Search()`	Terminates the object search sequence and frees any involved memory.
`HC_End_Font_Search()`	Terminates the font search sequence and frees any involved memory.
`HC_End_Open_Segment_Search()`	Terminates the segment search sequence and frees any involved memory.
`HC_End_Segment_Search()`	Terminates the segment search sequence and frees any involved memory.
`HC_End_Texture_Search()`	Terminates the texture search sequence and frees any involved memory.
`HC_End_Shader_Search()`	Terminates the shader search sequence and frees any involved memory.
`HC_End_Glyph_Search()`	Terminates the glyph search sequence and frees any involved memory.
`HC_End_Line_Style_Search()`	Terminates the line style search sequence and frees any involved memory.
`HC_End_Shape_Search()`
`HC_Exit_Program()`	Calls the defined exit handlers, and exits to the operating system with a normal status.
`HC_Find_Alias()`	Retrieves the alias names, one at a time. The function returns false when all aliases have been returned.
`HC_Find_Callback_Name()`	Retrieves the callback names, one at a time. The function returns false when all aliases have been returned.
`HC_Find_Color_Name()`	Retrieves the color names, one at a time. The function returns false when all color names have been returned.
`HC_Find_Contents()`	Retrieves the object keys, one at a time. The function returns false when all objects have been returned.
`HC_Find_Contents_Original_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.
`HC_Find_Font()`	Retrieves the font names, one at a time. The function returns false when all aliases have been returned.
`HC_Find_Open_Segment()`	Retrieves the segments, one at a time. The function returns false when all segments have been returned.
`HC_Find_Related_Selection()`	Allows you to inspect the “next best” geometry item with the current Selection Event.
`HC_Find_Segment()`	Retrieves the segment names, one at a time. The function returns false when all segments have been returned.
`HC_Find_Texture()`	Retrieves the texture names, one at a time. The function returns false when all textures have been returned.
`HC_Find_Shader()`	Retrieves the shader names, one at a time. The function returns false when all shaders have been returned.
`HC_Find_Glyph()`	Retrieves the glyph names, one at a time. The function returns false when all glyphs have been returned.
`HC_Find_Line_Style()`	Retrieves the line style names, one at a time. The function returns false when all line styles have been returned.
`HC_Find_Shape()`
`HC_Flush_Attributes()`	Flushes attributes from a segment but leaves styles, geometry, segments, and subsegments.
`HC_Flush_By_Key()`	Throws away the contents of a geometric primitive or a segment but leaves the structure intact.
`HC_Flush_Contents()`	Empties some or all of the drawing primitives, attributes, or subsegments from a segment.
`HC_Flush_Geometry()`	Flushes just geometry from a segment but leaves attributes, styles, segments, and subsegments.
`HC_Edit_Sphere()`	Edits a sphere object as it sits in the database without deleting and re-inserting.
`HC_Edit_Circle()`	Generates a flat, infinitely thin, colored-in circular object.
`HC_Edit_Circle_By_Radius()`	Generates a flat, infinitely thin, colored-in circular object.
`HC_Edit_Circular_Arc()`	Modifies a circular arc as it sits in the database.
`HC_Edit_Circular_Chord()`	Edits a circular chord as it sits in the database.
`HC_Edit_Circular_Wedge()`	Edits a circular wedge as it sits in the database.
`HC_Edit_Cutting_Plane()`	Modifies a cutting plane as it exists in the database.
`HC_Edit_Ellipse()`	Edits an ellipse as it sits in the database.
`HC_Edit_Elliptical_Arc()`	Edits an elliptical arc as it sits in the database.
`HC_Edit_Grid()`	Edits a grid object as it sits in the database.
`HC_Edit_Line()`	Edits a line object as it sits in the database, without deleting and reinserting.
`HC_Edit_Infinite_Line()`	Modifies an existing infinite line.
`HC_Edit_Infinite_Ray()`	Modifies an existing infinite ray.
`HC_DEdit_Infinite_Line()`	Similar to Edit_Infinite_Line(), but operates on double-precision data.
`HC_DEdit_Infinite_Ray()`
`HC_Edit_Marker()`	Edits a marker object as it sits in the database.
`HC_Edit_Cylinder()`	Edits a cylinder object as it sits in the database without deleting and reinserting.
`HC_Edit_PolyCylinder_Points()`	Edits an existing polycylinder by inserting or deleting its points.
`HC_Edit_PolyCylinder_Radii()`	Edits an existing polycylinder by inserting or deleting its points.
`HC_DEdit_PolyCylinder_Points()`	Similar to Edit_PolyCylinder_Points, but operates on double-precision data.
`HC_DEdit_PolyCylinder_Radii()`	Similar to Edit_PolyCylinder_Radii, but operates on double-precision data.
`HC_Edit_PolyCylinder()`	Edits a polycylinder as it sits in the database, without deleting and reinserting.
`HC_Edit_PolyCylinder_With_Basis()`	Edits the polycylinder’s points, radii, and vector basis.
`HC_Copy_Geometry()`	Copies the geometry referred to by key to the given segment.
`HC_Copy_Segment()`	Completely duplicates a segment.
`HC_Create_Segment()`	Brings a segment into existence without opening it.
`HC_Include_Segment()`	Leaves a note for the system directing it to grab a copy of another segment whenever the current one is displayed.
`HC_Include_Segment_By_Key()`	Similar to Include_Segment(), but operates on an object referenced by an HC_KEY.
`HC_Insert_Area_Light()`	Inserts an area light.
`HC_Insert_Circle()`	Generates a flat, infinitely thin, filled circle.
`HC_Insert_Circular_Arc()`	Generates a portion of the circumference of a circle.
`HC_Insert_Circular_Chord()`	Generates a polygon describing a portion of a circle.
`HC_Insert_Circular_Wedge()`	Generates a wedge shaped polygon representing a portion of a circle.
`HC_Insert_Cutting_Plane()`	Creates a special geometric object that “cuts away” part of the normal scene.
`HC_Insert_Cylinder()`	Inserts a cylinder into the currently open segment.
`HC_Insert_Sphere()`	Generates a sphere.
`HC_Insert_Circle_By_Radius()`	Generates a flat, infinitely thin, colored-in circular object.
`HC_Insert_Distant_Light()`	Inserts a distant point source of light into your scene.
`HC_Insert_Ellipse()`	Generates a flat, infinitely thin, colored-in elliptical object.
`HC_Insert_Elliptical_Arc()`	Generates a portion of the perimeter of an ellipse.
`HC_Insert_Grid()`	Generates a flat array of edges, faces, and/or markers.
`HC_Insert_Image()`	Inserts a pixel-based image in the HOOPS Visualize database.
`HC_Insert_Compressed_Image()`	Inserts a compressed pixel-based image in the HOOPS database.
`HC_Insert_Image_By_Ref()`	Similar to Insert_Image(), but does not create a copy of the image data within HOOPS.
`HC_DInsert_Image_By_Ref()`	Similar to Insert_Image_By_Ref(), but operates on double-precision data.
`HC_Insert_Ink()`	Utility routine to extend the “currently-being-inked-in” polyline.
`HC_Insert_Line()`	Adds a simple line segment to the current graphics segment.
`HC_Insert_Infinite_Line()`	Adds an infinitely long line to the currently open segment.
`HC_Insert_Infinite_Ray()`	Adds an infinitely long line to the currently open segment.
`HC_DInsert_Infinite_Line()`	Similar to Insert_Infinite_Line() but accepts parameters of type double for increased precision. Unlike Insert_Infinite_Line, the parameters are not truncated.
`HC_DInsert_Infinite_Ray()`	Similar to Insert_Infinite_Ray() but accepts parameters of type double for increased precision. Unlike Insert_Infinite_Ray, the parameters are not truncated.
`HC_Insert_Local_Light()`	Inserts an omni-directional “point” source of light into your scene.
`HC_Insert_Marker()`	Inserts a single marker symbol at the specified location in your scene.
`HC_Insert_Mesh()`	Puts a rectangular array of faces into the database.
`HC_Insert_Mesh_By_Ref()`
`HC_DInsert_Mesh_By_Ref()`	Similar to Insert_Mesh_By_Ref(), but operates on double-precision data.
`HC_Insert_NURBS_Curve()`
`HC_Insert_Polygon()`	Generates a simple flat, infinitely thin, colored-in object.
`HC_Insert_Polyline()`	Generates a connected chain of line segments. Can be used to approximate arcs.
`HC_Insert_Shell()`	Generates an object that is an arbitrarily-connected collection of arbitrary polygonal facets.
`HC_Insert_Shell_By_Ref()`
`HC_DInsert_Shell_By_Ref()`	Similar to Insert_Shell_By_Ref(), but operates on double-precision data.
`HC_Insert_Shell_By_Tristrips()`	Generates an object that is an arbitrarily-connected collection of arbitrary polygonal facets.
`HC_DInsert_Shell_By_Tristrips()`	Similar to Insert_Shell_By_Tristrips(), but operates on double-precision data.
`HC_Insert_Spot_Light()`	Inserts a directional “point” source of light into your scene.
`HC_Insert_String_Cursor()`	Places a cursor into a text string.
`HC_Insert_Text()`	Puts lettering into the current segment, and thence into the picture.
`HC_Insert_Text_Leader()`	Inserts a leader line.
`HC_Insert_Text_With_Encoding()`	Similar to Insert_Text(), but operates with encoded text rather than Latin1 text.
`HC_Open_Segment()`	Readies a segment to receive drawing commands. (Also useful when several attributes all need changing at once.)
`HC_Renumber_Key()`	Changes the key for a segment, include, style, or piece of geometry to a value more useful to your program.
`HC_Show_Include_Segment()`	Returns the segment that is referenced by an inclusion.
`HC_Show_Owner_Original_Key()`	Similar to Show_Owner() but returns the non-renumber key of the owning segment.
`HC_Style_Segment()`	“Styles” the currently open segment to be drawn in the style of the referenced ones.
`HC_Style_Segment_By_Key()`	Similar to Style_Segment(), but operates on a style referenced by an HC_KEY.
`HC_MSet_Character_Attributes()`	Allows developers to set text attributes on a per-character basis within a text string.
`HC_MUnSet_Character_Attributes()`	Un-sets text attributes established in a previous call to MSet_Character_Attributes.
`HC_MSet_Face_Normals()`	Speedily sets the drawing attributes on a large number of shell or mesh faces.
`HC_MSet_Face_Colors_By_FIndex()`	Sets the drawing attributes on a contiguous range of shell or mesh faces speedily.
`HC_MSet_Face_Colors_By_Value()`	Sets the drawing attributes on a contiguous range of shell or mesh faces speedily.
`HC_MSet_Vertex_Colors_By_FIndex()`	Sets the color on a contiguous range of shell, mesh, or polycylinder vertices.
`HC_MSet_Vertex_Colors_By_Value()`	Sets the color on a contiguous range of shell, mesh, or polycylinder vertices.
`HC_MSet_Vertex_Colors_By_Value4()`	Sets the color on a contiguous range of shell, mesh, or polycylinder vertices.
`HC_MSet_Vertex_Normals()`	Speedily sets the drawing attributes on a large number of shell, mesh, or polycylinder vertices.
`HC_MSet_Vertex_Parameters()`	Speedily sets the drawing attributes on a large number of shell, mesh, or polycylinder vertices.
`HC_Modify_Color_Map()`	Changes the array of colors which are used when displaying Images, or “by index”, color attributes.
`HC_Modify_Color_Map_By_Value()`	Similar to Modify_Color_Map() but operates with a color values rather than names or map indices.
`HC_Move_By_Key()`	Moves a single geometric primitive or segment from one segment to another.
`HC_Move_Distant_Light()`	Changes the location, in object space, of a previously-inserted “distant light”.
`HC_Move_Image()`	Changes the location, in object space, of a previously-inserted Image. Double-precision parameters, if passed to this function, are truncated during calculations.
`HC_Move_Light_Position()`	Changes the location, in object space, of a previously inserted “local light” or “spot light”.
`HC_Move_Light_Target()`	Changes the location towards which a previously inserted “spot light” shines in user coordinates.
`HC_Move_Segment()`	Changes the name of a segment, and/or moves it somewhere else in the segment tree.
`HC_Move_String_Cursor()`	Changes the position of a previously created String Cursor.
`HC_Move_Text()`	Changes the location, in object space, of a previously-inserted Text item.
`HC_Open_Edge()`	Prepares an edge within a shell or mesh for the local overriding of drawing attributes.
`HC_Open_Face()`	Prepares a face within a shell or mesh for the local overriding of drawing attributes.
`HC_Open_Geometry()`	Readies an item of geometry - in particular a shell or a mesh - or a light to receive local attributes.
`HC_Open_LOD()`	Allows user to open a LOD representation for the purpose of manually inserting a LOD.
`HC_Open_Region()`	Prepares a defined shell region for modification.
`HC_Open_Segment_By_Key()`	Similar to Open_Segment(), but operates on an object referenced by an HC_KEY.
`HC_Open_Vertex()`	Prepares a vertex within a shell, mesh, or polycylinder for the local overriding of drawing attributes.
`HC_Orbit_Camera()`	Walks the viewer’s point of view around the object being looked at.
`HC_PShow_Net_Callback()`	Returns the net effective callback settings along a path of segments specified by an array of HC_KEY’s.
`HC_PShow_Net_Camera()`	Returns the net effective setting along a discrete segment path.
`HC_PShow_Net_Camera_By_Volume()`	Similar to Show_Camera_By_Volume(), but returns the net effective camera along a discrete segment path.
`HC_PShow_Net_Camera_Position()`	Returns the net effective setting along a discrete segment path.
`HC_PShow_Net_Camera_Target()`	Returns the net effective setting along a specified path of keys rather than the local one.
`HC_PShow_Net_Camera_Up_Vector()`	Returns the net effective setting along a discrete segment path.
`HC_PShow_Net_Camera_Field()`	Returns the net effective setting along a discrete segment path.
`HC_PShow_Net_Camera_Projection()`	Returns the net effective setting along a discrete segment path specified with a set of keys.
`HC_DPShow_Net_Camera()`	Similar to PShow_Net_Camera(), but operates on double-precision cameras.
`HC_DPShow_Net_Camera_By_Volume()`	Similar to PShow_Net_Camera_By_Volume(), but operates on double-precision cameras.
`HC_DPShow_Net_Camera_Position()`	Similar to PShow_Net_Camera_Position(), but operates on double-precision cameras.
`HC_DPShow_Net_Camera_Target()`	Similar to PShow_Net_Camera_Target(), but operates on double-precision cameras.
`HC_DPShow_Net_Camera_Up_Vector()`	Similar to PShow_Net_Camera_Up_Vector(), but operates on double-precision cameras.
`HC_DPShow_Net_Camera_Field()`	Similar to PShow_Net_Camera_Field(), but operates on double-precision cameras.
`HC_PShow_Net_Color()`	Similar to Show_Color(), but returns the net effective settings along a discrete path of segments.
`HC_PShow_Net_Color_Map()`
`HC_PShow_Net_Color_Map_By_Value()`	Similar to Show_Color_Map_By_Value(), but returns the net effective setting along a discrete segment path.
`HC_PShow_Net_Color_Map_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.
`HC_PShow_Net_Driver_Options()`	Similar to Show_Driver_Options(), but returns the net effective settings along a discrete segment path.
`HC_PShow_Net_Edge_Pattern()`	Similar to Show_Edge_Pattern(), but returns the net effective setting along a discrete segment path.
`HC_PShow_Net_Edge_Weight()`	Similar to Show_Edge_Weight(), but returns the net effective setting along a discreet segment path.
`HC_PShow_Net_Face_Pattern()`	Similar to Show_Face_Pattern(), but returns the net effective setting rather than the local one.
`HC_PShow_Net_Handedness()`	Similar to Show_Handedness(), but returns the net effective setting along a discrete segment path.
`HC_PShow_Net_Heuristics()`	Similar to Show_Heuristics(), but returns the net effective settings along a discrete segment path.
`HC_PShow_Net_Line_Pattern()`	Similar to Show_Line_Pattern(), but returns the net effective setting along a discrete segment path.
`HC_PShow_Net_Line_Weight()`	Similar to Show_Line_Weight(), but returns the net effective setting along a discrete segment path.
`HC_PShow_Net_Marker_Size()`	Similar to Show_Marker_Size(), but returns the net effective setting along a discrete segment path.
`HC_PShow_Net_Marker_Symbol()`	Similar to Show_Marker_Symbol(), but returns the net effective setting along a discrete segment path.
`HC_PShow_Net_Modelling_Matrix()`	Similar to Show_Modelling_Matrix(), but returns the net effective value along a discrete segment path.
`HC_DPShow_Net_Modelling_Matrix()`	Similar to PShow_Net_Modelling_Matrix(), but operates on double-precision modelling matrices.
`HC_PShow_Net_Rendering_Options()`	Similar to Show_Rendering_Options() but returns the net settings along a discrete path.
`HC_PShow_Net_Selectability()`	Similar to Show_Selectability() but returns the net settings along a discrete path.
`HC_PShow_Net_Text_Alignment()`	Similar to Show_Text_Alignment(), but returns the net effective setting along a discrete segment path.
`HC_PShow_Net_Text_Font()`	Similar to Show_Text_Font(), but returns the net effective settings along a discrete segment path.
`HC_PShow_Net_Text_Path()`	Similar to Show_Text_Path(), but returns the net effective setting along a discrete segment path.
`HC_PShow_Net_Text_Spacing()`	Similar to Show_Text_Spacing(), but returns the net effective setting along a discrete segment path.
`HC_PShow_Net_Texture_Matrix()`	Similar to Show_Texture_Matrix(), but returns the net effective matrix along a discrete segment path.
`HC_PShow_Net_User_Index_Count()`	Similar to Show_User_Index_Count(), but returns the net effective size rather than the local one.
`HC_PShow_Net_User_Indices()`	Similar to Show_User_Indices(), but returns the net effective settings along a discrete segment path.
`HC_PShow_Net_User_Options()`	Similar to Show_User_Options(), but returns the net effective settings along a discrete segment path.
`HC_PShow_Net_Unicode_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.
`HC_PShow_Net_User_Opt_Length()`	Finds the net effective value of the length along a path of segments specified by an array of HC_KEY’s.
`HC_PShow_Net_Unicode_Opt_Length()`	Returns the net effective value of the length along a path of segments specified by an array of HC_KEY’s.
`HC_PShow_Net_User_Value()`
`HC_PShow_Net_Visibility()`	Similar to Show_Visibility(), but returns the net effective settings along a discreet segment path.
`HC_PShow_Net_Window()`	Similar to Show_Window() but returns the net effective setting along a discrete segment path.
`HC_PShow_Net_Window_With_Options()`
`HC_PShow_Net_Window_Frame()`	Similar to Show_Window_Frame(), but returns the net effective setting along a discrete segment path.
`HC_PShow_Net_Window_Pattern()`	Similar to Show_Window_Pattern(), but returns the net effective setting along a discrete segment path.
`HC_PShow_One_Net_Callback()`	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.
`HC_PShow_One_Net_Callback_WD()`	Returns the net effective setting of a single callback along a path of segment specified by an array of HC_KEY’s.
`HC_PShow_One_Net_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.
`HC_PShow_One_Net_Color_By_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.
`HC_PShow_One_Net_Color_By_Value()`	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.
`HC_PShow_One_Net_Color_Map()`	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.
`HC_PShow_One_Net_Color_Map_By_V()`	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.
`HC_PShow_One_Net_Driver_Option()`	Show_One_Driver_Option() but returns the net settings along a discrete path.
`HC_PShow_One_Net_Heuristic()`	Similar to Show_One_Heuristic() but returns the net settings along a discrete path.
`HC_PShow_One_Net_Rendering_Opti()`	Similar to Show_One_Rendering_Option() but returns the net settings along a discrete path.
`HC_PShow_One_Net_Selectability()`	Similar to Show_One_Selectability() but returns the net settings along a discrete path.
`HC_PShow_One_Net_Text_Font()`	Similar to Show_One_Text_Font() but returns the net settings along a discrete path.
`HC_PShow_One_Net_User_Index()`	Similar to Show_One_Net_User_Index() but returns the net settings along a discrete path.
`HC_PShow_One_Net_User_Option()`
`HC_PShow_One_Net_Unicode_Opt()`	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.
`HC_PShow_One_Net_Visibility()`	Similar to Show_One_Visibility() but returns the net settings along a discrete path.
`HC_Pan_Camera()`	Sweeps the camera across its current scene.
`HC_Parse_String()`	A utility routine for extracting delimited strings from longer strings.
`HC_Pause()`	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.
`HC_Print_Version()`	Prints out the version number of the HOOPS you’re using.
`HC_QShow_Existence()`	Similar to Show_Existence(), but operates on a given segment rather than the currently open one.
`HC_Show_Existence()`	A utility routine to determine how much of something exists within a segment, or if it exists at all.
`HC_Show_Existence_By_Key()`	Similar to Show_Existence(), but operates on an object referenced by an HC_KEY.
`HC_QShow_Existence_Unicode()`	Similar to Show_Existence_Unicode(), but operates on a given segment rather than the currently open one.
`HC_Show_Existence_Unicode()`	A utility routine used to determine whether one or more unicode user options exist within a segment.
`HC_Show_Existence_Unicode_By_K()`	Similar to Show_Existence_Unicode(), but operates on an object referenced by an HC_KEY.
`HC_Read_Metafile()`	Reads a metafile into a segment from a file.
`HC_Record_Instance_Handle()`	Registers the instance of the application with the HOOPS dynamic link library.
`HC_Record_Profile_Source()`	Identifies the INI file name and section to use for evaluating profile strings.
`HC_Relinquish_Memory()`	Returns temporary memory (kept internally by HOOPS) to the system.
`HC_Rename_Segment()`	Changes the name of a segment, and/or moves it somewhere else in the segment tree.
`HC_Rename_Segment_By_Key()`
`HC_Report_Error()`	Performs the default HOOPS error printing/displaying.
`HC_Reset_System()`	Performs a complete master reset of the HOOPS system.
`HC_Restart_Ink()`	Makes sure that the next Insert_Ink request in the current segment starts a brand-new line.
`HC_Roll_Camera()`	Pinwheels the user’s point of view around the viewing axis.
`HC_Rotate_Object()`	Moves the represented object about its X -, Y -, or Z -axis.
`HC_Rotate_Object_Offaxis()`	Moves the represented object about an arbitrary axis.
`HC_DRotate_Object()`	Similar to Rotate_Object(), but operates on double-precision data.
`HC_DRotate_Object_Offaxis()`	Similar to Rotate_Object_Offaxis(), but operates on double-precision data.
`HC_Rotate_Texture()`	Moves the represented texture about its U -, V -, or W -axis.
`HC_Rotate_Texture_Offaxis()`	Rotates the represented texture coordinates (vertex parameters) about an arbitrary axis.
`HC_Scale_Object()`	Enlarges or reduces objects within the user data space. Not to be confused with Zoom_Camera.
`HC_DScale_Object()`	Similar to Scale_Object(), but operates on double-precision data.
`HC_Scale_Texture()`	Gives the appearance of enlarging or reducing the size of a surface’s texture map by scaling the referenced (u, v, w) vertex parameters.
`HC_Scroll_Text()`	To shift text around as you would on a scrolling alphanumeric terminal screen.
`HC_Set_Bounding_Cuboid()`	Specifies the cuboid used by HOOPS to circumscribe the geometry within a segment.
`HC_Set_Bounding_Sphere()`	Specifies the sphere used by HOOPS to circumscribe the geometry within a segment.
`HC_DSet_Bounding_Cuboid()`	Similar to Set_Bounding_Cuboid(), but operates on double-precision data.
`HC_DSet_Bounding_Sphere()`	Similar to Set_Bounding_Sphere(), but operates on double-precision data.
`HC_Set_Callback()`	Establishes a procedural link between HOOPS database traversal and immediate mode rendering.
`HC_Set_Callback_With_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.
`HC_Set_Camera()`	Allows the complete specification of the viewing camera’s position, orientation, and field of view.
`HC_Set_Camera_By_Volume()`	Sets up the Camera so that the screen will show one simple rectangular box extracted from the infinite user data space.
`HC_Set_Camera_Field()`	After the viewing “camera” has been positioned, adjusts the width or height of the total field of view.
`HC_Set_Camera_Position()`	Sets up your viewing tripod within the framework of the scene you’ve created.
`HC_Set_Camera_Projection()`	Lets you control how your 3D scene is to be converted to 2D for viewing.
`HC_Set_Camera_Target()`	Determines what your viewing camera is looking at.
`HC_Set_Camera_Up_Vector()`	Given a “camera” position and target, which define a line of sight, the “up vector” defines how much the camera is tilted.
`HC_Set_Color()`	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.
`HC_Set_Explicit_Color()`	Allows the specific channel, RGB, and texture components of a color definition to be set separately.
`HC_Set_Color_By_FIndex()`	This is a specialized version of Set_Color_By_Index for use with false-colored pictures.
`HC_Set_Color_By_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.
`HC_Set_Color_By_Value()`	Changes the color to be used when rendering the contents of a segment. The color is defined numerically rather than by quoted-string.
`HC_Set_Color_Map()`	Sets up the colors to be used when displaying images or “by index” color attributes.
`HC_Set_Color_Map_By_Value()`	Similar to Set_Color_Map(), but operates with a color values rather than names or map indices.
`HC_Set_Driver_Options()`	Provides information to the system about a variety of special device-specific display options.
`HC_Set_Edge_Pattern()`	Applies a pattern of dots and dashes, or whatever, to the edges of polygons, circles, ellipses, shells, and meshes.
`HC_Set_Edge_Pattern_Explicit()`	Applies line style and inner joins options to the edges of polygons, circles, ellipses, shells, and meshes.
`HC_Set_Edge_Weight()`	Makes the edges of polygons, circles, ellipses, shells, and meshes broader or narrower than normal.
`HC_Set_Face_Pattern()`	Allows a pattern to be applied to surfaces in the scene.
`HC_Set_Handedness()`	Changes the Cartesian world coordinate system from “left-handed” to “right-handed” and back again.
`HC_Set_Heuristics()`	Gives hints to the system about good short cuts to take during program execution.
`HC_Set_Line_Pattern()`	Applies a pattern of dashes and dots to lines and polylines.
`HC_Set_Line_Pattern_Explicit()`	Applies line style, caps, joins and arrow options on a line or polyline to be set directly.
`HC_Set_Line_Weight()`	Makes simple lines and polylines broader or narrower than normal.
`HC_Set_Marker_Size()`	Makes marker symbols larger or smaller than usual.
`HC_Set_Marker_Symbol()`	Changes the screen icon used to represent graphical “markers” in the scene.
`HC_Set_Modelling_Matrix()`	Allows direct manipulation of the transformation that is applied against all the picture elements in a segment.
`HC_DSet_Modelling_Matrix()`	Similar to Set_Modelling_Matrix(), but operates on double-precision matrices.
`HC_Set_Normal()`	Forces the normal vector at a vertex, edge, or face to a particular value.
`HC_Set_Parameter()`	Defines texture mapping coordinates for a previously opened Shell or Mesh vertex.
`HC_Set_Priority()`	Overrides the default drawing priority automatically assigned by HOOPS.
`HC_UnSet_PBR_Material()`
`HC_Set_PBR_Material()`
`HC_Show_PBR_Material()`	Shows a physically-based rendering material on a segment with the attributes specified.
`HC_PShow_Net_PBR_Material()`	Shows the net physically-based rendering material on a segment with the attributes specified, according to the key path.
`HC_Set_Rendering_Options()`
`HC_Set_Selectability()`	Allows you to make part of your picture sensitive or insensitive to being “selected” by the user.
`HC_Set_Shader()`	Allows you to have the current segment drawn using a custom vertex and/or pixel shader.
`HC_Set_Shader_Outputs()`	Sets the output required by the shader at runtime. Only valid for modern custom shaders.
`HC_Show_Shader_Outputs_Size()`	Returns the size of the shader output specification in bytes. Only valid for modern custom shaders.
`HC_Show_Shader_Outputs()`	Returns the shader output specification if present. Only valid for modern custom shaders.
`HC_UnSet_Shader_Outputs()`	Removes the output specification from the shader. Only valid for modern custom shaders.
`HC_Set_Shader_Uniforms()`	Sets uniforms required by the shader at runtime. Only valid for modern custom shaders.
`HC_Set_Shader_Uniforms_Data()`	Sets uniforms data used by the shader at runtime. Only valid for modern custom shaders.
`HC_Show_Shader_Uniforms_Data_Size()`	Returns the size of the shader uniform data in bytes. Only valid for modern custom shaders.
`HC_Show_Shader_Uniforms_Data()`	Returns the size of the shader uniform data in bytes. Only valid for modern custom shaders.
`HC_Show_Shader_Uniforms_Size()`	Returns the size of the shader uniform specification in bytes. Only valid for modern custom shaders.
`HC_Show_Shader_Uniforms()`	Returns the shader uniforms specification if present. Only valid for modern custom shaders.
`HC_UnSet_Shader_Uniforms()`	Removes the uniform specification from the shader. Only valid for modern custom shaders.
`HC_Set_Streaming_Mode()`	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.
`HC_Set_Text_Alignment()`	Determines where in each chunk of text the “reference point” is to fall.
`HC_Set_Text_Font()`	Chooses the character style to use for text.
`HC_Set_Text_Path()`	Allows you to alter the direction in which text strings run.
`HC_Set_Text_Size()`
`HC_Set_Text_Spacing()`	Allows you to space out or squeeze the text strings in a segment.
`HC_Set_Texture_Matrix()`	Allows direct specification of the transformation that is applied against all vertex parameters in the segment’s scope.
`HC_Set_User_Index()`	Associates a segment with an index into a user-defined array of option strings.
`HC_Set_User_Options()`	Allows you to create new “attributes” of your own choosing.
`HC_Set_Unicode_Options()`	Stores a double byte character string in the currently opened segment.
`HC_Set_User_Value()`
`HC_Set_Visibility()`	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.
`HC_Set_Window()`	Limits the amount of the screen (or the containing Window) to be used by the referenced segment upon display.
`HC_Set_Window_With_Options()`
`HC_Set_Window_Frame()`	Causes the system to automatically delineate any windows encountered.
`HC_Set_Window_Pattern()`	Specifies the patterned texture to use for window backgrounds.
`HC_Show_Alias()`	Returns the expansion of a given alias.
`HC_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.
`HC_Show_Area_Light()`	Shows the points and options associated with the area light of the given key.
`HC_Show_Area_Light_Count()`
`HC_Show_Bounding_Cuboid()`	Returns the cuboid used by HOOPS to circumscribe the geometry within a segment.
`HC_Show_Bounding_Cuboid_By_Key()`	Similar to Show_Bounding_Cuboid(), but operates on an object referenced by an HC_KEY.
`HC_DShow_Bounding_Cuboid()`	Similar to Show_Bounding_Cuboid(), but operates on double-precision data.
`HC_DShow_Bounding_Cuboid_By_Key()`	Similar to Show_Bounding_Cuboid_By_Key(), but operates on double-precision data.
`HC_Show_Bounding_Info()`	Identifies which type of bounding volume HOOPS is using to circumscribe geometry.
`HC_Show_Bounding_Info_By_Key()`	Similar to Show_Bounding_Info(), but operates on an object referenced by an HC_KEY.
`HC_Show_Bounding_Sphere()`	Returns the sphere used by HOOPS to circumscribe the geometry within a segment.
`HC_Show_Bounding_Sphere_By_Key()`	Similar to Show_Bounding_Sphere(), but operates on an object referenced by an HC_KEY.
`HC_DShow_Bounding_Sphere()`	Similar to Show_Bounding_Sphere(), but operates on double-precision data.
`HC_DShow_Bounding_Sphere_By_Key()`	Similar to Show_Bounding_Sphere_By_Key(), but operates on double-precision data.
`HC_Show_Button()`	Returns the name of the button that initiated the current event.
`HC_Show_Button_Source()`	Returns the keyboard-device segment and the button specification that gave rise to the current button event.
`HC_Show_Callback()`	Returns the name of a procedural link between HOOPS database traversal and immediate mode rendering.
`HC_Show_Callback_Name()`	Shows the definition of a callback name.
`HC_Show_Callback_Name_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.
`HC_Show_Camera()`	Returns the complete specification of the viewing camera’s position, orientation, and field of view.
`HC_Show_Camera_By_Volume()`	Returns the simple rectangular box in user data space as set in a previous call to Set_Camera_By_Volume().
`HC_Show_Camera_Field()`	Returns the viewing camera’s field of view.
`HC_Show_Camera_Position()`	Returns the viewing camera’s position.
`HC_Show_Camera_Projection()`	Returns the viewing camera’s projection.
`HC_Show_Camera_Target()`	Returns the viewing camera’s target.
`HC_Show_Camera_Up_Vector()`	Returns the viewing camera’s up-vector.
`HC_Show_Circle()`	Returns the three points used to define the circle, as referenced by a key.
`HC_Show_Circular_Arc()`	Returns the three points used to define the circular arc, as referenced by a key.
`HC_Show_Circular_Chord()`	Returns the three points used to define the circular chord, as referenced by a key.
`HC_Show_Circular_Wedge()`	Returns the three points used to define the circular wedge, as referenced by a key.
`HC_Show_Color()`	Returns the named color(s) used to render the contents of the currently open segment.
`HC_Show_Color_By_Index()`	Returns the color map indices used to render the contents of the currently open segment.
`HC_Show_Color_By_Value()`	Returns the numerically-defined colors of objects in the currently open segment.
`HC_Show_Color_Map()`	Returns the color map that has been set on the currently open segment by a previous call to Set_Color_Map().
`HC_Show_Color_Map_By_Value()`	Returns the color map that has been set on the currently open segment by a previous call to Set_Color_Map_By_Value().
`HC_Show_Color_Map_Count()`	Shows the number of entries in the current virtual color map.
`HC_Show_Color_Name()`	Shows the definition of a color.
`HC_Show_Color_Name_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.
`HC_Show_Compilation_Results()`	Returns the shader source size and the errors (if any).
`HC_Show_Compilation_Results_Size()`	Returns the shader source size and the errors size (if any).
`HC_Show_Explicit_Color()`	Returns the various components of a color definition.
`HC_PShow_Net_Explicit_Color()`	Similar to Show_Explicit_Color(), but shows the net effective settings along a discrete segment path.
`HC_Show_Contents_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.
`HC_Show_Cutting_Plane()`	Returns the the coefficients used to define the cutting plane, as referenced.
`HC_Show_Cylinder()`	Returns the previous definition of a cylinder, as referenced by a key.
`HC_Show_Circle_By_Radius()`	Returns the center, radius and normal values used to define the circle, as referenced by a key.
`HC_Show_Sphere()`	Returns the parameters of a sphere, as defined in a previous call to Insert_Sphere().
`HC_Show_Device_Info()`	Returns selected information about the physical device.
`HC_Show_Device_Info_By_Key()`	Similar to Show_Device_Info(), but the driver segment is identified by a key instead of by name.
`HC_Show_Distant_Light()`	Returns the direction of a “distant light”, as referenced by a key.
`HC_Show_Driver_Options()`	Returns a list of the driver options that have been set on the currently open segment.
`HC_Show_Edge_Pattern()`	Returns the edge pattern that has been set on the currently open segment.
`HC_Show_Edge_Pattern_Explicit()`	Returns the explicit edge pattern that has been set on the currently open segment.
`HC_Show_Edge_Weight()`	Returns the edge weight that has been set on the currently open segment.
`HC_Show_Ellipse()`	Returns the three points used to define the ellipse, as referenced by a key.
`HC_Show_Elliptical_Arc()`	Returns the three points and two distances used to define the elliptical arc referenced by a key.
`HC_Show_Environment()`	Allows you to retrieve information from the operating system environment of your running program.
`HC_Show_Face_Pattern()`	Returns the face pattern that has been set on the currently open segment.
`HC_Show_Font()`	Describes a specific set of simple geometry to be used as the actual shapes when drawing text characters.
`HC_Show_Font_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.
`HC_Show_Font_Info()`	Returns selected information about the specified font.
`HC_Show_Font_Size()`	Finds the size in bytes of a particular font. This is useful in determining the size of the data structure that must hold data
`HC_Show_Grid()`	Retrieves the original definition of a grid.
`HC_Show_Handedness()`	Returns the type of Cartesian coordinate system that has been set on the currently open segment.
`HC_Show_Heuristics()`	Returns the heuristic settings that have been made on the currently open segment.
`HC_Show_Image()`	Returns the rectangular array of pixel data, as referenced by a key.
`HC_Show_Image_Size()`	Finds the size of a particular image, This is useful in determining the size of the data structure that must hold data
`HC_Show_Snapshot()`	Takes a snapshot of the scene.
`HC_Show_Compressed_Image()`	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.
`HC_Show_Compressed_Image_Size()`	Finds the size of a particular image, This is useful in determining the size of the data structure that must hold data
`HC_Show_Image_Bytes_Per_Pixel()`
`HC_Show_Image_Format()`	Returns the underlying format of the raster data in the provided image.
`HC_Show_Image_Name()`	Returns the name associated with an image key.
`HC_Show_Glyph()`	Returns the definition of a glyph as established by a previous call to Define_Glyph().
`HC_Show_Glyph_Size()`	Finds the size in bytes of a particular glyph. This is useful in determining the size of the structure that must hold data .
`HC_Show_Shader()`	Returns the shader setting for the currently open segment.
`HC_Show_Shape()`
`HC_Show_Shape_Size()`
`HC_Show_Line_Style()`	Returns the line style that has been set on the currently open segment.
`HC_Show_Line_Style_Size()`	Returns the size of the line style that has been set on the currently open segment.
`HC_Show_Line_Pattern()`	Returns the line pattern that has been set on the currently open segment.
`HC_Show_Line_Pattern_Explicit()`	Returns the explicit line pattern that has been set on the currently open segment.
`HC_Show_Key_Status()`	Helps to maintain lists of valid keys.
`HC_Show_Key_Type()`	Returns the type of object referenced by a key.
`HC_Show_LOD_Type()`	Determines whether a given LOD level exists, and if so, its type.
`HC_Show_Line()`	Returns the endpoints of the line, as referenced by a key.
`HC_Show_Infinite_Line()`	Returns the vector of points that define an infinite line, as referenced by a key.
`HC_Show_Infinite_Ray()`	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().
`HC_DShow_Infinite_Line()`	Similar to Show_Infinite_Line(), but operates on double-precision data.
`HC_DShow_Infinite_Ray()`	Similar to Show_Infinite_Ray(), but returns double-precision values.
`HC_Show_Line_Weight()`	Returns the line weight that has been set on the currently open segment.
`HC_Show_Local_Light()`	Returns the position of a “local light”, as referenced by a key.
`HC_Show_Location()`	Returns the raw 2-D position that was indicated by the user.
`HC_Show_Location_Source()`	Returns the locater-device segment and the user action that gave rise to the current location event.
`HC_Show_Marker()`	Returns the position of a marker, as referenced by a key.
`HC_Show_Marker_Size()`	Returns the marker scale that has been set on the currently open segment.
`HC_Show_Marker_Symbol()`	Returns the marker symbol that has been set on the currently open segment.
`HC_Show_Memory_Usage()`	Tells your program how much memory is being used for graphics data storage.
`HC_Show_Memory_Statistics()`	Tells your program how much memory is being used by the input option.
`HC_Show_Mesh()`	Returns the previous definition of a mesh, as referenced by a key.
`HC_Show_Mesh_Size()`	Finds the size of a given mesh. This is usefule in determining the size of the data structure that must hold points
`HC_Show_Modelling_Matrix()`	Returns the modelling matrix that has been set on the currently open segment.
`HC_DShow_Modelling_Matrix()`	Similar to Show_Modelling_Matrix(), but operates on double-precision matrices.
`HC_Show_NURBS_Curve()`	Returns the previous definition of a NURBS curve, as referenced by a key.
`HC_Show_NURBS_Curve_Size()`	Finds the size of a given NURBS curve. This is useful in determining the size of the data structure that must hold points
`HC_Show_Normal()`	Returns the normal for the currently open vertex or face.
`HC_Show_One_Callback()`	Similar to Show_Callback(), but returns the setting of a single callback point in the currently open segment.
`HC_Show_One_Callback_With_Data()`	Retrieves the data pointer that was passed in during a previous call to Set_Callback_With_Data().
`HC_Show_One_Color()`	Returns the color value for one particular type of geometry.
`HC_Show_One_Color_By_Index()`	Similar to Show_One_Color(), but returns the value of a single attribute in the currently open segment.
`HC_Show_One_Color_By_Value()`	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.
`HC_Show_One_Color_Map()`	Shows a single entry in the current virtual color map.
`HC_Show_One_Color_Map_By_Value()`	Similar to Show_One_Color_Map(), but returns the value of a single attribute in the currently open segment.
`HC_Show_One_Driver_Option()`	Similar to Show_Driver_Options() but returns a single option rather than the entire set.
`HC_Show_One_Heuristic()`	Similar to Show_Heuristics() but returns a single setting, rather than the entire set.
`HC_Show_One_Rendering_Option()`	Similar to Show_Rendering_Options() but returns a single setting, rather than the entire set.
`HC_Show_One_Selectability()`	Similar to Show_Selectability() but returns a single setting, rather than the entire set.
`HC_Show_One_System_Option()`	Similar to Show_System_Options(), but returns the value of a single attribute in the currently open segment.
`HC_Show_One_Text_Font()`	Similar to Show_Text_Font() but returns a single setting, rather than the entire set.
`HC_Show_One_User_Index()`	Similar to Show_User_Index() but returns a single setting, rather than the entire set.
`HC_Show_One_User_Option()`	Similar to Show_User_Options() but returns a single setting, rather than the entire set.
`HC_Show_One_Unicode_Option()`	Similar to Show_Unicode_Options(), but returns the value of a single attribute in the currently open segment.
`HC_Show_One_Visibility()`	Similar to Show_Visibility() but returns a single setting, rather than the entire set.
`HC_Show_Open_Segment_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.
`HC_Show_Owner()`	Returns the segment which contains a given segment or which contains an item with a given key.
`HC_Show_Owner_By_Key()`	Similar to Show_Owner(), but operates on an object referenced by an HC_KEY.
`HC_Show_Parameter()`	Returns the parameters that have been set on the currently open vertex.
`HC_Show_Parameter_Size()`	Returns the size of the list array. Always three (3) for now.
`HC_Show_Partial_Image()`	Returns a user-specified rectangular array of pixel data, as referenced by a key.
`HC_Show_Partial_Mesh()`	Returns a portion of the previous definition of a mesh, as referenced by a key.
`HC_Show_Partial_Polygon()`	Returns a portion of the vector of points along the edge of a given polygon, as referenced by a key.
`HC_Show_Partial_Polyline()`	Returns a portion of the vector of points along a given polyline, as referenced by a key.
`HC_Show_Partial_Shell()`	Returns a portion of the previous definition of a shell, as referenced by a key.
`HC_Show_Partial_Shell_Size()`	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().
`HC_DShow_Partial_Mesh()`
`HC_DShow_Partial_Polygon()`
`HC_DShow_Partial_Polyline()`
`HC_DShow_Partial_Shell()`
`HC_Show_Pathname_Expansion()`	Identifies the full absolute pathname corresponding to a relative pathname.
`HC_Show_Polygon()`	Returns the vector of points along the edge of the polygon referenced by a key.
`HC_Show_Polygon_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
`HC_Show_Polyline()`	Returns the vector of points along the polyline, as referenced by a key.
`HC_Show_Polyline_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
`HC_Show_Priority()`	Returns the drawing priority corresponding to the given key.
`HC_Show_Rendering_Options()`	Returns a list of the rendering options that have been set on the currently open segment.
`HC_Show_Segment_Name_Length()`
`HC_Show_Segment_Name()`
`HC_Show_Segment()`	Returns the segment name corresponding to the given key.
`HC_Show_Segment_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.
`HC_Show_Selectability()`	Returns a list of the selectability options that have been set on the currently open segment.
`HC_Show_Selection()`	Returns the name of the segment that was selected by the user.
`HC_Show_Selection_Element()`	Returns the key of the database element that was selected by the user, plus an offset within that element.
`HC_Show_Selection_Source_Elem()`	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.
`HC_DShow_Selection_Source_Elem()`	Similar to Show_Selection_Source_Element(), but operates on double-precision data.
`HC_Show_Selection_Original_Key()`	Returns the original HOOPS key to a renumbered selection object.
`HC_Show_Selection_Elements()`	Returns the key of the database element that was selected by the user, plus arrays of offsets describing the selected item’s sub-elements.
`HC_Show_Selection_Elements_Coun()`	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.
`HC_Show_Selection_Item()`
`HC_Show_Selection_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.
`HC_Show_Selection_Original_Keys()`	Returns an array of original HOOPS keys that delineate the ownership of the selection object.
`HC_Show_Selection_Keys_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
`HC_Show_Selection_Location()`
`HC_Show_Selection_Pathname()`	Returns the fully-qualified name of the segment that was selected by the user.
`HC_Show_Selection_Position()`	Shows the position that has just been used to select something. The position is returned in terms of both window coordinates and world coordinates.
`HC_DShow_Selection_Position()`	Similar to Show_Selection_Position(), but operates on double-precision data.
`HC_Show_Selection_Source()`	Returns the locater-device segment, the picture segment, and the user action that gave rise to the current selection event.
`HC_Show_Shell()`	Returns the previous definition of a shell, as referenced by a key.
`HC_Show_Shell_By_Tristrips()`	Returns the previous definition of a shell, as referenced by a key.
`HC_Show_Shell_By_Tristrips_Size()`	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 .
`HC_Show_Shell_Size()`	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
`HC_Show_Shell_Face_Count()`	Returns the number of faces in the shell in constant time.
`HC_Show_Shell_Tristrip_Count()`	Returns the tristrip count for a shell after it has been prepared for rendering.
`HC_Show_Spot_Light()`	Returns a full description of the “spot light” referenced by a key.
`HC_Show_Streaming_Mode()`	Returns the streaming mode that has been set on the currently open segment.
`HC_Show_String()`	Returns the text string that caused the current string-input event.
`HC_Show_String_Count()`	Finds the number of characters in the string the user has just finished typing in.
`HC_Show_String_Cursor()`	Retrieves the key of the owning text, and position within that text, of a previously defined string cursor.
`HC_Show_String_Length()`	Finds the number of bytes in the string the user has just finished typing in.
`HC_Show_String_Source()`	Returns the keyboard-device segment and cursor that gave rise to the current string event.
`HC_Show_String_With_Encoding()`	Similar to Show_String(), but operates on encoded text rather than Latin1 text.
`HC_Show_Style_Segment()`	Returns the segment that is referenced by a style inclusion.
`HC_Show_System_Info()`	Provides information on the capabilities of the HOOPS library in use.
`HC_Show_System_Options()`	Examines the current list of debugging/control “system options”.
`HC_Show_Text()`	Returns the position, size, and contents of a previously defined text string, as referenced by a key.
`HC_Show_Text_Leader()`
`HC_Show_Text_With_Encoding()`	Similar to Show_Text, but operates on encoded text rather than Latin1 text.
`HC_Show_Text_Alignment()`	Returns the text alignment settings that have been made on the currrently open segment.
`HC_Show_Text_Count()`	Finds the number of characters in a given text string, as reference by a key.
`HC_Show_Text_Encoding()`	Finds the type of encoding with which a particular string was inserted, as referenced by a key.
`HC_Show_Text_Font()`	Returns the font settings that have been made on the currrently open segment.
`HC_Show_Text_Length()`	Finds the number of bytes in a given text string, as referenced by a key.
`HC_Show_Text_Path()`	Returns the text path that has been set on the currrently open segment.
`HC_Show_Text_Size()`
`HC_Show_Text_Spacing()`	Returns the text spacing that has been set on the currrently open segment.
`HC_Show_Texture()`	Shows the definition of a texture.
`HC_Show_Shader_Definition()`	Returns the options and source associated with the shader whose name was passed.
`HC_Show_Shader_Definition_Source_Size()`	Returns the size of the shader source in bytes. Only valid for modern custom shaders.
`HC_Show_Shader_Definition_By_Key()`	Returns the shader stage and its source code. Only valid for modern custom shaders.
`HC_Set_Shader_Inputs()`	Sets the inputs required by the shader at runtime. Only valid for modern custom shaders.
`HC_Show_Shader_Inputs_Size()`	Returns the size of the shader input specification in bytes. Only valid for modern custom shaders.
`HC_Show_Shader_Inputs()`	Returns the shader input specification if present. Only valid for modern custom shaders.
`HC_UnSet_Shader_Inputs()`	Removes the input specification from the shader. Only valid for modern custom shaders.
`HC_Define_Shader_Sampler()`	Defines a texture sampler to be used by a modern custom shader.
`HC_Show_Shader_Sampler_Def_Size()`	Returns the size of the shader sampler definition in bytes.
`HC_Show_Shader_Sampler_Def()`	Returns the shader sampler definition.
`HC_Define_Shader_Texture()`	Defines a texture to be used by a modern custom shader.
`HC_Show_Shader_Texture_Def_Size()`	Returns the size information for the shader texture definition.
`HC_Show_Shader_Texture_Def()`	Returns the data associated with the shader texture definition.
`HC_Set_Shader_Textures()`	Sets the textures and samplers required by the shader at runtime. Only valid for modern custom shaders.
`HC_UnSet_Shader_Textures()`	Removes the textures and samplers from the shader. Only valid for modern custom shaders.
`HC_Show_Shader_Textures_Count()`	Returns the number of textures and samplers associated with the shader. Only valid for modern custom shaders.
`HC_Show_Shader_Textures()`	Returns the textures and samplers associated with the shader if present. Only valid for modern custom shaders.
`HC_Show_Local_Texture()`	Retrieves a texture definition from the currently open segment.
`HC_Show_Texture_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.
`HC_Show_Glyph_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.
`HC_Show_Shape_Count()`
`HC_Show_Line_Style_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.
`HC_Show_Texture_Matrix()`	Returns the transformation that has been set against all vertex parameters in the scope of the currently open segment.
`HC_Show_Time()`	Returns the time elapsed in the current program execution.
`HC_Show_User_Index_Count()`	Returns the size of the indices array.
`HC_Show_User_Indices()`	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().
`HC_Show_User_Options()`	Returns the user options that have been set on the currently open segment.
`HC_Show_Unicode_Options()`	Show the unicode user options string stored on the currently open segment.
`HC_Show_User_Options_Length()`	Determines string length for proper buffer allocation on a call to Show_User_Options.
`HC_Show_Unicode_Options_Length()`	Determines string length for proper buffer allocation on a call to Show_Unicode_Options.
`HC_Show_User_Value()`
`HC_Show_Visibility()`	Returns the visibility settings for the currently open segment.
`HC_Show_Wakeup()`	Returns the time specification of the current wakeup event.
`HC_Show_Window()`	Returns the amount of screen used by the currently open segment upon display.
`HC_Show_Window_With_Options()`
`HC_Show_Window_Frame()`	Returns the window frame visibility setting.
`HC_Show_Window_Pattern()`	Returns the window pattern set on the currently open segment.
`HC_Translate_Object()`	Moves objects about within the user data space.
`HC_DTranslate_Object()`	Similar to Translate_Object(), but operates on double-precision data.
`HC_Translate_Texture()`	Moves texture images about on the surface of texture mapped shells and meshes by transforming their (u, v, w) vertex parameters.
`HC_UnDefine_Alias()`	Removes all settings established by a previous call to Define_Alias().
`HC_UnDefine_Callback_Name()`	Removes all settings established by a previous call to Define_Callback_Name().
`HC_UnDefine_Color_Name()`	Removes all settings established by a previous call to Define_Color_Name().
`HC_UnDefine_Error_Handler()`	Removes all settings established by a previous call to Define_Error_Handler().
`HC_UnDefine_Exit_Handler()`	Removes all settings established by a previous call to Define_Exit_Handler().
`HC_UnDefine_Font()`	Removes all settings established by a previous call to Define_Font().
`HC_UnDefine_Glyph()`	Removes the glyph definintion established in a previous call to Define_Glyph().
`HC_UnDefine_Line_Style()`	Removes a custom line style established by a previous call to Define_Line_Style().
`HC_UnDefine_Shape()`	Deletes the shape definition, frees any memory allocated to the shape object, and triggers a redraw on any dependent scene elements.
`HC_UnDefine_Texture()`	Removes all settings established by a previous call to Define_Texture().
`HC_UnDefine_Local_Texture()`	Remove a texture definition on the currently open segment.
`HC_UnDefine_Shader()`	Removes the shader code associated with the passed name.
`HC_UnSet_Bounding_Volume()`	Forces HOOPS to recalculate the bounding volume used by HOOPS to circumscribe the geometry within a segment.
`HC_UnSet_Callback()`	Removes all settings established by a previous call to Set_Callback().
`HC_UnSet_Camera()`	Removes all settings established by a previous call to Set_Camera().
`HC_UnSet_Color()`	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.
`HC_UnSet_Color_Map()`	Removes all settings established by a previous call to Set_Color_Map().
`HC_UnSet_Driver_Options()`	Removes all settings established by a previous call to Set_Driver_Options().
`HC_UnSet_Edge_Pattern()`	Removes all settings established by a previous call to Set_Edge_Pattern().
`HC_UnSet_Edge_Weight()`	Removes all settings established by a previous call to Set_Edge_Weight().
`HC_UnSet_Face_Pattern()`	Removes all settings established by a previous call to Set_Face_Pattern().
`HC_UnSet_Handedness()`	Removes all settings established by a previous call to Set_Handedness().
`HC_UnSet_Heuristics()`	Removes all settings established by a previous call to Set_Heuristics().
`HC_UnSet_Line_Pattern()`	Removes all settings established by a previous call to Set_Line_Pattern().
`HC_UnSet_Line_Weight()`	Removes all settings established by a previous call to Set_Line_Weight().
`HC_UnSet_Marker_Size()`	Removes all settings established by a previous call to Set_Marker_Size().
`HC_UnSet_Marker_Symbol()`	Removes all settings established by a previous call to Set_Marker_Symbol().
`HC_UnSet_Modelling_Matrix()`	Removes all settings established by a previous call to Set_Modelling_Matrix().
`HC_UnSet_Normal()`	Removes all settings established by a previous call to Set_Normal().
`HC_UnSet_One_Callback()`	Removes a given callback setting established by a previous call to Set_Callback(), rather than all settings.
`HC_UnSet_One_Color()`	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.
`HC_UnSet_One_Driver_Option()`	Removes a given setting established by a previous call to Set_Driver_Options(), rather than all settings.
`HC_UnSet_One_Heuristic()`	Removes a given setting established by a previous call to Set_Heuristics(), rather than all settings.
`HC_UnSet_One_Rendering_Option()`	Removes a given setting established by a previous call to Set_Rendering_Options(), rather than all settings.
`HC_UnSet_One_Selectability()`	Removes a given setting established by a previous call to Set_Selectability(), rather than all settings.
`HC_UnSet_One_Text_Font()`	Removes a given setting established by a previous call to Set_Text_Font(), rather than all settings.
`HC_UnSet_One_User_Index()`	Removes a given setting established by a previous call to Set_User_Options(), rather than all settings.
`HC_UnSet_One_User_Option()`	Removes a given setting established by a previous call to Set_User_Options(), rather than all settings.
`HC_UnSet_One_Unicode_Option()`	Removes a given setting established by a previous call to Set_Unicode_Options(), rather than all settings.
`HC_UnSet_One_Visibility()`	Removes a given setting established by a previous call to Set_Visibility(), rather than all settings.
`HC_UnSet_Parameter()`	Removes all settings established by a previous call to Set_Parameter().
`HC_UnSet_Rendering_Options()`	Removes all settings established by a previous call to Set_Rendering_Options().
`HC_UnSet_Selectability()`	Removes all settings established by a previous call to Set_Selectability().
`HC_UnSet_Shader()`	Removes the settings established by a previous call to Set_Shader() for the provided graphic primitive.
`HC_UnSet_Streaming_Mode()`	Removes all settings established by a previous call to Set_Streaming_Mode().
`HC_UnSet_Text_Alignment()`	Removes all settings established by a previous call to Set_Text_Alignment().
`HC_UnSet_Text_Font()`	Removes all settings established by a previous call to Set_Text_Font().
`HC_UnSet_Text_Path()`	Removes all settings established by a previous call to Set_Text_Path().
`HC_UnSet_Text_Spacing()`	Removes all settings established by a previous call to Set_Text_Spacing().
`HC_UnSet_Texture_Matrix()`	Removes all settings established by a previous call to Set_Texture_Matrix().
`HC_UnSet_User_Options()`	Removes all settings established by a previous call to Set_User_Options().
`HC_UnSet_Unicode_Options()`	Removes all settings established by a previous call to Set_Unicode_Options().
`HC_UnSet_User_Indices()`
`HC_UnSet_User_Data()`
`HC_UnSet_User_Value()`
`HC_UnSet_Visibility()`	Removes all settings established by a previous call to Set_Visibility().
`HC_UnSet_Window()`	Removes all settings established by a previous call to Set_Window().
`HC_UnSet_Window_Frame()`	Removes all settings established by a previous call to Set_Window_Frame().
`HC_UnSet_Window_Pattern()`	Removes all settings established by a previous call to Set_Window_Pattern().
`HC_Update_Display()`	Makes sure that external appearances are up-to-date with respect to the internal definitions.
`HC_Update_Display_Timed()`	Executes Update_Display and returns true if completed within a given interval.
`HC_Update_One_Display()`	Executes Update_Display on a single driver instance.
`HC_Update_One_Display_Timed()`	Limit the amount of time allowed for an update.
`HC_Write_Metafile()`	Writes the information in a segment out into a disk file.
`HC_Zoom_Camera()`	Narrows or enlarges the viewing field of the camera.
`HC_Show_Geometry_Pointer()`	Retrieves a pointer to the internal data structure of the object identified by key .
`HC_Show_Geometry_Options()`	Shows options that have been attached to geometry by Set_Geometry_Options.
`HC_Set_Geometry_Options()`	Allows users to make geometry-specific settings on a variety of 3dGS geometric primitives.
`HC_Insert_NURBS_Surface()`	Generates a Non-Uniform Rational B-Spline (NURBS) surface.
`HC_Show_NURBS_Surface_Size()`	Returns the definition of an existing NURBS surface, as referenced by a key.
`HC_Show_NURBS_Surface()`
`HC_Trim_NURBS_Surface_By_Poly()`	Inserts a polyline into the trim list and applies the trim to a surface.
`HC_Trim_NURBS_Surface_By_Curve()`	Inserts a NURBS curve into the trim list and applies the trim to a surface.
`HC_Edit_NURBS_Surface()`	Edits the properties of an existing NURBS surface.
`HC_Edit_NURBS_Surface_Points()`	Edits only the control points in a NURBS surface.
`HC_Edit_NURBS_Surface_Weights()`	Edits only the weights in a NURBS surface.
`HC_Edit_NURBS_Surface_Knots()`	Edits only the knots of in a NURBS surface.
`HC_Show_Trim_Count()`	Returns the number of objects in the trim list of the currently open NURBS surface or trim collection.
`HC_Show_Trim_Type()`	Returns the type of an object on the trim list of the currently open NURBS surface or trim collection.
`HC_Show_Trim_Poly()`	Returns the definition of an existing trimming polyline.
`HC_Show_Trim_Poly_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
`HC_Show_Trim_Curve()`	Returns the definition of an existing NURBS curve trim object.
`HC_Show_Trim_Curve_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
`HC_Delete_Trim()`	Deletes a trim object from the trim list.
`HC_Open_Trim()`	Readies an item on the trim list for editing or querying.
`HC_Close_Trim()`	Closes the session that began with an opening call to Open_Trim().
`HC_Set_Trim_Operation()`	Sets the trim operation associated with a particular object in the trim list.
`HC_Show_Trim_Operation()`	Shows the type of trimming currently associated with an object in the trim list.
`HC_Create_Trim_Collection()`	Creates a trim collection object without opening it or otherwise defining it.
`HC_Set_Variable_Line_Weight()`	Defines weights for lines that scale in a similar manner to other geometric primitives.
`HC_Set_Variable_Edge_Weight()`	Defines weights for edges that scale in a similar manner to other geometric primitives.
`HC_Set_Variable_Marker_Size()`	Defines marker sizes that scale in a similar manner to other geometric primitives.
`HC_Show_Variable_Edge_Weight()`	Show the current variable edge weight setting.
`HC_Show_Variable_Line_Weight()`	Show the current variable line weight setting.
`HC_Show_Variable_Marker_Size()`	Show the current variable marker size setting.
`HC_PShow_Net_Var_Edge_Weight()`	Similar to Show_Variable_Edge_Weight(), but returns the net effective setting along a discrete segment path.
`HC_PShow_Net_Var_Line_Weight()`	Similar to Show_Variable_Line_Weight(), but returns the net effective setting along a discrete segment path.
`HC_PShow_Net_Var_Marker_Size()`	Similar to Show_Variable_Marker_Size(), but returns the net effective setting along a discrete segment path.
`HC_MShow_Character_Attributes()`	Returns attributes from a given text string on a per-character basis.
`HC_Show_Character_Attribute_Cou()`	Returns the number of characters in a given text string that have per-character attributes.
`HC_Show_One_Character_Attribute()`	Returns one per-character attribute setting from a given text string.
`HC_Set_Faces()`	Adds a specified range of shell faces to an open region.
`HC_Set_Region()`	Adds an open face to the specified region.
`HC_MSet_Region_Faces()`	Adds a specified range of shell faces to the specified region without requiring open geometry or regions.
`HC_MSet_Face_Regions()`	Maps a specified range of faces to a given set of regions.
`HC_Show_Faces()`	Show faces associated with the currently open region.
`HC_Show_Faces_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
`HC_Show_Region()`	Show the region associated with the currently open face.
`HC_MShow_Region_Faces()`
`HC_MShow_Region_Faces_Count()`
`HC_MShow_Face_Regions()`	Show the regions defined for a given shell without requiring open geometry.
`HC_MShow_Face_Regions_Count()`	Finds the number of face regions in a shell. This is useful for determining the size of the data structure needed for regions .
`HC_MShow_Partial_Face_Regions()`
`HC_Show_Region_Range()`	Return the range of region numbers associated with a given shell.
`HC_Insert_PolyCylinder()`	Create a polycylinder from a 3D array of points and an array of radii.
`HC_Show_PolyCylinder()`	Returns the previous definition of a polycylinder, as referenced by a key.
`HC_Show_PolyCylinder_Counts()`	Finds the number of items in a given polycylinder. This is useful in determining the size of the data structure that holds pts
`HC_Insert_Shell_From_Region()`	Creates a new shell containing the points and faces (and any associated attributes) in an existing shell region.
`HC_Insert_Unicode_Text()`	Insert encoded text as an array of short integers.
`HC_Show_Unicode_Text()`	Returns the position, size, and contents of a previously-defined unicode text string, as referenced by a key.
`HC_Compute_Selection_By_Shell()`	Forces a selection event between the supplied shell and a specified portion of a segment tree.
`HC_DCompute_Selection_By_Shell()`	Similar to Compute_Selection_By_Shell(), but operates on double-precision data.
`HC_Compute_Selection_By_Sh_W_Op()`	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.
`HC_DCompute_Selection_By_Sh_W_O()`	Similar to Compute_Selection_By_Shell_With_Options(), but operates on double-precision data.
`HC_Compute_Selection_By_Swept_S()`	Forces a selection event between the volume created by a shell moving along a path and a specified portion of a segment tree.
`HC_DCompute_Selection_By_Swpt_S()`	Similar to Compute_Selection_By_Swept_Shell(), but operates on double-precision data.
`HC_Compute_Selection_By_Swept_2()`	Similar to Compute_Selection_By_Swept_Shell(), but takes an extra parameter which receives a bounding box of the collision volume.
`HC_DCompute_Selection_By_Swpt_2()`	Similar to Compute_Selection_By_Swept_Shell2(), but operates on double-precision data.
`HC_Compute_Selection_By_Key()`	Forces a selection event between a supplied shell, as referenced by a key, and a specified portion of a segment tree.
`HC_DCompute_Selection_By_Key()`
`HC_Compute_Swept_Shell()`	Sweeps an existing shell along a defined path to create new shells that containes the swept volume.
`HC_DCompute_Swept_Shell()`	Similar to Compute_Swept_Shell(), but operates on double-precision data.
`HC_Compute_Swept_Shell_Along_P()`	Creates a new set of shells by sweeping a shell along a path.
`HC_DCompute_Swept_Shell_Along_P()`	Similar to Compute_Swept_Shell_Along_Path(), but operates on double-precision data.
`HC_Compute_Selection_Dist_By_Sh()`	Computes the closest distance between the specified shell and another geometric primitive within a HOOPS segment tree.
`HC_DCompute_Selection_Dist_By_S()`	Similar to Compute_Selection_Distance_By_Shell(), but operates on double-precision data.
`HC_Begin_Shell_Selection()`	Begins a mode of operation whereby calls to Compute_Selection_By_Shell cache intermediate data in order to speed up successive computations.
`HC_End_Shell_Selection()`	Terminates the shell selection sequence and frees any involved memory..
`HC_Compute_Intersect_Polyline()`	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 .
`HC_Show_Intersect_Polyline_Size()`	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().
`HC_DCompute_Intersect_Polyline()`	Similar to Compute_Intersect_Polyline(), but operates on double-precision data.
`HC_DShow_Intersect_Polyline_Size()`
`HC_Compute_Point_Inside_Shell()`	Tests whether a given point is inside a shell, which is assumed to be a closed surface.
`HC_DCompute_Point_Inside_Shell()`	Similar to Compute_Point_Inside_Shell, but operates on double-precision data.
`HC_Compute_Point_On_Shell()`	Tests whether a given point is on the surface of a shell.
`HC_DCompute_Point_On_Shell()`	Similar to Compute_Point_On_Shell, but operates on double-precision data.
`HC_Compute_Points_Inside_Shell()`	Tests whether a given set of points reside within, on, or outside the volume defined by a shell.
`HC_DCompute_Points_Inside_Shell()`
`HC_Compute_Points_On_Shell()`	Tests, within a certain tolerance, whether a given set of points reside on the surface of a shell.
`HC_DCompute_Points_On_Shell()`	Similar to Compute_Points_On_Shell, but operates on double-precision data.
`HC_Compute_Points_Distance_F_Sh()`	Calculates the closest distance between a given set of points and a shell.
`HC_DCompute_Points_Distance_F_S()`	Similar to Compute_Points_Distance_From_Shell, but operates on double-precision data.
`HC_Compute_Points_Distance_F_S2()`
`HC_DCompute_Points_Distance_FS2()`
`HC_Compute_Shell_Enclosure()`	Classifies the relationship between the first shell and the second: “in”, “out”, and “clash”.
`HC_DCompute_Shell_Enclosure()`
`HC_Compute_Selection_By_Ray()`	Forces a selection event between a supplied ray and all polyhedron-based objects within a specified portion of a segment tree.
`HC_DCompute_Selection_By_Ray()`	Similar to Compute_Selection_By_Ray(), but operates on double-precision data.
`HC_Filter_Circumcuboid()`	Determines the bounding cuboid for a particular segment, based on visibility settings in the segment tree.
`HC_Filter_Circumcuboid_By_Key()`	Similar to Filter_Circumcuboid(), but operates on an object referenced by an HC_KEY.
`HC_Filter_Circumcuboid_By_Path()`	Similar to Filter_Circumcuboid(), but operates on a keypath instead of a single segment.
`HC_Filter_Circumsphere()`	Determines the bounding sphere for a particular segment, based on visibility settings in the tree.
`HC_Filter_Circumsphere_By_Key()`	Similar to Filter_Circumsphere(), but operates on an object referenced by an HC_KEY.
`HC_Filter_Circumsphere_By_Path()`	Similar to Filter_Circumsphere(), but operates on a keypath instead of a single segment.
`HC_DFilter_Circumcuboid()`	Similar to Filter_Circumcuboid(), but operates on double-precision data.
`HC_DFilter_Circumcuboid_By_Key()`	Similar to Filter_Circumcuboid(), but operates on an object referenced by an HC_KEY.
`HC_DFilter_Circumcuboid_By_Path()`	Similar to Filter_Circumcuboid_By_Path(), but operates on double-precision data.
`HC_DFilter_Circumsphere()`	Similar to Filter_Circumsphere(), but operates on double-precision data.
`HC_DFilter_Circumsphere_By_Key()`	Similar to Filter_Circumsphere_By_Key(), but operates on double-precision data.
`HC_DFilter_Circumsphere_By_Path()`	Similar to Filter_Circumsphere_By_Path(), but operates on double-precision data.
`HC_Set_Polygonal_Clip_Region()`	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.
`HC_DSet_Polygonal_Clip_Region()`	Similar to Set_Polygonal_Clip_Region(), but operates on double-precision data.
`HC_Set_Complex_Clip_Region()`	Defines a complex clip region in the segment tree.
`HC_DSet_Complex_Clip_Region()`	Similar to Set_Complex_Clip_Region(), but takes double-precision precision points.
`HC_Show_Clip_Region()`	Show the clip region settings on the currently open segment.
`HC_DShow_Clip_Region()`	Similar to Show_Clip_Region(), but returns double-precision data.
`HC_Show_Clip_Region_Size()`	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 .
`HC_DShow_Clip_Region_Size()`
`HC_PShow_Net_Clip_Region()`	Returns all the clip regions found on the key path passed to the function.
`HC_PShow_Net_Clip_Region_Size()`	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.
`HC_DPShow_Net_Clip_Region()`	Like PShow_Net_Clip_Region, but operates on double-precision data.
`HC_DPShow_Net_Clip_Region_Size()`	Similar to PShow_Clip_Region_Size(), but operates on double-precision data.
`HC_UnSet_Clip_Region()`	Removes all clip regions set by a previous call to Set_Polygonal_Clip_Region()
`HC_Regenerate_LOD()`	Throws away any existing LODs in the provided segment tree and regenerates them according to the supplied options.
`HC_Regenerate_LOD_By_Key()`	Similar to Regenerate_LOD(), but operates on an object referenced by an HC_KEY.
`HC_Set_Text_Region()`	Allows the user to define a region into which the currently open text string will be fitted.
`HC_Show_Text_Region()`	Show the text region settings on the currently open text string.
`HC_DSet_Text_Region()`	Similar to Set_Text_Region, but operates on double-precision data.
`HC_DShow_Text_Region()`
`HC_Show_Text_Region_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
`HC_UnSet_Text_Region()`	Removes all settings established by a previous call to Set_Text_Region().
`HC_Compute_Screen_Extent()`	Calculates a screen-space box that fully encloses the segment referred to by the supplied segment path.
`HC_Compute_Screen_Extent_By_Pat()`	Similar to Compute_Screen_Extent(), but concatenates the matrices along a segment path rather than the currently open segment.
`HC_Compute_Screen_Extent_By_Key()`	Similar to Compute_Screen_Extent(), but operates on an object referenced by an HC_KEY.
`HC_Set_Camera_Near_Limit()`	Controls the near camera plane setting.
`HC_Show_Camera_Near_Limit()`	Returns information about the camera near limit.
`HC_PShow_Net_Camera_Near_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.
`HC_UnSet_Camera_Near_Limit()`	Removes the hither camera plane value set by a previous call to Set_Camera_Limit().
`HC_PShow_One_Net_User_Opt_Len()`	Similar to Show_One_User_Option() but returns the net settings along a discrete path.
`HC_Show_One_User_Option_Length()`	Similar to Show_User_Options_Length(), but returns the value of a single attribute in the currently open segment.
`HC_PShow_One_Net_Uni_Opt_Len()`	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.
`HC_Show_One_Uni_Option_Length()`	Similar to PShow_Net_Unicode_Opt_Length(), but returns the value of a single attribute in the currently open segment.
`HC_Show_Original_Key()`	Returns the original (non-renumbered) version of a key.
`HC_Show_Renumbered_Key()`	Returns the key value of an object after it was renumbered.
`HC_Compute_Vector_Angle()`
`HC_DCompute_Vector_Angle()`	Similar to Compute_Vector_Angle(), but operates on double-precision data.
`HC_Set_Conditions()`	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.
`HC_UnSet_Conditions()`	Removes all the conditions established by a previous call to Set_Conditions().
`HC_UnSet_One_Condition()`	Removes a given condition established by a previous call to Set_Conditions().
`HC_Set_Conditional_Action()`	Allows the user to associated specific action(s) with a set of conditions.
`HC_Show_Cond_Action_Types()`	Shows all actions set in the current segment.
`HC_Show_One_Conditional_Action()`	Shows the options and conditions for the specified action.
`HC_UnSet_Conditional_Actions()`	Removes all the actions in the current segment.
`HC_UnSet_One_Conditional_Action()`	Removes a given action established by a previous call to Set_Conditional_Actions().
`HC_Conditional_Style()`	Similar to Style_Segment(), but uses a list of conditions that must be satisfied in order for the inclusion to apply.
`HC_Conditional_Style_By_Key()`	Similar to Conditional_Style(), but accepts a key rather than a pathname to identify the segment to be styled.
`HC_Evaluate_Condition()`
`HC_Conditional_Include()`
`HC_Conditional_Include_By_Key()`	Similar to Conditional_Include(), but accepts a key rather than a pathname to identify the segment to be included.
`HC_Show_Conditions()`	Returns the conditions that have been set on the currently open segment during a previous call to Set_Conditions().
`HC_PShow_Net_Conditions()`	Similar to Show_Conditions() but returns the net effective settings along a discrete segment path.
`HC_Show_Conditions_Length()`	Determines string length for proper buffer allocation on a call to Show_Conditions().
`HC_PShow_Net_Conditions_Length()`	Similar to Show_Conditions_Length() but shows the net effective length along a discrete segment path.
`HC_Show_One_Condition()`	Similar to Show_Conditions() but returns the value of a single option rather than the entire list.
`HC_PShow_One_Net_Condition()`	Similar to Show_One_Condition() but returns the net effective value along a discrete segment path.
`HC_Show_Conditional_Include()`	Returns the pathname and valid conditions that have been established by a previous call to Conditional_Include().
`HC_Show_Conditional_Style()`	Returns the pathname and valid conditions that have been established by a previous call to Conditional_Style().
`HC_Copy_Segment_With_Mapping()`	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.
`HC_Reverse_Contents_Search()`
`HC_MShow_Vertex_Colors_By_Value()`
`HC_MShow_Vertex_Colors_By_FInd()`
`HC_MShow_Face_Colors_By_Value()`	Returns face color settings from a contiguous range of faces without having to open geometry.
`HC_MShow_Face_Colors_By_FIndex()`	Returns face color settings from a contiguous range of faces without having to open geometry.
`HC_MShow_Vertex_Normals()`
`HC_MShow_Vertex_Parameters()`
`HC_MShow_Vertex_Parameter_Size()`
`HC_Set_Circular_Center()`	Allows the user to override the calculated center point for circle-based geometries such as circles, circular wedges, arcs, and chords.
`HC_Set_Circular_Center_By_Key()`	Similar to Set_Circular_Center(), but operates on a piece of geometry identified by a key.
`HC_DSet_Circular_Center()`	Similar to Set_Circular_Center(), but operates on double-precision circular geometry.
`HC_DSet_Circular_Center_By_Key()`	Similar to Set_Circular_Center_By_Key(), but operates on double-precision circular geometry.
`HC_Show_Circular_Center()`	Returns the center point of a given circle-based primitive.
`HC_DShow_Circular_Center()`	Similar to Show_Circular_Center(), but operates on double-precision data.
`HC_MShow_Net_Vertex_Normals()`
`HC_Show_Error()`	Shows whether a severe error was generated during the previous HOOPS call and returns the error components if true.
`HC_MSet_Vertex_Visibilities()`	Sets per-vertex visibility settings of a range of vertices at once. This overrides the visibility settings inherited from the segment-level.
`HC_MUnSet_Vertex_Visibilities()`	Removes per-vertex visibility settings of a range of vertices at once. This allows the shell or mesh to inherit segment-level visibility settings.
`HC_MShow_Vertex_Visibilities()`
`HC_MSet_Face_Visibilities()`	Sets the visibility of a range of faces at once.
`HC_MUnSet_Face_Visibilities()`	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.
`HC_MShow_Face_Visibilities()`
`HC_MSet_Specific_Vertex_Vis()`	Sets per-vertex visibility settings on several individual vertices at once. This overrides the visibility settings inherited from the segment-level.
`HC_MUnSet_Specific_Vertex_Vis()`	Removes per-vertex visibility settings on several individual vertices at once. This allows the shell or mesh to inherit segment-level visibility settings.
`HC_MShow_Specific_Vertex_Vis()`
`HC_MSet_Specific_Face_Vis()`	Sets the visibility of a list of specific of faces at once.
`HC_MUnSet_Specific_Face_Vis()`	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.
`HC_MShow_Specific_Face_Vis()`	Similar to MShow_Specific_Face_Visibilities() which shows the visibility settings for a precise list of faces.
`HC_MUnSet_Face_Colors()`	Removes color settings from a contiguous range of faces.
`HC_MUnSet_Vertex_Colors()`	Removes vertex-specific color settings from a range of vertices with adjacent offsets.
`HC_Insert_Cutting_Section()`	Creates a special piece of geometry which “cuts away” a portion of the scene.
`HC_DInsert_Cutting_Section()`	Similar to Insert_Cutting_Section(), but operates on double-precision data.
`HC_Show_Cutting_Section()`	Returns the array of coefficients used to define a cutting section.
`HC_Show_Cutting_Section_Count()`	Returns the number of plane-defining quadruplets in planes .
`HC_DShow_Cutting_Section()`	Similar to Show_Cutting_Section(), but operates on double-precision cutting sections.
`HC_Edit_Cutting_Section()`	Modifies a cutting section as it exists in the database.
`HC_DEdit_Cutting_Section()`	Similar to Edit_Cutting_Section(), but operates on double-precision data.
`HC_Compute_Triangulation()`	Provides a triangle based tesselation of a HOOPS Shell which can contain facets which have more than 3 edges.
`HC_Compute_Triangulation_Size()`	Similar to Compute_Triangulation(), but returns triangle list size for use in allocating space for triangle_list .
`HC_Compute_Polyline_From_Curve()`	Calculates and returns a tesselated version of a specified curve.
`HC_DCompute_Polyline_From_Curve()`	Similar to Compute_Polyline_From_Curve(), but operates on double-precision data.
`HC_Compute_Pline_From_Crv_Size()`	Calculates and returns a the size of the tesselated curve, for use in a later call to Compute_Polyline_From_Curve.
`HC_DCompute_Pline_From_Crv_Size()`	Similar to Compute_Polyline_From_Curve, but operates on double-precision data.
`HC_Optimize_Segment_Tree()`	Traverses the specified segment tree and makes modifications within it to try to improve rendering performance.
`HC_Optimize_Segment_Tree_By_Key()`	Similar to Optimize_Segment_Tree(), but operates on a segme.
`HC_Show_Optimized_Mapping()`	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().
`HC_PShow_Net_Texture()`	Returns the net effective texture definition and image instead of the local one.
`HC_PShow_One_Net_Texture()`	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..
`HC_PShow_Net_Shader()`	Similar to Show_Shader_Definition(), but returns the net effective value along a discrete segment path.
`HC_PShow_Net_Shaders()`	Similar to Show_Shader(), but returns the net effective value along a discrete segment path.
`HC_PShow_One_Net_Shader_Option()`	Returns the value of the requested option set for a specific shader.
`HC_Show_Priority_Range()`	Returns the lowest and highest priority subsegments within a segment identified by key .
`HC_Delete_Specific_Shell_Points()`	Removes a specified set of points from the pointlist of a particular shell.
`HC_Delete_Specific_Shell_Faces()`	Removes a particular face from the facelist of a particular shell.
`HC_MSet_Spec_Vert_Col_By_FIndex()`	Sets the color on an arbitrary set of shell, mesh, or polycylinder vertices.
`HC_MSet_Spec_Vert_Col_By_Value()`	Sets the color on an arbitrary set of shell, mesh, or polycylinder vertices.
`HC_MSet_Spec_Face_Col_By_FIndex()`	Sets the drawing attributes on an arbitrary set of shell or mesh faces speedily.
`HC_MSet_Spec_Face_Col_By_Value()`	Sets the drawing attributes on an arbitrary set of shell or mesh faces speedily.
`HC_MShow_Spec_Vert_Col_By_FInd()`
`HC_MShow_Spec_Vert_Col_By_Value()`
`HC_MShow_Spec_Face_Col_By_FInd()`	Returns face color settings from an arbitrary set of faces without having to open geometry.
`HC_MShow_Spec_Face_Col_By_Value()`	Returns face color settings from an arbitrary set of faces without having to open geometry.
`HC_MUnSet_Spec_Vertex_Colors()`	Removes vertex-specific color settings from a set of vertices with arbitrary offsets.
`HC_MUnSet_Spec_Face_Colors()`	Removes vertex-specific color settings from an arbitrary set of faces.
`HC_Gather_Capping_Geometry()`	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.
`HC_Generate_Shell_From_Geometry()`
`HC_Generate_Edges()`	Generates a set of shell/mesh edges and inserts them into the HOOPS segment tree.
`HC_Generate_Poly_From_Geometry()`	Generates a polyline based on a specified curve.
`HC_Compute_Face_Neighborhood_Si()`	Returns the number of faces within a shell that share an edge with the specified face.
`HC_Compute_Face_Neighborhood()`	Returns the indices of the faces within a shell that share an edge with the specified face.
`HC_Show_Net_Normal()`	Similar to Show_Normal(), but returns the net effective normal rather than the local one.
`HC_Rollback_Ink()`	Removes vertices added to a polyline via Insert_Ink().
`HC_Reference_Geometry()`	Directs HOOPS to create a reference to some geometry when processing a segment.
`HC_Reference_Geometry_By_Key()`	Similar to Reference_Geometry(), but references a particular item, rather than a segment and all of its contents.
`HC_Conditional_Reference()`	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().
`HC_Conditional_Reference_By_Key()`	Similar to Conditional_Reference(), but references a particular item, rather than a segment and all of its contents.
`HC_Show_Reference_Geometry()`	Returns the identifier of the original geometry or segment referenced by a particular reference key.
`HC_Show_Conditional_Reference()`	Returns the identifier of the original geometry or segment, and the conditions for the reference, for a particular reference key.
`HC_Show_Reference_Geometry_Filt()`
`HC_Begin_Open_Item_Search()`	Returns the keys to all currently open segments or geometric primitives.
`HC_Find_Open_Item()`	Retrieves the open items in a segment tree, one at a time. The function returns false when all items have been returned.
`HC_Show_Open_Item_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.
`HC_End_Open_Item_Search()`	Terminates the open item search sequence, and frees any involved memory.
`HC_PShow_Net_Color_Map_Length()`	Similar to Show_Color_Map(), but returns the net effective setting along a discrete segment path.
`HC_Show_Color_Map_Length()`	Returns the size of the color map that has been set on the currently open segment.
`HC_Move_Key_By_Key()`	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.
`HC_Set_User_Data()`	This function allows the user to associate binary data with a segment or piece of geometry in the database.
`HC_Show_One_User_Data()`	Returns the user data that has been set on the currently open segment and associated with a specific unique index.
`HC_Show_User_Data_Indices()`	Returns the list of user data indices associated with the current segment.
`HC_UnSet_One_User_Data()`	This function unsets binary user data associated with a segment or piece of geometry in the database.
`HC_PShow_One_Net_User_Data()`	Similar to Show_One_User_Data() but returns the net effective settings along a discrete segment path.
`HC_MShow_Vertex_Colors_With_Ex()`
`HC_MUnSet_Vertex_Normals()`	Speedily unsets the normal values a range of faces on a large number of shell, mesh, or polycylinder vertices.
`HC_MUnSet_Face_Normals()`	Removes the normal values for a range of faces at once. This allows the shell or mesh to inherit segment-level normal value settings.
`HC_MUnSet_Vertex_Parameters()`	Unsets the drawing attributes on a large number of shell, mesh, or polycylinder vertices.
`HC_MSet_Specific_Vertex_Normals()`	Speedily sets the normal values a set of faces on a large number of shell, mesh, or polycylinder vertices.
`HC_MUnSet_Specific_Vert_Normals()`	Speedily unsets the normal values a set of faces on a large number of shell, mesh, or polycylinder vertices.
`HC_MShow_Specific_Vert_Normals()`
`HC_MSet_Specific_Face_Normals()`	Speedily sets the normal values for a specific faces on a shell or mesh faces.
`HC_MUnSet_Specific_Face_Normals()`	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.
`HC_MShow_Specific_Face_Normals()`	Shows the normal values for a list of faces.
`HC_MSet_Spec_Vertex_Parameters()`	Sets the parameter values for a specific set of vertices on shell, mesh, or polycylinder.
`HC_MShow_Spec_Vertex_Parameters()`
`HC_MUnSet_Spec_Vert_Parameters()`	Unsets the parameter values for a specific set of vertices on shell, mesh, or polycylinder.
`HC_MUnSet_Vertex_Colors2()`	Removes vertex-specific color settings from a range of vertices with adjacent offsets based on type .
`HC_MUnSet_Spec_Vertex_Colors2()`	Removes vertex-specific color settings from a set of vertices with arbitrary offsets based on type .
`HC_MShow_Spec_Vert_Colors_W_Ex()`
`HC_MShow_Face_Colors_With_Ex()`	Returns face color settings from a range of faces without having to open each face.
`HC_MShow_Spec_Face_Colors_W_Ex()`	Returns face color settings from an arbitrary set of faces without having to open each face.
`HC_MShow_Vertex_Parameters_W_Ex()`
`HC_MShow_Spec_Vertex_Params_W_E()`
`HC_MShow_Vertex_Vis_W_Ex()`
`HC_MShow_Spec_Vertex_Vis_W_Ex()`
`HC_MShow_Face_Vis_W_Ex()`	Shows the visibility settings for a range of faces.
`HC_MShow_Spec_Face_Vis_W_Ex()`	Returns the visibility settings from an arbitrary set of faces without having to open each face.
`HC_MShow_Vertex_Normals_W_Ex()`
`HC_MShow_Spec_Vert_Normals_W_Ex()`
`HC_MShow_Face_Normals_W_Ex()`	Returns the normal settings for a range of faces without having to open each face.
`HC_MShow_Spec_Face_Normals_W_Ex()`	Returns the normal settings from an arbitrary set of faces without having to open each face.
`HC_Include_Segment_Key_By_Key()`	Similar to Include_Segment_By_Key(), but inserts the include into a the segment associated with the passed key.
`HC_Conditional_Include_Key_By_Ke()`	Similar to Conditional_Include_By_Key(), but inserts the include into the segment associated with the passed key.
`HC_Define_Named_Style()`	Defines a name that can be used to draw other segments in the style of the source.
`HC_Define_Named_Style_By_Key()`
`HC_UnDefine_Named_Style()`	Removes a named style definintion established by a previous call to Define_Named_Style.
`HC_Show_Named_Style()`	Returns the segment path of a named style established by a previous call to Define_Named_Style().
`HC_Begin_Named_Style_Search()`	Used to locate all named styles previously defined by Define_Named_Style().
`HC_Find_Named_Style()`	Retrieves the style names, one at a time. The function returns false when all objects have been returned.
`HC_Show_Named_Style_Count()`	Returns the number of named styles established by previous calls to Define_Named_Style().
`HC_End_Named_Style_Search()`	Terminates a named style search sequence and frees any involved memory.
`HC_PShow_Net_Named_Style()`	Similar to Show_Named_Style(), but returns the net effective value along a discrete segment path.
`HC_Named_Style_Segment()`	Requests that the current segment be drawn in the style of the segment associated with the given name.
`HC_Conditional_Named_Style()`
`HC_Show_Named_Style_Segment()`	Returns the name of a named style previously defined by Define_Named_Style().
`HC_Open_Segment_Key_By_Key()`	Similar to Open_Segment(), but opens a child segment under parent_segment instead of the currently opened segment.
`HC_Style_Segment_Key_By_Key()`	Similar to Style_Segment(), but styles a segment identified by target_segment .
`HC_Named_Style_Segment_By_Key()`	Similar to Named_Style_Segment() but operates on a key rather than an open segment.
`HC_Conditional_Named_Style_By_Key()`
`HC_Show_Conditional_Named_Style()`
`HC_Create_Segment_Key_By_Key()`	Similar to Create_Segment(), but inserts a new segment into the segment associated with the passed key.
`HC_Set_Default_Line_Styles()`	Defines all default line styles in the currently open segment.
`HC_Set_Default_Line_Styles_By_K()`	Similar to Set_Default_Line_Styles() but operates on a key rather than an open segment.
`HC_Set_Default_Glyphs()`	Defines all default glyphs in the currently open segment.
`HC_Set_Default_Glyphs_By_Key()`	Similar to Set_Default_Glyphs() but operates on a key rather than an open segment.
`HC_Set_Default_Shapes()`
`HC_Set_Default_Shapes_By_Key()`
`HC_Reference_Geometry_Key_By_Ke()`	Similar to Reference_Geometry(), but operates on the segment identified by target_segment instead of the currently open segment.
`HC_PShow_Net_Line_Style()`	Similar to Show_Line_Style(), but returns the net effective value along a discrete segment path.
`HC_PShow_Net_Line_Style_Size()`	Similar to Show_Line_Style_Size(), but returns the net effective value along a discrete segment path.
`HC_PShow_Net_Glyph()`	Similar to Show_Glyph(), but returns the net effective value along a discrete segment path.
`HC_PShow_Net_Glyph_Size()`	Similar to Show_Glyph_Size(), but returns the net effective value along a discrete segment path.
`HC_PShow_Net_Shape()`
`HC_PShow_Net_Shape_Size()`
`HC_Generate_Error()`	Injects an error into HOOPS 3DF.
`HC_Commit_Proxy()`
`HC_Create_Proxy()`
`HC_Inspect_Proxies()`
`HC_Begin_Error_Handler_Search()`	Finds all currently defined error handlers.
`HC_Begin_Exit_Handler_Search()`	Finds all the currently defined exit handlers.
`HC_End_Error_Handler_Search()`	Terminates the error handler search sequence and frees any memory involved.
`HC_End_Exit_Handler_Search()`	Terminates the exit handler search sequence and frees any memory involved .
`HC_Find_Error_Handler()`	Retrieves the address of the registered error handlers one at a time.
`HC_Find_Exit_Handler()`	Retrieves the font names, one at a time. The function returns false when all aliases have been returned.
`HC_Show_Error_Handler_Count()`	Finds out how many error handlers will be returned.
`HC_Show_Exit_Handler_Count()`	Finds out how many exit handlers will be returned.
`HC_Compute_Subshell()`	Creates a subshell from the source shell or mesh in the currently open segment and subject to the specified criteria.
`HC_MSet_Specific_Edge_Vis()`	Sets per-edge visibility settings on multiple edges at once. This overrides the visibility settings inherited from the segment-level.
`HC_MShow_Face_Normals()`	Returns the normals set on the faces of some geometry without having to open each face.
`HC_MShow_Net_Face_Normals()`	Similar to MShow_Face_Normals(), but returns the net effective normals set on the faces of some geometry.
`HC_MShow_Specific_Edge_Vis()`
`HC_MUnSet_Specific_Edge_Vis()`	Removes per-edge visibility settings on multiple edges at once. This allows the shell or mesh to inherit segment-level visibility settings.
`HC_Show_Font_Info_By_Path()`	Similar to Show_Font_Info(), but returns the net effective font information along a discrete segment path.
`HC_Show_Reference_Keys()`	Returns a list of keys that a given segment references.
`HC_Show_Reference_Keys_Count()`	Returns the number of references that a given segment references.
`HC_PShow_Net_Line_Pattern_Exp()`	Similar to Show_Line_Pattern_Explicit(), but returns the net effective setting along a discrete path of segments.
`HC_PShow_Net_Edge_Pattern_Exp()`	Similar to Show_Edge_Pattern_Explicit(), but returns the net effective setting along a discrete path of segments.
`HC_Begin_Buffered_Selection()`
`HC_Collect_Area_Samples()`	Gathers all objects that have been drawn in the selection area, and prepares them to be returned to the user.
`HC_Show_Sample_Max_Length()`	Returns the maximum number of keys that will be returned by a call to Find_Next_Sample.
`HC_Find_Next_Sample()`	Allows you to inspect the next item in the list of items found by Collect_Area_Samples.
`HC_End_Buffered_Selection()`	Ends the selection process for the current buffered selection event. that was previously started using Begin_Buffered_Selection.
`HC_UnSet_Priority()`
`HC_Define_Highlight()`	Specifies a method of highlighting an item.
`HC_Define_Geometry_Highlight()`	Specifies a method of highlighting a subpart of an item.
`HC_UnDefine_Highlight()`	UnDefines an existing highlight.
`HC_UnDefine_Geometry_Highlight()`	UnDefines an existing geometry highlight.
`HC_Begin_Highlight_Search()`	Searches for all highlights.
`HC_Find_Highlight()`	Returns the next highlight that was collected.
`HC_Show_Highlight_Count()`	Returns the number of distinct highlights collected, and the maximum number of keys that will be returned in the results to Find_Highlight().
`HC_End_Highlight_Search()`	Discards any remaining results from this search.
`HC_Determine_Highlight_Status()`	Determines if a particular key path invokes highlights.
`HC_Check_Double_Precision()`
`HC_DSet_Camera()`	Similar to Set_Camera(), but operates on double-precision parameter values.
`HC_DSet_Camera_By_Volume()`	Similar to Set_Camera_By_Volume(), but accepts double-precision parameters and operates on double-precision cameras.
`HC_DSet_Camera_Position()`	Similar to Set_Camera_Position(), but operates on double-precision cameras.
`HC_DSet_Camera_Target()`	Similar to Set_Camera_Target(). This command should be used in conjunction with other double-precision Set_Camera functions.
`HC_DSet_Camera_Up_Vector()`	Similar to Set_Camera_Up_Vector(). This command should be used in conjunction with other double-precision Set_Camera functions.
`HC_DSet_Camera_Field()`	Similar to Set_Camera_Field(). This command should be used in conjunction with other double-precision Set_Camera functions.
`HC_DShow_Camera()`	Similar to Show_Camera() but accepts double-precision values. This command should be used in conjunction with other double-precision Set_Camera functions.
`HC_DShow_Camera_By_Volume()`	Similar to Show_Camera_By_Volume(), but operates on double-precision cameras.
`HC_DShow_Camera_Position()`	Similar to Show_Camera_Position(). This command should be used in conjunction with other double-precision Set_Camera functions.
`HC_DShow_Camera_Target()`	Similar to Show_Camera_Target(). This command should be used in conjunction with other double-precision Set_Camera functions.
`HC_DShow_Camera_Up_Vector()`	Similar to Show_Camera_Up_Vector(). This command should be used in conjunction with the other double-precision Set_Camera functions.
`HC_DShow_Camera_Field()`	Similar to Show_Camera_Field(). This command should be used in conjunction with the other double-precision Set_Camera functions.
`HC_DOrbit_Camera()`	Similar to Orbit_Camera(), but operates on double-precision cameras.
`HC_DPan_Camera()`	Similar to Pan_Camera(), but operates on double-precision data.
`HC_DRoll_Camera()`	Similar to Roll_Camera(), but operates on double-precision data.
`HC_DDolly_Camera()`	Similar to Dolly_Camera(), but operates on double-precision cameras.
`HC_DZoom_Camera()`	Similar to Zoom_Camera, but operates on a double precision camera.
`HC_DInsert_Text()`	Similar to Insert_Text(), but accepts parameters of type double for increased precision. Unlike Insert_Text, the parameters are not truncated.
`HC_DInsert_Text_Leader()`	Inserts a leader line with double precision parameters. Unlike Insert_Text_Leader, these parameters will not be truncated.
`HC_DInsert_Text_With_Encoding()`	Similar to Insert_Text_With_Encoding() but accepts double-precision values.
`HC_DShow_Text()`	Similar to Show_Text(), but returns double-precision values.
`HC_DShow_Text_Leader()`
`HC_DShow_Text_With_Encoding()`	Similar to Show_Text_With_Encoding(), but returns double-precision values.
`HC_DEdit_Text_Leader()`
`HC_DInsert_Line()`	Similar to Insert_Line(), but accepts parameters of type double for increased precision. Unlike Insert_Line, the parameters are not truncated.
`HC_DEdit_Line()`	Similar to Edit_Line(), but operates on double-precision data.
`HC_DShow_Line()`	Similar to Show_Line(), but returns double-precision values.
`HC_DInsert_Marker()`	Similar to Insert_Marker(), but accepts parameters of type double for increased precision. Unlike Insert_Marker, the parameters are not truncated.
`HC_DEdit_Marker()`	Similar to Edit_Marker(), but operates on double-precision data.
`HC_DShow_Marker()`	Similar to Show_Marker, but returns double-precision values.
`HC_DInsert_Polygon()`	Similar to Insert_Polygon(), but accepts double-precision values for points.
`HC_DEdit_Polygon()`	Similar to Edit_Polygon(), but accepts double-precision values.
`HC_DShow_Polygon()`	Similar to Show_Polygon(), but returns double-precision values.
`HC_DInsert_Polyline()`	Similar to Insert_Polyline(), but accepts double-precision values for points.
`HC_DEdit_Polyline()`	Similar to Edit_Polyline(), but accepts double-precision values.
`HC_DShow_Polyline()`	Similar to Show_Polyline(), but returns double-precision data.
`HC_DInsert_Shell()`	Similar to Insert_Shell() but accepts double-precision values for points.
`HC_DShow_Shell()`	Similar to Show_Shell(), but returns double-precision values.
`HC_DShow_Shell_By_Tristrips()`	Similar to Show_Shell_By_Tristrips(), but operates on double-precision data.
`HC_DEdit_Shell_Points()`	Similar to Edit_Shell_Points(), but accepts double-precision values.
`HC_DInsert_Circle()`	Similar to Insert_Circle(), but accepts parameters of type double for increased precision.
`HC_DInsert_Circle_By_Radius()`
`HC_DInsert_Circular_Arc()`	Similar to Insert_Circular_Arc(), but accepts parameters of type double for increased precision.
`HC_DInsert_Circular_Chord()`	Similar to Insert_Circular_Chord(), but accepts parameters of type double for increased precision.
`HC_DInsert_Circular_Wedge()`	Similar to Insert_Circular_Wedge, but accepts parameters of type double for increased precision.
`HC_DEdit_Circle()`	Similar to Edit_Circle(), but operates on double-precision data.
`HC_DEdit_Circle_By_Radius()`	Similar to Edit_Circle_By_Radius(), but operates on double-precision data.
`HC_DEdit_Circular_Arc()`	Similar to Edit_Circular_Arc(), but operates on double-precision data.
`HC_DEdit_Circular_Chord()`	Similar to Edit_Circular_Chord(), but operates on double-precision data.
`HC_DEdit_Circular_Wedge()`	Similar to Edit_Circular_Wedge(), but operates on double-precision data.
`HC_DShow_Circle()`	Similar to Show_Circle(), but returns double-precision values.
`HC_DShow_Circle_By_Radius()`	Similar to Show_Circle_By_Radius, but returns double-precision values.
`HC_DShow_Circular_Arc()`	Similar to Show_Circular_Arc(), but returns double-precision values.
`HC_DShow_Circular_Chord()`	Similar to Show_Circular_Chord(), but returns double-precision values.
`HC_DShow_Circular_Wedge()`	Similar to Show_Circular_Wedge(), but returns double-precision values.
`HC_DInsert_Ellipse()`	Similar to Insert_Ellipse(), but accepts parameters of type double for increased precision.
`HC_DInsert_Elliptical_Arc()`	Similar to Insert_Elliptical_Arc(), but accepts parameters of type double for increased precision.
`HC_DEdit_Ellipse()`	Similar to Edit_Ellipse(), but operates on double-precision data.
`HC_DEdit_Elliptical_Arc()`	Similar to Edit_Elliptical_Arc(), but operates on double-precision data.
`HC_DShow_Ellipse()`	Similar to Show_Ellipse(), but returns double-precision values.
`HC_DShow_Elliptical_Arc()`	Similar to Show_Elliptical_Arc(), but returns double-precision values.
`HC_DInsert_Grid()`	Similar to Insert_Grid(), but accepts parameters of type double for increased precision.
`HC_DShow_Grid()`	Similar to Show_Grid(), but returns double-precision values.
`HC_DEdit_Grid()`	Similar to Edit_Grid(), but operates on double-precision data.
`HC_DInsert_Mesh()`	Similar to Insert_Mesh(), but accepts parameters of type double for increased precision. Unlike Insert_Marker, the parameters are not truncated.
`HC_DShow_Mesh()`	Similar to Show_Mesh(), but returns double-precision values.
`HC_DEdit_Mesh()`	Similar to Edit_Mesh(), but can operate on double-precision geometry represented by key , and returns double-precision values for points .
`HC_DInsert_Image()`	Similar to Insert_Image(), but accepts parameters of type double for increased precision.
`HC_DInsert_Compressed_Image()`
`HC_DShow_Image()`	Similar to Show_Image(), but returns double-precision values.
`HC_DShow_Image_Size()`	Similar to Show_Image_Size(), but operates on double-precision data.
`HC_DShow_Compressed_Image()`	Similar to Show_Compressed_Image(), but operates on double-precision data.
`HC_DMove_Image()`	Similar to Move_Image() but operates on double-precision parameter values.
`HC_DInsert_Ink()`	Similar to Insert_Ink() but accepts parameters of type double for increased precision. Unlike Insert_Ink, the parameters are not truncated.
`HC_DInsert_PolyCylinder()`	Similar to Insert_PolyCylinder(), but operates on double-precision data.
`HC_DShow_PolyCylinder()`	Similar to Show_PolyCylinder(), but operates on double-precision data.
`HC_DEdit_PolyCylinder()`	Similar to Edit_PolyCylinder(), but operates on double-precision data.
`HC_DEdit_PolyCylinder_With_Basis()`	Similar to Edit_PolyCylinder_With_Basis, but operates on double-precision data.
`HC_DInsert_Cutting_Plane()`	Similar to Insert_Cutting_Plane(), but accepts parameters of type double for increased precision.
`HC_DShow_Cutting_Plane()`	Similar to Show_Cutting_Plane(), but returns double-precision values.
`HC_DEdit_Cutting_Plane()`	Similar to Edit_Cutting_Plane(), but operates on double-precision data.
`HC_DInsert_Cylinder()`	Similar to Insert_Cylinder(), but accepts parameters of type double for increased precision.
`HC_DShow_Cylinder()`	Similar to Show_Cylinder(), but operates on double-precision data.
`HC_DEdit_Cylinder()`	Similar to Edit_Cylinder(), but operates on double-precision data.
`HC_DInsert_Sphere()`	Similar to Insert_Sphere(), but operates on double-precision data.
`HC_DShow_Sphere()`	Similar to Show_Sphere(), but returns double-precision data.
`HC_DEdit_Sphere()`	Similar to Edit_Sphere(), but operates on double-precision data.
`HC_DInsert_NURBS_Curve()`
`HC_DShow_NURBS_Curve()`	Similar to Show_NURBS_Curve, but operates on double-precision values.
`HC_DEdit_NURBS_Curve()`	Similar to Edit_NURBS_Curve() but accepts double-precision values.
`HC_DInsert_NURBS_Surface()`	Similar to Insert_NURBS_Surface(), but accepts parameters of type double for increased precision. Unlike Insert_NURBS_Surface, the parameters are not truncated.
`HC_DShow_NURBS_Surface()`	Similar to Show_NURBS_Surface() but operates on double-precision values.
`HC_DEdit_NURBS_Surface()`	Similar to Edit_NURBS_Surface(), but accepts double-precision parameters.
`HC_DEdit_NURBS_Surface_Points()`	Similar to Edit_NURBS_Surface_Points(), but accepts double-precision parameters.
`HC_DInsert_Local_Light()`	Similar to Insert_Local_Light(), but accepts parameters of type double for increased precision. Unlike Insert_Local_Light, the parameters are not truncated.
`HC_DShow_Local_Light()`	Similar to Show_Local_Light(), but returns double-precision values.
`HC_DInsert_Spot_Light()`	Similar to Insert_Spot_Light(), but accepts double-precision values for points.
`HC_DShow_Spot_Light()`	Similar to Show_Spot_Light(), but returns double-precision values.
`HC_DInsert_Area_Light()`	Similar to Insert_Area_Light, but operates on double-precision data.
`HC_DShow_Area_Light()`	Similar to Show_Area_Light, but operates on double-precision data.
`HC_DCompute_Coordinates()`	Similar to Compute_Coordinates(), but returns double-precision values for position.
`HC_DCompute_Coordinates_By_Path()`	Similar to Compute_Coordinates_By_Path(), but operates on double-precision data.
`HC_DCompute_Transformed_Points()`	Similar to Compute_Transformed_Points() but accepts and returns double-precision values.
`HC_Compute_Boolean_Shell2()`
`HC_DCompute_Boolean_Shell()`	Similar to Compute_Boolean_Shell(), but accepts and returns double-precision values.
`HC_DCompute_Optimized_Shell()`	Similar to Compute_Optimized_Shell(), but computes and returns double-precision values.
`HC_Memory_Usage_By_Key()`
`HC_Apply_Attribute_Filter()`
`HC_Show_Attribute_Filter()`
`HC_Show_Attribute_Filter_Length()`
`HC_Begin_Decimate_Shell()`
`HC_End_Decimate_Shell()`
`HC_Decimate_Shell()`

Macro definitions

HC_PROTO_DEFINED

Functions

void HC_Abort_Program(char const *message)

Function to create a map linking PrcIds and A3DEntities.

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

Provides an orderly way to terminate execution upon the discovery of an error.

DETAILS

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

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

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.

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.)

DETAILS

Use this routine only if your program organizes and keeps track of the net transformations applied to your objects.

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.

NOTES

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.)

See also

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

RESTRICTIONS

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

void HC_DAppend_Modelling_Matrix(double const array[])

Similar to Append_Modelling_Matrix(), but accepts double-precision data.

See also

HC_Append_Modelling_Matrix

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

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.

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.)

DETAILS

Use this routine if your program organizes and keeps track of the net transformations applied to your vertex parameters.

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.

NOTES

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.)

See also

HC_Set_Texture_Matrix, HC_Rotate_Texture, HC_Translate_Texture, HC_Scale_Texture.

RESTRICTIONS

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

void HC_Begin_Alias_Search(void)

These routines recall the name of each alias.

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:

DETAILS

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.

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.

NOTES

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.

See also

HC_Show_Alias, HC_Define_Alias, HC_Show_Pathname_Expansion

RESTRICTIONS

void HC_Begin_Callback_Name_Search(void)

Finds the names of all previously defined callback routines.

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

DETAILS

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.

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.

NOTES

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.

void HC_Begin_Color_Name_Search(void)

These routines recall all the defined color names.

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

DETAILS

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().

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.

NOTES

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

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.

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.

DETAILS

In a contents search, Begin_Contents_Search() initiates and defines the search. Only the types specified in filterare used in the search, 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 :ref:segment name syntax <prog_guide/3dgs/01_3_database_dbase_structure: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.

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.

NOTES

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.

Parameters

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

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

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

Begin_Font_Search() initiates and defines the search. Only the types specified in filter are searched for.

DETAILS: A font search allows you to find out what fonts are available on a given display.

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 ()

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.

NOTES

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.

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.

void HC_Begin_Glyph_Search(void)

These routines recall all the defined glyph names.

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

DETAILS

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().

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.

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

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

void HC_Begin_Line_Style_Search(void)

These routines recall all the defined line style names.

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 ()

DETAILS

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().

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.

NOTES

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

void HC_Begin_Open_Segment_Search(void)

Returns the pathnames of all open segments.

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.

DETAILS

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() .

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.

NOTES: You can use these routines with no segments open. The first call to Find_Open_Segment() will just return false.

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.

void HC_Begin_Segment_Search(char const *segspec)

Finds all segments matching a search specification.

Begin_Segment_Search() initiates the search by specifying where to start looking for segments.

DETAILS: The segment search routines provide the ability to determine the current segment structure of the database.

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.

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.

NOTES: If no segments are found that match the specification, the first call to Find_Segment() returns false.

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.

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

void HC_Begin_Shader_Search(char const *search)

These routines recall the name of each shader.

…prints all the known shader names, their options and source. Begin_Shader_Search() initiates the search for each shader name.

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 ()

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.

See also

HC_Show_Shader, HC_Define_Shader

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.

Parameters: search – - A specification of which custom shader implementation to search for: either “legacy” or “modern”.

void HC_Begin_Shape_Search(void)

void HC_Begin_Texture_Search(void)

These routines recall all the defined texture names.

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

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

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() .

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.

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

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.

void HC_Begin_Local_Texture_Search(void)

Begins a texture search on the currently open segment.

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_Open_Segment_By_Key(segKey); HC_Show_Segment (segKey, pathname);
    HC_Begin_Contents_Search (".", "attributes");
    while (HC_Find_Contents(type, &tempKey)){
        if (!strcmp (type, "texture definitions")) {
            HC_Begin_Local_Texture_Search();
            HC_Show_Texture_Count(&texture_count);
            HC_Find_Texture (texture_name);
        }
    }
}
HC_End_Contents_Search();

DETAILS

See also

HC_Begin_Texture_Search

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.

void HC_Bring_To_Front(char const *segment)

Deprecated:: This function has been deprecated. It is superseded by setting the hsra rendering option to priority.

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.

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, 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.

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.

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.

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.

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.

RESTRICTIONS

See also

HC_Set_Window, HC_Set_Heuristics, HC_Set_Streaming_Mode, HC_Set_Camera, HC_Set_Visibility.

Parameters: segment – - Name of the segment(s) to be shuffled forward.

void HC_Bring_To_Front_By_Key(Key key)

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

Deprecated:: This function is deprecated.

See also

HC_Bring_To_Front()

Parameters: key – - Open_Segment() , or any Insert routine.

void HC_Close_Edge(void)

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

See also

HC_Open_Edge()

void HC_Close_Face(void)

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

See also

HC_Open_Face()

void HC_Close_Geometry(void)

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

See also

HC_Open_Geometry()

void HC_Close_LOD(void)

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

See also

HC_Open_LOD()

void HC_Close_Region(void)

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

See also

HC_Open_Region()

void HC_Close_Segment(void)

Closes the currently open segment.

See also

HC_Open_Segment, HC_Rename_Segment, HC_Flush_Contents, HC_Reset_System

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.

void HC_Close_Vertex(void)

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

See also

HC_Open_Vertex()

bool HC_Compile_Shader(int key_count, Key const path_keys[], char const *options)

Defines a section of code that will be injected into HOOPS 3DF shaders.

The geometry suboption needs to be the type of geometry which we want to see the shader for, optionally followed by a filter to limit generation to a particular set of primitives. For example, you could specify “geometry = (shell = triangles)” to get only the triangle shader for the shell, “geometry = (shell = (lines, points))” to get only the lines and points shaders for the shell, or “geometry = shell” to get triangle, lines, and points shaders for shells. The following is a list of geometry choices with the primitive types they may generate:

“nurbs curve” - “lines”
“elliptical arc” - “lines”
“circular arc” - “lines”
“line” - “lines”
“polyline” - “lines”
“polygon” - “triangles”, “lines”
“circular chord” - “triangles”, “lines”
“circular wedge” - “triangles”, “lines”
“ellipse” - “triangles”, “lines”
“circle” - “triangles”, “lines”
“marker” - “points”
“shell” - “triangles”, “lines”, “points”
“mesh” - “triangles”, “lines”, “points”
“cylinder” - “triangles”, “lines”
“polycylinder” - “triangles”, “lines”
“sphere” - “triangles”, “lines”
“nurbs surface” - “triangles”, “lines”
“text” - “triangles”, “lines”
“grid” - “triangles”, “lines”, “points”
“infinite line” - “lines”
“image” - “triangles”

Supported Options:: geometry, stage, vertex format
DETAILS: [all] geometry

[all] stage [vertex | pixel]

The stage suboption will be either vertex or pixel if you wanted to restrict the shaders that are generated to a particular stage.

vertex format

The vertex format suboption can have the following options:

“position” - [on | off]
“double position” - [on | off]
“normals” - [on | off]
“diffuse” - [on | off]
“specular” - [on | off]

Default activated options are : position, normals and diffuse.

See also

HC_Show_Compilation_Results_Size, HC_Show_Compilation_Results

Parameters

key_count – - The number of keys in the path
path_keys – - An array of keys, from the target segment up to a driver. Also possible to pass a single segment key
options – - A quoted string or a string variable containing a list of the desired options

Returns

true if it was able to find a custom shader on the given path for either the vertex or pixel shader and geometry, construct the shader source for any relevant primitive types, invoke the shader compile function, and the compilation is successful. Returns false otherwise.

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

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

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.

DETAILS

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() ).

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,

NOTES

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

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.

See also

HC_Compute_Circumcuboid()

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

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

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

See also

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

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

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

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.

See also

HC_Compute_Circumsphere()

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

bool HC_DCompute_Circumcuboid(char const *segment, DPoint *min, DPoint *max)

Similar to Compute_Circumcuboid, but accepts double-precision parameters.

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

bool HC_DCompute_Circumcuboid_By_Key(Key key, DPoint *min, DPoint *max)

Similar to Compute_Circumcuboid_By_Key(), but operates on double-precision data.

See also

HC_Compute_Circumcuboid_By_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

bool HC_DCompute_Circumsphere(char const *segment, DPoint *center, double *radius)

Similar to Compute_Circumsphere(), but operates on double-precision data.

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

bool HC_DCompute_Circumsphere_By_Key(Key key, DPoint *center, double *radius)

Similar to Compute_Circumsphere_By_Key(), but operates on double-precision data.

See also

HC_Compute_Circumsphere_By_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

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.

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.

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.

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.

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.

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.

See also

HC_Compute_Color()

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.

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.

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() .

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.

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.

The algorithm used is O(n squared). In other words, it’s going to take a while.

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.

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

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.

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.

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

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.

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.

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.

NOTES

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.

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.

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.

See also

HC_Compute_Transform, HC_Show_Selection_Position, HC_Show_Polyline, HC_Show_Shell.

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 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 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

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.

See also

HC_Compute_Coordinates()

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.
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.
out_position – - A 3-D coordinate position in the out_system coordinate space. Passed by reference in all languages. Returned to user.

Returns

success

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

Computes the cross product of two vectors.

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

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:

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

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

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.

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

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

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

See also

HC_Compute_Coordinates, HC_Compute_Cross_Product

Parameters

vector1 – - Input 3D vector.
vector2 – - Input 3D vector.

Returns

value

double HC_DCompute_Dot_Product(DVector const *vector1, DVector const *vector2)

Similar to Compute_Dot_Product, but operates on double-precision data.

Parameters

vector1 – - Input 3D vector.
vector2 – - Input 3D vector.

Returns

value

void HC_Compute_Identity_Matrix(float out_matrix[])

See also

HC_Set_Modelling_Matrix

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].

Parameters: out_matrix – - Output transformation matrix, returned to the caller.

void HC_DCompute_Identity_Matrix(double out_matrix[])

Similar to Compute_Identity_Matrix(), but operates on double-precision data.

Parameters: out_matrix – - Output transformation matrix, returned to the caller.

void HC_Compute_Matrix_Adjoint(float const matrix[], float out_matrix[])

See also

HC_Compute_Coordinates, HC_Compute_Matrix_Inverse, HC_Compute_Transform, HC_Compute_Transformed_Plane, HC_Set_Modelling_Matrix, HC_Show_Device_Info

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.

Parameters

matrix – - Input transformation matrix.
out_matrix – - Output transformation matrix, returned to the caller. Can point to the same place as matrix.

void HC_DCompute_Matrix_Adjoint(double const matrix[], double out_matrix[])

Similar to Compute_Matrix_Adjoint(), but operates on double-precision data.

Parameters

matrix – - Input transformation matrix.
out_matrix – - Output transformation matrix, returned to the caller. Can point to the same place as matrix.

double HC_Compute_Matrix_Determinant(float const matrix[])

See also

HC_Compute_Coordinates, HC_Compute_Matrix_Inverse, HC_Compute_Normalized_Matrix, HC_Compute_Transform, HC_Set_Modelling_Matrix, HC_Show_Device_Info

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

Parameters: matrix – - Input transformation matrix.
Returns: value

double HC_DCompute_Matrix_Determinant(double const matrix[])

Similar to Compute_Matrix_Determinant(), but operates on double-precision data.

Parameters: matrix – - Input transformation matrix.
Returns: value

bool HC_Compute_Matrix_Inverse(float const matrix[], float out_matrix[])

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.

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

See also

HC_Compute_Coordinates, HC_Compute_Matrix_Determinant, HC_Compute_Matrix_Adjoint, HC_Compute_Transform, HC_Set_Modelling_Matrix, HC_Show_Device_Info

Parameters

matrix – - Input transformation matrix.
out_matrix – - Output transformation matrix, returned to the caller. Can point to the same place as matrix.

Returns

success

bool HC_DCompute_Matrix_Inverse(double const matrix[], double out_matrix[])

Similar to Compute_Matrix_Inverse(), but operates on double-precision data.

Parameters

matrix – - Input transformation matrix.
out_matrix – - Output transformation matrix, returned to the caller. Can point to the same place as matrix.

Returns

success

void HC_Compute_Matrix_Product(float const matrix1[], float const matrix2[], float out_matrix[])

Given:

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).

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

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

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.

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.

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[])

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

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

See also

HC_Compute_Coordinates, HC_Compute_Matrix_Determinant, HC_Compute_Transform, HC_Set_Modelling_Matrix, HC_Show_Device_Info

Parameters

matrix – - Input transformation matrix.
out_matrix – - Output transformation matrix, returned to the caller. Can point to the same place as matrix.

Returns

success

bool HC_DCompute_Normalized_Matrix(double const matrix[], double out_matrix[])

Similar to Compute_Normalized_Matrix, but operates on double-precision data.

Parameters

matrix – - Input transformation matrix.
out_matrix – - Output transformation matrix, returned to the caller. Can point to the same place as matrix.

Returns

success

bool HC_Compute_Normalized_Vector(Vector const *vector, Vector *out_vector)

See also

HC_Compute_Coordinates, HC_Compute_Transform, HC_Set_Modelling_Matrix, HC_Show_Device_Info

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

Parameters

vector – - Input 3D vector.
out_vector – - Output 3D vector returned to the caller. Can point to the same place as vector .

Returns

success

bool HC_DCompute_Normalized_Vector(DVector const *vector, DVector *out_vector)

Parameters

vector – - Input 3D vector.
out_vector – - Output 3D vector returned to the caller. Can point to the same place as input vector.

Returns

success

void HC_Compute_Offaxis_Rotation(double x, double y, double z, double theta, float out_matrix[])

See also

HC_Compute_Offcenter_Rotation, HC_Set_Modelling_Matrix

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

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.

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.

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.

void HC_Compute_Offcenter_Rotation(double alpha, double beta, double theta, double x, double y, double z, float out_matrix[])

See also

HC_Compute_Offaxis_Rotation, HC_Set_Modelling_Matrix

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