@tushar-br/editing-pack 1.0.188 → 1.0.190

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

@@ -1,116 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2023 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from ...io.com.gltf2_io import TextureInfo
-from .texture import texture
-from ..com.conversion import get_anisotropy_rotation_gltf_to_blender
-from math import pi
-from mathutils import Vector
-
-
-def anisotropy(
-        mh,
-        location,
-        anisotropy_socket,
-        anisotropy_rotation_socket,
-        anisotropy_tangent_socket
-):
-
-    if anisotropy_socket is None or anisotropy_rotation_socket is None or anisotropy_tangent_socket is None:
-        return
-
-    x, y = location
-    try:
-        ext = mh.pymat.extensions['KHR_materials_anisotropy']
-        # Needed for KHR_animation_pointer
-        mh.pymat.extensions['KHR_materials_anisotropy']['blender_nodetree'] = mh.node_tree
-        mh.pymat.extensions['KHR_materials_anisotropy']['blender_mat'] = mh.mat  # Needed for KHR_animation_pointer
-    except Exception:
-        return
-
-    anisotropy_strength = ext.get('anisotropyStrength', 0)
-    anisotropy_rotation = ext.get('anisotropyRotation', 0)
-    tex_info = ext.get('anisotropyTexture')
-    if tex_info is not None:
-        tex_info = TextureInfo.from_dict(tex_info)
-
-    # We are going to use UVMap of Normal map if it exists, as input for the anisotropy tangent
-
-    if tex_info is None:
-        anisotropy_socket.default_value = anisotropy_strength
-        anisotropy_rotation_socket.default_value = get_anisotropy_rotation_gltf_to_blender(anisotropy_rotation)
-        return
-
-    # Tangent node
-    node = mh.node_tree.nodes.new('ShaderNodeTangent')
-    node.direction_type = "UV_MAP"
-    node.location = x - 180, y - 200
-    uv_idx = tex_info.tex_coord or 0
-
-    # Get the UVMap of the normal map if available (if not, keeping the first UVMap available, uv_idx = 0)
-    tex_info_normal = mh.pymat.normal_texture
-    if tex_info_normal is not None:
-        try:
-            uv_idx = tex_info.extensions['KHR_texture_transform']['texCoord']
-        except Exception:
-            pass
-
-    node.uv_map = 'UVMap' if uv_idx == 0 else 'UVMap.%03d' % uv_idx
-    mh.node_tree.links.new(anisotropy_tangent_socket, node.outputs['Tangent'])
-
-    # Multiply node
-    multiply_node = mh.node_tree.nodes.new('ShaderNodeMath')
-    multiply_node.label = 'Anisotropy strength'
-    multiply_node.operation = 'MULTIPLY'
-    multiply_node.location = x - 180, y + 200
-    mh.node_tree.links.new(anisotropy_socket, multiply_node.outputs[0])
-    multiply_node.inputs[1].default_value = anisotropy_strength
-
-    # Divide node
-    divide_node = mh.node_tree.nodes.new('ShaderNodeMath')
-    divide_node.label = 'Rotation conversion'
-    divide_node.operation = 'DIVIDE'
-    divide_node.location = x - 180, y
-    mh.node_tree.links.new(anisotropy_rotation_socket, divide_node.outputs[0])
-    divide_node.inputs[1].default_value = 2 * pi
-
-    # Rotation node
-    rotation_node = mh.node_tree.nodes.new('ShaderNodeMath')
-    rotation_node.label = 'Anisotropy rotation'
-    rotation_node.operation = 'ADD'
-    rotation_node.location = x - 180 * 2, y
-    mh.node_tree.links.new(divide_node.inputs[0], rotation_node.outputs[0])
-    rotation_node.inputs[1].default_value = anisotropy_rotation
-
-    # ArcTan node
-    arctan_node = mh.node_tree.nodes.new('ShaderNodeMath')
-    arctan_node.label = 'ArcTan2'
-    arctan_node.operation = 'ARCTAN2'
-    arctan_node.location = x - 180 * 3, y
-    mh.node_tree.links.new(rotation_node.inputs[0], arctan_node.outputs[0])
-
-    # Separate XYZ
-    sep_node = mh.node_tree.nodes.new('ShaderNodeSeparateXYZ')
-    sep_node.location = x - 180 * 4, y
-    mh.node_tree.links.new(arctan_node.inputs[0], sep_node.outputs[1])
-    mh.node_tree.links.new(arctan_node.inputs[1], sep_node.outputs[0])
-    mh.node_tree.links.new(multiply_node.inputs[0], sep_node.outputs[2])
-
-    # Multiply add node
-    multiply_add_node = mh.node_tree.nodes.new('ShaderNodeVectorMath')
-    multiply_add_node.location = x - 180 * 5, y
-    multiply_add_node.operation = 'MULTIPLY_ADD'
-    multiply_add_node.inputs[1].default_value = Vector((2, 2, 1))
-    multiply_add_node.inputs[2].default_value = Vector((-1, -1, 0))
-    mh.node_tree.links.new(sep_node.inputs[0], multiply_add_node.outputs[0])
-
-    # Texture
-    texture(
-        mh,
-        tex_info=tex_info,
-        label='ANISOTROPY',
-        location=(x - 180 * 6, y),
-        is_data=True,
-        color_socket=multiply_add_node.inputs[0]
-    )

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

@@ -1,203 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2021 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import bpy
-from ...io.com.gltf2_io import TextureInfo
-from .pbrMetallicRoughness import \
-    base_color, emission, normal, occlusion, make_settings_node
-from .material_utils import color_factor_and_texture
-from .texture import texture, get_source
-from .image import BlenderImage
-import numpy as np
-
-
-def pbr_specular_glossiness(mh):
-    """Creates node tree for pbrSpecularGlossiness materials."""
-    ext = mh.get_ext('KHR_materials_pbrSpecularGlossiness', {})
-
-    pbr_node = mh.nodes.new('ShaderNodeBsdfPrincipled')
-    out_node = mh.nodes.new('ShaderNodeOutputMaterial')
-    pbr_node.location = 10, 300
-    out_node.location = 300, 300
-    mh.links.new(pbr_node.outputs[0], out_node.inputs[0])
-
-    locs = calc_locations(mh, ext)
-
-    base_color(
-        mh,
-        is_diffuse=True,
-        location=locs['diffuse'],
-        color_socket=pbr_node.inputs['Base Color'],
-        alpha_socket=pbr_node.inputs['Alpha'],
-    )
-
-    emission(
-        mh,
-        location=locs['emission'],
-        color_socket=pbr_node.inputs['Emission Color'],
-        strength_socket=pbr_node.inputs['Emission Strength'],
-    )
-
-    normal(
-        mh,
-        location=locs['normal'],
-        normal_socket=pbr_node.inputs['Normal'],
-    )
-
-    if mh.pymat.occlusion_texture is not None:
-        if mh.settings_node is None:
-            mh.settings_node = make_settings_node(mh)
-            mh.settings_node.location = 10, 425
-            mh.settings_node.width = 240
-        occlusion(
-            mh,
-            location=locs['occlusion'],
-            occlusion_socket=mh.settings_node.inputs['Occlusion'],
-        )
-
-    # The F0 color is the specular tint modulated by
-    # ((1-IOR)/(1+IOR))^2. Setting IOR=1000 makes this factor
-    # approximately 1.
-    pbr_node.inputs['IOR'].default_value = 1000
-
-    # Specular
-    color_factor_and_texture(
-        mh,
-        location=locs['specular'],
-        label='Specular Color',
-        socket=pbr_node.inputs['Specular Tint'],
-        factor=ext.get('specularFactor', [1, 1, 1]),
-        tex_info=ext.get('specularGlossinessTexture'),
-    )
-
-    # Glossiness
-    glossiness(
-        mh,
-        ext,
-        location=locs['glossiness'],
-        roughness_socket=pbr_node.inputs['Roughness'],
-    )
-
-
-def glossiness(mh, ext, location, roughness_socket):
-    # Glossiness = glossinessFactor * specularGlossinessTexture.alpha
-    # Roughness = 1 - Glossiness
-
-    factor = ext.get('glossinessFactor', 1)
-    tex_info = ext.get('specularGlossinessTexture')
-    if tex_info is not None:
-        tex_info = TextureInfo.from_dict(tex_info)
-
-    # Simple case: no texture
-    if tex_info is None or factor == 0:
-        roughness_socket.default_value = 1 - factor
-        return
-
-    # Bake an image with the roughness. The reason we don't do
-    # 1-X with a node is that won't export.
-    roughness_img = make_roughness_image(mh, factor, tex_info)
-    if roughness_img is None:
-        return
-
-    texture(
-        mh,
-        tex_info,
-        location=location,
-        label='ROUGHNESS',
-        color_socket=None,
-        alpha_socket=roughness_socket,
-        is_data=False,
-        forced_image=roughness_img,
-    )
-
-
-def make_roughness_image(mh, glossiness_factor, tex_info):
-    """
-    Bakes the roughness (1-glossiness) into an image. The
-    roughness is in the alpha channel.
-    """
-    pytexture = mh.gltf.data.textures[tex_info.index]
-    source = get_source(mh, pytexture)
-
-    if source is None:
-        return None
-
-    pyimg = mh.gltf.data.images[source]
-    BlenderImage.create(mh.gltf, source)
-
-    # See if cached roughness texture already exists
-    if hasattr(pyimg, 'blender_roughness_image_name'):
-        return bpy.data.images[pyimg.blender_roughness_image_name]
-
-    orig_image = bpy.data.images[pyimg.blender_image_name]
-    # TODO: check for placeholder image and bail
-
-    # Make a copy of the specularGlossiness texture
-    # Avoids interfering if it's used elsewhere
-    image = orig_image.copy()
-
-    w, h = image.size
-    pixels = np.empty(w * h * 4, dtype=np.float32)
-    image.pixels.foreach_get(pixels)
-    pixels = pixels.reshape((w, h, 4))
-
-    # Glossiness = GlossinessFactor * Texture.alpha
-    # Roughness = 1 - Glossiness
-    if glossiness_factor != 1:
-        pixels[:, :, 3] *= glossiness_factor
-    pixels[:, :, 3] *= -1
-    pixels[:, :, 3] += 1
-
-    pixels = pixels.reshape(w * h * 4)
-    image.pixels.foreach_set(pixels)
-
-    image.pack()
-
-    # Cache for reuse
-    pyimg.blender_roughness_image_name = image.name
-
-    return image
-
-
-def calc_locations(mh, ext):
-    """Calculate locations to place each bit of the node graph at."""
-    # Lay the blocks out top-to-bottom, aligned on the right
-    x = -200
-    y = 0
-    height = 460  # height of each block
-    locs = {}
-
-    locs['occlusion'] = (x, y)
-    if mh.pymat.occlusion_texture is not None:
-        y -= height
-
-    locs['diffuse'] = (x, y)
-    if 'diffuseTexture' in ext or mh.vertex_color:
-        y -= height
-
-    locs['glossiness'] = (x, y)
-    gloss_factor = ext.get('glossinessFactor', 1)
-    if 'specularGlossinessTexture' in ext and gloss_factor != 0:
-        y -= height
-
-    locs['normal'] = (x, y)
-    if mh.pymat.normal_texture is not None:
-        y -= height
-
-    locs['specular'] = (x, y)
-    if 'specularGlossinessTexture' in ext:
-        y -= height
-
-    locs['emission'] = (x, y)
-    if mh.pymat.emissive_texture is not None:
-        y -= height
-
-    # Center things
-    total_height = -y
-    y_offset = total_height / 2 - 20
-    for key in locs:
-        x, y = locs[key]
-        locs[key] = (x, y + y_offset)
-
-    return locs

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

@@ -1,56 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2021 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from .pbrMetallicRoughness import base_color
-
-
-def unlit(mh):
-    """Creates node tree for unlit materials."""
-    # Emission node for the base color
-    emission_node = mh.nodes.new('ShaderNodeEmission')
-    emission_node.location = 10, 126
-
-    # Create a "Lightpath trick": makes Emission visible only to
-    # camera rays, so it won't "glow" in Cycles.
-    #
-    # [Is Camera Ray] => [Mix] =>
-    #   [Transparent] => [   ]
-    #      [Emission] => [   ]
-    lightpath_node = mh.nodes.new('ShaderNodeLightPath')
-    transparent_node = mh.nodes.new('ShaderNodeBsdfTransparent')
-    mix_node = mh.nodes.new('ShaderNodeMixShader')
-    lightpath_node.location = 10, 600
-    transparent_node.location = 10, 240
-    mix_node.location = 260, 320
-    mh.links.new(mix_node.inputs['Fac'], lightpath_node.outputs['Is Camera Ray'])
-    mh.links.new(mix_node.inputs[1], transparent_node.outputs[0])
-    mh.links.new(mix_node.inputs[2], emission_node.outputs[0])
-
-    # Material output
-    alpha_socket = None
-    out_node = mh.nodes.new('ShaderNodeOutputMaterial')
-    if mh.is_opaque():
-        out_node.location = 490, 290
-        mh.links.new(out_node.inputs[0], mix_node.outputs[0])
-    else:
-        # Create a "Mix with Transparent" setup so there's a
-        # place to put Alpha.
-        #
-        #         Alpha => [Mix] => [Output]
-        # [Transparent] => [   ]
-        #         Color => [   ]
-        mix2_node = mh.nodes.new('ShaderNodeMixShader')
-        alpha_socket = mix2_node.inputs['Fac']
-        mix2_node.location = 490, -50
-        out_node.location = 700, -70
-        mh.links.new(mix2_node.inputs[1], transparent_node.outputs[0])
-        mh.links.new(mix2_node.inputs[2], mix_node.outputs[0])
-        mh.links.new(out_node.inputs[0], mix2_node.outputs[0])
-
-    base_color(
-        mh,
-        location=(-200, 380),
-        color_socket=emission_node.inputs['Color'],
-        alpha_socket=alpha_socket,
-    )

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

@@ -1,170 +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 .animation_node import BlenderNodeAnim
-from .animation_weight import BlenderWeightAnim
-from .animation_pointer import BlenderPointerAnim
-from .animation_utils import simulate_stash, restore_animation_on_object
-from .vnode import VNode
-
-
-class BlenderAnimation():
-    """Dispatch Animation to node or morph weights animation, or via KHR_animation_pointer"""
-    def __new__(cls, *args, **kwargs):
-        raise RuntimeError("%s should not be instantiated" % cls)
-
-    @staticmethod
-    def anim(gltf, anim_idx):
-        """Create actions/tracks for one animation."""
-        # Caches the action/slot for each object, keyed by:
-        #   - anim_idx
-        #   - obj_name
-        #   - target_id_type
-        gltf.action_cache = {}
-        # Things we need to stash when we're done.
-        gltf.needs_stash = []
-
-        import_user_extensions('gather_import_animation_before_hook', gltf, anim_idx)
-
-        for vnode_id in gltf.vnodes:
-            if isinstance(vnode_id, int):
-                BlenderNodeAnim.anim(gltf, anim_idx, vnode_id)
-            BlenderWeightAnim.anim(gltf, anim_idx, vnode_id)
-
-        if gltf.data.extensions_used is not None and "KHR_animation_pointer" in gltf.data.extensions_used:
-            for cam_idx, cam in enumerate(gltf.data.cameras if gltf.data.cameras else []):
-                if len(cam.animations) == 0:
-                    continue
-                BlenderPointerAnim.anim(gltf, anim_idx, cam, cam_idx, 'CAMERA')
-
-            if gltf.data.extensions is not None and "KHR_lights_punctual" in gltf.data.extensions:
-                for light_idx, light in enumerate(gltf.data.extensions["KHR_lights_punctual"]["lights"]):
-                    if len(light["animations"]) == 0:
-                        continue
-                    BlenderPointerAnim.anim(gltf, anim_idx, light, light_idx, 'LIGHT')
-
-            for mat_idx, mat in enumerate(gltf.data.materials if gltf.data.materials else []):
-                if len(mat.blender_material) == 0:
-                    # The animated material is not used in Blender, so do not animate it
-                    continue
-                if len(mat.animations) != 0:
-                    BlenderPointerAnim.anim(gltf, anim_idx, mat, mat_idx, 'MATERIAL')
-                if mat.normal_texture is not None and len(mat.normal_texture.animations) != 0:
-                    BlenderPointerAnim.anim(gltf, anim_idx, mat.normal_texture, mat_idx, 'MATERIAL_PBR', name=mat.name)
-                if mat.occlusion_texture is not None and len(mat.occlusion_texture.animations) != 0:
-                    BlenderPointerAnim.anim(gltf, anim_idx, mat.occlusion_texture,
-                                            mat_idx, 'MATERIAL_PBR', name=mat.name)
-                if mat.pbr_metallic_roughness is not None and len(mat.pbr_metallic_roughness.animations) != 0:
-                    # This can be a regulat PBR or unlit material
-                    is_unlit = mat.extensions is not None and "KHR_materials_unlit" in mat.extensions
-                    BlenderPointerAnim.anim(gltf, anim_idx, mat.pbr_metallic_roughness, mat_idx,
-                                            'MATERIAL_PBR', name=mat.name, is_unlit=is_unlit)
-
-                texs = [
-                    mat.emissive_texture,
-                    mat.normal_texture,
-                    mat.occlusion_texture,
-                    mat.pbr_metallic_roughness.base_color_texture if mat.pbr_metallic_roughness is not None else None,
-                    mat.pbr_metallic_roughness.metallic_roughness_texture if mat.pbr_metallic_roughness is not None else None,
-                ]
-
-                for tex in [t for t in texs if t is not None]:
-                    if tex.extensions is not None and "KHR_texture_transform" in tex.extensions:
-                        # This can be a regulat PBR or unlit material
-                        is_unlit = mat.extensions is not None and "KHR_materials_unlit" in mat.extensions
-                        BlenderPointerAnim.anim(
-                            gltf,
-                            anim_idx,
-                            tex.extensions["KHR_texture_transform"],
-                            mat_idx,
-                            'TEX_TRANSFORM',
-                            name=mat.name,
-                            is_unlit=is_unlit)
-
-                if mat.extensions is not None:
-                    texs = [
-                        mat.extensions["KHR_materials_volume"].get("thicknessTexture") if "KHR_materials_volume" in mat.extensions else None,
-                        mat.extensions["KHR_materials_transmission"].get("transmissionTexture") if "KHR_materials_transmission" in mat.extensions else None,
-                        mat.extensions["KHR_materials_specular"].get("specularTexture") if "KHR_materials_specular" in mat.extensions else None,
-                        mat.extensions["KHR_materials_specular"].get("specularColorTexture") if "KHR_materials_specular" in mat.extensions else None,
-                        mat.extensions["KHR_materials_sheen"].get("sheenColorTexture") if "KHR_materials_sheen" in mat.extensions else None,
-                        mat.extensions["KHR_materials_sheen"].get("sheenRoughnessTexture") if "KHR_materials_sheen" in mat.extensions else None,
-                        mat.extensions["KHR_materials_clearcoat"].get("clearcoatTexture") if "KHR_materials_clearcoat" in mat.extensions else None,
-                        mat.extensions["KHR_materials_clearcoat"].get("clearcoatRoughnessTexture") if "KHR_materials_clearcoat" in mat.extensions else None,
-                        mat.extensions["KHR_materials_clearcoat"].get("clearcoatNormalTexture") if "KHR_materials_clearcoat" in mat.extensions else None,
-                        mat.extensions["KHR_materials_anisotropy"].get("anisotropyTexture") if "KHR_materials_anisotropy" in mat.extensions else None,
-                    ]
-
-                    for tex in [t for t in texs if t is not None]:
-                        if 'extensions' in tex and "KHR_texture_transform" in tex['extensions']:
-                            BlenderPointerAnim.anim(
-                                gltf,
-                                anim_idx,
-                                tex['extensions']["KHR_texture_transform"],
-                                mat_idx,
-                                'TEX_TRANSFORM',
-                                name=mat.name)
-
-                for ext in [
-                        "KHR_materials_emissive_strength",
-                        # "KHR_materials_iridescence",
-                        "KHR_materials_volume",
-                        "KHR_materials_ior",
-                        "KHR_materials_transmission",
-                        "KHR_materials_clearcoat",
-                        "KHR_materials_sheen",
-                        "KHR_materials_specular",
-                        "KHR_materials_anisotropy"
-                ]:
-                    if mat.extensions is not None and ext in mat.extensions:
-                        BlenderPointerAnim.anim(gltf, anim_idx, mat.extensions[ext], mat_idx, 'EXT', name=mat.name)
-
-        # Push all actions onto NLA tracks with this animation's name
-        track_name = gltf.data.animations[anim_idx].track_name
-        for (obj, action, slot) in gltf.needs_stash:
-            simulate_stash(obj, track_name, action, slot)
-
-        import_user_extensions('gather_import_animation_after_hook', gltf, anim_idx, track_name)
-
-        if hasattr(bpy.data.scenes[0], 'gltf2_animation_tracks') is False:
-            return
-
-        if track_name not in [track.name for track in bpy.data.scenes[0].gltf2_animation_tracks]:
-            new_ = bpy.data.scenes[0].gltf2_animation_tracks.add()
-            new_.name = track_name
-        # reverse order, as animation are created in reverse order (because of NLA adding tracks are reverted)
-        bpy.data.scenes[0].gltf2_animation_tracks.move(len(bpy.data.scenes[0].gltf2_animation_tracks) - 1, 0)
-
-    @staticmethod
-    def restore_animation(gltf, animation_name):
-        """Restores the actions for an animation by its track name."""
-        for vnode_id in gltf.vnodes:
-            vnode = gltf.vnodes[vnode_id]
-            if vnode.type == VNode.Bone:
-                obj = gltf.vnodes[vnode.bone_arma].blender_object
-            elif vnode.type == VNode.Object:
-                obj = vnode.blender_object
-            else:
-                continue
-
-            restore_animation_on_object(obj, animation_name)
-            if obj.data and hasattr(obj.data, 'shape_keys'):
-                restore_animation_on_object(obj.data.shape_keys, animation_name)
-
-        if gltf.data.extensions_used is not None and "KHR_animation_pointer" in gltf.data.extensions_used:
-            for cam in gltf.data.cameras if gltf.data.cameras else []:
-                restore_animation_on_object(cam.blender_object_data, animation_name)
-
-            if gltf.data.extensions and "KHR_lights_punctual" in gltf.data.extensions:
-                for light in gltf.data.extensions['KHR_lights_punctual']['lights']:
-                    restore_animation_on_object(light['blender_object_data'], animation_name)
-
-            for mat in gltf.data.materials if gltf.data.materials else []:
-                if len(mat.blender_material) == 0:
-                    # The animated material is not used in Blender, so do not animate it
-                    continue
-                restore_animation_on_object(mat.blender_nodetree, animation_name)
-                restore_animation_on_object(mat.blender_mat, animation_name)