@tushar-br/editing-pack 1.0.188 → 1.0.190

package/staging_area/Blender/5.0/scripts/addons_core/io_scene_gltf2/blender/imp/camera.py

@@ -1,75 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2021 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import bpy
-from math import tan
-from ..com.extras import set_extras
-from ...io.imp.user_extensions import import_user_extensions
-
-
-class BlenderCamera():
-    """Blender Camera."""
-    def __new__(cls, *args, **kwargs):
-        raise RuntimeError("%s should not be instantiated" % cls)
-
-    @staticmethod
-    def create(gltf, vnode, camera_id):
-        """Camera creation."""
-        pycamera = gltf.data.cameras[camera_id]
-
-        import_user_extensions('gather_import_camera_before_hook', gltf, vnode, pycamera)
-
-        if not pycamera.name:
-            pycamera.name = "Camera"
-
-        cam = bpy.data.cameras.new(pycamera.name)
-        set_extras(cam, pycamera.extras)
-
-        # Blender create a perspective camera by default
-        if pycamera.type == "orthographic":
-            cam.type = "ORTHO"
-
-            cam.ortho_scale = max(pycamera.orthographic.xmag, pycamera.orthographic.ymag) * 2
-
-            cam.clip_start = pycamera.orthographic.znear
-            cam.clip_end = pycamera.orthographic.zfar
-
-            # Store multiple channel data, as we will need all channels to convert to
-            # blender data when animated by KHR_animation_pointer
-            if gltf.data.extensions_used is not None and "KHR_animation_pointer" in gltf.data.extensions_used:
-                if len(pycamera.animations) > 0:
-                    for anim_idx in pycamera.animations.keys():
-                        for channel_idx in pycamera.animations[anim_idx]:
-                            channel = gltf.data.animations[anim_idx].channels[channel_idx]
-                            pointer_tab = channel.target.extensions["KHR_animation_pointer"]["pointer"].split("/")
-                            if len(pointer_tab) == 5 and pointer_tab[1] == "cameras" and \
-                                    pointer_tab[3] == "orthographic" and \
-                                    pointer_tab[4] in ["xmag", "ymag"]:
-                                # Store multiple channel data, as we will need all channels to convert to
-                                # blender data when animated
-                                if not hasattr(pycamera, "multiple_channels_mag"):
-                                    pycamera.multiple_channels_mag = {}
-                                pycamera.multiple_channels_mag[pointer_tab[4]] = (anim_idx, channel_idx)
-
-        else:
-            cam.angle_y = pycamera.perspective.yfov
-            cam.lens_unit = "FOV"
-            cam.sensor_fit = "VERTICAL"
-
-            # TODO: fov/aspect ratio
-
-            cam.clip_start = pycamera.perspective.znear
-            if pycamera.perspective.zfar is not None:
-                cam.clip_end = pycamera.perspective.zfar
-            else:
-                # Infinite projection
-                cam.clip_end = 1e12  # some big number
-
-        pycamera.blender_object_data = cam  # Needed in case of KHR_animation_pointer
-
-        return cam
-
-    @staticmethod
-    def calc_lens_from_fov(gltf, input_value, sensor):
-        return (sensor / 2.0) / tan(input_value * 0.5)

package/staging_area/Blender/5.0/scripts/addons_core/io_scene_gltf2/blender/imp/draco_compression_extension.py

@@ -1,138 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2021 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from ctypes import *
-
-from ...io.com.gltf2_io import BufferView
-from ...io.imp.gltf2_io_binary import BinaryData
-from ...io.com.draco import dll_path
-
-
-def decode_primitive(gltf, prim):
-    """
-    Handles draco compression.
-    Moves decoded data into new buffers and buffer views held by the accessors of the given primitive.
-    """
-
-    # Load DLL and setup function signatures.
-    dll = cdll.LoadLibrary(str(dll_path().resolve()))
-
-    dll.decoderCreate.restype = c_void_p
-    dll.decoderCreate.argtypes = []
-
-    dll.decoderRelease.restype = None
-    dll.decoderRelease.argtypes = [c_void_p]
-
-    dll.decoderDecode.restype = c_bool
-    dll.decoderDecode.argtypes = [c_void_p, c_void_p, c_size_t]
-
-    dll.decoderReadAttribute.restype = c_bool
-    dll.decoderReadAttribute.argtypes = [c_void_p, c_uint32, c_size_t, c_char_p]
-
-    dll.decoderGetVertexCount.restype = c_uint32
-    dll.decoderGetVertexCount.argtypes = [c_void_p]
-
-    dll.decoderGetIndexCount.restype = c_uint32
-    dll.decoderGetIndexCount.argtypes = [c_void_p]
-
-    dll.decoderAttributeIsNormalized.restype = c_bool
-    dll.decoderAttributeIsNormalized.argtypes = [c_void_p, c_uint32]
-
-    dll.decoderGetAttributeByteLength.restype = c_size_t
-    dll.decoderGetAttributeByteLength.argtypes = [c_void_p, c_uint32]
-
-    dll.decoderCopyAttribute.restype = None
-    dll.decoderCopyAttribute.argtypes = [c_void_p, c_uint32, c_void_p]
-
-    dll.decoderReadIndices.restype = c_bool
-    dll.decoderReadIndices.argtypes = [c_void_p, c_size_t]
-
-    dll.decoderGetIndicesByteLength.restype = c_size_t
-    dll.decoderGetIndicesByteLength.argtypes = [c_void_p]
-
-    dll.decoderCopyIndices.restype = None
-    dll.decoderCopyIndices.argtypes = [c_void_p, c_void_p]
-
-    decoder = dll.decoderCreate()
-    extension = prim.extensions['KHR_draco_mesh_compression']
-
-    name = prim.name if hasattr(prim, 'name') else '[unnamed]'
-
-    # Create Draco decoder.
-    draco_buffer = bytes(BinaryData.get_buffer_view(gltf, extension['bufferView']))
-    if not dll.decoderDecode(decoder, draco_buffer, len(draco_buffer)):
-        gltf.log.error('Draco Decoder: Unable to decode. Skipping primitive {}.'.format(name))
-        return
-
-    # Choose a buffer index which does not yet exist, skipping over existing glTF buffers yet to be loaded
-    # and buffers which were generated and did not exist in the initial glTF file, like this decoder does.
-    base_buffer_idx = len(gltf.data.buffers)
-    for existing_buffer_idx in gltf.buffers:
-        if base_buffer_idx <= existing_buffer_idx:
-            base_buffer_idx = existing_buffer_idx + 1
-
-    # Read indices.
-    index_accessor = gltf.data.accessors[prim.indices]
-    if dll.decoderGetIndexCount(decoder) != index_accessor.count:
-        gltf.log.warning(
-            'Draco Decoder: Index count of accessor and decoded index count does not match. Updating accessor.')
-        index_accessor.count = dll.decoderGetIndexCount(decoder)
-    if not dll.decoderReadIndices(decoder, index_accessor.component_type):
-        gltf.log.error('Draco Decoder: Unable to decode indices. Skipping primitive {}.'.format(name))
-        return
-
-    indices_byte_length = dll.decoderGetIndicesByteLength(decoder)
-    decoded_data = bytes(indices_byte_length)
-    dll.decoderCopyIndices(decoder, decoded_data)
-
-    # Generate a new buffer holding the decoded indices.
-    gltf.buffers[base_buffer_idx] = decoded_data
-
-    # Create a buffer view referencing the new buffer.
-    gltf.data.buffer_views.append(BufferView.from_dict({
-        'buffer': base_buffer_idx,
-        'byteLength': indices_byte_length
-    }))
-
-    # Update accessor to point to the new buffer view.
-    index_accessor.buffer_view = len(gltf.data.buffer_views) - 1
-
-    # Read each attribute.
-    for attr_idx, attr in enumerate(extension['attributes']):
-        dracoId = extension['attributes'][attr]
-        if attr not in prim.attributes:
-            gltf.log.error(
-                'Draco Decoder: Draco attribute {} not in primitive attributes. Skipping primitive {}.'.format(
-                    attr, name))
-            return
-
-        accessor = gltf.data.accessors[prim.attributes[attr]]
-        if dll.decoderGetVertexCount(decoder) != accessor.count:
-            gltf.log.warning(
-                'Draco Decoder: Vertex count of accessor and decoded vertex count does not match for attribute {}. Updating accessor.'.format(
-                    attr,
-                    name))
-            accessor.count = dll.decoderGetVertexCount(decoder)
-        if not dll.decoderReadAttribute(decoder, dracoId, accessor.component_type, accessor.type.encode()):
-            gltf.log.error('Draco Decoder: Could not decode attribute {}. Skipping primitive {}.'.format(attr, name))
-            return
-
-        byte_length = dll.decoderGetAttributeByteLength(decoder, dracoId)
-        decoded_data = bytes(byte_length)
-        dll.decoderCopyAttribute(decoder, dracoId, decoded_data)
-
-        # Generate a new buffer holding the decoded vertex data.
-        buffer_idx = base_buffer_idx + 1 + attr_idx
-        gltf.buffers[buffer_idx] = decoded_data
-
-        # Create a buffer view referencing the new buffer.
-        gltf.data.buffer_views.append(BufferView.from_dict({
-            'buffer': buffer_idx,
-            'byteLength': byte_length
-        }))
-
-        # Update accessor to point to the new buffer view.
-        accessor.buffer_view = len(gltf.data.buffer_views) - 1
-
-    dll.decoderRelease(decoder)

package/staging_area/Blender/5.0/scripts/addons_core/io_scene_gltf2/blender/imp/image.py

@@ -1,102 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2021 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import bpy
-import os
-from os.path import dirname, join, basename
-
-from ...io.com.path import uri_to_path
-from ...io.imp.gltf2_io_binary import BinaryData
-from ...io.imp.user_extensions import import_user_extensions
-
-
-# Note that Image is not a glTF2.0 object
-class BlenderImage():
-    """Manage Image."""
-    def __new__(cls, *args, **kwargs):
-        raise RuntimeError("%s should not be instantiated" % cls)
-
-    @staticmethod
-    def create(gltf, img_idx):
-        """Image creation."""
-        img = gltf.data.images[img_idx]
-
-        if img.blender_image_name is not None:
-            # Image is already used somewhere
-            return
-
-        import_user_extensions('gather_import_image_before_hook', gltf, img)
-
-        if img.uri is not None and not img.uri.startswith('data:'):
-            blender_image = create_from_file(gltf, img_idx)
-        else:
-            blender_image = create_from_data(gltf, img_idx)
-
-        if blender_image:
-            blender_image.alpha_mode = 'CHANNEL_PACKED'
-            img.blender_image_name = blender_image.name
-
-        import_user_extensions('gather_import_image_after_hook', gltf, img, blender_image)
-
-
-def create_from_file(gltf, img_idx):
-    # Image stored in a file
-
-    num_images = len(bpy.data.images)
-
-    img = gltf.data.images[img_idx]
-
-    path = join(dirname(gltf.filename), uri_to_path(img.uri))
-    path = os.path.abspath(path)
-    if bpy.data.is_saved and bpy.context.preferences.filepaths.use_relative_paths:
-        try:
-            path = bpy.path.relpath(path)
-        except:
-            # May happen on Windows if on different drives, eg. C:\ and D:\
-            pass
-
-    img_name = img.name or basename(path)
-
-    try:
-        blender_image = bpy.data.images.load(
-            path,
-            check_existing=True,
-        )
-
-        needs_pack = gltf.import_settings['import_pack_images']
-        if needs_pack:
-            blender_image.pack()
-
-    except RuntimeError:
-        gltf.log.error("Missing image file (index %d): %s" % (img_idx, path))
-        blender_image = _placeholder_image(img_name, os.path.abspath(path))
-
-    if len(bpy.data.images) != num_images:  # If created a new image
-        blender_image.name = img_name
-
-    return blender_image
-
-
-def create_from_data(gltf, img_idx):
-    # Image stored as data => pack
-    img_data = BinaryData.get_image_data(gltf, img_idx)
-    if img_data is None:
-        return
-    img_name = gltf.data.images[img_idx].name or 'Image_%d' % img_idx
-
-    # Create image, width and height are dummy values
-    blender_image = bpy.data.images.new(img_name, 8, 8)
-    # Set packed file data
-    blender_image.pack(data=img_data.tobytes(), data_len=len(img_data))
-    blender_image.source = 'FILE'
-
-    return blender_image
-
-
-def _placeholder_image(name, path):
-    image = bpy.data.images.new(name, 128, 128)
-    # allow the path to be resolved later
-    image.filepath = path
-    image.source = 'FILE'
-    return image

package/staging_area/Blender/5.0/scripts/addons_core/io_scene_gltf2/blender/imp/light.py

@@ -1,143 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2021 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import bpy
-from math import pi
-
-from ...io.imp.user_extensions import import_user_extensions
-from ..com.conversion import PBR_WATTS_TO_LUMENS
-from ..com.extras import set_extras
-
-
-class BlenderLight():
-    """Blender Light."""
-    def __new__(cls, *args, **kwargs):
-        raise RuntimeError("%s should not be instantiated" % cls)
-
-    @staticmethod
-    def create(gltf, vnode, light_id):
-        """Light creation."""
-        pylight = gltf.data.extensions['KHR_lights_punctual']['lights'][light_id]
-
-        import_user_extensions('gather_import_light_before_hook', gltf, vnode, pylight)
-
-        if pylight['type'] == "directional":
-            light = BlenderLight.create_directional(gltf, light_id)  # ...Why not pass the pylight?
-        elif pylight['type'] == "point":
-            light = BlenderLight.create_point(gltf, light_id)
-        elif pylight['type'] == "spot":
-            light = BlenderLight.create_spot(gltf, light_id)
-
-        if 'color' in pylight.keys():
-            light.color = pylight['color']
-
-        # TODO range
-
-        set_extras(light, pylight.get('extras'))
-
-        pylight['blender_object_data'] = light  # Needed in case of KHR_animation_pointer
-
-        return light
-
-    @staticmethod
-    def create_directional(gltf, light_id):
-        pylight = gltf.data.extensions['KHR_lights_punctual']['lights'][light_id]
-
-        if 'name' not in pylight.keys():
-            pylight['name'] = "Sun"  # Uh... Is it okay to mutate the import data?
-
-        sun = bpy.data.lights.new(name=pylight['name'], type="SUN")
-
-        if 'intensity' in pylight.keys():
-            sun.energy = BlenderLight.calc_energy_directional(gltf, pylight['intensity'])
-
-        return sun
-
-    @staticmethod
-    def calc_energy_directional(gltf, pylight_data):
-        if gltf.import_settings['export_import_convert_lighting_mode'] == 'SPEC':
-            return pylight_data / PBR_WATTS_TO_LUMENS
-        elif gltf.import_settings['export_import_convert_lighting_mode'] == 'COMPAT':
-            return pylight_data
-        elif gltf.import_settings['export_import_convert_lighting_mode'] == 'RAW':
-            return pylight_data
-        else:
-            raise ValueError(gltf.import_settings['export_import_convert_lighting_mode'])
-
-    @staticmethod
-    def calc_energy_pointlike(gltf, pylight_data):
-        if gltf.import_settings['export_import_convert_lighting_mode'] == 'SPEC':
-            return pylight_data / PBR_WATTS_TO_LUMENS * 4 * pi
-        elif gltf.import_settings['export_import_convert_lighting_mode'] == 'COMPAT':
-            return pylight_data * 4 * pi
-        elif gltf.import_settings['export_import_convert_lighting_mode'] == 'RAW':
-            return pylight_data
-        else:
-            raise ValueError(gltf.import_settings['export_import_convert_lighting_mode'])
-
-    @staticmethod
-    def create_point(gltf, light_id):
-        pylight = gltf.data.extensions['KHR_lights_punctual']['lights'][light_id]
-
-        if 'name' not in pylight.keys():
-            pylight['name'] = "Point"
-
-        point = bpy.data.lights.new(name=pylight['name'], type="POINT")
-
-        if 'intensity' in pylight.keys():
-            point.energy = BlenderLight.calc_energy_pointlike(gltf, pylight['intensity'])
-
-        return point
-
-    @staticmethod
-    def create_spot(gltf, light_id):
-        pylight = gltf.data.extensions['KHR_lights_punctual']['lights'][light_id]
-
-        if 'name' not in pylight.keys():
-            pylight['name'] = "Spot"
-
-        spot = bpy.data.lights.new(name=pylight['name'], type="SPOT")
-
-        # Angles
-        if 'spot' in pylight.keys():
-            gltf_default_outer_cone_angle = pi / 4
-            gltf_default_inner_cone_angle = 0.0
-
-            spot.spot_size = BlenderLight.calc_spot_cone_outer(
-                gltf, pylight['spot'].get('outerConeAngle', gltf_default_outer_cone_angle))
-            spot.spot_blend = BlenderLight.calc_spot_cone_inner(
-                gltf, pylight['spot'].get(
-                    'outerConeAngle', gltf_default_outer_cone_angle), pylight['spot'].get(
-                    'innerConeAngle', gltf_default_inner_cone_angle))
-
-        if 'intensity' in pylight.keys():
-            spot.energy = BlenderLight.calc_energy_pointlike(gltf, pylight['intensity'])
-
-        # Store multiple channel data, as we will need all channels to convert to
-        # blender data when animated by KHR_animation_pointer
-        if gltf.data.extensions_used is not None and "KHR_animation_pointer" in gltf.data.extensions_used:
-            if len(pylight['animations']) > 0:
-                for anim_idx in pylight['animations'].keys():
-                    for channel_idx in pylight['animations'][anim_idx]:
-                        channel = gltf.data.animations[anim_idx].channels[channel_idx]
-                        pointer_tab = channel.target.extensions["KHR_animation_pointer"]["pointer"].split("/")
-                        if len(pointer_tab) == 6 and pointer_tab[1] == "extensions" and \
-                                pointer_tab[2] == "KHR_lights_punctual" and \
-                                pointer_tab[3] == "lights" and \
-                                pointer_tab[5] in ["spot.innerConeAngle", "spot.outerConeAngle"]:
-                            # Store multiple channel data, as we will need all channels to convert to
-                            # blender data when animated
-                            if "multiple_channels" not in pylight.keys():
-                                pylight['multiple_channels'] = {}
-                            pylight['multiple_channels'][pointer_tab[5]] = (anim_idx, channel_idx)
-
-        return spot
-
-    @staticmethod
-    def calc_spot_cone_outer(gltf, outercone):
-        return outercone * 2
-
-    @staticmethod
-    def calc_spot_cone_inner(gltf, outercone, innercone):
-        return 1 - (innercone / outercone)

package/staging_area/Blender/5.0/scripts/addons_core/io_scene_gltf2/blender/imp/material.py

@@ -1,113 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2021 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import bpy
-
-from ...io.imp.user_extensions import import_user_extensions
-from ..com.extras import set_extras
-from .pbrMetallicRoughness import MaterialHelper, pbr_metallic_roughness
-from .KHR_materials_pbrSpecularGlossiness import pbr_specular_glossiness
-from .KHR_materials_unlit import unlit
-
-
-class BlenderMaterial():
-    """Blender Material."""
-    def __new__(cls, *args, **kwargs):
-        raise RuntimeError("%s should not be instantiated" % cls)
-
-    @staticmethod
-    def create(gltf, material_idx, vertex_color):
-        """Material creation."""
-
-        if material_idx is None:
-            # If no material is specified, we create a default one
-            mat = bpy.data.materials.new(name="DefaultMaterial")
-            mat.node_tree.nodes.clear()
-            output_node = mat.node_tree.nodes.new(type='ShaderNodeOutputMaterial')
-            output_node.location = (0, 0)
-            shader_node = mat.node_tree.nodes.new(type='ShaderNodeBsdfPrincipled')
-            shader_node.location = (-200, 0)
-            mat.node_tree.links.new(shader_node.outputs[0], output_node.inputs[0])
-            if vertex_color:
-                # Add vertex color node
-                vertex_color_node = mat.node_tree.nodes.new(type='ShaderNodeVertexColor')
-                vertex_color_node.location = (-400, 0)
-                mat.node_tree.links.new(vertex_color_node.outputs[0], shader_node.inputs[0])
-            return mat.name
-
-
-        pymaterial = gltf.data.materials[material_idx]
-
-        import_user_extensions('gather_import_material_before_hook', gltf, pymaterial, vertex_color)
-
-        name = pymaterial.name
-        if name is None:
-            name = "Material_" + str(material_idx)
-
-        mat = bpy.data.materials.new(name)
-        pymaterial.blender_material[vertex_color] = mat.name
-
-        set_extras(mat, pymaterial.extras)
-        BlenderMaterial.set_double_sided(pymaterial, mat)
-        BlenderMaterial.set_eevee_surface_render_method(pymaterial, mat)
-        BlenderMaterial.set_viewport_color(pymaterial, mat, vertex_color)
-
-        mat.node_tree.nodes.clear()
-
-        mh = MaterialHelper(gltf, pymaterial, mat, vertex_color)
-
-        exts = pymaterial.extensions or {}
-        if 'KHR_materials_unlit' in exts:
-            unlit(mh)
-            pymaterial.pbr_metallic_roughness.blender_nodetree = mat.node_tree  # Used in case of for KHR_animation_pointer
-            # Used in case of for KHR_animation_pointer #TODOPointer Vertex Color...
-            pymaterial.pbr_metallic_roughness.blender_mat = mat
-        elif 'KHR_materials_pbrSpecularGlossiness' in exts:
-            pbr_specular_glossiness(mh)
-        else:
-            pbr_metallic_roughness(mh)
-            pymaterial.pbr_metallic_roughness.blender_nodetree = mat.node_tree  # Used in case of for KHR_animation_pointer
-            # Used in case of for KHR_animation_pointer #TODOPointer Vertex Color...
-            pymaterial.pbr_metallic_roughness.blender_mat = mat
-
-        # Manage KHR_materials_variants
-        # We need to store link between material idx in glTF and Blender Material id
-        if gltf.KHR_materials_variants is True:
-            gltf.variant_mapping[str(material_idx) + str(vertex_color)] = mat
-
-        pymaterial.blender_nodetree = mat.node_tree  # Used in case of for KHR_animation_pointer
-        pymaterial.blender_mat = mat  # Used in case of for KHR_animation_pointer #TODOPointer Vertex Color...
-
-        import_user_extensions('gather_import_material_after_hook', gltf, pymaterial, vertex_color, mat)
-
-    @staticmethod
-    def set_double_sided(pymaterial, mat):
-        mat.use_backface_culling = (pymaterial.double_sided != True)
-
-    @staticmethod
-    def set_eevee_surface_render_method(pymaterial, mat):
-        alpha_mode = pymaterial.alpha_mode or 'OPAQUE'
-        if alpha_mode in ['OPAQUE', 'MASK']:
-            mat.surface_render_method = 'DITHERED'
-        else:
-            mat.surface_render_method = 'BLENDED'
-
-    @staticmethod
-    def set_viewport_color(pymaterial, mat, vertex_color):
-        # If there is no texture and no vertex color, use the base color as
-        # the color for the Solid view.
-        if vertex_color:
-            return
-
-        exts = pymaterial.extensions or {}
-        if 'KHR_materials_pbrSpecularGlossiness' in exts:
-            # TODO
-            return
-        else:
-            pbr = pymaterial.pbr_metallic_roughness
-            if pbr is None or pbr.base_color_texture is not None:
-                return
-            color = pbr.base_color_factor or [1, 1, 1, 1]
-
-        mat.diffuse_color = color