This section gives an overview of some of the key features and capabilities of Creation.

Framework

Built on the Creation Core: Time constraints and production priorities mean in-house development cannot tackle hard problems such as advanced multithreading schedulers and just-in-time compilation of performance critical code. The Creation Core provides Creation Platform with its multi-threaded dependency graph, making it trivial for developers to leverage multiprocessor architectures. The Creation Core also provides many other advanced features such as the Map-Reduce computation model and dynamic, live code recompilation. Find out more >>

Source Access: Traditional in-studio development starts with canned 3D tools and bends them to their needs, usually by trying to manipulate opaque black boxes through the provided scripting language. This limits the range of possible approaches to a problem and also limits the range of problems that can be solved. Creation provides a full toolbox for creating custom 2D and 3D applications, along with full source code access – the only black box is the Creation Core multi-threading engine. As a result, development is easier, faster and results in high-performance tools that are tailored to production needs.

Graph Viewers: As complexity increases, visual programming approaches can be inefficient compared to written languages. Creation applications use code to author the graph description. However, building graphs with text-based languages becomes difficult without a way to visualize the resulting graph. Creation Platform brings the benefits of both approaches by providing a traditional text-based programming language with a graphical way to visualize what is being built.

Visual Profiler: Optimizing multithreaded applications is difficult as there many metrics that are important. For example, the total time taken by a function across processors is not the only key metric, as often you need to know what is being blocked by that function. The Visual Profiler displays data from Fabric Core’s profiling functionality to show an execution timeline of Fabric nodes across threads, which enables you to easily identify performance bottlenecks. The visual profiler provides a graphical timeline of activity on each thread, helping programmers identify precisely which operators are most worth optimizing. This creates faster code, which can allow artists to work with more complex assets.

Undo/Redo & Persistence: When building an application from scratch, writing proper undo/redo & persistence systems is trivial, long and tedious. Creation Platform provides a proper undo/redo & persistence framework that is easy to apply to your own code, letting you focus on the creative work that provides unique value to your studio. Development costs are reduced when applications are built on a stable foundation.

User Interface via Qt: Building UI widgets is tedious, trivial, and detracts from high-value work. Creation Platform uses the Qt widget library for its UI, which lets your programmers focus on the creative work that provides unique value to your studio. Development costs are reduced and all UIs are consistent across operating system platforms.

Full 3D Math Library: Implemented in both KL and Python, we provide a complete 3D-centric math library which lets you focus on the critical workflow and functionality.

Geometry

Polygon Meshes: Simpler geometry data structures used in scene graphs and game engines do not provide the richness required to build content creation tools. Creation Platform provides rich geometry data structures that can express polygon adjacency, edge & point sharing, bidirectional relationships between edges, points & polygons as well as topological characteristics. By providing the right data structures to operate on meshes, Creation can reduce development costs and offer more memory efficiency by eliminating the need to build sidecar data structures.

DCC Integration – Maya, Softimage

Developing within a DCC using its scripting language puts hard limits on the design, implementation and performance of custom tools. It also creates dependencies that make migrating to another DCC application difficult. Creation Platform provides deep integration into industry-leading DCC applications like Autodesk Maya. Geometry can be loaded directly from running applications and streamed into Creation Platform. This enables a real time connection between Fabric and the DCC application. Creation can also be used to render results directly back to the viewport of the application.

By enabling custom development inside a DCC, Creation Platform provides a level of independence from any particular DCC choice. Developing inside a DCC using Creation Platform can provide far superior performance than using the native functionality of the DCC. Developing with Creation significantly opens up the range of possible functionality for DCC extensions.

Find out more >>

Data

Extension system: Creation provides a rich extension system to support inclusion of existing libraries to support diverse requirements such as custom hardware integration, custom data types and simulation systems.

Supported formats: Creation provides wrappers to standard file format libraries as well as higher level interfaces that bring consistency to handling proper file formats. We have integrated over 20 different libraries, including:

2D: Ptex, EXR, JPEG, TIFF, PNG, TGA, HDR

3D: Alembic, OBJ, FBX, Lidar

Creation Platform comes with explorers for viewing Alembic and FBX data – our high performance scene loaders enable you to quickly load and view data in these standalone tools.

Mocap device integration: Building custom motion capture applications – for tasks such as virtual production – requires code that will supporting streaming and import of motion capture data, applying motion data to a skeleton, retargeting to a character and finally displaying the result. Creation Platform provides a consistent interface to motion capture devices, along with common code that serves as a foundation for a custom virtual production application. This allows developers to spend their time on building value and differentiation into their application, rather than wasting time reinventing the wheel.

Simulation

Bullet integration: The cost adding physics behaviour to a custom application may be prohibitive. Creation Platform provides an integration with Bullet Physics to easily run physics soft and rigid body simulations as part of your custom application. This makes it easy to add simulation as part of character or world behaviours. This can significantly reduce development costs and allows for features that would otherwise have been deemed too long to implement.

Muscle Simulation (offered as a Creation Module): Muscle simulation is a requirement for very high quality character and vfx work, but the cost of developing a custom solution is prohibitively high. Muscle solutions are computationally expensive and their performance often gets in the way of the creative process. Creation Platform provides a full-featured muscle system which is fully customizable and extendable; detailed muscle systems can be built, resulting in unmatched quality, using a high-performance implementation that lets artists build the complexity they need.

Unified Hair/Fur/Feathers Simulation (offered as a Creation Module):  Creation provides some sample hair simulation operators. Together with the DCC deep integrations (Maya) this will allow interactive Hair Simulation in KL drawn to an external application, or directly into DCC viewports. This sytem encompasses short and long hair, as well as fur and feathers.

Fluid Simulation: Fluids simulations are one of the most performance-hungry areas of 3D. A framework like Creation allows you to implement solvers quickly, with guaranteed performance under the hood.

Particles is an area we will focus on in 2013, but we already provide a few simple examples for you to work with. This SPH simulator was implemented in a couple of days without focusing on optimizations. It is only using CPU multi-threading, but already gives some impressive performance results (running on a consumer laptop).

We use the particle system as the basis of our 101 tutorial, which you can find here.

Real-time Rendering

Simple viewport rendering does not render scenes with enough fidelity for today’s production needs. Such fidelity is only available in game engines built around simple, hard-coded character rigs and other video-game specific assumptions. Writing a rendering engine from scratch is prohibitive in time and cost. Creation Platform provides a data-driven rendering architecture with both the fidelity and flexibility required for use on virtual sets and other real-time scenarios where performance and fidelity are critical. This leads to a higher keep rate on shots, less re-work, and a more fluid production.

Find out more >>

Motion Capture Retargeting

We have written extensions to enable Creation Platform to work with mocap data from Vicon and OptiTrack.

Animation

One of the areas we are focused on (given one of our founders invented CAT, this is hardly suprising!) is character animation. We believe that performance and workflow can only be improved by taking a different approach to rigging. By taking a different approach, we are enabling real-time animation workflows with heavyweight, complex characters.

Character Rigging Solvers: Traditional character animation tools impose limits on how rigs can be built; automatic floor snapping for toes, fingertip resting on objects, or partially physics-driven secondary bones are difficult, and sometimes impossible, to implement with a DCC tool’s scripting facilities. Creation provides a high-level solver library for character rigging: concepts such as “leg”, “arm and shoulder” or “spine” can be readily used and are built on top of more atomic IK, FK and raycasting functions.

Full Body IK: When retargeting motion capture to a character, poses performed by talent may make no sense on the CG character: a hand may not rest on the hip anymore, or two hands may no longer touch each other. Without full-body IK, these corrections have to be made on a case-by-case basis by an animator. Solvers in Creation can drive many parts of the skeleton at once. Full body solvers are particularly useful for retargeting motion capture data. With Creation, it’s possible to build sophisticated motion capture tools that perform real time retargeting of motion. Full body IK is a complex problem which requires a deep knowledge of character rigging and animation – Creation provides example full body solvers out of the box tools for building custom mocap tools.

Watch video >>

Manipulators: Addressing custom needs with in-house development involves a lot of tedious work, including 3D UI, scene manipulation and 3D picking. Creation Platform allows you to associate any drawn gizmo with Python event handlers. Any data can be manipulated by gizmos and the associated handlers. Using Creation Platform for in-studio development allows programmers to rapidly get to the core of the issue by using our high-level building blocks. This means in-house development for custom animation solutions is faster and becomes a viable option on more projects.

Keyframe Track Editor: Custom animation tools require a keyframe editor. The Creation track editor is built on qt and can be extended for your own needs.

Rigging overview: You can find an in-depth overview of the rigging paradigm here