Day 46

Today Mr Douglas dropped by. I decided to only show him the method Mr Ron showed me yesterday as the previous methods weren't that good as the entire simulation takes too slow. Mr Douglas said the method used in this case was good and it makes the scene much faster. However, yesterday Mr Ron left the last part for me to find out as previously the final result turns out to be like that:

I decided to post it up on odforce to get some help regarding this, and thank god, someone replied and solved it for me.

http://forums.odforce.net/index.php?/topic/13202-vops-problem/page__gopid__82608&#entry82608

Now, I will document what exactly goes on in the file:

Firstly, the first fracture system is done using the usual way.

The difference starts with the first voronoi fracture node.

There is a option under the voronoi fracture node, attributes tab, called Keep Internal Attributes.

Mr Ron checked that, and under primitive piece, keyed in "piece"

What that does is it stores the data each piece has, and the scatter points will follow that set of data throughout the entire simulation

 After that, inside the dops.

I once asked Mr Ron if it is possible to trigger the fracturing without having any collisions. He said it was possible, and this is how it works,

He created random velocities to make the pieces fall apart differently.

The expression used was,

fit01(rand($OBJ),-1,1)*10 for Vx
fit01(rand($OBJ/2),-1,1)*10 for Vy
fit01(rand($OBJ+2),-1,1)*10 for Vz

What the expressions does is that, it takes a random value for the object and the value is then fit into a value range of -1 to 1. The multiplication is to increase the  overall velocity. While the division and addition of numbers to the object is to give it more variance.

At the end, this is how it looks:




Next, A timeshift node is used to lock the simulation at its first frame. Then a foreach node is used to add another layer of fracture points on the already pre-fractured piece. First, we need to make sure that the attribute piece needs to have point data so that the scatter points could reference that set of data. Hence, an attribute promote node is used to first convert the primitive data to detail. Then the scatter point is applied. After the scatter point, a attribute promote node is used to convert the detail data into point data. Then a voronoi fracture node is used at the end.





















Then, a dopimport node is used to bring back only the point data from the dops.

A vopsop is used to copy the geometry data onto the points.

A copy sop wasn't used because, firstly it is too slow and a copy sop aligns geometry based on normal positions.

The vopsop in this case, aligns the geometry based on a rotation matrix.

First, we create the parameter "piece", then the attributes orient and P(point position) is imported inside. The orient matrix is then converted into a quaternion matrix.( rotation matrix with a angle) It is then multiplied with the original point position and added to the calculated point position from the dops. The output looks like this:

After making sure it looks good, Mr Ron created new groups for each piece. First he removed all the groups using a clean node.

Then a connectivity node is used to connect similar attributes class and output a new attribute. Then a partition sop is used to create a new group based on the new attributes.

After that, We went into foreach again to create a point in the center of each secondary pre-fractured geometry piece.

What this does is, it adds a point in the center of each piece and then put the new point in a group. The node "attributecreate_piece" creates the "piece" attributes and then stamps the foreach data.

Then after that, he splits up the group, one of the point data, and the other for the geometry data.

For the points side, I brought it into a popnetwork. Everything else was the same as previous.

A group node is used to group the points after it reaches a certain value. For the particles that didn't reached the assigned values, It will be stored in a new group.

For those particles that didn't managed to reach the assigned values, a position node is used to calculate the original point position.

A force is used to drive the particles apart.

Mr Ron said that we needed the orient attribute to copy the geometry piece onto the point data. But the popnetwork doesn't have. It reads velocity and normals values first. As we needed the orient attribute, Mr Ron made one using a vopsop.

What it does inside is, He is normalising the point velocitiy attribute. Then what the lookat node does is, it reads the normals of the point velocity and outputs it in a 3 x 3 matrix. Then he converts it into a quaternion matrix, then the attribute "orient" is connected to it.

It works though, next step, to copy the geometry on to the particles point data.

It didn't really work at first though. But anyways, it looks like this:

It is the same vopsop that is used to copy the geometry to the points earlier. But the result turns out to be like that,

I posted on the forum and I was given help.

What was new inside:

The difference is, the new point position is subtracted with the original point position. And then it is multiplied with the calculated point position. The result turns out to be like this:

And the playblast simulation: