@tushar-br/editing-pack 1.0.188 → 1.0.190

package/staging_area/Blender/5.0/scripts/addons_core/io_scene_gltf2/io/com/gltf2_io_extensions.py

@@ -1,30 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2021 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from typing import List, Dict, Any
-
-
-class Extension:
-    """Container for extensions. Allows to specify requiredness"""
-    extension = True  # class method used to check Extension class at traversal (after reloading script, isinstance is not working)
-
-    def __init__(self, name: str, extension: Dict[str, Any], required: bool = True):
-        self.name = name
-        self.extension = extension
-        self.required = required
-
-
-class ChildOfRootExtension(Extension):
-    """Container object for extensions that should be appended to the root extensions"""
-
-    def __init__(self, path: List[str], name: str, extension: Dict[str, Any], required: bool = True):
-        """
-        Wrap a local extension entity into an object that will later be inserted into a root extension and converted
-        to a reference.
-        :param path: The path of the extension object in the root extension. E.g. ['lights'] for
-        KHR_lights_punctual. Must be a path to a list in the extensions dict.
-        :param extension: The data that should be placed into the extension list
-        """
-        self.path = path
-        super().__init__(name, extension, required)

package/staging_area/Blender/5.0/scripts/addons_core/io_scene_gltf2/io/com/lights_punctual.py

@@ -1,68 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2021 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from ...io.com.gltf2_io import from_dict, from_union, from_none, from_float, from_str, from_list
-from ...io.com.gltf2_io import to_float, to_class
-
-
-class LightSpot:
-    """light/spot"""
-
-    def __init__(self, inner_cone_angle, outer_cone_angle):
-        self.inner_cone_angle = inner_cone_angle
-        self.outer_cone_angle = outer_cone_angle
-
-    @staticmethod
-    def from_dict(obj):
-        assert isinstance(obj, dict)
-        inner_cone_angle = from_union([from_float, from_none], obj.get("innerConeAngle"))
-        outer_cone_angle = from_union([from_float, from_none], obj.get("outerConeAngle"))
-        return LightSpot(inner_cone_angle, outer_cone_angle)
-
-    def to_dict(self):
-        result = {}
-        result["innerConeAngle"] = from_union([from_float, from_none], self.inner_cone_angle)
-        result["outerConeAngle"] = from_union([from_float, from_none], self.outer_cone_angle)
-        return result
-
-
-class Light:
-    """defines a set of lights for use with glTF 2.0. Lights define light sources within a scene"""
-
-    def __init__(self, color, intensity, spot, type, range, name, extensions, extras):
-        self.color = color
-        self.intensity = intensity
-        self.spot = spot
-        self.type = type
-        self.range = range
-        self.name = name
-        self.extensions = extensions
-        self.extras = extras
-
-    @staticmethod
-    def from_dict(obj):
-        assert isinstance(obj, dict)
-        color = from_union([lambda x: from_list(from_float, x), from_none], obj.get("color"))
-        intensity = from_union([from_float, from_none], obj.get("intensity"))
-        spot = LightSpot.from_dict(obj.get("spot"))
-        type = from_str(obj.get("type"))
-        range = from_union([from_float, from_none], obj.get("range"))
-        name = from_union([from_str, from_none], obj.get("name"))
-        extensions = from_union([lambda x: from_dict(lambda x: from_dict(lambda x: x, x), x), from_none],
-                                obj.get("extensions"))
-        extras = obj.get("extras")
-        return Light(color, intensity, spot, type, range, name, extensions, extras)
-
-    def to_dict(self):
-        result = {}
-        result["color"] = from_union([lambda x: from_list(to_float, x), from_none], self.color)
-        result["intensity"] = from_union([from_float, from_none], self.intensity)
-        result["spot"] = from_union([lambda x: to_class(LightSpot, x), from_none], self.spot)
-        result["type"] = from_str(self.type)
-        result["range"] = from_union([from_float, from_none], self.range)
-        result["name"] = from_union([from_str, from_none], self.name)
-        result["extensions"] = from_union([lambda x: from_dict(lambda x: from_dict(lambda x: x, x), x), from_none],
-                                          self.extensions)
-        result["extras"] = self.extras
-        return result

package/staging_area/Blender/5.0/scripts/addons_core/io_scene_gltf2/io/com/path.py

@@ -1,19 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2023 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from urllib.parse import unquote, quote
-from os.path import normpath
-from os import sep
-
-
-def uri_to_path(uri):
-    uri = uri.replace('\\', '/')  # Some files come with \\ as dir separator
-    uri = unquote(uri)
-    return normpath(uri)
-
-
-def path_to_uri(path):
-    path = normpath(path)
-    path = path.replace(sep, '/')
-    return quote(path)

package/staging_area/Blender/5.0/scripts/addons_core/io_scene_gltf2/io/com/variants.py

@@ -1,32 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2022 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from ...io.com.gltf2_io import from_dict, from_union, from_none, from_float, from_str, from_list
-from ...io.com.gltf2_io import to_float, to_class
-
-
-class Variant:
-    """defines variant for use with glTF 2.0."""
-
-    def __init__(self, name, extensions, extras):
-        self.name = name
-        self.extensions = extensions
-        self.extras = extras
-
-    @staticmethod
-    def from_dict(obj):
-        assert isinstance(obj, dict)
-        name = from_union([from_str, from_none], obj.get("name"))
-        extensions = from_union([lambda x: from_dict(lambda x: from_dict(lambda x: x, x), x), from_none],
-                                obj.get("extensions"))
-        extras = obj.get("extras")
-        return Variant(name, extensions, extras)
-
-    def to_dict(self):
-        result = {}
-        result["name"] = from_union([from_str, from_none], self.name)
-        result["extensions"] = from_union([lambda x: from_dict(lambda x: from_dict(lambda x: x, x), x), from_none],
-                                          self.extensions)
-        result["extras"] = self.extras
-        return result

package/staging_area/Blender/5.0/scripts/addons_core/io_scene_gltf2/io/exp/binary_data.py

@@ -1,35 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2021 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import typing
-import array
-from ...io.com import constants as gltf2_io_constants
-
-
-class BinaryData:
-    """Store for gltf binary data that can later be stored in a buffer."""
-
-    def __init__(self, data: bytes, bufferViewTarget=None):
-        if not isinstance(data, bytes):
-            raise TypeError("Data is not a bytes array")
-        self.data = data
-        self.bufferViewTarget = bufferViewTarget
-
-    def __eq__(self, other):
-        return self.data == other.data
-
-    def __hash__(self):
-        return hash(self.data)
-
-    @classmethod
-    def from_list(cls,
-                  lst: typing.List[typing.Any],
-                  gltf_component_type: gltf2_io_constants.ComponentType,
-                  bufferViewTarget=None):
-        format_char = gltf2_io_constants.ComponentType.to_type_code(gltf_component_type)
-        return BinaryData(array.array(format_char, lst).tobytes(), bufferViewTarget)
-
-    @property
-    def byte_length(self):
-        return len(self.data)

package/staging_area/Blender/5.0/scripts/addons_core/io_scene_gltf2/io/exp/buffer.py

@@ -1,54 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2021 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import base64
-
-from ...io.com import gltf2_io
-from ...io.exp import binary_data as gltf2_io_binary_data
-
-
-class Buffer:
-    """Class representing binary data for use in a glTF file as 'buffer' property."""
-
-    def __init__(self, buffer_index=0, initial_data=None):
-        self.__data = bytearray(b"")
-        if initial_data is not None:
-            self.__data = bytearray(initial_data.tobytes())
-        self.__buffer_index = buffer_index
-
-    def add_and_get_view(self, binary_data: gltf2_io_binary_data.BinaryData) -> gltf2_io.BufferView:
-        """Add binary data to the buffer. Return a glTF BufferView."""
-        offset = len(self.__data)
-        self.__data.extend(binary_data.data)
-
-        length = binary_data.byte_length
-
-        # offsets should be a multiple of 4 --> therefore add padding if necessary
-        padding = (4 - (length % 4)) % 4
-        self.__data.extend(b"\x00" * padding)
-
-        buffer_view = gltf2_io.BufferView(
-            buffer=self.__buffer_index,
-            byte_length=length,
-            byte_offset=offset,
-            byte_stride=None,
-            extensions=None,
-            extras=None,
-            name=None,
-            target=binary_data.bufferViewTarget
-        )
-        return buffer_view
-
-    @property
-    def byte_length(self):
-        return len(self.__data)
-
-    def to_bytes(self):
-        return self.__data
-
-    def clear(self):
-        self.__data = b""
-
-    def to_embed_string(self):
-        return 'data:application/octet-stream;base64,' + base64.b64encode(self.__data).decode('ascii')

package/staging_area/Blender/5.0/scripts/addons_core/io_scene_gltf2/io/exp/draco.py

@@ -1,174 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2021 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from ctypes import *
-from pathlib import Path
-
-from ...io.exp.binary_data import BinaryData
-from ...io.com.draco import dll_path
-
-
-def encode_scene_primitives(scenes, export_settings):
-    """
-    Handles draco compression.
-    Moves position, normal and texture coordinate attributes into a Draco encoded buffer.
-    """
-
-    # Load DLL and setup function signatures.
-    dll = cdll.LoadLibrary(str(dll_path().resolve()))
-
-    dll.encoderCreate.restype = c_void_p
-    dll.encoderCreate.argtypes = [c_uint32]
-
-    dll.encoderRelease.restype = None
-    dll.encoderRelease.argtypes = [c_void_p]
-
-    dll.encoderSetCompressionLevel.restype = None
-    dll.encoderSetCompressionLevel.argtypes = [c_void_p, c_uint32]
-
-    dll.encoderSetQuantizationBits.restype = None
-    dll.encoderSetQuantizationBits.argtypes = [c_void_p, c_uint32, c_uint32, c_uint32, c_uint32, c_uint32]
-
-    dll.encoderSetIndices.restype = None
-    dll.encoderSetIndices.argtypes = [c_void_p, c_size_t, c_uint32, c_void_p]
-
-    dll.encoderSetAttribute.restype = c_uint32
-    dll.encoderSetAttribute.argtypes = [c_void_p, c_char_p, c_size_t, c_char_p, c_void_p, c_bool]
-
-    dll.encoderEncode.restype = c_bool
-    dll.encoderEncode.argtypes = [c_void_p, c_uint8]
-
-    dll.encoderGetEncodedVertexCount.restype = c_uint32
-    dll.encoderGetEncodedVertexCount.argtypes = [c_void_p]
-
-    dll.encoderGetEncodedIndexCount.restype = c_uint32
-    dll.encoderGetEncodedIndexCount.argtypes = [c_void_p]
-
-    dll.encoderGetByteLength.restype = c_uint64
-    dll.encoderGetByteLength.argtypes = [c_void_p]
-
-    dll.encoderCopy.restype = None
-    dll.encoderCopy.argtypes = [c_void_p, c_void_p]
-
-    # Don't encode the same primitive multiple times.
-    encoded_primitives_cache = {}
-
-    # Compress meshes into Draco buffers.
-    for scene in scenes:
-        for node in scene.nodes:
-            __traverse_node(node, lambda node: __encode_node(node, dll, export_settings, encoded_primitives_cache))
-
-    # Release uncompressed index and attribute buffers.
-    # Since those buffers may be shared across nodes, this step must happen after all meshes have been compressed.
-    for scene in scenes:
-        for node in scene.nodes:
-            __traverse_node(node, lambda node: __cleanup_node(node))
-
-
-def __cleanup_node(node):
-    if node.mesh is None:
-        return
-
-    for primitive in node.mesh.primitives:
-        if primitive.extensions is None or primitive.extensions['KHR_draco_mesh_compression'] is None:
-            continue
-
-        primitive.indices.buffer_view = None
-        for attr_name in primitive.attributes:
-            attr = primitive.attributes[attr_name]
-            attr.buffer_view = None
-
-
-def __traverse_node(node, f):
-    f(node)
-    if node.children is not None:
-        for child in node.children:
-            __traverse_node(child, f)
-
-
-def __encode_node(node, dll, export_settings, encoded_primitives_cache):
-    if node.mesh is not None:
-        export_settings['log'].info('Draco encoder: Encoding mesh {}.'.format(node.name))
-        for primitive in node.mesh.primitives:
-            __encode_primitive(primitive, dll, export_settings, encoded_primitives_cache)
-
-
-def __encode_primitive(primitive, dll, export_settings, encoded_primitives_cache):
-    attributes = primitive.attributes
-    indices = primitive.indices
-
-    # Check if this primitive has already been encoded.
-    # This usually happens when nodes are duplicated in Blender, thus their indices/attributes are shared data.
-    if primitive in encoded_primitives_cache:
-        if primitive.extensions is None:
-            primitive.extensions = {}
-        primitive.extensions['KHR_draco_mesh_compression'] = encoded_primitives_cache[primitive]
-        return
-
-    # Only do TRIANGLES primitives
-    if primitive.mode not in [None, 4]:
-        return
-
-    if 'POSITION' not in attributes:
-        export_settings['log'].warning('Draco encoder: Primitive without positions encountered. Skipping.')
-        return
-
-    positions = attributes['POSITION']
-
-    # Skip nodes without a position buffer, e.g. a primitive from a Blender shared instance.
-    if attributes['POSITION'].buffer_view is None:
-        return
-
-    encoder = dll.encoderCreate(positions.count)
-
-    draco_ids = {}
-    for attr_name in attributes:
-        attr = attributes[attr_name]
-        draco_id = dll.encoderSetAttribute(
-            encoder,
-            attr_name.encode(),
-            attr.component_type,
-            attr.type.encode(),
-            attr.buffer_view.data,
-            attr.normalized)
-        draco_ids[attr_name] = draco_id
-
-    dll.encoderSetIndices(encoder, indices.component_type, indices.count, indices.buffer_view.data)
-
-    dll.encoderSetCompressionLevel(encoder, export_settings['gltf_draco_mesh_compression_level'])
-    dll.encoderSetQuantizationBits(encoder,
-                                   export_settings['gltf_draco_position_quantization'],
-                                   export_settings['gltf_draco_normal_quantization'],
-                                   export_settings['gltf_draco_texcoord_quantization'],
-                                   export_settings['gltf_draco_color_quantization'],
-                                   export_settings['gltf_draco_generic_quantization'])
-
-    preserve_triangle_order = primitive.targets is not None and len(primitive.targets) > 0
-    if not dll.encoderEncode(encoder, preserve_triangle_order):
-        export_settings['log'].error('Could not encode primitive. Skipping primitive.')
-
-    byte_length = dll.encoderGetByteLength(encoder)
-    encoded_data = bytes(byte_length)
-    dll.encoderCopy(encoder, encoded_data)
-
-    if primitive.extensions is None:
-        primitive.extensions = {}
-
-    extension_info = {
-        'bufferView': BinaryData(encoded_data),
-        'attributes': draco_ids
-    }
-    primitive.extensions['KHR_draco_mesh_compression'] = extension_info
-    encoded_primitives_cache[primitive] = extension_info
-
-    # Set to triangle list mode.
-    primitive.mode = 4
-
-    # Update accessors to match encoded data.
-    indices.count = dll.encoderGetEncodedIndexCount(encoder)
-    encoded_vertices = dll.encoderGetEncodedVertexCount(encoder)
-    for attr_name in attributes:
-        attributes[attr_name].count = encoded_vertices
-
-    dll.encoderRelease(encoder)

package/staging_area/Blender/5.0/scripts/addons_core/io_scene_gltf2/io/exp/export.py

@@ -1,122 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2021 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-#
-# Imports
-#
-
-import json
-import struct
-from ...io.exp.user_extensions import export_user_extensions
-
-#
-# Globals
-#
-
-#
-# Functions
-#
-from collections import OrderedDict
-
-
-def save_gltf(gltf, export_settings, encoder, glb_buffer):
-    # Use a class here, to be able to pass data by reference to hook (to be able to change them inside hook)
-    class GlTF_format:
-        def __init__(self, indent, separators):
-            self.indent = indent
-            self.separators = separators
-
-    gltf_format = GlTF_format(None, (',', ':'))
-
-    if export_settings['gltf_format'] != 'GLB':
-        gltf_format.indent = "\t"
-        # The comma is typically followed by a newline, so no trailing whitespace is needed on it.
-        # No space before and after ':' to save space
-        gltf_format.separators = (',', ':')
-
-    sort_order = [
-        "asset",
-        "extensionsUsed",
-        "extensionsRequired",
-        "extensions",
-        "extras",
-        "scene",
-        "scenes",
-        "nodes",
-        "cameras",
-        "animations",
-        "materials",
-        "meshes",
-        "textures",
-        "images",
-        "skins",
-        "accessors",
-        "bufferViews",
-        "samplers",
-        "buffers"
-    ]
-
-    export_user_extensions('gather_gltf_encoded_hook', export_settings, gltf_format, sort_order)
-
-    gltf_ordered = OrderedDict(sorted(gltf.items(), key=lambda item: sort_order.index(item[0])))
-    gltf_encoded = json.dumps(
-        gltf_ordered,
-        indent=gltf_format.indent,
-        separators=gltf_format.separators,
-        cls=encoder,
-        allow_nan=False)
-
-    #
-
-    if export_settings['gltf_format'] != 'GLB':
-        file = open(export_settings['gltf_filepath'], "w", encoding="utf8", newline="\n")
-        file.write(gltf_encoded)
-        file.write("\n")
-        file.close()
-
-        binary = export_settings['gltf_binary']
-        if len(binary) > 0 and not export_settings['gltf_embed_buffers']:
-            file = open(export_settings['gltf_filedirectory'] + export_settings['gltf_binaryfilename'], "wb")
-            file.write(binary)
-            file.close()
-
-    else:
-        file = open(export_settings['gltf_filepath'], "wb")
-
-        gltf_data = gltf_encoded.encode()
-        binary = glb_buffer
-
-        length_gltf = len(gltf_data)
-        spaces_gltf = (4 - (length_gltf & 3)) & 3
-        length_gltf += spaces_gltf
-
-        length_bin = len(binary)
-        zeros_bin = (4 - (length_bin & 3)) & 3
-        length_bin += zeros_bin
-
-        length = 12 + 8 + length_gltf
-        if length_bin > 0:
-            length += 8 + length_bin
-
-        # Header (Version 2)
-        file.write('glTF'.encode())
-        file.write(struct.pack("I", 2))
-        file.write(struct.pack("I", length))
-
-        # Chunk 0 (JSON)
-        file.write(struct.pack("I", length_gltf))
-        file.write('JSON'.encode())
-        file.write(gltf_data)
-        file.write(b' ' * spaces_gltf)
-
-        # Chunk 1 (BIN)
-        if length_bin > 0:
-            file.write(struct.pack("I", length_bin))
-            file.write('BIN\0'.encode())
-            file.write(binary)
-            file.write(b'\0' * zeros_bin)
-
-        file.close()
-
-    return True

package/staging_area/Blender/5.0/scripts/addons_core/io_scene_gltf2/io/exp/image_data.py

@@ -1,80 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2021 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import re
-
-
-class ImageData:
-    """Contains encoded images"""
-    # FUTURE_WORK: as a method to allow the node graph to be better supported, we could model some of
-    # the node graph elements with numpy functions
-
-    def __init__(self, data: bytes, mime_type: str, name: str):
-        self._data = data
-        self._mime_type = mime_type
-        self._name = name
-        self._adjusted_name = None
-        self._uri = None
-
-    def __eq__(self, other):
-        return self._data == other.data
-
-    def __hash__(self):
-        return hash(self._data)
-
-    def adjusted_name(self):
-        regex_dot = re.compile(r"\.")
-        adjusted_name = re.sub(regex_dot, "_", self.name)
-        new_name = "".join([char for char in adjusted_name if char not in r"!#$&'()*+,/:;<>?@[\]^`{|}~"])
-        return new_name
-
-    @property
-    def data(self):
-        return self._data
-
-    @property
-    def name(self):
-        return self._name
-
-    @property
-    def file_extension(self):
-        if self._mime_type == "image/jpeg":
-            return ".jpg"
-        elif self._mime_type == "image/webp":
-            return ".webp"
-        return ".png"
-
-    @property
-    def byte_length(self):
-        return len(self._data)
-
-    @property
-    def uri(self):
-        return self._uri
-
-    @uri.setter
-    def uri(self, uri):
-        self._uri = uri
-
-
-    def set_adjusted_name(self, names):
-        # Set adjusted name
-        name = self.name
-        count = 1
-        regex = re.compile(r"-\d+$")
-        while name + self.file_extension in names:
-            regex_found = re.findall(regex, name)
-            if regex_found:
-                name = re.sub(regex, "-" + str(count), name)
-            else:
-                name += "-" + str(count)
-
-            count += 1
-        # TODO: allow embedding of images (base64)
-        self._adjusted_name = name + self.file_extension
-        return self._adjusted_name
-
-    @property
-    def adjusted_name(self):
-        return self._adjusted_name

package/staging_area/Blender/5.0/scripts/addons_core/io_scene_gltf2/io/exp/user_extensions.py

@@ -1,17 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2021 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-def export_user_extensions(hook_name, export_settings, *args):
-    if args and hasattr(args[0], "extensions"):
-        if args[0].extensions is None:
-            args[0].extensions = {}
-
-    for extension in export_settings['gltf_user_extensions']:
-        hook = getattr(extension, hook_name, None)
-        if hook is not None:
-            try:
-                hook(*args, export_settings)
-            except Exception as e:
-                export_settings['log'].error("Extension hook " + hook_name + " fails on " + extension.__module__)
-                export_settings['log'].error(str(e))

package/staging_area/Blender/5.0/scripts/addons_core/io_scene_gltf2/io/imp/__init__.py

@@ -1,5 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2021 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-"""IO imp package."""