Skip to content
Snippets Groups Projects
render.py 76.2 KiB
Newer Older
# SPDX-License-Identifier: GPL-2.0-or-later
Luca Bonavita's avatar
Luca Bonavita committed

# <pep8 compliant>
"""Write the POV file using this file's functions and some from other modules then render it."""
Luca Bonavita's avatar
Luca Bonavita committed
import bpy
Maurice Raybaud's avatar
Maurice Raybaud committed
from sys import platform
Maurice Raybaud's avatar
Maurice Raybaud committed
from math import (
    pi,
)  # maybe move to scenography.py and topology_*****_data.py respectively with smoke and matrix

import tempfile  # generate temporary files with random names
from bpy.types import Operator
Maurice Raybaud's avatar
Maurice Raybaud committed
from bpy.utils import register_class, unregister_class
Maurice Raybaud's avatar
Maurice Raybaud committed
from . import (
    scripting,
)  # for writing, importing and rendering directly POV Scene Description Language items
from . import scenography  # for atmosphere, environment, effects, lighting, camera
from . import shading  # for BI POV shaders emulation
Maurice Raybaud's avatar
Maurice Raybaud committed
from . import object_mesh_topology  # for mesh based geometry
from . import object_curve_topology  # for curves based geometry

# from . import object_primitives  # for import and export of POV specific primitives
Maurice Raybaud's avatar
Maurice Raybaud committed
from .scenography import image_format, img_map, img_map_transforms, path_image

from .shading import write_object_material_interior
Maurice Raybaud's avatar
Maurice Raybaud committed
from .object_primitives import write_object_modifiers
Maurice Raybaud's avatar
Maurice Raybaud committed

Campbell Barton's avatar
Campbell Barton committed
def string_strip_hyphen(name):
Maurice Raybaud's avatar
Maurice Raybaud committed
    """Remove hyphen characters from a string to avoid POV errors."""
Campbell Barton's avatar
Campbell Barton committed
    return name.replace("-", "")
Maurice Raybaud's avatar
Maurice Raybaud committed

Maurice Raybaud's avatar
Maurice Raybaud committed
def safety(name, ref_level_bound):
Maurice Raybaud's avatar
Maurice Raybaud committed
    """append suffix characters to names of various material declinations.
Maurice Raybaud's avatar
Maurice Raybaud committed
    Material declinations are necessary to POV syntax and used in shading.py
Maurice Raybaud's avatar
Maurice Raybaud committed
    by the pov_has_no_specular_maps function to create the finish map trick and
Maurice Raybaud's avatar
Maurice Raybaud committed
    the suffixes avoid name collisions.
    Keyword arguments:
    name -- the initial material name as a string
Maurice Raybaud's avatar
Maurice Raybaud committed
    ref_level_bound -- the enum number of the ref_level_bound being written:
        ref_level_bound=1 is for texture with No specular nor Mirror reflection
        ref_level_bound=2 is for texture with translation of spec and mir levels
Maurice Raybaud's avatar
Maurice Raybaud committed
        for when no map influences them
Maurice Raybaud's avatar
Maurice Raybaud committed
        ref_level_bound=3 is for texture with Maximum Spec and Mirror
Maurice Raybaud's avatar
Maurice Raybaud committed
    """
Maurice Raybaud's avatar
Maurice Raybaud committed
    # All the try except clause below seems useless as each time
    # prefix rewritten even after and outside of it what was the point?
    # It may not even be any longer possible to feed no arg from Blender UI
    # try:
    # if name: # if int(name) > 0: # could be zero if no argument provided
    # # and always triggered exception so is this similar ?
    # prefix = "shader"
    # except BaseException as e:
    # print(e.__doc__)
    # print('An exception occurred: {}'.format(e))
Maurice Raybaud's avatar
Maurice Raybaud committed
    # prefix = "" # rewritten below...
    prefix = "shader_"
Campbell Barton's avatar
Campbell Barton committed
    name = string_strip_hyphen(name)
Maurice Raybaud's avatar
Maurice Raybaud committed
    if ref_level_bound == 2:
        return prefix + name
Maurice Raybaud's avatar
Maurice Raybaud committed
    # implicit else-if (no return yet)
    if ref_level_bound == 1:
        return prefix + name + "0"  # used for 0 of specular map
Maurice Raybaud's avatar
Maurice Raybaud committed
    # implicit else-if (no return yet)
    if ref_level_bound == 3:
        return prefix + name + "1"  # used for 1 of specular map
# -------- end safety string name material

Luca Bonavita's avatar
Luca Bonavita committed

Maurice Raybaud's avatar
Maurice Raybaud committed
def is_renderable(ob):
    """test for objects flagged as hidden or boolean operands not to render"""
    return not ob.hide_render and ob not in csg_list
Campbell Barton's avatar
Campbell Barton committed

Maurice Raybaud's avatar
Maurice Raybaud committed
    """test for non hidden, non boolean operands objects to render"""
    return [ob for ob in bpy.data.objects if is_renderable(ob)]
Maurice Raybaud's avatar
Maurice Raybaud committed
def no_renderable_objects():
    """Boolean operands only. Not to render"""
    return list(csg_list)
Maurice Raybaud's avatar
Maurice Raybaud committed
tab_level = 0
user_dir = bpy.utils.resource_path('USER')
preview_dir = os.path.join(user_dir, "preview")

# Make sure Preview directory exists and is empty
Maurice Raybaud's avatar
Maurice Raybaud committed
smoke_path = os.path.join(preview_dir, "smoke.df3")

Maurice Raybaud's avatar
Maurice Raybaud committed
# below properties not added to __init__ yet to avoid conflicts with material sss scale
# unless it would override then should be interfaced also in scene units property tab
Maurice Raybaud's avatar
Maurice Raybaud committed
# if scene.pov.sslt_enable:
    # file.write("    mm_per_unit %s\n"%scene.pov.mm_per_unit)
    # file.write("    subsurface {\n")
    # file.write("        samples %s, %s\n"%(scene.pov.sslt_samples_max,scene.pov.sslt_samples_min))
    # if scene.pov.sslt_radiosity:
        # file.write("        radiosity on\n")
    # file.write("}\n")
Maurice Raybaud's avatar
Maurice Raybaud committed
'''
Maurice Raybaud's avatar
Maurice Raybaud committed
# """Translate some object level POV statements from Blender UI
# to POV syntax and write to exported file """

# # Maybe return that string to be added instead of directly written.

# '''XXX WIP
# import .object_mesh_topology.write_object_csg_inside_vector
# write_object_csg_inside_vector(ob, file)
Maurice Raybaud's avatar
Maurice Raybaud committed
# '''

# if ob.pov.hollow:
# File.write("\thollow\n")
# if ob.pov.double_illuminate:
# File.write("\tdouble_illuminate\n")
# if ob.pov.sturm:
# File.write("\tsturm\n")
# if ob.pov.no_shadow:
# File.write("\tno_shadow\n")
# if ob.pov.no_image:
# File.write("\tno_image\n")
# if ob.pov.no_reflection:
# File.write("\tno_reflection\n")
# if ob.pov.no_radiosity:
# File.write("\tno_radiosity\n")
# if ob.pov.inverse:
# File.write("\tinverse\n")
# if ob.pov.hierarchy:
# File.write("\thierarchy\n")

# # XXX, Commented definitions
# '''
# if scene.pov.photon_enable:
# File.write("photons {\n")
# if ob.pov.target:
# File.write("target %.4g\n"%ob.pov.target_value)
# if ob.pov.refraction:
# File.write("refraction on\n")
# if ob.pov.reflection:
# File.write("reflection on\n")
# if ob.pov.pass_through:
# File.write("pass_through\n")
# File.write("}\n")
# if ob.pov.object_ior > 1:
# File.write("interior {\n")
# File.write("ior %.4g\n"%ob.pov.object_ior)
# if scene.pov.photon_enable and ob.pov.target and ob.pov.refraction and ob.pov.dispersion:
# File.write("ior %.4g\n"%ob.pov.dispersion_value)
# File.write("ior %s\n"%ob.pov.dispersion_samples)
# if scene.pov.photon_enable == False:
# File.write("caustics %.4g\n"%ob.pov.fake_caustics_power)
# '''
Luca Bonavita's avatar
Luca Bonavita committed
def write_pov(filename, scene=None, info_callback=None):
Maurice Raybaud's avatar
Maurice Raybaud committed
    """Main export process from Blender UI to POV syntax and write to exported file """
    with open(filename, "w") as file:
        # Only for testing
        if not scene:
            scene = bpy.data.scenes[0]

        render = scene.render
        world = scene.world
        global_matrix = mathutils.Matrix.Rotation(-pi / 2.0, 4, 'X')
        comments = scene.pov.comments_enable and not scene.pov.tempfiles_enable
        linebreaksinlists = scene.pov.list_lf_enable and not scene.pov.tempfiles_enable
        feature_set = bpy.context.preferences.addons[__package__].preferences.branch_feature_set_povray
        using_uberpov = feature_set == 'uberpov'
        pov_binary = PovrayRender._locate_binary()
Luca Bonavita's avatar
Luca Bonavita committed

        if using_uberpov:
            print("Unofficial UberPOV feature set chosen in preferences")
        else:
            print("Official POV-Ray 3.7 feature set chosen in preferences")
        if 'uber' in pov_binary:
            print("The name of the binary suggests you are probably rendering with Uber POV engine")
        else:
            print("The name of the binary suggests you are probably rendering with standard POV engine")
Luca Bonavita's avatar
Luca Bonavita committed

Maurice Raybaud's avatar
Maurice Raybaud committed
            tab_str = ""
            if tabtype == 'NONE':
                tab_str = ""
            elif tabtype == 'TAB':
                tab_str = "\t"
            elif tabtype == 'SPACE':
                tab_str = spaces * " "
            return tab_str

        tab = set_tab(scene.pov.indentation_character, scene.pov.indentation_spaces)
        if not scene.pov.tempfiles_enable:

            def tab_write(str_o):
                """Indent POV syntax from brackets levels and write to exported file """
                global tab_level
                brackets = str_o.count("{") - str_o.count("}") + str_o.count("[") - str_o.count("]")
                if brackets < 0:
                    tab_level = tab_level + brackets
                if tab_level < 0:
                    print("Indentation Warning: tab_level = %s" % tab_level)
                    tab_level = 0
                if tab_level >= 1:
                    file.write("%s" % tab * tab_level)
                file.write(str_o)
                if brackets > 0:
                    tab_level = tab_level + brackets

        else:

            def tab_write(str_o):
                """write directly to exported file if user checked autonamed temp files (faster)."""

                file.write(str_o)

        def unique_name(name, name_seq):
            """Increment any generated POV name that could get identical to avoid collisions"""

            if name not in name_seq:
                name = string_strip_hyphen(name)
                return name

            name_orig = name
            i = 1
            while name in name_seq:
                name = "%s_%.3d" % (name_orig, i)
                i += 1
Campbell Barton's avatar
Campbell Barton committed
            name = string_strip_hyphen(name)
Luca Bonavita's avatar
Luca Bonavita committed
            return name

        def write_matrix(matrix):
            """Translate some transform matrix from Blender UI
            to POV syntax and write to exported file """
            tab_write(
                "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],
                )
Luca Bonavita's avatar
Luca Bonavita committed

        material_names_dictionary = {}
        DEF_MAT_NAME = ""  # or "Default"?

        # -----------------------------------------------------------------------------

        def export_meta(metas):
            """write all POV blob primitives and Blender Metas to exported file """
            # TODO - blenders 'motherball' naming is not supported.

            if comments and len(metas) >= 1:
                file.write("//--Blob objects--\n\n")
            # Get groups of metaballs by blender name prefix.
            meta_group = {}
            meta_elems = {}
            for meta_ob in metas:
                prefix = meta_ob.name.split(".")[0]
                if prefix not in meta_group:
                    meta_group[prefix] = meta_ob  # .data.threshold
                elems = [
                    (elem, meta_ob)
                    for elem in meta_ob.data.elements
                    if elem.type in {'BALL', 'ELLIPSOID', 'CAPSULE', 'CUBE', 'PLANE'}
                ]
                if prefix in meta_elems:
                    meta_elems[prefix].extend(elems)
                else:
                    meta_elems[prefix] = elems

                # empty metaball
                if len(elems) == 0:
                    tab_write("\n//dummy sphere to represent empty meta location\n")
                    tab_write(
                        "sphere {<%.6g, %.6g, %.6g>,0 pigment{rgbt 1} "
                        "no_image no_reflection no_radiosity "
                        "photons{pass_through collect off} hollow}\n\n"
                        % (meta_ob.location.x, meta_ob.location.y, meta_ob.location.z)
                    )  # meta_ob.name > povdataname)
                # other metaballs
                else:
                    for mg, mob in meta_group.items():
                        if len(meta_elems[mg]) != 0:
                            tab_write("blob{threshold %.4g // %s \n" % (mob.data.threshold, mg))
                            for elems in meta_elems[mg]:
                                elem = elems[0]
                                loc = elem.co
                                stiffness = elem.stiffness
                                if elem.use_negative:
                                    stiffness = -stiffness
                                if elem.type == 'BALL':
                                    tab_write(
                                        "sphere { <%.6g, %.6g, %.6g>, %.4g, %.4g "
                                        % (loc.x, loc.y, loc.z, elem.radius, stiffness)
                                    write_matrix(global_matrix @ elems[1].matrix_world)
                                    tab_write("}\n")
                                elif elem.type == 'ELLIPSOID':
                                    tab_write(
                                        "sphere{ <%.6g, %.6g, %.6g>,%.4g,%.4g "
                                        % (
                                            loc.x / elem.size_x,
                                            loc.y / elem.size_y,
                                            loc.z / elem.size_z,
                                            elem.radius,
                                            stiffness,
                                        )
                                    tab_write(
                                        "scale <%.6g, %.6g, %.6g>"
                                        % (elem.size_x, elem.size_y, elem.size_z)
                                    write_matrix(global_matrix @ elems[1].matrix_world)
                                    tab_write("}\n")
                                elif elem.type == 'CAPSULE':
                                    tab_write(
                                        "cylinder{ <%.6g, %.6g, %.6g>,<%.6g, %.6g, %.6g>,%.4g,%.4g "
                                        % (
                                            (loc.x - elem.size_x),
                                            loc.y,
                                            loc.z,
                                            (loc.x + elem.size_x),
                                            loc.y,
                                            loc.z,
                                            elem.radius,
                                            stiffness,
                                        )
                                    # tab_write("scale <%.6g, %.6g, %.6g>" % (elem.size_x, elem.size_y, elem.size_z))
                                    write_matrix(global_matrix @ elems[1].matrix_world)
                                    tab_write("}\n")

                                elif elem.type == 'CUBE':
                                    tab_write(
                                        "cylinder { -x*8, +x*8,%.4g,%.4g translate<%.6g,%.6g,%.6g> scale  <1/4,1,1> scale <%.6g, %.6g, %.6g>\n"
                                        % (
                                            elem.radius * 2.0,
                                            stiffness / 4.0,
                                            loc.x,
                                            loc.y,
                                            loc.z,
                                            elem.size_x,
                                            elem.size_y,
                                            elem.size_z,
                                        )
                                    write_matrix(global_matrix @ elems[1].matrix_world)
                                    tab_write("}\n")
                                    tab_write(
                                        "cylinder { -y*8, +y*8,%.4g,%.4g translate<%.6g,%.6g,%.6g> scale <1,1/4,1> scale <%.6g, %.6g, %.6g>\n"
                                        % (
                                            elem.radius * 2.0,
                                            stiffness / 4.0,
                                            loc.x,
                                            loc.y,
                                            loc.z,
                                            elem.size_x,
                                            elem.size_y,
                                            elem.size_z,
                                        )
                                    write_matrix(global_matrix @ elems[1].matrix_world)
                                    tab_write("}\n")
                                    tab_write(
                                        "cylinder { -z*8, +z*8,%.4g,%.4g translate<%.6g,%.6g,%.6g> scale <1,1,1/4> scale <%.6g, %.6g, %.6g>\n"
                                        % (
                                            elem.radius * 2.0,
                                            stiffness / 4.0,
                                            loc.x,
                                            loc.y,
                                            loc.z,
                                            elem.size_x,
                                            elem.size_y,
                                            elem.size_z,
                                        )
                                    )
                                    write_matrix(global_matrix @ elems[1].matrix_world)
                                    tab_write("}\n")

                                elif elem.type == 'PLANE':
                                    tab_write(
                                        "cylinder { -x*8, +x*8,%.4g,%.4g translate<%.6g,%.6g,%.6g> scale  <1/4,1,1> scale <%.6g, %.6g, %.6g>\n"
                                        % (
                                            elem.radius * 2.0,
                                            stiffness / 4.0,
                                            loc.x,
                                            loc.y,
                                            loc.z,
                                            elem.size_x,
                                            elem.size_y,
                                            elem.size_z,
                                        )
                                    )
                                    write_matrix(global_matrix @ elems[1].matrix_world)
                                    tab_write("}\n")
                                    tab_write(
                                        "cylinder { -y*8, +y*8,%.4g,%.4g translate<%.6g,%.6g,%.6g> scale <1,1/4,1> scale <%.6g, %.6g, %.6g>\n"
                                        % (
                                            elem.radius * 2.0,
                                            stiffness / 4.0,
                                            loc.x,
                                            loc.y,
                                            loc.z,
                                            elem.size_x,
                                            elem.size_y,
                                            elem.size_z,
                                        )
                                    )
                                    write_matrix(global_matrix @ elems[1].matrix_world)
                                    tab_write("}\n")

                            try:
                                one_material = elems[1].data.materials[
                                    0
                                ]  # lame! - blender cant do enything else.
                            except BaseException as e:
                                print(e.__doc__)
                                print('An exception occurred: {}'.format(e))
                                one_material = None
                            if one_material:
                                diffuse_color = one_material.diffuse_color
                                trans = 1.0 - one_material.pov.alpha
                                if (
                                    one_material.use_transparency
                                    and one_material.transparency_method == 'RAYTRACE'
                                ):
                                    pov_filter = one_material.pov_raytrace_transparency.filter * (
                                        1.0 - one_material.alpha
                                    )
                                    trans = (1.0 - one_material.pov.alpha) - pov_filter
                                else:
                                    pov_filter = 0.0
                                material_finish = material_names_dictionary[one_material.name]
Maurice Raybaud's avatar
Maurice Raybaud committed
                                tab_write(
                                    "pigment {srgbft<%.3g, %.3g, %.3g, %.3g, %.3g>} \n"
                                        diffuse_color[0],
                                        diffuse_color[1],
                                        diffuse_color[2],
                                        pov_filter,
                                        trans,
                                tab_write("finish{%s} " % safety(material_finish, ref_level_bound=2))
                                material_finish = DEF_MAT_NAME
                                trans = 0.0
                                tab_write(
                                    "pigment{srgbt<1,1,1,%.3g>} finish{%s} "
                                    % (trans, safety(material_finish, ref_level_bound=2))
Luca Bonavita's avatar
Luca Bonavita committed

                                write_object_material_interior(one_material, mob, tab_write)
                                # write_object_material_interior(one_material, elems[1])
                                tab_write("radiosity{importance %3g}\n" % mob.pov.importance_value)
                                tab_write("}\n\n")  # End of Metaball block

        '''
                meta = ob.data
    
                # important because no elements will break parsing.
                elements = [elem for elem in meta.elements if elem.type in {'BALL', 'ELLIPSOID'}]
    
                if elements:
                    tab_write("blob {\n")
                    tab_write("threshold %.4g\n" % meta.threshold)
                    importance = ob.pov.importance_value
    
                    try:
                        material = meta.materials[0]  # lame! - blender cant do enything else.
                    except:
                        material = None
    
                    for elem in elements:
                        loc = elem.co
    
                        stiffness = elem.stiffness
                        if elem.use_negative:
                            stiffness = - stiffness
    
                        if elem.type == 'BALL':
    
                            tab_write("sphere { <%.6g, %.6g, %.6g>, %.4g, %.4g }\n" %
                                     (loc.x, loc.y, loc.z, elem.radius, stiffness))
    
                            # After this wecould do something simple like...
                            #     "pigment {Blue} }"
                            # except we'll write the color
    
                        elif elem.type == 'ELLIPSOID':
                            # location is modified by scale
                            tab_write("sphere { <%.6g, %.6g, %.6g>, %.4g, %.4g }\n" %
                                     (loc.x / elem.size_x,
                                      loc.y / elem.size_y,
                                      loc.z / elem.size_z,
                                      elem.radius, stiffness))
                            tab_write("scale <%.6g, %.6g, %.6g> \n" %
                                     (elem.size_x, elem.size_y, elem.size_z))
    
                    if material:
                        diffuse_color = material.diffuse_color
                        trans = 1.0 - material.pov.alpha
                        if material.use_transparency and material.transparency_method == 'RAYTRACE':
                            pov_filter = material.pov_raytrace_transparency.filter * (1.0 - material.alpha)
                            trans = (1.0 - material.pov.alpha) - pov_filter
                        else:
                            pov_filter = 0.0
    
                        material_finish = material_names_dictionary[material.name]
    
                        tab_write("pigment {srgbft<%.3g, %.3g, %.3g, %.3g, %.3g>} \n" %
                                 (diffuse_color[0], diffuse_color[1], diffuse_color[2],
                                  pov_filter, trans))
                        tab_write("finish {%s}\n" % safety(material_finish, ref_level_bound=2))
    
                        tab_write("pigment {srgb 1} \n")
                        # Write the finish last.
                        tab_write("finish {%s}\n" % (safety(DEF_MAT_NAME, ref_level_bound=2)))
    
                    write_object_material_interior(material, elems[1])
    
                    write_matrix(global_matrix @ ob.matrix_world)
                    # Importance for radiosity sampling added here
                    tab_write("radiosity { \n")
                    # importance > ob.pov.importance_value
                    tab_write("importance %3g \n" % importance)
                    tab_write("}\n")
    
                    tab_write("}\n")  # End of Metaball block
    
                    if comments and len(metas) >= 1:
                        file.write("\n")
        '''

        def export_global_settings(scene):
            """write all POV global settings to exported file """
            # Imperial units warning
            if scene.unit_settings.system == "IMPERIAL":
                print("Warning: Imperial units not supported")

            tab_write("global_settings {\n")
            tab_write("assumed_gamma 1.0\n")
            tab_write("max_trace_level %d\n" % scene.pov.max_trace_level)

            if scene.pov.global_settings_advanced:
                if not scene.pov.radio_enable:
                    file.write("    adc_bailout %.6f\n" % scene.pov.adc_bailout)
                file.write("    ambient_light <%.6f,%.6f,%.6f>\n" % scene.pov.ambient_light[:])
                file.write("    irid_wavelength <%.6f,%.6f,%.6f>\n" % scene.pov.irid_wavelength[:])
                file.write("    number_of_waves %s\n" % scene.pov.number_of_waves)
                file.write("    noise_generator %s\n" % scene.pov.noise_generator)
            if scene.pov.radio_enable:
                tab_write("radiosity {\n")
                tab_write("adc_bailout %.4g\n" % scene.pov.radio_adc_bailout)
                tab_write("brightness %.4g\n" % scene.pov.radio_brightness)
                tab_write("count %d\n" % scene.pov.radio_count)
                tab_write("error_bound %.4g\n" % scene.pov.radio_error_bound)
                tab_write("gray_threshold %.4g\n" % scene.pov.radio_gray_threshold)
                tab_write("low_error_factor %.4g\n" % scene.pov.radio_low_error_factor)
                tab_write("maximum_reuse %.4g\n" % scene.pov.radio_maximum_reuse)
                tab_write("minimum_reuse %.4g\n" % scene.pov.radio_minimum_reuse)
                tab_write("nearest_count %d\n" % scene.pov.radio_nearest_count)
                tab_write("pretrace_start %.3g\n" % scene.pov.radio_pretrace_start)
                tab_write("pretrace_end %.3g\n" % scene.pov.radio_pretrace_end)
                tab_write("recursion_limit %d\n" % scene.pov.radio_recursion_limit)
                tab_write("always_sample %d\n" % scene.pov.radio_always_sample)
                tab_write("normal %d\n" % scene.pov.radio_normal)
                tab_write("media %d\n" % scene.pov.radio_media)
                tab_write("subsurface %d\n" % scene.pov.radio_subsurface)
Maurice Raybaud's avatar
Maurice Raybaud committed
                tab_write("}\n")
            once_sss = 1
            once_ambient = 1
            once_photons = 1
            for material in bpy.data.materials:
                if material.pov_subsurface_scattering.use and once_sss:
                    # In pov, the scale has reversed influence compared to blender. these number
                    # should correct that
                    tab_write(
                        "mm_per_unit %.6f\n" % (material.pov_subsurface_scattering.scale * 1000.0)
                    )
                    # 1000 rather than scale * (-100.0) + 15.0))

                    # In POV-Ray, the scale factor for all subsurface shaders needs to be the same

                    # formerly sslt_samples were multiplied by 100 instead of 10
                    sslt_samples = (11 - material.pov_subsurface_scattering.error_threshold) * 10

                    tab_write("subsurface { samples %d, %d }\n" % (sslt_samples, sslt_samples / 10))
                    once_sss = 0

                if world and once_ambient:
                    tab_write("ambient_light rgb<%.3g, %.3g, %.3g>\n" % world.pov.ambient_color[:])
                    once_ambient = 0

                if scene.pov.photon_enable:
                    if once_photons and (
                        material.pov.refraction_type == "2" or material.pov.photons_reflection
                    ):
                        tab_write("photons {\n")
                        tab_write("spacing %.6f\n" % scene.pov.photon_spacing)
                        tab_write("max_trace_level %d\n" % scene.pov.photon_max_trace_level)
                        tab_write("adc_bailout %.3g\n" % scene.pov.photon_adc_bailout)
                        tab_write(
                            "gather %d, %d\n"
                            % (scene.pov.photon_gather_min, scene.pov.photon_gather_max)
                        )
                        if scene.pov.photon_map_file_save_load in {'save'}:
                            ph_file_name = 'Photon_map_file.ph'
                            if scene.pov.photon_map_file != '':
                                ph_file_name = scene.pov.photon_map_file + '.ph'
                            ph_file_dir = tempfile.gettempdir()
                            path = bpy.path.abspath(scene.pov.photon_map_dir)
                            if os.path.exists(path):
                                ph_file_dir = path
                            full_file_name = os.path.join(ph_file_dir, ph_file_name)
                            tab_write('save_file "%s"\n' % full_file_name)
                            scene.pov.photon_map_file = full_file_name
                        if scene.pov.photon_map_file_save_load in {'load'}:
                            full_file_name = bpy.path.abspath(scene.pov.photon_map_file)
                            if os.path.exists(full_file_name):
                                tab_write('load_file "%s"\n' % full_file_name)
                        tab_write("}\n")
                        once_photons = 0
Luca Bonavita's avatar
Luca Bonavita committed

Maurice Raybaud's avatar
Maurice Raybaud committed
            tab_write("}\n")
        # sel = renderable_objects() #removed for booleans
        if comments:
            file.write(
                "//----------------------------------------------\n"
                "//--Exported with POV-Ray exporter for Blender--\n"
                "//----------------------------------------------\n\n"
            )
        file.write("#version 3.7;\n")  # Switch below as soon as 3.8 beta gets easy linked
        # file.write("#version 3.8;\n")
        file.write(
            "#declare Default_texture = texture{pigment {rgb 0.8} " "finish {brilliance 3.8} }\n\n"
        )
        if comments:
            file.write("\n//--Global settings--\n\n")

        export_global_settings(scene)

        if comments:
            file.write("\n//--Custom Code--\n\n")
        scripting.export_custom_code(file)

        if comments:
            file.write("\n//--Patterns Definitions--\n\n")
        local_pattern_names = []
        for texture in bpy.data.textures:  # ok?
            if texture.users > 0:
                current_pat_name = string_strip_hyphen(bpy.path.clean_name(texture.name))
                # string_strip_hyphen(patternNames[texture.name]) #maybe instead of the above
            
Loading
Loading full blame...