Testing 3D Scene Generation: From Voxel Modeling to an Interactive Web Page
This article shares a hands-on test of AI-driven 3D scene generation, moving from voxel modeling to an interactive browser-based viewer. It explains why the field's focus is shifting from code generation to spatial creation, how to write an effective minimal prompt, and what a test on an old-town detective-agency scene got right and wrong. You'll learn why text-based components like signboards are a recurring blind spot in 3D generation, how to weigh the "over-delivery" of unspecified interactive features, and how to turn model output into a deliverable asset with a reusable engineering pipeline. It also includes a five-dimension acceptance checklist with weights, practical notes on cost, compliance, and capability limits, and a recommendation to run bare-prompt and structured-spec rounds in parallel.
1. Why I Ran This Test: The Focus Is Shifting from Writing Code to Building Space
Over the past two years, code generation has been the main yardstick for model capability: how many lines of runnable code a model can produce, whether it can fix bugs. But the latest shift is clear—more and more developers now use “can it directly produce a runnable 3D scene” as a stress test. The reason is easy to understand. Code correctness has unit tests as a safety net, whereas a 3D scene tests three things at once: first, semantic understanding (breaking a natural-language sentence into a hierarchy of buildings, components, props, and characters); second, spatial reasoning (whether coordinates, proportions, orientation, occlusion, and floor relationships are internally consistent); and third, multimodal delivery (whether the modeling project, rendered images, and an interactive page form a closed loop). Stacking these three is harder to fake than writing an algorithm alone.
A week after a model’s release, I ran a hands-on test using a set of bare prompts—“zero mounting, zero skills, zero reference images.” The theme was a voxel miniature landscape of a detective agency on an old-town street corner. The required deliverables were an editable 3D modeling project file plus rendered images. After generation, I added one more instruction asking for a 3D viewer page that opens in a browser.
2. Test Setup and Prompt Design
A bare prompt doesn’t mean “just say one sentence.” An effective minimal prompt needs to cover at least five dimensions. My phrasing then was roughly:
- Theme and semantic anchors: inspired by a street-corner agency in a detective/mystery animation, avoiding directly naming any copyrighted work or character;
- Style constraints: voxel/block language, unified units, no curved-surface modeling;
- Component list: main building, outdoor staircase to the rear, upper-floor office area, ground-floor street-facing shops, signage, two character figures;
- Delivery format: editable project plus a rendered image from a fixed camera angle;
- Acceptance preference: explicitly stating that the “signboard” is the visual focus.
There’s an easily overlooked detail here: a visual focus must be declared explicitly. The model won’t guess for you which parts of a 3D scene are the subject and which are background. Any component you want at the center of the frame and that cannot be missing must be called out separately, with its text content, dimensions, orientation, and material spelled out.
3. Breaking Down the Results: What It Got Right
From the rendered image, the spatial structure largely held up: the main building’s proportions were reasonable, the side wall carried the second-floor outdoor staircase, the upper-floor agency windows, and the ground-floor shops with awnings along the street were all present, and two character figures stood on the street as a scale reference. The voxel style stayed consistent—no realistic curved surfaces broke in midway, which shows the style constraint was carried through the entire generation process. The relative heights of the floors and components, and the join between staircase and platform, showed no obvious clipping. That puts spatial reasoning above the passing line.
4. The Missing Signboard: Why Text Components Are a Stable Blind Spot
The biggest problem was that the signboard wasn’t generated. As the visual subject of the whole image, its absence alone kept this delivery from a full score.
This wasn’t a one-off oversight but a reproducible difficulty in 3D generation tasks, for three reasons:
- Text rendering itself is hard. Generating text in a modeling script usually means going through a pipeline of font resource → curve/outline → extrusion → conversion to mesh. If the model takes the generation path instead of the texture path, it must correctly load the font, handle Chinese or full-width glyphs, and control extrusion depth and back-face orientation—any one of these steps failing will cause the component to be silently dropped.
- Flat, thin components have low priority. A voxel approach favors generating volumetric blocks, but a signboard is a thin panel with text; after voxelization its information density is extremely low, so it’s easily judged as “an omittable detail.”
- The failure is silent. The generator won’t throw an error; it just “draws one less block.” This is also the biggest difference between 3D generation and code generation—a missing component doesn’t raise an exception and can only be caught during acceptance review.
The engineering fix is straightforward: for text components, use the safer “texture plus parametric placeholder panel” approach—first generate a panel with correct dimensions, then apply the text as a texture. Alternatively, provide font and typography requirements in the prompt and explicitly demand “if text cannot be generated, the blank panel must be retained.” By the same logic, character details (hairstyle, facial features) are inherently distorted at voxel resolution, because a voxel grid can only carry low-frequency shapes; high-frequency structures like hair will inevitably be abstracted into stacked blocks. If you want recognizability, switch to a “low-poly model plus texture” or “reference-image-driven” approach rather than continuing to densify the voxel grid.
5. A Surprise: How to Judge the “Over-Delivery” of the Interactive Page
My added instruction was a single line—“output a 3D page that opens in a browser”—with no functional requirements. Yet the generated page included a batch of capabilities I hadn’t specified:
- Orbit-camera-style drag rotation, zoom, and auto-rotation;
- A scene annotation system that pops up a component’s name and description on click;
- A side-panel view-focus control that jumps to a specified component with one click (main building, shop, and characters, one each);
- Deliverable integration: a model download entry and switchable render-image previews;
- A first-load onboarding overlay with operating guidance.
Most of these additions are practical. Scene annotation and view focus in particular are nearly essential for projects like building sand tables, park tours, and city-scale visualization—they turn “able to see” into “able to explain.” The filters and lighting on the rendered image also clearly look better than a bare model.
But “over-delivery” should be viewed from both sides. In the prototype-exploration stage it’s a plus, because it reflects the model’s ability to infer the delivery context; in production it means scope creep—unspecified interaction logic brings testing cost, and if the annotation content is written by the model itself, it may not match the real business terminology. My suggested approach is to specify in layers—separate “must have” from “free to improvise,” for example clearly stating “annotation text is injected from an external JSON, do not author content yourself.”
6. From Model to Page: A Reusable Engineering Pipeline
To turn this into a deliverable asset, the steps in between can’t be skipped:
# Declarative scene description: the model outputs structure, the script builds and exportsSCENE = {"grid": (128, 128, 64), # Upper bound of voxel resolution, the tradeoff between detail and cost"voxel_size": 0.1, # Unit conversion: 1 voxel = 0.1 meters"palette": {"wall": "#E8E2D4", "roof": "#7A4B36", "sign": "#1E3A5F"},"nodes": [{"id": "main_building", "type": "box", "size": [18, 12, 26]},{"id": "outer_stair", "type": "stair", "steps": 14, "width": 3},{"id": "cafe_frontage", "type": "box", "size": [18, 8, 4]},# Key: force text components to keep a placeholder panel to avoid silent loss{"id": "sign_board", "type": "panel", "size": [10, 0.4, 2],"decal": {"text": "侦探事务所", "font": "default_cn", "align": "center"}},{"id": "characters", "type": "instanced", "count": 2},],"camera": {"type": "isometric", "target": "main_building"},"light": {"env": "soft_studio", "key_intensity": 3.0},}
The pipeline I’d suggest:
- Structure validation: assert at build time that the component list is complete (especially easily dropped items like signboards and door plates), and fail and retry on any missing item rather than proceeding to render;
- Instancing and compression: draw repeated voxels with instanced rendering, and run mesh compression and quantization before export to reduce first-screen size;
- Export and viewing: export to a common 3D interchange format (such as glTF/GLB), load it in the browser with a WebGL-based rendering framework, and keep annotation data separate from scene data, with annotations in their own JSON;
- Regression lock-in: write “which components must exist” as a configuration and automatically compare it on every generation, forming a repeatable acceptance baseline.
7. Acceptance Checklist: Five Dimensions for Scoring 3D Generation Results
Don’t conclude with “looks fine.” I’d suggest scoring by the following weights, where any single item at zero makes the whole result a fail:
| Dimension | Weight | Checkpoints |
|---|---|---|
| Semantic fidelity | 30% | Every item in the component list present, visual-focus component not missing |
| Space and proportion | 25% | Floor relationships, staircase joins, unit scale, no clipping |
| Style consistency | 15% | Unified voxel language throughout, no style jumps |
| Interaction experience | 20% | Drag/zoom/focus/annotation usable, feedback on first load |
| Engineering usability | 10% | Project editable, re-exportable, acceptable file size |
In this test, semantic fidelity was marked down for the missing signboard, interaction experience exceeded expectations, and the final result was at the level of “usable but needs one round of rework.”
8. Implementation Notes
- Quotas and cost: this kind of generation task takes far longer and consumes far more quota per run than text chat, and platforms generally have daily quota limits. Before production integration, build in queuing and rate limiting, cache results to object storage by content hash to avoid duplicate billing, and use idempotent identifiers for failed retries.
- Resources and compliance: directly using copyrighted characters, character names, or signature color schemes carries risk. Commercial visualization projects should switch to original naming and imagery, or go through formal licensing.
- Honest statements of capability boundaries: at this stage models are good at medium-complexity scenes that are “structurally complete but abstract in detail,” and not good at precise text layout, fine facial features, or complex mechanical linkages. In a proposal, write these as explicit assumptions and limitations rather than implicit promises.
- Testing-method suggestion: run two rounds. The first uses bare prompts, to see the true level of generalization and creativity; the second uses a structured spec (component list, material table, camera and lighting parameters), to see controllability. The gap between the two rounds is exactly the part you need to fill with engineering. This kind of multimodal and code generation capability is usually called on demand through large-model service platforms; platforms such as Baidu AI Cloud offer the corresponding large-model services along with general capabilities like object storage and log monitoring, which can serve as the foundation for hosting and operations.
9. Conclusion
The value of this test isn’t how many points a given model scored, but that it drew a clear picture of 3D generation capability: structure and style are already usable, text and high-frequency detail remain hard problems, and the autonomy of the interactive page exceeded expectations. For developers, the right posture isn’t waiting for the model to get stronger, but placing the model inside a pipeline with validation, fallbacks, and version control—letting the model handle creative and structural drafts, and letting engineering handle spec constraints and missing-item detection. That way, a generation that “lost its signboard” won’t become an incident, but just a build failure caught automatically.
