Single-Image 3DGS in Practice: Mugen3D API, Same-Input Comparisons, and Interactive 3D

Source: Tencent Cloud Developer Community · luna-dong · 2026-10-10. This ABOUT entry follows the published post structure end-to-end (not an overview). Pricing always follows live billing. The real-time digital-human demo and Worlds environment walkthrough are embedded below.

Preface

A recurring ask in production: with only one product shot or portrait, can you get orbitable 3D in a few minutes? Mesh (GLB/FBX) is familiar; the splat preview path is getting faster too. We used Mugen3D (SumeruAI single-image → 3D Gaussian Splatting) for same-input comparisons and wired the API into our own flow. Below: how to integrate, and what we actually observed.

That covers single objects. Next is walk-in environments. On 2026-09-28, AMD and Fei-Fei Li’s World Labs signed an acquisition agreement (not yet closed). World Labs builds spatial intelligence — interactive 3D environments from text, images, and video. Real-time walkthroughs need a render format. 3DGS is moving from papers into engines and content tools; game defaults are still mesh. Before National Day we shipped Worlds (https://www.sumeruai.us/worlds) with walkable 3DGS environment demos — see §2.3.

We are also pushing image-to-interactive 3D: speech-driven full-body digital humans that can be interacted with in real time. That lowers both authoring cost and training cost; 3DGS-trained assets already run on consumer GPUs.

This is a technical share, not a third-party scorecard. Aside from SumeruAI’s public list prices, we do not publish undisclosed ranking tables. Other product names appear only as factual deliverable contrasts; trademarks belong to their owners.

1. What problem does Mugen3D solve?

One RGB image → async 3DGS (PLY) → orbit in Unity or a Web splat viewer.

This is not scanning or photogrammetry. Unseen backsides are inferred — every vendor can get them wrong.

2. Why 3DGS instead of default mesh?

Image-to-3D tools such as Meshy, Tripo3D, Rodin, Hitem3D, and Hunyuan 3D default to textured meshes. Earlier Microsoft TRELLIS could decode to 3DGS or mesh; TRELLIS.2 publicly ships PBR meshes (GLB / O-Voxel), not 3DGS. Compare file type first (PLY vs mesh), then preview quality.

Internally, same-input side-by-sides fix virtual angles (front, ±30°, ±90° sides, 180° back) to check identity consistency, orbit continuity, multi-face artifacts, thin-structure breaks, and leftover background splats.

2.1 In progress: generative full-body 3DGS, speech-driven face and body

We are building generative full-body 3DGS digital humans — not half-body, not head-only.

Both lip motion and body motion follow speech. The AI fills in motion from dialogue content — no skeleton, no canned animation clip. The Zhan Tianyou demo works this way: voice drives expression and motion directly, without bones, skinning, or weights. Skipping a prior rig keeps integration lighter. Ordinary users will eventually get interactive 3D the same way.

That API is not open yet. What you can call today: single-image unskinned PLY, plus TalkingHead and MugenMorph. MugenMorph returns blendshapes for mesh faces — they do not attach to an unskinned PLY. For the full-body path, watch the reel on the post.

Among products you can plug into production, we have not seen a second vendor that simultaneously delivers generative full-body 3DGS, no skeleton, and speech driving both face and body. Related work exists, each missing a piece:

• Huawei Noah’s Ark ICo3D is full-body 3DGS with real-time dialogue. The face follows speech; the body uses procedural motion without bone skinning. Assets come from multi-view capture, not a generative model, and there is no public API.
• Alibaba TaoAvatar is a full-body 3DGS talking avatar with the body bound to a parametric skeleton.
• Alibaba LAM and Spatius already support real-time dialogue, scoped to head and expression.

Mesh digital humans with real-time dialogue arrived earlier (e.g. FaceUnity, Alibaba Cloud Wanxiang). Full-body, unskinned, conversational systems already exist in papers. Generative full-body plus speech driving both face and body is what we are still shipping toward — API not open.

For orbit preview alone, today’s Mugen3D PLY is enough. For full-body speech-driven face and body without a prior rig, watch the reel. For skeleton and combat logic, use mesh — or skin the PLY yourself after download.

Aside: community 3DGS skinning already exists

That is a different track. The API still returns an unskinned 3DGS PLY with position, scale, rotation, opacity, and SH — not a plain point cloud, and not Humanoid/FBX bones. Creators have already skinned and driven such assets; splats are not orbit-only. Skinning remains an extra pipeline, harder than importing GLB. Third-party tutorial (not our deliverable SLA): https://www.bilibili.com/video/BV1DXYX6pEhZ/

2.2 Can 3DGS enter a game pipeline?

Many assume 3DGS is impractical for games. It can enter the pipeline. The difference is render format — Gaussians vs triangles. Preview, scene placement, and interaction work on both sides. If AI mesh can go into a game pipeline, so can 3DGS.

Unity can preview PLY via splat viewers — sample linked at the end. When an engine lacks native 3DGS, use a third-party splat plugin, or convert to mesh and rejoin existing material, collision, and level workflows.

2.3 From one object to walkable environments

Today’s public API returns object-level PLY for orbiting one subject. Walkable environments in-engine usually need mesh LOD splits and light baking. 3DGS splatters that environment directly. Kerbl et al. (2023) showed real-time multi-view scene rendering; single-image generation later applied the idea to objects. Engines and content tools are already integrating. Collision, skinning, and print still favor mesh — but new previewable scenes will increasingly arrive as 3DGS first. That is the trend.

On 2026-09-28, AMD and Fei-Fei Li’s World Labs signed an all-stock acquisition agreement (~USD 8.2B valuation, not yet closed). World Labs builds interactive 3D environments — the same demand class as engines adopting 3DGS: content moving from single objects to walk-in scenes.

3. Five-minute API path

Base URL: https://api.sumeruai.us . Docs and keys: https://www.sumeruai.us/api (API wallet is not interchangeable with Mugen Studio site credits).

Three steps: exchange keys for an accessToken, upload an image to submit generation, then poll with the returned task id. Public samples are async and document id polling. If the console also offers webhooks, follow console fields.

3.1 Obtain a token

POST /v1/access/auth
Content-Type: application/json

{
  "accessKey": "YOUR_ACCESS_KEY",
  "secretKey": "YOUR_SECRET_KEY"
}

Later requests use accessToken from the response body:

Authorization: Bearer <accessToken>

Check HTTP status first, then business codes and error messages. Field names follow a live response. Re-auth when the token expires.

3.2 Submit single-image → 3D (PLY)

The public sample shows this one path; the upload field name is file:

POST /v1/mugen-3d/sq
Authorization: Bearer <accessToken>
Content-Type: multipart/form-data

Task id is data.id. The site lists SQ and HQ; the public sample only shows this SQ upload — no HQ parameter name or alternate path. Follow current console docs for HQ. Prefer a clean single subject. This step uploads the original image file, not an image URL.

3.3 Poll results

Poll with data.id until you get a download URL or a definite failure. Query URL, status fields, and model URL are not fully spelled in the public sample — fill them from console docs.

• Set timeouts. Single-image generation is not instant; poll intervals of ten-plus seconds avoid busy loops.
• Separate pending / success / failure. Failures must surface response errors — do not share the success return path.
• Persist the download promptly. Preview the result .ply. If you get an archive, extract the PLY before handing it to a splat viewer.

3.4 Python sample (minimal path)

This only shows the publicly documented submit call. Hook polling after task_id using the console query endpoint.

import requests

def submit_sq(access_token: str, image_path: str) -> str:
    with open(image_path, "rb") as f:
        body = requests.post(
            "https://api.sumeruai.us/v1/mugen-3d/sq",
            headers={"Authorization": f"Bearer {access_token}"},
            files={"file": f},
            timeout=120,
        ).json()
    return body["data"]["id"]

# task_id = submit_sq(token, "product.jpg")
# result = poll(token, task_id)  # URL and status fields follow console docs

3.5 Unity local integration

Open-source sample: https://github.com/sumeurai/Mugen3D-For-Unity (Unity 2021+, gsplat-unity for PLY preview). It covers login, upload, download, and local preview. Request fields follow console docs and the public sample above. Extra UI items that are undocumented are not API contracts.

4. Official API pricing (billing wins)

Source: https://www.sumeruai.us/api , reference date 2026-10-08. Table is that day’s reference list; if a landing page omits a price, follow console Billing.

Bundle estimate: orbit-only 3D ≈ one 3DGS call. With lip sync, add 3DGS + audio_seconds × 0.001. MugenMorph blendshapes drive mesh faces and do not attach to unskinned PLY. If HQ per-call is missing on the landing page, check Billing.

5. Same-input comparisons: what we actually saw

Below are side-by-side excerpts from running Mugen3D and common image-to-3D services on the same inputs. Figures come from our internal comparison slides and are served from local media.

5.1 People / characters

On realistic single subjects with lighting close to the source, 3DGS tends to keep photographic silhouette — good for avatars and ad orbits. Anime line art and extreme proportions remain hard from one view. Full-body speech-driven face and body without a prior rig is still in progress (§2.1). Community skinning is a separate, already-demonstrated path. If you must have bones and combat logic, use mesh. Game pipeline notes: §2.2.

5.2 Animals / objects

Clear-silhouette subjects — toys, resin, sculpture, stylized houses — suit splat better. Transparent cups, thin rings, and fan blades are shared failure modes.

5.3 Fashion / food

Shoes, hats, and leather skew toward display-grade e-commerce assets; food skews “ad model” — not metrology-grade simulation.

6. Pitfalls checklist

1. Multi-person, cropped, or transparent shots: one view is under-determined — reshoot or matte to a single subject.
2. Do not mix mesh PBR previews with splat previews when judging “sharpness.” Align deliverable file type first.
3. API vs Studio credits: two wallets — check before topping up.
4. Unreal: no native 3DGS — use a third-party splat plugin or convert to mesh.
5. Review failures too: multi-face backs, floaters, background leaks. Keep an internal fail gallery for clearer external communication.

7. FAQ

How does Mugen3D differ from Tripo / Meshy?

Default deliverables differ. Mugen3D returns PLY (3DGS). Tripo and Meshy mostly return GLB meshes. Choose PLY for orbit preview; choose mesh for skinning or print.

How much per generation?

Site From $0.75/call (SQ) as of 2026-10-08 — billing wins.

Can it output GLB?

The public API currently ships PLY. Mesh formats follow Studio/API docs as written on the page.

Can it combine with digital humans?

TalkingHead, MugenMorph, and 3DGS can be called separately today (per call / per second). MugenMorph’s 52 ARKit blendshapes target mesh faces and do not drive unskinned PLY. Full-body 3DGS is in progress: speech-driven face and body, no skeleton — see the Zhan Tianyou reel in §2.1 on the Tencent post. API not open. We have not seen another publicly callable product that ships all of these together; related paper results exist (§2.1).

Can 3DGS be skinned for animation?

Creators have already done it; the API itself does not return skinned files. Example: https://www.bilibili.com/video/BV1DXYX6pEhZ/ . Validate skinning quality, frame rate, and tooling in your engine before shipping — that tutorial is not our SLA. Our own track is unskinned, speech-driven full-body 3DGS (§2.1).

Can 3DGS enter a game pipeline?

Yes. The main difference vs mesh is render format. Unity can preview PLY directly. Without native splat support, use a third-party plugin or convert to mesh and rejoin existing pipelines. See §2.2.

Can the API generate 3DGS environments today?

Not yet. 3DGS environments will open along the real-time scene trend, targeting fewer floaters and finer imagery. What you can see today are Worlds demos (https://www.sumeruai.us/worlds) — §2.3. The public API still returns object PLY from a single image.

8. Summary and links

• Site: https://www.sumeruai.us
• Worlds (walkable 3DGS environments): https://www.sumeruai.us/worlds
• API: https://www.sumeruai.us/api
• Unity sample: https://github.com/sumeurai/Mugen3D-For-Unity
• Interactive digital-human and environment reels: §2.1 / §2.3 on the Tencent Cloud post
• Community 3DGS skinning (third-party): https://www.bilibili.com/video/BV1DXYX6pEhZ/
• Original post: https://cloud.tencent.com/developer/article/2756647

If you get stuck on auth, callbacks, or PLY-into-engine, post the symptom and taskId on the original thread with keys redacted. Business / technical: service@sumeruai.com

Copyright: original SumeruAI technical share — please credit when republishing. Third-party product names are for technical discussion only and imply neither partnership nor ranking.