Evaluating LLMs for 3D Creation and Interactive Web Generation: A Practical Acceptance Framework

    This article examines 3D creation and spatial reasoning as a new dimension for evaluating large language models. It proposes a bare-prompt deliverable contract, a five-part acceptance framework covering semantic completeness, geometric consistency, editability, rendering quality, and interaction usability, and practical engineering guidance for prompts, checklists, quotas, and reproducible pipelines.

    1. Background: 3D Creation Is Becoming a New Dimension for Model Evaluation

    As capabilities such as code generation and text summarization move toward increasingly homogeneous competition, 3D creation and spatial reasoning are becoming an important window into the overall capabilities of large models. The reason is that 3D tasks require a model not only to “generate content” but also to maintain structural consistency under implicit geometric constraints: how floors are connected, whether stairs are reachable, whether the positional relationship between shops and office areas is reasonable, and whether theme signage appears at visual anchor points. These requirements are closer to real engineering delivery than simple text continuation.

    A raw-prompt test reveals several useful observations. First, the model can deliver two rendered images and an editable 3D project file, indicating that it has preliminary organizational capability from natural language to 3D assets. Second, elements such as the building main body, second-floor staircase, agency floor, ground-floor shop, and character accents basically appear, indicating that the model has some understanding of scene semantics. Third, the theme signboard is missing, exposing insufficient identification of key semantic priorities: the signboard is the visual anchor of a themed miniature landscape, and its absence directly affects theme recognizability. Fourth, the interactive web page supplements functions that the prompt did not explicitly require, such as drag-to-rotate, auto-rotate, scene annotations, view focus, model download, image switching, and first-time onboarding, indicating that the model has potential in deliverable expansion.

    Therefore, evaluation should not only ask “whether the rendered images look good.” It should establish an acceptance framework oriented toward engineering delivery: whether semantics are complete, whether geometry is consistent, whether the project is editable, whether the web page is usable, and whether quotas are controllable. Only by turning a one-off experience into a reproducible process can the model’s 3D creation capability be judged objectively.

    2. Evaluation Design: Even a Bare Prompt Needs a Deliverable Contract

    A “bare prompt” does not mean no constraints. If the prompt only says “make a themed miniature landscape,” the model may return only images and may omit an editable project file. A reasonable bare prompt should include five layers of information: task, semantics, style, deliverables, and acceptance. For example:

    1. Task: Use a general-purpose 3D modeling tool to create a "Detective Agency" themed voxel miniature landscape.
    2. Style: Voxel block language, miniature landscape, recognizable theme.
    3. Semantic elements: building main body, second-floor staircase, agency floor, ground-floor shop, theme signboard, character accents.
    4. Deliverables: editable 3D project file, at least two rendered images, optional interactive viewer.
    5. Acceptance: project can be opened, semantics are complete, views can be focused, web page supports drag-to-rotate.

    The value of this template is that it turns “expectations” into a “contract.” Among these items, the “editable project file” is used to check object grouping, hierarchy naming, and material adjustability; “at least two rendered images” are used to observe composition and lighting consistency; the “optional interactive viewer” is used to evaluate web delivery capability. During evaluation, prompt versions, generation time, artifact hashes, missing items, and failure reasons should also be recorded to avoid scoring solely by subjective impression. If platform quotas are limited, priority should be given to retaining three core artifact types: project files, rendered images, and interactive web pages. The consumption of each retry should also be recorded to provide a basis for subsequent batch evaluation.

    3. Acceptance Breakdown: From “Does It Look Right?” to “Is It Usable?”

    3D creation acceptance can be broken down into five dimensions: semantic completeness, geometric consistency, editability, rendering quality, and interaction usability. Semantic completeness focuses on whether key elements such as the theme signboard, staircase, functional floor zoning, and character accents are all present; a missing theme signboard should directly lead to a deduction because it is the anchor for scene recognition. Geometric consistency focuses on whether the staircase connects floors, whether the positional relationship between shops and the agency is reasonable, and whether the voxel scale is uniform. Editability focuses on whether the project file is grouped by object, whether naming is clear, and whether materials are adjustable. Rendering quality focuses on whether composition, lighting, filters, and viewpoints serve the theme expression. Interaction usability focuses on whether the web page supports drag-to-rotate, auto-rotate, scene annotations, view focus, model download, image switching, and first-time onboarding.

    A simple acceptance script can be built with pseudocode:

    1. required = ["building main body", "second-floor staircase", "ground-floor shop", "theme signboard", "character accents"]
    2. actual = scan_project("editable_project")
    3. missing = [item for item in required if item not in actual.semantics]
    4. score = {
    5. "semantic": 100 - 20 * len(missing),
    6. "geometry": check_connections(actual),
    7. "editable": check_groups(actual),
    8. "render": review_images(actual.renders),
    9. "interaction": check_viewer("viewer.html")
    10. }

    This script is not a specific product interface; it expresses an acceptance approach: first list required semantics, then scan project artifacts, and finally score by dimension. In practice, it should also check whether annotations are consistent with model coordinates, whether focus animations clip through objects, whether mobile devices are usable, and whether resource loading failures have fallback prompts. The web page is not decoration; it is part of the deliverable.

    4. Interactive Web Page: From Static Delivery to Scenario-Based Application

    The value of an interactive web page lies in turning a 3D model into an operable scene. Basic capabilities include drag-to-rotate, auto-rotate, and zoom; enhanced capabilities include scene annotations, view focus, model download, image switching, and first-time onboarding. Scene annotations are suitable for applications such as sand tables, urban modeling, and real-estate visualization, mapping key elements in the model to clickable labels. View focus binds labels to camera viewpoints so that users can quickly locate the theme signboard, staircase, or shop. The data structure can be simplified as:

    1. const annotations = [
    2. { id: "sign", label: "Theme signboard", position: [0, 0, 0], focus: true },
    3. { id: "stair", label: "Second-floor staircase", position: [0, 0, 0], focus: true },
    4. { id: "shop", label: "Ground-floor shop", position: [0, 0, 0], focus: true }
    5. ];

    During acceptance, check whether annotation names are consistent with the semantic checklist, whether focus positions are accurate, whether viewpoint switching is smooth, whether the download entry is available, and whether first-time operation guidance is provided. If the web page supplements functions not required by the prompt, they should be recorded as bonus items but cannot replace core semantic acceptance. For smart visualization projects, the interactive web page should also consider resource size, lazy loading, mobile adaptation, and graceful degradation to avoid a situation where “the demo works but the delivery does not.”

    5. Engineering Recommendations: Prompts, Checklists, Quotas, and Pipelines

    First, layer the prompt. The task layer describes the theme and style; the semantic layer lists required elements; the delivery layer specifies project files, rendered images, and web pages; the acceptance layer clearly states openable, editable, focusable, and draggable. Second, establish an acceptance checklist. Whether files exist, whether images are complete, whether the web page opens, whether semantics are complete, whether interactions are usable, and whether logs are retained should all be recorded item by item. Third, control quotas and costs. Validate the process with small scenes first, then expand to large scenes; limit voxel counts, texture sizes, and web resources; set upper limits for failure retries; and use queues for batch tasks. Fourth, archive in an engineering manner. With general-purpose categories such as object storage, container platforms, log services, and monitoring and alerting on Baidu AI Cloud, rendered artifacts can be archived, batch rendering tasks can be executed, failure reasons can be recorded, and resource consumption can be observed, thereby turning one-off evaluation into a reproducible pipeline.

    Finally, evaluation should avoid judging solely by a single rendered image. A more reasonable conclusion should cover editable delivery, semantic completeness, spatial consistency, interaction enhancement, and controllable quotas at the same time. 3D creation capability is not the ability to “generate an image”; it is the ability to turn natural-language requirements into inspectable, editable, and interactive engineering assets. Only by establishing clear prompt contracts and acceptance checklists can developers objectively compare different approaches and truly integrate model capabilities into visualization, digital twin, and 3D content production workflows.