• defining custom targets
• add in example for usd overrides from issue
• how code target resolve works for impls which are graphs vs source code or C++
• PR to fix resolves for issue. Under review. Fixed problem for logger.

[] Geo reosolvers, including usd primvars
[] file name revolvers. E.g usage in Arnold, Mel / omniverse
[] object path resolvers

• V10 is an API break for rendering graphs.
• This is a placeholder to update dynamic graph rendering using the V10 API.
• For now V9 is being specified on module import by specify 'mermard@9' for the distro.

See: https://github.com/mermaid-js/mermaid/blob/develop/CHANGELOG.md#mermaidrender-is-async-and-doesnt-accept-callbacks for more info.

• (ASWF WIP)[https://github.com/AcademySoftwareFoundation/MaterialX/pull/1303]
• formalize source code utilities
  • std lib files
  • std lib impl generation
  • extend mxdefinition.py to include source code impl support.

• initial json schema for node graphs ( for Gltf proposal )
• additional attributes such as units, cm, and graph positioning
• usd graph wrapping?
• mtlx to json and back to mltkx round trip — required ?
• baking vs graphs wrapping
• cm node wrapping
• data validation tests

A common core utility to be able to sample any type of output with a root material.
WIP generation and rendering testing part of this. kwokcb/MaterialX#36

[ ] New convert definitions to convert from type X to material (written, to review)
[ ] Python script to create and add in decorations
[ ] Add in matrix support
[x] Add in float, vec, color, BSDF, EDF, surface, volume support
[ ] Log issues with existing code gen (in progress)
[x] Code gen test GLSL
[x] Code gen test with OSL
[ ] Code gen test with MDL (tbd)
[x] Render test GLSL
[x] Render test with OSL
[ ] Render test with MDL (tbd)
[ ] PR for definitions fix and code gen fixes (in branch, not in ASWF)

• Done. Under review.
• To separate out connection code into nodegraphs + nodes + connections book.

On-going

• topological value changes. In 1.38.8
• publishing interface changes. In review for 1.38.9
• Web viewer updates.
  • Uniform Performance. 1.38.9
  • UI revamp. 1.38.9
  • [] Drag and Drop
    • Geometry D&D. 1.38.9
    • Fix single file texture D&D. Maybe 1.38.9 or 1.39
• target implementation resolve. 1.38.8

Back-logged

• downstream traversal
• nested nodegraphs

• Save copy of 1.38.8 library
• Add definition comparison to definition doc generation (so can tag what version a definition was introduced in)

Add in

• typedefs
• geompropdefs
• unit and unittype.
• colorspace. Need to add in different impls for each target. GLSL is done.

Setup Workflow

• Python USD setup
• Basic USD shader graph traversal

Export Workflow

• Export from USD to MTLX
• Codegen

Synchronizing USD and MTLX

• Basic value edit

• Topological edit

• USD Material encapsulation with shared shader / graph reference vs non-encapsulate MaterialX approach.

• Import MTLX to USD (without UsdMtlx Python support)

• More attributes

• More Examples

• Boostrap update
  • Dark / light mode update
  • Dark / light mode detection

GraphIO support for diagram generation.

[ ] Address Nick P. reuse issues. (Need to be totally string based args ?)
[x] GraphIO Mermaid and dot graph generation up.
[x] Fixes for issues found in definitions up.

AcademySoftwareFoundation/MaterialX#1188

Current notebook / tutorial indicates this is not supported yet.
Add in 1.38.7 version for which it is supported now.

• Basic renderer setup for GLSL
• OSL renderer setup
• MSL renderer setup
• Extract into mxrender.py
• Creating "renderable" graphs roots (using convert*)
• Handling topological changes.
  • "Hashing" / Shader dictionary
• Log issues with core API (missing wrapper so far, but also fixing direct paths to interface inputs vs interior inputs as no one will ever figure out you need to do this.
• Full reflection model (e.g. to JSON)

• Go over basic code generation up to the point of producing code for a given language.
• Use generateshader.py as source material.
• Thought: check in a version of this with Jupyter comments (annotations).

Basics for creating nodegraphs including:

• instantiating a graph,
• creating input and output
  interfaces
• creating nodes
• connecting nodes to each other and to the interfaces.

Connecting with a root of a surface shader within the graph and to a surface material outside:

• Output mermaid graph
• Output render image

• Initial JSON test using 3rd party Python packages. xmltodict and sample schame
• Replicate MaterialJSON from branch ASWF proposal. Read and write done
• Initial write-up using serialization.
• JSON proposal issue on ASWF repo
• Python utilities extraction to mtlxutils

Change

• Add web previews / editing to UI per node
• Update core Web viewer
  • performance updates
  • editor updates
  • drag-drop updates
• JS module publishing. Core module now available as part of 1.38.9 release.
• Use MTLX JS for mermaid generation
• Use MTLX JS for shader preview and shader gen

• utility to compare elements at arbitrary level.
• log issue that built in function has incorrect compare for children
• compare libraries, nodefs and impls.
• compareVersions.py command and sample output.
• mtlxuitls utility (pull out MaterialXCompare class from command)

• Add 2D pipeline setup
• extract to show glTF distillation pipeline
  • including image swizzle graph for ORM.
• Possible USDz distillation pipeline
• Possible deferrred rendering pipeline

Plugin

• Added in mtlx<->gltf interop
• Added in mtlx xml->json interop
• Added in usd material text preview
• Added in gltf / json text preview
• Added in glTF QT widget

Core QuiltiX Updates

• Logged issue about incorrect type resolve for glTF
  • Added PR for fix - in-
• Small graph data integrity issues -- checked in.
• USD text preview -- checked in
• Logged issue about multi-output type not work.
  • PR for fix
    • in review and test Richard's changes. In progress

Plugin Writeup

• Basics of pipeline interop
• Incorporating Python packages
  • Github template repos
• "Plugin" design
• Graph handling + interop glTF/USD/MTLX
• Usage for glTF pipeline and editor.
  • glTF editor site V1

• Filter predicates in Python working now
• New conversion to material definitions added now
• Rebuild reference library to include MSL and any definition changes.
• Sync shader gen notebook to include new Metal support.
• TargetDef / TypeDef Python exposure usage

• Base file, graph manipulation / traversal (mtlxutil created)
• Utility in MTLX core PR for GraphIO ( Will use mxgraph for now instead of
  relying on core changes)
• Utility to inline source implementations
• Utillity to create definitions for source implementations (code in notebooks)
• Utility to generate material roots for sample.
  • [] Utility to render these using OSL, or other
• Utility to generate graphs based on input textures. (tooling be proposed by Mosha on TSC)
• Blender based utilities
  • SVG to MTLX / GLTF
  • Blender material to MTLX plug-in
  • Image to MTLX / GLTF

• OCIO 2.2 setup
• built in configs and colorspaces
• source code gen for glsl, osl, Mel
• Logged issue of missing osl in Python api (works in local build) AcademySoftwareFoundation/OpenColorIO#1820
• nodedefs and impl for source code logic
• stand alone utility to mxtlxuits package and sample command
• check on basic blocks progress (OCIO TSC)

Possible options:

• Show only OSL
• Show all

Note that there is a difference betweeen generating a reference and generating
the code for the function which has no current option for code gen.

• Look at LLMs for MaterialX development

• Short-term:

• Multi-language code generation. in progress
• Graph generation / remapping.
• schema generation (JSON graphs prototype for glTF mtlx discussions tried. And in book)
• Coding assist - CoPilot book done

• ... more to come ...

• Figure out how to host on Codespaces and Colab
• Create sample repo that can be used for both.
  - [x] Add additional cell for Colab specific setup
• Add video for Codespace usage. TBD

• Basic graph traversal
• Export to Mermaid example

Show grid 3x3 or 4x4 for matrix value inputs in node library UI.

• Pull useful parts about libraries, assets, publishing creation docs from 1.39 spec. Not required as in core github now.

For interactive editing, look at code spaces

Something akin to this

• Test with local Jupyter basics book
• Try pushing to Google Colab
• Investigate using Github codespaces instead. In progress.
• Encapsulate std lib inside Python module.
• Core support for PySide pip install. Help wanted to get this into ASWF build system and published ?
• Add pip install of MaterialX modules as part of Colab setup.

• Core publishing fix and base workflow in node editor (PR in review)
• Update existing library core update (spacing PR in review)
• 1.39 spec documentation re-review
• Doc: Identifier generation
• Doc: namespace, nodegraphs, versioning
• Doc: document strings
• Doc: comparisons with Houdini / Maya
• Source code approach vs functional graph approach
• creatematerial.py script (in progress)
• Doc: tokens and variants