Prompt Evaluation and Engineering Practices for 3D Scene Generation

    Large language models are increasingly evaluated on their ability to build 3D space rather than just write code, and this shift introduces new challenges around semantic completeness, spatial reasoning, and reproducibility. Drawing on a deliberately bare-prompt test in a mainstream open-source 3D content creation tool, this article analyzes where models succeed and where they silently fail, then proposes a reusable six-dimension scoring framework, a structured prompt template with priorities and fallback rules, a layered generation strategy, and a minimal automated validation script. It closes with engineering guidance for turning single-turn generation into a controllable pipeline and for adapting workflows to three distinct delivery formats: modeling files, interactive web pages, and additive manufacturing.

    Why the Evaluation Focus Shifted from “Writing Code” to “Building Space”

    Over the past two years, most public benchmarks for large models centered on algorithm problems, business scripts, and API integration tasks, with scoring based on whether code ran successfully in one pass and whether edge cases were fully handled. The recent shift is that evaluation now probes a model’s ability to build 3D space: given a natural-language description, the model is expected to output directly usable scene assets, a runnable browser-based interactive page, or a physical model that can be handed to an additive manufacturing device.

    This migration has clear technical drivers. The intermediate representation of a coding task is one-dimensional text, with highly deterministic syntax and execution results, so the model only needs to fill in blanks within existing syntactic constraints. In contrast, the intermediate representation of a 3D scene is a hierarchical spatial graph structure that involves a large number of implicit constraints—coordinate systems, units, relative scale, occlusion relationships, normal directions, and topological validity. Judging a 3D artifact often cannot rely on “can it render” alone; what matters is whether the spatial relationships conform to physical and visual intuition. This capability is closer to “spatial reasoning” than “symbolic reasoning,” which makes it an important dimension for distinguishing tiers of model capability.

    At the same time, the iteration cadence of new versions is accelerating, and capability announcements around 3D creation and spatial understanding are becoming denser. For developers, the truly valuable question is not whether a given version is “strong” but how to measure its capability boundaries with reproducible methods in their own environment and turn the results into a regression-testable evaluation baseline.

    A Retrospective of a Bare-Prompt Test

    To make the test reflect the model’s raw capability as much as possible, I deliberately used a “zero-scaffolding” approach: no domain skill packs attached, no example files provided, no step-by-step instructions—just a natural-language scene description, asking for the generation of a miniature diorama themed on the “detective agency” from a mystery anime, produced via script inside a mainstream open-source 3D content creation tool.

    The results split into two parts that need to be examined separately.

    The praiseworthy part: the spatial structure basically held up. The room’s depth, the relative placement of desks and chairs, the window relationships of bookshelves and windows, and the common “cut-away walls” presentation of miniature models were all within expectations, and the camera view produced a still frame with a normal look. For pure language input, this shows the model’s spatial prior for high-frequency semantics like “indoor scenes” is effective.

    The reason it can’t get full marks: the most critical identifying element was lost. In the original work, a very prominent institutional signboard hangs on the wall—it is one of the most important identifying symbols of the scene. Remove it, and what remains is merely “a room that looks like an office,” and the thematic information essentially fails. This is not a minor detail flaw but a loss of the semantic subject.

    From an evaluation standpoint, this failure is representative and exposes three common problems:

    • Insufficient prioritization of visually salient elements. The model tends to generate “structural large geometry” (walls, floors, furniture) while easily omitting elements that are “semantically critical but geometrically simple” (signboards, nameplates, markings, text). The latter is harder because it requires aligning planar geometry, texture, and text content simultaneously, and the proportion of such samples in training signals is often not high.
    • Text-based asset generation remains a weak spot. When it comes to readable text, specific fonts, and layout, scripted generation usually needs to call external font or texture resources; absent explicit instructions, the model tends to “avoid” rather than “approximate.”
    • The under-specification problem of prompts is amplified. I only said “themed on a certain detective agency” without saying “must include the door plate and signboard.” A human creator would fill in genre common sense on their own, but the model may treat the description as a closed-set constraint. This suggests to practitioners that under-specified prompts in 3D tasks are more likely to cause structural-level deviations than in coding tasks.

    At the same time, there was a part that exceeded expectations: when delivering the interactive web page, the model proactively added interactive capabilities I did not request, such as view switching, object focusing, and brightness adjustment. This can be seen as “capability spillover,” which engineering should treat differently—it adds product value but also brings risks of uncontrollable behavior and performance overhead.

    A Reusable Framework for 3D Generation Quality Evaluation

    To turn the above subjective judgment into regression-testable metrics, I suggest building a scoring sheet across six dimensions, with each scored 0–5 and the reason for each deduction retained.

    1. Required element coverage. First extract a “required elements checklist” from the prompt, then check each item for existence, positional reasonableness, and visibility. This is the most easily overlooked dimension and the one that best distinguishes passing from excellent.
    2. Scale and coordinate consistency. Check whether units are unified, whether furniture heights match ergonomic magnitudes, whether objects intersect, and whether they penetrate the ground or float. I recommend directly reading the scene’s bounding boxes for numerical validation rather than relying on the naked eye.
    3. Topology and editability. Check for non-manifold edges, flipped normals, and overlapping faces; whether objects have clear naming and hierarchical grouping; and whether the whole can be rebuilt after changing a parameter. Editability determines whether an asset can enter the production pipeline.
    4. Material and lighting readability. Check whether portable, general material parameters (base color, roughness, metalness, and the like) are used, and whether the scene depends on renderer-specific nodes. Proprietary nodes will cause an asset to fail outright in other pipelines.
    5. Interaction and runtime performance. Check whether the polygon count, draw calls, and texture sizes fall within an acceptable range for the browser, and whether first-frame time is stable. When interaction is rich but the frame rate is unusable, actual usability drops instead.
    6. Delivery-format fit. The same scene has completely different requirements when delivered as a “modeling file,” an “interactive web page,” or an “additive manufacturing” product, so each must be scored separately—one ruler cannot measure all three.

    Turning “Feel” into Executable Constraints: Structured Prompts

    The quality of prompts for 3D tasks largely depends on whether the constraints are executable. I recommend changing prompts from prose to structured descriptions with explicit fields, at minimum including coordinate system, units, checklist, priorities, and fallback rules:

    1. scene:
    2. theme: Retro detective agency (miniature diorama, cut-away walls)
    3. units: meters # Explicit units to avoid scale drift
    4. up_axis: +Z
    5. origin: Projection of the room's geometric center onto the ground
    6. constraints:
    7. must_have: # Required elements; missing any one fails
    8. - Walls and floor (cut-away, keeping two walls)
    9. - Desk, chair, bookshelf, floor-to-ceiling window
    10. - Wall-mounted signboard (readable text, roughly 1/6 of wall height, centered slightly high)
    11. priority: # Order to guarantee first when budget is insufficient
    12. - Signboard > desktop items > decorative knick-knacks
    13. fallback:
    14. - If no font resource is available, assemble the signboard outline from monospace geometric blocks and keep a placeholder text layer
    15. forbid:
    16. - Objects penetrating the ground or walls
    17. - Relying on a single renderer's proprietary shading nodes
    18. deliverables:
    19. - Scripted generation entry point (adjustable parameters)
    20. - Open-standard 3D interchange format asset
    21. - Interactive web page (with view switching and object focusing)

    The key to this template is not the fields themselves but the two lines “priority + fallback.” With a fallback rule, the model will not choose to skip the signboard when font resources are missing; instead it degrades to a geometric approximation, avoiding the situation where a key element simply disappears.

    For the generation strategy, I recommend advancing in layers rather than in one pass:

    1. Round 1 Blockout: produce only block-level layout (walls/floor/furniture bounding boxes) and confirm spatial relationships
    2. Round 2 Detailing: add furnishings, doors and windows, and structural details on the confirmed layout
    3. Round 3 Markings and text: handle signboards, nameplates, book covers, and other text assets separately
    4. Round 4 Materials and lighting: unify material parameters and the lighting scheme
    5. Round 5 Delivery adaptation: export the model / generate the web page / run a watertightness check before additive manufacturing

    The benefit of layering is that each round is verifiable and reversible. Round 3 handles text assets separately precisely because it is the highest-failure-rate stage and the one most easily “casually skipped” by earlier steps.

    Automated Validation: Moving Subjective Review Forward as Machine Checks

    3D artifacts are more suitable for automated validation than code, because their correctness has many geometric invariants to rely on. A minimal usable validation script can first cover the four most common categories of problems:

    1. def validate_scene(objects, tol=1e-4):
    2. issues = []
    3. # 1) Existence of required elements
    4. missing = REQUIRED_ITEMS - {o.name for o in objects}
    5. if missing:
    6. issues.append(("missing_required", sorted(missing)))
    7. # 2) Ground penetration / floating: compare the z interval of the bounding box with ground height
    8. for o in objects:
    9. if o.is_static and abs(o.bbox_min_z - GROUND_Z) > tol:
    10. if o.bbox_min_z < GROUND_Z:
    11. issues.append(("penetrating_ground", o.name))
    12. else:
    13. issues.append(("floating", o.name))
    14. # 3) Unexpected intersections: check only whitelisted combinations that are allowed to overlap
    15. for other in objects:
    16. if {o.name, other.name} in ALLOWED_OVERLAP:
    17. continue
    18. if o.bbox.intersects(other.bbox):
    19. issues.append(("overlap", o.name, other.name))
    20. # 4) Topology and normals
    21. for o in objects:
    22. if o.non_manifold_edges or o.has_flipped_normals:
    23. issues.append(("topology", o.name))
    24. return issues

    Wiring this check to the back of the generation flow forms a “generate → validate → revise” closed loop: the failure information from validation serves as input for the next round’s prompt, which is far more stable than manually eyeballing images for errors, and it is naturally suited to regression testing—run a baseline scene set after each model or prompt change to quantify capability changes rather than judging by impression.

    Engineering Implementation: From Single-Turn Dialogue to a Controllable Pipeline

    When this kind of capability is to be offered as a service or plugged into business workflows, four pieces of infrastructure need to be filled in.

    Scripting as an intermediate representation. Having the model output a parameterized generation script rather than a binary asset directly brings reproducibility, versionability, and diff comparison. Once a script goes into a code repository, it can be reviewed and rolled back just like ordinary code.

    Deploying inference and rendering services. A generation service typically contains two workloads—model inference and asset post-processing—that differ substantially in form and are well suited to being hosted on a container platform with elastic scaling by queue depth. The heavy generated assets (model files, textures, web packages) are suited to object storage, delivered to end devices with a distribution network; small files and state information can go through a message queue to smooth out peaks.

    Quality observability. The metrics a 3D generation pipeline needs to observe differ from those of traditional APIs. Beyond latency and failure rate, they should include the distribution of problems produced by the validation script (which category loses the most points), the average number of revision rounds, and the pass rate grouped by prompt template. These metrics need to land in a logging service and monitoring alerts so that during version iteration one can judge “did it get stronger, or just more verbose?” Baidu AI Cloud provides general capabilities such as object storage, container platform, logging service, and monitoring alerts for this kind of pipeline, which can be combined directly into the observability foundation above without building them yourself.

    Content safety and compliance. Generation involving text and textures requires unified content moderation of outputs before rendering, to avoid emitting uncontrollable text directly into assets visible to end users.

    Key Differences Among the Three Delivery Formats

    The same scene has completely different engineering constraints when facing different deliverables, and in practice it’s best to align with users ahead of time:

    • Modeling files: focus on parameterization capability and topology quality; high polygon counts are allowed; the key checks are naming hierarchy and material portability.
    • Interactive web pages: focus on first-screen time and frame rate; geometry simplification, texture compression, and on-demand loading are needed; interactive capability must be controllable, avoiding “free play” by the model that makes behavior hard to predict.
    • Additive manufacturing: focus on watertightness, wall thickness, support structures, and printability; thin walls and overhangs must be detected in advance; in addition, material volume and print time need to be estimated, feeding cost information forward to the user.

    Conclusion and Practical Recommendations

    Driving 3D scene generation with natural language currently sits at a “structurally usable, semantically under-specified” stage. It can reliably produce a skeleton with reasonable spatial relationships, but still has clear gaps in semantically critical elements, text assets, and topological details—and these gaps are often silent: they don’t throw errors, they just make your scene “missing the most important signboard.”

    Three recommendations for practitioners:

    1. Drive prompts with checklists. Explicitly list the required elements of the theme and annotate priorities and fallback strategies, rather than leaving common-sense judgment entirely to the model.
    2. Layered generation + automated validation. Use geometric invariants for machine review, turning “can it get full marks” from a subjective argument into a regression-testable metric.
    3. Design workflows separately by delivery format. The constraints of the modeling, web, and additive-manufacturing pipelines are not interchangeable; don’t cover all deliverables with one set of prompts.

    Model capabilities are evolving fast, but the methods and evaluation framework above have a longer lifecycle. Build the evaluation and validation infrastructure first, and no matter how the underlying model is swapped out, your 3D content production pipeline can keep producing usable assets stably.