specialization

Why?

My primary role thus far as a developer has been asset management, tools and animation. I have chosen to make an FBX importer as my specialization to have full control over every step from asset file to GPU buffer.

This enables me to more easily troubleshot assets as well as giving relevant errors and warnings to the art and animation team.

My goal is to remove any pipeline limitations and use the time otherwise spent on debugging faulty assets to further bringing our games vision to life!

Goal

Import meshes and animations from FBX-files, extract relevant information and convert to engine data structure. Improve pipeline efficiency.

Project Info

Team Size: 1

Duration: 7 Weeks

Engine: BGGE (Custom Engine)

Language: C++

Preprod

Duration: 1 week

Time: 10 hrs

Goal: Create a feature list to satisfy our engines needs and break it down in to smaller tasks. There after, begin sprint planning sorting the tasks by importance and implementation order.

Feature list

  • Import mesh vertices and indices.

  • Get vertex normal, UV, tangent and color.

  • Combine mesh-nodes in to singular mesh with multiple elements.

  • Divide elements based on material, one for each material.

  • Remove duplicate vertices.

  • Import LOD-groups.

  • Import skeleton, animation, bind-pose and skin-weights.

  • Add relevant errors and warnings

Assumptions

As our team already had an established pipeline it was agreed that every FBX-file would only contains one asset and be treated as such during import.

I therefore knew that all mesh-nodes were to be combined and imported as a single mesh with multiple elements, one for each material slot. Further more this means only one skeleton, LOD-group and animation is to be present in the file.

Data structure & Interface

Sprint 1 : “ Hello world”

Duration: 2 weeks

Time: 40 hrs

Goal: User can import a static mesh from FBX-file with one material and relevant vertex data.

Tasks

  • Scene: An FBX-scene can be loaded and initialized with correct metrics.

  • Mesh: Relevant nodes can be extracted from FBX-scene. A vertex and index list can be extracted from mesh-nodes.

  • Vertex elements: Vertex normal, tangent, UV and color is imported.

Scene

After setting up the project I begin with creating a workspace through witch I can import the file as a scene. The workspace is responsible for an FBX-manager, a geometry-converter and the axis-system.

To import the scene I followed Your first FBX SDK program.

I then prepare the scene for use, using my workspace to convert the system units to engine format (cm), remove bad polygons, triangulate meshes and convert to correct axis system.

Mesh

To get the mesh nodes, I recursively search the node tree from the root and compare their attributes.

For each mesh node I then extract the vertex positions by getting control points at each polygon index, incrementing the index list accordingly

Vertex elements

To extract vertex elements I first had to determine its polygon and control point index as it can be stored be eighter.

I then get the mesh element list and extract by storage method.

Sprint 2 : Meshes

Duration: 2 weeks

Time: 40 hrs

Goal: User can import skeletal meshes and LOD groups with multiple materials. Duplicate vertices are removed.

Tasks

  • Materials: Mesh is divided int to multiple elements, one per material and material slots are assigned.

  • LOD groups: LOD groups can be imported.

  • Skeleton: Mesh skeleton and bind-pose is imported.

  • Skin weights: Vertex contains skin-weight data.

  • Duplicate vertices: Duplicate vertices are removed and indices remapped.

Materials

To divide meshes by material I run the prior steps for each material. First I compare the material index with the scene material list to determine the elements scene material index. Then, for each polygon I compare its material with the scene material index to determine whether it is part of the same element.

LOD groups

Extracting LODs proved simple as it is imported the same way as meshes after being broken down in to individual nodes and then getting the display level threshold.

Skeleton

After getting the skeleton root node from the scene I recursively go through each child. If it has a skeleton attribute I Add it to the my list of joints, updating name, parent and and the name to index map accordingly. For each child, its index is added to the parents children. As for the bindpose, I evaluate the inverse of all joints local transforms as I add them.

Skin weights

Mapping skin-weights to vertices was done by first getting the mesh node deformer by skin type. Then, for each cluster and each of their indices I get their weight by control point index and map it to their corresponding boneID by comparing the skeletons joint to name map and the clusters node name. The control point index was then mapped to it’s bone weights. As I get vertex elements the index is compared with the bone weight map to assign skin-weight properties.

Duplicate vertices

To remove duplicated vertices I bind a vertex hash to it’s corresponding index. If the map contains a hash I replace the index list value with the map value and discard the vertex.

Sprint 3 : Animations

Duration: 2 weeks

Time: 40 hrs

Goal: User can import animations. FBX-Importer is feature complete and integrated in our engine.

Tasks

  • Animations: Every frame in the imported animation contains a transform for each joint. Animation has correct duration and fps.

  • Integration: FBX-Importer is integrated in the engine. All FBX-assets from the art and animation team are supported.

Animations

I begin by importing a scene and its skeleton as I did with meshes. Then I get the scene animation stack and the global time mode.

The fps and duration is evaluated by the animation stacks local timespan. With fps and duration I can calculate the number of frames.

To get the frame transforms and map them to the correct joint I first need to get the animation clips start and end time. Thereafter I can loop through each frame, setting the time frame and getting the scene node corresponding to each joint. The transform is then evaluated by the nodes local transform at said timestamp.

Integration

As I integrated the importer to our engine I was presented by a few issues for certain skeletal meshes.

Some assets had miss-matched namespaces in the animation and mesh files. To fix this I remap the joints to the stem substring.

Some files also had mismatched translation offsets in the root bone. A fix is being worked on and a warning has been added during import.

Conclusion

After successfully implementing the desired features I have learnt a lot about how to interact with large and complex data structures. I also feel more qualified helping the team with asset related issues.

I wish I had spent more time exploring the FBX-interface before committing to a full implementation. Having more in-depth knowledge would have eliminated a lot of trial and error.

Looking forward I need to expand on the documentation and refine the logs to be more easily understandable by our artists, with examples of what might have gone wrong and how to fix it themselves.