852 lines
24 KiB
Python
852 lines
24 KiB
Python
# ##### BEGIN GPL LICENSE BLOCK #####
|
|
#
|
|
# This program is free software; you can redistribute it and/or
|
|
# modify it under the terms of the GNU General Public License
|
|
# as published by the Free Software Foundation; either version 2
|
|
# of the License, or (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software Foundation,
|
|
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
#
|
|
# ##### END GPL LICENSE BLOCK #####
|
|
|
|
import os
|
|
import logging
|
|
from collections.abc import Mapping
|
|
from contextlib import contextmanager
|
|
from typing import Optional, Tuple, Union
|
|
import math
|
|
|
|
from mathutils import Matrix
|
|
|
|
import blf
|
|
import bpy
|
|
from bpy import app
|
|
|
|
import gpu
|
|
from gpu_extras.batch import batch_for_shader
|
|
|
|
from .image_utils import IMG
|
|
|
|
bk_logger = logging.getLogger(__name__)
|
|
|
|
cached_images = {}
|
|
|
|
cached_gpu_textures = {}
|
|
|
|
_cached_image_shader: Optional[gpu.types.GPUShader] = None
|
|
|
|
SEGMENTS_DEFAULT = 4
|
|
|
|
|
|
def _resolve_region_dimensions(region) -> Tuple[float, float]:
|
|
width = getattr(region, "width", None) if region else None
|
|
height = getattr(region, "height", None) if region else None
|
|
|
|
if width is None or width <= 0 or height is None or height <= 0:
|
|
ctx_region = getattr(bpy.context, "region", None)
|
|
if ctx_region is not None:
|
|
width = width or getattr(ctx_region, "width", None)
|
|
height = height or getattr(ctx_region, "height", None)
|
|
|
|
width = float(width or 1.0)
|
|
height = float(height or 1.0)
|
|
return width, height
|
|
|
|
|
|
@contextmanager
|
|
def overlay_matrix_guard(region=None, *args, **kwargs):
|
|
"""Ensure viewport overlays draw in screen space regardless of other handlers."""
|
|
|
|
pushed = False
|
|
try:
|
|
try:
|
|
gpu.matrix.push()
|
|
pushed = True
|
|
gpu.matrix.load_identity()
|
|
width, height = _resolve_region_dimensions(region)
|
|
_set_overlay_projection(width, height)
|
|
except Exception: # noqa: BLE001
|
|
bk_logger.exception("Failed to prepare overlay matrix state")
|
|
yield
|
|
finally:
|
|
if pushed:
|
|
try:
|
|
gpu.matrix.pop()
|
|
except Exception: # noqa: BLE001
|
|
bk_logger.exception("Failed to restore overlay matrix state")
|
|
|
|
|
|
def _ortho_projection_matrix(width: float, height: float, *, near=-100.0, far=100.0):
|
|
"""Return a pixel-aligned orthographic projection matrix."""
|
|
|
|
if width <= 0.0:
|
|
width = 1.0
|
|
if height <= 0.0:
|
|
height = 1.0
|
|
if far == near:
|
|
far = near + 0.001
|
|
|
|
sx = 2.0 / width
|
|
sy = 2.0 / height
|
|
sz = -2.0 / (far - near)
|
|
tx = -1.0
|
|
ty = -1.0
|
|
tz = -(far + near) / (far - near)
|
|
|
|
return Matrix(
|
|
(
|
|
(sx, 0.0, 0.0, tx),
|
|
(0.0, sy, 0.0, ty),
|
|
(0.0, 0.0, sz, tz),
|
|
(0.0, 0.0, 0.0, 1.0),
|
|
)
|
|
)
|
|
|
|
|
|
def _set_overlay_projection(width: float, height: float):
|
|
"""Set the 2D projection matrix used by BlenderKit overlays."""
|
|
|
|
try:
|
|
projection = _ortho_projection_matrix(width, height)
|
|
gpu.matrix.load_projection_matrix(projection)
|
|
except Exception: # noqa: BLE001
|
|
bk_logger.exception("overlay_matrix_guard: Failed to load projection matrix")
|
|
|
|
|
|
VERTEX_SHADER_LEGACY = """
|
|
uniform mat4 ModelViewProjectionMatrix;
|
|
in vec2 pos;
|
|
in vec2 texCoord;
|
|
out vec2 uv;
|
|
|
|
void main()
|
|
{
|
|
uv = texCoord;
|
|
gl_Position = ModelViewProjectionMatrix * vec4(pos.xy, 0.0, 1.0);
|
|
}
|
|
"""
|
|
|
|
|
|
FRAGMENT_SHADER_LEGACY = """
|
|
in vec2 uv;
|
|
out vec4 fragColor;
|
|
uniform sampler2D image;
|
|
uniform float transparency;
|
|
uniform int color_space_mode;
|
|
|
|
vec3 linear_to_srgb(vec3 linear_color)
|
|
{
|
|
vec3 cutoff = vec3(0.0031308);
|
|
vec3 lower = linear_color * 12.92;
|
|
vec3 higher = 1.055 * pow(max(linear_color, vec3(0.0)), vec3(1.0 / 2.4)) - 0.055;
|
|
return mix(lower, higher, step(cutoff, linear_color));
|
|
}
|
|
|
|
void main()
|
|
{
|
|
vec4 color = texture(image, uv);
|
|
if (color_space_mode == 1) {
|
|
color.rgb = linear_to_srgb(color.rgb);
|
|
}
|
|
color.a *= transparency;
|
|
fragColor = color;
|
|
}
|
|
"""
|
|
|
|
|
|
def create_image_shader_info():
|
|
"""Return GPU shader info for the runtime image shader."""
|
|
shader_info = gpu.types.GPUShaderCreateInfo()
|
|
shader_info.vertex_in(0, "VEC2", "pos")
|
|
shader_info.vertex_in(1, "VEC2", "texCoord")
|
|
|
|
stage_iface = gpu.types.GPUStageInterfaceInfo("uv_iface")
|
|
stage_iface.smooth("VEC2", "uv")
|
|
shader_info.vertex_out(stage_iface)
|
|
|
|
shader_info.push_constant("MAT4", "ModelViewProjectionMatrix")
|
|
shader_info.push_constant("FLOAT", "transparency")
|
|
shader_info.push_constant("INT", "color_space_mode")
|
|
shader_info.sampler(0, "FLOAT_2D", "image")
|
|
|
|
shader_info.fragment_out(0, "VEC4", "fragColor")
|
|
shader_info.vertex_source(
|
|
"""
|
|
void main()
|
|
{
|
|
uv = texCoord;
|
|
gl_Position = ModelViewProjectionMatrix * vec4(pos.xy, 0.0, 1.0);
|
|
}
|
|
"""
|
|
)
|
|
shader_info.fragment_source(
|
|
"""
|
|
void main()
|
|
{
|
|
vec4 color = texture(image, uv);
|
|
if (color_space_mode == 1) {
|
|
vec3 cutoff = vec3(0.0031308);
|
|
vec3 lower = color.rgb * 12.92;
|
|
vec3 higher = 1.055 * pow(max(color.rgb, vec3(0.0)), vec3(1.0 / 2.4)) - 0.055;
|
|
color.rgb = mix(lower, higher, step(cutoff, color.rgb));
|
|
}
|
|
color.a *= transparency;
|
|
fragColor = color;
|
|
}
|
|
"""
|
|
)
|
|
return shader_info
|
|
|
|
|
|
def create_image_shader():
|
|
"""Return a cached shader that supports transparency across Blender versions.
|
|
Features:
|
|
- sRGB conversion for UI overlays
|
|
- transparency
|
|
"""
|
|
global _cached_image_shader
|
|
|
|
if _cached_image_shader is not None:
|
|
return _cached_image_shader
|
|
|
|
shader = None
|
|
|
|
create_info_supported = (
|
|
hasattr(gpu, "shader")
|
|
and hasattr(gpu.shader, "create_from_info")
|
|
and hasattr(gpu.types, "GPUShaderCreateInfo")
|
|
)
|
|
|
|
if create_info_supported:
|
|
try:
|
|
shader_info = create_image_shader_info()
|
|
shader = gpu.shader.create_from_info(shader_info)
|
|
except Exception: # noqa: BLE001
|
|
bk_logger.exception("Failed to create image shader")
|
|
shader = None
|
|
|
|
if shader is None:
|
|
try:
|
|
shader = gpu.types.GPUShader(VERTEX_SHADER_LEGACY, FRAGMENT_SHADER_LEGACY)
|
|
except Exception: # noqa: BLE001
|
|
bk_logger.exception("Failed to create image shader")
|
|
|
|
if shader is None:
|
|
# fallback to builtin shader
|
|
# mainly for MacOS builds that have issues with custom shaders
|
|
if app.version < (4, 0, 0):
|
|
shader = gpu.shader.from_builtin("2D_IMAGE")
|
|
else:
|
|
shader = gpu.shader.from_builtin("IMAGE")
|
|
|
|
_cached_image_shader = shader
|
|
return shader
|
|
|
|
|
|
def get_ui_scale() -> float:
|
|
"""Get the UI scale
|
|
|
|
Returns:
|
|
The UI scale factor as a float.
|
|
"""
|
|
return bpy.context.preferences.system.dpi / 96.0
|
|
# sources:
|
|
# "sys" values are from system,
|
|
# and for current monitor on which the blender is running
|
|
sys_ps = bpy.context.preferences.system.pixel_size
|
|
# dpi scaling 72 =-> 1.0, 126 -> 1.75 (dpi -> sys_ui_scale)
|
|
# 96 / dpi gives correct scale factor
|
|
sys_dpi = bpy.context.preferences.system.dpi
|
|
# global scaler
|
|
sys_sc = bpy.context.preferences.system.ui_scale
|
|
# local ui scaler (can be set by user per blender window)
|
|
view_sc = bpy.context.preferences.view.ui_scale
|
|
|
|
|
|
def _get_flat_shader_2d():
|
|
if app.version < (4, 0, 0):
|
|
shader_name = "2D_UNIFORM_COLOR"
|
|
else:
|
|
shader_name = "UNIFORM_COLOR"
|
|
return gpu.shader.from_builtin(shader_name)
|
|
|
|
|
|
def draw_rect(x, y, width, height, color):
|
|
"""Used for drawing 2D rectangle backgrounds."""
|
|
xmax = x + width
|
|
ymax = y + height
|
|
points = (
|
|
(x, y), # (x, y)
|
|
(x, ymax), # (x, y)
|
|
(xmax, ymax), # (x, y)
|
|
(xmax, y), # (x, y)
|
|
)
|
|
indices = ((0, 1, 2), (2, 3, 0))
|
|
|
|
shader = _get_flat_shader_2d()
|
|
batch = batch_for_shader(shader, "TRIS", {"pos": points}, indices=indices)
|
|
|
|
gpu.state.blend_set("ALPHA")
|
|
shader.bind()
|
|
shader.uniform_float("color", color)
|
|
batch.draw(shader)
|
|
|
|
|
|
def draw_rect_outline(x, y, width, height, color, line_width=1.0):
|
|
"""Used for drawing 2D rectangle outlines."""
|
|
xmax = x + width
|
|
ymax = y + height
|
|
coords = (
|
|
(x, y), # (x, y)
|
|
(x, ymax), # (x, y)
|
|
(xmax, ymax), # (x, y)
|
|
(xmax, y), # (x, y)
|
|
)
|
|
indices = ((0, 1), (1, 2), (2, 3), (3, 0))
|
|
|
|
shader = _get_flat_shader_2d()
|
|
batch = batch_for_shader(shader, "LINES", {"pos": coords}, indices=indices)
|
|
|
|
gpu.state.blend_set("ALPHA")
|
|
gpu.state.line_width_set(line_width)
|
|
shader.bind()
|
|
shader.uniform_float("color", color)
|
|
batch.draw(shader)
|
|
|
|
|
|
def draw_line2d(x1, y1, x2, y2, width, color):
|
|
"""Used for drawing line from dragged thumbnail to the 3D bounding box."""
|
|
coords = ((x1, y1), (x2, y2))
|
|
indices = ((0, 1),)
|
|
|
|
shader = _get_flat_shader_2d()
|
|
|
|
batch = batch_for_shader(shader, "LINES", {"pos": coords}, indices=indices)
|
|
gpu.state.blend_set("ALPHA")
|
|
gpu.state.line_width_set(max(1.0, width))
|
|
shader.bind()
|
|
shader.uniform_float("color", color)
|
|
batch.draw(shader)
|
|
gpu.state.line_width_set(1.0)
|
|
|
|
|
|
def _parse_radius_value(
|
|
value,
|
|
*,
|
|
max_radius: float,
|
|
min_dimension: float,
|
|
ui_scale: float = 1.0,
|
|
) -> float:
|
|
"""Return a clamped radius in pixels.
|
|
|
|
Accepts raw pixel values, strings with percentages (e.g. "50%"),
|
|
mapping types containing ``percent``/``pct``/``ratio`` or ``px`` keys,
|
|
and falls back to treating anything else as raw pixels.
|
|
"""
|
|
|
|
def clamp_radius(radius: float) -> float:
|
|
return max(0.0, min(radius, max_radius))
|
|
|
|
effective_scale = ui_scale if ui_scale > 0.0 else 1.0
|
|
|
|
def scale_px_value(px_value: float) -> float:
|
|
return clamp_radius(px_value * effective_scale)
|
|
|
|
if isinstance(value, str):
|
|
text = value.strip()
|
|
if text.endswith("%"):
|
|
number = text[:-1].strip()
|
|
try:
|
|
pct = float(number) / 100.0
|
|
except ValueError:
|
|
return 0.0
|
|
radius_px = pct * min_dimension
|
|
return clamp_radius(radius_px)
|
|
# plain numeric string interpreted as pixels
|
|
try:
|
|
value = float(text)
|
|
except ValueError:
|
|
return 0.0
|
|
return scale_px_value(value)
|
|
|
|
if isinstance(value, Mapping):
|
|
if "percent" in value:
|
|
try:
|
|
pct = float(value["percent"]) / 100.0
|
|
except (TypeError, ValueError):
|
|
pct = 0.0
|
|
radius_px = pct * min_dimension
|
|
return clamp_radius(radius_px)
|
|
if "pct" in value:
|
|
try:
|
|
pct = float(value["pct"]) / 100.0
|
|
except (TypeError, ValueError):
|
|
pct = 0.0
|
|
radius_px = pct * min_dimension
|
|
return clamp_radius(radius_px)
|
|
if "ratio" in value:
|
|
try:
|
|
ratio = float(value["ratio"])
|
|
except (TypeError, ValueError):
|
|
ratio = 0.0
|
|
radius_px = ratio * min_dimension
|
|
return clamp_radius(radius_px)
|
|
if "px" in value:
|
|
try:
|
|
px_value = float(value["px"])
|
|
except (TypeError, ValueError):
|
|
px_value = 0.0
|
|
return scale_px_value(px_value)
|
|
|
|
try:
|
|
numeric_value = float(value) # type: ignore
|
|
except (TypeError, ValueError):
|
|
numeric_value = 0.0
|
|
return scale_px_value(numeric_value)
|
|
|
|
|
|
def _rounded_rect_outline(
|
|
x: float,
|
|
y: float,
|
|
width: float,
|
|
height: float,
|
|
radius: Union[tuple[Union[str, float], ...], str, float] = (0.0,),
|
|
segments: int = SEGMENTS_DEFAULT,
|
|
):
|
|
if width <= 0 or height <= 0:
|
|
return []
|
|
min_dimension = min(width, height)
|
|
max_radius = max(0.0, min_dimension / 2.0)
|
|
|
|
if isinstance(radius, (tuple, list)):
|
|
raw_radii = list(radius)
|
|
else:
|
|
raw_radii = [radius]
|
|
if not raw_radii:
|
|
raw_radii = [0.0]
|
|
ui_scale = get_ui_scale()
|
|
parsed_radii = [
|
|
_parse_radius_value(
|
|
value,
|
|
max_radius=max_radius,
|
|
min_dimension=min_dimension,
|
|
ui_scale=ui_scale,
|
|
)
|
|
for value in raw_radii
|
|
]
|
|
while len(parsed_radii) < 4:
|
|
parsed_radii.append(parsed_radii[-1])
|
|
radii = parsed_radii[:4]
|
|
|
|
r_tl, r_tr, r_br, r_bl = radii
|
|
|
|
if all(r == 0.0 for r in radii):
|
|
outline = [
|
|
(x, y),
|
|
(x + width, y),
|
|
(x + width, y + height),
|
|
(x, y + height),
|
|
]
|
|
outline.append(outline[0])
|
|
return outline
|
|
|
|
steps = max(1, int(segments))
|
|
outline = []
|
|
steps = max(1, int(segments))
|
|
outline = []
|
|
|
|
def emit_corner(cx, cy, start_angle, end_angle, radius_value, fallback_point):
|
|
if radius_value <= 0.0:
|
|
outline.append(fallback_point)
|
|
return
|
|
for step in range(steps + 1):
|
|
t = step / steps
|
|
angle = start_angle + (end_angle - start_angle) * t
|
|
outline.append(
|
|
(
|
|
cx + math.cos(angle) * radius_value,
|
|
cy + math.sin(angle) * radius_value,
|
|
)
|
|
)
|
|
|
|
emit_corner(
|
|
x + r_tl,
|
|
y + height - r_tl,
|
|
math.pi,
|
|
math.pi / 2.0,
|
|
r_tl,
|
|
(x, y + height),
|
|
)
|
|
emit_corner(
|
|
x + width - r_tr,
|
|
y + height - r_tr,
|
|
math.pi / 2.0,
|
|
0.0,
|
|
r_tr,
|
|
(x + width, y + height),
|
|
)
|
|
emit_corner(
|
|
x + width - r_br,
|
|
y + r_br,
|
|
0.0,
|
|
-math.pi / 2.0,
|
|
r_br,
|
|
(x + width, y),
|
|
)
|
|
emit_corner(
|
|
x + r_bl,
|
|
y + r_bl,
|
|
-math.pi / 2.0,
|
|
-math.pi,
|
|
r_bl,
|
|
(x, y),
|
|
)
|
|
|
|
if outline and outline[0] != outline[-1]:
|
|
outline.append(outline[0])
|
|
return outline
|
|
|
|
|
|
def _rounded_rect_mesh(
|
|
x: float,
|
|
y: float,
|
|
width: float,
|
|
height: float,
|
|
radius: Union[tuple[Union[str, float], ...], str, float],
|
|
crop: Tuple[float, float, float, float],
|
|
segments: int = SEGMENTS_DEFAULT,
|
|
):
|
|
if width <= 0.0 or height <= 0.0:
|
|
return None
|
|
outline = _rounded_rect_outline(
|
|
x,
|
|
y,
|
|
width,
|
|
height,
|
|
radius,
|
|
segments=segments,
|
|
)
|
|
if not outline:
|
|
return None
|
|
loop = outline[:-1] if len(outline) > 1 and outline[0] == outline[-1] else outline
|
|
if len(loop) < 3:
|
|
return None
|
|
crop_u0, crop_v0, crop_u1, crop_v1 = crop
|
|
u_span = crop_u1 - crop_u0
|
|
v_span = crop_v1 - crop_v0
|
|
if u_span == 0.0:
|
|
u_span = 1.0
|
|
if v_span == 0.0:
|
|
v_span = 1.0
|
|
coords = list(loop)
|
|
try:
|
|
inv_width = 1.0 / width
|
|
except ZeroDivisionError:
|
|
inv_width = 0.0
|
|
try:
|
|
inv_height = 1.0 / height
|
|
except ZeroDivisionError:
|
|
inv_height = 0.0
|
|
uvs = []
|
|
for vx, vy in coords:
|
|
rel_x = (vx - x) * inv_width
|
|
rel_y = (vy - y) * inv_height
|
|
u = crop_u0 + rel_x * u_span
|
|
v = crop_v0 + rel_y * v_span
|
|
uvs.append((u, v))
|
|
indices = [(0, idx, idx + 1) for idx in range(1, len(coords) - 1)]
|
|
return coords, uvs, indices
|
|
|
|
|
|
def draw_rounded_rect_with_border(
|
|
x: float,
|
|
y: float,
|
|
width: float,
|
|
height: float,
|
|
radius: Union[tuple[Union[str, float], ...], str, float] = (0.0,),
|
|
fill_color: Tuple[float, float, float, float] = (0.0, 0.0, 0.0, 1.0),
|
|
border_color: Optional[Tuple[float, float, float, float]] = None,
|
|
border_thickness: float = 1.0,
|
|
):
|
|
if width <= 0 or height <= 0:
|
|
return
|
|
outline = _rounded_rect_outline(x, y, width, height, radius)
|
|
if not outline:
|
|
return
|
|
loop = outline[:-1] if len(outline) > 1 and outline[0] == outline[-1] else outline
|
|
if len(loop) < 3:
|
|
return
|
|
shader = _get_flat_shader_2d()
|
|
indices = [(0, idx, idx + 1) for idx in range(1, len(loop) - 1)]
|
|
batch = batch_for_shader(shader, "TRIS", {"pos": loop}, indices=indices)
|
|
gpu.state.blend_set("ALPHA")
|
|
shader.bind()
|
|
shader.uniform_float("color", fill_color)
|
|
batch.draw(shader)
|
|
if border_color and border_thickness > 0:
|
|
gpu.state.line_width_set(border_thickness)
|
|
if outline[0] == outline[-1]:
|
|
line_points = outline
|
|
else:
|
|
line_points = outline + [outline[0]]
|
|
line_batch = batch_for_shader(shader, "LINE_STRIP", {"pos": line_points})
|
|
shader.uniform_float("color", border_color)
|
|
line_batch.draw(shader)
|
|
gpu.state.line_width_set(1.0)
|
|
|
|
|
|
def draw_strikethrough_line(x_start, x_end, y, color, thickness):
|
|
if x_end <= x_start:
|
|
return
|
|
draw_line2d(x_start, y, x_end, y, thickness, color)
|
|
|
|
|
|
def create_shader_info():
|
|
"""Added for Blender 4.5+ in which the gpu.shader.from_builtin("UNIFORM_COLOR") silently stopped working.
|
|
Interestingly for draw_rect_3d UNIFORM_COLOR still works just fine.
|
|
https://github.com/BlenderKit/BlenderKit/issues/1574
|
|
"""
|
|
if app.version < (4, 5, 0):
|
|
return bk_logger.warning("Unexpected call to create_shader_info()!")
|
|
shader_info = gpu.types.GPUShaderCreateInfo()
|
|
shader_info.vertex_in(0, "VEC3", "pos")
|
|
shader_info.push_constant("MAT4", "ModelViewProjectionMatrix")
|
|
shader_info.push_constant("VEC4", "color")
|
|
shader_info.fragment_out(0, "VEC4", "fragColor")
|
|
shader_info.vertex_source(
|
|
"""
|
|
void main() {
|
|
gl_Position = ModelViewProjectionMatrix * vec4(pos, 1.0);
|
|
}
|
|
"""
|
|
)
|
|
shader_info.fragment_source(
|
|
"""
|
|
void main() {
|
|
fragColor = color;
|
|
}
|
|
"""
|
|
)
|
|
return shader_info
|
|
|
|
|
|
def draw_lines(vertices, indices, color):
|
|
"""Used for drawing 3D bounding box."""
|
|
if app.version < (4, 0, 0):
|
|
shader = gpu.shader.from_builtin("3D_UNIFORM_COLOR")
|
|
elif app.version < (4, 5, 0):
|
|
shader = gpu.shader.from_builtin("UNIFORM_COLOR")
|
|
else:
|
|
shader_info = create_shader_info()
|
|
shader = gpu.shader.create_from_info(shader_info)
|
|
|
|
batch = batch_for_shader(shader, "LINES", {"pos": vertices}, indices=indices)
|
|
gpu.state.blend_set("ALPHA")
|
|
shader.bind()
|
|
shader.uniform_float("color", color)
|
|
batch.draw(shader)
|
|
|
|
|
|
def draw_rect_3d(coords, color):
|
|
"""Used for drawing 3D rectangle backgrounds."""
|
|
indices = [(0, 1, 2), (2, 3, 0)]
|
|
if app.version < (4, 0, 0):
|
|
shader = gpu.shader.from_builtin("3D_UNIFORM_COLOR")
|
|
else:
|
|
shader = gpu.shader.from_builtin("UNIFORM_COLOR")
|
|
batch = batch_for_shader(shader, "TRIS", {"pos": coords}, indices=indices)
|
|
|
|
gpu.state.blend_set("ALPHA")
|
|
shader.bind()
|
|
shader.uniform_float("color", color)
|
|
batch.draw(shader)
|
|
|
|
|
|
def _resolve_color_space_mode() -> int:
|
|
"""Return shader color conversion mode for the current drawing context.
|
|
|
|
area over non-3D means UI overlay, so we need to apply sRGB conversion."""
|
|
area = getattr(bpy.context, "area", None)
|
|
if area is None:
|
|
return 0
|
|
|
|
# Blender 5.0+ node editors already expect linear data, so avoid extra conversion there
|
|
node_editor_types = {"NODE_EDITOR", "VIEW_3D"}
|
|
|
|
if area.type in node_editor_types:
|
|
return 0
|
|
|
|
return 1
|
|
|
|
|
|
def draw_image_runtime(
|
|
x: float,
|
|
y: float,
|
|
width: float,
|
|
height: float,
|
|
image: Union[bpy.types.Image, IMG],
|
|
transparency: Optional[float] = 1.0,
|
|
crop: Tuple[float, float, float, float] = (0, 0, 1, 1),
|
|
batch: Optional[gpu.types.GPUBatch] = None,
|
|
corner_radius: Optional[Union[tuple[Union[str, float], ...], str, float]] = None,
|
|
corner_segments: int = SEGMENTS_DEFAULT,
|
|
) -> Optional[gpu.types.GPUBatch]:
|
|
"""Draws an image at given location with given size.
|
|
|
|
Supports optional rounded corner clipping by supplying ``corner_radius``.
|
|
|
|
Returns:
|
|
The batch object if successful, or None if the image is invalid.
|
|
"""
|
|
if width <= 0.0 or height <= 0.0 or not image.name or not image.filepath:
|
|
return None
|
|
|
|
image_shader = create_image_shader()
|
|
rounded_segments = max(1, int(corner_segments))
|
|
cache_key = (
|
|
image.filepath,
|
|
float(x),
|
|
float(y),
|
|
float(width),
|
|
float(height),
|
|
tuple(float(component) for component in crop),
|
|
repr(corner_radius) if corner_radius is not None else None,
|
|
rounded_segments,
|
|
)
|
|
|
|
texture = None
|
|
if batch is None:
|
|
ci = cached_images.get(cache_key)
|
|
if ci is not None:
|
|
batch = ci["batch"]
|
|
image_shader = ci["image_shader"]
|
|
texture = ci["texture"]
|
|
|
|
if batch is None:
|
|
coords = None
|
|
uvs = None
|
|
indices = None
|
|
if corner_radius is not None:
|
|
mesh_data = _rounded_rect_mesh(
|
|
x,
|
|
y,
|
|
width,
|
|
height,
|
|
corner_radius,
|
|
crop,
|
|
rounded_segments,
|
|
)
|
|
if mesh_data:
|
|
coords, uvs, indices = mesh_data
|
|
if coords is None or uvs is None or indices is None:
|
|
coords = [(x, y), (x + width, y), (x, y + height), (x + width, y + height)]
|
|
uvs = [
|
|
(crop[0], crop[1]),
|
|
(crop[2], crop[1]),
|
|
(crop[0], crop[3]),
|
|
(crop[2], crop[3]),
|
|
]
|
|
indices = [(0, 1, 2), (2, 1, 3)]
|
|
batch = batch_for_shader(
|
|
image_shader, "TRIS", {"pos": coords, "texCoord": uvs}, indices=indices
|
|
)
|
|
texture = path_to_gpu_texture(image.filepath)
|
|
cached_images[cache_key] = {
|
|
"batch": batch,
|
|
"image_shader": image_shader,
|
|
"texture": texture,
|
|
}
|
|
|
|
if batch is None or image_shader is None:
|
|
return None
|
|
|
|
if texture is None:
|
|
texture = path_to_gpu_texture(image.filepath)
|
|
|
|
if texture is None:
|
|
return None
|
|
|
|
color_space_mode = _resolve_color_space_mode()
|
|
|
|
gpu.state.blend_set("ALPHA")
|
|
|
|
image_shader.bind()
|
|
image_shader.uniform_sampler("image", texture)
|
|
|
|
# may not be available in simple shader
|
|
try:
|
|
# set floats
|
|
image_shader.uniform_float("transparency", transparency)
|
|
|
|
# set color space mode
|
|
image_shader.uniform_int("color_space_mode", color_space_mode)
|
|
batch.draw(image_shader)
|
|
except Exception:
|
|
pass
|
|
|
|
return batch
|
|
|
|
|
|
def path_to_gpu_texture(path: str) -> Optional[gpu.types.GPUTexture]:
|
|
"""Convert a Blender image to a GPU texture.
|
|
|
|
Returns:
|
|
The GPU texture if successful, or None if the image is invalid.
|
|
"""
|
|
# check if exists and is file [prevent exception for missing files]
|
|
if path in cached_gpu_textures:
|
|
return cached_gpu_textures[path]
|
|
|
|
if not os.path.exists(path) or not os.path.isfile(path):
|
|
# do not spam log with warnings, just return None
|
|
return None
|
|
img = bpy.data.images.load(path, check_existing=False)
|
|
img.gl_load()
|
|
|
|
tex = gpu.texture.from_image(img)
|
|
cached_gpu_textures[path] = tex
|
|
|
|
# # Clean up Blender image
|
|
bpy.data.images.remove(img)
|
|
return tex
|
|
|
|
|
|
def get_text_size(
|
|
font_id: int = 0, text: str = "", text_size: float = 16, dpi: int = 72
|
|
):
|
|
if app.version < (4, 0, 0):
|
|
blf.size(font_id, text_size, dpi)
|
|
else:
|
|
blf.size(font_id, text_size)
|
|
return blf.dimensions(font_id, text)
|
|
|
|
|
|
def draw_text(text, x, y, size, color=(1, 1, 1, 0.5), halign="LEFT", valign="TOP"):
|
|
font_id = 1
|
|
if type(text) != str:
|
|
text = str(text)
|
|
blf.color(font_id, color[0], color[1], color[2], color[3])
|
|
if app.version < (4, 0, 0):
|
|
blf.size(font_id, size, 72)
|
|
else:
|
|
blf.size(font_id, size)
|
|
if halign != "LEFT":
|
|
width, height = blf.dimensions(font_id, text)
|
|
if halign == "RIGHT":
|
|
x -= width
|
|
elif halign == "CENTER":
|
|
x -= width // 2
|
|
if valign == "CENTER":
|
|
y -= height // 2
|
|
# bottom could be here but there's no reason for it
|
|
blf.position(font_id, x, y, 0)
|
|
|
|
blf.draw(font_id, text)
|