Destruction using Blast API

The project started by reading the documentation for the API and setting up the project.

The next step was setting up a Blast Asset class that would work as the main wrapper for handling Blast.

This was a process itself as i started by defining the data used to create the assets, as well as familiarizing myself with the API and Library. 

As i started to implement the wrapper i decided to use the High level TK(Toolkit) API instead of the Low Level one as it provides a better entry point to using blast, this also lead me to use the available authoring extensions to create the meshes and chunks. 

​

Using a mesh cleaner object and the "NvBlastExtAuthoringCreateMesh" method i created a Blast::Mesh i could assign it to a fracture tool. The next step was to generate fracture points inside the mesh for this i used the available Voronoi site generator to generate a number of fractures contained inside the mesh.

By doing this i was able to fracture any input mesh into usable chunks, the next step was to create the bonds connecting the chunks and actually create a TKAsset .
 

​This is the point were i encountered some major issues with the API and i will keep it short in this segment as they are discussed in more detail in the Issues section. 

​​

​The first one was that certain functions did not exist in the latest version of the API that existed in previous ones and they were still referenced in comments for functions. This was particularly in for the generation of bonds between chunks. ​

After this was successfully resolved I immediately encountered another issue that being that the function calls made through the API were not calling the correct function, this had to be resolved by recreating the function outside of the API thus giving more functionality for debugging but also more control. 

Once this was finally resolved i could generate geometry for the chunks to use this then  started the process of creating PhysX actors for the chunks and putting them i the scene. This was done by saving the calculated geometry for a assets chunks and passing it to create shape in PhysX and attaching the created shapes to a new actor representing the chunk. 

(A little note: I discovered is that PhysX does not do well with dynamic rigid body's with multiple shapes especially if they are large)

​

Now i had something that was visible and the next step was to actually damage the original mesh and have it split into its chunks. 

 

TKActors contain a damage function that takes a damage shader and arguments, these can be customized and you can create your own shaders as long as the function has the same signature. I decided to use the default radial shader to start with as it was the most intuitive way to think about it. As i was calling the damage function i had to define something that would listen to the callback events sent by it. I decided that to simplify the usage and debugging i would have each wrapper object listen to its own actors callbacks.

Next i implemented the necessary functions for catching the split event, all i had to do now was remove the PhysX actor of the actor that was split and add the PhysX actors corresponding to the chunks this was a relatively simple task as all the necessary data was available. A part of this was since the actor data sent for both the chunk being split and the chunks to be created contained a unique index we could easily store active PhysX actors in a unordered map to keep track of them.
 

At this point i added the manager to keep track of all of the Blast wrapper objects as well as to make it easier to apply damage on contact, as it contains a function with the same signature as the PhysX on contact callback, when called it checks the user data of the shape and with that being assigned to the index of the wrapper object we can now apply damage to the object. 

​

At this point i had run out of time to make any meaningful progress but when conversing with my mentor i still felt that the point i got to was satisfactory ​for the issues i encountered and the timespan of the project. Being able to use it as a starting point for further improvements also contributed to this sentiment.