TL;DR
This paper introduces "model graphs," a novel visual programming language that integrates the strengths of previous procedural modeling systems. It allows for efficient, interactive creation of complex 3D models like buildings and landscapes by combining visual dataflow principles with a more intuitive, infix-notation-based approach to defining operations and variables.
What Problem Does This Paper Address?
Procedural modeling, the algorithmic creation of 3D content, offers significant advantages in terms of data amplification and control over detail. However, existing systems often fall short in one or more areas: they can be difficult to learn (e.g., L-systems, shape grammars), lack interactivity (e.g., pure scripting), or are specialized for specific domains (e.g., Xfrog for plants). The authors identify a need for a unified system that combines the ease of use of visual tools, the expressiveness of programming languages, and the interactivity of direct manipulation, without the drawbacks of compilation or complex syntax.
Methods
The core contribution is the model graph system. Unlike traditional visual dataflow pipelines (VDFPs) where edges represent data flow, model graphs use directed edges to define the order of execution. This allows for a more direct representation of control flow and avoids the need for explicit data pipelines.
Key features of model graphs include:
- Nodes: Wrap operations, similar to VDFPs.
- Edges: Define execution order, not data transport.
- Variables: Support for named variables, arrays, and records, allowing for state management and complex computations.
- Infix Notation: Formulas can be entered in a familiar infix style, making them more readable and easier to write than postfix notations.
- Gizmos: Interactive handles in the viewport that allow direct manipulation of model parameters, providing immediate visual feedback.
- Modularization: Model graphs can be called as subroutines (using
CallOperator), enabling the creation of reusable components and complex hierarchies. - Specialized Components: A library of nodes for creating geometry (e.g.,
CubeComponent,CylinderComponent,SphereComponent) and textures (TextureFile,RoughTextureGenerator,ProceduralTextureGenerator). - Control Flow: Operators like
ForOperator,WhileOperator, andComparatorprovide intuitive ways to implement loops and conditional logic.
The system translates these model graphs into scene graphs for rendering, aiming for efficient execution on multicore processors.
Datasets
Not discussed in the paper. The paper focuses on the system's methodology and demonstrates its capabilities with examples of trees, buildings, and landscapes, but does not refer to specific datasets for training or evaluation.
Key Insights and Ideas
- Execution Order vs. Data Flow: The fundamental insight is that using edges to define execution order, rather than data flow, simplifies the representation of procedural models and aligns better with how users think about sequences of operations.
- Bridging the Gap: Model graphs successfully integrate features from diverse procedural modeling approaches (grammars, VDFPs, scripting, direct manipulation) into a single, coherent system.
- Interactive Proceduralism: The inclusion of "gizmos" is crucial, enabling direct, interactive editing of procedural models in the viewport, which significantly enhances usability.
- Intuitive Formula Entry: Supporting infix notation for formulas makes the system more accessible to users familiar with standard programming languages.
- Performance Potential: By using a heap for variables and a more explicit execution order, model graphs can achieve better performance and require less synchronization for parallel execution compared to traditional VDFPs.
Key Results
The paper demonstrates the system's versatility through examples:
- Trees: Modeled using a recursive technique similar to Oppenheimer's [1986], showcasing the system's ability to handle recursion and texture application.
- Buildings: A sketch-system for buildings is presented, allowing interactive editing of roofs and facades using gizmos. The system computes roof geometry and facades based on user-defined points.
- Landscapes: A "SlopingHills" model graph generates heightfields for mountain ranges, demonstrating the system's capacity for complex terrain generation.
The authors report geometry creation times of approximately 27 seconds (single thread) and 17 seconds (multi-thread) for a scene with over 800,000 polygons, indicating reasonable performance.
Limitations and Future Work
Limitations:
- Interpreted Language: Model graphs are currently an interpreted language, which limits their performance compared to compiled applications.
- Limited Viewport Display: While gizmos provide interactivity, the direct editing of the model graph itself in the viewport is limited.
Future Work:
- Just-in-Time Compilation: To overcome performance limitations, the authors suggest exploring just-in-time compilation or exporting model graphs to C++ code.
- Improved Interface: Enhancing the viewport interface to allow more direct editing of the model graph and automatic reflection of changes.
- Integration of Tool Pipelines: Integrating existing tool pipelines (e.g., for city modeling) into the model graph environment to reduce data exchange overhead.
- Expanded Operator Library: Developing operators for more advanced procedural modeling techniques like Euler operators, CSG, NURBS, subdivision surfaces, and hardware shading.
- Visual L-Systems: Exploring the possibility of creating visual L-systems by recording editing steps within model graphs.
- Game Development: Leveraging the system for producing portable games due to its platform support (Windows, Linux).
Summary updated