object_mesh_topology.py

# ***** BEGIN GPL LICENSE BLOCK *****
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# #**** END GPL LICENSE BLOCK #****

# <pep8 compliant>

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

meshes or curve based shapes."""

####################
## Faster mesh export
import numpy as np

####################
import random  # used for hair
import bpy
from . import texturing  # for how textures influence shaders
from .scenography import export_smoke


def matrix_as_pov_string(matrix):
    """Translate some tranform matrix from Blender UI
    to POV syntax and return that string """
    matrix_string = (
        "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],
        )
    )
    return matrix_string


#    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,
    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

    # 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(ob, 'material_slots'):
    #                for ms in ob.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(ob):
    #            # Grab materials attached to object instances ...
    #            if hasattr(ob, 'material_slots'):
    #                for ms in ob.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(ob, name, dataname):
        """Compare other objects exported material slots to avoid rewriting duplicates"""
        if hasattr(ob, 'material_slots'):
            has_local_mats = False
            key = [dataname]
            for ms in ob.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] = name
                return obmats2data[key]
        return None

    data_ref = {}