@tushar-br/editing-pack 1.0.188 → 1.0.190

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

@@ -1,248 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2021 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import typing
-import bpy
-
-from ....io.exp.user_extensions import export_user_extensions
-from ....io.com.gltf2_io_extensions import Extension
-from ....io.exp.image_data import ImageData
-from ....io.exp.binary_data import BinaryData
-from ....io.com import debug as gltf2_io_debug
-from ....io.com import gltf2_io
-from ..sampler import gather_sampler
-from ..cache import cached
-from .search_node_tree import get_texture_node_from_socket, NodeSocket
-from . import image
-
-
-@cached
-def gather_texture(
-        blender_shader_sockets: typing.Tuple[bpy.types.NodeSocket],
-        use_tile: bool,
-        export_settings):
-    """
-    Gather texture sampling information and image channels from a blender shader texture attached to a shader socket.
-
-    :param blender_shader_sockets: The sockets of the material which should contribute to the texture
-    :param export_settings: configuration of the export
-    :return: a glTF 2.0 texture with sampler and source embedded (will be converted to references by the exporter)
-    """
-
-    if not __filter_texture(blender_shader_sockets, export_settings):
-        return None, None, None
-
-    source, webp_image, image_data, factor, udim_image = __gather_source(
-        blender_shader_sockets, use_tile, export_settings)
-
-    exts, remove_source = __gather_extensions(blender_shader_sockets, source, webp_image, image_data, export_settings)
-
-    texture = gltf2_io.Texture(
-        extensions=exts,
-        extras=__gather_extras(blender_shader_sockets, export_settings),
-        name=__gather_name(blender_shader_sockets, export_settings),
-        sampler=__gather_sampler(blender_shader_sockets, export_settings),
-        source=source if remove_source is False else None
-    )
-
-    # although valid, most viewers can't handle missing source properties
-    # This can have None source for "keep original", when original can't be found
-    if texture.source is None and remove_source is False:
-        return None, None, udim_image
-
-    export_user_extensions('gather_texture_hook', export_settings, texture, blender_shader_sockets)
-
-    return texture, factor, udim_image
-
-
-def __filter_texture(blender_shader_sockets, export_settings):
-    # User doesn't want to export textures
-    if export_settings['gltf_image_format'] == "NONE":
-        return None
-    return True
-
-
-def __gather_extensions(blender_shader_sockets, source, webp_image, image_data, export_settings):
-
-    extensions = {}
-
-    remove_source = False
-    required = False
-
-    ext_webp = {}
-
-    # If user want to keep original textures, and these textures are WebP, we need to remove source from
-    # gltf2_io.Texture, and populate extension
-    if export_settings['gltf_keep_original_textures'] is True \
-            and source is not None \
-            and source.mime_type == "image/webp":
-        ext_webp["source"] = source
-        remove_source = True
-        required = True
-
-# If user want to export in WebP format (so without fallback in png/jpg)
-    if export_settings['gltf_image_format'] == "WEBP":
-        # We create all image without fallback
-        ext_webp["source"] = source
-        remove_source = True
-        required = True
-
-# If user doesn't want to export in WebP format, but want WebP too. Texture is not WebP
-    if export_settings['gltf_image_format'] != "WEBP" \
-            and export_settings['gltf_add_webp'] \
-            and source is not None \
-            and source.mime_type != "image/webp":
-        # We need here to create some WebP textures
-
-        new_mime_type = "image/webp"
-        new_data, _ = image_data.encode(new_mime_type, export_settings)
-        if len(new_data) == 0:
-            export_settings['log'].warning("Image data is empty, not exporting image")
-            return None, False
-
-        if export_settings['gltf_format'] == 'GLTF_SEPARATE':
-
-            uri = ImageData(
-                data=new_data,
-                mime_type=new_mime_type,
-                name=source.uri.name
-            )
-            buffer_view = None
-            name = source.uri.name
-            image.set_real_uri(uri, export_settings) # Note: image, here, is the imported image python file
-
-        else:
-            buffer_view = BinaryData(data=new_data)
-            uri = None
-            name = source.name
-
-        webp_image = __make_webp_image(buffer_view, None, None, new_mime_type, name, uri, export_settings)
-
-        ext_webp["source"] = webp_image
-
-
-# If user doesn't want to export in WebP format, but want WebP too. Texture is WebP
-    if export_settings['gltf_image_format'] != "WEBP" \
-            and source is not None \
-            and source.mime_type == "image/webp":
-
-        # User does not want fallback
-        if export_settings['gltf_webp_fallback'] is False:
-            ext_webp["source"] = source
-            remove_source = True
-            required = True
-
-# If user doesn't want to export in webp format, but want WebP too as fallback. Texture is WebP
-    if export_settings['gltf_image_format'] != "WEBP" \
-            and webp_image is not None \
-            and export_settings['gltf_webp_fallback'] is True:
-        # Already managed in __gather_source, we only have to assign
-        ext_webp["source"] = webp_image
-
-        # Not needed in code, for for documentation:
-        # remove_source = False
-        # required = False
-
-    if len(ext_webp) > 0:
-        extensions["EXT_texture_webp"] = Extension('EXT_texture_webp', ext_webp, required)
-        return extensions, remove_source
-    else:
-        return None, False
-
-
-@cached
-def __make_webp_image(buffer_view, extensions, extras, mime_type, name, uri, export_settings):
-    return gltf2_io.Image(
-        buffer_view=buffer_view,
-        extensions=extensions,
-        extras=extras,
-        mime_type=mime_type,
-        name=name,
-        uri=uri
-    )
-
-
-def __gather_extras(blender_shader_sockets, export_settings):
-    return None
-
-
-def __gather_name(blender_shader_sockets, export_settings):
-    return None
-
-
-def __gather_sampler(blender_shader_sockets, export_settings):
-    shader_nodes = [get_texture_node_from_socket(socket, export_settings) for socket in blender_shader_sockets]
-    if len(shader_nodes) > 1:
-        export_settings['log'].warning(
-            "More than one shader node tex image used for a texture. "
-            "The resulting glTF sampler will behave like the first shader node tex image."
-        )
-    first_valid_shader_node = next(filter(lambda x: x is not None, shader_nodes))
-
-    # group_path can't be a list, so transform it to str
-
-    sep_item = "##~~gltf-sep~~##"
-    sep_inside_item = "##~~gltf-inside-sep~~##"
-    group_path_str = ""
-    if len(first_valid_shader_node.group_path) > 0:
-        # Retrieving the blender material using this shader tree
-        for mat in bpy.data.materials:
-            if id(mat.node_tree) == id(first_valid_shader_node.group_path[0].original):
-                group_path_str += mat.name  # TODO if linked, we can have multiple materials with same name...
-                break
-    if len(first_valid_shader_node.group_path) > 1:
-        for idx, i in enumerate(first_valid_shader_node.group_path[1:]):
-            group_path_str += sep_item
-            if idx == 0:
-                group_path_str += first_valid_shader_node.group_path[0].name
-            else:
-                group_path_str += i.id_data.name
-            group_path_str += sep_inside_item
-            group_path_str += i.name
-
-    return gather_sampler(
-        first_valid_shader_node.shader_node,
-        group_path_str,
-        export_settings)
-
-
-def __gather_source(blender_shader_sockets, use_tile, export_settings):
-    source, image_data, factor, udim_image = image.gather_image(blender_shader_sockets, use_tile, export_settings)
-
-    if export_settings['gltf_keep_original_textures'] is False \
-            and export_settings['gltf_image_format'] != "WEBP" \
-            and source is not None \
-            and source.mime_type == "image/webp":
-
-        if export_settings['gltf_webp_fallback'] is False:
-            # Already managed in __gather_extensions
-            return source, None, image_data, factor, udim_image
-        else:
-            # Need to create a PNG texture
-
-            new_mime_type = "image/png"
-            new_data, _ = image_data.encode(new_mime_type, export_settings)
-            # We should not have empty data here, as we are calculating fallback, so the real image should be ok already
-
-            if export_settings['gltf_format'] == 'GLTF_SEPARATE':
-                buffer_view = None
-                uri = ImageData(
-                    data=new_data,
-                    mime_type=new_mime_type,
-                    name=source.uri.name
-                )
-                name = source.uri.name
-
-                image.set_real_uri(uri, export_settings) # Note: image, here, is the imported image python file
-
-            else:
-                uri = None
-                buffer_view = BinaryData(data=new_data)
-                name = source.name
-
-            png_image = __make_webp_image(buffer_view, None, None, new_mime_type, name, uri, export_settings)
-
-        # We inverted the png & WebP image, to have the png as main source
-        return png_image, source, image_data, factor, udim_image
-    return source, None, image_data, factor, udim_image

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

@@ -1,291 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2021 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import bpy
-import typing
-from ....io.com import gltf2_io
-from ....io.com.gltf2_io_extensions import Extension
-from ....io.exp.user_extensions import export_user_extensions
-from ..sampler import detect_manual_uv_wrapping
-from ..cache import cached
-from . import texture as gltf2_blender_gather_texture
-from .search_node_tree import \
-    get_texture_node_from_socket, \
-    from_socket, \
-    FilterByType, \
-    previous_node, \
-    get_const_from_socket, \
-    NodeSocket, \
-    get_texture_transform_from_mapping_node
-
-# blender_shader_sockets determine the texture and primary_socket determines
-# the textransform and UVMap. Ex: when combining an ORM texture, for
-# occlusion the primary_socket would be the occlusion socket, and
-# blender_shader_sockets would be the (O,R,M) sockets.
-
-
-def gather_texture_info(primary_socket, blender_shader_sockets, export_settings, filter_type='ALL'):
-    export_settings['current_texture_transform'] = {}  # For KHR_animation_pointer
-    return __gather_texture_info_helper(primary_socket, blender_shader_sockets, 'DEFAULT', filter_type, export_settings)
-
-
-def gather_material_normal_texture_info_class(
-        primary_socket,
-        blender_shader_sockets,
-        export_settings,
-        filter_type='ALL'):
-    export_settings['current_texture_transform'] = {}  # For KHR_animation_pointer
-    export_settings['current_normal_scale'] = {}  # For KHR_animation_pointer
-    return __gather_texture_info_helper(primary_socket, blender_shader_sockets, 'NORMAL', filter_type, export_settings)
-
-
-def gather_material_occlusion_texture_info_class(
-        primary_socket,
-        blender_shader_sockets,
-        export_settings,
-        filter_type='ALL'):
-    export_settings['current_texture_transform'] = {}  # For KHR_animation_pointer
-    export_settings['current_occlusion_strength'] = {}  # For KHR_animation_pointer
-    return __gather_texture_info_helper(
-        primary_socket,
-        blender_shader_sockets,
-        'OCCLUSION',
-        filter_type,
-        export_settings)
-
-
-@cached
-def __gather_texture_info_helper(
-        primary_socket: bpy.types.NodeSocket,
-        blender_shader_sockets: typing.Tuple[bpy.types.NodeSocket],
-        kind: str,
-        filter_type: str,
-        export_settings):
-    if not __filter_texture_info(primary_socket, blender_shader_sockets, filter_type, export_settings):
-        return None, {}, {}, None
-
-    tex_transform, uvmap_info = __gather_texture_transform_and_tex_coord(primary_socket, export_settings)
-
-    index, factor, udim_image = __gather_index(blender_shader_sockets, None, export_settings)
-    if udim_image is not None:
-        udim_info = {'udim': udim_image is not None, 'image': udim_image, 'sockets': blender_shader_sockets}
-    else:
-        udim_info = {}
-
-    fields = {
-        'extensions': __gather_extensions(tex_transform, export_settings),
-        'extras': __gather_extras(blender_shader_sockets, export_settings),
-        'index': index,
-        'tex_coord': None  # This will be set later, as some data are dependant of mesh or object
-    }
-
-    if kind == 'DEFAULT':
-        texture_info = gltf2_io.TextureInfo(**fields)
-
-    elif kind == 'NORMAL':
-        fields['scale'] = __gather_normal_scale(primary_socket, export_settings)
-        texture_info = gltf2_io.MaterialNormalTextureInfoClass(**fields)
-
-    elif kind == 'OCCLUSION':
-        fields['strength'] = __gather_occlusion_strength(primary_socket, export_settings)
-        texture_info = gltf2_io.MaterialOcclusionTextureInfoClass(**fields)
-
-    if texture_info.index is None:
-        return None, {} if udim_image is None else uvmap_info, udim_info, None
-
-    export_user_extensions('gather_texture_info_hook', export_settings, texture_info, blender_shader_sockets)
-
-    return texture_info, uvmap_info, udim_info, factor
-
-
-def gather_udim_texture_info(
-        primary_socket: bpy.types.NodeSocket,
-        blender_shader_sockets: typing.Tuple[bpy.types.NodeSocket],
-        udim_info,
-        tex,
-        export_settings):
-
-    tex_transform, _ = __gather_texture_transform_and_tex_coord(primary_socket, export_settings)
-    export_settings['current_udim_info'] = udim_info
-    index, _, _ = __gather_index(blender_shader_sockets,
-                                 udim_info['image'].name + str(udim_info['tile']), export_settings)
-    export_settings['current_udim_info'] = {}
-
-    fields = {
-        'extensions': __gather_extensions(tex_transform, export_settings),
-        'extras': __gather_extras(blender_shader_sockets, export_settings),
-        'index': index,
-        'tex_coord': None  # This will be set later, as some data are dependant of mesh or object
-    }
-
-    if tex in ["normalTexture", "clearcoatNormalTexture"]:
-        fields['scale'] = __gather_normal_scale(primary_socket, export_settings)
-        texture_info = gltf2_io.MaterialNormalTextureInfoClass(**fields)
-    elif tex == "occlusionTexture":
-        fields['strength'] = __gather_occlusion_strength(primary_socket, export_settings)
-        texture_info = gltf2_io.MaterialOcclusionTextureInfoClass(**fields)
-    else:
-        texture_info = gltf2_io.TextureInfo(**fields)
-
-    export_user_extensions('gather_udim_texture_info_hook', export_settings, texture_info, blender_shader_sockets)
-
-    return texture_info
-
-
-def __filter_texture_info(primary_socket, blender_shader_sockets, filter_type, export_settings):
-    if primary_socket is None:
-        return False
-    if get_texture_node_from_socket(primary_socket, export_settings) is None:
-        return False
-    if not blender_shader_sockets:
-        return False
-    if not all([elem is not None for elem in blender_shader_sockets]):
-        return False
-    if filter_type == "ALL":
-        # Check that all sockets link to texture
-        if any([get_texture_node_from_socket(socket, export_settings) is None for socket in blender_shader_sockets]):
-            # sockets do not lead to a texture --> discard
-            return False
-    elif filter_type == "ANY":
-        # Check that at least one socket link to texture
-        if all([get_texture_node_from_socket(socket, export_settings) is None for socket in blender_shader_sockets]):
-            return False
-    elif filter_type == "NONE":
-        # No check
-        pass
-
-    return True
-
-
-def __gather_extensions(texture_transform, export_settings):
-    if texture_transform is None:
-        return None
-    extension = Extension("KHR_texture_transform", texture_transform)
-    return {"KHR_texture_transform": extension}
-
-
-def __gather_extras(blender_shader_sockets, export_settings):
-    return None
-
-
-# MaterialNormalTextureInfo only
-def __gather_normal_scale(primary_socket, export_settings):
-    result = from_socket(
-        primary_socket,
-        FilterByType(bpy.types.ShaderNodeNormalMap))
-    if not result:
-        return None
-    strengthInput = result[0].shader_node.inputs['Strength']
-    normal_scale = None
-    if not strengthInput.is_linked and strengthInput.default_value != 1:
-        normal_scale = strengthInput.default_value
-
-    # Storing path for KHR_animation_pointer
-    path_ = {}
-    path_['length'] = 1
-    path_['path'] = "/materials/XXX/YYY/scale"
-    export_settings['current_normal_scale']["node_tree." + strengthInput.path_from_id() + ".default_value"] = path_
-
-    return normal_scale
-
-
-# MaterialOcclusionTextureInfo only
-def __gather_occlusion_strength(primary_socket, export_settings):
-    # Look for a MixRGB node that mixes with pure white in front of
-    # primary_socket. The mix factor gives the occlusion strength.
-    nav = primary_socket.to_node_nav()
-    nav.move_back()
-
-    reverse = False
-    strength = None
-
-    if nav.moved and nav.node.type == 'MIX' and nav.node.blend_type == 'MIX':
-        fac, path = nav.get_constant('Factor')
-        if fac is not None:
-            col1, _ = nav.get_constant('#A_Color')
-            col2, _ = nav.get_constant('#B_Color')
-            if col1 == [1.0, 1.0, 1.0] and col2 is None:
-                strength = fac
-            if col1 is None and col2 == [1.0, 1.0, 1.0]:
-                strength = 1.0 - fac  # reversed for reversed inputs
-                reverse = True
-
-        # Storing path for KHR_animation_pointer
-        path_ = {}
-        path_['length'] = 1
-        path_['path'] = "/materials/XXX/occlusionTexture/strength"
-        path_['reverse'] = reverse
-        export_settings['current_occlusion_strength'][path] = path_
-
-    return strength
-
-
-def __gather_index(blender_shader_sockets, use_tile, export_settings):
-    # We just put the actual shader into the 'index' member
-    return gltf2_blender_gather_texture.gather_texture(blender_shader_sockets, use_tile, export_settings)
-
-
-def __gather_texture_transform_and_tex_coord(primary_socket, export_settings):
-    # We're expecting
-    #
-    #     [UV Map] => [Mapping] => [UV Wrapping] => [Texture Node] => ... => primary_socket
-    #
-    # The [UV Wrapping] is for wrap modes like MIRROR that use nodes,
-    # [Mapping] is for KHR_texture_transform, and [UV Map] is for texCoord.
-    result_tex = get_texture_node_from_socket(primary_socket, export_settings)
-    blender_shader_node = result_tex.shader_node
-
-    nodes_used = export_settings.get('nodes_used', {})
-    nodes_used[blender_shader_node.name] = True
-
-    # Skip over UV wrapping stuff (it goes in the sampler)
-    result = detect_manual_uv_wrapping(blender_shader_node, result_tex.group_path)
-    if result:
-        node = previous_node(result['next_socket'])
-    else:
-        node = previous_node(NodeSocket(blender_shader_node.inputs['Vector'], result_tex.group_path))
-
-    texture_transform = None
-    if node.node and node.node.type == 'MAPPING':
-        texture_transform = get_texture_transform_from_mapping_node(node, export_settings)
-        node = previous_node(NodeSocket(node.node.inputs['Vector'], node.group_path))
-
-    uvmap_info = {}
-
-    if node.node and node.node.type == 'UVMAP' and node.node.uv_map:
-        uvmap_info['type'] = "Fixed"
-        uvmap_info['value'] = node.node.uv_map
-
-    elif node and node.node and node.node.type == 'ATTRIBUTE' \
-            and node.node.attribute_type == "GEOMETRY" \
-            and node.node.attribute_name:
-        # If this attribute is Face Corner / 2D Vector, this is a UV map
-        # So we can use it as a UV map Fixed
-        # But this will be checked later, when we know the mesh
-        uvmap_info['type'] = 'Attribute'
-        uvmap_info['value'] = node.node.attribute_name
-
-    else:
-        uvmap_info['type'] = 'Active'
-
-    return texture_transform, uvmap_info
-
-
-def check_same_size_images(
-    blender_shader_sockets: typing.Tuple[bpy.types.NodeSocket],
-    export_settings
-) -> bool:
-    """Check that all sockets leads to images of the same size."""
-    if not blender_shader_sockets or not all(blender_shader_sockets):
-        return False
-
-    sizes = set()
-    for socket in blender_shader_sockets:
-        tex = get_texture_node_from_socket(socket, export_settings)
-        if tex is None:
-            return False
-        size = tex.shader_node.image.size
-        sizes.add((size[0], size[1]))
-
-    return len(sizes) == 1