Generate assets directly from text prompts

Remove procedural image guides from the production diffusion path. Generate sprites and backgrounds directly from written prompts, keep fail-closed neural enforcement, and make realistic style parsing negation-aware.

app.py

@@ -126,8 +126,6 @@ PRIMARY_LORA_MODEL = os.environ.get("PRIMARY_LORA_MODEL", "latent-consistency/lc
 PRIMARY_IMAGE_STEPS = int(os.environ.get("PRIMARY_IMAGE_STEPS", "4"))
 PRIMARY_SPRITE_STEPS = int(os.environ.get("PRIMARY_SPRITE_STEPS", "6"))
 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.82"))
 USE_PRIMARY_IMAGE_MODEL = os.environ.get("USE_PRIMARY_IMAGE_MODEL", "1") == "1"
 REQUIRE_PRIMARY_IMAGE_MODEL = os.environ.get(
     "REQUIRE_PRIMARY_IMAGE_MODEL",
@@ -154,7 +152,6 @@ FREE_DIFFUSION_ERROR = None
 CONTROLNET_PIPE = None
 CONTROLNET_ERROR = None
 PRIMARY_TEXT_PIPE = None
-PRIMARY_IMAGE_TO_IMAGE_PIPE = None
 PRIMARY_MODEL_ERROR = None
 
 
@@ -225,7 +222,18 @@ def interpret_style_hint(style_hint: str) -> StylePlan:
     tags: list[str] = []
 
     def has(*words: str) -> bool:
-        return any(word in text for word in words)
+        negation = re.compile(
+            r"(?:\bno\b|\bnot\b|\bwithout\b|\bavoid(?:ing)?\b|"
+            r"\bexclude(?:d|ing)?\b|\brather\s+than\b|\bnon[- ]?)\s+"
+            r"(?:[\w-]+\s+){0,3}$"
+        )
+        for word in words:
+            pattern = re.compile(rf"(?<![\w-]){re.escape(word)}(?![\w-])")
+            for match in pattern.finditer(text):
+                prefix = text[max(0, match.start() - 48) : match.start()]
+                if not negation.search(prefix):
+                    return True
+        return False
 
     if has("watercolor", "ink wash", "gouache", "paper"):
         tags.append("watercolor")
@@ -255,6 +263,13 @@ def interpret_style_hint(style_hint: str) -> StylePlan:
         texture = "visible bristle strokes and canvas-like texture"
         lighting = "dramatic directional light"
         linework = "painted edges instead of hard outlines"
+    elif has("photorealistic", "photo-realistic", "realistic", "cinematic realism", "lifelike"):
+        tags.append("realistic")
+        medium = "realistic game concept art"
+        palette = "natural material colors with controlled cinematic contrast"
+        texture = "physically plausible fabric, skin, metal, and surface detail"
+        lighting = "cinematic directional light with realistic shadows"
+        linework = "natural painted edges without graphic outlines"
     elif has("pixel", "8-bit", "16-bit", "retro"):
         tags.append("pixel")
         medium = "retro pixel-art game asset"
@@ -1374,9 +1389,7 @@ def draw_sprite(spec: AssetSpec, rng: random.Random) -> bytes:
         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.
+        # Profile silhouette for the optional local procedural fallback.
         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),
@@ -1544,7 +1557,7 @@ def diffusion_negative_prompt(spec: AssetSpec) -> str:
         )
     return (
         common
-        + ", landscape, environment scene, room, horizon, opaque background, drop shadow, "
+        + ", landscape, environment scene, room, horizon, complex background, drop shadow, "
         "trees, foliage, ground, floor, scenery, background objects, frame, border"
     )
 
@@ -1602,8 +1615,8 @@ def build_camera_control_image(spec: AssetSpec, width: int = 1024, height: int =
 
 
 def initialize_primary_image_model() -> None:
-    """Load the production diffusion pipelines once under ZeroGPU CUDA emulation."""
-    global PRIMARY_TEXT_PIPE, PRIMARY_IMAGE_TO_IMAGE_PIPE, PRIMARY_MODEL_ERROR
+    """Load the production text-to-image pipeline once under ZeroGPU CUDA emulation."""
+    global PRIMARY_TEXT_PIPE, PRIMARY_MODEL_ERROR
     if not USE_PRIMARY_IMAGE_MODEL or PRIMARY_TEXT_PIPE is not None or PRIMARY_MODEL_ERROR:
         return
     if not os.environ.get("SPACE_ID"):
@@ -1611,7 +1624,7 @@ def initialize_primary_image_model() -> None:
 
     try:
         import torch
-        from diffusers import AutoPipelineForImage2Image, AutoPipelineForText2Image, LCMScheduler
+        from diffusers import AutoPipelineForText2Image, LCMScheduler
 
         model_kwargs = {
             "torch_dtype": torch.float16,
@@ -1631,13 +1644,7 @@ def initialize_primary_image_model() -> None:
         if hasattr(text_pipe, "enable_vae_slicing"):
             text_pipe.enable_vae_slicing()
 
-        image_pipe = AutoPipelineForImage2Image.from_pipe(text_pipe)
-        image_pipe.scheduler = LCMScheduler.from_config(image_pipe.scheduler.config)
-        if hasattr(image_pipe, "set_progress_bar_config"):
-            image_pipe.set_progress_bar_config(disable=True)
-
         PRIMARY_TEXT_PIPE = text_pipe
-        PRIMARY_IMAGE_TO_IMAGE_PIPE = image_pipe
     except Exception as exc:
         PRIMARY_MODEL_ERROR = short_error(exc)
 
@@ -1645,33 +1652,21 @@ def initialize_primary_image_model() -> None:
 def primary_diffusion_prompt(spec: AssetSpec) -> str:
     if is_background_spec(spec):
         return (
-            f"{spec.prompt} Production-quality 2D game background only. Preserve the supplied camera layout "
-            "and readable gameplay space. Use connected environmental forms and clean terrain structure. "
-            "No characters and no decorative overlay."
+            f"{spec.prompt} Generate this scene directly from the written description as a production-quality "
+            "2D game background. Follow the stated camera projection exactly and keep gameplay space readable. "
+            "Use connected environmental forms and clean terrain structure. No characters and no decorative overlay."
         )
     return (
         f"{spec.prompt} One complete isolated game sprite only, centered, fully visible, readable silhouette, "
-        "camera angle and pose exactly matching the supplied guide, on a plain uniform white studio background. "
+        "with its anatomy, body shape, camera angle, and pose derived directly from the written description. "
+        "Use a plain uniform white studio background for clean extraction. "
         "Add recognizable costume, equipment, materials, and character details. "
         "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."""
+    """Generate every production asset directly from text with the primary model."""
     if PRIMARY_MODEL_ERROR:
         return None, PRIMARY_MODEL_ERROR
     if PRIMARY_TEXT_PIPE is None:
@@ -1691,13 +1686,10 @@ def primary_diffusion_png(spec: AssetSpec, index: int, run_id: int) -> tuple[byt
             "guidance_scale": PRIMARY_GUIDANCE_SCALE,
             "generator": generator,
         }
-        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,
+        width, height = (1344, 768) if is_background_spec(spec) else (1024, 1024)
+        image = PRIMARY_TEXT_PIPE(
+            width=width,
+            height=height,
             **common,
         ).images[0]
         return polish_diffusion_asset(image, spec), None
@@ -2115,7 +2107,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; assets are camera-guided and still require visual review"
+        return "direct locally hosted text-to-image diffusion—no procedural guide or per-image API credit; visual review required"
     return "diffusion output—higher visual variety; verify subject, perspective, alpha edges, and prompt compliance"
 
 
@@ -2124,16 +2116,17 @@ 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(f"camera-guided {primary_source}")
+        sprite_chain.append(f"direct text-to-image {primary_source}")
     if USE_DIFFUSION_FOR_SPRITES:
         sprite_chain.append(FREE_IMAGE_MODEL)
     if USE_HF_IMAGE_PROVIDER:
         sprite_chain.append(HF_IMAGE_MODEL)
-    sprite_chain.append("shape-aware procedural renderer (no neural model)")
+    if not (USE_PRIMARY_IMAGE_MODEL and REQUIRE_PRIMARY_IMAGE_MODEL):
+        sprite_chain.append("shape-aware procedural renderer (development fallback only)")
     sprite_source = " → ".join(sprite_chain)
     background_chain = []
     if USE_PRIMARY_IMAGE_MODEL:
-        background_chain.append(f"camera-guided {primary_source}")
+        background_chain.append(f"direct text-to-image {primary_source}")
     if USE_CONTROLNET_FOR_BACKGROUNDS:
         background_chain.append(f"{CONTROLNET_BASE_MODEL} + {CONTROLNET_MODEL}")
     if USE_HF_STRUCTURE_PROVIDER:
@@ -2142,7 +2135,8 @@ def model_configuration_summary() -> str:
         background_chain.append(FREE_IMAGE_MODEL)
     if USE_HF_IMAGE_PROVIDER:
         background_chain.append(HF_IMAGE_MODEL)
-    background_chain.append("camera-safe procedural renderer (no neural model)")
+    if not (USE_PRIMARY_IMAGE_MODEL and REQUIRE_PRIMARY_IMAGE_MODEL):
+        background_chain.append("camera-safe procedural renderer (development fallback only)")
     background_source = " → ".join(background_chain)
     remote_sources = []
     if USE_HF_STRUCTURE_PROVIDER:
@@ -2171,9 +2165,9 @@ 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. 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."
+        "Every production image is generated directly from its written prompt by the primary text-to-image model. "
+        "No procedural guide is supplied to the model. The procedural renderer is development-only and is blocked in "
+        "the deployed Space when the primary model fails."
     )