3D Scene Generation Evaluation for Large Models: Bare Prompts, Scoring, and Engineering Delivery

    This article documents an evaluation of a general-purpose large model for 3D scene generation using a bare prompt. The task asks the model to build a voxel-style street-corner detective agency with a two-story building, external staircase, rooftop sign, street-level characters, editable project file, renders, and an interactive web page. It explains the test setup, a weighted scoring framework, and the result of 7.05 out of 10. The analysis highlights strengths in spatial structure, interaction, and incremental correction, as well as weaknesses in key element recall, character recognizability, and editability. It then presents a practical engineering workflow for stable delivery, including structured prompts, automated asset validation, cloud rendering and distribution, and guidance for avoiding common failure modes.

    1. Background and Test Setup

    Over the past two years, large-model evaluation has shifted from “whether the code is correct” to “whether the model can build a structurally sound, editable, and presentable 3D scene from a text description.” Three forces drive this shift:

    • Demand side: smart parks, property showcases, and digital exhibition booths need rapid 3D prototypes.
    • Capability side: 3D generation requires the model to reliably execute the full chain of parsing semantics → planning space → composing structures → organizing materials → exporting files.
    • Validation side: models can operate modeling software through scripts, export interchange formats, render images, and embed results into web pages, making outcomes visual, measurable, and comparable.

    To make this test reproducible, the record below should be retained:

    • Model under test: [fill in actual model/version; lock the specific version during evaluation]
    • Platform: online AI coding environment (credit-based sandbox; optional delivery targets such as 3D modeling, web pages, and printing)
    • Test date: [fill in actual date]
    • Delivery format: editable project file + rendered images + interactive web page
    • Interaction rounds: 1 round for baseline generation, 1 follow-up for signboard completion, and 1 follow-up for interactive web page; 3 rounds in total
    • Archiving: keep the full prompt, artifact links, screenshots, and raw itemized scores where possible

    The complete bare prompt used in this test is as follows. It can be used for reproduction:

    1. Please build a voxel-style 3D miniature scene of a “Street Corner Detective Agency,” with the following requirements:
    2. 1. A two-story corner building facing the street; the second floor is a detective agency, and the first floor is a street-corner café.
    3. 2. The first floor includes glass doors and windows and an awning; the second floor is directly accessible from the street through an external staircase to the door.
    4. 3. A prominent Chinese-language sign reading “Detective Agency” is placed on the roof.
    5. 4. Several character figures are placed on the street, with recognizable hairstyles and clothing.
    6. 5. Output an editable 3D project file, multiple rendered images, and a 3D web page that can be rotated and zoomed in a browser.

    2. Testing Method: The Bare-Prompt Principle

    A bare prompt means that no skill packs, examples, or preset workflows are loaded during testing. Only the natural-language requirement is provided, so the evaluation measures the model’s native capability.

    A bare prompt is not just a casual one-liner. The test prompt must cover theme, style, key elements, spatial scale, and deliverable types; otherwise, results cannot be compared fairly. In production, a more reliable approach is to use bare prompts for capability assessment and structured prompts for stable output. This test is positioned as a capability assessment.

    3. Quantifying 3D Creation Ability: Scoring Framework and Anchors

    To avoid “scoring by feeling,” each item should first define anchors on a 0–10 scale, and then be combined into a weighted total.

    General anchors:

    • 0–2: key deliverables are missing, major structural errors exist, or assets are unusable.
    • 3–4: some deliverables are missing or major structural errors exist; rework is needed.
    • 5–6: deliverables are mostly complete and the main structure is correct, but there are a few obvious defects.
    • 7–8: deliverables are complete, structure is accurate, and only minor details remain imperfect.
    • 9–10: deliverables are complete, structure is precise, details are in place, and the experience is excellent.

    Each dimension is refined as follows:

    Dimension Weight Core focus Score
    Delivery completeness 20% Whether project files, rendered images, and interactive web pages are complete, openable, and consistent 9
    Structural and spatial fidelity 25% Accuracy of floor relationships, external staircase, and street-front storefronts 9
    Key element recall 20% Whether explicit elements, especially visual focal points, are implemented item by item 4
    Character and detail recognizability 10% Whether character proportions, hairstyles, and clothing are immediately recognizable 4
    Editability 15% Semantic grouping, adjustable materials, and use of common export formats 6
    Interaction and rendering experience 10% View control, auto-rotation, scene annotation, and visual quality 9

    Additional dimension anchors:

    • Delivery completeness: if only rendered images are missing, the score is about 6; if the web page fails to load, treat it as a hidden defect and deduct to 4.
    • Key element recall: if the visual focal point, such as the signboard, is missing, the score should not exceed 4.
    • Editability: if all geometry is merged into a single mesh with no named groups, deduct to 6 or below.

    Weighted total = 9 × 0.20 + 9 × 0.25 + 4 × 0.20 + 4 × 0.10 + 6 × 0.15 + 9 × 0.10 = 1.8 + 2.25 + 0.8 + 0.4 + 0.9 + 0.9 = 7.05.

    4. Case Review: Strengths, Weaknesses, and Takeaways

    The strengths are mainly in structural fidelity and interaction. The external staircase, functional separation between floors, and street-level figures were all present, indicating that the model has basic spatial parsing capability. Two rendered images and the editable project file were all output and could be opened. After adding only one sentence—“make the model into a web-based 3D page”—the model exceeded expectations and implemented drag-to-rotate, wheel-to-zoom, auto-rotation, key-point annotations, view focusing, first-load guidance, and image/model switching and downloading. These features directly support POI labels, key-area positioning, and lower-cost reporting and demonstrations for building sand-table or miniature-scene use cases. When the missing signboard was pointed out with “the roof needs a sign,” the model added it specifically rather than rebuilding everything, showing relatively good incremental correction ability.

    The weaknesses are in key element recall and character recognition. The most prominent “Detective Agency” sign was completely missed. There are three reasons:

    • Chinese text carries high information density but occupies a small geometric volume, and the model is not sensitive to this type of element.
    • The long prompt diluted attention.
    • The model tends to prioritize large-scale structures and ignore small attached elements.

    Characters were also hard to recognize because voxel resolution and abstract style made it difficult to balance detail and representation.

    The key takeaway is that evaluation must distinguish “model capability limitation” from “insufficient prompt specification.” Although the requirements were written out, the model still missed the sign, showing that “writing all requirements” does not mean “executing all requirements.” The extra web features generated by the model are valuable, but they also suggest that interaction logic should be actively constrained by the tester, avoiding a situation where both sides imagine different outcomes.

    5. From a One-Off Test to Stable Delivery

    The core conclusion is this: bare prompts are suitable for capability assessment, while structured prompts are suitable for stable delivery. A structured template can turn natural language into engineering instructions:

    1. Task type: voxel-style miniature scene modeling
    2. Key element checklist:
    3. 1. Two-story corner building; external staircase connecting first floor and second floor
    4. 2. First-floor corner café (glass doors/windows, awning, menu board)
    5. 3. Second-floor detective agency (door, windows, air-conditioning outdoor unit)
    6. 4. Rooftop “Detective Agency” sign (must include Chinese text)
    7. 5. Street-level character figures (recognizable hairstyles and clothing)
    8. Technical requirements: unified units; character height about one third of floor height; semantic object grouping and naming; parameterized materials; export to open 3D interchange formats
    9. Deliverables: editable project file + three rendered images (front/side/45-degree overhead) + interactive web page
    10. Self-check requirement: verify the element checklist before delivery and explicitly explain any missing items

    Key points:

    • Turning elements into a checklist reduces the probability of omission.
    • Quantified constraints, such as “character height is about one third of floor height,” reduce ambiguity compared with “balanced proportions.”
    • Explicit self-check requirements make it easier to locate problems quickly.

    After asset generation, run an automated validation pass to replace “checking by feeling” with “checking by rules.” The following code is pseudocode and only illustrates the flow. Replace interface names with the SDK of the actual modeling software or validation tools. Before running, add dependencies, input/output formats, and environment descriptions:

    1. # Pseudocode: depends on asset_checker (replace with the actual modeling software SDK)
    2. # Input: scene_model (project file path); Output: issues (list of problems)
    3. # Runtime: Python 3.10+, install the relevant modeling SDK and dependencies
    4. from asset_checker import MeshValidator, NamingConvention
    5. KEY_ELEMENTS = ["main_building", "stair", "cafe", "office", "signboard", "characters"]
    6. REQUIRED_MATERIALS = ["wall", "roof", "glass", "sign_text"]
    7. validator = MeshValidator("scene_model")
    8. issues = []
    9. issues += NamingConvention.check(validator) # 1. Naming and grouping
    10. for e in KEY_ELEMENTS: # 2. Presence of key elements
    11. if not validator.has_group(e): issues.append(f"Missing key element: {e}")
    12. for m in REQUIRED_MATERIALS: # 3. Material completeness
    13. if not validator.has_material(m): issues.append(f"Missing material: {m}")
    14. issues += validator.check_non_manifold() # 4. Geometry validity
    15. issues += validator.check_budget({"triangles": 500000, "file_mb": 50}) # 5. Scale/performance
    16. issues += validator.check_bounds({"width":12,"depth":10,"height":8}, tolerance=0.2) # 6. Dimension consistency
    17. print("Validation result:", "Passed" if not issues else issues)

    Cloud rendering and distribution are key to project deployment. A typical pipeline is: upload assets to object storage → convert and compress formats (geometry simplification, texture compression) → render from multiple views (strictly matching the model) → package and publish the web page → enable logging and monitoring alerts.

    Security notes should be added during deployment:

    • Object storage buckets should be private and have access authentication enabled. Deliver access through temporary authorized URLs to avoid public readability.
    • For external distribution, use a CDN and configure hotlink protection and Referer checks.
    • If uploaded characters, textures, annotations, or other information involve customer data or personal information, perform de-identification and compliance review first, following the principles of minimum necessity and least privilege.
    • Avoid recording sensitive content in logs and set retention periods.
    • Teams can make equivalent substitutions according to their own cloud environments.

    The evaluation workflow itself should also be engineered:

    • Classify test cases by level: smoke-level (whether model/image/web outputs can be generated), scenario-level (structural fidelity), and stress-level (complex topology and performance).
    • When quotas are limited, prioritize smoke-level and scenario-level cases.
    • Archive prompts, artifacts, scores, and issue lists after each round to form a baseline.
    • The model handles “0 to 1” generation, while engineers handle validation, repair, and integration, and place outputs under version control.

    6. Common Failure Modes and Avoidance Guide

    When troubleshooting, follow a fixed order: first check whether deliverables are complete, then structural fidelity, then element recall and character details, and finally performance and compatibility. Five high-frequency failure modes are listed below.

    1. Missing key elements, such as a missing signboard.
      Cause: text-based elements have weak geometric representation, and attention is diluted in long prompts.
      Fix: turn elements into a checklist, generate step by step, add explicit self-checks, and use incremental correction.

    2. Character and detail distortion.
      Cause: insufficient voxel resolution.
      Fix: use different voxel resolutions for different parts, use higher precision for characters, and supplement with simplified geometry plus textures when necessary.

    3. Poor editability.
      Cause: geometry is merged into a single mesh with no grouping.
      Fix: require semantic grouping, parameterized materials, and open-format export, and include naming conventions in validation.

    4. Incomplete or inconsistent deliverables.
      Cause: only a model is produced without a web page, or rendered images do not match the model.
      Fix: explicitly declare all deliverables and use the same asset source for the model, rendered images, and web page.

    5. Performance and compatibility issues on display endpoints.
      Cause: excessive polygons, oversized textures, and lag on low-end devices.
      Fix: set scale budgets, use progressive loading and degraded rendering, and perform compatibility tests on target devices.

    7. Conclusion

    This test shows that general-purpose large models already have practical value in 3D miniature-scene generation. The structure is complete, the interaction is rich, and incremental correction is possible, which is enough to support proof of concept and presentation prototypes. However, there is still clear room for improvement in engineering details such as key element recall, character recognizability, and editability.

    For developers, rather than focusing only on whether a single generation “looks right,” it is better to build a complete pipeline of “structured prompt + automated validation + cloud rendering and distribution,” constraining the model’s uncertainty within a controllable process. As multimodal models continue to evolve in the 3D domain, the methodology will iterate accordingly, but the principles of “clarifying requirements, constraining outputs, and verifying delivery” will remain unchanged.