object_mesh_topology.py

# SPDX-License-Identifier: GPL-2.0-or-later

# <pep8 compliant>

"""Translate to POV the control point compounded geometries like polygon

meshes or curve based shapes."""

# --------
# -- Faster mesh export ...one day
# import numpy as np
# --------
import bpy
from . import texturing  # for how textures influence shaders
from .scenography import export_smoke

def matrix_as_pov_string(matrix):
    """Translate some transform matrix from Blender UI
    to POV syntax and return that string """
    return "matrix <" \
           "%.6f, %.6f, %.6f, " \
           "%.6f, %.6f, %.6f, " \
           "%.6f, %.6f, %.6f, " \
           "%.6f, %.6f, %.6f" \
           ">\n" % (
               matrix[0][0],
               matrix[1][0],
               matrix[2][0],
               matrix[0][1],
               matrix[1][1],
               matrix[2][1],
               matrix[0][2],
               matrix[1][2],
               matrix[2][2],
               matrix[0][3],
               matrix[1][3],
               matrix[2][3],
           )


def write_object_csg_inside_vector(ob, file):
    """Write inside vector for use by pov CSG, only once per object using boolean"""
    has_csg_inside_vector = False
    for modif in ob.modifiers:
        if (
                not has_csg_inside_vector
                and modif.type == 'BOOLEAN'
                and ob.pov.boolean_mod == "POV"
        ):
            file.write(
                "\tinside_vector <%.6g, %.6g, %.6g>\n"
                % (
                    ob.pov.inside_vector[0],
                    ob.pov.inside_vector[1],
                    ob.pov.inside_vector[2],
                )
            )
            has_csg_inside_vector = True


#    objectNames = {}
DEF_OBJ_NAME = "Default"


def export_meshes(
        preview_dir,
        file,
        scene,
        sel,
        csg,
        string_strip_hyphen,
        safety,
        write_object_modifiers,
        material_names_dictionary,
        write_object_material_interior,
        exported_lights_count,
        unpacked_images,
        image_format,
        img_map,
        img_map_transforms,
        path_image,
        smoke_path,
        global_matrix,
        write_matrix,
        using_uberpov,
        comments,
        linebreaksinlists,
        tab,
        tab_level,
        tab_write,
        info_callback,
):
    """write all meshes as POV mesh2{} syntax to exported file """
    # # some numpy functions to speed up mesh export NOT IN USE YET
    # # Current 2.93 beta numpy linking has troubles so definitions commented off for now

    # # TODO: also write a numpy function to read matrices at object level?
    # # feed below with mesh object.data, but only after doing data.calc_loop_triangles()
    # def read_verts_co(self, mesh):
    # #'float64' would be a slower 64-bit floating-point number numpy datatype
    # # using 'float32' vert coordinates for now until any issue is reported
    # mverts_co = np.zeros((len(mesh.vertices) * 3), dtype=np.float32)
    # mesh.vertices.foreach_get("co", mverts_co)
    # return np.reshape(mverts_co, (len(mesh.vertices), 3))

    # def read_verts_idx(self, mesh):
    # mverts_idx = np.zeros((len(mesh.vertices)), dtype=np.int64)
    # mesh.vertices.foreach_get("index", mverts_idx)
    # return np.reshape(mverts_idx, (len(mesh.vertices), 1))

    # def read_verts_norms(self, mesh):
    # #'float64' would be a slower 64-bit floating-point number numpy datatype
    # # using less accurate 'float16' normals for now until any issue is reported
    # mverts_no = np.zeros((len(mesh.vertices) * 3), dtype=np.float16)
    # mesh.vertices.foreach_get("normal", mverts_no)
    # return np.reshape(mverts_no, (len(mesh.vertices), 3))

    # def read_faces_idx(self, mesh):
    # mfaces_idx = np.zeros((len(mesh.loop_triangles)), dtype=np.int64)
    # mesh.loop_triangles.foreach_get("index", mfaces_idx)
    # return np.reshape(mfaces_idx, (len(mesh.loop_triangles), 1))

    # def read_faces_verts_indices(self, mesh):
    # mfaces_verts_idx = np.zeros((len(mesh.loop_triangles) * 3), dtype=np.int64)
    # mesh.loop_triangles.foreach_get("vertices", mfaces_verts_idx)
    # return np.reshape(mfaces_verts_idx, (len(mesh.loop_triangles), 3))

    # # Why is below different from vertex indices?
    # def read_faces_verts_loops(self, mesh):
    # mfaces_verts_loops = np.zeros((len(mesh.loop_triangles) * 3), dtype=np.int64)
    # mesh.loop_triangles.foreach_get("loops", mfaces_verts_loops)
    # return np.reshape(mfaces_verts_loops, (len(mesh.loop_triangles), 3))

    # def read_faces_norms(self, mesh):
    # #'float64' would be a slower 64-bit floating-point number numpy datatype
    # # using less accurate 'float16' normals for now until any issue is reported
    # mfaces_no = np.zeros((len(mesh.loop_triangles) * 3), dtype=np.float16)
    # mesh.loop_triangles.foreach_get("normal", mfaces_no)
    # return np.reshape(mfaces_no, (len(mesh.loop_triangles), 3))

    # def read_faces_smooth(self, mesh):
    # mfaces_smth = np.zeros((len(mesh.loop_triangles) * 1), dtype=np.bool)
    # mesh.loop_triangles.foreach_get("use_smooth", mfaces_smth)
    # return np.reshape(mfaces_smth, (len(mesh.loop_triangles), 1))

    # def read_faces_material_indices(self, mesh):
    # mfaces_mats_idx = np.zeros((len(mesh.loop_triangles)), dtype=np.int16)
    # mesh.loop_triangles.foreach_get("material_index", mfaces_mats_idx)
    # return np.reshape(mfaces_mats_idx, (len(mesh.loop_triangles), 1))

    #        obmatslist = []
    #        def hasUniqueMaterial():
    #            # Grab materials attached to object instances ...
    #            if hasattr(obj, 'material_slots'):
    #                for ms in obj.material_slots:
    #                    if ms.material is not None and ms.link == 'OBJECT':
    #                        if ms.material in obmatslist:
    #                            return False
    #                        else:
    #                            obmatslist.append(ms.material)
    #                            return True
    #        def hasObjectMaterial(obj):
    #            # Grab materials attached to object instances ...
    #            if hasattr(obj, 'material_slots'):
    #                for ms in obj.material_slots:
    #                    if ms.material is not None and ms.link == 'OBJECT':
    #                        # If there is at least one material slot linked to the object
    #                        # and not the data (mesh), always create a new, "private" data instance.
    #                        return True
    #            return False
    # For objects using local material(s) only!
    # This is a mapping between a tuple (dataname, material_names_dictionary, ...),
    # and the POV dataname.
    # As only objects using:
    #     * The same data.
    #     * EXACTLY the same materials, in EXACTLY the same sockets.
    # ... can share a same instance in POV export.
    obmats2data = {}

    def check_object_materials(obj, obj_name, dataname):
        """Compare other objects exported material slots to avoid rewriting duplicates"""
        if hasattr(obj, 'material_slots'):
            has_local_mats = False
            key = [dataname]
            for ms in obj.material_slots:
                if ms.material is not None:
                    key.append(ms.material.name)
                    if ms.link == 'OBJECT' and not has_local_mats:
                        has_local_mats = True
                else:
                    # Even if the slot is empty, it is important to grab it...
                    key.append("")
            if has_local_mats:
                # If this object uses local material(s), lets find if another object
                # using the same data and exactly the same list of materials
                # (in the same slots) has already been processed...
                # Note that here also, we use object name as new, unique dataname for Pov.
                key = tuple(key)  # Lists are not hashable...
                if key not in obmats2data:
                    obmats2data[key] = obj_name