scenography.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>

"""With respect to camera frame and optics distortions, also export environment

with world, sky, atmospheric effects such as rainbows or smoke """

import bpy
from bpy.utils import register_class, unregister_class
import os
from imghdr import what  # imghdr is a python lib to identify image file types
from math import atan, pi, sqrt, degrees
from . import df3_library  # for smoke rendering
from .object_primitives import write_object_modifiers

##############find image texture # used for export_world
def image_format(imgF):
    """Identify input image filetypes to transmit to POV."""
    # First use the below explicit extensions to identify image file prospects
    ext = {
        'JPG': "jpeg",
        'JPEG': "jpeg",
        'GIF': "gif",
        'TGA': "tga",
        'IFF': "iff",
        'PPM': "ppm",
        'PNG': "png",
        'SYS': "sys",
        'TIFF': "tiff",
        'TIF': "tiff",
        'EXR': "exr",
        'HDR': "hdr",
    }.get(os.path.splitext(imgF)[-1].upper(), "")
    # Then, use imghdr to really identify the filetype as it can be different
    if not ext:
        # maybe add a check for if path exists here?
        print(" WARNING: texture image has no extension")  # too verbose

        ext = what(imgF)  # imghdr is a python lib to identify image file types
    return ext


def img_map(ts):
    """Translate mapping type from Blender UI to POV syntax and return that string."""
    image_map = ""
    texdata = bpy.data.textures[ts.texture]
    if ts.mapping == 'FLAT':
        image_map = "map_type 0 "
    elif ts.mapping == 'SPHERE':
        image_map = "map_type 1 "
    elif ts.mapping == 'TUBE':
        image_map = "map_type 2 "

    ## map_type 3 and 4 in development (?) (ENV in pov 3.8)
    ## for POV-Ray, currently they just seem to default back to Flat (type 0)
    # elif ts.mapping=="?":
    #    image_map = " map_type 3 "
    # elif ts.mapping=="?":
    #    image_map = " map_type 4 "
    if ts.use_interpolation:  # Available if image sampling class reactivated?
        image_map += " interpolate 2 "
    if texdata.extension == 'CLIP':
        image_map += " once "
    # image_map += "}"
    # if ts.mapping=='CUBE':
    #    image_map+= "warp { cubic } rotate <-90,0,180>"
    # no direct cube type mapping. Though this should work in POV 3.7
    # it doesn't give that good results(best suited to environment maps?)
    # if image_map == "":
    #    print(" No texture image  found ")
    return image_map


def img_map_transforms(ts):
    """Translate mapping transformations from Blender UI to POV syntax and return that string."""
    # XXX TODO: unchecked textures give error of variable referenced before assignment XXX
    # POV-Ray "scale" is not a number of repetitions factor, but ,its
    # inverse, a standard scale factor.
    # 0.5 Offset is needed relatively to scale because center of the
    # scale is 0.5,0.5 in blender and 0,0 in POV
    # Strange that the translation factor for scale is not the same as for
    # translate.
    # TODO: verify both matches with other blender renderers / internal in previous versions.
    image_map_transforms = ""
    image_map_transforms = "scale <%.4g,%.4g,%.4g> translate <%.4g,%.4g,%.4g>" % (
        ts.scale[0],
        ts.scale[1],
        ts.scale[2],
        ts.offset[0],
        ts.offset[1],
        ts.offset[2],
    )
    # image_map_transforms = (" translate <-0.5,-0.5,0.0> scale <%.4g,%.4g,%.4g> translate <%.4g,%.4g,%.4g>" % \
    # ( 1.0 / ts.scale.x,
    # 1.0 / ts.scale.y,
    # 1.0 / ts.scale.z,
    # (0.5 / ts.scale.x) + ts.offset.x,
    # (0.5 / ts.scale.y) + ts.offset.y,
    # ts.offset.z))
    # image_map_transforms = (
    # "translate <-0.5,-0.5,0> "
    # "scale <-1,-1,1> * <%.4g,%.4g,%.4g> "
    # "translate <0.5,0.5,0> + <%.4g,%.4g,%.4g>" % \
    # (1.0 / ts.scale.x,
    # 1.0 / ts.scale.y,
    # 1.0 / ts.scale.z,
    # ts.offset.x,
    # ts.offset.y,
    # ts.offset.z)
    # )
    return image_map_transforms


def img_map_bg(wts):
    """Translate world mapping from Blender UI to POV syntax and return that string."""
    tex = bpy.data.textures[wts.texture]
    image_mapBG = ""
    # texture_coords refers to the mapping of world textures:
    if wts.texture_coords == 'VIEW' or wts.texture_coords == 'GLOBAL':
        image_mapBG = " map_type 0 "
    elif wts.texture_coords == 'ANGMAP':
        image_mapBG = " map_type 1 "
    elif wts.texture_coords == 'TUBE':
        image_mapBG = " map_type 2 "

    if tex.use_interpolation:
        image_mapBG += " interpolate 2 "
    if tex.extension == 'CLIP':
        image_mapBG += " once "
    # image_mapBG += "}"
    # if wts.mapping == 'CUBE':
    #   image_mapBG += "warp { cubic } rotate <-90,0,180>"
    # no direct cube type mapping. Though this should work in POV 3.7
    # it doesn't give that good results(best suited to environment maps?)
    # if image_mapBG == "":
    #    print(" No background texture image  found ")
    return image_mapBG


def path_image(image):
    """Conform a path string to POV syntax to avoid POV errors."""
    return bpy.path.abspath(image.filepath, library=image.library).replace("\\", "/")
    # .replace("\\","/") to get only forward slashes as it's what POV prefers,
    # even on windows


# end find image texture
# -----------------------------------------------------------------------------


def export_camera(scene, global_matrix, render, tab_write):
    """Translate camera from Blender UI to POV syntax and write to exported file."""
    camera = scene.camera

    # DH disabled for now, this isn't the correct context
    active_object = None  # bpy.context.active_object # does not always work  MR
    matrix = global_matrix @ camera.matrix_world
    focal_point = camera.data.dof.focus_distance

    # compute resolution
    q_size = render.resolution_x / render.resolution_y
    tab_write("#declare camLocation  = <%.6f, %.6f, %.6f>;\n" % matrix.translation[:])
    tab_write(
        "#declare camLookAt = <%.6f, %.6f, %.6f>;\n"
        % tuple([degrees(e) for e in matrix.to_3x3().to_euler()])
    )

    tab_write("camera {\n")
    if scene.pov.baking_enable and active_object and active_object.type == 'MESH':
        tab_write("mesh_camera{ 1 3\n")  # distribution 3 is what we want here
        tab_write("mesh{%s}\n" % active_object.name)
        tab_write("}\n")
        tab_write("location <0,0,.01>")
        tab_write("direction <0,0,-1>")

    else:
        if camera.data.type == 'ORTHO':
            # todo: track when SensorHeightRatio was added to see if needed (not used)
            sensor_height_ratio = (
                render.resolution_x * camera.data.ortho_scale / render.resolution_y
            )
            tab_write("orthographic\n")
            # Blender angle is radian so should be converted to degrees:
            # % (camera.data.angle * (180.0 / pi) )
            # but actually argument is not compulsory after angle in pov ortho mode
            tab_write("angle\n")
            tab_write("right <%6f, 0, 0>\n" % -camera.data.ortho_scale)
            tab_write("location  <0, 0, 0>\n")
            tab_write("look_at  <0, 0, -1>\n")
            tab_write("up <0, %6f, 0>\n" % (camera.data.ortho_scale / q_size))

        elif camera.data.type == 'PANO':
            tab_write("panoramic\n")
            tab_write("location  <0, 0, 0>\n")
            tab_write("look_at  <0, 0, -1>\n")
            tab_write("right <%s, 0, 0>\n" % -q_size)
            tab_write("up <0, 1, 0>\n")
            tab_write("angle  %f\n" % (360.0 * atan(16.0 / camera.data.lens) / pi))
        elif camera.data.type == 'PERSP':
            # Standard camera otherwise would be default in pov
            tab_write("location  <0, 0, 0>\n")
            tab_write("look_at  <0, 0, -1>\n")
            tab_write("right <%s, 0, 0>\n" % -q_size)
            tab_write("up <0, 1, 0>\n")
            tab_write(
                "angle  %f\n"
                % (2 * atan(camera.data.sensor_width / 2 / camera.data.lens) * 180.0 / pi)
            )

        tab_write(
            "rotate  <%.6f, %.6f, %.6f>\n" % tuple([degrees(e) for e in matrix.to_3x3().to_euler()])
        )
        tab_write("translate <%.6f, %.6f, %.6f>\n" % matrix.translation[:])
        if camera.data.dof.use_dof and (focal_point != 0 or camera.data.dof.focus_object):
            tab_write("aperture %.3g\n" % (1 / (camera.data.dof.aperture_fstop * 10000) * 1000))
            tab_write(
                "blur_samples %d %d\n"
                % (camera.data.pov.dof_samples_min, camera.data.pov.dof_samples_max)
            )
            tab_write("variance 1/%d\n" % camera.data.pov.dof_variance)
            tab_write("confidence %.3g\n" % camera.data.pov.dof_confidence)
            if camera.data.dof.focus_object:
                focal_ob = scene.objects[camera.data.dof.focus_object.name]
                matrix_blur = global_matrix @ focal_ob.matrix_world
                tab_write("focal_point <%.4f,%.4f,%.4f>\n" % matrix_blur.translation[:])
            else:
                tab_write("focal_point <0, 0, %f>\n" % focal_point)
    if camera.data.pov.normal_enable:
        tab_write(
            "normal {%s %.4f turbulence %.4f scale %.4f}\n"
            % (
                camera.data.pov.normal_patterns,
                camera.data.pov.cam_normal,
                camera.data.pov.turbulence,
                camera.data.pov.scale,
            )
        )
    tab_write("}\n")


exported_lights_count = 0


def export_lights(lamps, file, scene, global_matrix, write_matrix, tab_write):
    """Translate lights from Blender UI to POV syntax and write to exported file."""

    # Incremented after each lamp export to declare its target
    # currently used for Fresnel diffuse shader as their slope vector:
    global exported_lights_count
    exported_lights_count = 0
    # Get all lamps
    for ob in lamps:
        lamp = ob.data

        matrix = global_matrix @ ob.matrix_world

        # Color is no longer modified by energy
        # any way to directly get bpy_prop_array as tuple?
        color = tuple(lamp.color)

        tab_write("light_source {\n")
        tab_write("< 0,0,0 >\n")
        tab_write("color srgb<%.3g, %.3g, %.3g>\n" % color)

        if lamp.type == 'POINT':
            pass
        elif lamp.type == 'SPOT':
            tab_write("spotlight\n")

            # Falloff is the main radius from the centre line
            tab_write("falloff %.2f\n" % (degrees(lamp.spot_size) / 2.0))  # 1 TO 179 FOR BOTH
            tab_write("radius %.6f\n" % ((degrees(lamp.spot_size) / 2.0) * (1.0 - lamp.spot_blend)))

            # Blender does not have a tightness equivalent, 0 is most like blender default.
            tab_write("tightness 0\n")  # 0:10f

            tab_write("point_at  <0, 0, -1>\n")
            if lamp.pov.use_halo:
                tab_write("looks_like{\n")
                tab_write("sphere{<0,0,0>,%.6f\n" % lamp.distance)
                tab_write("hollow\n")
                tab_write("material{\n")
                tab_write("texture{\n")
                tab_write("pigment{rgbf<1,1,1,%.4f>}\n" % (lamp.pov.halo_intensity * 5.0))
                tab_write("}\n")
                tab_write("interior{\n")
                tab_write("media{\n")
                tab_write("emission 1\n")
                tab_write("scattering {1, 0.5}\n")
                tab_write("density{\n")
                tab_write("spherical\n")
                tab_write("color_map{\n")
                tab_write("[0.0 rgb <0,0,0>]\n")
                tab_write("[0.5 rgb <1,1,1>]\n")
                tab_write("[1.0 rgb <1,1,1>]\n")
                tab_write("}\n")
                tab_write("}\n")
                tab_write("}\n")
                tab_write("}\n")
                tab_write("}\n")
                tab_write("}\n")
                tab_write("}\n")
        elif lamp.type == 'SUN':
            tab_write("parallel\n")
            tab_write("point_at  <0, 0, -1>\n")  # *must* be after 'parallel'

        elif lamp.type == 'AREA':
            tab_write("fade_distance %.6f\n" % (lamp.distance / 2.0))
            # Area lights have no falloff type, so always use blenders lamp quad equivalent
            # for those?
            tab_write("fade_power %d\n" % 2)
            size_x = lamp.size
            samples_x = lamp.pov.shadow_ray_samples_x
            if lamp.shape == 'SQUARE':
                size_y = size_x
                samples_y = samples_x
            else:
                size_y = lamp.size_y
                samples_y = lamp.pov.shadow_ray_samples_y

            tab_write(
                "area_light <%.6f,0,0>,<0,%.6f,0> %d, %d\n" % (size_x, size_y, samples_x, samples_y)
            )
            tab_write("area_illumination\n")
            if lamp.pov.shadow_ray_sample_method == 'CONSTANT_JITTERED':
                if lamp.pov.use_jitter:
                    tab_write("jitter\n")
            else:
                tab_write("adaptive 1\n")
                tab_write("jitter\n")

        # No shadow checked either at global or light level:
        if not scene.pov.use_shadows or (lamp.pov.shadow_method == 'NOSHADOW'):
            tab_write("shadowless\n")

        # Sun shouldn't be attenuated. Area lights have no falloff attribute so they
        # are put to type 2 attenuation a little higher above.
        if lamp.type not in {'SUN', 'AREA'}:
            if lamp.falloff_type == 'INVERSE_SQUARE':
                tab_write("fade_distance %.6f\n" % (sqrt(lamp.distance / 2.0)))
                tab_write("fade_power %d\n" % 2)  # Use blenders lamp quad equivalent
            elif lamp.falloff_type == 'INVERSE_LINEAR':
                tab_write("fade_distance %.6f\n" % (lamp.distance / 2.0))
                tab_write("fade_power %d\n" % 1)  # Use blenders lamp linear
            elif lamp.falloff_type == 'CONSTANT':
                tab_write("fade_distance %.6f\n" % (lamp.distance / 2.0))
                tab_write("fade_power %d\n" % 3)
                # Use blenders lamp constant equivalent no attenuation.
            # Using Custom curve for fade power 3 for now.
            elif lamp.falloff_type == 'CUSTOM_CURVE':
                tab_write("fade_power %d\n" % 4)

        write_matrix(matrix)

        tab_write("}\n")

        exported_lights_count += 1

        # v(A,B) rotates vector A about origin by vector B.
        file.write(
            "#declare lampTarget%s= vrotate(<%.4g,%.4g,%.4g>,<%.4g,%.4g,%.4g>);\n"
            % (
                exported_lights_count,
                -(ob.location.x),
                -(ob.location.y),
                -(ob.location.z),
                ob.rotation_euler.x,
                ob.rotation_euler.y,
                ob.rotation_euler.z,
            )
        )


def export_world(world, scene, global_matrix, tab_write):
    """write world as POV backgrounbd and sky_sphere to exported file """
    render = scene.pov
    camera = scene.camera
    matrix = global_matrix @ camera.matrix_world  # view dependant for later use
    if not world:
        return
    #############Maurice####################################
    # These lines added to get sky gradient (visible with PNG output)
    if world:
        # For simple flat background:
        if not world.pov.use_sky_blend:
            # Non fully transparent background could premultiply alpha and avoid anti-aliasing
            # display issue:
            if render.alpha_mode == 'TRANSPARENT':
                tab_write(
                    "background {rgbt<%.3g, %.3g, %.3g, 0.75>}\n" % (world.pov.horizon_color[:])
                )
            # Currently using no alpha with Sky option:
            elif render.alpha_mode == 'SKY':
                tab_write("background {rgbt<%.3g, %.3g, %.3g, 0>}\n" % (world.pov.horizon_color[:]))
            # StraightAlpha:
            # XXX Does not exists anymore
            # else:
            # tab_write("background {rgbt<%.3g, %.3g, %.3g, 1>}\n" % (world.pov.horizon_color[:]))

        world_tex_count = 0
        # For Background image textures
        for t in world.pov_texture_slots:  # risk to write several sky_spheres but maybe ok.
            if t:
                tex = bpy.data.textures[t.texture]
            if tex.type is not None:
                world_tex_count += 1
                # XXX No enable checkbox for world textures yet (report it?)
                # if t and tex.type == 'IMAGE' and t.use:
                if tex.type == 'IMAGE':
                    image_filename = path_image(tex.image)
                    if tex.image.filepath != image_filename:
                        tex.image.filepath = image_filename
                    if image_filename != "" and t.use_map_blend:
                        textures_blend = image_filename
                        # colvalue = t.default_value
                        t_blend = t

                    # Commented below was an idea to make the Background image oriented as camera
                    # taken here:
                    # http://news.pov.org/pov.newusers/thread/%3Cweb.4a5cddf4e9c9822ba2f93e20@news.pov.org%3E/
                    # Replace 4/3 by the ratio of each image found by some custom or existing
                    # function
                    # mapping_blend = (" translate <%.4g,%.4g,%.4g> rotate z*degrees" \
                    #                "(atan((camLocation - camLookAt).x/(camLocation - " \
                    #                "camLookAt).y)) rotate x*degrees(atan((camLocation - " \
                    #                "camLookAt).y/(camLocation - camLookAt).z)) rotate y*" \
                    #                "degrees(atan((camLocation - camLookAt).z/(camLocation - " \
                    #                "camLookAt).x)) scale <%.4g,%.4g,%.4g>b" % \
                    #                (t_blend.offset.x / 10 , t_blend.offset.y / 10 ,
                    #                 t_blend.offset.z / 10, t_blend.scale.x ,
                    #                 t_blend.scale.y , t_blend.scale.z))
                    # using camera rotation valuesdirectly from blender seems much easier
                    if t_blend.texture_coords == 'ANGMAP':
                        mapping_blend = ""
                    else:
                        # POV-Ray "scale" is not a number of repetitions factor, but its
                        # inverse, a standard scale factor.
                        # 0.5 Offset is needed relatively to scale because center of the
                        # UV scale is 0.5,0.5 in blender and 0,0 in POV
                        # Further Scale by 2 and translate by -1 are
                        # required for the sky_sphere not to repeat

                        mapping_blend = (
                            "scale 2 scale <%.4g,%.4g,%.4g> translate -1 "
                            "translate <%.4g,%.4g,%.4g> rotate<0,0,0> "
                            % (
                                (1.0 / t_blend.scale.x),
                                (1.0 / t_blend.scale.y),
                                (1.0 / t_blend.scale.z),
                                0.5 - (0.5 / t_blend.scale.x) - t_blend.offset.x,
                                0.5 - (0.5 / t_blend.scale.y) - t_blend.offset.y,
                                t_blend.offset.z,
                            )
                        )

                        # The initial position and rotation of the pov camera is probably creating
                        # the rotation offset should look into it someday but at least background
                        # won't rotate with the camera now.
                    # Putting the map on a plane would not introduce the skysphere distortion and
                    # allow for better image scale matching but also some waay to chose depth and
                    # size of the plane relative to camera.
                    tab_write("sky_sphere {\n")
                    tab_write("pigment {\n")
                    tab_write(
                        "image_map{%s \"%s\" %s}\n"
                        % (image_format(textures_blend), textures_blend, img_map_bg(t_blend))
                    )
                    tab_write("}\n")
                    tab_write("%s\n" % (mapping_blend))
                    # The following layered pigment opacifies to black over the texture for
                    # transmit below 1 or otherwise adds to itself
                    tab_write("pigment {rgb 0 transmit %s}\n" % (tex.intensity))
                    tab_write("}\n")
                    # tab_write("scale 2\n")
                    # tab_write("translate -1\n")

        # For only Background gradient

        if world_tex_count == 0:
            if world.pov.use_sky_blend:
                tab_write("sky_sphere {\n")
                tab_write("pigment {\n")
                # maybe Should follow the advice of POV doc about replacing gradient
                # for skysphere..5.5
                tab_write("gradient y\n")
                tab_write("color_map {\n")
                # XXX Does not exists anymore
                # if render.alpha_mode == 'STRAIGHT':
                # tab_write("[0.0 rgbt<%.3g, %.3g, %.3g, 1>]\n" % (world.pov.horizon_color[:]))
                # tab_write("[1.0 rgbt<%.3g, %.3g, %.3g, 1>]\n" % (world.pov.zenith_color[:]))
                if render.alpha_mode == 'TRANSPARENT':
                    tab_write("[0.0 rgbt<%.3g, %.3g, %.3g, 0.99>]\n" % (world.pov.horizon_color[:]))
                    # aa premult not solved with transmit 1
                    tab_write("[1.0 rgbt<%.3g, %.3g, %.3g, 0.99>]\n" % (world.pov.zenith_color[:]))
                else:
                    tab_write("[0.0 rgbt<%.3g, %.3g, %.3g, 0>]\n" % (world.pov.horizon_color[:]))
                    tab_write("[1.0 rgbt<%.3g, %.3g, %.3g, 0>]\n" % (world.pov.zenith_color[:]))
                tab_write("}\n")
                tab_write("}\n")
                tab_write("}\n")
                # Sky_sphere alpha (transmit) is not translating into image alpha the same
                # way as 'background'

        # if world.pov.light_settings.use_indirect_light:
        #    scene.pov.radio_enable=1

        # Maybe change the above to a function copyInternalRenderer settings when
        # user pushes a button, then:
        # scene.pov.radio_enable = world.pov.light_settings.use_indirect_light
        # and other such translations but maybe this would not be allowed either?

    ###############################################################

    mist = world.mist_settings

    if mist.use_mist:
        tab_write("fog {\n")
        if mist.falloff == 'LINEAR':
            tab_write("distance %.6f\n" % ((mist.start + mist.depth) * 0.368))
        elif mist.falloff == 'QUADRATIC':  # n**2 or squrt(n)?
            tab_write("distance %.6f\n" % ((mist.start + mist.depth) ** 2 * 0.368))
        elif mist.falloff == 'INVERSE_QUADRATIC':  # n**2 or squrt(n)?
            tab_write("distance %.6f\n" % ((mist.start + mist.depth) ** 2 * 0.368))
        tab_write(
            "color rgbt<%.3g, %.3g, %.3g, %.3g>\n"
            % (*world.pov.horizon_color, 1.0 - mist.intensity)
        )
        # tab_write("fog_offset %.6f\n" % mist.start) #create a pov property to prepend
        # tab_write("fog_alt %.6f\n" % mist.height) #XXX right?
        # tab_write("turbulence 0.2\n")
        # tab_write("turb_depth 0.3\n")
        tab_write("fog_type 1\n")  # type2 for height
        tab_write("}\n")
    if scene.pov.media_enable:
        tab_write("media {\n")
        tab_write(
            "scattering { %d, rgb %.12f*<%.4g, %.4g, %.4g>\n"
            % (
                int(scene.pov.media_scattering_type),
                (scene.pov.media_diffusion_scale),
                *(scene.pov.media_diffusion_color[:]),
            )
        )
        if scene.pov.media_scattering_type == '5':
            tab_write("eccentricity %.3g\n" % scene.pov.media_eccentricity)
        tab_write("}\n")
        tab_write(
            "absorption %.12f*<%.4g, %.4g, %.4g>\n"
            % (scene.pov.media_absorption_scale, *(scene.pov.media_absorption_color[:]))
        )
        tab_write("\n")
        tab_write("samples %.d\n" % scene.pov.media_samples)
        tab_write("}\n")


####################################################################################################
def export_rainbows(rainbows, file, scene, global_matrix, write_matrix, tab_write):
    """write all POV rainbows primitives to exported file """
    for ob in rainbows:
        povdataname = ob.data.name  # enough? XXX not used nor matrix fn?
        angle = degrees(ob.data.spot_size / 2.5)  # radians in blender (2
        width = ob.data.spot_blend * 10
        distance = ob.data.shadow_buffer_clip_start
        # eps=0.0000001
        # angle = br/(cr+eps) * 10 #eps is small epsilon variable to avoid dividing by zero
        # width = ob.dimensions[2] #now let's say width of rainbow is the actual proxy height
        # formerly:
        # cz-bz # let's say width of the rainbow is height of the cone (interfacing choice

        # v(A,B) rotates vector A about origin by vector B.
        # and avoid a 0 length vector by adding 1

        # file.write("#declare %s_Target= vrotate(<%.6g,%.6g,%.6g>,<%.4g,%.4g,%.4g>);\n" % \
        # (povdataname, -(ob.location.x+0.1), -(ob.location.y+0.1), -(ob.location.z+0.1),
        # ob.rotation_euler.x, ob.rotation_euler.y, ob.rotation_euler.z))

        direction = (  # XXX currently not used (replaced by track to?)
            ob.location.x,
            ob.location.y,
            ob.location.z,
        )  # not taking matrix into account
        rmatrix = global_matrix @ ob.matrix_world

        # ob.rotation_euler.to_matrix().to_4x4() * mathutils.Vector((0,0,1))
        # XXX Is result of the below offset by 90 degrees?
        up = ob.matrix_world.to_3x3()[1].xyz  # * global_matrix

        # XXX TO CHANGE:
        # formerly:
        # tab_write("#declare %s = rainbow {\n"%povdataname)

        # clumsy for now but remove the rainbow from instancing
        # system because not an object. use lamps later instead of meshes

        # del data_ref[dataname]
        tab_write("rainbow {\n")

        tab_write("angle %.4f\n" % angle)
        tab_write("width %.4f\n" % width)
        tab_write("distance %.4f\n" % distance)
        tab_write("arc_angle %.4f\n" % ob.pov.arc_angle)
        tab_write("falloff_angle %.4f\n" % ob.pov.falloff_angle)
        tab_write("direction <%.4f,%.4f,%.4f>\n" % rmatrix.translation[:])
        tab_write("up <%.4f,%.4f,%.4f>\n" % (up[0], up[1], up[2]))
        tab_write("color_map {\n")
        tab_write("[0.000  color srgbt<1.0, 0.5, 1.0, 1.0>]\n")
        tab_write("[0.130  color srgbt<0.5, 0.5, 1.0, 0.9>]\n")
        tab_write("[0.298  color srgbt<0.2, 0.2, 1.0, 0.7>]\n")
        tab_write("[0.412  color srgbt<0.2, 1.0, 1.0, 0.4>]\n")
        tab_write("[0.526  color srgbt<0.2, 1.0, 0.2, 0.4>]\n")
        tab_write("[0.640  color srgbt<1.0, 1.0, 0.2, 0.4>]\n")
        tab_write("[0.754  color srgbt<1.0, 0.5, 0.2, 0.6>]\n")
        tab_write("[0.900  color srgbt<1.0, 0.2, 0.2, 0.7>]\n")
        tab_write("[1.000  color srgbt<1.0, 0.2, 0.2, 1.0>]\n")
        tab_write("}\n")

        pov_mat_name = "Default_texture"
        # tab_write("texture {%s}\n"%pov_mat_name)
        write_object_modifiers(scene, ob, file)
        # tab_write("rotate x*90\n")
        # matrix = global_matrix @ ob.matrix_world
        # write_matrix(matrix)
        tab_write("}\n")
        # continue #Don't render proxy mesh, skip to next object


def export_smoke(file, smoke_obj_name, smoke_path, comments, global_matrix, write_matrix):
    """export Blender smoke type fluids to pov media using df3 library"""

    flowtype = -1  # XXX todo: not used yet? should trigger emissive for fire type
    depsgraph = bpy.context.evaluated_depsgraph_get()
    smoke_obj = bpy.data.objects[smoke_obj_name].evaluated_get(depsgraph)
    domain = None
    smoke_modifier = None
    # Search smoke domain target for smoke modifiers
    for mod in smoke_obj.modifiers:
        if mod.type == 'FLUID':
            if mod.fluid_type == 'FLOW':
                if mod.flow_settings.flow_type == 'BOTH':
                    flowtype = 2
                else:
                    if mod.flow_settings.smoke_flow_type == 'SMOKE':
                        flowtype = 0
                    else:
                        if mod.flow_settings.smoke_flow_type == 'FIRE':
                            flowtype = 1

            if mod.fluid_type == 'DOMAIN':
                domain = smoke_obj
                smoke_modifier = mod

    eps = 0.000001  # XXX not used currently. restore from corner case ... zero div?
    if domain is not None:
        mod_set = smoke_modifier.domain_settings
        channeldata = []
        for v in mod_set.density_grid:
            channeldata.append(v.real)
            print(v.real)
        ## Usage en voxel texture:
        # channeldata = []
        # if channel == 'density':
        # for v in mod_set.density_grid:
        # channeldata.append(v.real)

        # if channel == 'fire':
        # for v in mod_set.flame_grid:
        # channeldata.append(v.real)

        resolution = mod_set.resolution_max
        big_res = []
        big_res.append(mod_set.domain_resolution[0])
        big_res.append(mod_set.domain_resolution[1])
        big_res.append(mod_set.domain_resolution[2])

        if mod_set.use_noise:
            big_res[0] = big_res[0] * (mod_set.noise_scale + 1)
            big_res[1] = big_res[1] * (mod_set.noise_scale + 1)
            big_res[2] = big_res[2] * (mod_set.noise_scale + 1)
        # else:
        # p = []
        ##gather smoke domain settings
        # BBox = domain.bound_box
        # p.append([BBox[0][0], BBox[0][1], BBox[0][2]])
        # p.append([BBox[6][0], BBox[6][1], BBox[6][2]])
        # mod_set = smoke_modifier.domain_settings
        # resolution = mod_set.resolution_max
        # smokecache = mod_set.point_cache
        # ret = read_cache(smokecache, mod_set.use_noise, mod_set.noise_scale + 1, flowtype)
        # res_x = ret[0]
        # res_y = ret[1]
        # res_z = ret[2]
        # density = ret[3]
        # fire = ret[4]

        # if res_x * res_y * res_z > 0:
        ##new cache format
        # big_res = []
        # big_res.append(res_x)
        # big_res.append(res_y)
        # big_res.append(res_z)
        # else:
        # max = domain.dimensions[0]
        # if (max - domain.dimensions[1]) < -eps:
        # max = domain.dimensions[1]

        # if (max - domain.dimensions[2]) < -eps:
        # max = domain.dimensions[2]

        # big_res = [int(round(resolution * domain.dimensions[0] / max, 0)),
        # int(round(resolution * domain.dimensions[1] / max, 0)),
        # int(round(resolution * domain.dimensions[2] / max, 0))]

        # if mod_set.use_noise:
        # big_res = [big_res[0] * (mod_set.noise_scale + 1),
        # big_res[1] * (mod_set.noise_scale + 1),
        # big_res[2] * (mod_set.noise_scale + 1)]

        # if channel == 'density':
        # channeldata = density

        # if channel == 'fire':
        # channeldata = fire

        # sc_fr = '%s/%s/%s/%05d' % (
        # efutil.export_path,
        # efutil.scene_filename(),
        # bpy.context.scene.name,
        # bpy.context.scene.frame_current
        # )
        #               if not os.path.exists( sc_fr ):
        #                   os.makedirs(sc_fr)
        #
        #               smoke_filename = '%s.smoke' % bpy.path.clean_name(domain.name)
        #               smoke_path = '/'.join([sc_fr, smoke_filename])
        #
        #               with open(smoke_path, 'wb') as smoke_file:
        #                   # Binary densitygrid file format
        #                   #
        #                   # File header
        #                   smoke_file.write(b'SMOKE')        #magic number
        #                   smoke_file.write(struct.pack('<I', big_res[0]))
        #                   smoke_file.write(struct.pack('<I', big_res[1]))
        #                   smoke_file.write(struct.pack('<I', big_res[2]))
        # Density data
        #                   smoke_file.write(struct.pack('<%df'%len(channeldata), *channeldata))
        #
        #               LuxLog('Binary SMOKE file written: %s' % (smoke_path))

        # return big_res[0], big_res[1], big_res[2], channeldata

        mydf3 = df3_library.df3(big_res[0], big_res[1], big_res[2])
        sim_sizeX, sim_sizeY, sim_sizeZ = mydf3.size()
        for x in range(sim_sizeX):
            for y in range(sim_sizeY):
                for z in range(sim_sizeZ):
                    mydf3.set(x, y, z, channeldata[((z * sim_sizeY + y) * sim_sizeX + x)])

        mydf3.exportDF3(smoke_path)
        print('Binary smoke.df3 file written in preview directory')
        if comments:
            file.write("\n//--Smoke--\n\n")

        # Note: We start with a default unit cube.
        #       This is mandatory to read correctly df3 data - otherwise we could just directly use bbox
        #       coordinates from the start, and avoid scale/translate operations at the end...
        file.write("box{<0,0,0>, <1,1,1>\n")
        file.write("    pigment{ rgbt 1 }\n")
        file.write("    hollow\n")
        file.write("    interior{ //---------------------\n")
        file.write("        media{ method 3\n")
        file.write("               emission <1,1,1>*1\n")  # 0>1 for dark smoke to white vapour
        file.write("               scattering{ 1, // Type\n")
        file.write("                  <1,1,1>*0.1\n")
        file.write("                } // end scattering\n")
        file.write("                density{density_file df3 \"%s\"\n" % (smoke_path))
        file.write("                        color_map {\n")
        file.write("                        [0.00 rgb 0]\n")
        file.write("                        [0.05 rgb 0]\n")
        file.write("                        [0.20 rgb 0.2]\n")
        file.write("                        [0.30 rgb 0.6]\n")
        file.write("                        [0.40 rgb 1]\n")
        file.write("                        [1.00 rgb 1]\n")
        file.write("                       } // end color_map\n")
        file.write("               } // end of density\n")
        file.write("               samples %i // higher = more precise\n" % resolution)
        file.write("         } // end of media --------------------------\n")
        file.write("    } // end of interior\n")

        # START OF TRANSFORMATIONS

        # Size to consider here are bbox dimensions (i.e. still in object space, *before* applying
        # loc/rot/scale and other transformations (like parent stuff), aka matrix_world).
        bbox = smoke_obj.bound_box
        dim = [
            abs(bbox[6][0] - bbox[0][0]),
            abs(bbox[6][1] - bbox[0][1]),
            abs(bbox[6][2] - bbox[0][2]),
        ]

        # We scale our cube to get its final size and shapes but still in *object* space (same as Blender's bbox).
        file.write("scale<%.6g,%.6g,%.6g>\n" % (dim[0], dim[1], dim[2]))

        # We offset our cube such that (0,0,0) coordinate matches Blender's object center.
        file.write("translate<%.6g,%.6g,%.6g>\n" % (bbox[0][0], bbox[0][1], bbox[0][2]))

        # We apply object's transformations to get final loc/rot/size in world space!
        # Note: we could combine the two previous transformations with this matrix directly...
        write_matrix(global_matrix @ smoke_obj.matrix_world)

        # END OF TRANSFORMATIONS

        file.write("}\n")

        # file.write("               interpolate 1\n")
        # file.write("               frequency 0\n")
        # file.write("   }\n")
        # file.write("}\n")


classes = ()


def register():
    for cls in classes:
        register_class(cls)


def unregister():
    for cls in classes:
        unregister_class(cls)