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

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

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

import bpy

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 voxel_lib  # for smoke rendering
from .model_primitives import write_object_modifiers


# -------- find image texture # used for export_world -------- #


def image_format(img_f):
    """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(img_f)[-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(img_f)  # 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 in ["VIEW", "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(file, 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(file, "#declare camLocation  = <%.6f, %.6f, %.6f>;\n" % matrix.translation[:])
    tab_write(
        file,
        (
            "#declare camLookAt = <%.6f, %.6f, %.6f>;\n"
            % tuple(degrees(e) for e in matrix.to_3x3().to_euler())
        ),
    )

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

    else:
        if camera.data.type == "ORTHO":
            # XXX 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(file, "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(file, "angle\n")
            tab_write(file, "right <%6f, 0, 0>\n" % -camera.data.ortho_scale)
            tab_write(file, "location  <0, 0, 0>\n")
            tab_write(file, "look_at  <0, 0, -1>\n")
            tab_write(file, "up <0, %6f, 0>\n" % (camera.data.ortho_scale / q_size))

        elif camera.data.type == "PANO":
            tab_write(file, "panoramic\n")
            tab_write(file, "location  <0, 0, 0>\n")
            tab_write(file, "look_at  <0, 0, -1>\n")
            tab_write(file, "right <%s, 0, 0>\n" % -q_size)
            tab_write(file, "up <0, 1, 0>\n")
            tab_write(file, "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(file, "location  <0, 0, 0>\n")
            tab_write(file, "look_at  <0, 0, -1>\n")
            tab_write(file, "right <%s, 0, 0>\n" % -q_size)
            tab_write(file, "up <0, 1, 0>\n")
            tab_write(
                file,
                "angle  %f\n"
                % (2 * atan(camera.data.sensor_width / 2 / camera.data.lens) * 180.0 / pi),
            )

        tab_write(
            file,
            "rotate  <%.6f, %.6f, %.6f>\n" % tuple(degrees(e) for e in matrix.to_3x3().to_euler()),
        )

        tab_write(file, "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(
                file, "aperture %.3g\n" % (1 / (camera.data.dof.aperture_fstop * 10000) * 1000)
            )
            tab_write(
                file,
                "blur_samples %d %d\n"
                % (camera.data.pov.dof_samples_min, camera.data.pov.dof_samples_max),
            )
            tab_write(file, "variance 1/%d\n" % camera.data.pov.dof_variance)
            tab_write(file, "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(file, "focal_point <%.4f,%.4f,%.4f>\n" % matrix_blur.translation[:])
            else:
                tab_write(file, "focal_point <0, 0, %f>\n" % focal_point)
    if camera.data.pov.normal_enable:
        tab_write(
            file,
            "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(file, "}\n")


exported_lights_count = 0


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

    from .render import write_matrix, tab_write

    # Incremented after each lamp export to declare its target
    # currently used for Fresnel diffuse shader as their slope vector:
    global exported_lights_count
    # Get all lamps and keep their count in a global variable
    for exported_lights_count, ob in enumerate(lamps, start=1):
        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(file, "light_source {\n")
        tab_write(file, "< 0,0,0 >\n")
        tab_write(file, "color srgb<%.3g, %.3g, %.3g>\n" % color)

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

            # Falloff is the main radius from the centre line
            tab_write(file, "falloff %.2f\n" % (degrees(lamp.spot_size) / 2.0))  # 1 TO 179 FOR BOTH
            tab_write(
                file, "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(file, "tightness 0\n")  # 0:10f

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

        elif lamp.type == "AREA":
            tab_write(file, "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(file, "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(
                file,
                "area_light <%.6f,0,0>,<0,%.6f,0> %d, %d\n"
                % (size_x, size_y, samples_x, samples_y),
            )
            tab_write(file, "area_illumination\n")
            if lamp.pov.shadow_ray_sample_method == "CONSTANT_JITTERED":
                if lamp.pov.use_jitter:
                    tab_write(file, "jitter\n")
            else:
                tab_write(file, "adaptive 1\n")
                tab_write(file, "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(file, "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(file, "fade_distance %.6f\n" % (sqrt(lamp.distance / 2.0)))
                tab_write(file, "fade_power %d\n" % 2)  # Use blenders lamp quad equivalent
            elif lamp.falloff_type == "INVERSE_LINEAR":
                tab_write(file, "fade_distance %.6f\n" % (lamp.distance / 2.0))
                tab_write(file, "fade_power %d\n" % 1)  # Use blenders lamp linear
            elif lamp.falloff_type == "CONSTANT":
                tab_write(file, "fade_distance %.6f\n" % (lamp.distance / 2.0))
                tab_write(file, "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(file, "fade_power %d\n" % 4)

        write_matrix(file, matrix)

        tab_write(file, "}\n")

        # 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(file, world, scene, global_matrix, tab_write):
    """write world as POV background and sky_sphere to exported file"""
    render = scene.pov
    agnosticrender = scene.render
    camera = scene.camera
    # matrix = global_matrix @ camera.matrix_world  # view dependant for later use NOT USED
    if not world:
        return

    # These lines added to get sky gradient (visible with PNG output)

    # For simple flat background:
    if not world.pov.use_sky_blend:
        # No alpha with Sky option:
        if render.alpha_mode == "SKY" and not agnosticrender.film_transparent:
            tab_write(
                file, "background {rgbt<%.3g, %.3g, %.3g, 0>}\n" % (world.pov.horizon_color[:])
            )

        elif render.alpha_mode == "STRAIGHT" or agnosticrender.film_transparent:
            tab_write(
                file, "background {rgbt<%.3g, %.3g, %.3g, 1>}\n" % (world.pov.horizon_color[:])
            )
        else:
            # Non fully transparent background could premultiply alpha and avoid
            # anti-aliasing display issue
            tab_write(
                file,
                "background {rgbft<%.3g, %.3g, %.3g, %.3g, 0>}\n"
                % (
                    world.pov.horizon_color[0],
                    world.pov.horizon_color[1],
                    world.pov.horizon_color[2],
                    render.alpha_filter,
                ),
            )

    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(file, "sky_sphere {\n")
                tab_write(file, "pigment {\n")
                tab_write(
                    file,
                    'image_map{%s "%s" %s}\n'
                    % (image_format(textures_blend), textures_blend, img_map_bg(t_blend)),
                )
                tab_write(file, "}\n")
                tab_write(file, "%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(file, "pigment {rgb 0 transmit %s}\n" % tex.intensity)
                tab_write(file, "}\n")
                # tab_write(file, "scale 2\n")
                # tab_write(file, "translate -1\n")

    # For only Background gradient

    if world_tex_count == 0 and world.pov.use_sky_blend:
        tab_write(file, "sky_sphere {\n")
        tab_write(file, "pigment {\n")
        # maybe Should follow the advice of POV doc about replacing gradient
        # for skysphere..5.5
        tab_write(file, "gradient y\n")
        tab_write(file, "color_map {\n")

        if render.alpha_mode == "TRANSPARENT":
            tab_write(
                file,
                "[0.0 rgbft<%.3g, %.3g, %.3g, %.3g, 0>]\n"
                % (
                    world.pov.horizon_color[0],
                    world.pov.horizon_color[1],
                    world.pov.horizon_color[2],
                    render.alpha_filter,
                ),
            )
            tab_write(
                file,
                "[1.0 rgbft<%.3g, %.3g, %.3g, %.3g, 0>]\n"
                % (
                    world.pov.zenith_color[0],
                    world.pov.zenith_color[1],
                    world.pov.zenith_color[2],
                    render.alpha_filter,
                ),
            )
        if agnosticrender.film_transparent or render.alpha_mode == "STRAIGHT":
            tab_write(file, "[0.0 rgbt<%.3g, %.3g, %.3g, 0.99>]\n" % (world.pov.horizon_color[:]))
            # aa premult not solved with transmit 1
            tab_write(file, "[1.0 rgbt<%.3g, %.3g, %.3g, 0.99>]\n" % (world.pov.zenith_color[:]))
        else:
            tab_write(file, "[0.0 rgbt<%.3g, %.3g, %.3g, 0>]\n" % (world.pov.horizon_color[:]))
            tab_write(file, "[1.0 rgbt<%.3g, %.3g, %.3g, 0>]\n" % (world.pov.zenith_color[:]))
        tab_write(file, "}\n")
        tab_write(file, "}\n")
        tab_write(file, "}\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(file, "fog {\n")
        if mist.falloff == "LINEAR":
            tab_write(file, "distance %.6f\n" % ((mist.start + mist.depth) * 0.368))
        elif mist.falloff in ["QUADRATIC", "INVERSE_QUADRATIC"]:  # n**2 or squrt(n)?
            tab_write(file, "distance %.6f\n" % ((mist.start + mist.depth) ** 2 * 0.368))
        tab_write(
            file,
            "color rgbt<%.3g, %.3g, %.3g, %.3g>\n"
            % (*world.pov.horizon_color, (1.0 - mist.intensity)),
        )
        # tab_write(file, "fog_offset %.6f\n" % mist.start) #create a pov property to prepend
        # tab_write(file, "fog_alt %.6f\n" % mist.height) #XXX right?
        # tab_write(file, "turbulence 0.2\n")
        # tab_write(file, "turb_depth 0.3\n")
        tab_write(file, "fog_type 1\n")  # type2 for height
        tab_write(file, "}\n")
    if scene.pov.media_enable:
        tab_write(file, "media {\n")
        tab_write(
            file,
            "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(file, "eccentricity %.3g\n" % scene.pov.media_eccentricity)
        tab_write(file, "}\n")
        tab_write(
            file,
            "absorption %.12f*<%.4g, %.4g, %.4g>\n"
            % (scene.pov.media_absorption_scale, *(scene.pov.media_absorption_color[:])),
        )
        tab_write(file, "\n")
        tab_write(file, "samples %.d\n" % scene.pov.media_samples)
        tab_write(file, "}\n")


# -----------------------------------------------------------------------------
def export_rainbows(rainbows, file, scene, global_matrix, tab_write):
    """write all POV rainbows primitives to exported file"""

    from .render import write_matrix, tab_write

    pov_mat_name = "Default_texture"
    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(file, "#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(file, "rainbow {\n")

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

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


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

    from .render import write_matrix, tab_write

    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 == "DOMAIN":
                domain = smoke_obj
                smoke_modifier = mod

            elif mod.fluid_type == "FLOW":
                if mod.flow_settings.flow_type == "BOTH":
                    flowtype = 2
                elif mod.flow_settings.flow_type == "FIRE":
                    flowtype = 1
                elif mod.flow_settings.flow_type == "SMOKE":
                    flowtype = 0
    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 in 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 = [
            mod_set.domain_resolution[0],
            mod_set.domain_resolution[1],
            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 = voxel_lib.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)])
        try:
            mydf3.exportDF3(smoke_path)
        except ZeroDivisionError:
            print("Show smoke simulation in 3D view before export")
        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(file, 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")
