render.py

                if material.pov.irid_enable:
                    tabWrite("irid { %.4g thickness %.4g turbulence %.4g }" % \
                             (material.pov.irid_amount, material.pov.irid_thickness,
                              material.pov.irid_turbulence))

            else:
                tabWrite("diffuse 0.8\n")
                tabWrite("phong 70.0\n")

                #tabWrite("specular 0.2\n")

            # This is written into the object
            '''
            if material and material.transparency_method=='RAYTRACE':
                'interior { ior %.3g} ' % material.raytrace_transparency.ior
            '''

            #tabWrite("crand 1.0\n") # Sand granyness
            #tabWrite("metallic %.6f\n" % material.spec)
            #tabWrite("phong %.6f\n" % material.spec)
            #tabWrite("phong_size %.6f\n" % material.spec)
            #tabWrite("brilliance %.6f " % (material.specular_hardness/256.0) # Like hardness

            tabWrite("}\n\n")

        # Level=2 Means translation of spec and mir levels for when no map influences them
        povHasnoSpecularMaps(Level=2)

        if material:
            special_texture_found = False
            for t in material.texture_slots:
                if t and t.use:
                    if (t.texture.type == 'IMAGE' and t.texture.image) or t.texture.type != 'IMAGE':
                        validPath=True
                else:
                    validPath=False
                if(t and t.use and validPath and
                   (t.use_map_specular or t.use_map_raymir or t.use_map_normal or t.use_map_alpha)):
                    special_texture_found = True
                    continue  # Some texture found

            if special_texture_found or colored_specular_found:
                # Level=1 Means No specular nor Mirror reflection
                povHasnoSpecularMaps(Level=1)

                # Level=3 Means Maximum Spec and Mirror
                povHasnoSpecularMaps(Level=3)

    def exportCamera():
        camera = scene.camera

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

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

        tabWrite("camera {\n")
        if scene.pov.baking_enable and active_object and active_object.type == 'MESH':
            tabWrite("mesh_camera{ 1 3\n")  # distribution 3 is what we want here
            tabWrite("mesh{%s}\n" % active_object.name)
            tabWrite("}\n")
            tabWrite("location <0,0,.01>")
            tabWrite("direction <0,0,-1>")
        # Using standard camera otherwise
        else:
            tabWrite("location  <0, 0, 0>\n")
            tabWrite("look_at  <0, 0, -1>\n")
            tabWrite("right <%s, 0, 0>\n" % - Qsize)
            tabWrite("up <0, 1, 0>\n")
            tabWrite("angle  %f\n" % (360.0 * atan(16.0 / camera.data.lens) / pi))

            tabWrite("rotate  <%.6f, %.6f, %.6f>\n" % \
                     tuple([degrees(e) for e in matrix.to_3x3().to_euler()]))
            tabWrite("translate <%.6f, %.6f, %.6f>\n" % matrix.translation[:])
            if camera.data.pov.dof_enable and focal_point != 0:
                tabWrite("aperture %.3g\n" % camera.data.pov.dof_aperture)
                tabWrite("blur_samples %d %d\n" % \
                         (camera.data.pov.dof_samples_min, camera.data.pov.dof_samples_max))
                tabWrite("variance 1/%d\n" % camera.data.pov.dof_variance)
                tabWrite("confidence %.3g\n" % camera.data.pov.dof_confidence)
                tabWrite("focal_point <0, 0, %f>\n" % focal_point)
        tabWrite("}\n")

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

            matrix = global_matrix * ob.matrix_world

            # Color is modified by energy #muiltiplie by 2 for a better match --Maurice
            color = tuple([c * lamp.energy * 2.0 for c in lamp.color])

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

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

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

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

                tabWrite("point_at  <0, 0, -1>\n")
            elif lamp.type == 'SUN':
                tabWrite("parallel\n")
                tabWrite("point_at  <0, 0, -1>\n")  # *must* be after 'parallel'

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

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

            # HEMI never has any shadow_method attribute
            if(not scene.render.use_shadows or lamp.type == 'HEMI' or
               (lamp.type != 'HEMI' and lamp.shadow_method == 'NOSHADOW')):
                tabWrite("shadowless\n")

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

            writeMatrix(matrix)

            tabWrite("}\n")

            lampCount += 1

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

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

    def exportMeta(metas):

        # TODO - blenders 'motherball' naming is not supported.

        if comments and len(metas) >= 1:
            file.write("//--Blob objects--\n\n")

        for ob in metas:
            meta = ob.data

            # important because no elements will break parsing.
            elements = [elem for elem in meta.elements if elem.type in {'BALL', 'ELLIPSOID'}]

            if elements:
                tabWrite("blob {\n")
                tabWrite("threshold %.4g\n" % meta.threshold)
                importance = ob.pov.importance_value

                try:
                    material = meta.materials[0]  # lame! - blender cant do enything else.
                except:
                    material = None

                for elem in elements:
                    loc = elem.co

                    stiffness = elem.stiffness
                    if elem.use_negative:
                        stiffness = - stiffness

                    if elem.type == 'BALL':

                        tabWrite("sphere { <%.6g, %.6g, %.6g>, %.4g, %.4g }\n" % \
                                 (loc.x, loc.y, loc.z, elem.radius, stiffness))

                        # After this wecould do something simple like...
                        #     "pigment {Blue} }"
                        # except we'll write the color

                    elif elem.type == 'ELLIPSOID':
                        # location is modified by scale
                        tabWrite("sphere { <%.6g, %.6g, %.6g>, %.4g, %.4g }\n" % \
                                 (loc.x / elem.size_x, loc.y / elem.size_y, loc.z / elem.size_z,
                                  elem.radius, stiffness))
                        tabWrite("scale <%.6g, %.6g, %.6g> \n" % \
                                 (elem.size_x, elem.size_y, elem.size_z))

                if material:
                    diffuse_color = material.diffuse_color
                    trans = 1.0 - material.alpha
                    if material.use_transparency and material.transparency_method == 'RAYTRACE':
                        povFilter = material.raytrace_transparency.filter * (1.0 - material.alpha)
                        trans = (1.0 - material.alpha) - povFilter
                    else:
                        povFilter = 0.0

                    material_finish = materialNames[material.name]

                    tabWrite("pigment {rgbft<%.3g, %.3g, %.3g, %.3g, %.3g>} \n" % \
                             (diffuse_color[0], diffuse_color[1], diffuse_color[2],
                              povFilter, trans))
                    tabWrite("finish {%s}\n" % safety(material_finish, Level=2))

                else:
                    tabWrite("pigment {rgb<1 1 1>} \n")
                    # Write the finish last.
                    tabWrite("finish {%s}\n" % (safety(DEF_MAT_NAME, Level=2)))

                writeObjectMaterial(material, ob)

                writeMatrix(global_matrix * ob.matrix_world)
                # Importance for radiosity sampling added here
                tabWrite("radiosity { \n")
                tabWrite("importance %3g \n" % importance)
                tabWrite("}\n")

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

                if comments and len(metas) >= 1:
                    file.write("\n")

#    objectNames = {}
    DEF_OBJ_NAME = "Default"

    def exportMeshes(scene, sel):
#        obmatslist = []
#        def hasUniqueMaterial():
#            # Grab materials attached to object instances ...
#            if hasattr(ob, 'material_slots'):
#                for ms in ob.material_slots:
#                    if ms.material is not None and ms.link == 'OBJECT':
#                        if ms.material in obmatslist:
#                            return False
#                        else:
#                            obmatslist.append(ms.material)
#                            return True
#        def hasObjectMaterial(ob):
#            # Grab materials attached to object instances ...
#            if hasattr(ob, 'material_slots'):
#                for ms in ob.material_slots:
#                    if ms.material is not None and ms.link == 'OBJECT':
#                        # If there is at least one material slot linked to the object
#                        # and not the data (mesh), always create a new, "private" data instance.
#                        return True
#            return False
        # For objects using local material(s) only!
        # This is a mapping between a tuple (dataname, materialnames, ...), and the POV dataname.
        # As only objects using:
        #     * The same data.
        #     * EXACTLY the same materials, in EXACTLY the same sockets.
        # ... can share a same instance in POV export.
        obmats2data = {}

        def checkObjectMaterials(ob, name, dataname):
            if hasattr(ob, 'material_slots'):
                has_local_mats = False
                key = [dataname]
                for ms in ob.material_slots:
                    if ms.material is not None:
                        key.append(ms.material.name)
                        if ms.link == 'OBJECT' and not has_local_mats:
                            has_local_mats = True
                    else:
                        # Even if the slot is empty, it is important to grab it...
                        key.append("")
                if has_local_mats:
                    # If this object uses local material(s), lets find if another object
                    # using the same data and exactly the same list of materials
                    # (in the same slots) has already been processed...
                    # Note that here also, we use object name as new, unique dataname for Pov.
                    key = tuple(key)  # Lists are not hashable...
                    if key not in obmats2data:
                        obmats2data[key] = name
                    return obmats2data[key]
            return None

        data_ref = {}

        def store(scene, ob, name, dataname, matrix):
            # The Object needs to be written at least once but if its data is
            # already in data_ref this has already been done.
            # This func returns the "povray" name of the data, or None
            # if no writing is needed.
            if ob.is_modified(scene, 'RENDER'):
                # Data modified.
                # Create unique entry in data_ref by using object name
                # (always unique in Blender) as data name.
                data_ref[name] = [(name, MatrixAsPovString(matrix))]
                return name
            # Here, we replace dataname by the value returned by checkObjectMaterials, only if
            # it is not evaluated to False (i.e. only if the object uses some local material(s)).
            dataname = checkObjectMaterials(ob, name, dataname) or dataname
            if dataname in data_ref:
                # Data already known, just add the object instance.
                data_ref[dataname].append((name, MatrixAsPovString(matrix)))
                # No need to write data
                return None
            else:
                # Data not yet processed, create a new entry in data_ref.
                data_ref[dataname] = [(name, MatrixAsPovString(matrix))]
                return dataname

        ob_num = 0
        for ob in sel:
            ob_num += 1

            # XXX I moved all those checks here, as there is no need to compute names
            #     for object we won't export here!
            if ob.type in {'LAMP', 'CAMERA', 'EMPTY', 'META', 'ARMATURE', 'LATTICE'}:
                continue
                   
            # Export Hair
            renderEmitter = True
            if hasattr(ob, 'particle_systems'):
                renderEmitter = False
                for pSys in ob.particle_systems:
                    if pSys.settings.use_render_emitter:
                        renderEmitter = True
                    for mod in [m for m in ob.modifiers if (m is not None) and (m.type == 'PARTICLE_SYSTEM')]:
                        if (pSys.settings.render_type == 'PATH') and mod.show_render and (pSys.name == mod.particle_system.name):
                            tstart = time.time()
                            texturedHair=0
                            if ob.active_material is not None:
                                pmaterial = ob.material_slots[pSys.settings.material - 1].material
                                for th in pmaterial.texture_slots:
                                    if th and th.use:
                                        if (th.texture.type == 'IMAGE' and th.texture.image) or th.texture.type != 'IMAGE':
                                            if th.use_map_color_diffuse:
                                                texturedHair=1
                                if pmaterial.strand.use_blender_units:
                                    strandStart = pmaterial.strand.root_size
                                    strandEnd = pmaterial.strand.tip_size
                                    strandShape = pmaterial.strand.shape 
                                else:  # Blender unit conversion
                                    strandStart = pmaterial.strand.root_size / 200.0
                                    strandEnd = pmaterial.strand.tip_size / 200.0
                                    strandShape = pmaterial.strand.shape
                            else:
                                pmaterial = "default"  # No material assigned in blender, use default one
                                strandStart = 0.01
                                strandEnd = 0.01
                                strandShape = 0.0
                            # Set the number of particles to render count rather than 3d view display    
                            pSys.set_resolution(scene, ob, 'RENDER')    
                            steps = pSys.settings.draw_step
                            steps = 3 ** steps # or (power of 2 rather than 3) + 1 # Formerly : len(particle.hair_keys)
                            
                            totalNumberOfHairs = ( len(pSys.particles) + len(pSys.child_particles) )
                            #hairCounter = 0
                            file.write('#declare HairArray = array[%i] {\n' % totalNumberOfHairs)
                            for pindex in range(0, totalNumberOfHairs):

                                #if particle.is_exist and particle.is_visible:
                                    #hairCounter += 1
                                    #controlPointCounter = 0
                                    # Each hair is represented as a separate sphere_sweep in POV-Ray.
                                    
                                    file.write('sphere_sweep{')
                                    if pSys.settings.use_hair_bspline:
                                        file.write('b_spline ')
                                        file.write('%i,\n' % (steps + 2))  # +2 because the first point needs tripling to be more than a handle in POV
                                    else:
                                        file.write('linear_spline ')
                                        file.write('%i,\n' % (steps))
                                    #changing world coordinates to object local coordinates by multiplying with inverted matrix    
                                    initCo = ob.matrix_world.inverted()*(pSys.co_hair(ob, pindex, 0))
                                    if ob.active_material is not None:
                                        pmaterial = ob.material_slots[pSys.settings.material-1].material
                                        for th in pmaterial.texture_slots:
                                            if th and th.use and th.use_map_color_diffuse:
                                                #treat POV textures as bitmaps
                                                if (th.texture.type == 'IMAGE' and th.texture.image and th.texture_coords == 'UV' and ob.data.uv_textures != None): # or (th.texture.pov.tex_pattern_type != 'emulator' and th.texture_coords == 'UV' and ob.data.uv_textures != None):
                                                    image=th.texture.image
                                                    image_width = image.size[0]
                                                    image_height = image.size[1]
                                                    image_pixels = image.pixels[:]
                                                    uv_co = pSys.uv_on_emitter(mod, pSys.particles[pindex], pindex, 0)
                                                    x_co = round(uv_co[0] * (image_width - 1))
                                                    y_co = round(uv_co[1] * (image_height - 1))
                                                    pixelnumber = (image_width * y_co) + x_co
                                                    r = image_pixels[pixelnumber*4]
                                                    g = image_pixels[pixelnumber*4+1]
                                                    b = image_pixels[pixelnumber*4+2]
                                                    a = image_pixels[pixelnumber*4+3]
                                                    initColor=(r,g,b,a)                                              
                                                else:
                                                    #only overwrite variable for each competing texture for now
                                                    initColor=th.texture.evaluate((initCo[0],initCo[1],initCo[2]))
                                    for step in range(0, steps):
                                        co = pSys.co_hair(ob, pindex, step)
                                    #for controlPoint in particle.hair_keys:
                                        if pSys.settings.clump_factor != 0:
                                            hDiameter = pSys.settings.clump_factor / 200.0 * random.uniform(0.5, 1)
                                        elif step == 0:
                                            hDiameter = strandStart
                                        else:
                                            hDiameter += (strandEnd-strandStart)/(pSys.settings.draw_step+1) #XXX +1 or not?
                                        if step == 0 and pSys.settings.use_hair_bspline:
                                            # Write three times the first point to compensate pov Bezier handling
                                            file.write('<%.6g,%.6g,%.6g>,%.7g,\n' % (co[0], co[1], co[2], abs(hDiameter)))
                                            file.write('<%.6g,%.6g,%.6g>,%.7g,\n' % (co[0], co[1], co[2], abs(hDiameter)))                                          
                                            #file.write('<%.6g,%.6g,%.6g>,%.7g' % (particle.location[0], particle.location[1], particle.location[2], abs(hDiameter))) # Useless because particle location is the tip, not the root.
                                            #file.write(',\n')
                                        #controlPointCounter += 1
                                        #totalNumberOfHairs += len(pSys.particles)# len(particle.hair_keys)
                                             
                                      # Each control point is written out, along with the radius of the
                                      # hair at that point.
                                        file.write('<%.6g,%.6g,%.6g>,%.7g' % (co[0], co[1], co[2], abs(hDiameter)))

                                      # All coordinates except the last need a following comma.

                                        if step != steps - 1:
                                            file.write(',\n')
                                        else:
                                            if texturedHair:
                                                # Write pigment and alpha (between Pov and Blender alpha 0 and 1 are reversed)
                                                file.write('\npigment{ color rgbf < %.3g, %.3g, %.3g, %.3g> }\n' %(initColor[0], initColor[1], initColor[2], 1.0-initColor[3]))
                                            # End the sphere_sweep declaration for this hair
                                            file.write('}\n')
                                        
                                      # All but the final sphere_sweep (each array element) needs a terminating comma.

                                    if pindex != totalNumberOfHairs:
                                        file.write(',\n')
                                    else:
                                        file.write('\n')

                            # End the array declaration.

                            file.write('}\n')
                            file.write('\n')
                            
                            if not texturedHair:
                                # Pick up the hair material diffuse color and create a default POV-Ray hair texture.

                                file.write('#ifndef (HairTexture)\n')
                                file.write('  #declare HairTexture = texture {\n')
                                file.write('    pigment {rgbt <%s,%s,%s,%s>}\n' % (pmaterial.diffuse_color[0], pmaterial.diffuse_color[1], pmaterial.diffuse_color[2], (pmaterial.strand.width_fade + 0.05)))
                                file.write('  }\n')
                                file.write('#end\n')
                                file.write('\n')

                            # Dynamically create a union of the hairstrands (or a subset of them).
                            # By default use every hairstrand, commented line is for hand tweaking test renders.
                            file.write('//Increasing HairStep divides the amount of hair for test renders.\n')
                            file.write('#ifndef(HairStep) #declare HairStep = 1; #end\n')
                            file.write('union{\n')
                            file.write('  #local I = 0;\n')
                            file.write('  #while (I < %i)\n' % totalNumberOfHairs)
                            file.write('    object {HairArray[I]')
                            if not texturedHair:
                                file.write(' texture{HairTexture}\n')
                            else:
                                file.write('\n')
                            # Translucency of the hair:
                            file.write('        hollow\n')
                            file.write('        double_illuminate\n')
                            file.write('        interior {\n')
                            file.write('            ior 1.45\n')
                            file.write('            media {\n')
                            file.write('                scattering { 1, 10*<0.73, 0.35, 0.15> /*extinction 0*/ }\n')
                            file.write('                absorption 10/<0.83, 0.75, 0.15>\n')
                            file.write('                samples 1\n')
                            file.write('                method 2\n')
                            file.write('                density {\n')
                            file.write('                    color_map {\n')
                            file.write('                        [0.0 rgb <0.83, 0.45, 0.35>]\n')
                            file.write('                        [0.5 rgb <0.8, 0.8, 0.4>]\n')
                            file.write('                        [1.0 rgb <1,1,1>]\n')
                            file.write('                    }\n')
                            file.write('                }\n')
                            file.write('            }\n')
                            file.write('        }\n')
                            file.write('    }\n')
                            
                            file.write('    #local I = I + HairStep;\n')
                            file.write('  #end\n')
                            
                            writeMatrix(global_matrix * ob.matrix_world)

                            
                            file.write('}')
                            print('Totals hairstrands written: %i' % totalNumberOfHairs)
                            print('Number of tufts (particle systems)', len(ob.particle_systems))
                            
                            # Set back the displayed number of particles to preview count
                            pSys.set_resolution(scene, ob, 'PREVIEW')
                            
                            if renderEmitter == False:
                                continue #don't render mesh, skip to next object.
            try:
                me = ob.to_mesh(scene, True, 'RENDER')
            except:
                # happens when curves cant be made into meshes because of no-data
                continue

            importance = ob.pov.importance_value
            me_materials = me.materials
            me_faces = me.tessfaces[:]
            
            if not me or not me_faces:
                continue

#############################################
            # Generating a name for object just like materials to be able to use it
            # (baking for now or anything else).
            # XXX I don't understand that:&nbsp;if we are here, sel if a non-empty iterable,
            #     so this condition is always True, IMO -- mont29
            if sel:
                name_orig = "OB" + ob.name
                dataname_orig = "DATA" + ob.data.name
            else:
                name_orig = DEF_OBJ_NAME
                dataname_orig = DEF_OBJ_NAME
            name = string_strip_hyphen(bpy.path.clean_name(name_orig))
            dataname = string_strip_hyphen(bpy.path.clean_name(dataname_orig))
##            for slot in ob.material_slots:
##                if slot.material is not None and slot.link == 'OBJECT':
##                    obmaterial = slot.material

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

            if info_callback:
                info_callback("Object %2.d of %2.d (%s)" % (ob_num, len(sel), ob.name))

            #if ob.type != 'MESH':
            #    continue
            # me = ob.data

            matrix = global_matrix * ob.matrix_world
            povdataname = store(scene, ob, name, dataname, matrix)
            if povdataname is None:
                print("This is an instance")
                continue

            print("Writing Down First Occurence")

            uv_textures = me.tessface_uv_textures
            if len(uv_textures) > 0:
                if me.uv_textures.active and uv_textures.active.data:
                    uv_layer = uv_textures.active.data
            else:
                uv_layer = None

            try:
                #vcol_layer = me.vertex_colors.active.data
                vcol_layer = me.tessface_vertex_colors.active.data
            except AttributeError:
                vcol_layer = None

            faces_verts = [f.vertices[:] for f in me_faces]
            faces_normals = [f.normal[:] for f in me_faces]
            verts_normals = [v.normal[:] for v in me.vertices]

            # quads incur an extra face
            quadCount = sum(1 for f in faces_verts if len(f) == 4)

            # Use named declaration to allow reference e.g. for baking. MR
            file.write("\n")
            tabWrite("#declare %s =\n" % povdataname)
            tabWrite("mesh2 {\n")
            tabWrite("vertex_vectors {\n")
            tabWrite("%d" % len(me.vertices))  # vert count

            tabStr = tab * tabLevel
            for v in me.vertices:
                if linebreaksinlists:
                    file.write(",\n")
                    file.write(tabStr + "<%.6f, %.6f, %.6f>" % v.co[:])  # vert count
                else:
                    file.write(", ")
                    file.write("<%.6f, %.6f, %.6f>" % v.co[:])  # vert count
                #tabWrite("<%.6f, %.6f, %.6f>" % v.co[:])  # vert count
            file.write("\n")
            tabWrite("}\n")

            # Build unique Normal list
            uniqueNormals = {}
            for fi, f in enumerate(me_faces):
                fv = faces_verts[fi]
                # [-1] is a dummy index, use a list so we can modify in place
                if f.use_smooth:  # Use vertex normals
                    for v in fv:
                        key = verts_normals[v]
                        uniqueNormals[key] = [-1]
                else:  # Use face normal
                    key = faces_normals[fi]
                    uniqueNormals[key] = [-1]

            tabWrite("normal_vectors {\n")
            tabWrite("%d" % len(uniqueNormals))  # vert count
            idx = 0
            tabStr = tab * tabLevel
            for no, index in uniqueNormals.items():
                if linebreaksinlists:
                    file.write(",\n")
                    file.write(tabStr + "<%.6f, %.6f, %.6f>" % no)  # vert count
                else:
                    file.write(", ")
                    file.write("<%.6f, %.6f, %.6f>" % no)  # vert count
                index[0] = idx
                idx += 1
            file.write("\n")
            tabWrite("}\n")

            # Vertex colors
            vertCols = {}  # Use for material colors also.

            if uv_layer:
                # Generate unique UV's
                uniqueUVs = {}
                #n = 0
                for fi, uv in enumerate(uv_layer):

                    if len(faces_verts[fi]) == 4:
                        uvs = uv_layer[fi].uv[0], uv_layer[fi].uv[1], uv_layer[fi].uv[2], uv_layer[fi].uv[3]
                    else:
                        uvs = uv_layer[fi].uv[0], uv_layer[fi].uv[1], uv_layer[fi].uv[2]

                    for uv in uvs:
                        uniqueUVs[uv[:]] = [-1]

                tabWrite("uv_vectors {\n")
                #print unique_uvs
                tabWrite("%d" % len(uniqueUVs))  # vert count
                idx = 0
                tabStr = tab * tabLevel
                for uv, index in uniqueUVs.items():
                    if linebreaksinlists:
                        file.write(",\n")
                        file.write(tabStr + "<%.6f, %.6f>" % uv)
                    else:
                        file.write(", ")
                        file.write("<%.6f, %.6f>" % uv)
                    index[0] = idx
                    idx += 1
                '''
                else:
                    # Just add 1 dummy vector, no real UV's
                    tabWrite('1') # vert count
                    file.write(',\n\t\t<0.0, 0.0>')
                '''
                file.write("\n")
                tabWrite("}\n")

            if me.vertex_colors:
                #Write down vertex colors as a texture for each vertex
                tabWrite("texture_list {\n")
                tabWrite("%d\n" % (((len(me_faces)-quadCount) * 3 )+ quadCount * 4)) # works only with tris and quad mesh for now
                VcolIdx=0
                if comments:
                    file.write("\n  //Vertex colors: one simple pigment texture per vertex\n")
                for fi, f in enumerate(me_faces):
                    # annoying, index may be invalid
                    material_index = f.material_index
                    try:
                        material = me_materials[material_index]
                    except:
                        material = None
                    if material: #and material.use_vertex_color_paint: #Always use vertex color when there is some for now
                     
                        col = vcol_layer[fi]

                        if len(faces_verts[fi]) == 4:
                            cols = col.color1, col.color2, col.color3, col.color4
                        else:
                            cols = col.color1, col.color2, col.color3

                        for col in cols:
                            key = col[0], col[1], col[2], material_index  # Material index!
                            VcolIdx+=1
                            vertCols[key] = [VcolIdx]
                            if linebreaksinlists:
                                tabWrite("texture {pigment{ color rgb <%6f,%6f,%6f> }}\n" % (col[0], col[1], col[2]))
                            else:
                                tabWrite("texture {pigment{ color rgb <%6f,%6f,%6f> }}" % (col[0], col[1], col[2]))
                                tabStr = tab * tabLevel
                    else:
                        if material:
                            # Multiply diffuse with SSS Color
                            if material.subsurface_scattering.use:
                                diffuse_color = [i * j for i, j in zip(material.subsurface_scattering.color[:], material.diffuse_color[:])]
                                key = diffuse_color[0], diffuse_color[1], diffuse_color[2], \
                                      material_index
                                vertCols[key] = [-1]
                            else:
                                diffuse_color = material.diffuse_color[:]
                                key = diffuse_color[0], diffuse_color[1], diffuse_color[2], \
                                      material_index
                                vertCols[key] = [-1]

                tabWrite("\n}\n")                
                # Face indices
                tabWrite("\nface_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]
                                # ci are zero based index so we'll subtract 1 from them
                            if linebreaksinlists:
                                file.write(",\n")
                                file.write(tabStr + "<%d,%d,%d>, %d,%d,%d" % \
                                           (fv[i1], fv[i2], fv[i3], ci1-1, ci2-1, ci3-1))  # vert count 
                            else:
                                file.write(", ")
                                file.write("<%d,%d,%d>, %d,%d,%d" % \
                                           (fv[i1], fv[i2], fv[i3], ci1-1, ci2-1, ci3-1))  # 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
            else:
                # No vertex colors, so write material colors as vertex colors
                for i, material in enumerate(me_materials):

                    if material:
                        # Multiply diffuse with SSS Color
                        if material.subsurface_scattering.use:
                            diffuse_color = [i * j for i, j in zip(material.subsurface_scattering.color[:], material.diffuse_color[:])]
                            key = diffuse_color[0], diffuse_color[1], diffuse_color[2], i  # i == f.mat
                            vertCols[key] = [-1]
                        else:
                            diffuse_color = material.diffuse_color[:]
                            key = diffuse_color[0], diffuse_color[1], diffuse_color[2], i  # i == f.mat
                            vertCols[key] = [-1]

                        idx = 0
                        LocalMaterialNames = []                       
                        for col, index in vertCols.items():
                            #if me_materials:
                            mater = me_materials[col[3]]
                            if me_materials is None: #XXX working?
                                material_finish = DEF_MAT_NAME  # not working properly,
                                trans = 0.0

                            else:
                                material_finish = materialNames[mater.name]                        
                                if mater.use_transparency:
                                    trans = 1.0 - mater.alpha
                                else:
                                    trans = 0.0                            
                                if (mater.specular_color.s == 0.0):
                                    colored_specular_found = False
                                else:
                                    colored_specular_found = True

                                if mater.use_transparency and mater.transparency_method == 'RAYTRACE':
                                    povFilter = mater.raytrace_transparency.filter * (1.0 - mater.alpha)
                                    trans = (1.0 - mater.alpha) - povFilter
                                else:
                                    povFilter = 0.0
                                    
                                ##############SF
                                texturesDif = ""
                                texturesSpec = ""
                                texturesNorm = ""
                                texturesAlpha = ""
                                #proceduralFlag=False
                                for t in mater.texture_slots:
                                    if t and t.use and t.texture.type != 'IMAGE' and t.texture.type != 'NONE':
                                        proceduralFlag=True
                                        image_filename = "PAT_%s"%string_strip_hyphen(bpy.path.clean_name(t.texture.name))
                                        if image_filename:
                                            if t.use_map_color_diffuse:
                                                texturesDif = image_filename
                                                # colvalue = t.default_value  # UNUSED
                                                t_dif = t
                                                if t_dif.texture.pov.tex_gamma_enable:
                                                    imgGamma = (" gamma %.3g " % t_dif.texture.pov.tex_gamma_value)
                                            if t.use_map_specular or t.use_map_raymir:
                                                texturesSpec = image_filename
                                                # colvalue = t.default_value  # UNUSED
                                                t_spec = t
                                            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 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

                                    if t and t.texture.type == 'IMAGE' and t.use and t.texture.image and t.texture.pov.tex_pattern_type == 'emulator':
                                        proceduralFlag=False
                                        if t.texture.image.packed_file:
                                            orig_image_filename=t.texture.image.filepath_raw
                                            workDir=os.path.dirname(__file__)
                                            previewDir=os.path.join(workDir, "preview")
                                            unpackedfilename= os.path.join(previewDir,("unpacked_img_"+(string_strip_hyphen(bpy.path.clean_name(t.texture.name)))))
                                            if not os.path.exists(unpackedfilename):
                                                # record which images that were newly copied and can be safely
                                                # cleaned up
                                                unpacked_images.append(unpackedfilename)                                            
                                            t.texture.image.filepath_raw=unpackedfilename
                                            t.texture.image.save()
                                            image_filename = unpackedfilename
                                            t.texture.image.filepath_raw=orig_image_filename
                                        else:
                                            image_filename = path_image(t.texture.image)
                                        # IMAGE SEQUENCE BEGINS
                                        if image_filename:
                                            if bpy.data.images[t.texture.image.name].source == 'SEQUENCE':
                                                korvaa = "." + str(bpy.data.textures[t.texture.name].image_user.frame_offset + 1).zfill(3) + "."
                                                image_filename = image_filename.replace(".001.", korvaa)
                                                print(" seq debug ")
                                                print(image_filename)
                                        # IMAGE SEQUENCE ENDS
                                        imgGamma = ""
                                        if image_filename:
                                            if t.use_map_color_diffuse:
                                                texturesDif = image_filename
                                                # colvalue = t.default_value  # UNUSED
                                                t_dif = t
                                                if t_dif.texture.pov.tex_gamma_enable:
                                                    imgGamma = (" gamma %.3g " % t_dif.texture.pov.tex_gamma_value)
                                            if t.use_map_specular or t.use_map_raymir:
                                                texturesSpec = image_filename
                                                # colvalue = t.default_value  # UNUSED
                                                t_spec = t
                                            if t.use_map_normal:
                                                texturesNorm = image_filename
                                                # colvalue = t.normal_factor * 10.0  # UNUSED