I want to get the texture filename of every triangle in the scene and put them into a format to be exported for an add on script

Question

I want to write an add-on script for a custom format. I have 99% of the boilerplate by finding a similar format's export and modifying it heavily.

Here is a snippet from my current script.

    #open the file for writing
    file = open(filepath, "wb")

    #get script name from the filepath - may want to check if this is blank at some point int he future?
    base_name = os.path.basename(filepath)
    script_name = os.path.splitext(base_name)[0]

    #branch the output here, depending on what the user wants to export
    #model output
    model_output_string = '';
    model_type_num = 4;
    vert_count = 0;
    #build the model into a string, then write that to the file later
    #start writing the mesh data to the file
    model_type_num = 4;
    if len(mesh.uv_textures) > 0:
    #if the model has a UV map
            uv_layer = mesh.tessface_uv_textures.active
            for face in mesh.tessfaces:
                    faceUV = uv_layer.data[face.index]
                    i=0
                    for index in face.vertices:
                            if len(face.vertices) == 3:
                                    vert = mesh.vertices[index]
                                    model_output_string += '%s     %s     %s     ' % (integer_to_string(vert.co.x), integer_to_string(vert.co.y), integer_to_string(vert.co.z))
                                    model_output_string += '%s     %s\n' % (integer_to_string(faceUV.uv[i][0]), integer_to_string(1-faceUV.uv[i][1]))
                                    vert_count+=1
                                    i+=1
    else:
    #else if the model has no UV map
            uv_layer = mesh.tessface_uv_textures.active
            for face in mesh.tessfaces:
                    for index in face.vertices:
                            if len(face.vertices) == 3:
                                    vert = mesh.vertices[index]
                                    model_output_string += '%s     %s     %s     ' % (integer_to_string(vert.co.x), integer_to_string(vert.co.y), integer_to_string(vert.co.z))
                                    model_output_string += ';     ;\n'
                                    vert_count+=1
    writeString(file, str(vert_count) + '\n')
    writeString(file, model_output_string)
    #end the model output
    #output the file and close it for editing
    file.flush()
    file.close()

Currently it takes every triangle in the scene and generates a file with the following format:

<number of triangles>
<triangle1.vertex1.x> <triangle1.vertex1.y> <triangle1.vertex1.z> <triangle1.vertex1.u> <triangle1.vertex1.v>
<triangle1.vertex2.x> <triangle1.vertex2.y> <triangle1.vertex2.z> <triangle1.vertex2.u> <triangle1.vertex2.v>
<triangle1.vertex3.x> <triangle1.vertex3.y> <triangle1.vertex3.z> <triangle1.vertex3.u> <triangle1.vertex3.v>
.
.
.
<triangleN.vertexN.x> <triangleN.vertexN.y> <triangleN.vertexN.z> <triangleN.vertexN.z> <triangleN.vertexN.v>

This part works fine. The issue is that I also need to save the texture data as well.

Each triangle has a texture, at least, assuming the model being saved is textured. We'll go under the assumption that the models are textured when being saved. It will make my work easier. The format I want to save it in is of the following format. The format dictates the need for two files.

The geometry file:

<number of triangles>
<number of texture batches>
<triangles within batch 1> <texture id of batch 1>
<triangles within batch 2> <texture id of batch 2>
.
.
.
<triangles within batch N> <texture id of batch N>
<triangle1.vertex1.x> <triangle1.vertex1.y> <triangle1.vertex1.z> <triangle1.vertex1.u> <triangle1.vertex1.v>
<triangle1.vertex2.x> <triangle1.vertex2.y> <triangle1.vertex2.z> <triangle1.vertex2.u> <triangle1.vertex2.v>
<triangle1.vertex3.x> <triangle1.vertex3.y> <triangle1.vertex3.z> <triangle1.vertex3.u> <triangle1.vertex3.v>
.
.
.
<triangleN.vertexN.x> <triangleN.vertexN.y> <triangleN.vertexN.z> <triangleN.vertexN.z> <triangleN.vertexN.v>

The texture file:

<number of textures>
<texture filename 1>
<texture filename 2>
.
.
.
<texture filename N>

I have no clue on how to get the filename of the texture for each triangle. What I would like is to be able to take each triangle as I iterate through them and put the filename of the texture associated with that triangle into an array. I can then take that array myself and make sure none of the texture ids are duplicated and that any sequential faces with the same texture get into the same branch. A later "upgrade" might be to take the triangles and sort them into batches so that no texture id is recycled, but that can also be done in the program they are being loaded into (and it would be way easier at that end then in the python model exporter).

I keep hearing something about texture slots material, but honestly I have no clue what that means at all other than that in computer graphics the material dictates data regarding the physical roughness and smoothness of some surface (aka polygon aka triangle). I do not need anything from the material other than the filename, so a solution that does not make it convenient to go back and add other properties to this export is perfectly acceptable. There will not be any support added later for more material stuff. The software this is being loaded into does not support such data, PERIOD.

For those wondering I'm on blender v2.79 as reported by the software. If a convenient solution requires an upgrade, that is perfectly acceptable. I am only on 2.79 because I don't use blender really at all and I just haven't yet bothered to go download the new version to get feature upgrades I'll probably never use.

I've also heard that supposedly this code does not grab everything in the scene. I'm not familiar enough to know whether this is the case or not. If this is the case please let know in the comments. I can make a separate question to look into getting that corrected (assuming I can't fix it myself).

Answer 1

There is no such a single file for material in Blender. Material is assigned to face for sure. And Material may contain diffuse color texture and other texture if present.

In the list object.data.polygons, you should find an entry for material index call face.material_index. Then you will need to find what texture you want to export to the file. Again, Blender and all other 3D software use their own format to manage the material. You will need to write your own converter to make it possible to export to file or text in your case.

Also, a similar github project to export obj can be found here

Answer 2

What I have determined is that even within my own editing process there is definitively no single answer on where to get the texture.

There are two means by which texture data is being supplied to any models I might be viewing or editing or what-have-you. The first method is that I directly drag and drop an image file into the uv editing window with a mesh selected. For whatever reason I cannot locate the exact mechanism by which the texture is then accessible to other scripts such as the obj export (which can and does export the texture filename into its material file). This is acceptable, because the obj export works with it.

The other method is to load an obj file with a material file attached to it. With the obj file loaded in the following script appears to print the texture filename for every triangle in the scene. I tested with 5-6 obj models both from me exporting a mesh made by me via dragging and dropping textures and from me loading old obj files I have received from other people.

import bpy

texture_list = []
for obj in bpy.context.scene.objects:
    if obj.type == 'MESH':
        for f in obj.data.polygons:
            mat = obj.material_slots[f.material_index].material
            # Iterate over all the current material's texture slots
            for t in mat.texture_slots:
                # If this is an image texture, with an active image append its name to the list
                if t and t.texture.type == 'IMAGE' and t.texture.image:
                    texture_list.append( t.texture.image.name )
print(texture_list)
print(len(texture_list))

The script above is an amalgam of the scripts given in the answers to this question:

How to get the name of image of "Image Texture" with python?

I wouldn't say I wouldn't say I understand fully how my script works. Basically I took the component of the one (accepted answer's) script of "loop through the objects face data" and merged it with the other script's component of compatible material examination.

This can in turn be restructured to be merged with my scripts current loop. I might post an update later to show the completed thing, but the actual difficulty of "how in the world do I get the texture data?!?!" has been resolved - architectural organization/integration of code is trivial.

I will not be accepting this answer though as it definitely leaves a bad taste in my mouth. I definitely do not like the idea of obj model export somehow working where mine fails and me having to try and accommodate for this, but it is at least viable enough to be worth sharing with anyone having similar pains. I don't condone hacks, but at least this works...