Hello,
Thank you for your interest in Creature!
I will give you clear cut transparent answers ( I like to be straightforward about things ):
1) First, I will direct your attention to Meshbone.cs:
https://github.com/kestrelm/Creature_Mo ... eshBone.cs
This is the core of the skeletal posing engine for the Creature runtimes ( all runtimes share very similar structures, albeit C#, C++, JS, Java etc. )
There is a class called MeshRenderComposition. It has a list: public List<MeshRenderRegion> regions, this contains the regions data structures in the rest pose. All regions index into a global point pool. You will notice each region has a start and end index that determines its range in the global point pool. The reason to do this is to ensure efficient final rendering ( so only a single draw call is required to render the entire character )
What you want is probably the final posed points of the regions with the animated bones. Have a look at CreatureModule.cs:
https://github.com/kestrelm/Creature_Mo ... eModule.cs
In particular, look for the method PoseCreature() and the lines:
Code: Select all
for(int j = 0; j < cur_regions.Count; j++) {
MeshBoneUtil.MeshRenderRegion cur_region = cur_regions[j];
int cur_pt_index = cur_region.getStartPtIndex();
cur_region.poseFinalPts(ref target_pts,
cur_pt_index * 3,
ref cur_bones);
// add in z offsets for different regions
for(int k = cur_region.getStartPtIndex() * 3;
k <= cur_region.getEndPtIndex() * 3;
k+=3)
{
target_pts[k + 2] = j * region_offsets_z;
}
Notice how the loop goes through each region and writes into the global target_pts pool array. So you can follow the same pattern to extract points from target_pts for each region.
Take note however that because everything in Creature is a mesh and deforms, you might have deforming polygons per frame. You can probably fit a proxy polygon for those points if you want to and align it to the target region pts based on its closest rigid transform.
2) The ability to do event triggers was just added in the latest update of the Creature Editor. However, right now the currently supported engines are Unity and UE4 ( the 2 biggest users of Creature )
Having said that, it's not difficult to get the events code working in Monogame since the Unity and Monogame runtimes are quite similar.
There is a class in:
https://github.com/kestrelm/Creature_Un ... eModule.cs
called CreatureMetaData. This is a generic class ( just basic C# ) that stores layer ordering and events.
The method BuildCreatureMetaData() actually builds the required data for events based on an input JSON dictionary.
After that, the actual callback trigger mechanism exists in:
https://github.com/kestrelm/Creature_Un ... troller.cs
Again, a general C# class called CreatureFrameCallback handles the callback work.
There are additional functions BuildFrameCallbacks(), ResetFrameCallbacks() and ProcessFrameCallbacks() that handle the rest of the actual trigger mechanisms. The callbacks are just based off C# events and notifications.
3) Again there is but this is currently for the Unity C# runtimes:
http://www.kestrelmoon.com/creaturedocs ... times.html
There is a method called SetActiveItemSwap to do the swapping of sprites manually for a region.
4) Yes so layer ordering is the same thing as events, as in it is supported in the meta data structure in the unity runtimes.
5) Sorry, motors are authored in the editor but it bakes out raw keyframes ( to speed up processing ) in the actual runtimes. In the future we might consider real-time motor runtime support.
6) Actually yes if you don't mind writing your own renderer. As you mentioned before, the C# runtimes give you all the data structures needed to represent a fully deforming skinnable character.
It has a set of bones and regions that index into a global point pool. The default renderer in the name of efficiency renders the entire character in one single draw call.
However, you can easily change this to not do it and assign a shader per region if you want to.
Have a look at the default monogame C# Renderer:
https://github.com/kestrelm/Creature_Mo ... enderer.cs
You should follow the same pattern of iterating through each region, and render a mesh with indices pointing into that region. You can assign a different shader for every region you care about.
Cheers
