AI-Assisted 3D Creation: Combining Parametric and Generative Modeling

In recent years, as the code generation capabilities of Large Language Models (LLMs) have continued to improve, “natural language-driven 3D creation” is transitioning from a conceptual demo to a reusable engineering practice. A qualified AI-assisted 3D workflow must not only generate models that “look right” but also produce structured, interactive, and performance-controllable 3D scenes. Starting from technical principles, this article systematically outlines the core methods and implementation essentials of this workflow.

1. Why LLMs Can Do 3D: Geometry is Code

The prerequisite for understanding how LLMs can take over 3D creation is understanding the essence of modern 3D content: whether it is a 3D scene in a web page, a CAD model of a mechanical part, or a character and level in a game, it ultimately boils down to structured data and code. Geometry is described by parameters and mathematical curves, materials are expressed via shader parameters, lights and cameras are defined by coordinates and properties, and animations are generated by keyframe interpolation on a timeline.

This means that as long as a model can stably output well-structured code or declarative descriptions, it can drive the entire 3D pipeline. Common forms in practice include:

• Scene Description Code: Writing scene graphs, entity hierarchies, and material/light configurations using general-purpose programming languages.
• Parametric Geometry Programs: Using mathematical functions to describe cross-sections, lofting paths, surfaces of revolution, and boolean operations to generate precise geometry.
• Declarative Asset Files: Describing meshes, node hierarchies, and animations in universal 3D formats for easy reuse on the rendering side.

Compared to “directly generating a model file,” a code-based approach has natural advantages: the geometric source is traceable, parameters are modifiable, errors are locatable, and it facilitates team collaboration and version control.

2. Two Complementary Technical Routes: Parametric and Generative Modeling

Currently, there are two primary complementary ways AI participates in 3D modeling, each suited to different objects. Choosing the right route often determines the final quality more than writing flashy prompts.

1. Parametric Modeling: Precise, Controllable, Reproducible

Parametric modeling uses programs and mathematical constraints to describe geometry, making it suitable for objects with strict requirements for dimensions, symmetry, and assembly relationships:

• Mechanical Parts and Industrial Products: Outer shells can be controlled via cross-section lofts or curved surfaces. Solids of revolution like gears and tires are generated by rotating a cross-section. Buttons, screws, and connectors are modeled individually and then assembled. Part hierarchies, tolerances, and symmetries can be precisely controlled.
• Regular Architectural Components: Floor heights, bays, door/window openings, and curtain wall divisions can all be parameterized. Adjusting a single value updates the entire structure globally.
• Hard-surface Objects like Home Appliances and Vehicles: Contour curves, fillets, and parting lines can be explicitly defined, making modification costs extremely low.

Example code (Parametric Gear):

function createGear({ teeth = 16, module = 2, thickness = 8 }) {
  const pitch = module * teeth / 2;                     // Pitch circle radius
  const profile = involuteToothProfile(teeth, module);  // Involute tooth profile
  const body = revolve(profile, thickness);             // Revolve and extrude into a solid
  const part = cutCylinder(body, pitch * 0.2);          // Boolean subtract for shaft hole
  return applyMaterial(part, { metalness: 0.85, roughness: 0.3 });
}

Once this code is generated by an LLM, all dimensions become adjustable parameters: change the number of teeth, module, or thickness, and simply re-run the script without needing to redraw the model.

2. Generative Modeling: Organic Forms and Atmospheric Assets

Generative modeling uses neural networks to directly generate meshes, textures, or point clouds, making it suitable for objects difficult to describe with parameters:

• Organic shapes like characters, creatures, and sculptures;
• Naturally scattered objects like rocks, vegetation, and ruins;
• Rapid drafts and style exploration during the concept design phase.

The precision and topology of generative results are usually less controllable than parametric methods. Therefore, they often serve as “asset providers,” entering the formal scene after simplification, retopology, and UV unwrapping.

3. Division of Labor Principle

A practical rule of thumb is: If it can be clearly defined by dimensions and constraints, use parametric modeling; if it relies on visual appeal and atmosphere, use generative modeling, followed by manual or procedural corrections. Combining the two ensures both precision and expressiveness.

3. Implementation Breakdown of Typical Scenarios

1. Interactive 3D Web Pages

The core of web-based 3D is “Scene Graph + Render Loop + Interaction Events.” To get LLMs to produce high-quality web 3D, the key is to break down requirements into explicit constraints:

• Define Theme and Composition: What is the main subject, where is the initial camera position, and which details need focus.
• Define Performance Budget: Triangle count limits, texture resolutions, and whether real-time shadows and post-processing are needed.
• Define Interaction List: Drag-to-rotate, scroll-to-zoom, click-to-pick, hover-to-highlight, etc., listed item by item.

A simple interaction registration example:

scene.onPointerDown = (hit) => {
  if (hit.object.userData.selectable) {
    highlight(hit.object);
    panel.show(hit.object.userData.info);
  }
};

2. Mechanical Parts and Assemblies

A “skeleton first, details later” generation strategy is recommended. First, have the model output a parts list and assembly relationships (what parts exist, how they fit, where the datum planes are). Then generate individual part geometries, and finally assemble them and perform interference checks. Organizing assembly relationships into a hierarchical structure ensures that modifying a single part later won’t affect the entire model.

3. Architectural Scenes

Use parametric modeling for regular parts (floors, column grids, curtain walls, railings) and generative modeling for atmospheric elements (surrounding terrain, vegetation, sky). Add environmental lighting and a camera path to quickly achieve a compelling architectural walkthrough. Parameters like floors and bays should be centralized in a configuration object for unified management:

const config = { floors: 6, floorHeight: 3.6, bayWidth: 8.4, curtainWallDivs: 12 };

4. Mini-Game Demos and Dynamic Presentations

For mini-game demos, the focus is a “minimum playable loop”: a controllable character, an objective, and a fail condition. Get this running before expanding. Cinematics and dynamic presentations rely on a timeline system: orchestrating keyframes, easing curves, and depth-of-field changes for the camera, combined with post-processing color grading, yields far greater visual impact than static displays.

4. Engineering Methods for Stable Outputs

1. Write “Specifications” in Prompts, Not “Feelings”. Descriptions like “make a cool scene” carry too little information. A more effective approach is providing verifiable specifications: object lists, dimension units, style keywords, performance limits, and interaction lists. The more explicit the spec, the more convergent the model’s output.
2. Iterate in Phases, Control Single-Generation Scale. Recommended workflow: Requirement breakdown -> Scene skeleton (empty scene + camera + lights) -> Main geometry -> Materials and lighting -> Interaction -> Optimization. Producing a runnable result at each phase allows quick localization of which step introduced an error.
3. Modularization and Configuration. Separate geometry generation, material libraries, camera controls, and interaction logic into independent modules with centralized parameter management. This ensures that neither manual edits nor further model iterations break the overall structure.
4. Establish an Acceptance Checklist. At the geometry level, check normal directions, mesh intersections, and unit/coordinate consistency. At the rendering level, check exposure, color gamut, and shadow quality. At the performance level, check frame rate, VRAM usage, and load times. A checklist-based acceptance significantly reduces issues where things “look right but crash when running.”

5. Performance and Experience Optimization Essentials

• Mesh and Draw Call Merging: Combine geometry for static objects to reduce draw call counts.
• Level of Detail (LOD): Use low-poly models for distant objects and dynamically switch based on camera distance.
• Texture Management: Load on demand, use compressed texture formats, and reasonably reuse material instances.
• On-Demand Rendering: Lower the frame rate or pause the render loop when there is no interaction; this yields significant benefits on mobile devices.
• Asset Hosting and Deployment: 3D resources are typically large in size. In practice, static assets are often hosted using object storage and Content Delivery Networks (CDNs) paired with browser caching strategies to optimize first-screen loading. For team collaboration or offline rendering pipelines, general-purpose container platforms and GPU computing resources can be used for deployment and scheduling.

6. Common Issues and Mitigation

• Normal Errors and Broken Meshes: Mostly caused by boolean operations or cross-section directions. Perform a unified normal repair after generation.
• Inconsistent Coordinates and Units: Agree on the same units and up-direction between the modeling and rendering ends. Normalize before assembly.
• Z-fighting: Add micro-offsets to coplanar geometry or adjust depth buffer precision.
• “Runnable but Hard to Modify” Generated Code: Require modularity, comments, and constant extraction directly in the prompt to ensure maintainability from the source.

7. Conclusion

The value of AI-assisted 3D creation lies not in “generating everything with a single sentence,” but in freeing developers from repetitive modeling labor. Parametric modeling ensures precision and controllability, generative modeling provides form and atmosphere, and engineered workflows with acceptance standards guarantee stable quality. By mastering the methodology of “dividing labor between two routes + specification-driven prompts + phased iteration,” developers can efficiently deliver high-quality, controllable outputs across web 3D, industrial parts, architectural walkthroughs, and game prototypes.