233 lines
7.9 KiB
Python
233 lines
7.9 KiB
Python
"""
|
|
Compatibility helpers wrapping Blender version-specific logic.
|
|
|
|
Anything that differs between Blender 4.2 LTS, 4.5 LTS, and 5.0+ should live here
|
|
so the main add-on stays focused on user-facing behavior.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import os
|
|
from typing import Iterable, Optional
|
|
|
|
try:
|
|
import bpy # type: ignore
|
|
from bpy.utils import register_class, unregister_class # type: ignore
|
|
except ImportError: # pragma: no cover - for static tooling
|
|
bpy = None # type: ignore
|
|
register_class = unregister_class = lambda cls: None # type: ignore
|
|
|
|
from . import version
|
|
|
|
|
|
# -- Registration helpers --------------------------------------------------
|
|
def safe_register_class(cls) -> bool:
|
|
try:
|
|
register_class(cls)
|
|
return True
|
|
except Exception as exc: # pragma: no cover - Blender runtime logging
|
|
print(f"[BasedPlayblast] register fail: {cls.__name__}: {exc}")
|
|
return False
|
|
|
|
|
|
def safe_unregister_class(cls) -> bool:
|
|
try:
|
|
unregister_class(cls)
|
|
return True
|
|
except Exception as exc: # pragma: no cover
|
|
print(f"[BasedPlayblast] unregister fail: {cls.__name__}: {exc}")
|
|
return False
|
|
|
|
|
|
# -- Scene/helpers ---------------------------------------------------------
|
|
def get_compositor_tree(scene):
|
|
"""
|
|
Return the compositor node tree, accounting for Blender 5.0 renames.
|
|
"""
|
|
if version.is_version_at_least(5, 0, 0):
|
|
return getattr(scene, "compositing_node_tree", None)
|
|
return getattr(scene, "node_tree", None)
|
|
|
|
|
|
def is_geometry_nodes_modifier(modifier) -> bool:
|
|
return getattr(modifier, "type", None) == "NODES"
|
|
|
|
|
|
def get_geometry_nodes_node_group(modifier):
|
|
if is_geometry_nodes_modifier(modifier):
|
|
return getattr(modifier, "node_group", None)
|
|
return None
|
|
|
|
|
|
# -- Render IO -------------------------------------------------------------
|
|
def set_video_file_format(scene) -> bool:
|
|
"""
|
|
Force Blender onto a video-friendly output. Returns True if a usable
|
|
format was chosen; False means callers should warn/abort.
|
|
|
|
- Blender 4.2/4.5: Can set FFMPEG directly for direct video output
|
|
- Blender 5.0+: image_settings.file_format no longer includes video formats.
|
|
We use PNG with 0% compression (fast, lossless) and encode frames manually.
|
|
"""
|
|
if not scene or not getattr(scene, "render", None):
|
|
return False
|
|
|
|
render = scene.render
|
|
is_blender_5 = version.is_version_at_least(5, 0, 0)
|
|
|
|
if not is_blender_5:
|
|
# Blender 4.2/4.5: Can set FFMPEG directly for direct video output
|
|
try:
|
|
render.image_settings.file_format = "FFMPEG"
|
|
return True
|
|
except Exception as exc:
|
|
print(f"[BasedPlayblast] FFMPEG set failed: {exc}")
|
|
return False
|
|
|
|
# Blender 5.0+: image_settings.file_format only supports image formats
|
|
# Use PNG with 0% compression - fast writes, lossless quality, then encode to video
|
|
if hasattr(render, "ffmpeg"):
|
|
try:
|
|
render.image_settings.file_format = "PNG"
|
|
render.image_settings.compression = 0 # 0% compression = fastest PNG writes
|
|
print("[BasedPlayblast] Blender 5.0: Using PNG with 0% compression "
|
|
"(fast, lossless quality). Blender 5.0 removed video formats from "
|
|
"image_settings.file_format, so we encode frames to video manually.")
|
|
return True
|
|
except Exception as exc:
|
|
print(f"[BasedPlayblast] PNG with 0% compression failed: {exc}")
|
|
|
|
# Last resort: PNG with default compression
|
|
try:
|
|
render.image_settings.file_format = "PNG"
|
|
print("[BasedPlayblast] video fallback -> PNG sequence (will encode manually)")
|
|
return False
|
|
except Exception as exc:
|
|
print(f"[BasedPlayblast] PNG fallback failed: {exc}")
|
|
return False
|
|
|
|
|
|
def viewport_opengl_render(context, area=None, region=None):
|
|
"""
|
|
Invoke viewport OpenGL animation render with overrides tuned per version.
|
|
"""
|
|
if bpy is None:
|
|
raise RuntimeError("bpy unavailable")
|
|
|
|
is_blender_5 = version.is_version_at_least(5, 0, 0)
|
|
|
|
def _call(**override_kwargs):
|
|
with context.temp_override(**override_kwargs):
|
|
bpy.ops.render.opengl(
|
|
"INVOKE_DEFAULT",
|
|
animation=True,
|
|
sequencer=False,
|
|
write_still=False,
|
|
**({"view_context": True} if not is_blender_5 else {}),
|
|
)
|
|
|
|
def _resolve_region(target_area, candidate_region):
|
|
if candidate_region and getattr(candidate_region, "type", None) == "WINDOW":
|
|
return candidate_region
|
|
if target_area:
|
|
for reg in target_area.regions:
|
|
if getattr(reg, "type", None) == "WINDOW":
|
|
return reg
|
|
return None
|
|
|
|
target_region = _resolve_region(area, region)
|
|
try:
|
|
if area and target_region:
|
|
override = context.copy()
|
|
override["area"] = area
|
|
override["region"] = target_region
|
|
_call(**override)
|
|
return True
|
|
bpy.ops.render.opengl(
|
|
"INVOKE_DEFAULT", animation=True, sequencer=False, write_still=False
|
|
)
|
|
return True
|
|
except TypeError:
|
|
# Blender 5 requires explicit view_context flag in some builds
|
|
if area and target_region:
|
|
override = context.copy()
|
|
override["area"] = area
|
|
override["region"] = target_region
|
|
with context.temp_override(**override):
|
|
bpy.ops.render.opengl(
|
|
"INVOKE_DEFAULT",
|
|
animation=True,
|
|
sequencer=False,
|
|
write_still=False,
|
|
view_context=False,
|
|
)
|
|
return True
|
|
bpy.ops.render.opengl(
|
|
"INVOKE_DEFAULT",
|
|
animation=True,
|
|
sequencer=False,
|
|
write_still=False,
|
|
view_context=False,
|
|
)
|
|
return True
|
|
except Exception as exc:
|
|
print(f"[BasedPlayblast] OpenGL render failed: {exc}")
|
|
raise
|
|
|
|
|
|
# -- Studio lights helpers --------------------------------------------------
|
|
def iter_studio_light_dirs(blender_binary_path: Optional[str]) -> Iterable[str]:
|
|
if not blender_binary_path:
|
|
return []
|
|
|
|
blender_dir = os.path.dirname(blender_binary_path)
|
|
version_token = version.get_version_category().split("+")[0]
|
|
candidates = [
|
|
os.path.join(blender_dir, "datafiles", "studiolights", "world"),
|
|
os.path.join(blender_dir, version_token, "datafiles", "studiolights", "world"),
|
|
os.path.join(os.path.dirname(blender_dir), version_token, "datafiles", "studiolights", "world"),
|
|
os.path.join(os.path.dirname(os.path.dirname(blender_binary_path)), version_token, "datafiles", "studiolights", "world"),
|
|
os.path.join("C:\\Program Files\\Blender Foundation", f"Blender {version_token}", version_token, "datafiles", "studiolights", "world"),
|
|
]
|
|
seen = set()
|
|
for path in candidates:
|
|
if path and path not in seen:
|
|
seen.add(path)
|
|
yield path
|
|
|
|
|
|
def find_first_existing_path(paths: Iterable[str]) -> Optional[str]:
|
|
for path in paths:
|
|
if path and os.path.exists(path):
|
|
return path
|
|
return None
|
|
|
|
|
|
def resolve_hdri_path(studio_dir: Optional[str]) -> Optional[str]:
|
|
if not studio_dir:
|
|
return None
|
|
|
|
preferred = [
|
|
"forest.exr",
|
|
"studio.exr",
|
|
"city.exr",
|
|
"courtyard.exr",
|
|
"night.exr",
|
|
"sunrise.exr",
|
|
"sunset.exr",
|
|
]
|
|
|
|
for fname in preferred:
|
|
candidate = os.path.join(studio_dir, fname)
|
|
if os.path.exists(candidate):
|
|
return candidate
|
|
|
|
try:
|
|
for entry in os.listdir(studio_dir):
|
|
if entry.lower().endswith(".exr"):
|
|
return os.path.join(studio_dir, entry)
|
|
except Exception as exc:
|
|
print(f"[BasedPlayblast] Studio dir listing failed: {exc}")
|
|
return None
|
|
|