[size="3"]HypVisual

HypVisual displays the content of the Hyperion files. It also allows the user to apply forces on the solid and to generate temporal interpolations. Although a large amount of code is not directly connected to the Ephydryne components but to the MFC or to some DirectX objects, we will have a look at the implementation of the main functions.

Elastic vs. plastic deformations

Before going further, it is important to remember the hypothesis made in the first article, that is, those related to the study of elastic deformations uniquely. A deformation is elastic when a linear relation between the applied forces and the displacements exists. Moreover, during an elastic deformation, solids change in shape that returns when a stress is removed. If the deformation is not elastic, it is called a plastic deformation which is permanent. This sort of deformation is very difficult to handle because results depend not only on the initial state but also on intermediate states of the deformation.

Elastic deformations have been supposed in order to obtain real-time results. As an aside, spring systems, widely used in the video games, are based on the same hypothesis. However temporal interpolation will be used to simulate plastic or viscous-elastic deformations loosely. It is worth noting that it is not mechanically correct, but looks realistic enough.

Temporal interpolation

The temporal interpolation is based on two ideas:

• Whereas elastic deformations are not permanent, our elastic deformations will be. Moreover, these deformations will be considered as key points of the temporal interpolation.
• How the solid gets its deformed shape, that is, how the interpolation functions are defined, is up to the programmer.

  
  
  

  HypVisual implements three interpolation schemes: linear, sinus and damped oscillations. Notice that whereas in spring systems node positions are almost computed for each displayed frame because of the time integration, the Hyperion method computes them only once and interpolates the entire scene.
  
  Implementation
  
  Like CDevMesh which is defined in the HypDev application, the MFC Document object contains four interfaces pointing to a same component:
  
  class CHypVisualDoc {
//. . .
hyp_ker::IPtrUnknown m_spUnknownMesh;
hyp_fem::t_spGeometricBase m_spBaseMesh;
hyp_fem::t_spGeometricObject m_spObjectMesh;
hyp_fem::t_spFEOMesh m_spMeshMesh;
//. . .
};When the application starts up, the CFEOMesh component is initialized through the Hyperion file.
  
  BOOL CHypVisualDoc::OnOpenDocument(LPCTSTR lpszPathName)
{
CWaitCursor wait;
try {
hyp_TRACE( ("Load Mesh from %s",lpszPathName) );
hyp_out::t_spD3DMeshObject spD3DMesh;
spD3DMesh.CreateInstance(hyp_out::CLSID_hypCObjectXFile,0);

spD3DMesh->SetObject(m_spUnknownMesh);
spD3DMesh->LoadD3DHypMesh(lpszPathName);

m_spMeshMesh->InitMasks();
} catch(hyp_ker::CComException hr) {
hyp_NOTIFY( ("Error during the loading of the file") );
return FALSE;
}
return TRUE;
}To display the object, the DirectX MeshBuilder component, m_pMesh, is initialized by the following function.
  
  void CHypMesh::Reset()
{
m_pMesh->Empty(0);
try {
hyp_out::t_spD3DMeshObject spD3DMesh;
spD3DMesh.CreateInstance(hyp_out::CLSID_hypCObjectXFile,0);
spD3DMesh->SetObject(m_pHypMesh); //m_pHypMesh is a data member of the CHypMesh class
spD3DMesh->InitializeD3DMeshBuilder(m_pMesh);
} catch(hyp_ker::CComException hr) {
hyp_FATAL( ("Error during the reset of the mesh") );
}
// . . .
}The best way to understand how the application works is to try several simulations.
  
  [size="3"]Does the method fulfill our objectives?
  
  You are perhaps wondering whether results obtained by this method are correct or not. In the first article, obtaining real-time and realistic solutions was my objective.
  
  Are the results realistic?
  
  Of course, some tests have been carried out in order to check whether obtained solutions are accurate or not. I will now present one of the most relevant tests. In this test, the solid is a beam fixed at one of its extremities (z=0). The dimensions of the beam are 2 by 2 by 20 meters between the points (0,0,0) and (2,2,20). A force having for intensity (100,0,0) is applied on the node (0,1,20). 40 elements along the z-axis and 2 along the x and z axes make this beam up.
  
  

  
  
  

  According to the Strength of Material, a theoretical solution is found.
  
  
  
  s corresponds to the displacement of the beam's extremity along the x-axis. L and Igz are related to the geometry of the beam. The numerical solution corresponding to our problem is 2 meters. As you can see in the chart, solution found by Hyperion is very close from the theoretical solution. Solution found by a FEM software application called ANSYS has been added as a reference.
  
  

  
  
  

  The Finite Element Method is one of the best engineering methods to resolve physical problems. It is proved by this case once again.
  
  Are the results real-time?
  
  Multiplication between the matrix K'-1r and the force vector is only the time-consuming part of the method because computation is almost done during the creation of the level. Whereas FEM is often slow, the adaptation implemented by the Ephydryne components is very fast and offers the same accuracy as the FEM. According to the video game requirements, the method could be considered real-time.
  
  
  [size="5"]Optimizations of the method
  
  The study of solid deformations mixes several engineering fields, each offering efficient optimizations. In this part, we will explore different ways to improve the Hyperion method.
  
  [size="3"]Related to the CPU
  
  Frequencies do not uniquely define performance of the CPU. For the past few years, new processor instructions have been implemented. Their names are SSE or 3DNow!. One of the goals of these extended instructions is to speed up matrix computations. Hyperion method uses matrix computation intensively and sometimes handles big matrices. That is why using these special instructions could decreases computation time especially during multiplications between force vectors and the matrix K'-1r.
  
  [size="3"]Related to the GPU
  
  In the previous examples, a lot of triangular sides have been created decreasing general performance. For instance, after loading a cube which is pre-computed to be deformed, more than 6 sides (depending on the density of elements) will be displayed even if the cube is not deformed. Furthermore if the solid is locally deformed, that is, if a few sides are displaced, a big number of sides will not be moved. Reducing dynamically the number of sides is one of the possible optimizations.
  
  

  
  
  

  On the other hand, when too few sides have been defined, quality of the result is reduced. The solution is to add new sides with the help of interpolation functions such as splines. As an aside, interpolation functions are deeply connected to the FEM. For instance, the finite element "cube" is related to one-degree interpolation functions. Whereas interpolation positions are computed regarding position of local nodes of the element, computation of interpolated nodes could be carried out with nodes related to several elements. Moreover, it turns out that finding the position of interpolated nodes is faster than finding FEM nodes.
  
  

  
  
  

  Of course, this method has to be used with carefulness because interpolation nodes could smooth local deformations.
  
  [size="3"]Related to the memory
  
  During loading of the level, a matrix for each deformable element is fetched into the RAM. A large amount of memory will be consumed very quickly if there are n matrices for n deformable objects. However some objects have almost the same topology.
  
  

  
  
  

  In the previous figure, two identical objects have the same topology, the same sort and the same density of finite elements, but have different proportions. For example, these two objects could be walls, items often used to build video games levels. Using homothety coefficients allows reducing the footprint of the application.
  
  It is also worth saying that compressing files related to the definition of matrices is very efficient. Data related to the Hyperion files have been compiled in the following table.
  
  Size of the file before compressionSize of the file after compression (1)Number of nodesNumber of elementsNumber of sides2,58 MB115 KB242100480685 KB55.1 KB105481762.85 MB333 KB18980336(1) Compression done with WinZip 8.0 - Compression maximum
  
  [size="3"]Related to the algorithm
  
  Great improvements can be done if algorithms which handle matrix operations are modified, such as:
  

  • checking to know whether global matrices are invertible or not;
  • matrix storage;
  • dynamic simplification when forces are applied. This simplification might be very close from the render mask simplification presented in the previous part.
    
    [size="5"]What next?
    
    In the two articles, we have studied an adaptation of the Finite Element Method. This adaptation brings about more interactivity in video games. However, you have perhaps guessed that this method is trickier than springs systems usually used.
    
    If you are interested in the FEM and its possible uses in real-time solutions, this article and the Hyperion project are good starting points. However, they do not provide any mathematical formulation because I wanted to focus on the adaptation of the FEM and not on the FEM itself. This method is a broad subject offering a lot of optimizations. Consequently, learning theory is the compulsory step to master the method.
    
    In the third and last article, I am going to summarize drawbacks and advantages of this method and also to present how is it possible to implement the method at (relatively) low cost.
    
    Don't hesitate to give me some feedback about this article by email at [email="pierre_rebours@yahoo.com"]pierre_rebours@yahoo.com[/email].