render.py

                                                #textNormName=t.texture.image.name + ".normal"
                                                #was the above used? --MR
                                                t_nor = t
                                            if t.use_map_alpha:
                                                texturesAlpha = image_filename
                                                # colvalue = t.alpha_factor * 10.0  # UNUSED
                                                #textDispName=t.texture.image.name + ".displ"
                                                #was the above used? --MR
                                                t_alpha = t

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


                                file.write("\n")
                                # THIS AREA NEEDS TO LEAVE THE TEXTURE OPEN UNTIL ALL MAPS ARE WRITTEN DOWN.
                                # --MR
                                currentMatName = string_strip_hyphen(materialNames[mater.name])
                                LocalMaterialNames.append(currentMatName)
                                file.write("\n #declare MAT_%s = \ntexture{\n" % currentMatName)

                                ################################################################################
                                
                                if mater.pov.replacement_text != "":
                                    file.write("%s\n" % mater.pov.replacement_text)
                                #################################################################################
                                if mater.diffuse_shader == 'MINNAERT':
                                    tabWrite("\n")
                                    tabWrite("aoi\n")
                                    tabWrite("texture_map {\n")
                                    tabWrite("[%.3g finish {diffuse %.3g}]\n" % \
                                             (mater.darkness / 2.0, 2.0 - mater.darkness))
                                    tabWrite("[%.3g\n" % (1.0 - (mater.darkness / 2.0)))

                                if mater.diffuse_shader == 'FRESNEL':
                                    # For FRESNEL diffuse in POV, we'll layer slope patterned textures
                                    # with lamp vector as the slope vector and nest one slope per lamp
                                    # into each texture map's entry.

                                    c = 1
                                    while (c <= lampCount):
                                        tabWrite("slope { lampTarget%s }\n" % (c))
                                        tabWrite("texture_map {\n")
                                        # Diffuse Fresnel value and factor go up to five,
                                        # other kind of values needed: used the number 5 below to remap
                                        tabWrite("[%.3g finish {diffuse %.3g}]\n" % \
                                                 ((5.0 - mater.diffuse_fresnel) / 5,
                                                  (mater.diffuse_intensity *
                                                   ((5.0 - mater.diffuse_fresnel_factor) / 5))))
                                        tabWrite("[%.3g\n" % ((mater.diffuse_fresnel_factor / 5) *
                                                              (mater.diffuse_fresnel / 5.0)))
                                        c += 1

                                # if shader is a 'FRESNEL' or 'MINNAERT': slope pigment pattern or aoi
                                # and texture map above, the rest below as one of its entry

                                if texturesSpec != "" or texturesAlpha != "":
                                    if texturesSpec != "":
                                        # tabWrite("\n")
                                        tabWrite("pigment_pattern {\n")
                                        if texturesSpec and texturesSpec.startswith("PAT_"):
                                            tabWrite("function{f%s(x,y,z).grey}" %texturesSpec) 
                                        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
                                            mappingSpec =imgMapTransforms(t_spec)
                                            # mappingSpec = "translate <%.4g,%.4g,%.4g> scale <%.4g,%.4g,%.4g>\n" % \
                                                          # (-t_spec.offset.x, t_spec.offset.y, t_spec.offset.z,
                                                           # 1.0 / t_spec.scale.x, 1.0 / t_spec.scale.y,
                                                           # 1.0 / t_spec.scale.z)
                                            tabWrite("uv_mapping image_map{%s \"%s\" %s}\n" % \
                                                     (imageFormat(texturesSpec), texturesSpec, imgMap(t_spec)))
                                            tabWrite("%s\n" % mappingSpec)
                                        tabWrite("}\n")
                                        tabWrite("texture_map {\n")
                                        tabWrite("[0 \n")

                                    if texturesDif == "":
                                        if texturesAlpha != "":
                                            tabWrite("\n")
                                            if texturesAlpha and texturesAlpha.startswith("PAT_"):
                                                tabWrite("function{f%s(x,y,z).transmit}\n" %texturesAlpha) 
                                            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
                                                mappingAlpha = imgMapTransforms(t_alpha)
                                                # 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)
                                                tabWrite("pigment {pigment_pattern {uv_mapping image_map" \
                                                         "{%s \"%s\" %s}%s" % \
                                                         (imageFormat(texturesAlpha), texturesAlpha,
                                                          imgMap(t_alpha), mappingAlpha))
                                            tabWrite("}\n")
                                            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], povFilter, trans))
                                            tabWrite("}\n")
                                            tabWrite("}\n")

                                        else:

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

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

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

                                    else:
                                        mappingDif = imgMapTransforms(t_dif)

                                        if texturesAlpha != "":
                                            mappingAlpha = imgMapTransforms(t_alpha)
                                            # 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")
                                            if texturesAlpha and texturesAlpha.startswith("PAT_"):
                                                tabWrite("function{f%s(x,y,z).transmit}\n" %texturesAlpha) 
                                            else:
                                                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")
                                            #if texturesAlpha and texturesAlpha.startswith("PAT_"):
                                                #tabWrite("[1 pigment{%s}]\n" %texturesDif) 
                                            if texturesDif and not texturesDif.startswith("PAT_"):
                                                tabWrite("[1 uv_mapping image_map {%s \"%s\" %s} %s]\n" % \
                                                         (imageFormat(texturesDif), texturesDif,
                                                          (imgGamma + imgMap(t_dif)), mappingDif))
                                            elif texturesDif and texturesDif.startswith("PAT_"):
                                                tabWrite("[1 %s]\n" %texturesDif)                                                          
                                            tabWrite("}\n")
                                            tabWrite("}\n")
                                            if texturesAlpha and texturesAlpha.startswith("PAT_"):
                                                tabWrite("}\n")

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

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

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

                                        ## 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 =imgMapTransforms(t_nor)
                                        # 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?
                                        if texturesNorm and texturesNorm.startswith("PAT_"):
                                            tabWrite("normal{function{f%s(x,y,z).grey} bump_size %.4g}\n" %(texturesNorm, t_nor.normal_factor * 10)) 
                                        else:
                                            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 == "" and mater.pov.replacement_text == "":
                                    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
                                        # Strange that the translation factor for scale is not the same as for
                                        # translate.
                                        # TODO: verify both matches with blender internal.
                                        mappingAlpha = imgMapTransforms(t_alpha)
                                        # 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)
                                        if texturesAlpha and texturesAlpha.startswith("PAT_"):
                                            tabWrite("function{f%s(x,y,z).transmit}\n" %texturesAlpha) 
                                        else:
                                            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], povFilter, trans))
                                        tabWrite("}\n")
                                        tabWrite("}\n")

                                    else:
                                        tabWrite("pigment {rgbft<%.3g, %.3g, %.3g, %.3g, %.3g>}\n" % \
                                                 (col[0], col[1], col[2], povFilter, trans))
                                                 
                                                                
                                    if texturesSpec != "":
                                        # Level 3 is full specular
                                        tabWrite("finish {%s}\n" % (safety(material_finish, Level=3)))
                                        
                                    elif colored_specular_found:
                                        # Level 1 is no specular
                                        tabWrite("finish {%s}\n" % (safety(material_finish, Level=1)))

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

                                elif mater.pov.replacement_text == "":
                                    mappingDif = imgMapTransforms(t_dif)
                                    # mappingDif = ("scale <%.4g,%.4g,%.4g> translate <%.4g,%.4g,%.4g>" % \
                                                  # ( 1.0 / t_dif.scale.x, 
                                                  # 1.0 / t_dif.scale.y,
                                                  # 1.0 / t_dif.scale.z, 
                                                  # 0.5-(0.5/t_dif.scale.x) + t_dif.offset.x,
                                                  # 0.5-(0.5/t_dif.scale.y) + t_dif.offset.y,
                                                  # 0.5-(0.5/t_dif.scale.z) + t_dif.offset.z))
                                    if texturesAlpha != "":
                                        # Strange that the translation factor for scale is not the same as for
                                        # translate.
                                        # TODO: verify both matches with blender internal.
                                        mappingAlpha = imgMapTransforms(t_alpha)
                                        # 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)
                                        if texturesAlpha and texturesAlpha.startswith("PAT_"):
                                            tabWrite("pigment{pigment_pattern {function{f%s(x,y,z).transmit}}\n" %texturesAlpha)
                                        else:
                                            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")
                                        if texturesAlpha and texturesAlpha.startswith("PAT_"):
                                            tabWrite("[1 function{f%s(x,y,z).transmit}]\n" %texturesAlpha) 
                                        elif texturesDif and not texturesDif.startswith("PAT_"):                                       
                                            tabWrite("[1 uv_mapping image_map {%s \"%s\" %s} %s]\n" % \
                                                     (imageFormat(texturesDif), texturesDif,
                                                      (imgMap(t_dif) + imgGamma), mappingDif))
                                        elif texturesDif and texturesDif.startswith("PAT_"):
                                            tabWrite("[1 %s]\n" %texturesDif)
                                        tabWrite("}\n")
                                        tabWrite("}\n")

                                    else:
                                        if texturesDif and texturesDif.startswith("PAT_"):
                                            tabWrite("pigment{%s}\n" %texturesDif) 
                                        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 != "":
                                        # Level 3 is full specular
                                        tabWrite("finish {%s}\n" % (safety(material_finish, Level=3)))                  
                                    else:
                                        # Level 2 is translated specular
                                        tabWrite("finish {%s}\n" % (safety(material_finish, Level=2)))

                                    ## 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 != "" and mater.pov.replacement_text == "":
                                    ## 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 =imgMapTransforms(t_nor)
                                    # 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?
                                    if texturesNorm and texturesNorm.startswith("PAT_"):
                                        tabWrite("normal{function{f%s(x,y,z).grey} bump_size %.4g}\n" %(texturesNorm, t_nor.normal_factor * 10))
                                    else:                                    
                                        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 != "" and mater.pov.replacement_text == "":
                                    tabWrite("]\n")

                                    tabWrite("}\n")

                                #End of slope/ior texture_map
                                if mater.diffuse_shader == 'MINNAERT' and mater.pov.replacement_text == "":
                                    tabWrite("]\n")
                                    tabWrite("}\n")
                                if mater.diffuse_shader == 'FRESNEL' and mater.pov.replacement_text == "":
                                    c = 1
                                    while (c <= lampCount):
                                        tabWrite("]\n")
                                        tabWrite("}\n")
                                        c += 1

                                  
                                        
                                # Close first layer of POV "texture" (Blender material)
                                tabWrite("}\n")
                                
                                if (mater.specular_color.s > 0.0):
                                    colored_specular_found = True
                                else:
                                    colored_specular_found = False
                                    
                                # Write another layered texture using invisible diffuse and metallic trick 
                                # to emulate colored specular highlights
                                special_texture_found = False
                                for t in mater.texture_slots:
                                    if(t and t.use and ((t.texture.type == 'IMAGE' and t.texture.image) or t.texture.type != 'IMAGE') and
                                       (t.use_map_specular or t.use_map_raymir)):
                                        # Specular mapped textures would conflict with colored specular
                                        # because POV can't layer over or under pigment patterned textures
                                        special_texture_found = True
                                
                                if colored_specular_found and not special_texture_found:
                                    if comments:
                                        file.write("  // colored highlights with a stransparent metallic layer\n")
                                    else:
                                        tabWrite("\n")
                                
                                    tabWrite("texture {\n")
                                    tabWrite("pigment {rgbft<%.3g, %.3g, %.3g, 0, 1>}\n" % \
                                                     (mater.specular_color[0], mater.specular_color[1], mater.specular_color[2]))
                                    tabWrite("finish {%s}\n" % (safety(material_finish, Level=2))) # Level 2 is translated spec

                                    texturesNorm = ""
                                    for t in mater.texture_slots:

                                        if t and t.texture.pov.tex_pattern_type != 'emulator':
                                            proceduralFlag=True
                                            image_filename = string_strip_hyphen(bpy.path.clean_name(t.texture.name))
                                        if t and t.texture.type == 'IMAGE' and t.use and t.texture.image and t.texture.pov.tex_pattern_type == 'emulator':
                                            proceduralFlag=False 
                                            image_filename = path_image(t.texture.image)
                                            imgGamma = ""
                                            if image_filename:
                                                if t.use_map_normal:
                                                    texturesNorm = image_filename
                                                    # colvalue = t.normal_factor * 10.0  # UNUSED
                                                    #textNormName=t.texture.image.name + ".normal"
                                                    #was the above used? --MR
                                                    t_nor = t
                                                    if proceduralFlag:
                                                        tabWrite("normal{function{f%s(x,y,z).grey} bump_size %.4g}\n" %(texturesNorm, t_nor.normal_factor * 10))
                                                    else:
                                                        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))
                                                                  
                                    tabWrite("}\n") # THEN IT CAN CLOSE LAST LAYER OF TEXTURE   --MR


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


                    
                # Vert Colors
                tabWrite("texture_list {\n")
                # In case there's is no material slot, give at least one texture (empty so it uses pov default)
                if len(vertCols)==0:
                    file.write(tabStr + "1")
                else:
                    file.write(tabStr + "%s" % (len(vertCols)))  # vert count
                if material is not None:    
                    if material.pov.replacement_text != "":
                        file.write("\n")
                        file.write(" texture{%s}\n" % material.pov.replacement_text)

                    else:
                        # Loop through declared materials list
                        for cMN in LocalMaterialNames:
                            if material != "Default":
                                file.write("\n texture{MAT_%s}\n" % cMN)#string_strip_hyphen(materialNames[material])) # Something like that
                else:
                    file.write(" texture{}\n")                
                tabWrite("}\n")

                # Face indices
                tabWrite("face_indices {\n")
                tabWrite("%d" % (len(me_faces) + quadCount))  # faces count
                tabStr = tab * tabLevel

                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:
                            if linebreaksinlists:
                                file.write(",\n")
                                # vert count
                                file.write(tabStr + "<%d,%d,%d>" % (fv[i1], fv[i2], fv[i3]))
                            else:
                                file.write(", ")
                                file.write("<%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:
                                # Color per vertex - vertex color

                                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:
                                # Color per material - flat material color
                                if material.subsurface_scattering.use:
                                    diffuse_color = [i * j for i, j in zip(material.subsurface_scattering.color[:], material.diffuse_color[:])]
                                else:
                                    diffuse_color = material.diffuse_color[:]
                                ci1 = ci2 = ci3 = vertCols[diffuse_color[0], diffuse_color[1], \
                                                  diffuse_color[2], f.material_index][0]

                            if linebreaksinlists:
                                file.write(",\n")
                                file.write(tabStr + "<%d,%d,%d>, %d,%d,%d" % \
                                           (fv[i1], fv[i2], fv[i3], ci1, ci2, ci3))  # vert count
                            else:
                                file.write(", ")
                                file.write("<%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
                tabStr = tab * tabLevel
                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:
                            if linebreaksinlists:
                                file.write(",\n")
                                file.write(tabStr + "<%d,%d,%d>" %\
                                (uniqueNormals[verts_normals[fv[i1]]][0],\
                                 uniqueNormals[verts_normals[fv[i2]]][0],\
                                 uniqueNormals[verts_normals[fv[i3]]][0]))  # vert count
                            else:
                                file.write(", ")
                                file.write("<%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]
                            if linebreaksinlists:
                                file.write(",\n")
                                file.write(tabStr + "<%d,%d,%d>" % (idx, idx, idx))  # vert count
                            else:
                                file.write(", ")
                                file.write("<%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
                    tabStr = tab * tabLevel
                    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.uv[0][:], uv.uv[1][:], uv.uv[2][:], uv.uv[3][:]
                        else:
                            uvs = uv.uv[0][:], uv.uv[1][:], uv.uv[2][:]

                        for i1, i2, i3 in indices:
                            if linebreaksinlists:
                                file.write(",\n")
                                file.write(tabStr + "<%d,%d,%d>" % (
                                         uniqueUVs[uvs[i1]][0],\
                                         uniqueUVs[uvs[i2]][0],\
                                         uniqueUVs[uvs[i3]][0]))
                            else:
                                file.write(", ")
                                file.write("<%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, ob)
                    except IndexError:
                        print(me)

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

                tabWrite("}\n")  # End of mesh block

            bpy.data.meshes.remove(me)

        for data_name, inst in data_ref.items():
            for ob_name, matrix_str in inst:
                tabWrite("//----Blender Object Name:%s----\n" % ob_name)
                tabWrite("object { \n")
                tabWrite("%s\n" % data_name)
                tabWrite("%s\n" % matrix_str)
                tabWrite("}\n")

    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 == 'TRANSPARENT':
                    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:
                # XXX Does not exists anymore
                #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
                # XXX No enable checkbox for world textures yet (report it?)
                #if t and t.texture.type == 'IMAGE' and t.use:
                if t and t.texture.type == 'IMAGE':
                    image_filename = path_image(t.texture.image)
                    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/
                    # Replace 4/3 by the ratio of each image found by some custom or existing
                    # function
                    #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))
                    #using camera rotation valuesdirectly from blender seems much easier
                    if t_blend.texture_coords == 'ANGMAP':
                        mappingBlend = ""
                    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
                  
                        mappingBlend = "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.
                    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))
                    # The following layered pigment opacifies to black over the texture for
                    # transmit below 1 or otherwise adds to itself
                    tabWrite("pigment {rgb 0 transmit %s}\n" % (t.texture.intensity))
                    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")
                    # maybe Should follow the advice of POV doc about replacing gradient
                    # for skysphere..5.5
                    tabWrite("gradient y\n")
                    tabWrite("color_map {\n")
                    # XXX Does not exists anymore
                    #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[:]))
                    if render.alpha_mode == 'TRANSPARENT':
                        tabWrite("[0.0 rgbt<%.3g, %.3g, %.3g, 0.99>]\n" % (world.horizon_color[:]))
                        # aa premult not solved with transmit 1
                        tabWrite("[1.0 rgbt<%.3g, %.3g, %.3g, 0.99>]\n" % (world.zenith_color[:]))
                    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 <%.4g, %.4g, %.4g>}\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")
        onceSss = 1
        onceAmbient = 1
        oncePhotons = 1
        for material in bpy.data.materials:
            if material.subsurface_scattering.use and onceSss:
                # In pov, the scale has reversed influence compared to blender. these number
                # should correct that
                tabWrite("mm_per_unit %.6f\n" % \
                         (material.subsurface_scattering.scale * 1000.0))# formerly ...scale * (-100.0) + 15.0))
                # In POV-Ray, the scale factor for all subsurface shaders needs to be the same
                sslt_samples = (11 - material.subsurface_scattering.error_threshold) * 10 # formerly ...*100
                tabWrite("subsurface { samples %d, %d }\n" % (sslt_samples, sslt_samples / 10))
                onceSss = 0

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

            if (material.pov.refraction_type == "2" or material.pov.photons_reflection == True) and oncePhotons:
                tabWrite("photons {\n")
                tabWrite("spacing %.6f\n" % scene.pov.photon_spacing)
                tabWrite("max_trace_level %d\n" % scene.pov.photon_max_trace_level)
                tabWrite("adc_bailout %.3g\n" % scene.pov.photon_adc_bailout)
                tabWrite("gather %d, %d\n" % (scene.pov.photon_gather_min, scene.pov.photon_gather_max))
                tabWrite("}\n")
                oncePhotons = 0

        tabWrite("}\n")

    def exportCustomCode():
        # Write CurrentAnimation Frame for use in Custom POV Code
        file.write("#declare CURFRAMENUM = %d;\n" % bpy.context.scene.frame_current)
        #Change path and uncomment to add an animated include file by hand:
        file.write("//#include \"/home/user/directory/animation_include_file.inc\"\n")
        for txt in bpy.data.texts:
            if txt.pov.custom_code:
                # Why are the newlines needed?
                file.write("\n")
                file.write(txt.as_string())
                file.write("\n")

    sel = renderable_objects()
    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--\n\n")

    exportGlobalSettings(scene)

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

    if comments:
        file.write("\n//--Patterns Definitions--\n\n")
    LocalPatternNames = []
    for texture in bpy.data.textures: #ok?
        if texture.users > 0:
            currentPatName = string_strip_hyphen(bpy.path.clean_name(texture.name)) #string_strip_hyphen(patternNames[texture.name]) #maybe instead
            LocalPatternNames.append(currentPatName) #use this list to prevent writing texture instances several times and assign in mats?
            file.write("\n #declare PAT_%s = \n" % currentPatName)
            file.write(exportPattern(texture))
            file.write("\n")                
    if comments:
        file.write("\n//--Background--\n\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")
    # write a default pigment for objects with no material (comment out to show black)
    file.write("#default{ pigment{ color rgb 0.8 }}\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")

    exportMeshes(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(scene, filename_ini, filename_pov, filename_image):
    feature_set = bpy.context.user_preferences.addons[__package__].preferences.branch_feature_set_povray
    using_uberpov = (feature_set=='uberpov')
    #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, "w")
    file.write("Version=3.7\n")
    file.write("Input_File_Name='%s'\n" % filename_pov)
    file.write("Output_File_Name='%s'\n" % filename_image)

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

    # Border render.
    if render.use_border:
        file.write("Start_Column=%4g\n" % render.border_min_x)
        file.write("End_Column=%4g\n" % (render.border_max_x))

        file.write("Start_Row=%4g\n" % (1.0 - render.border_max_y))
        file.write("End_Row=%4g\n" % (1.0 - render.border_min_y))

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

    # Activated (turn this back off when better live exchange is done between the two programs
    # (see next comment)
    file.write("Display=1\n")
    file.write("Pause_When_Done=0\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=N\n")
    #file.write("Output_File_Type=T\n") # TGA, best progressive loading
    file.write("Output_Alpha=1\n")

    if scene.pov.antialias_enable:
        # method 2 (recursive) with higher max subdiv forced because no mipmapping in POV-Ray
        # needs higher sampling.
        # aa_mapping = {"5": 2, "8": 3, "11": 4, "16": 5}
        if using_uberpov:
            method = {"0": 1, "1": 2, "2": 3}
        else:
            method = {"0": 1, "1": 2, "2": 2}
        file.write("Antialias=on\n")
        file.write("Antialias_Depth=%d\n" % scene.pov.antialias_depth)
        file.write("Antialias_Threshold=%.3g\n" % scene.pov.antialias_threshold)
        if using_uberpov and scene.pov.antialias_method == '2':
            file.write("Sampling_Method=%s\n" % method[scene.pov.antialias_method])
            file.write("Antialias_Confidence=%.3g\n" % scene.pov.antialias_confidence)
        else:
            file.write("Sampling_Method=%s\n" % method[scene.pov.antialias_method])
        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

    @staticmethod
    def _locate_binary():
        addon_prefs = bpy.context.user_preferences.addons[__package__].preferences

        # Use the system preference if its set.
        pov_binary = addon_prefs.filepath_povray
        if pov_binary:
            if os.path.exists(pov_binary):
                return pov_binary
            else:
                print("User Preferences path to povray %r NOT FOUND, checking $PATH" % pov_binary)

        # Windows Only
        # assume if there is a 64bit binary that the user has a 64bit capable OS
        if sys.platform[:3] == "win":
            import winreg
            win_reg_key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, "Software\\POV-Ray\\v3.7\\Windows")
            win_home = winreg.QueryValueEx(win_reg_key, "Home")[0]

            # First try 64bits UberPOV
            pov_binary = os.path.join(win_home, "bin", "uberpov64.exe")
            if os.path.exists(pov_binary):
                return pov_binary
                
            # Then try 64bits POV
            pov_binary = os.path.join(win_home, "bin", "pvengine64.exe")
            if os.path.exists(pov_binary):
                return pov_binary

            # Then try 32bits UberPOV
            pov_binary = os.path.join(win_home, "bin", "uberpov32.exe")
            if os.path.exists(pov_binary):
                return pov_binary 
                
            # Then try 32bits POV
            pov_binary = os.path.join(win_home, "bin", "pvengine.exe")
            if os.path.exists(pov_binary):
                return pov_binary

        # search the path all os's
        pov_binary_default = "povray"

        os_path_ls = os.getenv("PATH").split(':') + [""]