render.py

                            tabWrite("pigment {rgbft<%.3g, %.3g, %.3g, %.3g, %.3g>}\n" % (col[0], col[1], col[2], 1.0 - material.alpha, trans))

                        if texturesSpec != "":
                            tabWrite("finish {%s}\n" % (safety(material_finish, Level=1)))  # Level 1 is no specular

                        else:
                            tabWrite("finish {%s}\n" % (safety(material_finish, Level=2)))  # Level 2 is translated spec

                    else:
                        # POV-Ray "scale" is not a number of repetitions factor, but its inverse, a standard scale factor.
                        # Offset seems needed relatively to scale so probably center of the scale is not the same in blender and POV
                        mappingDif = ("translate <%.4g,%.4g,%.4g> scale <%.4g,%.4g,%.4g>" % (-t_dif.offset.x, t_dif.offset.y, t_dif.offset.z, 1.0 / t_dif.scale.x, 1.0 / t_dif.scale.y, 1.0 / t_dif.scale.z))
                        if texturesAlpha != "":
                            # POV-Ray "scale" is not a number of repetitions factor, but its inverse, a standard scale factor.
                            # Offset seems needed relatively to scale so probably center of the scale is not the same in blender and POV
                            mappingAlpha = " translate <%.4g,%.4g,%.4g> scale <%.4g,%.4g,%.4g>" % (t_alpha.offset.x, t_alpha.offset.y, t_alpha.offset.z, 1.0 / t_alpha.scale.x, 1.0 / t_alpha.scale.y, 1.0 / t_alpha.scale.z)
                            tabWrite("pigment {\n")
                            tabWrite("pigment_pattern {\n")
                            tabWrite("uv_mapping image_map{%s \"%s\" %s}%s}\n" % (imageFormat(texturesAlpha), texturesAlpha, imgMap(t_alpha), mappingAlpha))
                            tabWrite("pigment_map {\n")
                            tabWrite("[0 color rgbft<0,0,0,1,1>]\n")
                            tabWrite("[1 uv_mapping image_map {%s \"%s\" %s} %s]\n" % (imageFormat(texturesDif), texturesDif, (imgGamma + imgMap(t_dif)), mappingDif))
                            tabWrite("}\n")
                            tabWrite("}\n")

                        else:
                            tabWrite("pigment {uv_mapping image_map {%s \"%s\" %s}%s}\n" % (imageFormat(texturesDif), texturesDif, (imgGamma + imgMap(t_dif)), mappingDif))

                        if texturesSpec != "":
                            tabWrite("finish {%s}\n" % (safety(material_finish, Level=1)))  # Level 1 is no specular

                        else:
                            tabWrite("finish {%s}\n" % (safety(material_finish, Level=2)))  # Level 2 is translated specular

                        ## scale 1 rotate y*0
                        #imageMap = ("{image_map {%s \"%s\" %s }\n" % (imageFormat(textures),textures,imgMap(t_dif)))
                        #tabWrite("uv_mapping pigment %s} %s finish {%s}\n" % (imageMap,mapping,safety(material_finish)))
                        #tabWrite("pigment {uv_mapping image_map {%s \"%s\" %s}%s} finish {%s}\n" % (imageFormat(texturesDif),texturesDif,imgMap(t_dif),mappingDif,safety(material_finish)))
                    if texturesNorm != "":
                        ## scale 1 rotate y*0
                        # POV-Ray "scale" is not a number of repetitions factor, but its inverse, a standard scale factor.
                        # Offset seems needed relatively to scale so probably center of the scale is not the same in blender and POV
                        mappingNor = " translate <%.4g,%.4g,%.4g> scale <%.4g,%.4g,%.4g>" % (-t_nor.offset.x, t_nor.offset.y, t_nor.offset.z, 1.0 / t_nor.scale.x, 1.0 / t_nor.scale.y, 1.0 / t_nor.scale.z)
                        #imageMapNor = ("{bump_map {%s \"%s\" %s mapping}" % (imageFormat(texturesNorm),texturesNorm,imgMap(t_nor)))
                        #We were not using the above maybe we should?
                        tabWrite("normal {uv_mapping bump_map {%s \"%s\" %s  bump_size %.4g }%s}\n" % (imageFormat(texturesNorm), texturesNorm, imgMap(t_nor), t_nor.normal_factor * 10, mappingNor))
                    if texturesSpec != "":
                        tabWrite("]\n")
                    ################################Second index for mapping specular max value##################################################################################################
                        tabWrite("[1 \n")

                if texturesDif == "":
                    if texturesAlpha != "":
                        # POV-Ray "scale" is not a number of repetitions factor, but its inverse, a standard scale factor.
                        # Offset seems needed relatively to scale so probably center of the scale is not the same in blender and POV
                        mappingAlpha = " translate <%.4g,%.4g,%.4g> scale <%.4g,%.4g,%.4g>\n" % (-t_alpha.offset.x, t_alpha.offset.y, t_alpha.offset.z, 1.0 / t_alpha.scale.x, 1.0 / t_alpha.scale.y, 1.0 / t_alpha.scale.z)  # strange that the translation factor for scale is not the same as for translate. ToDo: verify both matches with blender internal.
                        tabWrite("pigment {pigment_pattern {uv_mapping image_map{%s \"%s\" %s}%s}\n" % (imageFormat(texturesAlpha), texturesAlpha, imgMap(t_alpha), mappingAlpha))
                        tabWrite("pigment_map {\n")
                        tabWrite("[0 color rgbft<0,0,0,1,1>]\n")
                        tabWrite("[1 color rgbft<%.3g, %.3g, %.3g, %.3g, %.3g>]\n" % (col[0], col[1], col[2], 1.0 - material.alpha, trans))
                        tabWrite("}\n")
                        tabWrite("}\n")

                    else:
                        tabWrite("pigment {rgbft<%.3g, %.3g, %.3g, %.3g, %.3g>}\n" % (col[0], col[1], col[2], 1.0 - material.alpha, trans))

                    if texturesSpec != "":
                        tabWrite("finish {%s}\n" % (safety(material_finish, Level=3)))  # Level 3 is full specular

                    else:
                        tabWrite("finish {%s}\n" % (safety(material_finish, Level=2)))  # Level 2 is translated specular

                else:
                    # POV-Ray "scale" is not a number of repetitions factor, but its inverse, a standard scale factor.
                    # Offset seems needed relatively to scale so probably center of the scale is not the same in blender and POV
                    mappingDif = ("translate <%.4g,%.4g,%.4g> scale <%.4g,%.4g,%.4g>" % (-t_dif.offset.x, t_dif.offset.y, t_dif.offset.z, 1.0 / t_dif.scale.x, 1.0 / t_dif.scale.y, 1.0 / t_dif.scale.z))  # strange that the translation factor for scale is not the same as for translate. ToDo: verify both matches with blender internal.
                    if texturesAlpha != "":
                        mappingAlpha = "translate <%.4g,%.4g,%.4g> scale <%.4g,%.4g,%.4g>" % (-t_alpha.offset.x, t_alpha.offset.y, t_alpha.offset.z, 1.0 / t_alpha.scale.x, 1.0 / t_alpha.scale.y, 1.0 / t_alpha.scale.z)  # strange that the translation factor for scale is not the same as for translate. ToDo: verify both matches with blender internal.
                        tabWrite("pigment {pigment_pattern {uv_mapping image_map{%s \"%s\" %s}%s}\n" % (imageFormat(texturesAlpha), texturesAlpha, imgMap(t_alpha), mappingAlpha))
                        tabWrite("pigment_map {\n")
                        tabWrite("[0 color rgbft<0,0,0,1,1>]\n")
                        tabWrite("[1 uv_mapping image_map {%s \"%s\" %s} %s]\n" % (imageFormat(texturesDif), texturesDif, (imgMap(t_dif) + imgGamma), mappingDif))
                        tabWrite("}\n")
                        tabWrite("}\n")

                    else:
                        tabWrite("pigment {\n")
                        tabWrite("uv_mapping image_map {\n")
                        #tabWrite("%s \"%s\" %s}%s\n" % (imageFormat(texturesDif),texturesDif,(imgGamma + imgMap(t_dif)),mappingDif))
                        tabWrite("%s \"%s\" \n" % (imageFormat(texturesDif), texturesDif))
                        tabWrite("%s\n" % (imgGamma + imgMap(t_dif)))
                        tabWrite("}\n")
                        tabWrite("%s\n" % mappingDif)
                        tabWrite("}\n")
                    if texturesSpec != "":
                        tabWrite("finish {%s}\n" % (safety(material_finish, Level=3)))  # Level 3 is full specular
                    else:
                        tabWrite("finish {%s}\n" % (safety(material_finish, Level=2)))  # Level 2 is translated specular

                    ## scale 1 rotate y*0
                    #imageMap = ("{image_map {%s \"%s\" %s }" % (imageFormat(textures),textures,imgMap(t_dif)))
                    #file.write("\n\t\t\tuv_mapping pigment %s} %s finish {%s}" % (imageMap,mapping,safety(material_finish)))
                    #file.write("\n\t\t\tpigment {uv_mapping image_map {%s \"%s\" %s}%s} finish {%s}" % (imageFormat(texturesDif),texturesDif,imgMap(t_dif),mappingDif,safety(material_finish)))
                if texturesNorm != "":
                    ## scale 1 rotate y*0
                    # POV-Ray "scale" is not a number of repetitions factor, but its inverse, a standard scale factor.
                    # Offset seems needed relatively to scale so probably center of the scale is not the same in blender and POV
                    mappingNor = (" translate <%.4g,%.4g,%.4g> scale <%.4g,%.4g,%.4g>" % (-t_nor.offset.x, t_nor.offset.y, t_nor.offset.z, 1.0 / t_nor.scale.x, 1.0 / t_nor.scale.y, 1.0 / t_nor.scale.z))
                    #imageMapNor = ("{bump_map {%s \"%s\" %s mapping}" % (imageFormat(texturesNorm),texturesNorm,imgMap(t_nor)))
                    #We were not using the above maybe we should?
                    tabWrite("normal {uv_mapping bump_map {%s \"%s\" %s  bump_size %.4g }%s}\n" % (imageFormat(texturesNorm), texturesNorm, imgMap(t_nor), t_nor.normal_factor * 10.0, mappingNor))
                if texturesSpec != "":
                    tabWrite("]\n")

                    tabWrite("}\n")

                #End of slope/ior texture_map
                if material.diffuse_shader in ('MINNAERT', 'FRESNEL'):
                    tabWrite("]\n")
                    tabWrite("}\n")
                tabWrite("}\n")  # THEN IT CAN CLOSE IT   --MR

                ############################################################################################################
                index[0] = idx
                idx += 1

            tabWrite("}\n")

            # Face indices
            tabWrite("face_indices {\n")
            tabWrite("%d" % (len(me_faces) + quadCount))  # faces count
            for fi, f in enumerate(me_faces):
                fv = faces_verts[fi]
                material_index = f.material_index
                if len(fv) == 4:
                    indices = (0, 1, 2), (0, 2, 3)
                else:
                    indices = ((0, 1, 2),)

                if vcol_layer:
                    col = vcol_layer[fi]

                    if len(fv) == 4:
                        cols = col.color1, col.color2, col.color3, col.color4
                    else:
                        cols = col.color1, col.color2, col.color3

                if not me_materials or me_materials[material_index] is None:  # No materials
                    for i1, i2, i3 in indices:
                        file.write(",\n")
                        tabWrite("<%d,%d,%d>" % (fv[i1], fv[i2], fv[i3]))  # vert count
                else:
                    material = me_materials[material_index]
                    for i1, i2, i3 in indices:
                        if me.vertex_colors and material.use_vertex_color_paint:
                            # Colour per vertex - vertex colour

                            col1 = cols[i1]
                            col2 = cols[i2]
                            col3 = cols[i3]

                            ci1 = vertCols[col1[0], col1[1], col1[2], material_index][0]
                            ci2 = vertCols[col2[0], col2[1], col2[2], material_index][0]
                            ci3 = vertCols[col3[0], col3[1], col3[2], material_index][0]
                        else:
                            # Colour per material - flat material colour
                            diffuse_color = material.diffuse_color
                            ci1 = ci2 = ci3 = vertCols[diffuse_color[0], diffuse_color[1], diffuse_color[2], f.material_index][0]

                        file.write(",\n")
                        tabWrite("<%d,%d,%d>, %d,%d,%d" % (fv[i1], fv[i2], fv[i3], ci1, ci2, ci3))  # vert count

            file.write("\n")
            tabWrite("}\n")

            # normal_indices indices
            tabWrite("normal_indices {\n")
            tabWrite("%d" % (len(me_faces) + quadCount))  # faces count
            for fi, fv in enumerate(faces_verts):

                if len(fv) == 4:
                    indices = (0, 1, 2), (0, 2, 3)
                else:
                    indices = ((0, 1, 2),)

                for i1, i2, i3 in indices:
                    if me_faces[fi].use_smooth:
                        file.write(",\n")
                        tabWrite("<%d,%d,%d>" %\
                        (uniqueNormals[verts_normals[fv[i1]]][0],\
                         uniqueNormals[verts_normals[fv[i2]]][0],\
                         uniqueNormals[verts_normals[fv[i3]]][0]))  # vert count
                    else:
                        idx = uniqueNormals[faces_normals[fi]][0]
                        file.write(",\n")
                        tabWrite("<%d,%d,%d>" % (idx, idx, idx))  # vert count

            file.write("\n")
            tabWrite("}\n")

            if uv_layer:
                tabWrite("uv_indices {\n")
                tabWrite("%d" % (len(me_faces) + quadCount))  # faces count
                for fi, fv in enumerate(faces_verts):

                    if len(fv) == 4:
                        indices = (0, 1, 2), (0, 2, 3)
                    else:
                        indices = ((0, 1, 2),)

                    uv = uv_layer[fi]
                    if len(faces_verts[fi]) == 4:
                        uvs = uv.uv1[:], uv.uv2[:], uv.uv3[:], uv.uv4[:]
                    else:
                        uvs = uv.uv1[:], uv.uv2[:], uv.uv3[:]

                    for i1, i2, i3 in indices:
                        file.write(",\n")
                        tabWrite("<%d,%d,%d>" % (
                                 uniqueUVs[uvs[i1]][0],\
                                 uniqueUVs[uvs[i2]][0],\
                                 uniqueUVs[uvs[i3]][0],
                                ))

                file.write("\n")
                tabWrite("}\n")

            if me.materials:
                try:
                    material = me.materials[0]  # dodgy
                    writeObjectMaterial(material)
                except IndexError:
                    print(me)

            writeMatrix(matrix)

            #Importance for radiosity sampling added here:
            tabWrite("radiosity { \n")
            tabWrite("importance %3g \n" % importance)
            tabWrite("}\n")

            tabWrite("}\n")  # End of mesh block
            tabWrite("%s\n" % name)  # Use named declaration to allow reference e.g. for baking. MR

            bpy.data.meshes.remove(me)

    def exportWorld(world):
        render = scene.render
        camera = scene.camera
        matrix = global_matrix * camera.matrix_world
        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.use_sky_blend:
                #Non fully transparent background could premultiply alpha and avoid anti-aliasing display issue:
                if render.alpha_mode == 'PREMUL':
                    tabWrite("background {rgbt<%.3g, %.3g, %.3g, 0.75>}\n" % (world.horizon_color[:]))
                #Currently using no alpha with Sky option:
                elif render.alpha_mode == 'SKY':
                    tabWrite("background {rgbt<%.3g, %.3g, %.3g, 0>}\n" % (world.horizon_color[:]))
                #StraightAlpha:
                else:
                    tabWrite("background {rgbt<%.3g, %.3g, %.3g, 1>}\n" % (world.horizon_color[:]))

            worldTexCount = 0
            #For Background image textures
            for t in world.texture_slots:  # risk to write several sky_spheres but maybe ok.
                if t and t.texture.type is not None:
                    worldTexCount += 1
                if t and t.texture.type == 'IMAGE':  # and t.use: #No enable checkbox for world textures yet (report it?)
                    image_filename = path_image(t.texture.image.filepath)
                    if t.texture.image.filepath != image_filename:
                        t.texture.image.filepath = image_filename
                    if image_filename != "" and t.use_map_blend:
                        texturesBlend = 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.povray.org/povray.newusers/thread/%3Cweb.4a5cddf4e9c9822ba2f93e20@news.povray.org%3E/
                    #mappingBlend = (" 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))#replace 4/3 by the ratio of each image found by some custom or existing function
                    #using camera rotation valuesdirectly from blender seems much easier
                    if t_blend.texture_coords == 'ANGMAP':
                        mappingBlend = ""
                    else:
                        mappingBlend = " translate <%.4g-0.5,%.4g-0.5,%.4g-0.5> rotate<0,0,0>  scale <%.4g,%.4g,%.4g>" % (
                                       t_blend.offset.x / 10.0, t_blend.offset.y / 10.0, t_blend.offset.z / 10.0,
                                       t_blend.scale.x * 0.85, t_blend.scale.y * 0.85, t_blend.scale.z * 0.85,
                                       )

                        #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.
                    tabWrite("sky_sphere {\n")
                    tabWrite("pigment {\n")
                    tabWrite("image_map{%s \"%s\" %s}\n" % (imageFormat(texturesBlend), texturesBlend, imgMapBG(t_blend)))
                    tabWrite("}\n")
                    tabWrite("%s\n" % (mappingBlend))
                    tabWrite("}\n")
                    #tabWrite("scale 2\n")
                    #tabWrite("translate -1\n")

            #For only Background gradient

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

            #if world.light_settings.use_indirect_light:
            #    scene.pov_radio_enable=1

            #Maybe change the above to a funtion copyInternalRenderer settings when user pushes a button, then:
            #scene.pov_radio_enable = world.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:
            tabWrite("fog {\n")
            tabWrite("distance %.6f\n" % mist.depth)
            tabWrite("color rgbt<%.3g, %.3g, %.3g, %.3g>\n" % (world.horizon_color[:] + (1.0 - mist.intensity,)))
            #tabWrite("fog_offset %.6f\n" % mist.start)
            #tabWrite("fog_alt 5\n")
            #tabWrite("turbulence 0.2\n")
            #tabWrite("turb_depth 0.3\n")
            tabWrite("fog_type 1\n")
            tabWrite("}\n")
        if scene.pov_media_enable:
            tabWrite("media {\n")
            tabWrite("scattering { 1, rgb %.3g}\n" % scene.pov_media_color)
            tabWrite("samples %.d\n" % scene.pov_media_samples)
            tabWrite("}\n")

    def exportGlobalSettings(scene):

        tabWrite("global_settings {\n")
        tabWrite("assumed_gamma 1.0\n")
        tabWrite("max_trace_level %d\n" % scene.pov_max_trace_level)

        if scene.pov_radio_enable:
            tabWrite("radiosity {\n")
            tabWrite("adc_bailout %.4g\n" % scene.pov_radio_adc_bailout)
            tabWrite("always_sample %d\n" % scene.pov_radio_always_sample)
            tabWrite("brightness %.4g\n" % scene.pov_radio_brightness)
            tabWrite("count %d\n" % scene.pov_radio_count)
            tabWrite("error_bound %.4g\n" % scene.pov_radio_error_bound)
            tabWrite("gray_threshold %.4g\n" % scene.pov_radio_gray_threshold)
            tabWrite("low_error_factor %.4g\n" % scene.pov_radio_low_error_factor)
            tabWrite("media %d\n" % scene.pov_radio_media)
            tabWrite("minimum_reuse %.4g\n" % scene.pov_radio_minimum_reuse)
            tabWrite("nearest_count %d\n" % scene.pov_radio_nearest_count)
            tabWrite("normal %d\n" % scene.pov_radio_normal)
            tabWrite("pretrace_start %.3g\n" % scene.pov_radio_pretrace_start)
            tabWrite("pretrace_end %.3g\n" % scene.pov_radio_pretrace_end)
            tabWrite("recursion_limit %d\n" % scene.pov_radio_recursion_limit)
            tabWrite("}\n")
        once = 1
        for material in bpy.data.materials:
            if material.subsurface_scattering.use and once:
                tabWrite("mm_per_unit %.6f\n" % (material.subsurface_scattering.scale * (-100.0) + 15.0))  # In pov, the scale has reversed influence compared to blender. these number should correct that
                once = 0  # In POV-Ray, the scale factor for all subsurface shaders needs to be the same

        if world:
            tabWrite("ambient_light rgb<%.3g, %.3g, %.3g>\n" % world.ambient_color[:])

        if material.pov_photons_refraction or material.pov_photons_reflection:
            tabWrite("photons {\n")
            tabWrite("spacing 0.003\n")
            tabWrite("max_trace_level 5\n")
            tabWrite("adc_bailout 0.1\n")
            tabWrite("gather 30, 150\n")
            tabWrite("}\n")

        tabWrite("}\n")

    sel = scene.objects
    comments = scene.pov_comments_enable
    if comments:
        file.write("//---------------------------------------------\n//--Exported with POV-Ray exporter for Blender--\n//---------------------------------------------\n\n")

    file.write("#version 3.7;\n")

    if comments:
        file.write("\n//--Global settings and background--\n\n")

    exportGlobalSettings(scene)

    if comments:
        file.write("\n")

    exportWorld(scene.world)

    if comments:
        file.write("\n//--Cameras--\n\n")

    exportCamera()

    if comments:
        file.write("\n//--Lamps--\n\n")

    exportLamps([l for l in sel if l.type == 'LAMP'])

    if comments:
        file.write("\n//--Material Definitions--\n\n")

    # Convert all materials to strings we can access directly per vertex.
    #exportMaterials()
    writeMaterial(None)  # default material
    for material in bpy.data.materials:
        if material.users > 0:
            writeMaterial(material)
    if comments:
        file.write("\n")

    exportMeta([l for l in sel if l.type == 'META'])

    if comments:
        file.write("//--Mesh objects--\n")

    exportMeshs(scene, sel)
    #What follow used to happen here:
    #exportCamera()
    #exportWorld(scene.world)
    #exportGlobalSettings(scene)
    # MR:..and the order was important for an attempt to implement pov 3.7 baking (mesh camera) comment for the record
    # CR: Baking should be a special case than. If "baking", than we could change the order.

    #print("pov file closed %s" % file.closed)
    file.close()
    #print("pov file closed %s" % file.closed)


def write_pov_ini(filename_ini, filename_pov, filename_image):
    scene = bpy.data.scenes[0]
    render = scene.render

    x = int(render.resolution_x * render.resolution_percentage * 0.01)
    y = int(render.resolution_y * render.resolution_percentage * 0.01)

    file = open(filename_ini.name, "w")
    file.write("Version=3.7\n")
    file.write("Input_File_Name='%s'\n" % filename_pov.name)
    file.write("Output_File_Name='%s'\n" % filename_image.name)

    file.write("Width=%d\n" % x)
    file.write("Height=%d\n" % y)

    # Needed for border render.
    '''
    file.write("Start_Column=%d\n" % part.x)
    file.write("End_Column=%d\n" % (part.x+part.w))

    file.write("Start_Row=%d\n" % (part.y))
    file.write("End_Row=%d\n" % (part.y+part.h))
    '''

    file.write("Bounding_Method=2\n")  # The new automatic BSP is faster in most scenes

    file.write("Display=1\n")  # Activated (turn this back off when better live exchange is done between the two programs (see next comment)
    file.write("Pause_When_Done=0\n")
    file.write("Output_File_Type=N\n")  # PNG, with POV-Ray 3.7, can show background color with alpha. In the long run using the POV-Ray interactive preview like bishop 3D could solve the preview for all formats.
    #file.write("Output_File_Type=T\n") # TGA, best progressive loading
    file.write("Output_Alpha=1\n")

    if scene.pov_antialias_enable:
        # aa_mapping = {"5": 2, "8": 3, "11": 4, "16": 5} # method 2 (recursive) with higher max subdiv forced because no mipmapping in POV-Ray needs higher sampling.
        method = {"0": 1, "1": 2}
        file.write("Antialias=on\n")
        file.write("Sampling_Method=%s\n" % method[scene.pov_antialias_method])
        file.write("Antialias_Depth=%d\n" % scene.pov_antialias_depth)
        file.write("Antialias_Threshold=%.3g\n" % scene.pov_antialias_threshold)
        file.write("Antialias_Gamma=%.3g\n" % scene.pov_antialias_gamma)
        if scene.pov_jitter_enable:
            file.write("Jitter=on\n")
            file.write("Jitter_Amount=%3g\n" % scene.pov_jitter_amount)
        else:
            file.write("Jitter=off\n")  # prevent animation flicker

    else:
        file.write("Antialias=off\n")
    #print("ini file closed %s" % file.closed)
    file.close()
    #print("ini file closed %s" % file.closed)


class PovrayRender(bpy.types.RenderEngine):
    bl_idname = 'POVRAY_RENDER'
    bl_label = "POV-Ray 3.7"
    DELAY = 0.5

    def _export(self, scene):
        import tempfile

        # mktemp is Deprecated since version 2.3, replaced with NamedTemporaryFile() #CR
        self._temp_file_in = tempfile.NamedTemporaryFile(suffix=".pov", delete=False)
        self._temp_file_out = tempfile.NamedTemporaryFile(suffix=".png", delete=False)  # PNG with POV 3.7, can show the background color with alpha. In the long run using the POV-Ray interactive preview like bishop 3D could solve the preview for all formats.
        #self._temp_file_out = tempfile.NamedTemporaryFile(suffix=".tga", delete=False)
        self._temp_file_ini = tempfile.NamedTemporaryFile(suffix=".ini", delete=False)
        '''
        self._temp_file_in = "/test.pov"
        self._temp_file_out = "/test.png"  # PNG with POV-Ray 3.7, can show the background color with alpha. In the long run using the POV-Ray interactive preview like bishop 3D could solve the preview for all formats.
        #self._temp_file_out = "/test.tga"
        self._temp_file_ini = "/test.ini"
        '''

        def info_callback(txt):
            self.update_stats("", "POV-Ray 3.7: " + txt)

        write_pov(self._temp_file_in, scene, info_callback)

    def _render(self, scene):

        try:
            os.remove(self._temp_file_out.name)  # so as not to load the old file
        except OSError:
            pass

        write_pov_ini(self._temp_file_ini, self._temp_file_in, self._temp_file_out)

        print ("***-STARTING-***")

        pov_binary = "povray"

        extra_args = []

        if scene.pov_command_line_switches != "":
            for newArg in scene.pov_command_line_switches.split(" "):
                extra_args.append(newArg)

        if sys.platform == "win32":
            import winreg
            regKey = winreg.OpenKey(winreg.HKEY_CURRENT_USER, "Software\\POV-Ray\\v3.7\\Windows")

            #64 bits blender
            if bitness == 64:
                try:
                    pov_binary = winreg.QueryValueEx(regKey, "Home")[0] + "\\bin\\pvengine64"
                except OSError:
                    # someone might run povray 32 bits on a 64 bits blender machine
                    try:
                        pov_binary = winreg.QueryValueEx(regKey, "Home")[0] + "\\bin\\pvengine"
                    except OSError:
                        print("POV-Ray 3.7: could not execute '%s', possibly POV-Ray isn't installed" % pov_binary)
                    else:
                        print("POV-Ray 3.7 64 bits could not execute, running 32 bits instead")
                else:
                    print("POV-Ray 3.7 64 bits found")

            #32 bits blender
            else:
                try:
                    pov_binary = winreg.QueryValueEx(regKey, "Home")[0] + "\\bin\\pvengine"
                # someone might also run povray 64 bits with a 32 bits build of blender.
                except OSError:
                    try:
                        pov_binary = winreg.QueryValueEx(regKey, "Home")[0] + "\\bin\\pvengine64"
                    except OSError:
                        print("POV-Ray 3.7: could not execute '%s', possibly POV-Ray isn't installed" % pov_binary)
                    else:
                        print("Running POV-Ray 3.7 64 bits build with 32 bits Blender, \nYou might want to run Blender 64 bits as well.")
                else:
                    print("POV-Ray 3.7 32 bits found")

        else:
            # DH - added -d option to prevent render window popup which leads to segfault on linux
            extra_args.append("-d")

        # print("Extra Args: " + str(extra_args))

        if 1:
            # TODO, when POV-Ray isn't found this gives a cryptic error, would be nice to be able to detect if it exists
            try:
                self._process = subprocess.Popen([pov_binary, self._temp_file_ini.name] + extra_args)  # stdout=subprocess.PIPE, stderr=subprocess.PIPE
            except OSError:
                # TODO, report api
                print("POV-Ray 3.7: could not execute '%s', possibly POV-Ray isn't installed" % pov_binary)
                import traceback
                traceback.print_exc()
                print ("***-DONE-***")
                return False

        else:
            # This works too but means we have to wait until its done
            os.system("%s %s" % (pov_binary, self._temp_file_ini.name))

        # print ("***-DONE-***")
        return True

    def _cleanup(self):
        for f in (self._temp_file_in, self._temp_file_ini, self._temp_file_out):
            #print("Name: %s" % f.name)
            #print("File closed %s" % f.closed)
            f.close()  # Why do I have to close them again? Without closeing the pov and ini files are not deletable. PNG is not closable!
            try:
                os.unlink(f.name)
                #os.remove(f.name)
            except OSError:  # was that the proper error type?
                #print("Couldn\'t remove/unlink TEMP file %s" % f.name)
                pass
            #print("")

        self.update_stats("", "")

    def render(self, scene):

        self.update_stats("", "POV-Ray 3.7: Exporting data from Blender")
        self._export(scene)
        self.update_stats("", "POV-Ray 3.7: Parsing File")

        if not self._render(scene):
            self.update_stats("", "POV-Ray 3.7: Not found")
            return

        r = scene.render
##WIP output format
##        if r.file_format == 'OPENEXR':
##            fformat = 'EXR'
##            render.color_mode = 'RGBA'
##        else:
##            fformat = 'TGA'
##            r.file_format = 'TARGA'
##            r.color_mode = 'RGBA'

        # compute resolution
        x = int(r.resolution_x * r.resolution_percentage * 0.01)
        y = int(r.resolution_y * r.resolution_percentage * 0.01)

        # Wait for the file to be created
        while not os.path.exists(self._temp_file_out.name):
            # print("***POV WAITING FOR FILE***")
            if self.test_break():
                try:
                    self._process.terminate()
                    print("***POV INTERRUPTED***")
                except OSError:
                    pass
                break

            poll_result = self._process.poll()
            if poll_result is not None:
                print("***POV PROCESS FAILED : %s ***" % poll_result)
                self.update_stats("", "POV-Ray 3.7: Failed")
                break

            time.sleep(self.DELAY)

        if os.path.exists(self._temp_file_out.name):
            # print("***POV FILE OK***")
            self.update_stats("", "POV-Ray 3.7: Rendering")

            prev_size = -1

            def update_image():
                # print("***POV UPDATING IMAGE***")
                result = self.begin_result(0, 0, x, y)
                lay = result.layers[0]
                # possible the image wont load early on.
                try:
                    lay.load_from_file(self._temp_file_out.name)
                except SystemError:
                    pass
                self.end_result(result)

            # Update while POV-Ray renders
            while True:
                # print("***POV RENDER LOOP***")

                # test if POV-Ray exists
                if self._process.poll() is not None:
                    print("***POV PROCESS FINISHED***")
                    update_image()
                    break

                # user exit
                if self.test_break():
                    try:
                        self._process.terminate()
                        print("***POV PROCESS INTERRUPTED***")
                    except OSError:
                        pass

                    break

                # Would be nice to redirect the output
                # stdout_value, stderr_value = self._process.communicate() # locks

                # check if the file updated
                new_size = os.path.getsize(self._temp_file_out.name)

                if new_size != prev_size:
                    update_image()
                    prev_size = new_size

                time.sleep(self.DELAY)
        else:
            print("***POV FILE NOT FOUND***")

        print("***POV FINISHED***")
        #time.sleep(self.DELAY)
        self._cleanup()