@tushar-br/editing-pack 1.0.188 → 1.0.190

package/staging_area/Blender/5.0/scripts/modules/bpy_extras/wm_utils/progress_report.py

@@ -1,160 +0,0 @@
-# SPDX-FileCopyrightText: 2015-2023 Blender Authors
-#
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-__all__ = (
-    "ProgressReport",
-    "ProgressReportSubstep",
-)
-
-import time
-
-
-class ProgressReport:
-    """
-    A basic 'progress report' using either simple prints in console, or WindowManager's 'progress' API.
-
-    This object can be used as a context manager.
-
-    It supports multiple levels of 'sub-steps' - you shall always enter at least one sub-step (because level 0
-    has only one single step, representing the whole 'area' of the progress stuff).
-
-    You should give the expected number of sub-steps each time you enter a new one (you may then step more or less then
-    given number, but this will give incoherent progression).
-
-    Leaving a sub-step automatically steps by one the parent level.
-
-        with ProgressReport() as progress:  # Not giving a WindowManager here will default to console printing.
-            progress.enter_substeps(10)
-            for i in range(10):
-                progress.enter_substeps(100)
-                for j in range(100):
-                    progress.step()
-                progress.leave_substeps()  # No need to step here, this implicitly does it.
-            progress.leave_substeps("Finished!")  # You may pass some message too.
-    """
-    __slots__ = ("wm", "running", "steps", "curr_step", "start_time")
-
-    def __init__(self, wm=None):
-        self_wm = getattr(self, "wm", None)
-        if self_wm:
-            self.finalize()
-        self.running = False
-
-        self.wm = wm
-        self.steps = [100000]
-        self.curr_step = [0]
-
-    initialize = __init__
-
-    def __enter__(self):
-        self.start_time = [time.time()]
-        if self.wm:
-            self.wm.progress_begin(0, self.steps[0])
-            self.update()
-            self.running = True
-        return self
-
-    def __exit__(self, _exc_type=None, _exc_value=None, _traceback=None):
-        self.running = False
-        if self.wm:
-            self.wm.progress_end()
-            self.wm = None
-        print("\n")
-        self.steps = [100000]
-        self.curr_step = [0]
-        self.start_time = [time.time()]
-
-    def start(self):
-        self.__enter__()
-
-    def finalize(self):
-        self.__exit__()
-
-    def update(self, msg=""):
-        steps = sum(s * cs for (s, cs) in zip(self.steps, self.curr_step))
-        steps_percent = steps / self.steps[0] * 100.0
-        tm = time.time()
-        loc_tm = tm - self.start_time[-1]
-        tm -= self.start_time[0]
-        if self.wm and self.running:
-            self.wm.progress_update(steps)
-        if msg:
-            prefix = "  " * (len(self.steps) - 1)
-            print(
-                prefix + "({:8.4f} sec | {:8.4f} sec) {:s}\nProgress: {:6.2f}%\r".format(
-                    tm, loc_tm, msg, steps_percent,
-                ),
-                end="",
-            )
-        else:
-            print("Progress: {:6.2f}%\r".format(steps_percent,), end="")
-
-    def enter_substeps(self, nbr, msg=""):
-        if msg:
-            self.update(msg)
-        self.steps.append(self.steps[-1] / max(nbr, 1))
-        self.curr_step.append(0)
-        self.start_time.append(time.time())
-
-    def step(self, msg="", nbr=1):
-        self.curr_step[-1] += nbr
-        self.update(msg)
-
-    def leave_substeps(self, msg=""):
-        if (msg):
-            self.update(msg)
-        assert len(self.steps) > 1
-        del self.steps[-1]
-        del self.curr_step[-1]
-        del self.start_time[-1]
-        self.step()
-
-
-class ProgressReportSubstep:
-    """
-    A sub-step context manager for ProgressReport.
-
-    It can be used to generate other sub-step contexts too, and can act as a (limited) proxy of its real ProgressReport.
-
-    Its exit method always ensure ProgressReport is back on 'level' it was before entering this context.
-    This means it is especially useful to ensure a coherent behavior around code that could return/continue/break
-    from many places, without having to bother to explicitly leave sub-step in each and every possible place!
-
-        with ProgressReport() as progress:  # Not giving a WindowManager here will default to console printing.
-            with ProgressReportSubstep(progress, 10, final_msg="Finished!") as subprogress1:
-                for i in range(10):
-                    with ProgressReportSubstep(subprogress1, 100) as subprogress2:
-                        for j in range(100):
-                            subprogress2.step()
-    """
-    __slots__ = ("progress", "nbr", "msg", "final_msg", "level")
-
-    def __init__(self, progress, nbr, msg="", final_msg=""):
-        # Allows to generate a sub-progress context handler from another one.
-        progress = getattr(progress, "progress", progress)
-
-        self.progress = progress
-        self.nbr = nbr
-        self.msg = msg
-        self.final_msg = final_msg
-
-    def __enter__(self):
-        self.level = len(self.progress.steps)
-        self.progress.enter_substeps(self.nbr, self.msg)
-        return self
-
-    def __exit__(self, _exc_type, _exc_value, _traceback):
-        assert len(self.progress.steps) > self.level
-        while len(self.progress.steps) > self.level + 1:
-            self.progress.leave_substeps()
-        self.progress.leave_substeps(self.final_msg)
-
-    def enter_substeps(self, nbr, msg=""):
-        self.progress.enter_substeps(nbr, msg)
-
-    def step(self, msg="", nbr=1):
-        self.progress.step(msg, nbr)
-
-    def leave_substeps(self, msg=""):
-        self.progress.leave_substeps(msg)

package/staging_area/Blender/5.0/scripts/modules/gpu_extras/__init__.py

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

package/staging_area/Blender/5.0/scripts/modules/gpu_extras/batch.py

@@ -1,80 +0,0 @@
-# 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.
-
-    :arg shader: shader for which a compatible format will be computed.
-    :type shader: :class:`gpu.types.GPUShader`
-    :arg type: "'POINTS', 'LINES', 'TRIS' or 'LINES_ADJ'".
-    :type type: str
-    :arg 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]]]
-    :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)

package/staging_area/Blender/5.0/scripts/modules/gpu_extras/presets.py

@@ -1,102 +0,0 @@
-# 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.
-
-    :arg position: 2D position where the circle will be drawn.
-    :type position: Sequence[float]
-    :arg 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]
-    :arg radius: Radius of the circle.
-    :type radius: float
-    :arg 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.
-
-    :arg texture: GPUTexture to draw (e.g. gpu.texture.from_image(image) for :class:`bpy.types.Image`).
-    :type texture: :class:`gpu.types.GPUTexture`
-    :arg position: Position of the lower left corner.
-    :type position: 2D Vector
-    :arg width: Width of the image when drawn (not necessarily
-        the original width of the texture).
-    :type width: float
-    :arg height: Height of the image when drawn.
-    :type height: float
-    :arg is_scene_linear_with_rec709_srgb_target:
-        True if the `texture` is stored in scene linear color space and
-        the destination framebuffer 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 framebuffer. (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)

package/staging_area/Blender/5.0/scripts/modules/nodeitems_utils.py

@@ -1,178 +0,0 @@
-# SPDX-FileCopyrightText: 2013-2023 Blender Authors
-#
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-__all__ = (
-    "NodeCategory",
-    "NodeItem",
-    "NodeItemCustom",
-    "draw_node_categories_menu",
-    "has_node_categories",
-    "node_items_iter",
-    "register_node_categories",
-    "unregister_node_categories",
-)
-
-import bpy
-
-
-class NodeCategory:
-    @classmethod
-    def poll(cls, _context):
-        return True
-
-    def __init__(self, identifier, name, *, description="", items=None):
-        self.identifier = identifier
-        self.name = name
-        self.description = description
-
-        if items is None:
-            self.items = lambda context: []
-        elif callable(items):
-            self.items = items
-        else:
-            def items_gen(context):
-                for item in items:
-                    if item.poll is None or context is None or item.poll(context):
-                        yield item
-            self.items = items_gen
-
-
-class NodeItem:
-    def __init__(self, nodetype, *, label=None, settings=None, poll=None):
-
-        if settings is None:
-            settings = {}
-
-        self.nodetype = nodetype
-        self._label = label
-        self.settings = settings
-        self.poll = poll
-
-    @property
-    def label(self):
-        if self._label:
-            return self._label
-        else:
-            # if no custom label is defined, fall back to the node type UI name
-            bl_rna = bpy.types.Node.bl_rna_get_subclass(self.nodetype)
-            if bl_rna is not None:
-                return bl_rna.name
-            else:
-                return "Unknown"
-
-    @property
-    def translation_context(self):
-        if self._label:
-            return bpy.app.translations.contexts.default
-        else:
-            # if no custom label is defined, fall back to the node type UI name
-            bl_rna = bpy.types.Node.bl_rna_get_subclass(self.nodetype)
-            if bl_rna is not None:
-                return bl_rna.translation_context
-            else:
-                return bpy.app.translations.contexts.default
-
-    # NOTE: is a staticmethod because called with an explicit self argument
-    # NodeItemCustom sets this as a variable attribute in __init__
-    @staticmethod
-    def draw(self, layout, _context):
-        props = layout.operator("node.add_node", text=self.label, text_ctxt=self.translation_context)
-        props.type = self.nodetype
-        props.use_transform = True
-
-        for setting in self.settings.items():
-            ops = props.settings.add()
-            ops.name = setting[0]
-            ops.value = setting[1]
-
-
-class NodeItemCustom:
-    def __init__(self, *, poll=None, draw=None):
-        self.poll = poll
-        self.draw = draw
-
-
-_node_categories = {}
-
-
-def register_node_categories(identifier, cat_list):
-    if identifier in _node_categories:
-        raise KeyError("Node categories list '{:s}' already registered".format(identifier))
-        # return
-
-    # works as draw function for menus
-    def draw_node_item(self, context):
-        layout = self.layout
-        col = layout.column(align=True)
-        for item in self.category.items(context):
-            item.draw(item, col, context)
-
-    menu_types = []
-    for cat in cat_list:
-        menu_type = type("NODE_MT_category_" + cat.identifier, (bpy.types.Menu,), {
-            "bl_space_type": 'NODE_EDITOR',
-            "bl_label": cat.name,
-            "category": cat,
-            "poll": cat.poll,
-            "draw": draw_node_item,
-        })
-
-        menu_types.append(menu_type)
-
-        bpy.utils.register_class(menu_type)
-
-    def draw_add_menu(self, context):
-        layout = self.layout
-
-        for cat in cat_list:
-            if cat.poll(context):
-                layout.menu("NODE_MT_category_" + cat.identifier)
-
-    # Stores: (categories list, menu draw function, sub-menu types).
-    _node_categories[identifier] = (cat_list, draw_add_menu, menu_types)
-
-
-def node_categories_iter(context):
-    for cat_type in _node_categories.values():
-        for cat in cat_type[0]:
-            if cat.poll and ((context is None) or cat.poll(context)):
-                yield cat
-
-
-def has_node_categories(context):
-    for cat_type in _node_categories.values():
-        for cat in cat_type[0]:
-            if cat.poll and ((context is None) or cat.poll(context)):
-                return True
-    return False
-
-
-def node_items_iter(context):
-    for cat in node_categories_iter(context):
-        for item in cat.items(context):
-            yield item
-
-
-def unregister_node_cat_types(cats):
-    for mt in cats[2]:
-        bpy.utils.unregister_class(mt)
-
-
-def unregister_node_categories(identifier=None):
-    # unregister existing UI classes
-    if identifier:
-        cat_types = _node_categories.get(identifier, None)
-        if cat_types:
-            unregister_node_cat_types(cat_types)
-        del _node_categories[identifier]
-
-    else:
-        for cat_types in _node_categories.values():
-            unregister_node_cat_types(cat_types)
-        _node_categories.clear()
-
-
-def draw_node_categories_menu(self, context):
-    for cats in _node_categories.values():
-        cats[1](self, context)