Skip to content

Transform your 3D texturing workflow with the power of generative AI, directly within Blender!

add automated texturing regression runs and generation heartbeat controls

sakalond082c23a2b727
diff --git a/stablegen/__init__.py b/stablegen/__init__.py
index 08c7fd4..e70751e 100644
--- a/stablegen/__init__.py
+++ b/stablegen/__init__.py
@@ -49,6 +49,7 @@ from .cameras import (
MoveCameraOrder, ApplyCameraOrderPreset,
)
from .debug_tools import debug_classes as _debug_classes
+from .texturing.regression import REGRESSION_CLASSES
from .texturing import masked_edit
from .utils import AddHDRI, ApplyModifiers, CurvesToMesh
from .texturing.generator import (
@@ -194,6 +195,7 @@ classes = [
]
# Append debug classes (defined in debug_tools.py)
classes.extend(_debug_classes)
+classes.extend(REGRESSION_CLASSES)
classes.extend(masked_edit.MASKED_EDIT_CLASSES)
diff --git a/stablegen/core/preferences.py b/stablegen/core/preferences.py
index 3fc1cbe..1d68864 100644
--- a/stablegen/core/preferences.py
+++ b/stablegen/core/preferences.py
@@ -148,6 +148,15 @@ class StableGenAddonPreferences(bpy.types.AddonPreferences):
default=120.0, min=10.0, max=600.0, step=100, precision=0,
) # type: ignore
+ timeout_generation_heartbeat: bpy.props.FloatProperty(
+ name="Generation Heartbeat (s)",
+ description=(
+ "Interval without WebSocket events before StableGen checks "
+ "ComfyUI history and queue; this does not cancel active generation"
+ ),
+ default=120.0, min=10.0, max=600.0, step=100, precision=0,
+ ) # type: ignore
+
timeout_reboot: bpy.props.FloatProperty(
name="Reboot Timeout (s)",
description="How long to wait for ComfyUI server to come back after a reboot",
@@ -224,6 +233,7 @@ class StableGenAddonPreferences(bpy.types.AddonPreferences):
col.prop(self, "timeout_ping")
col.prop(self, "timeout_api")
col.prop(self, "timeout_transfer")
+ col.prop(self, "timeout_generation_heartbeat")
col.prop(self, "timeout_reboot")
col.prop(self, "timeout_mesh_gen")
col.prop(self, "timeout_scan")
diff --git a/stablegen/core/properties.py b/stablegen/core/properties.py
index 7c6b228..3b497b1 100644
--- a/stablegen/core/properties.py
+++ b/stablegen/core/properties.py
@@ -644,6 +644,12 @@ def register_properties(update_model_list, ControlNetUnit, LoRAUnit,
description="True if the most recent generation ended with an error",
default=False,
)
+ bpy.types.Scene.sg_last_gen_error_message = bpy.props.StringProperty(
+ name="Last Generation Error Message",
+ description="Diagnostic message from the most recent generation error",
+ default="",
+ options={'SKIP_SAVE'},
+ )
bpy.types.Scene.generation_progress = bpy.props.FloatProperty(
name="Generation Progress", description="Current progress of image generation",
default=0.0, min=0.0, max=100.0, update=update_parameters,
diff --git a/stablegen/texturing/generator.py b/stablegen/texturing/generator.py
index d6a2968..c53a1d1 100644
--- a/stablegen/texturing/generator.py
+++ b/stablegen/texturing/generator.py
@@ -859,8 +859,9 @@ class ComfyUIGenerate(_PBRMixin, bpy.types.Operator):
elif total_pixels > upper_bound:
target_mp = target_px / 1_000_000
self.report({'WARNING'}, f"High resolution detected. Resolutions above {target_mp:.1f} MP may reduce performance and quality.")
-
- self._cameras = [obj for obj in bpy.context.scene.objects if obj.type == 'CAMERA']
+
+ from .view_plan import generation_cameras
+ self._cameras = generation_cameras(context.scene)
if not self._cameras:
self.report({'ERROR'}, "No cameras found in the scene. Use 'Add Cameras' to create them.")
context.scene.generation_status = 'idle'
@@ -1330,7 +1331,7 @@ class ComfyUIGenerate(_PBRMixin, bpy.types.Operator):
# Clear output directories which are not needed anymore
addon_prefs = context.preferences.addons[_ADDON_PKG].preferences
# Save blend file in the output directory if enabled
- if addon_prefs.save_blend_file:
+ if addon_prefs.save_blend_file and not context.scene.get('_sg_regression_output'):
blend_dir = get_dir_path(context, "revision")
# Save the current blend file in the output directory
scene_name = os.path.splitext(os.path.basename(bpy.data.filepath))[0]
diff --git a/stablegen/texturing/regression.py b/stablegen/texturing/regression.py
new file mode 100644
index 0000000..ac5ea30
--- /dev/null
+++ b/stablegen/texturing/regression.py
@@ -0,0 +1,692 @@
+"""Unattended, isolated preset comparisons using the normal generation and bake operators."""
+
+from contextlib import contextmanager
+from datetime import datetime
+from pathlib import Path
+import json
+import math
+import time
+
+import bpy
+from mathutils import Vector
+
+from ..core import ADDON_PKG
+
+
+# A second entry is a real second generation pass over the first pass's material.
+CASES = (
+ ('SDXL Characters', ('CHARACTERS',)),
+ ('SDXL Quick Draft', ('QUICK DRAFT',)),
+ ('SDXL Characters + UV Inpainting', ('CHARACTERS', 'UV INPAINTING')),
+ ('SDXL Characters + Local Refine', ('CHARACTERS', 'LOCAL REFINE')),
+ ('Qwen Precise', ('QWEN PRECISE',)),
+ ('Qwen Safe', ('QWEN SAFE',)),
+ ('Qwen Safe + Local Edit', ('QWEN SAFE', 'LOCAL EDIT (QWEN)')),
+ ('Qwen Safe + Refine (Qwen)', ('QWEN SAFE', 'REFINE (QWEN)')),
+)
+
+DETAIL_PRESETS = frozenset({'LOCAL REFINE', 'LOCAL EDIT (QWEN)'})
+_camera_enum_cache = {}
+_model_cache = {}
+_model_enum_history = [] # Keep Blender's borrowed enum strings alive after refresh.
+_SELECT_MODEL = '__SELECT_MODEL__'
+
+
+def model_cache(context):
+ wrapper = context.preferences.addons.get(ADDON_PKG) if context else None
+ server = wrapper.preferences.server_address if wrapper else ''
+ if server not in _model_cache:
+ _model_cache[server] = {'loading': False, 'message': '', 'ids': {},
+ 'sdxl': [], 'qwen_image_edit': []}
+ return server, _model_cache[server]
+
+
+def set_model_items(cache, architecture, names):
+ items = [(_SELECT_MODEL, 'Select a model', 'Choose an installed ComfyUI model', 0)]
+ for name in sorted(set(names or [])):
+ key = (architecture, name)
+ if key not in cache['ids']:
+ cache['ids'][key] = len(cache['ids']) + 1
+ items.append((name, name, 'ComfyUI model: ' + name, cache['ids'][key]))
+ cache[architecture] = items
+ _model_enum_history.append(items)
+
+
+def regression_model_items(context, architecture):
+ _, cache = model_cache(context)
+ if not cache[architecture]:
+ set_model_items(cache, architecture, [])
+ return cache[architecture]
+
+
+def sdxl_model_items(self, context):
+ return regression_model_items(context, 'sdxl')
+
+
+def qwen_model_items(self, context):
+ return regression_model_items(context, 'qwen_image_edit')
+
+
+def refresh_regression_models(context):
+ from ..core.server_api import _fetch_api_list, fetch_diffusion_models
+ from ..core.state import _run_async
+ from .qwen_models import is_qwen_image_21_model
+ server, cache = model_cache(context)
+ if cache['loading']:
+ return
+ cache['loading'] = True
+ cache['message'] = 'Loading models from ComfyUI...'
+
+ def fetch():
+ qwen_models = fetch_diffusion_models(server)
+ if qwen_models is not None:
+ qwen_models = [name for name in qwen_models
+ if not is_qwen_image_21_model(name)]
+ return {'sdxl': _fetch_api_list(server, '/models/checkpoints'),
+ 'qwen_image_edit': qwen_models}
+
+ def done(result):
+ cache['loading'] = False
+ for architecture in ('sdxl', 'qwen_image_edit'):
+ set_model_items(cache, architecture, result.get(architecture) if result else [])
+ if not result or any(result.get(architecture) is None for architecture in ('sdxl', 'qwen_image_edit')):
+ cache['message'] = 'Could not load all model lists. Check ComfyUI and refresh.'
+ elif len(cache['sdxl']) == 1 or len(cache['qwen_image_edit']) == 1:
+ cache['message'] = 'No models found for one architecture. Install models and refresh.'
+ else:
+ cache['message'] = ''
+ for window in bpy.context.window_manager.windows:
+ for area in window.screen.areas:
+ area.tag_redraw()
+
+ _run_async(fetch, done)
+
+
+class SG_OT_RefreshRegressionModels(bpy.types.Operator):
+ bl_idname = 'stablegen.refresh_regression_models'
+ bl_label = 'Refresh Model Lists'
+ bl_description = 'Load SDXL checkpoints and Qwen diffusion/GGUF models from ComfyUI'
+
+ @classmethod
+ def poll(cls, context):
+ server, cache = model_cache(context)
+ return bool(server) and not cache['loading'] and SG_OT_TexturingRegression._active is None
+
+ def execute(self, context):
+ refresh_regression_models(context)
+ return {'FINISHED'}
+
+
+def detail_camera_items(self, context):
+ # Blender retains enum string pointers; keep each returned list alive.
+ names = tuple(sorted(obj.name for obj in context.scene.objects if obj.type == 'CAMERA')) if context else ()
+ if names not in _camera_enum_cache:
+ _camera_enum_cache[names] = [('NONE', 'None (skip local cases)', 'Skip Local Refine and Local Edit')]
+ _camera_enum_cache[names].extend(('CAMERA:' + name, name, 'Use this camera for the local second passes only')
+ for name in names)
+ return _camera_enum_cache[names]
+
+
+def park_detail_camera(scene):
+ """Keep the copied detail camera out of every scene-camera enumeration."""
+ for camera in list(scene.objects):
+ if camera.type != 'CAMERA' or not camera.get('_sg_regression_detail_camera'):
+ continue
+ # An ID reference preserves the isolated camera, its parent/constraints
+ # and lens through orphan cleanup without linking it into the scene.
+ scene['_sg_regression_pending_detail_camera'] = camera
+ if scene.camera == camera:
+ scene.camera = next((obj for obj in scene.objects
+ if obj.type == 'CAMERA' and obj != camera), None)
+ for collection in list(camera.users_collection):
+ collection.objects.unlink(camera)
+
+
+def configure_camera_scope(scene, preset, edit_prompt):
+ detail = preset in DETAIL_PRESETS
+ scene['_sg_regression_camera_scope'] = 'detail' if detail else 'base'
+ if detail:
+ camera = scene.get('_sg_regression_pending_detail_camera')
+ if camera is not None:
+ scene.collection.objects.link(camera)
+ del scene['_sg_regression_pending_detail_camera']
+ scene.camera = camera
+ scene.comfyui_prompt = edit_prompt
+ scene.texture_prompt = edit_prompt
+ scene.use_separate_texture_prompt = True
+ scene.refine_prompt = edit_prompt
+ scene.use_camera_prompts = False
+
+
+@contextmanager
+def internal_operators():
+ from .. import utils
+ previous = utils._sg_bypass_modal_check
+ utils._sg_bypass_modal_check = True
+ try:
+ yield
+ finally:
+ utils._sg_bypass_modal_check = previous
+
+
+def copy_scene(context, source, name):
+ """FULL_COPY also remaps rigs/constraints; repair string-based camera references."""
+ context.window.scene = source
+ key = '_sg_regression_source_name'
+ saved = [(obj, key in obj, obj.get(key)) for obj in source.objects]
+ try:
+ for obj, _, _ in saved:
+ obj[key] = obj.name
+ if bpy.ops.scene.new(type='FULL_COPY') != {'FINISHED'}:
+ raise RuntimeError('Could not duplicate the source scene')
+ scene = context.window.scene
+ finally:
+ for obj, existed, value in saved:
+ if existed:
+ obj[key] = value
+ else:
+ del obj[key]
+ scene.name = name
+ mapping = {obj[key]: obj.name for obj in scene.objects if key in obj}
+ for obj in scene.objects:
+ original = source.objects.get(obj.get(key, ''))
+ if original and obj.data and obj.data == original.data:
+ obj.data = obj.data.copy()
+ for collection in (scene.camera_prompts, scene.sg_camera_order):
+ for item in collection:
+ item.name = mapping.get(item.name, item.name)
+ # Node groups can remain shared even when object/material IDs are copied.
+ groups, materials = {}, {}
+ def isolate_groups(tree):
+ for node in tree.nodes:
+ if node.type == 'GROUP' and node.node_tree:
+ old = node.node_tree
+ if old not in groups:
+ groups[old] = old.copy()
+ isolate_groups(groups[old])
+ node.node_tree = groups[old]
+ for obj in scene.objects:
+ for slot in obj.material_slots:
+ mat = slot.material
+ if not mat:
+ continue
+ if mat not in materials:
+ materials[mat] = mat.copy()
+ if materials[mat].use_nodes:
+ isolate_groups(materials[mat].node_tree)
+ slot.material = materials[mat]
+ if scene.world:
+ scene.world = scene.world.copy()
+ if scene.world.use_nodes:
+ isolate_groups(scene.world.node_tree)
+ return scene
+
+
+def targets(context):
+ from .rendering import _texture_bake_targets
+ candidates = [o for o in context.view_layer.objects
+ if o.type == 'MESH' and not o.hide_get() and not o.hide_render]
+ if context.scene.texture_objects == 'selected':
+ candidates = [o for o in candidates if o.select_get()]
+ return _texture_bake_targets(candidates)[0]
+
+
+def save_scene(scene, path):
+ bpy.data.libraries.write(str(path), {scene}, path_remap='ABSOLUTE', fake_user=True)
+
+
+def verify_baked(objects, output_dir):
+ """Do not treat a vanished modal (including exceptions) as bake success."""
+ for obj in objects:
+ expected = Path(output_dir) / (obj.name + '.png')
+ mat = obj.active_material
+ if not expected.is_file() or not mat or not mat.use_nodes:
+ raise RuntimeError(f'Bake did not finish for {obj.name}')
+ images = [n.image for n in mat.node_tree.nodes if n.type == 'TEX_IMAGE' and n.image]
+ if not any(Path(bpy.path.abspath(im.filepath)).resolve() == expected.resolve() for im in images):
+ raise RuntimeError(f'Baked material was not applied to {obj.name}')
+ for image in images:
+ image.pack()
+
+
+def build_comparison(context, entries, name):
+ """Freeze evaluated, baked meshes so moving them cannot move their projection."""
+ comparison = bpy.data.scenes.new(name)
+ cursor = 0.0
+ for index, entry in enumerate(entries):
+ collection = bpy.data.collections.new(f'{index + 1:02d} {entry["label"]}')
+ comparison.collection.children.link(collection)
+ meshes = []
+ source = bpy.data.scenes.get(entry.get('scene', ''))
+ if entry['status'] == 'passed' and source:
+ context.window.scene = source
+ depsgraph = context.evaluated_depsgraph_get()
+ for obj_name in entry['objects']:
+ obj = source.objects[obj_name]
+ evaluated = obj.evaluated_get(depsgraph)
+ mesh = bpy.data.meshes.new_from_object(evaluated, depsgraph=depsgraph)
+ mesh.materials.clear()
+ mesh.materials.append(obj.active_material)
+ for face in mesh.polygons:
+ face.material_index = 0
+ result = bpy.data.objects.new(f'{index + 1:02d} {obj.name}', mesh)
+ collection.objects.link(result)
+ result.matrix_world = evaluated.matrix_world.copy()
+ meshes.append(result)
+ corners = [obj.matrix_world @ Vector(c) for obj in meshes for c in obj.bound_box]
+ lower = Vector(tuple(min(c[i] for c in corners) for i in range(3))) if corners else Vector((0, 0, 0))
+ upper = Vector(tuple(max(c[i] for c in corners) for i in range(3))) if corners else Vector((2, 2, 2))
+ width = max(upper.x - lower.x, 1.0)
+ height = max(upper.z - lower.z, 1.0)
+ shift = Vector((cursor - lower.x, -lower.y, -lower.z))
+ for obj in meshes:
+ obj.location += shift
+ curve = bpy.data.curves.new(f'Label {index + 1:02d}', 'FONT')
+ curve.body = f'{index + 1:02d} {entry["label"]}\n{entry["status"].upper()}'
+ if entry.get('skip_reason'):
+ curve.body += '\n' + entry['skip_reason']
+ curve.size = min(height * .075, width / max(len(entry['label']), 12) * 1.5)
+ label = bpy.data.objects.new(curve.name, curve)
+ collection.objects.link(label)
+ label.location = (cursor, -.2 * height, 0)
+ label.rotation_euler.x = math.pi / 2
+ label['result'] = entry.get('error', '') or entry.get('skip_reason', '') or entry.get('file', '')
+ cursor += width + max(width * .3, height * .2)
+ context.window.scene = comparison
+ return comparison
+
+
+class SG_OT_TexturingRegression(bpy.types.Operator):
+ bl_idname = 'stablegen.texturing_regression'
+ bl_label = 'Run Texturing Regression'
+ bl_description = ('Texture independent copies of the current scene with eight workflows, '
+ 'bake each result and create a labeled comparison scene. Uses the current '
+ 'prompt, seed, target selection and camera placement. May take a long time')
+
+ bake_resolution: bpy.props.IntProperty(name='Bake Resolution', default=2048, min=128, max=8192)
+ sdxl_model: bpy.props.EnumProperty(name='SDXL Model', items=sdxl_model_items,
+ description='Choose a checkpoint installed in ComfyUI')
+ qwen_model: bpy.props.EnumProperty(name='Qwen Model', items=qwen_model_items,
+ description='Choose a Qwen diffusion or GGUF model installed in ComfyUI')
+ detail_camera: bpy.props.EnumProperty(name='Detail Camera', items=detail_camera_items,
+ description='Excluded from base generation; used alone for Local Refine and Local Edit')
+ detail_edit_prompt: bpy.props.StringProperty(name='Detail Edit Prompt',
+ description='Specific change to make in the detail camera view, for both local second passes')
+ _active = None
+ status = ''
+
+ @classmethod
+ def poll(cls, context):
+ from ..utils import sg_modal_active
+ from ..ui import queue
+ return (context.window is not None and context.mode == 'OBJECT'
+ and cls._active is None and not sg_modal_active(context)
+ and not queue._queue_processing
+ and not getattr(context.window_manager, 'sg_batch_running', False))
+
+ def invoke(self, context, event):
+ from ..core import state
+ _, cache = model_cache(context)
+ architecture = context.scene.model_architecture
+ if architecture in {'sdxl', 'qwen_image_edit'} and state._cached_checkpoint_architecture == architecture:
+ names = [item[0] for item in state._cached_checkpoint_list
+ if not item[0].startswith(('NO_', 'NONE_'))]
+ set_model_items(cache, architecture, names)
+ if architecture in {'sdxl', 'qwen_image_edit'}:
+ if context.scene.model_name in {item[0] for item in regression_model_items(context, architecture)}:
+ setattr(self, 'sdxl_model' if architecture == 'sdxl' else 'qwen_model', context.scene.model_name)
+ refresh_regression_models(context)
+ return context.window_manager.invoke_props_dialog(self, width=520)
+
+ def draw(self, context):
+ layout = self.layout
+ for index, (label, _) in enumerate(CASES):
+ layout.label(text=f'{index + 1}. {label}')
+ layout.separator()
+ layout.prop(self, 'bake_resolution')
+ layout.prop(self, 'sdxl_model')
+ layout.prop(self, 'qwen_model')
+ layout.operator('stablegen.refresh_regression_models', icon='FILE_REFRESH')
+ _, cache = model_cache(context)
+ if cache['message']:
+ layout.label(text=cache['message'], icon='INFO')
+ layout.separator()
+ layout.prop(self, 'detail_camera')
+ detail = layout.column()
+ detail.enabled = self.detail_camera != 'NONE'
+ detail.prop(self, 'detail_edit_prompt')
+ if self.detail_camera == 'NONE':
+ layout.label(text='Local Refine and Local Edit will be skipped.', icon='INFO')
+ else:
+ layout.label(text='Detail camera is excluded from all base and full-scene passes.')
+ layout.label(text='Uses the current prompt and cameras; keeps the source scene intact.')
+ layout.label(text='Stop finishes the current pass before creating a partial comparison.')
+
+ def execute(self, context):
+ from .generator import ComfyUIGenerate
+ # Capture the enum name before scene duplication changes its available items.
+ self.detail_camera_name = '' if self.detail_camera == 'NONE' else self.detail_camera.removeprefix('CAMERA:')
+ if self.detail_camera_name:
+ camera = context.scene.objects.get(self.detail_camera_name)
+ if not camera or camera.type != 'CAMERA':
+ self.report({'ERROR'}, 'Choose a detail camera in the current scene')
+ return {'CANCELLED'}
+ if not self.detail_edit_prompt.strip():
+ self.report({'ERROR'}, 'Enter a Detail Edit Prompt for the local passes')
+ return {'CANCELLED'}
+ source_targets = {obj.name for obj in targets(context)}
+ if not source_targets or not any(o.type == 'CAMERA' and o.name != self.detail_camera_name
+ for o in context.scene.objects):
+ self.report({'ERROR'}, 'The scene needs visible target meshes and at least one base camera besides the detail camera')
+ return {'CANCELLED'}
+ _, cache = model_cache(context)
+ if cache['loading']:
+ self.report({'ERROR'}, 'Wait for the model lists to finish loading')
+ return {'CANCELLED'}
+ self.model_selections = {'sdxl': self.sdxl_model, 'qwen_image_edit': self.qwen_model}
+ for architecture, model in self.model_selections.items():
+ if model == _SELECT_MODEL or model not in {item[0] for item in regression_model_items(context, architecture)}:
+ self.report({'ERROR'}, 'Choose both an SDXL model and a Qwen model from the dropdowns')
+ return {'CANCELLED'}
+ if not ComfyUIGenerate.poll(context):
+ self.report({'ERROR'}, 'Connect ComfyUI and configure the StableGen output directory first')
+ return {'CANCELLED'}
+ self.source = context.scene
+ self.window = context.window
+ self.area = context.area
+ self.entries = []
+ self.index = -1
+ self.pass_index = 0
+ self.phase = 'next'
+ self.stop_requested = False
+ self.scene = None
+ self.bake_restore = None
+ self.timer = None
+ stamp = datetime.now().strftime('%Y-%m-%d_%H-%M-%S_%f')
+ self.root = Path(bpy.path.abspath(context.preferences.addons[ADDON_PKG].preferences.output_dir)) / 'regression' / stamp
+ try:
+ self.root.mkdir(parents=True, exist_ok=False)
+ self.template = copy_scene(context, self.source, 'Regression Source ' + stamp)
+ for obj in self.template.objects:
+ obj['_sg_regression_target'] = obj.get('_sg_regression_source_name') in source_targets
+ obj['_sg_regression_detail_camera'] = (obj.type == 'CAMERA'
+ and obj.get('_sg_regression_source_name') == self.detail_camera_name)
+ self.template.use_fake_user = True
+ save_scene(self.template, self.root / 'source.blend')
+ self.source_settings = {key: getattr(self.template, key) for key in
+ ('comfyui_prompt', 'comfyui_negative_prompt', 'texture_prompt',
+ 'use_separate_texture_prompt', 'seed', 'texture_objects', 'use_camera_prompts',
+ 'sg_use_custom_camera_order', 'sequential_custom_camera_order')}
+ self.timer = context.window_manager.event_timer_add(.5, window=self.window)
+ self._next_tick = time.monotonic()
+ type(self)._active = self
+ type(self).status = 'Preparing regression'
+ context.window_manager.modal_handler_add(self)
+ self.write_report('running')
+ return {'RUNNING_MODAL'}
+ except Exception as exc:
+ context.window.scene = self.source
+ self.cleanup(context)
+ self.report({'ERROR'}, str(exc))
+ return {'CANCELLED'}
+
+ def write_report(self, status):
+ data = {'status': status, 'source_scene': self.source.name,
+ 'phase': self.phase,
+ 'source_file': bpy.data.filepath, 'seed': self.source.seed,
+ 'bake_resolution': self.bake_resolution, 'cases': self.entries,
+ 'detail_camera': self.detail_camera_name,
+ 'detail_edit_prompt': self.detail_edit_prompt.strip(),
+ 'planned_cases': [label for label, _ in CASES]}
+ path = self.root / 'report.json'
+ temporary = path.with_suffix('.tmp')
+ temporary.write_text(json.dumps(data, indent=2), encoding='utf-8')
+ temporary.replace(path)
+
+ def apply_pass(self, context):
+ from ..ui.presets import PRESETS
+ preset = CASES[self.index][1][self.pass_index]
+ arch = PRESETS[preset]['model_architecture']
+ self.scene.architecture_mode = arch
+ self.preset = preset
+ self.deadline = time.monotonic() + 60
+ self.phase = 'refresh'
+ with internal_operators():
+ bpy.ops.stablegen.refresh_checkpoint_list()
+ bpy.ops.stablegen.refresh_lora_list()
+
+ def configure_pass(self, context):
+ self.scene.stablegen_preset = self.preset
+ with internal_operators():
+ if bpy.ops.stablegen.apply_preset() != {'FINISHED'}:
+ raise RuntimeError(f'Cannot apply {self.preset}; check its required models and LoRAs')
+ for key, value in self.source_settings.items():
+ setattr(self.scene, key, value)
+ self.scene.generation_mode = 'standard'
+ self.scene.ask_object_prompts = False
+ self.scene.control_after_generate = 'fixed'
+ configure_camera_scope(self.scene, self.preset, self.detail_edit_prompt.strip())
+ self.phase = 'ready'
+ self.ready_ticks = 0
+
+ def start_generation(self, context):
+ from .view_plan import generation_cameras
+ # Every pass gets an isolated output path and an explicit camera scope.
+ self.scene['_sg_regression_output'] = str(self.root / f'{self.index + 1:02d}' / f'pass-{self.pass_index + 1}')
+ cameras = generation_cameras(self.scene)
+ if not cameras:
+ raise RuntimeError('No cameras available for this regression pass')
+ # Selection changes during generation/baking; always restore the captured targets.
+ for obj in context.view_layer.objects:
+ obj.select_set(bool(obj.get('_sg_regression_target')) or obj in cameras)
+ self.scene.texture_objects = 'selected'
+ model = self.model_selections[self.scene.model_architecture]
+ if model:
+ self.scene.model_name = model
+ if not self.scene.model_name or self.scene.model_name.startswith(('NO_', 'NONE_')):
+ raise RuntimeError('No usable model selected')
+ self.entry['passes'].append({'preset': self.preset, 'model': self.scene.model_name,
+ 'method': self.scene.generation_method,
+ 'qwen_method': self.scene.qwen_generation_method,
+ 'cameras': [obj.name for obj in cameras],
+ 'camera_scope': self.scene['_sg_regression_camera_scope'],
+ 'prompt': self.scene.texture_prompt if self.scene.use_separate_texture_prompt else self.scene.comfyui_prompt})
+ self.scene.sg_last_gen_error = False
+ self.phase = 'generation'
+ self.write_report('running')
+ with internal_operators():
+ result = bpy.ops.object.test_stable('INVOKE_DEFAULT')
+ if result != {'RUNNING_MODAL'}:
+ raise RuntimeError(f'Generation did not start: {result}')
+ self.phase = 'generation'
+
+ def start_bake(self, context):
+ from .rendering import BakeTextures
+ self.bake_objects = [o for o in context.view_layer.objects if o.get('_sg_regression_target')]
+ if not self.bake_objects:
+ raise RuntimeError('No targets remain for baking')
+ BakeTextures._objects = self.bake_objects
+ BakeTextures._current_index = 0
+ BakeTextures._phase = 'unwrap'
+ BakeTextures._total_objects = len(self.bake_objects)
+ self.bake_restore = {
+ 'engine': self.scene.render.engine,
+ 'persistent': self.scene.render.use_persistent_data,
+ 'cycles': {key: getattr(self.scene.cycles, key) for key in
+ ('device', 'samples', 'max_bounces', 'use_denoising')},
+ 'compute': context.preferences.addons['cycles'].preferences.compute_device_type,
+ }
+ with internal_operators():
+ result = bpy.ops.object.bake_textures('EXEC_DEFAULT', texture_resolution=self.bake_resolution,
+ bake_pbr=False, add_material=True, flatten_for_refine=False,
+ try_unwrap='smart', overlap_only=True)
+ if result != {'RUNNING_MODAL'}:
+ raise RuntimeError(f'Bake did not start: {result}')
+ self.phase = 'bake'
+ self.settle_ticks = 0
+
+ def restore_bake(self, context):
+ if self.bake_restore:
+ saved = self.bake_restore
+ self.scene.render.engine = saved['engine']
+ self.scene.render.use_persistent_data = saved['persistent']
+ for key, value in saved['cycles'].items():
+ setattr(self.scene.cycles, key, value)
+ context.preferences.addons['cycles'].preferences.compute_device_type = saved['compute']
+ self.bake_restore = None
+
+ def tick(self, context):
+ from .generator import ComfyUIGenerate
+ from ..core import state
+ from ..utils import get_dir_path
+ if self.scene and self.window.scene != self.scene:
+ self.window.scene = self.scene
+ self.stop_requested = True
+ if self.phase in {'generation', 'bake'}:
+ if ComfyUIGenerate._is_running or any(
+ op.bl_idname in {'OBJECT_OT_test_stable', 'OBJECT_OT_bake_textures'}
+ for win in context.window_manager.windows for op in win.modal_operators):
+ return
+ if self.phase == 'generation':
+ if self.scene.sg_last_gen_error:
+ raise RuntimeError(self.scene.sg_last_gen_error_message or 'Generation failed or was cancelled')
+ self.pass_index += 1
+ if self.stop_requested:
+ self.entry['status'] = 'stopped'
+ self.phase = 'next'
+ elif self.pass_index < len(CASES[self.index][1]):
+ self.apply_pass(context)
+ else:
+ self.start_bake(context)
+ else:
+ # Bake restores Cycles settings in a deferred callback.
+ self.settle_ticks += 1
+ if self.settle_ticks < 2:
+ return
+ self.restore_bake(context)
+ verify_baked(self.bake_objects, get_dir_path(context, 'baked'))
+ self.entry['objects'] = [obj.name for obj in self.bake_objects]
+ self.entry['output'] = self.scene.get('_sg_regression_output', '')
+ if '_sg_regression_output' in self.scene:
+ del self.scene['_sg_regression_output']
+ self.entry['file'] = str(self.root / f'{self.index + 1:02d}.blend')
+ save_scene(self.scene, self.entry['file'])
+ self.entry['status'] = 'passed'
+ self.phase = 'next'
+ self.write_report('running')
+ return
+ if self.stop_requested:
+ if state._pending_refreshes:
+ return
+ if self.entries and self.entries[-1]['status'] == 'running':
+ self.entries[-1]['status'] = 'stopped'
+ return self.finish(context)
+ if self.phase == 'next':
+ self.index += 1
+ if self.index == len(CASES):
+ return self.finish(context)
+ label = CASES[self.index][0]
+ self.entry = {'label': label, 'status': 'running', 'passes': []}
+ self.entries.append(self.entry)
+ self.write_report('running')
+ if not self.detail_camera_name and any(preset in DETAIL_PRESETS for preset in CASES[self.index][1]):
+ self.entry['status'] = 'skipped'
+ self.entry['skip_reason'] = 'No detail camera assigned'
+ self.write_report('running')
+ return
+ self.scene = copy_scene(context, self.template, f'Regression {self.index + 1:02d} {label}')
+ park_detail_camera(self.scene)
+ self.scene.use_fake_user = True
+ self.entry['scene'] = self.scene.name
+ self.pass_index = 0
+ self.apply_pass(context)
+ elif self.phase in {'refresh', 'ready'}:
+ if state._pending_refreshes:
+ if time.monotonic() > self.deadline:
+ # Never switch scenes with outstanding context-dependent refresh callbacks.
+ self.stop_requested = True
+ type(self).status = 'Model refresh timed out; waiting for cleanup'
+ return
+ if self.phase == 'refresh':
+ self.configure_pass(context)
+ else:
+ self.ready_ticks += 1
+ if self.ready_ticks >= 2:
+ self.start_generation(context)
+
+ def finish(self, context):
+ self.phase = 'finishing'
+ if self.scene and '_sg_regression_output' in self.scene:
+ del self.scene['_sg_regression_output']
+ result = build_comparison(context, self.entries, 'StableGen Regression Comparison')
+ result['regression_report'] = str(self.root / 'report.json')
+ save_scene(result, self.root / 'comparison.blend')
+ self.write_report('stopped' if self.stop_requested else 'complete')
+ self.cleanup(context)
+ passed = sum(entry['status'] == 'passed' for entry in self.entries)
+ level = {'INFO'} if passed == len(CASES) else {'WARNING'}
+ self.report(level, f'Regression: {passed}/{len(CASES)} passed. Results: {self.root}')
+ return {'FINISHED'}
+
+ def cleanup(self, context):
+ if self.timer:
+ context.window_manager.event_timer_remove(self.timer)
+ self.timer = None
+ type(self)._active = None
+ type(self).status = ''
+
+ def modal(self, context, event):
+ if event.type == 'ESC':
+ self.stop_requested = True
+ return {'RUNNING_MODAL'}
+ if event.type != 'TIMER':
+ return {'PASS_THROUGH'}
+ # Blender's Event does not expose the originating timer. Generation and
+ # baking also emit TIMER events, so throttle our state machine by time.
+ now = time.monotonic()
+ if now < self._next_tick:
+ return {'PASS_THROUGH'}
+ self._next_tick = now + .5
+ try:
+ with context.temp_override(window=self.window, area=self.area):
+ result = self.tick(bpy.context)
+ if result:
+ return result
+ except Exception as exc:
+ import traceback
+ traceback.print_exc()
+ if self.phase == 'finishing' or self.index >= len(CASES) or not self.entries:
+ self.window.scene = self.source
+ self.cleanup(context)
+ self.report({'ERROR'}, f'Regression could not finish: {exc}')
+ return {'CANCELLED'}
+ self.entry['status'] = 'failed'
+ self.entry['error'] = str(exc)
+ self.restore_bake(context)
+ if self.scene and '_sg_regression_output' in self.scene:
+ del self.scene['_sg_regression_output']
+ self.phase = 'next'
+ self.write_report('running')
+ type(self).status = (('Stopping after current pass: ' if self.stop_requested else '')
+ + f'{self.index + 1}/{len(CASES)} {self.phase}: '
+ + (CASES[self.index][0] if 0 <= self.index < len(CASES) else 'comparison'))
+ for area in self.window.screen.areas:
+ area.tag_redraw()
+ return {'PASS_THROUGH'}
+
+
+class SG_OT_StopTexturingRegression(bpy.types.Operator):
+ bl_idname = 'stablegen.stop_texturing_regression'
+ bl_label = 'Stop After Current Pass'
+ bl_description = 'Finish the active generation or bake, then build a partial comparison'
+
+ @classmethod
+ def poll(cls, context):
+ return SG_OT_TexturingRegression._active is not None
+
+ def execute(self, context):
+ SG_OT_TexturingRegression._active.stop_requested = True
+ return {'FINISHED'}
+
+
+REGRESSION_CLASSES = [SG_OT_RefreshRegressionModels, SG_OT_TexturingRegression, SG_OT_StopTexturingRegression]
diff --git a/stablegen/texturing/view_plan.py b/stablegen/texturing/view_plan.py
index ba496a7..c36f396 100644
--- a/stablegen/texturing/view_plan.py
+++ b/stablegen/texturing/view_plan.py
@@ -16,6 +16,17 @@ from typing import Any, Iterable, Mapping, Sequence
_NATURAL_PARTS = re.compile(r"(\d+)")
+def generation_cameras(scene):
+ """Scope regression passes without unlinking cameras used by existing materials."""
+ cameras = [obj for obj in scene.objects if obj.type == 'CAMERA']
+ if scene.get('_sg_regression_output'):
+ scope = scene.get('_sg_regression_camera_scope')
+ if scope in {'base', 'detail'}:
+ cameras = [obj for obj in cameras
+ if bool(obj.get('_sg_regression_detail_camera')) == (scope == 'detail')]
+ return cameras
+
+
def natural_name_key(name: str) -> tuple:
"""Return a stable natural-sort key (``Camera_2`` before ``Camera_10``)."""
return tuple(
diff --git a/stablegen/timeout_config.py b/stablegen/timeout_config.py
index 1c902cf..d2b10f8 100644
--- a/stablegen/timeout_config.py
+++ b/stablegen/timeout_config.py
@@ -2,17 +2,28 @@
import bpy # pylint: disable=import-error
-_DEFAULTS = {'ping': 1.0, 'api': 10.0, 'transfer': 120.0, 'reboot': 120.0, 'mesh_gen': 600.0, 'scan': 10.0}
+_DEFAULTS = {
+ 'ping': 1.0,
+ 'api': 10.0,
+ 'transfer': 120.0,
+ 'generation_heartbeat': 120.0,
+ 'reboot': 120.0,
+ 'mesh_gen': 600.0,
+ 'scan': 10.0,
+}
def get_timeout(category, default=None):
"""Return a timeout value (seconds) from the addon preferences.
Args:
- category: One of ``'ping'``, ``'api'``, ``'transfer'``, ``'reboot'``.
+ category: One of ``'ping'``, ``'api'``, ``'transfer'``,
+ ``'generation_heartbeat'``, ``'reboot'``, ``'mesh_gen'``,
+ or ``'scan'``.
default: Fallback value if the preference cannot be read.
When *None*, built-in defaults are:
- ping=1.0, api=10.0, transfer=120.0, reboot=120.0.
+ ping=1.0, api=10.0, transfer=120.0,
+ generation_heartbeat=120.0, reboot=120.0.
"""
if default is None:
default = _DEFAULTS.get(category, 10.0)
diff --git a/stablegen/ui/panel.py b/stablegen/ui/panel.py
index 03d8fa0..3a6b9a7 100644
--- a/stablegen/ui/panel.py
+++ b/stablegen/ui/panel.py
@@ -2301,6 +2301,13 @@ class StableGenPanel(bpy.types.Panel):
row.alignment = 'CENTER'
row.label(text="Debug / Diagnostics", icon="GHOST_ENABLED")
+ from ..texturing.regression import SG_OT_TexturingRegression
+ if SG_OT_TexturingRegression._active is not None:
+ debug_box.label(text=SG_OT_TexturingRegression.status)
+ debug_box.operator("stablegen.stop_texturing_regression", icon="CANCEL")
+ else:
+ debug_box.operator("stablegen.texturing_regression", icon="SEQUENCE")
+
row = debug_box.row()
row.operator("stablegen.export_retarget_debug_bundle",
text="Export Retarget Test Bundle",
diff --git a/stablegen/utils.py b/stablegen/utils.py
index 37d0d27..f77fb34 100644
--- a/stablegen/utils.py
+++ b/stablegen/utils.py
@@ -5,6 +5,7 @@ from datetime import datetime
# ── Heavy modal operators that should block most other panel buttons ──
_SG_BLOCKED_MODALS = frozenset({
'STABLEGEN_OT_masked_edit',
+ 'STABLEGEN_OT_texturing_regression',
'OBJECT_OT_test_stable',
'OBJECT_OT_bake_textures',
'OBJECT_OT_add_cameras',
@@ -276,6 +277,10 @@ def get_generation_dirs(context):
# Define directory structure
revision_dir = os.path.join(base_dir, scene_name, timestamp)
+ # Debug regression passes have isolated output paths without changing preferences.
+ regression_output = context.scene.get('_sg_regression_output')
+ if regression_output:
+ revision_dir = regression_output
masked_output = context.scene.get("_sg_masked_output")
if masked_output:
revision_dir = masked_output