Add Chromium-only Blender WebEngine parity work

blender-5.2.0/scripts/modules/gpu_extras/__init__.py

@@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: 2002-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+__all__ = (
+    "batch",
+    "presets",
+)

blender-5.2.0/scripts/modules/gpu_extras/batch.py

@@ -0,0 +1,82 @@
+# SPDX-FileCopyrightText: 2018-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+__all__ = (
+    "batch_for_shader",
+)
+
+
+def batch_for_shader(shader, type, content, *, indices=None):
+    """
+    Return a batch already configured and compatible with the shader.
+
+    :param shader: shader for which a compatible format will be computed.
+    :type shader: :class:`gpu.types.GPUShader`
+    :param type: The primitive type of batch geometry.
+    :type type: Literal['POINTS', 'LINES', 'TRIS', 'LINE_STRIP', 'TRI_STRIP', 'LINES_ADJ', 'TRIS_ADJ', 'LINE_STRIP_ADJ']
+    :param content: Maps the name of the shader attribute with the data to fill the vertex buffer.
+       For the dictionary values see documentation for :class:`gpu.types.GPUVertBuf.attr_fill` data argument.
+    :type content: dict[str, Buffer | Sequence[float] | Sequence[int] | \
+Sequence[Sequence[float]] | Sequence[Sequence[int]]]
+    :param indices: Optional index buffer contents. When omitted, the batch draws all vertices in order.
+    :type indices: Sequence[int] | Sequence[Sequence[int]] | None
+    :return: compatible batch
+    :rtype: :class:`gpu.types.GPUBatch`
+    """
+    from gpu.types import (
+        GPUBatch,
+        GPUIndexBuf,
+        GPUVertBuf,
+        GPUVertFormat,
+    )
+
+    def recommended_comp_type(attr_type):
+        if attr_type in {'FLOAT', 'VEC2', 'VEC3', 'VEC4', 'MAT3', 'MAT4'}:
+            return 'F32'
+        if attr_type in {'UINT', 'UVEC2', 'UVEC3', 'UVEC4'}:
+            return 'U32'
+        # `attr_type` in {'INT', 'IVEC2', 'IVEC3', 'IVEC4', 'BOOL'}.
+        return 'I32'
+
+    def recommended_attr_len(attr_name):
+        attr_len = 1
+        try:
+            item = content[attr_name][0]
+            while True:
+                attr_len *= len(item)
+                item = item[0]
+        except (TypeError, IndexError):
+            pass
+        return attr_len
+
+    def recommended_fetch_mode(comp_type):
+        if comp_type == 'F32':
+            return 'FLOAT'
+        return 'INT'
+
+    for data in content.values():
+        vbo_len = len(data)
+        break
+    else:
+        raise ValueError("Empty 'content'")
+
+    vbo_format = GPUVertFormat()
+    attrs_info = shader.attrs_info_get()
+    for name, attr_type in attrs_info:
+        comp_type = recommended_comp_type(attr_type)
+        attr_len = recommended_attr_len(name)
+        vbo_format.attr_add(id=name, comp_type=comp_type, len=attr_len, fetch_mode=recommended_fetch_mode(comp_type))
+
+    vbo = GPUVertBuf(vbo_format, vbo_len)
+
+    for id, data in content.items():
+        if len(data) != vbo_len:
+            raise ValueError("Length mismatch for 'content' values")
+        vbo.attr_fill(id, data)
+
+    if indices is None:
+        return GPUBatch(type=type, buf=vbo)
+    else:
+        ibo = GPUIndexBuf(type=type, seq=indices)
+        return GPUBatch(type=type, buf=vbo, elem=ibo)

blender-5.2.0/scripts/modules/gpu_extras/presets.py

@@ -0,0 +1,102 @@
+# SPDX-FileCopyrightText: 2018-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+__all__ = (
+    "draw_circle_2d",
+    "draw_texture_2d",
+)
+
+
+def draw_circle_2d(position, color, radius, *, segments=None):
+    """
+    Draw a circle.
+
+    :param position: 2D position where the circle will be drawn.
+    :type position: Sequence[float]
+    :param color: Color of the circle (RGBA).
+       To use transparency blend must be set to ``ALPHA``, see: :func:`gpu.state.blend_set`.
+    :type color: Sequence[float]
+    :param radius: Radius of the circle.
+    :type radius: float
+    :param segments: How many segments will be used to draw the circle.
+        Higher values give better results but the drawing will take longer.
+        If None or not specified, an automatic value will be calculated.
+    :type segments: int | None
+    """
+    from math import sin, cos, pi, ceil, acos
+    import gpu
+    from gpu.types import (
+        GPUBatch,
+        GPUVertBuf,
+        GPUVertFormat,
+    )
+
+    if segments is None:
+        max_pixel_error = 0.25  # TODO: multiply 0.5 by display dpi
+        segments = int(ceil(pi / acos(1.0 - max_pixel_error / radius)))
+        segments = max(segments, 8)
+        segments = min(segments, 1000)
+
+    if segments <= 0:
+        raise ValueError("Amount of segments must be greater than 0.")
+
+    with gpu.matrix.push_pop():
+        gpu.matrix.translate(position)
+        gpu.matrix.scale_uniform(radius)
+        mul = (1.0 / (segments - 1)) * (pi * 2)
+        verts = [(sin(i * mul), cos(i * mul)) for i in range(segments)]
+        fmt = GPUVertFormat()
+        pos_id = fmt.attr_add(id="pos", comp_type='F32', len=2, fetch_mode='FLOAT')
+        vbo = GPUVertBuf(len=len(verts), format=fmt)
+        vbo.attr_fill(id=pos_id, data=verts)
+        batch = GPUBatch(type='LINE_STRIP', buf=vbo)
+        shader = gpu.shader.from_builtin('POLYLINE_UNIFORM_COLOR')
+        shader.uniform_float("viewportSize", gpu.state.viewport_get()[2:])
+        shader.uniform_float("lineWidth", gpu.state.line_width_get())
+        shader.uniform_float("color", color)
+        batch.draw(shader)
+
+
+def draw_texture_2d(texture, position, width, height, is_scene_linear_with_rec709_srgb_target=False):
+    """
+    Draw a 2d texture.
+
+    :param texture: GPUTexture to draw (e.g. gpu.texture.from_image(image) for :class:`bpy.types.Image`).
+    :type texture: :class:`gpu.types.GPUTexture`
+    :param position: 2D position of the lower left corner.
+    :type position: Sequence[float]
+    :param width: Width of the image when drawn (not necessarily
+        the original width of the texture).
+    :type width: float
+    :param height: Height of the image when drawn.
+    :type height: float
+    :param is_scene_linear_with_rec709_srgb_target:
+        True if the `texture` is stored in scene linear color space and
+        the destination frame-buffer uses the Rec.709 sRGB color space
+        (which is true when drawing textures acquired from :class:`bpy.types.Image` inside a
+        'PRE_VIEW', 'POST_VIEW' or 'POST_PIXEL' draw handler).
+        Otherwise the color space is assumed to match the one of the frame-buffer. (default=False)
+    :type is_scene_linear_with_rec709_srgb_target: bool
+    """
+    import gpu
+    from . batch import batch_for_shader
+
+    coords = ((0, 0), (1, 0), (1, 1), (0, 1))
+    indices = ((0, 1, 2), (2, 3, 0))
+
+    shader = gpu.shader.from_builtin(
+        'IMAGE_SCENE_LINEAR_TO_REC709_SRGB' if is_scene_linear_with_rec709_srgb_target else 'IMAGE')
+    batch = batch_for_shader(
+        shader, 'TRIS',
+        {"pos": coords, "texCoord": coords},
+        indices=indices
+    )
+
+    with gpu.matrix.push_pop():
+        gpu.matrix.translate(position)
+        gpu.matrix.scale((width, height))
+
+        shader.uniform_sampler("image", texture)
+
+        batch.draw(shader)