Update app.py

Guide neural sprites by camera and palette

app.py

@@ -126,6 +126,7 @@ PRIMARY_LORA_MODEL = os.environ.get("PRIMARY_LORA_MODEL", "latent-consistency/lc
 PRIMARY_IMAGE_STEPS = int(os.environ.get("PRIMARY_IMAGE_STEPS", "4"))
 PRIMARY_GUIDANCE_SCALE = float(os.environ.get("PRIMARY_GUIDANCE_SCALE", "1.5"))
 PRIMARY_BACKGROUND_STRENGTH = float(os.environ.get("PRIMARY_BACKGROUND_STRENGTH", "0.72"))
+PRIMARY_SPRITE_STRENGTH = float(os.environ.get("PRIMARY_SPRITE_STRENGTH", "0.72"))
 USE_PRIMARY_IMAGE_MODEL = os.environ.get("USE_PRIMARY_IMAGE_MODEL", "1") == "1"
 REQUIRE_PRIMARY_IMAGE_MODEL = os.environ.get(
     "REQUIRE_PRIMARY_IMAGE_MODEL",
@@ -1371,6 +1372,70 @@ def draw_sprite(spec: AssetSpec, rng: random.Random) -> bytes:
         image.save(out, format="PNG")
         return out.getvalue()
 
+    if spec.camera == "side_view":
+        # Profile silhouette used both by the procedural fallback and as the
+        # neural img2img camera guide. A single visible eye and forward nose
+        # prevent the model from reverting to its common front-facing pose.
+        draw.ellipse((cx - 28 * scale, cy + 31 * scale, cx + 31 * scale, cy + 46 * scale), fill=(0, 0, 0, 55))
+        draw.rounded_rectangle(
+            (cx - 15 * scale, cy - 16 * scale, cx + 17 * scale, cy + 32 * scale),
+            radius=max(4, int(10 * scale)),
+            fill=outline,
+        )
+        draw.rounded_rectangle(
+            (cx - 10 * scale, cy - 11 * scale, cx + 12 * scale, cy + 27 * scale),
+            radius=max(3, int(7 * scale)),
+            fill=body,
+        )
+        draw.ellipse((cx - 17 * scale, cy - 50 * scale, cx + 17 * scale, cy - 16 * scale), fill=outline)
+        draw.ellipse((cx - 12 * scale, cy - 45 * scale, cx + 13 * scale, cy - 20 * scale), fill=accent)
+        draw.polygon(
+            ((cx + 12 * scale, cy - 36 * scale), (cx + 24 * scale, cy - 31 * scale), (cx + 12 * scale, cy - 27 * scale)),
+            fill=accent,
+        )
+        draw.ellipse((cx + 5 * scale, cy - 37 * scale, cx + 10 * scale, cy - 32 * scale), fill=(255, 255, 255, 245))
+        draw.line((cx + 7 * scale, cy - 4 * scale, cx + 35 * scale, cy + 11 * scale), fill=outline, width=max(5, int(9 * scale)))
+        draw.line((cx + 7 * scale, cy - 4 * scale, cx + 35 * scale, cy + 11 * scale), fill=trim, width=max(2, int(5 * scale)))
+        draw.line((cx - 5 * scale, cy + 27 * scale, cx - 19 * scale, cy + 52 * scale), fill=outline, width=max(5, int(10 * scale)))
+        draw.line((cx + 7 * scale, cy + 27 * scale, cx + 24 * scale, cy + 50 * scale), fill=outline, width=max(5, int(10 * scale)))
+        if "bow" in role_prompt or "archer" in role_prompt or "ranger" in role_prompt:
+            draw.arc((cx + 25 * scale, cy - 19 * scale, cx + 56 * scale, cy + 35 * scale), 95, 265, fill=trim, width=max(2, int(4 * scale)))
+        out = io.BytesIO()
+        image.save(out, format="PNG")
+        return out.getvalue()
+
+    if spec.camera == "isometric":
+        # Offset limbs and facial features establish a three-quarter pose rather
+        # than the symmetric front view used by the generic fallback.
+        draw.ellipse((cx - 31 * scale, cy + 29 * scale, cx + 38 * scale, cy + 46 * scale), fill=(0, 0, 0, 58))
+        draw.polygon(
+            (
+                (cx - 21 * scale, cy - 12 * scale),
+                (cx + 12 * scale, cy - 20 * scale),
+                (cx + 26 * scale, cy + 24 * scale),
+                (cx - 7 * scale, cy + 35 * scale),
+            ),
+            fill=outline,
+        )
+        draw.polygon(
+            (
+                (cx - 14 * scale, cy - 8 * scale),
+                (cx + 8 * scale, cy - 14 * scale),
+                (cx + 19 * scale, cy + 20 * scale),
+                (cx - 4 * scale, cy + 27 * scale),
+            ),
+            fill=body,
+        )
+        draw.ellipse((cx - 18 * scale, cy - 49 * scale, cx + 18 * scale, cy - 14 * scale), fill=outline)
+        draw.ellipse((cx - 12 * scale, cy - 43 * scale, cx + 13 * scale, cy - 19 * scale), fill=accent)
+        draw.ellipse((cx + 4 * scale, cy - 35 * scale, cx + 9 * scale, cy - 30 * scale), fill=(255, 255, 255, 245))
+        draw.line((cx + 11 * scale, cy - 4 * scale, cx + 39 * scale, cy + 9 * scale), fill=trim, width=max(4, int(8 * scale)))
+        draw.line((cx - 3 * scale, cy + 28 * scale, cx - 22 * scale, cy + 50 * scale), fill=outline, width=max(5, int(10 * scale)))
+        draw.line((cx + 12 * scale, cy + 24 * scale, cx + 31 * scale, cy + 43 * scale), fill=outline, width=max(5, int(10 * scale)))
+        out = io.BytesIO()
+        image.save(out, format="PNG")
+        return out.getvalue()
+
     shadow = (int(cx - 36 * scale), int(cy + 34 * scale), int(cx + 36 * scale), int(cy + 48 * scale))
     draw.ellipse(shadow, fill=(0, 0, 0, 65))
 
@@ -1476,7 +1541,11 @@ def diffusion_negative_prompt(spec: AssetSpec) -> str:
             "particle effect, particles, confetti, sparkles, floating dots, glowing orbs, embers, lens flare"
             + camera_negative
         )
-    return common + ", landscape, environment scene, room, horizon, opaque background, drop shadow"
+    return (
+        common
+        + ", landscape, environment scene, room, horizon, opaque background, drop shadow, "
+        "trees, foliage, ground, floor, scenery, background objects, frame, border"
+    )
 
 
 def build_camera_control_image(spec: AssetSpec, width: int = 1024, height: int = 576) -> Image.Image:
@@ -1581,10 +1650,24 @@ def primary_diffusion_prompt(spec: AssetSpec) -> str:
         )
     return (
         f"{spec.prompt} One complete isolated game sprite only, centered, fully visible, readable silhouette, "
-        "camera angle exactly as specified, on a plain uniform white studio background."
+        "camera angle and pose exactly matching the supplied guide, on a plain uniform white studio background. "
+        "No scenery, floor, trees, foliage, frame, or environmental props."
     )
 
 
+def primary_image_guide(spec: AssetSpec, index: int, run_id: int) -> Image.Image:
+    """Build a clean camera-and-palette guide for the neural image-to-image pass."""
+    guide_png = local_asset_png(spec, index, run_id)
+    guide = Image.open(io.BytesIO(guide_png)).convert("RGBA")
+    if is_background_spec(spec):
+        return guide.convert("RGB").resize((1344, 768), Image.LANCZOS)
+
+    guide = guide.resize((1024, 1024), Image.LANCZOS)
+    white = Image.new("RGB", guide.size, (255, 255, 255))
+    white.paste(guide.convert("RGB"), mask=guide.getchannel("A"))
+    return white
+
+
 def primary_diffusion_png(spec: AssetSpec, index: int, run_id: int) -> tuple[bytes | None, str | None]:
     """Generate every production asset with SSD-1B; backgrounds use camera-guided img2img."""
     if PRIMARY_MODEL_ERROR:
@@ -1606,18 +1689,15 @@ def primary_diffusion_png(spec: AssetSpec, index: int, run_id: int) -> tuple[byt
             "guidance_scale": PRIMARY_GUIDANCE_SCALE,
             "generator": generator,
         }
-        if is_background_spec(spec):
-            if PRIMARY_IMAGE_TO_IMAGE_PIPE is None:
-                return None, "primary camera-guided image-to-image pipeline is unavailable"
-            guide_png = local_asset_png(spec, index, run_id)
-            guide = Image.open(io.BytesIO(guide_png)).convert("RGB").resize((1344, 768), Image.LANCZOS)
-            image = PRIMARY_IMAGE_TO_IMAGE_PIPE(
-                image=guide,
-                strength=PRIMARY_BACKGROUND_STRENGTH,
-                **common,
-            ).images[0]
-        else:
-            image = PRIMARY_TEXT_PIPE(width=1024, height=1024, **common).images[0]
+        if PRIMARY_IMAGE_TO_IMAGE_PIPE is None:
+            return None, "primary camera-guided image-to-image pipeline is unavailable"
+        guide = primary_image_guide(spec, index, run_id)
+        strength = PRIMARY_BACKGROUND_STRENGTH if is_background_spec(spec) else PRIMARY_SPRITE_STRENGTH
+        image = PRIMARY_IMAGE_TO_IMAGE_PIPE(
+            image=guide,
+            strength=strength,
+            **common,
+        ).images[0]
         return polish_diffusion_asset(image, spec), None
     except Exception as exc:
         return None, short_error(exc)
@@ -2033,7 +2113,7 @@ def model_source_note(image_model: str) -> str:
     if "via fal-ai" in lowered or "via replicate" in lowered:
         return "routed image-to-image refinement—preserves a layout guide but consumes account inference credit"
     if "zerogpu" in lowered:
-        return "locally hosted neural diffusion—no per-image API credit; backgrounds are camera-guided and still require visual review"
+        return "locally hosted neural diffusion—no per-image API credit; assets are camera-guided and still require visual review"
     return "diffusion output—higher visual variety; verify subject, perspective, alpha edges, and prompt compliance"
 
 
@@ -2042,7 +2122,7 @@ def model_configuration_summary() -> str:
     sprite_chain = []
     primary_source = f"{PRIMARY_IMAGE_MODEL} + {PRIMARY_LORA_MODEL} on ZeroGPU"
     if USE_PRIMARY_IMAGE_MODEL:
-        sprite_chain.append(primary_source)
+        sprite_chain.append(f"camera-guided {primary_source}")
     if USE_DIFFUSION_FOR_SPRITES:
         sprite_chain.append(FREE_IMAGE_MODEL)
     if USE_HF_IMAGE_PROVIDER:
@@ -2089,8 +2169,8 @@ def model_configuration_summary() -> str:
         f"prompts: `{prompt_source}` · sprites: `{sprite_source}` · backgrounds: `{background_source}` · "
         f"remote image fallback: `{remote_fallback}` · neural image models: `{neural_status}` · "
         f"neural enforcement: `{enforcement}` · primary readiness: `{readiness}`. "
-        "Every production image is generated by the primary neural model. Backgrounds start from a deterministic "
-        "camera guide and are refined with image-to-image diffusion; the procedural renderer remains an emergency "
+        "Every production image is generated by the primary neural model. Sprites and backgrounds start from deterministic "
+        "camera-and-palette guides and are refined with image-to-image diffusion; the procedural renderer remains an emergency "
         "development fallback and is blocked in the deployed Space when the primary model fails."
     )