[epolanski]

I see lots of off topic comments, but I'd like to ask as someone who played with fbx and similar formats supported by Autodesk and large parts of the gaming/CG industry what does OpenUSD provides exactly over different formats.

I feel like there's never been a 3D counterpart to standards like Midi for audio.

[jsheard]

For one the reference implementation of USD is open source, unlike FBX where you have to depend on Autodesks binary blobs and are at the mercy of whatever jankiness comes with them. Such as the fact that the FBX SDK still isn't thread safe in TYOOL 2023 so you have to take a global lock whenever you touch it.

Even Autodesk is backing USD so presumably even they have given up on the long term prospects of FBX.

[OmarShehata]

What about glTF?

[jms55]

glTF is actually pretty good. It just's fairly minimal and lacks support for an entire scene description, lacking important features such as LODs.

Coincidentally, I help develop the Bevy game engine, and I was just talking to people about working on a bevy_usd library. From what they told me, USD is extremely complicated, and the "spec" is basically just the C++ source code. I was warned not to bother. Imo it would be better if glTF just got more support and extensions.

[kevthecoder]

Yeah, working with OpenUSD in Rust is difficult. There's been a bit of work on Rust bindings but it's not ready at the moment (https://github.com/vfx-rs/usd-bind). I believe you need the c++ code base locally for the bindings, which adds an extra barrier for development.

A full Rust port of OpenUSD would be very ambitious. It's quite complicated (e.g. the OpenUSD composition rules) and depends on other vfx c++ libraries.

I've been experimenting with implementating a subset of OpenUSD in Rust, but there's lots of challenges given the original codebase. E.g. the c++ code uses lots of base classes, downcasting and there's no lifetime information. It's possible to port these across, but gets ugly in the details (e.g. trying to avoid non-static downcasting in Rust). It would take a lot of effort to do a total idiomatic rewrite given the size of the codebase and how interconnected the pieces are in OpenUSD. I still think it's worth pursuing though, OpenUSD is great.

[vvanders]

That gives me serious collada vibes. I've been out of the space for ~6 years but I recall that collada was the thing that was supposed to solve all of this, looks like it didn't really take off.

[dagmx]

Colada was really under specified and support was super fractured. It never really gained traction as a result outside of very specific pipelines

[kettlecorn]

This is the dark secret to USD: pretty much everyone is relying on the same massive C++ project!

Projects that want leaner dependencies, like everything on the web, don’t yet have a good way to work with USD.

[johnnyanmac]

>Projects that want leaner dependencies, like everything on the web

Did the web suddenly switch to WebASM overnight or do we have a different definition on "lean dependencies"? using any of the popular JS frameworks seems to bring in a few hundred dependencies alone.

[kettlecorn]

By lean I mean the OpenUSD Wasm binary is over 10mb, last I checked.

[pixelesque]

glTF is really single-asset only: that's not what USD is - USD is designed for entire scenes with scene graph hierarchy, and layers of overrides / additions (it's essentially a mini-evaluation engine internally). It's very powerful, but also quite complicated, and not just a file format.

USD started in the very complicated CG/VFX world where this type of complexity and flexibility is needed, however, Apple (and others) have been pushing it into other realms (VR, mobile, .usdz).

[johnnyanmac]

GLTF supports scene graphs. But given what domain creates and primarily uses it, most of its usage in projects will inevitably treat it as if it's an FBX substitute. We're still far from the days where Unity/Unreal Engine will export an entire scene into a hierarchy of gltf files with one master file to organize them.

[jsheard]

They serve different roles, glTF is intended to be an asset delivery format that aligns with how GPUs work so it can be loaded onto one with fairly minimal overhead. USD is intended to be an interchange format for moving assets between editors and renderers. They're kind of analogous to JPG/PNG and PSD respectively, if PSD were an open standard.

What Apple is doing with USD might have been better served by glTF, but glTF is a Khronos standard and Apple refuses to work with them for unspecified legal reasons.

[GeekyBear]

> glTF is a Khronos standard and Apple refuses to work with them

Given that Apple created OpenCL and handed it over to Khronos, this seems a bit off.

> OpenCL was initially developed by Apple Inc., which holds trademark rights, and refined into an initial proposal in collaboration with technical teams at AMD, IBM, Qualcomm, Intel, and Nvidia. Apple submitted this initial proposal to the Khronos Group.

https://en.wikipedia.org/wiki/OpenCL#History

Apple just has a long history of working with Pixar. I think they've been using Pixar's USD as the basis for their AR asset file format since 2018.

https://www.techrepublic.com/article/apples-usdz-ar-file-for...

[jsheard]

They used to work with Khronos but things have developed since 2008 - Apple has completely abandoned OpenCL and OpenGL, won't support Vulkan alongside Metal, and during the development of WebGPU one of their representatives let slip that there's a legal dispute blocking any further interaction between Apple and Khronos.

https://docs.google.com/document/d/1F6ns6I3zs-2JL_dT9hOkX_25...

> Apple is not comfortable working under Khronos IP framework, because of dispute between Apple Legal & Khronos which is private. Can’t talk about the substance of this dispute. Can’t make any statement for Apple to agree to Khronos IP framework.

Since the details of the dispute haven't come out it's unclear if it has been resolved yet, but regardless they don't seem to be on good terms.

[johnnyanmac]

Interesting. I thought it was simply a matter of Apple wanting full vertical integration of its hardware, as usual. Since all these rumblings really started rolling right before the M1 chip was announced. Didn't know those tensions evolved into a full on legal battle.

[GeekyBear]

Interesting. Thanks!

[slimsag]

glTF is not a very optimal runtime format, and IIRC it even started out originally with the statement that it was 'purely for interchanging models between programs' and that engines would/should still use their own format (hence the Transfer Format in the glTF name.)

Even GLB, the binary glTF format, is very sub-optimal for runtime. It even has chunks of JSON embedded in it.

[jsheard]

glTF wouldn't be my first choice for a runtime format but it's hard to see the intent behind it as anything but a runtime format, there's a very distinct mapping from glTF concepts to OpenGL concepts. The first version didn't even have a standard material definition, the asset just had an inlined GLSL shader to render it with. They even use the same enum values so that you can plug the values in the glTF file directly into an OpenGL call if you want to.

Marrying the format so closely to OpenGL is looking pretty dated now of course, with OpenGL/WebGL dead and buried by Vulkan/WebGPU. You can render glTF with Vulkan/WebGPU but the flexibility of the format and the newer APIs rigid pipeline layouts are at odds with each other - ideally you want the data to follow a consistent, rigid layout.

[pjmlp]

> OpenGL/WebGL dead and buried by Vulkan/WebGPU.

If only.

Vulkan requires everyone to be a driver writer before they can even think about drawing a triangle, while at the same time already beating OpenGL with spaghetti extensions at the rate it is getting new ones every month.

And it is only a GNU/Linux and Android thing anyway, not the main API on PlayStation, XBox, Apple, Windows and Switch.

WebGL took a decade to be fully adopted, WebGPU has at least another decade ahead of it until it becomes fully widespread, and even then it will be targeting 2015 hardware capabilities.

[erichocean]

> what does OpenUSD provides exactly over different formats

USD is to scene authoring what FBX is to 3D object authoring (though it also can do 3D object authoring).

USD adds complex shading, lighting and cameras, state-of-the-art multi-level instancing workflows, and most importantly, a very flexible way of referencing/layering assets and performing per-scene or per-shot overrides, plus tools (payloads) that enable extremely large scenes to be opened and authored in minutes instead of hours.

It really is pretty groundbreaking and has a ton of momentum.

The other hugely helpful component is USD has a very high-performance rendering architecture written in C++ called "Hydra" that allows for both interactive and non-interactive rendering backends to be developed and switched between at runtime. I can't think of a single commercial renderer that either hasn't already built a Hydra delegate, or isn't planning to.

[Keyframe]

Pretty much a next-gen RIB. FBX itself was always weird child ever since Kaydara days (untill bought by Autodesk).

[mrguyorama]

IMO the equivalent to Midi files in the 3D world is OBJ files. https://en.wikipedia.org/wiki/Wavefront_.obj_file

It's just a simple text file but it supports 3D objects and materials and is supported by pretty much everything. A complete novice can write code to generate it.