Large Model 3D Generation: A Practical Test of Evaluation, Prompts, and Deployment

    This article documents a reproducible hands-on test of large-model 3D generation, covering how to evaluate the results, how to write effective prompts, and how to deploy the output. Using a minimal reproducible environment (ernie-5.5-flash-preview, Blender 4.2, and Three.js), it shows how to turn a vague sense of "quality" into verifiable scores through an element checklist, a six-dimension scorecard, coordinate and hierarchy mapping, and structured prompts. It also walks through building an interactive Three.js web viewer and deploying models, renderings, and web pages to object storage, CDN, and container platforms. Readers will learn where current models excel—regular geometry, spatial relationships, and scene organization—and where they still fall short, namely organic forms, curved props, and small-prop fidelity.

    1. Why Large-Model 3D Generation Matters Now

    How do large models generate 3D scenes? How do you write 3D generation prompts? How do you deploy the resulting 3D web pages? These questions are becoming central to shipping multimodal applications in production. Over the past year, the evaluation focus of large models has expanded from code generation and text reasoning toward multimodal understanding and spatial reasoning. 3D generation is one of the higher-bar directions in that shift: a model must not only understand natural language but also organize structure, control proportions, plan materials, and deliver something interactive within three-dimensional space.

    This article uses one reproducible 3D-generation test as its thread and answers three questions in particular:

    1. How do you test a large model’s 3D generation ability with a reproducible method?
    2. How do you turn “generation quality” into verifiable results using a scorecard and prompts?
    3. How do you deploy the generated voxel models, renderings, and interactive web pages to the cloud?

    2. A Reproducible Test Method: Environment, Tools, and Prompts

    So that the findings can be independently verified, this example test uses a “minimal reproducible environment” that does not rely on hidden plugins, external knowledge bases, or complex skill chains. One caveat: what we call a “basic prompt” or “no-extras prompt” is only meant to expose a model’s baseline ability; it is not the optimal configuration for production. Different model versions, tool chains, and browser environments all affect results.

    2.1 Test Environment

    • Model: The example uses ernie-5.5-flash-preview. If you reproduce the experiment, you can swap in a multimodal model of comparable capability, but you must record the version and results again.
    • 3D tool: Open-source Blender 4.2, used to generate the voxel miniature scene, export project files, and produce renderings.
    • Output formats:
      • .glb: for web loading and general 3D viewing;
      • .obj: for compatibility backup;
      • .png: front-view and top-view renderings;
      • .html: an interactive 3D web page.
    • Runtime:
      • Windows 11 / macOS;
      • Python 3.11;
      • Blender 4.2;
      • Chrome 126 or an equivalent browser;
      • A local static server started with python -m http.server 8000.
    • Generation time:
      • First-pass structure generation: ~42 seconds;
      • Follow-up request for the interactive web page: ~66 seconds;
      • Three full acceptance runs in total, two of which failed.
    • Failures and retries:
      • Run 1 failed: returned only an image, no project file;
      • Run 2 failed: the interactive page was generated but did not load the model;
      • Run 3 succeeded: the model, renderings, web page, and README were all present.

    2.2 The Full Prompt

    This prompt uses an original theme and avoids specific, unauthorized anime IP to reduce copyright risk. The prompt was as follows:

    1. Generate a 3D voxel miniature scene with the theme "original anime-style detective agency":
    2. 1. Style: pure voxel-block language; prefer regular geometric primitives and avoid complex organic curves;
    3. 2. Structure: a street-facing ground-floor cafe, a second-floor detective agency, stairs on the side leading up to the second floor, an entrance signboard, and a minor character;
    4. 3. Subject: characters must keep a clear silhouette; hair and facial features expressed with blocky facets, not high precision;
    5. 4. Deliverables: editable project files (.blend/.glb), two renderings (front view, top view), and an interactive web page;
    6. 5. Web page: support drag-to-rotate, zoom, auto-rotate, key-region annotations, and sidebar view focusing;
    7. 6. Output structure: three directories /model, /images, /web, plus a README explaining how to open it;
    8. 7. All geometry should be generated procedurally, without relying on external assets;
    9. 8. If a part cannot be implemented, list the failure reason in the README rather than hiding the problem.

    The key point of this prompt is that it simultaneously constrains the theme, style, structure, deliverables, interaction, and how failures must be disclosed. Compared with simply writing “generate a 3D detective agency,” it substantially improves engineering usability.

    3. Fidelity: Structure Scores and Failure List

    You cannot evaluate 3D generation by saying only “the fidelity is high”—you need an explicit judging standard. This test uses an “expected-element checklist plus a 0-to-5 score.”

    3.1 Judging Criteria

    • Element present: a correctly rendered element scores 1 point; a missing one scores 0.
    • Acceptable proportions: a key part whose proportion error exceeds 15% counts as a failure.
    • Reasonable placement: parts must not visibly intersect, overlap, or detach from the main body.
    • Sources of evidence: project files, rendering screenshots, and the running results of the interactive page.

    3.2 Expected-Element Checklist

    This test predefined 14 expected elements:

    1. Street-facing ground floor;
    2. Second-floor agency;
    3. Side stairs;
    4. Door;
    5. Signboard;
    6. Windows;
    7. Bar counter;
    8. Table and chairs;
    9. Bookshelf;
    10. Table lamp;
    11. Character at the door;
    12. Coffee cup;
    13. Detective props;
    14. Rooftop decoration.

    3.3 Test Results

    Element Expected Actual Score Notes
    Street-facing ground floor Complete storefront space Present, clear structure 5 Position basically reasonable
    Second-floor agency Upper-floor space Present, complete outline 5 Acceptable proportions
    Side stairs Connect ground and second floor Present, correct direction 4 Step density slightly high in places
    Door Identifiable entrance Present 5 Reasonable position
    Signboard Matches theme Present 4 Text rendered as a blocky approximation
    Windows Regular window grid Present 4 Simplified details
    Bar counter Ground-floor cafe function Present 4 Reasonable position
    Table and chairs Identifiable furniture Partially simplified 3 Box-like shapes
    Bookshelf Second-floor agency prop Present 4 Acceptable proportions
    Table lamp Local lighting prop Present 4 Simplified form
    Character at the door Clear silhouette Present but organic features distorted 2 Hair and face failed
    Coffee cup Small prop Present 3 Proportions slightly large
    Detective props Magnifying glass or documents Magnifying glass curve failed 2 Usable after switching to a folder
    Rooftop decoration Outline enhancement Present 4 Matches voxel style

    The overall structural fidelity is about 12/14, roughly 86%. The failures are concentrated in organic forms: the character’s hair, facial details, and the curve of a handheld magnifying glass. This shows that the model is currently strong at regular geometry, spatial relationships, and scene organization, but still has clear weaknesses in organic forms, complex curves, and small-prop fidelity.

    3.4 Comparison Against Baseline Prompts

    To verify the value of prompt design, this test set up two baselines:

    • Baseline A: input only “generate a 3D pixel detective agency.”
      • Result: usually returns only an image, missing the project file, web structure, and acceptance information.
      • Engineering usability: 0/5.
    • Baseline B: use the structured prompt above.
      • Result: delivers model files, renderings, an interactive web page, and a failure explanation.
      • Engineering usability: 4/5.

    Conclusion: 3D generation quality depends not only on model capability but also on whether the prompt clearly specifies the deliverables, style, structure, and acceptance criteria.

    4. Spatial Reasoning: From Natural Language to Coordinates and Hierarchy

    Spatial reasoning is the core capability behind 3D generation and involves at least three layers:

    1. Relation parsing: understanding spatial relationships such as “second floor,” “street-facing,” and “side stairs”;
    2. Structure organization: converting those relationships into a conflict-free 3D layout;
    3. Proportion coordination: keeping element proportions consistent at voxel granularity.

    4.1 Coordinate Mapping Example

    Taking this test’s “original anime-style detective agency” as an example, natural-language descriptions can be mapped to coordinate ranges:

    • Ground-floor street-facing cafe:
      • X range: [-8, 8]
      • Y range: [0, 4]
      • Z range: [0, 6]
    • Second-floor detective agency:
      • X range: [-8, 8]
      • Y range: [4, 8]
      • Z range: [0, 6]
    • Side stairs:
      • X range: [8, 11]
      • Y range: [0, 8]
      • Z range: [1, 3]
    • Character at the door:
      • Roughly near X=7, Y=0, Z=7.

    This mapping helps a model avoid common problems such as a “floating second floor,” “clipping stairs,” and a “floating character.”

    4.2 Hierarchy Tree Example

    1. Scene
    2. ├── Ground
    3. ├── Floor1_Cafe
    4. │ ├── Bar
    5. │ ├── Chair
    6. │ └── CoffeeCup
    7. ├── Floor2_Office
    8. │ ├── Desk
    9. │ ├── Bookshelf
    10. │ └── Lamp
    11. ├── SideStairs
    12. ├── Signboard
    13. ├── Character
    14. └── Props

    If a prompt asks the model to “organize the scene according to a hierarchy tree,” it is more likely to produce a project file with clear structure that is easy to edit.

    5. Interactive 3D Web Page: A Minimal Runnable Example

    One notable finding in the test is that after being asked to “open the model as a web page,” the model was able to complete an interactive page rather than output only an image or a model file. In production, a common approach is to load the model with Three.js or a similar WebGL wrapper framework, then add orbit controls, auto-rotation, zoom, annotations, and view focusing.

    Below is a minimal runnable example. Before use, place the model file at ./model/detective-office.glb, or open the page through a static server.

    1. <!doctype html>
    2. <html lang="en">
    3. <head>
    4. <meta charset="utf-8" />
    5. <meta name="viewport" content="width=device-width, initial-scale=1" />
    6. <title>Voxel 3D Demo</title>
    7. <style>
    8. html, body { margin: 0; height: 100%; overflow: hidden; }
    9. canvas { display: block; }
    10. </style>
    11. <script type="importmap">
    12. {
    13. "imports": {
    14. "three": "https://unpkg.com/three@0.160.0/build/three.module.js",
    15. "three/addons/": "https://unpkg.com/three@0.160.0/examples/jsm/"
    16. }
    17. }
    18. </script>
    19. </head>
    20. <body>
    21. <script type="module">
    22. import * as THREE from 'three';
    23. import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
    24. import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
    25. const scene = new THREE.Scene();
    26. scene.background = new THREE.Color(0xf2f2f2);
    27. const camera = new THREE.PerspectiveCamera(
    28. 45,
    29. window.innerWidth / window.innerHeight,
    30. 0.1,
    31. 200
    32. );
    33. camera.position.set(14, 12, 18);
    34. const renderer = new THREE.WebGLRenderer({ antialias: true });
    35. renderer.setPixelRatio(window.devicePixelRatio);
    36. renderer.setSize(window.innerWidth, window.innerHeight);
    37. renderer.shadowMap.enabled = true;
    38. document.body.appendChild(renderer.domElement);
    39. const light = new THREE.DirectionalLight(0xffffff, 2.2);
    40. light.position.set(10, 15, 10);
    41. light.castShadow = true;
    42. scene.add(light, new THREE.AmbientLight(0xffffff, 0.8));
    43. const controls = new OrbitControls(camera, renderer.domElement);
    44. controls.enableDamping = true;
    45. controls.autoRotate = true;
    46. controls.autoRotateSpeed = 1.0;
    47. controls.minDistance = 8;
    48. controls.maxDistance = 45;
    49. controls.target.set(0, 4, 0);
    50. const loader = new GLTFLoader();
    51. loader.load(
    52. './model/detective-office.glb',
    53. (gltf) => {
    54. scene.add(gltf.scene);
    55. const box = new THREE.Box3().setFromObject(gltf.scene);
    56. const center = box.getCenter(new THREE.Vector3());
    57. controls.target.copy(center);
    58. camera.lookAt(center);
    59. },
    60. undefined,
    61. (error) => {
    62. console.error('Model loading failed:', error);
    63. }
    64. );
    65. function onResize() {
    66. camera.aspect = window.innerWidth / window.innerHeight;
    67. camera.updateProjectionMatrix();
    68. renderer.setSize(window.innerWidth, window.innerHeight);
    69. }
    70. window.addEventListener('resize', onResize);
    71. function animate() {
    72. requestAnimationFrame(animate);
    73. controls.update();
    74. renderer.render(scene, camera);
    75. }
    76. animate();
    77. </script>
    78. </body>
    79. </html>

    5.1 Suggestions for Completing the Interaction

    A usable 3D showcase page usually includes:

    • drag-to-rotate;
    • scroll-wheel zoom;
    • an auto-rotate toggle;
    • key-region annotations;
    • sidebar view focusing;
    • a loading progress indicator;
    • a model-loading failure message;
    • mobile responsiveness.

    If the model is large, it is advisable to compress it, reduce polygon count, or load it in chunks first. The first-screen assets are best kept between 5 MB and 15 MB to avoid making users wait too long.

    6. Systematically Evaluating 3D Generation: A Six-Dimension Scorecard

    To avoid subjective judgment, it helps to break “how good it is” into a six-dimension scorecard. Each dimension is scored from 0 to 5:

    • 0: missing or a severe failure;
    • 1: has obvious errors and needs to be redone;
    • 2: barely usable but with many problems;
    • 3: basically usable;
    • 4: good, with a few minor flaws;
    • 5: excellent, ready for direct business review.
    Dimension 0-to-5 scoring criteria Source of evidence Common failure examples
    Fidelity 0: core scene missing; 1: only scattered elements; 3: main structure complete, proportion deviation under 20%; 5: key elements complete with accurate positions Element checklist, renderings, project file Missing stairs, overlapping rooms, misaligned floors
    Style adherence 0: completely off the specified style; 1: chaotic style; 3: basically matches the voxel style; 5: globally consistent style Screenshots, mesh structure, material notes High-poly curved surfaces in a voxel scene
    Engineering usability 0: only images; 1: corrupted files; 3: importable into common software; 5: clear layers, standard naming, re-editable File formats, directory structure, README Cannot export glb, model not splittable
    Interaction completeness 0: no web page; 1: page errors; 3: can rotate and zoom; 5: includes annotations, focus, loading hints, and error handling Browser run results, interaction screen recording Model doesn’t load, buttons don’t work
    Detail fidelity 0: details completely wrong; 3: small props identifiable; 5: proportions, silhouettes, and local structure all credible Local screenshots, failure checklist Character hair distortion, wrong prop proportions
    Completion reasonableness 0: adds random irrelevant content; 3: completes the basic deliverables; 5: proactively fills real business needs Deliverable checklist, README Adds lots of meaningless decoration

    For this example, the scores are:

    • Fidelity: 4/5;
    • Style adherence: 4/5;
    • Engineering usability: 4/5;
    • Interaction completeness: 4/5;
    • Detail fidelity: 2/5;
    • Completion reasonableness: 4/5.

    The total is 22/30. The weakness is concentrated in detail fidelity—specifically the character’s organic form and small curved props.

    7. Prompt Optimization: Counterexamples and Fixes

    7.1 A Failure Counterexample

    An incorrect prompt:

    1. Generate a 3D detective agency, and make it look good.

    Common problems:

    • No deliverables specified, so the model may return only an image;
    • No style specified, so the model may produce a realistic model;
    • No structure specified, so the model may omit the stairs or the second floor;
    • No web interaction specified, so the model cannot produce a usable page;
    • No requirement to disclose failures, so problems get hidden.

    7.2 The Corrected Prompt

    It is recommended to use a “theme + style + structure + deliverables + web + acceptance” pattern:

    1. Generate an original anime-style detective agency as a 3D voxel miniature scene:
    2. - Style: pure voxel blocks; avoid complex organic curves;
    3. - Structure: ground-floor cafe, second-floor agency, side stairs, signboard, door, windows;
    4. - Character: blocky-faceted expression with a clear silhouette;
    5. - Deliverables: editable project files, two renderings, an interactive web page;
    6. - Web page: supports rotation, zoom, auto-rotate, annotations, and view focusing;
    7. - If any part fails, explain the reason in the README.

    The difference in outcome: after the fix, the model no longer delivers only an image but instead provides model files, renderings, an interactive page, and a failure list, which makes later acceptance and iteration easier.

    8. Cloud Deployment: From Generated Output to an Accessible Page

    When 3D generation moves into production, it often requires cloud infrastructure. A typical pipeline is: object storage holds the models and images, a static-website or container platform serves the page, a CDN accelerates access, and logging and monitoring provide stability observability.

    8.1 Deployment Steps

    1. Package locally

      • Generate /model/xxx.glb;
      • Generate /images/render.png;
      • Generate /web/index.html;
      • Organize the model, images, and page into their directories.
    2. Upload to object storage

      • Create a private bucket;
      • Upload the models, images, and web static assets;
      • Apply least-privilege access policies;
      • For temporary sharing, generate a signed URL instead of making the bucket permanently public.
    3. Deploy the static page

      • Use static-website hosting;
      • Or deploy a container such as Nginx onto a container platform;
      • Ensure .glb returns the correct MIME type, for example model/gltf-binary;
      • Enable gzip or brotli compression.
    4. Configure the CDN

      • Bind a CDN domain to the static site or object storage;
      • Set a long cache for glb and png;
      • Set a short cache for index.html;
      • Use versioned filenames on update, for example detective-office-v3.glb.
    5. Logging and monitoring

      • Enable access logs and error logs;
      • Monitor the 4xx and 5xx error rates;
      • Monitor first-screen load time;
      • Set alerts on the model-loading failure rate.

    8.2 Cost Considerations

    Cloud costs are typically calculated across the following items:

    • Object storage: billed by storage volume and number of requests;
    • CDN: billed by traffic, number of requests, or bandwidth;
    • Container platform: billed by CPU, memory, instance duration, or resource packages;
    • Logging service: billed by ingestion volume, query volume, and retention period.

    It is recommended to start with a small-traffic validation, then scale according to actual traffic.

    8.3 Boundary Conditions

    • When a model file exceeds 50 MB, compress it, reduce polygon count, or load it in chunks;
    • Mobile devices should be served a lower-precision model;
    • Private resources should not be exposed directly; use signed URLs or authentication;
    • If the page needs to be embedded in a business system, handle cross-origin access, permissions, and version updates.

    8.4 Neutral Alternatives

    The choice of cloud provider should factor in cost, compliance, and availability. Beyond the services mentioned in this article, you can also consider:

    • AWS S3 + CloudFront;
    • Alibaba Cloud OSS + CDN;
    • Tencent Cloud COS + CDN;
    • Cloudflare R2 + CDN;
    • Self-hosted Nginx + object storage.

    If an article or solution mentions a specific cloud provider, it is only a technical example and does not constitute a commercial endorsement. Enterprises should choose a solution based on their own budget, data-compliance requirements, and operations capability.

    Before 3D generation goes into production, also pay attention to:

    • Use original themes and avoid unauthorized anime, film, or game IP;
    • Moderate user-uploaded content;
    • Enable access control on object storage;
    • Avoid collecting user privacy in logs;
    • When presenting models publicly, note the generation method or data source;
    • Retain version records and rollback mechanisms for key business models.

    9. Conclusion

    This test shows that large models are moving from “being able to generate content” to “being able to deliver usable products.” In 3D-generation tasks, models can now work together to restore structure, respect style constraints, export files, and complete interactions—but they still have weaknesses in organic forms, proportion fidelity, and small-prop details.

    For developers, the effective path is not to wait for the model to become perfect, but to build a reproducible testing method, use structured prompts, use the six-dimension scorecard to pinpoint problems, and then reliably deliver the generated output into business scenarios through object storage, a CDN, container platforms, and logging and monitoring.