LLM 3D Creation and Spatial Reasoning: A Zero-Shot Evaluation

    This article presents a zero-shot 3D modeling test that evaluates large language models on spatial reasoning, 3D project file generation, and Web 3D interaction. It examines the test design, the delivered 3D assets, the model’s structural accuracy and limitations, and the unexpected generation of an interactive HTML page with camera controls, scene annotations, and preset viewpoints. It also discusses potential applications in lightweight 3D visualization and the engineering challenges of precision, performance, concurrency, and business-logic integration.

    LLM 3D Creation and Spatial Reasoning: A Zero-Shot Evaluation

    Introduction: Extending LLM Capabilities Beyond Flat Information

    In recent years, the capability boundaries of large language models have continued to expand. From text understanding and generation and code completion, they have gradually extended to 3D space construction and complex spatial logic reasoning. The 3D creation capability of large models has recently become a core evaluation direction, marking a shift from understanding flat information to understanding three-dimensional space. This article is based on a real zero-shot 3D modeling test and analyzes the technical performance and application potential of large models in spatial reasoning, model generation, and Web 3D interaction.

    1. Technical Paths for 3D Creation and Spatial Reasoning

    In traditional development workflows, 3D modeling relies heavily on professional graphics software and underlying rendering engines. When large models are involved in 3D creation, there are two main paths:

    1. Direct generation of project files: The model understands natural language descriptions and directly generates 3D project files in standard formats. For example, it can assemble complex miniature scenes from basic geometric elements such as voxel blocks.
    2. Code generation based on WebGL: The model cannot directly render graphics, but its strength lies in writing code. By generating front-end code based on the WebGL standard, the model can use the browser to call local GPU resources for real-time 3D rendering and interaction.

    Spatial reasoning is the foundation of all of this. It determines whether the model can accurately understand physical spatial hierarchies and relative positions, such as “the first floor is below,” “the stairs are on the side,” and “the sign is on the wall.”

    2. Test Design and Prompt Construction

    To objectively evaluate the current 3D creation level of large models, this test used a set of bare prompts. No external plugins were attached, and no reference documents were provided. The test relied entirely on the model’s base capabilities for inference.

    Test objective: Build an architectural miniature scene with a multi-level structure.

    Scene element requirements:

    • First-floor commercial area, such as a restaurant or shop;
    • Second-floor main space, such as an office area;
    • Outdoor stairs on the side connecting the first and second floors;
    • Auxiliary decorative entities outside the scene, such as character models.

    Deliverable requirements: An editable 3D project file, two rendered PNG images from different viewpoints, and an interactive HTML file that can be opened directly in a browser.

    3. Deliverable Analysis: Spatial Reasoning and Model Construction Evaluation

    The model ultimately delivered a 3D project file and PNG renders. Judging from the structural fidelity of the static model, the model demonstrated reasonable spatial reasoning and basically reproduced the core architectural levels required by the test:

    1. Accurate macro structure: The positional relationships among the side stairs, the second-floor main space, and the first-floor auxiliary area were consistent with physical common sense. There was no clipping or spatial disorder.
    2. Missing details: The model omitted the sign element, which is the most distinctive part of the building appearance. This indicates that under bare-prompt conditions, the model focuses more on building the macro geometric structure and lacks the initiative to complete culturally or identity-related elements with strong visual associations.
    3. Abstract representation of irregular entities: The decorative entities around the scene, such as character models, had highly abstract geometric features and deviated from conventional human proportions and detail aesthetics. This shows that the current model is still limited by voxel or basic geometric representation when handling complex surfaces, organic forms, and concrete objects.

    4. Unexpected Gain: Technical Breakdown of Automated Web 3D Interaction

    The most notable outcome of this test was not the static model project file, but the interactive web page that the model generated autonomously. When the prompt only simply asked to “open the file in HTML,” the model proactively generated a set of code containing rich front-end interaction functions, demonstrating strong emergent business-logic capability.

    1. Basic 3D interaction control

    The generated web page natively supports mouse drag rotation, scroll wheel zoom, and auto-rotation control. At the technical level, this is implemented by instantiating a camera controller, listening for mouse events, and updating the camera coordinate system’s position and orientation vectors in real time.

    2. Scene annotation system

    The system automatically identified key parts of the model and added anchor annotations in 3D space. Users can see floating text labels in the 3D space. In scenarios such as digital twins, smart city sandboxes, and real estate visualization, this non-intrusive scene annotation is highly practical.

    3. Preset viewpoint focus

    The side function bar provides viewpoint switching and lists several core elements in the model. When an element is clicked, the camera smoothly transitions to a close-up view of that element. This function depends on the developer presetting multiple camera parameters for each element, including camera Position coordinates and Target point coordinates, and using linear interpolation to achieve dynamic viewpoint transitions.

    4. Asset integration and user experience loop

    The model not only rendered the 3D scene but also integrated the rendered image display and project file download entry into the same page. On the first page load, it triggered a UI prompt guiding users to drag the 3D model, forming a complete delivery loop with a good user experience.

    5. Application Scenarios and Engineering Challenges

    Based on the test results, the potential of large models in 3D visualization is beginning to emerge. For lightweight display projects such as real estate sandboxes, urban modeling, and smart campuses, using large models to quickly generate interactive 3D web pages can significantly reduce front-end engineering code-writing costs and shorten project delivery cycles.

    However, bringing this into large-scale production environments still faces challenges:

    • Balancing precision and performance: The geometry generated by the model often has a high polygon count or insufficiently optimized structure. Directly importing it into a large engine may cause rendering lag.
    • Concurrency and resource scheduling: High-frequency, large-batch 3D content generation places strict requirements on the model’s concurrent invocation quota and inference latency. Without strong underlying computing power and container platform support, it is difficult to support enterprise-grade industrial modeling needs.
    • Adaptation to complex business logic: The interactions generated by the current model are mostly generic templates. If enterprises need to connect actual business data, such as updating 3D scene states in real time through message queues, manual secondary development and interface integration are still required.

    6. Conclusion

    Large models have taken a solid step in 3D creation and spatial reasoning. In particular, their automatic generation of Web 3D interaction code demonstrates surprising business understanding and code organization capabilities. Although there is still room for improvement in detail fidelity and complex surface modeling, with algorithm iteration, optimization of spatial reasoning mechanisms, and the development of underlying computing platforms, large models will become an important productivity tool in the AIGC 3D field and reshape the future development paradigm of digital visualization.