Canvas: visual programming for Fabric Engine


#1

I’m really happy and proud to give you the first proper look at Canvas, our visual programming system for Fabric 2.0.

Quick highlight video:
[VIMEO]121492305[/VIMEO]

Tons more information here: Fabric Canvas

This is the first part of the FE2.0 plan, and we’ll be showing this in more detail at GTC on March 18th - please contact me if you want to meet up.

Looking forward to hearing what you have to say, and hopefully getting you on the alpha/beta when we open things up (there is a sign up form on the Canvas page).

Cheers,

Paul and the rest of the Fabric team


#2

This is what I have been waiting for! Coming from XSI, and being a programing simpleton, a node based environment is beyond welcome.


#3

I’m glad you like it, thanks for the kind words. We’re very excited to see what people get up to. If ICE is any indication, you guys will have a riot :slight_smile:


#4

Paul, 3 questions for you:

  1. Can Fabric Engine/Canvas be used as a standalone, all-purpose dataflow programming language? (Outside Maya et cetera) This is something the programming languages market sorely lacks right now - a good dataflow programming language that is as versatile as, say, Visual C#.

  2. Can it be used for (realtime/GPU) image or video processing? If yes, what image and video formats are currently supported?

  3. Can the result be compiled to a standalone executable file and distributed as software tool?

Thanks in advance,

  • Artsyboy

#5
  1. Can Fabric Engine/Canvas be used as a standalone, all-purpose dataflow programming language? (Outside Maya et cetera) This is something the programming languages market sorely lacks right now - a good dataflow programming language that is as versatile as, say, Visual C#.

Yes - that is part of the design. There is nothing graphics specific about the core of Fabric. Cut and paste of a comment I wrote elsewhere:

The Data Flow Graph that Canvas is built upon is written entirely in KL (Fabric’s language that enables us to hit the performance targets we set). What this means is that any node in the graph can be opened and edited directly - it’s all KL. This in turn means we were able to write a tool to automatically generate Canvas presets from existing KL code. It means that the preset library for Canvas is extremely rich, as we were able to go through 4 years of our own code to build it. (more info here: https://vimeo.com/121492304).

Where it gets a bit crazy: we have a tool (KL2EDK) that automates a lot of the wrapping process for C/C++ libraries and exposes them fully within KL. So with this new KL2DFG tool we can wrap a library and then generate a visual programming interface to it, and then run that within any host application (and our standalone). There are some very cool demos coming soon that show this in action.

  1. Can it be used for (realtime/GPU) image or video processing? If yes, what image and video formats are currently supported?

Yes - we are building a demo at the moment to show some of this. Here is a list of current extensions: Fabric Resources

It’s simple to extend Fabric to support additional data types. You can do this with Fabric 1.x - Canvas just introduces the new data flow graph and visual programming.

  1. Can the result be compiled to a standalone executable file and distributed as software tool?

We have a third party developer program that will go live soon with 2.0. This will enable you to build and deploy Fabric tools and applications (you can already freely distribute KL code of course - but this allows you to protect your code and provide it as a complete application). The business model is similar to Unreal/Unity etc, with OEM options if you want something more comprehensive.

Hope that helps,

Paul


#6

That looks awesome Paul. Quite interested in testing this out.

One question I have just from watching the videos, what kind of customizability do you have in the node editor? Can you group/color code nodes? Sticky notes support? Basically all the features Houdini has that makes working with the node editor such a joy in that program.

I would really love to have a bezier style option for connecting nodes because it is much easier to see the node flow at a glance compared to spline. ie:


#7

The node system is completely customizable - I think it’s a bit more challenging to do something like top down vs left/right, but you can certainly get in there and change things around. One thing we’re hoping to see is people sharing/showcasing these sorts of changes - the benefit of being 1) open and 2) free to individuals is that it should encourage more of a community. We will see :slight_smile:

Sign up is here: http://fabricengine.com/canvas-testing-program/


#8

correct me if im wrong. But this looks like Cinema4D’s xpresso, with the advantage of being cross platform, multi threaded and supporting GPU calculations.

And that is really awesome!

just doesnt look like there is c4d support yet…


#9

I would say it looks more like Houdini’s nodal system.


#10

Canvas is sitting on a data flow graph, so there are obviously similarities with many DCCs since it’s a common approach to take. We aren’t yet showing some of the key features of the Fabric data flow graph - but over the next few beta drops you will see what we’re doing. It’s very much our own take on visual programming as owning the language it’s authoring gives us some interesting opportunities. Obviously we have drawn upon a range of existing systems for inspiration (remember that most of our team worked on ICE), and we really like some of the innovation we’re seeing in places like Blueprint.

There is someone in the alpha group that was working on Splicing Fabric to C4D. I’m not sure if he’ll continue that project with 2.0 - I will try to find out. There are no dependencies on Fabric Software to integrate into other tools, we make the tools we use available to our users.

One of our testers posted this today (recreating an ICE graph they had built before):
[VIMEO]121620463[/VIMEO]

Cheers,

Paul


#11

Fabric Looks better and better ! Congrats for the hard work Guys !

Paul is there any idiot proof video / tutorials that could teach us how fabric could be use as a modular visual rigging system.

Basically can fabric represent a Maya sequence of python/mel command into visual node than can interact each other in order to build complex rig. Exactly what we have in houdini, but with the advantage of the user friendly UI of Maya for animators.

Just a small C&C is it possible to modify the color of the nodal UI into more grey / dark grey / neutral color ? :slight_smile:

cheers

E


#12

Hi Emmanuel - we have this project going on: Kraken OSS Rigging and the intent is to move that into Canvas. Pretty sure that’s what you’re after…

The Canvas UI is fully customizable. You’ll see elements change as we go through this testing cycle and get feedback on workflow and interface.

Thanks,

Paul


#13

That looks great Paul, but can we get closer to something like this with Fabric :
http://www.mikejutan.com/work/publications/index_files/BlockParty2_Siggraph2013.pdf

I mean for example you create your:

  • legs node which is a blackbox with a fancy icons that contain subnodes and connectors

  • this legs node is compose of subnodes like the one i see in your demo

  • each subnodes is compose of code that do basic operation

  • then you do the same for each part of the body

  • then you assemble your rig by connecting each independant part together

Then you can have a lib of

  • full char pattern
  • component of a char pattern
  • atomic fonction pattern
  • physics behavior pattern

Your system look to be able to achieve such stuff , but it would cool to see an idiot proof tutorial where you take a character and show us how the modular power of Fabric can be use by the average guys like us.

I see that nodes represent KL code, it looks that KL is sort of VEX equivalent instead of calling binding to C++ you use an easier language but with the exact same speed of C++.
This could really fasten thing i guess, and as your stuff looks also to use the GPU for fasten computation … it really start to make sense now ! :slight_smile:

To be honest fabric was kinda obsucur stuff to me from now ! But i do trust the wizardry power of softimage guys ! :slight_smile:

Cheers

E


#14

Hi there - thanks for the additional info. It’s important to note that Fabric is a platform, not a complete application. Our expectation is that other people will build tools like you describe and then make them available through our 3rd party developer program (similar to Unity/Unreal etc).

We’re focused on a few things:

  1. Performance (self-explanatory, but a good example is here:Double Negative and Fabric Engine
  2. Accessibility - making it easy for all technical levels of developer to build with Fabric. Obviously Canvas is a big step in that direction
  3. Portability - making it possible to run Fabric tools and applications within a wide range of other applications (commercial as well as custom) as well as in a standalone environment when it makes sense
  4. Extensibility - making it easy to add support (again, with no dependency on us) for custom data types, software libraries and hardware devices. A good example of that is our VR stuff from last year: Fabric for VR

All that to say, even with Canvas, we are still a developer platform. The goal of Fabric when we started was ‘make it possible for one or two TDs to build extreme powerful, specialised tools’. Now we’re getting there I think you’ll soon start seeing more artist-friendly Fabric tools becoming available.

Paul


#15

Thanks for all the information Paul !

I will have to read / watch / test Fabric, to understand exactly what can be done with it.

I haven’t read all the site yet, but from what i get

  • you have a set of very low level function code in C++ executed on the CPU/GPU

  • those function can be call directly in language call KL which offer native performance

  • those function can be call in 2 different place
    1> individually as a standalone tool
    2> inside a 3D package like Maya / XSI

  • those function can be call in 2 different form
    1> directly in code
    2> with a nodal UI

  • those function can be use with 3 languages
    1> Python = native perf call
    2> KL = native perf call
    3> C++ = core language

    What is still unclear is the content of those core function. do you have a place like this
    http://openframeworks.cc/documentation/

    Where we can i have a list of all the KL function classify by familly ( Math / OpenGL / Dynamics …)

    Sorry if i look like an idiot, but i swear , i have hard time to understand EXACTLY what i can do with Fabric. Having the ability to build agnostic rig outside of Maya and Houdini and then be able to get the same 2 rig generated in Maya and Houdini would be impressive !

    Cheers

    E


#16

Sorry, you’re a bit off the mark here :slight_smile:

There is no C++ involved. Our core execution engine is written in C++, but that’s not so relevant since you don’t ever do anything with that directly - it’s the bit we spend so much time working on so that your KL is highly optimised for LLVM to compile down to the runtime target. KL is not an interpreted language.

All of the information you’re after is available in our documentation: Fabric Docs

A list of current extensions is available here: Fabric Resources

You can also look through the Fabric Engine pages for lots of demos and additional information here: Fabric product pages

Sorry if i look like an idiot, but i swear , i have hard time to understand EXACTLY what i can do with Fabric. Having the ability to build agnostic rig outside of Maya and Houdini and then be able to get the same 2 rig generated in Maya and Houdini would be impressive !

It’s fine - Fabric is quite hard to explain, but we’re getting better at it! What you describe is exactly what some of our customers are doing. There is also this project: Kraken OSS Rigging

Cheers,

Paul


#17

My perception of FE is that it’s something like the Houdini Engine with the difference being that it lets you build your digital assets with native math nodes and low level code that executes automatically on GPU via KL.


#18

Thanks for the info Paul ! :slight_smile:


#19

Thought you might enjoy this one: image processing with Canvas using our GPU compute capability.

[VIMEO]122130309[/VIMEO]

"In this video we take a look at using Fabric Canvas for image processing. Since the KL language that underlies Canvas has full GPU support, we experimented with a continuous GPU pipeline for image processing. All nodes in the video (except for the file loaders) are live (not cached). This allows for interactive framerates on HD full float composites.

Numbers on the test machine

I7-3770k @ 3.5 GHZ, 16GB RAM
NVidia K5000

Shot1:
CPU: 1.42 FPS
GPU: 8.15 FPS

Shot2:
CPU: 9.4 FPS
GPU: 36.0 FPS"


#20

Hey Paul,
Great progress on the node based interface. I’m wondering, how much work would it be to create a timeline layer based widget (which could be linked to footage or keyframes, etc)? Is that something you’d be interested in adding to canvas?