3D Creation with Large Models: A Practical Test and Engineering Evaluation

    This article examines how general-purpose large models handle 3D creation and spatial reasoning through a bare-prompt voxel miniature landscape test. It reviews the delivered artifacts, the gap between structural modeling and thematic element recall, the unexpected gains in interactive web packaging, a layered evaluation framework, and engineering practices for treating model output as an editable first draft rather than a final deliverable.

    1. Test Background: Why 3D Creation Is Becoming a New Lens for Model Evaluation

    For some time, evaluation of general-purpose large models has focused mainly on text understanding, code generation, tool calling, and multi-turn dialogue. As editable 3D engineering, interactive web pages, and lightweight visualization delivery become more common, 3D creation and spatial reasoning are emerging as new dimensions for observation. Unlike pure text generation, which mainly tests language organization, or pure code generation, which mainly tests syntactic correctness, 3D creation involves structure planning, spatial relationships, asset organization, deliverable packaging, and interaction design at the same time.

    This article discusses general-purpose large models with 3D creation and spatial reasoning capabilities. It does not recommend or rank specific products. More precisely, it attempts to answer a general technical question: when developers provide only a bare prompt, what can a large model deliver in a 3D miniature landscape task, what is it likely to miss, how can its engineering usability be evaluated, and how can a demonstration experience be turned into a reusable evaluation method?

    A typical 3D creation task usually includes the following deliverables:

    • An editable 3D project file for later manual modification;
    • At least one rendered image for quickly judging visual fidelity;
    • An optional interactive web page for displaying the model, annotations, view switching, and resource downloads;
    • Optional print or export formats for downstream production workflows.

    These deliverables appear simple, but they reflect the model’s combined understanding of task goals, spatial layout, thematic elements, file organization, and front-end interaction. Evaluation therefore cannot only ask whether the result “looks right.” It must also ask whether it “can be modified,” “can be used,” and “can be reproduced reliably.”

    2. Bare-Prompt Test: Complete Deliverables, but Thematic Element Recall Still Has Limits

    In a general test, the tester used only a bare prompt and asked for a voxel miniature landscape themed around a “city detective agency,” with the building facade and signboard as visual highlights. The deliverables were an editable 3D project file and rendered images. Here, “bare prompt” means no additional skills, no private assets, no reference images, and no multi-turn correction. The test observed only the model’s first response to a natural-language request.

    From the delivery result, the model produced two rendered images and one editable 3D project file, indicating a certain level of completeness in task decomposition and file organization. The model restored the main building structure, including side stairs, second-floor office space, and first-floor shop area, and attempted to add character figures as scene accents. This shows that the model could extract key constraints such as “miniature landscape,” “voxel language,” “main building,” and “visual highlights” from the prompt and organize a basically readable 3D scene.

    The problem was also clear: the most recognizable thematic element, the signboard, did not appear. For a themed scene such as a detective agency, a signboard is not merely decoration; it is a core semantic anchor. Without the signboard, the model can still present “a building,” but it is difficult for viewers to immediately identify it as “a detective agency.” This exposes a common boundary: large models can complete a skeleton with “a building, stairs, and rooms” in structured modeling, but they remain unstable in thematic semantic recall, key identifier generation, and visual focus control.

    In addition, character造型 was abstracted. [Note: the previous sentence contains a Chinese term and must be corrected in the final article.] Character figures can serve as scale references and atmosphere elements, but fine-grained features such as hairstyle, clothing, and pose may deviate from expectations. For demonstration scenes, this deviation may be acceptable; for commercial displays, IP-themed spaces, or cultural tourism sandboxes, manual review and secondary editing are required.

    Therefore, when evaluating 3D creation capability, it is advisable to include at least the following checks:

    1. Structural completeness: whether the main building, floor relationships, stairs, entrances, and surrounding environment match the prompt;
    2. Thematic element recall: whether semantic anchors such as signboards, identifiers, characters, and props appear;
    3. Spatial relationships: whether floors, orientation, occlusion, scale, and circulation are reasonable;
    4. Editability: whether the project file preserves object hierarchy, materials, and modifiable structures;
    5. Visual expression: whether lighting, materials, and composition in the rendered image serve the theme;
    6. Reproducibility: whether repeated generation with the same prompt remains within an acceptable range.

    3. The “Unexpected Gain” of Interactive Web Pages: From Model Delivery to Scene Delivery

    More noteworthy is the interactive web page. The tester’s original prompt only required that the file could be opened in a web page, but the generated page additionally included model dragging, auto-rotation, scene annotations, view focus, resource downloads, and rendered-image switching. In other words, the model did not stop at “generating a model file”; it attempted to package the model into a scene page that could be demonstrated, browsed, and delivered.

    This kind of “unexpected gain” is valuable in engineering. For projects such as campus sandboxes, city modeling, and smart building visualization, scene annotations and view focus are common requirements. Annotations can associate buildings, entrances, equipment, or areas in the model with business information; view focus can help non-expert users quickly locate key objects; auto-rotation and dragging lower the barrier to using 3D pages. The model’s ability to proactively add these interactions suggests some understanding of common patterns for “displaying 3D models on a web page.”

    However, more interactive features do not necessarily mean higher engineering completeness. Evaluation should distinguish between “demo-ready” and “production-ready”:

    • Demo-ready: the page opens, the model rotates, annotations display, and resources can be downloaded;
    • Production-ready: resource paths are configurable, annotation data is maintainable, model loading has fallback options, page performance can be monitored, and permission and copyright boundaries are clear.

    For example, a maintainable interactive page usually needs to decouple the model, annotations, views, and descriptive information. Scene annotations can be described with a configuration similar to the following, rather than hard-coded into page logic:

    1. {
    2. "scene": "detective-office-micro-scene",
    3. "annotations": [
    4. {
    5. "id": "entrance",
    6. "label": "Main entrance",
    7. "position": [0, 1.2, 3.5],
    8. "focus": {
    9. "camera": "front",
    10. "zoom": 1.4
    11. }
    12. },
    13. {
    14. "id": "signboard",
    15. "label": "Theme signboard",
    16. "position": [0, 4.8, 2.1],
    17. "focus": {
    18. "camera": "front-top",
    19. "zoom": 1.8
    20. }
    21. }
    22. ]
    23. }

    The value of this configuration-based approach is that the model generates a first draft, and the engineering team can continue to integrate annotations, views, descriptions, and business data. For applications on general cloud platforms such as Baidu AI Cloud, object storage can be used to host model and image assets, container platforms can be used to deploy interactive pages, and logging services and monitoring alerts can be used to observe loading failures, missing resources, and access anomalies. These are general engineering practices that do not depend on specific model capabilities.

    4. From a Single Experience to an Evaluation Framework: How to Quantify 3D Creation Capability

    A single test is easily affected by prompt quality, randomness, and human judgment. To turn “looks good” into “a judgeable capability,” a layered evaluation framework is needed.

    The first layer is task understanding. Check whether the model identifies the theme, deliverable types, visual highlights, and format constraints. If the prompt requires that “the signboard is the visual highlight” but the result has no signboard, the priority of thematic elements was not correctly executed.

    The second layer is spatial reasoning. A 3D scene is not a flat collage; floor levels, stairs, entrances, occlusion, and scale relationships must be self-consistent. The model can be asked to output an object hierarchy or a simple scene description to help judge whether its spatial planning is reasonable.

    The third layer is asset organization. An editable project file should preserve object naming, grouping, materials, and basic transformation information. If the deliverable is only a merged whole model, subsequent modification costs will rise significantly.

    The fourth layer is interaction packaging. A web page should provide basic browsing capabilities while avoiding excessive feature stacking. Scene annotations, view focus, resource downloads, and image switching should all have clear data sources and fallback strategies.

    The fifth layer is quota and stability. 3D generation usually consumes more computing resources than text generation, and daily call quotas, concurrency limits, and failure retry strategies all affect practical usability. Testing should record successful delivery rate, average waiting time, failure types, and manual repair time, rather than only looking at a single result.

    A simplified evaluation record can be designed as follows:

    1. Task: Voxel miniature landscape generation
    2. Input: Bare prompt
    3. Deliverables: Project file / rendered images / interactive page
    4. Structural completeness: Pass / partial pass / fail
    5. Thematic element recall: Signboard missing, character details deviated
    6. Spatial relationships: Floors and stairs basically reasonable
    7. Editability: Object hierarchy readable, materials need review
    8. Interactive page: Dragging, rotation, annotations, focus, download available
    9. Quota impact: High consumption per run, batch testing required
    10. Manual repair items: Add signboard, fix character造型, organize annotation data

    5. Engineering Implementation Advice: Treat Model Output as a First Draft, Not a Final Version

    For developers and enterprise users, a more realistic positioning is to treat large-model 3D creation output as an “editable first draft.” It can significantly reduce the cost of building a scene from scratch, but it cannot replace manual acceptance, copyright review, and engineering packaging.

    It is advisable to add four steps to the implementation process:

    1. Prompt templating: write themes, structures, key elements, delivery formats, and prohibitions into templates to reduce omissions;
    2. Automated acceptance checklist: perform rule-based checks on signboards, entrances, floors, characters, materials, and file structure;
    3. Manual review: focus on thematic semantics, copyright elements, scale relationships, and editability;
    4. Asset hosting and monitoring: use general object storage, container platforms, logging services, and monitoring alerts to manage deliverables and page runtime status.

    At the same time, avoid the mistake of treating demonstration capability as production capability. Generating a web page with annotations and view focus in one run shows that the model has good task generalization awareness; however, a production system still needs permission control, data maintenance, performance optimization, exception handling, and version management. Only when these elements are complete can 3D creation capability truly enter a business pipeline.

    6. Conclusion

    This general test shows that large models can already complete basic structural modeling, rendered image output, and interactive page packaging in a 3D miniature landscape task. Web page interaction even produced “gain features” beyond the prompt. However, missing key thematic elements, character detail deviations, and unstable editability still indicate that the output is better suited as a first draft than a final version.

    Therefore, when evaluating large-model 3D creation capability, it is not enough to look only at whether the rendered image is attractive or whether the web page has rich features. Evaluation should comprehensively consider task understanding, spatial reasoning, thematic recall, asset organization, interaction packaging, quota constraints, and manual repair cost. For developers, the most practical approach is to establish reusable prompt templates, acceptance checklists, and engineering hosting workflows, letting the model handle rapid generation and the engineering system handle stable delivery.