HOOPSACIS Bridge Use Cases

HOOPS/ACIS Bridge Use CasesFrom DocR22< HOOPSJump to: navigation, searchContents[hide]∙ 1 Initialization and Shutdown∙ 2 Reading ACIS Files∙ 3 Creating and Rendering ACIS Entitieso 3.1 Defining ACIS Geometryo 3.2 Rendering ACIS Geometryo 3.3 Inserting ACIS Geometry into the HOOPS databaseo 3.4 Deleting ACIS and HOOPS Geometry∙ 4 See AlsoInitialization and ShutdownTo initialize the HOOPS/ACIS Bridge, call api_initialize_hoops_acis_bridge in an application initialization routine. This function initializes the ACIS components that the Bridge uses and registers HA_History_Callbacks with the global history callback list. All geometry rendered via HA_Render_Entity routines will be mapped to corresponding segments and geometry in the HOOPS graphics database. (HOOPS does not need an explicit initialization routine, as it is automatically initialized during the first call of a HOOPS function.)If your application performs advanced ACIS operations, then you may need to call api_initialize_* to start up the modules you are using. These calls should be made just after calling api_initialize_hoops_acis_bridge. Likewise, any modules that you initialize should be shut down just prior to calling api_terminate_hoops_acis_bridge. The ACIS modules initialized and shut down within the calls toapi_initialize_hoops_acis_bridge and api_terminate_hoops_acis_bridge are: Booleans, Faceter, and Rendering.To terminate the HOOPS/ACIS Bridge, call api_terminate_hoops_acis_bridge. This should be called in an application-cleanup routine, when ACIS is no longer needed. This does not shut down the HOOPS Graphics System; HOOPS' HC_Reset_System will still need to be called to directly shutdown HOOPS:void MySolidHoopsAppCleanup(){api_terminate_hoops_acis_bridge(); // shutdown ACISapi_stop_modeler(); // shutdown ACISterminate_base(); // shutdown ACISHC_Reset_System(); // shutdown HOOPS}Reading ACIS FilesTo read an ACIS file, call HA_Read_Sat_File. This parses the specified ACIS file, populates the ACIS database with its contents, and then maps the model to a corresponding HOOPS segment tree hierarchy including geometry and attributes. The following snippet shows how you might implement a Read method for yoursolid-model class:// an application-specific read functionint HSolidModel::Read(const char* FileName){unsigned int i;char extension[120];bool success = true;extension[0] = '\0';HC_Parse_String(FileName, ".", -1, extension);// make it lower casefor(i = 0; i < strlen(extension); i++)extension[i]=(char)tolower(extension[i]);// read the file into the model object's model segmentHC_Open_Segment_By_Key(m_ModelKey);// read each file into its own subsegment of the main model segment// so that we can easily apply transformations to different parts// that might be read into the same model object; currently not// supported in MVO, but could be added in the future. This is// also required so that when we do segment level deletion later on,// we do not delete the model_keysegmentHC_Open_Segment("");if(streq(extension,"sat")){ENTITY_LIST elist;ENTITY* entity;// read an SAT fileHA_Read_Sat_File(FileName, elist);// set next() function to return first element in "list"elist.init();while(entity = elist.next()){m_entityList.add(entity);}}elsesuccess = false;HC_Close_Segment();HC_Close_Segment();return success;}The HOOPS/ACIS Reference Application contains another example of such a function. Refer to the HSolidModel::Read() method located in HSolidModel.cpp.Creating and Rendering ACIS EntitiesRendering ACIS entities is performed by calling HA_Render_Entity orHA_Render_Entities.As an example, we will go through a process of inserting a spherical solid into ACIS and passing the tessellated information to HOOPS for subsequent rendering and interaction. This and future sections assume familiarity with the ACIS entity types.Defining ACIS GeometryA sphere, along with many other predefined ACIS objects, is represented by a BODY entity, and is created via the routine:<outcome> = api_make_sphere(<radius>, <sphere_body>);ACIS entities are referred to by their pointers, so this function populates memory with a sphere of the specified radius and returns the pointer of the associated ACIS body. However, the sphere is not actually rendered (mapped to corresponding HOOPS segments and geometry) until a call is made to the HA_Render_Entity routine (discussed in the next section).The following code demonstrates how to create an ACIS sphere. Note that it callsHA_Render_Entity.// create an ACIS sphere and return the sphere's body IDBODY* HOpCreateSolidSphere::CreateSolidSphere(HPoint& center, double radius) {BODY* sphere_body;SPAvector translate_vector;SPAtransf delta_transf;outcome o;translate_vector.set_x(center.x);translate_vector.set_y(center.y);translate_vector.set_z(center.z);delta_transf = translate_transf(translate_vector);o = api_make_sphere(radius, sphere_body);o = api_transform_entity(sphere_body, delta_transf);assert(o.ok());// before rendering bodies, check if this view is in 'merge faces'// mode or not, and ensure that the rendering option is set// accordingly. This is necessary because the HOOPS/GM Rendering// Options are procedural; they set the current state of the bridge,// and we need to make sure that all parts in each view object are// rendered in a consistent modeif(((HSolidView*)GetView())->GetOptimizations())HA_Set_Rendering_Options("merge faces");elseHA_Set_Rendering_Options("no merge faces");// now put it in the HOOPS databaseHA_Render_Entity((ENTITY*)sphere_body);((HSolidModel*)m_pView->GetModel())->AddAcisEntity(sphere_body);return sphere_body;}Rendering ACIS GeometryAfter an ACIS entity is defined and inserted into the ACIS database, the tessellated geometric information that represents the entity must be generated. BODY entities (along with others) are composed of FACE and EDGE entities. These entities denote the logical surface and edge/boundary information associated with the body. Specifically, a cylinder body object is composed of three FACE entities, one for the top, one for the bottom, and one for the 'tubular' part of the cylinder. It is composed of two EDGE entities, one for a circle denoting the top edge, and one for a circle denoting the bottom edge.The HOOPS/ACIS Integration includes a function—HA_Render_Entity—that replaces api_facet_entity. Like the function it replaces, HA_Render_Entity triggers the rendering of faces and edges. Unlike api_facet_entity, this bridge function also causes wire bodies to be rendered. (Note that the example under discussion, a cylinder, does not contain any wire entities.) The geometric data that represents the cylinder is automatically mapped to a group of geometric primitives in the HOOPS database. (By default, these primitives are inserted into the expanded segment pattern. TheHA_Set_Rendering_Options function, discussed later in this document, provides forcontrol of this behavior, including creation of subsegments and optimization of the geometry.)To render ACIS entities and have their tessellated representation automatically mapped to HOOPS graphical primitives, you may simply call one of these two functions:HA_Render_Entity(ENTITY* entity, const char* pattern = 0);HA_Render_Entities(const ENTITY_LIST& entities, const char* pattern = 0);These functions also update the bidirectional mapping (which uses a hash table) between ACIS entity pointers and HOOPS keys, which is maintained by the HOOPS/ACIS integration.Inserting ACIS Geometry into the HOOPS databaseRecall that the HOOPS geometry and any additional segments generated as a result of the HA_Render_Entity and HA_Render_Entities routines will be placed in the currently open HOOPS segment. The following code ties together the code necessary to insert a sphere object into both ACIS and HOOPS. It assumes that we have obtained the creation parameters for a cylinder from the UI, opens a segment and then calls the CreateSolidSphere function discussed previously. After CreateSolidSphere is called (which calls HA_Render_Entity, discussed above), the ACIS database will contain a parametric representation of the sphere (an ACIS body), and the HOOPS database will contain the corresponding geometric representation (a HOOPS shell): // open a HOOPS segment, which will contain the cylinder geometryHC_Open_Segment_By_Key(GetView()->GetModel()->GetModelKey());// put each entity in a separate segment so that we can easily apply// transformations to separately created entitiesHC_Open_Segment("");BODY* sphere_ptr;sphere_ptr = CreateSolidSphere(m_ptFirst, radius_length);HC_Close_Segment();HC_Close_Segment();The ACIS entity that represents the cylinder is accessible via the sphere_ptr pointer. Details on how to identify the HOOPS geometric primitives associated with the ACIS entity are covered later in this document, in the section Operating on ACIS Entities with HOOPS/ACIS Bridge.The HOOPS/ACIS Reference Application implements and uses theplatform-independent creation/rendering functions discussed above. It also includes additional geometry creation functions:The HOpCreateSolidCone, HOpCreateSolidTorus and HOpCreateSolidSphere classes are all derived from the HBaseOperator MVO class, and provide forcreation of 'rubberband' construction geometry, in addition tocreation/rendering of the ACIS and HOOPS entities. They containimplementations of CreateSolidCone, CreateSolidTorus, andCreateSolidSphere functions as outlined above.Deleting ACIS and HOOPS GeometryWe will recall that the HOOPS/ACIS Integration maintains a mapping between ACIS entities and HOOPS Geometry, which enables the developer to determine the ACIS entities associated with a given HOOPS geometric primitive or segment, and vice versa. The HA_Render_Entities function causes this mapping to be created/updated each time it is called upon to populate the HOOPS database with the tessellated representations of ACIS entities.Conversely, another HOOPS/ACIS function must be called when deleting HOOPS geometry associated with ACIS entities, in order to ensure that the internal mapping is kept up-to-date. This function is called HA_Delete_Entity_Geometry, and should be used to delete the HOOPS geometry associated with an ACIS entity before the latter is deleted. For example, the following function is a wrapper function that deletes an ACIS entity along with its associated HOOPS geometry:void HSolidModel::DeleteAcisEntity(ENTITY* entity){ENTITY_LIST elist;elist.add(entity);HA_Delete_Entity_Geometry(elist);// delete the ACIS bodyapi_del_entity(entity);}It is important to use HA_Delete_Entity_Geometry whenever deleting HOOPS geometric primitives associated with deleted ACIS entities. If only the normal HOOPS/3dGS deletion functions were called (HC_Delete_By_Key, etc.), then the HOOPS/ACIS mapping would not be correct, and problems would occur during subsequent operations.。