AI 3D generation

CONCEPT (single object for image-to-3D)
A [stylized low-poly | realistic | hand-painted] [object], one object only,
centered, whole object in frame with margin, three-quarter view from slightly
above, plain light-gray background, soft even studio lighting, no cast
shadows, no text, no props, clear silhouette, solid (not transparent) materials.

TURNAROUND SHEET (props, vehicles, buildings)
Orthographic reference sheet of [object]: front, left side, back and top views
in a row, same scale, aligned on a common ground line, no perspective,
flat neutral lighting, plain white background, thin gaps between views,
no labels, identical design in every view.

CHARACTER TURNAROUND
Character reference sheet of [description], full body, A-pose (arms 45° down,
legs slightly apart), front, side and back views side by side, same height,
orthographic, neutral expression, flat even lighting, plain background,
fingers separated, no weapon or loose props, no motion blur, no cropping.

SEAMLESS TILEABLE TEXTURE
Seamless tileable [red brick wall | mossy cobblestone | oak planks] texture,
top-down orthographic, fills the whole square frame, even diffuse lighting,
no shadows, no highlights, no vignette, no perspective, [2 m] of real-world
surface per tile, consistent scale, 1:1 aspect.

TRIM SHEET
Game trim sheet texture, square, horizontal strips stacked edge to edge:
[crown molding, plain concrete band, metal panel with rivets, window frame,
brick soldier course], each strip full width, flat front view, even lighting,
no shadows, no gaps, no text.

DECAL
Single [rust stain | peeling poster | graffiti tag] decal, centered on a plain
pure-white background, front view, flat lighting, soft natural edges, no
frame, no shadow, isolated.

SKY BACKDROP (background only, not lighting)
Wide 360-degree equirectangular panorama of [overcast sky over low hills],
horizon exactly at the vertical middle, no sun disk, no buildings, soft gradient.

 generate (image → 3D, 3–4 variants)       pick the one with the best silhouette
      │
 import GLB into Blender 5.x               File > Import > glTF 2.0
      │
 scale, orient, origin                     real meters, Z up, feet on 0, apply transforms
      │
 clean                                     merge by distance, delete floaters, fill holes
      │
 retopo or decimate                        props: Decimate; characters: retopology
      │
 UV unwrap                                 new, clean UVs on the low-poly mesh
      │
 bake                                      old texture + high-poly detail → new maps
      │
 material check                            one Principled BSDF, image textures only
      │
 rig (optional)                            vendor auto-rig, Mixamo, or Rigify
      │
 export                                    GLB for web and Godot, Sollumz for GTA V

import bpy
import bmesh
from mathutils import Matrix, Vector
 
def tris(ob: bpy.types.Object) -> int:
    return sum(len(p.vertices) - 2 for p in ob.data.polygons)
 
def normalize(ob: bpy.types.Object, height: float) -> None:
    """Bake transforms into the mesh, scale it to `height`
    meters, origin at bottom center, placed at 0,0,0."""
    me = ob.data
    mw = ob.matrix_world.copy()
    ob.parent = None  # glTF imports may add a parent
    me.transform(mw)
    ob.matrix_world = Matrix.Identity(4)
    lo = Vector([min(v.co[i] for v in me.vertices)
                 for i in range(3)])
    hi = Vector([max(v.co[i] for v in me.vertices)
                 for i in range(3)])
    k = height / (hi.z - lo.z)
    base = Vector(((lo.x + hi.x) / 2, (lo.y + hi.y) / 2,
                   lo.z))
    me.transform(Matrix.Scale(k, 4) @
                 Matrix.Translation(-base))
    bm = bmesh.new()
    bm.from_mesh(me)
    bmesh.ops.remove_doubles(bm, verts=bm.verts,
                             dist=0.0001)  # weld seams
    bm.to_mesh(me)
    bm.free()
 
def decimate(ob: bpy.types.Object, target: int) -> None:
    """Non-destructive Decimate modifier to ~target tris."""
    mod = ob.modifiers.new("Decimate", "DECIMATE")
    mod.ratio = min(1.0, target / max(tris(ob), 1))
 
ob = bpy.context.active_object
normalize(ob, height=1.0)  # this prop is 1 m tall
decimate(ob, target=5000)

1. Image model: CONCEPT template → 3–4 options → pick one; regenerate a
   side and back view if the tool takes multi-view input.
2. Higgsfield image → 3D (web, add-on "3D Model" tab, or ask Claude with the
   Higgsfield connector: "turn this image into a 3D model"). Download the GLB.
3. Blender: File > Import > glTF 2.0. Run normalize() + decimate() above
   (target 5–20k tris for web).
4. Check the albedo for baked shadows; paint them out or regenerate.
5. If you will edit the texture: Smart UV Project on a copy, bake the
   original texture across ("Selected to Active").
6. Export GLB → optimize and load: /3d/export/web-threejs/.

1. CHARACTER TURNAROUND template (A-pose, fingers apart, no props).
2. Meshy or Tripo multi-image → 3D, humanoid, quad or low-poly output,
   ~10–30k faces.
3. Blender: normalize(height=1.75), delete floaters, Mirror modifier if the
   halves drifted, one material, check the face and hands.
4. Rig: vendor auto-rig, or export FBX → Mixamo auto-rigger → download with
   skin; add clips "without skin".
5. Blender: import the FBX, fix 0.01 scale, rename or keep mixamorig: bones,
   push each clip to its own NLA track, name them (Idle, Walk, Run).
6. Export GLB; in Godot the clips arrive in an AnimationPlayer:
   /3d/export/godot/.

1. SEAMLESS TILEABLE TEXTURE template, "red brick wall, 2 m per tile".
2. Check tiling: place the image 2×2 (any image editor, or a Blender plane with
   the UVs scaled by 2). Fix seams by offsetting 50% and painting the cross.
3. Make normal and roughness maps from it (Materials & UVs covers the nodes),
   or generate them and confirm the bricks line up.
4. Principled BSDF: Base Color (sRGB), Roughness and Normal (Non-Color).
5. UV the wall to real size so one tile covers 2 m; bake or export as GLB.

1. TURNAROUND SHEET of the facade for reference; generate trim sheet and
   decals with the templates above.
2. Block out walls, floors, openings on a 1 m grid by hand, from a modular
   kit, or with Claude + MCP (/3d/ai-workflows/llm-blender/).
3. Map the trim sheet onto moldings and window frames; tileable textures on
   walls; decals for dirt and signs.
4. Use image-to-3D only for small props that dress it (planters, lamps).
5. Export per target; collision meshes stay simple boxes.

1. Image model: one CONCEPT image per prop, same style words in every prompt.
2. Run Stable Fast 3D (≈ 6 GB VRAM, runs on Apple Silicon) or TRELLIS.2
   (24 GB NVIDIA) on the folder; mind each model's license.
3. Blender: import all, run normalize() + decimate(target=2000) per object,
   join each prop into one material.
4. Batch-export one GLB per object (script in /3d/ai-workflows/llm-blender/).

1. Rig the character (auto-rig or Mixamo) and export it.
2. Meshy Text to Motion: "a character waving with the right hand", 3 s;
   or pick a clip from Higgsfield's animation library.
3. Apply it to your rig in the vendor tool, or import the FBX/BVH into Blender
   and retarget onto your armature.
4. Clean foot slide and the first/last frames so it loops; export.