[AI 3D Generation Workflow]
Input (Image/Text)
    ↓
AI Generate Model
    ↓
┌─────────────────┐
│  Visual Ready    │ ✅ Most tools achieve this
└─────────────────┘
    ↓ ⚠️ Gap
┌─────────────────┐
│ Physics Ready    │ ❌ Very few tools achieve
└─────────────────┘
    ↓
Actual Application (Game/VR/AR)
      ↑
   "Last Mile"

[Capability Radar Map]
        Visual Quality
           │
           ⭐⭐⭐⭐⭐
           │
  Geometry ─────┼───── Material
  ⭐⭐⭐⭐   │   ⭐⭐⭐⭐
           │
  Topology ─────┼───── Structure
  ⭐⭐⭐     │   ⭐⭐
           │
  Colliders ─────┴───── Center of Mass
  ⭐☆☆☆☆     ⭐☆☆☆☆

[Visual vs Physics Comparison]
Model: An exquisite chest

Visual Perspective:
┌─────────────┐
│  ▓▓▓▓▓▓▓▓▓ │  ← Exquisite metal textures
│ ▓  Chest  ▓ │  ← Complex carving details
│  ▓▓▓▓▓▓▓▓▓ │
└─────────────┘
"Looks amazing!"

Physics Perspective:
┌─────────────┐
│  ? ? ? ? ?  │  ← Internal structure unknown
│ ? ? ? ? ? ? │  ← Colliders missing
│  ? ? ? ? ?  │  ← Center of mass not calculated
└─────────────┘
"How to interact with it?"

[Cost Chain]
AI tools ignore physics
    ↓
Developers spend time fixing
    ↓
Negates AI time savings
    ↓
Project efficiency declines
    ↓
User satisfaction decreases

[Structural Problem Example]
Chair model
    │
    ├─ Slender chair legs (1cm diameter)
    │   └─ Problem: Cannot support human weight
    │
    ├─ Exquisite backrest carving
    │   └─ Problem: Fragile connections, easily break
    │
    └─ Complex armrest design
        └─ Problem: Unstable center of gravity, easily tips over

// Manually add structural supports in Unity
public class AddStructuralSupport : MonoBehaviour
{
    void AddInvisibleSupports()
    {
        // Method 1: Add invisible support colliders
        GameObject support = new GameObject("Support");
        support.transform.parent = transform;
        support.transform.localPosition = new Vector3(0, 0.25f, 0);

        BoxCollider supportCollider = support.AddComponent<BoxCollider>();
        supportCollider.size = new Vector3(0.5f, 0.5f, 0.5f);

        // Problem: This is "cheating", not true structural repair
    }
}

[Collider Problem Case]
AI-generated door model

Visual: Exquisite medieval wooden door
    ├─ Exquisite carvings
    ├─ Metal door handle
    └─ Hinge details

Physics:
    ❌ No collider
    Result: Character passes directly through door

    Or:
    ⚠️ Door frame has collider, but door panel doesn't
    Result: Character can walk to door frame, but cannot "open" door

[Center of Mass Error Example]
AI-generated vase model

Correct center of mass (at bottom center of vase body):
      ●───┐
     ╱     │
    │  🏺  │
     ╲     │
      └────┘
       ↑
      Center of mass ✓
    (Stable, not easy to tip over)

AI-generated center of mass (at geometric center):
      ●───┐
     ╱  ↑  │
    │ 🏺 │ │
     ╲  │  │
      └─┴──┘
       ↑
      Center of mass ✗
    (Unstable, easy to tip over)

// Manually adjust center of mass position
public class AdjustCenterOfMass : MonoBehaviour
{
    void Start()
    {
        Rigidbody rb = GetComponent<Rigidbody>();

        // Method 1: Use experimental approach
        // Repeatedly test to find stable center of mass position
        rb.centerOfMass = new Vector3(0, 0.1f, 0); // Requires multiple attempts

        // Method 2: Use approximate calculation
        // Assume uniform density, use bounding box center
        // Problem: Inaccurate for irregular or hollow objects
    }
}

[Non-manifold Edge Example]
Normal edge (manifold):
    │
    A
   ╱ ╲
  B   C
   ╲ ╱
    D
(Connects two faces: ABC and ACD)

Non-manifold edge:
    │
    A
   ╱│╲
  B │ C
   ╱│╲
    D
(Connects three faces: ABC, ACD, ABD)
    ↑
 Physics engine cannot handle correctly

[3D Model in World]
3D Model
    ├─ Visual presentation (what others see)
    │   ├─ Geometry shape
    │   ├─ Texture materials
    │   └─ Rendering effects
    │
    └─ Physics properties (foundation of interaction) ← Marble focuses here
        ├─ Structural integrity
        ├─ Collision boundaries
        ├─ Center of mass position
        └─ Physics behavior

Has structural integrity:
    ├─ Won't collapse without reason
    ├─ Can withstand reasonable physical stress
    ├─ Slender parts sufficiently sturdy
    └─ Complex structures self-supporting

No structural integrity:
    ├─ Disintegrates from slight touch
    ├─ Slender parts easily break
    ├─ Complex structures need extra support
    └─ Cannot be used for physics simulation

Has spatial consistency:
    ├─ Stable in any view
    ├─ Doesn't deform after rotation
    ├─ Maintains features after scaling
    └─ Consistent behavior in any scenario

No spatial consistency:
    ├─ Anomalies at certain angles
    ├─ Shape distortion after rotation
    ├─ Lost detail after scaling
    └─ Different behavior in different scenarios

Out-of-the-box ready:
    ├─ Download and import directly
    ├─ No manual collider adjustment needed
    ├─ No center of mass calculation needed
    ├─ No topology repair needed
    └─ Immediately usable in games

Not out-of-the-box ready:
    ├─ Need manual collider addition (30-60 minutes)
    ├─ Need center of mass adjustment (10-20 minutes)
    ├─ Need topology repair (15-30 minutes)
    └─ Need testing and iteration (20-40 minutes)

[Spatial Consistency Engine Architecture]
                    ┌─────────────────┐
                    │   Input Module    │
                    │ (Image/Text)      │
                    └────────┬─────────┘
                             │
                    ┌────────▼─────────┐
                    │  Dual-Engine      │
                    │  Synthesis Layer   │
                    │ ┌─────┬─────────┐ │
                    │ │Trellis│Hunyuan│ │
                    │ └──┬───┴────┬───┘ │
                    │    └───┬────┘     │
                    └─────────┼─────────┘
                              │
              ┌───────────────┼───────────────┐
              │               │               │
    ┌─────────▼──────┐ ┌─────▼─────┐ ┌─────▼──────┐
    │  Geometry       │ │  Topology  │ │   Physics   │
    │  Verification   │ │ Verification│ │ Verification│
    │ ├─ Boundary     │ │ ├─ Manifold │ │ ├─ Mass     │
    │ │  alignment    │ │ │  check    │ │ │  distribution│
    │ ├─ Gap detection│ │ ├─ Closure   │ │ ├─ Center   │
    │ └─ Overlap       │ │ └─ Connectivity│ │ │  of mass   │
    │    detection    │ │             │ │ └─ Stability │
    └───────┬────────┘ └─────┬─────┘ └─────┬─────┘
            │                 │               │
            └─────────────┬───┴───────────────┘
                          │
                ┌─────────▼─────────┐
                │  Repair &         │
                │  Optimization     │
                │  Layer            │
                │ ├─ Auto repair     │
                │ ├─ Collider        │
                │ │  generation      │
                │ └─ Physics property │
                │    setup           │
                └─────────┬─────────┘
                          │
                ┌─────────▼─────────┐
                │  Quality Scoring   │
                │  Module            │
                │  └─ Marble Score    │
                └─────────┬─────────┘
                          │
                ┌─────────▼─────────┐
                │  Output Module     │
                │  └─ GLB/GLTF export │
                └───────────────────┘

[Dual-Engine Synergy]
Input: Chest image
    │
    ├─────────────┬─────────────┐
    │             │             │
 Trellis        Hunyuan3D
(Adobe Research) (Tencent)
    │             │
    ├─ Structure   ├─ Texture
    │  specialist  │  specialist
    ├─ Excellent   ├─ Rich
    │  topology    │  details
    │  Good        │  Realistic
    │  stability   │  visuals
    │             │
    └──────┬──────┘
           │
    [Spatial Synthesis Algorithm]
           │
    ┌──────▼──────┐
    │ Final Output │
    │ ├─ Sturdy    │
    │ │  structure │
    │ ├─ Exquisite │
    │ │  textures  │
    │ └─ Physics   │
    │   ready     │
    └─────────────┘

[Geometry Verification]
Input model
    ↓
Boundary alignment verification
    ├─ Detect height differences of adjacent faces
    ├─ Identify discontinuous edges
    └─ Verify surface smoothness
    ↓
Gap detection
    ├─ Identify tiny gaps
    ├─ Detect unnecessary overlaps
    └─ Calculate optimal boundary positions
    ↓
Self-intersection detection
    ├─ Raycast detection
    ├─ Face-to-face intersection verification
    └─ Mark problem areas
    ↓
Auto repair
    ├─ Fill gaps
    ├─ Eliminate overlaps
    └─ Separate intersecting faces

[Topology Verification]
Manifoldness check
    ├─ Verify each edge connects two faces
    ├─ Detect non-manifold geometry
    └─ Fix non-manifold structures
    ↓
Closure verification
    ├─ Detect holes and cracks
    ├─ Verify mesh integrity
    └─ Fill necessary openings
    ↓
Connectivity analysis
    ├─ Check isolated vertices
    ├─ Verify edge connections
    └─ Clean up unused elements

[Physics Verification]
Volume & mass analysis
    ├─ Calculate model volume
    ├─ Estimate mass distribution
    └─ Identify density anomalies
    ↓
Center of mass calculation
    ├─ Discretize volume units
    ├─ Calculate mass contributions
    ├─ Determine weighted average position
    └─ Adjust for special cases
    ↓
Stability prediction
    ├─ Analyze center of mass position
    ├─ Evaluate support base area
    ├─ Predict tipping risk
    └─ Generate stability report

[Marble GLB File Structure]
├── Render mesh
│   ├── Vertex data
│   ├── Triangle face indices
│   └── Texture coordinates
├── Texture maps
│   ├── Color map
│   ├── Normal map
│   └── Roughness map
├── Colliders ✅
│   ├── Optimized collision mesh
│   └── Collider metadata
├── Physics properties ✅
│   ├── Center of mass position
│   ├── Mass estimation
│   └── Physics material parameters
└── Marble score ✅
    └── Quality score report

{
  "Marble": {
    "version": "1.0",
    "model_id": "marble_12345",
    "physics_ready": true,
    "collider": {
      "type": "mesh",
      "optimized": true,
      "convex": false
    },
    "rigidbody": {
      "mass": 1.0,
      "centerOfMass": [0.0, 0.5, 0.0],
      "useGravity": true
    },
    "marble_score": 87
  }
}

Marble Score = Structural Integrity × 30% + Geometric Consistency × 30% + Physics-Readiness × 40%

Where:
Structural Integrity = Topology quality × 50% + Stability × 50%
Geometric Consistency = Spatial persistence × 50% + Transform stability × 50%
Physics-Readiness = Collider quality × 40% + Center of mass accuracy × 30% + Physics parameters × 30%

[Score Value Chain]
High Marble score
    ↓
Developers confident to use
    ↓
Reduced testing and verification time
    ↓
Accelerated project progress
    ↓
Improved final product quality

[Traditional Tool Output]
Generation time: 2 minutes
Output file: chest.obj

Visual assessment: ⭐⭐⭐⭐⭐
    └─ Exquisite geometric shapes
    └─ Gorgeous metal textures
    └─ Complex carving details

Physics-ready assessment: ⭐☆☆☆☆
    ├─ Colliders: ❌ None
    ├─ Center of mass: ❌ Not calculated
    ├─ Topology: ⚠️ May have defects
    └─ Structure: ⚠️ May be unstable

Post-processing needs:
    ├─ Add colliders: 30 minutes
    ├─ Calculate center of mass: 10 minutes
    ├─ Check topology: 15 minutes
    ├─ Test stability: 20 minutes
    └─ Total: 75 minutes

[Marble Output]
Generation time: 3 minutes
Output file: chest_marble.glb

Visual assessment: ⭐⭐⭐⭐⭐
    └─ Exquisite geometric shapes
    └─ Gorgeous metal textures
    └─ Complex carving details

Physics-ready assessment: ⭐⭐⭐⭐☆
    ├─ Colliders: ✅ Auto-generated optimized colliders
    ├─ Center of mass: ✅ Precisely calculated
    ├─ Topology: ✅ Manifold mesh verification passed
    └─ Structure: ✅ Stability prediction good

Marble score: 87/100
    ├─ Structural integrity: 85/100
    ├─ Geometric consistency: 90/100
    └─ Physics-readiness: 86/100

Post-processing needs:
    └─ None needed, direct import and use

// Unity import traditional AI-generated model
GameObject chest = new GameObject("Chest");

// 1. Import model
// Need to manually drag in OBJ file

// 2. Add Mesh Renderer (automatic)
MeshRenderer renderer = chest.AddComponent<MeshRenderer>();
// Visual effect: ✅ Exquisite

// 3. Add collider (manual)
MeshCollider collider = chest.AddComponent<MeshCollider>();
collider.convex = true;
// Problem: May be too complex, poor performance

// 4. Add Rigidbody
Rigidbody rb = chest.AddComponent<Rigidbody>();
rb.mass = 5f;
// Problem: Center of mass not calculated, chest may tip

// 5. Test
// Result: Chest rolls on floor, cannot be stably placed

// 6. Fix (extra time needed)
// - Adjust center of mass
// - Optimize collider
// - Add support structure

// Unity import Marble-generated model
GameObject chest = new GameObject("Chest_Marble");

// 1. Import model (with physics properties)
// Drag in Marble GLB file

// 2. Apply Marble preset (one-click)
MarblePrefab.Apply(chest);

// 3. Auto configuration complete
// - Colliders: ✅ Optimized Mesh Collider
// - Center of mass: ✅ Precise position
// - Mass: ✅ Reasonable estimate

// 4. Test
// Result: Chest stably placed, natural physics behavior

// 5. No fix needed

// Unreal import traditional AI-generated model
ATraditionalChest* Chest = GetWorld()->SpawnActor<ATraditionalChest>();

// 1. Import model
// Need to manually import FBX/OBJ

// 2. Create collider
UBoxComponent* Collider = CreateDefaultSubobject<UBoxComponent>(TEXT("Collider"));
// Problem: Box Collider not precise enough

// 3. Configure physics
UPrimitiveComponent* RootComponent = GetRootComponent();
RootComponent->SetEnableGravity(true);
// Problem: Center of mass not set

// 4. Test
// Result: Less than ideal physics behavior

// Unreal import Marble-generated model
AMarbleChest* Chest = GetWorld()->SpawnActor<AMarbleChest>();

// 1. Import model (with physics properties)
// Marble GLB file automatically recognized

// 2. Apply Marble settings
// Colliders, center of mass, mass auto-configured

// 3. Test
// Result: Perfect physics behavior