GLTFSpecGloss in Godot – Complete Guide

Understanding the intricacies of 3D material settings can be a game-changer, especially for those venturing into the world of game development. The GLTFSpecGloss class in Godot 4 exemplifies an important piece of this puzzle. While it’s part of an archived GLTF extension, grasping its use is beneficial for those looking to import or maintain older 3D assets with specular and glossy texture data. Let’s dive into the world of materials and learn how to wield this knowledge in your game creation journey.

What is GLTFSpecGloss?

GLTFSpecGloss is a class in Godot 4 that manages the data relating to the KHR_materials_pbrSpecularGlossiness extension. This extension is deprecated, yet it’s crucial to understand for developers who need to import older models with materials that use specular and glossiness workflows, as opposed to the more modern metallic-roughness workflow.

What is GLTFSpecGloss used for?

Although not the go-to standard anymore, GLTFSpecGloss helps import and represent older materials that were designed with a specular-glossiness shading model. It’s used for rendering materials with specific reflective properties, and this compatibility is essential for preserving the original appearance of legacy 3D assets.

Why should I learn about GLTFSpecGloss?

Understanding GLTFSpecGloss is vital for developers who need to work with, import, or convert older 3D assets. By learning about this class, you maintain the capability to control and fine-tune the appearance of materials in Godot 4, ensuring that your game has the visual fidelity and the artistic vision you aspire to achieve.

CTA Small Image

Importing a GLTF File with SpecGloss Materials

First, we’ll start by importing a GLTF file that utilizes the SpecGloss extension. Before doing any coding, ensure your model file (.gltf or .glb) is in your project’s folder.

const GLTF_FILE_PATH = "res://path_to_your_model/model.gltf"

func import_spec_gloss_model():
    var importer =
    var scene = importer.import_scene(GLTF_FILE_PATH, 0)

This snippet will import your model with SpecGloss materials and add it as a child node, ensuring that it appears in your game scene.

Converting SpecGloss Materials to Standard Materials

Next, you might want to convert these materials to Godot’s standard material system. Here is how you can loop through the imported mesh instances and convert the materials:

func convert_materials(node):
    for i in range(node.get_child_count()):
        var child = node.get_child(i)
        if child is MeshInstance:
            var material_count = child.get_surface_material_count()
            for j in range(material_count):
                var mat = child.get_surface_material(j)
                if mat is GLTFSpecGloss:
                    var standard_mat = specular_to_standard(mat)
                    child.set_surface_material(j, standard_mat)
                elif child.get_child_count() > 0:

In this code example, specular_to_standard would be a function you’d define that takes a SpecGloss material, reads its properties, and creates a new StandardMaterial with those properties.

Extracting SpecGloss Properties

To convert a GLTFSpecGloss material to a standard material, you need to extract key properties. Here’s how you would do it for the diffuse color and the specular and glossiness properties:

func specular_to_standard(spec_gloss_mat):
    var standard_mat =
    standard_mat.albedo_color = spec_gloss_mat.diffuse_factor
    standard_mat.specular = spec_gloss_mat.specular_factor
    standard_mat.glossiness = spec_gloss_mat.glossiness_factor
    return standard_mat

With the above function, you capture the diffuse color and reflectivity settings from the SpecGloss material and apply them to your new standard material.

Loading Textures from SpecGloss

Many SpecGloss materials will include textures for further detail. Here’s how you can transfer those textures to your new standard material:

func specular_to_standard(spec_gloss_mat):
    var standard_mat =
    # Copy other properties as before...
    if spec_gloss_mat.diffuse_texture:
        standard_mat.albedo_texture = spec_gloss_mat.diffuse_texture
    if spec_gloss_mat.specular_glossiness_texture:
        standard_mat.specular_texture = spec_gloss_mat.specular_glossiness_texture
    return standard_mat

Remember, you need to validate that the textures exist within the SpecGloss before attempting to assign them to avoid any runtime errors.

When continuing to work with textures from SpecGloss materials, we need to pay attention to the texture coordinates provided in the GLTF file. They might be required for correct mapping onto your 3D models. Here’s how you could manage texture coordinates:

func specular_to_standard(spec_gloss_mat):
    var standard_mat =
    # Copy properties and textures as before...

    if spec_gloss_mat.diffuse_texture:
        standard_mat.albedo_texture = spec_gloss_mat.diffuse_texture
        standard_mat.uv1_scale = spec_gloss_mat.diffuse_texture_scale
        standard_mat.uv1_offset = spec_gloss_mat.diffuse_texture_offset

    return standard_mat

This piece of code makes sure the diffuse texture is mapped correctly according to the scale and offset specified in the original material.

In certain cases, you might encounter additional maps such as normal maps or emission maps within your SpecGloss materials, which need to be addressed as well:

func specular_to_standard(spec_gloss_mat):
    var standard_mat =
    # Copy properties, diffuse, and specular textures as before...

    if spec_gloss_mat.normal_texture:
        standard_mat.normal_texture = spec_gloss_mat.normal_texture

    if spec_gloss_mat.emission_texture:
        standard_mat.emission_texture = spec_gloss_mat.emission_texture
        standard_mat.emission_color = spec_gloss_mat.emission_factor

    return standard_mat

By associating the normal and emission textures along with their respective factors, your new material will mimic the original visual characteristics that were intended in the SpecGloss material.

Furthermore, it might be necessary to handle texture transformations for these additional maps as well:

func specular_to_standard(spec_gloss_mat):
    var standard_mat =
    # Copy properties, diffuse, specular textures, and handle their transformations as before...

    if spec_gloss_mat.normal_texture:
        standard_mat.normal_texture = spec_gloss_mat.normal_texture
        # Assume you have methods to extract and apply the UV transformations
        apply_normal_texture_transforms(standard_mat, spec_gloss_mat)

    if spec_gloss_mat.emission_texture:
        standard_mat.emission_texture = spec_gloss_mat.emission_texture
        apply_emission_texture_transforms(standard_mat, spec_gloss_mat)

    return standard_mat

And the utility functions to transform the textures would look something like this:

func apply_normal_texture_transforms(standard_mat, spec_gloss_mat):
    standard_mat.uv2_scale = spec_gloss_mat.normal_texture_scale
    standard_mat.uv2_offset = spec_gloss_mat.normal_texture_offset

func apply_emission_texture_transforms(standard_mat, spec_gloss_mat):
    standard_mat.uv2_scale = spec_gloss_mat.emission_texture_scale
    standard_mat.uv2_offset = spec_gloss_mat.emission_texture_offset

These helper functions ensure that the textures for normals and emissions are accurately placed on the material, maintaining the integrity of the original model. Keeping track and fitting all these textures to their correct material characteristics is critical to ensure your game’s graphics are as immersive as possible.

It should be noted, once these conversions are handled properly, you can easily integrate legacy models within your Godot 4 projects, benefiting from the advanced rendering techniques of the engine while preserving the aesthetic of your older assets.

Finally, always remember that while this might seem like a lot of manual work if you’re dealing with many models or complex assets, a well-crafted script can automate most of these processes, making your life significantly easier and your development process more efficient.

At this point, you’ve got the basic idea of converting SpecGloss materials to standard ones, but let’s continue to refine our approach. For example, handling transparency can be quite crucial for accurately representing materials that are partially see-through:

func specular_to_standard(spec_gloss_mat):
    var standard_mat =
    # Copy previous properties, textures, and transformations...

    # Handle transparency
    if spec_gloss_mat.alpha_mode == "BLEND":
        standard_mat.flags_transparent = true

    return standard_mat

With this addition, our standard material will now consider the alpha mode settings from the SpecGloss material and set transparency appropriately.

Sometimes, to achieve a more realistic look, we have to tweak the roughness property mirroring how light interacts with the material surface:

func specular_to_standard(spec_gloss_mat):
    var standard_mat =
    # Copy previous properties, textures, and transformations...

    # Convert glossiness to roughness
    standard_mat.roughness = 1.0 - spec_gloss_mat.glossiness_factor

    return standard_mat

This gives us the roughness property as the inverted glossiness factor, which is how Godot’s standard PBR materials expect to handle reflections.

In the case of dealing with occlusion maps, which are utilized to simulate ambient shadowing effects, we should also take them into account:

func specular_to_standard(spec_gloss_mat):
    var standard_mat =
    # Copy previous properties, textures, transformations, roughness...

    if spec_gloss_mat.occlusion_texture:
        standard_mat.ao_texture = spec_gloss_mat.occlusion_texture

    return standard_mat

The above snippet includes the ambient occlusion texture if provided, enhancing the detail and depth of the material appearance.

Don’t forget to deal with double-sided materials which can be important in materials like foliage or cloth:

func specular_to_standard(spec_gloss_mat):
    var standard_mat =
    # Copy previous properties, textures, transformations, roughness, occlusion...

    # Handle double-sided materials
    if spec_gloss_mat.double_sided:
        standard_mat.cull_mode = CullMode.DISABLED

    return standard_mat

This adjustment ensures that your material will render on both sides of your geometry, which is a common requirement for certain types of surfaces.

Lastly, let us not neglect the importance of detail maps which can add a finer level of texture to a surface beyond what’s provided by other maps:

func specular_to_standard(spec_gloss_mat):
    var standard_mat =
    # Copy previous properties, textures, transformations, roughness, occlusion, double-sided...

    if spec_gloss_mat.detail_texture:
        standard_mat.detail_albedo_texture = spec_gloss_mat.detail_texture

    return standard_mat

Implementing a detail albedo texture, your standard material simulates more intricate surface characteristics, providing a richer visual experience.

The power of Godot 4 lies in its flexibility to adapt to various needs, and by translating older material systems to it, you unlock the potential of your assets while leveraging Godot’s modern rendering capabilities.

Remember that understanding the mapping of these material properties is an essential part of the conversion process. It ensures that your application capitalizes on Godot’s rendering engine capabilities, producing appealing visuals while keeping backward compatibility with older assets.

We at Zenva pride ourselves on empowering developers with the knowledge they need to bring their creative visions to life. Whether it’s through dealing with legacy material systems or utilizing the newest features of engines like Godot 4, we strive to furnish you with comprehensive and engaging tutorials.

Continuing Your Game Development Journey

The path to mastering game development is an ongoing adventure, filled with learning and experimenting. As you dive deeper into working with materials, shaders, and the Godot 4 engine, remember that this is just the tip of the iceberg. To further your skills and bring your unique game ideas to life, consider exploring our Godot Game Development Mini-Degree. This comprehensive collection of courses will guide you through the entire process of creating games with Godot 4, from foundational concepts to more complex mechanics.

Our curriculum is designed to be accessible for beginners, yet challenging enough for more seasoned developers who wish to refine their craft. At Zenva, we’re committed to providing high-quality content that empowers you to not just learn, but to excel in game development. With our wide range of tutorials and courses, you can grasp everything from the basics of GDScript to advanced topics such as AI and physics for your 3D and 2D games. Moreover, for a broader exploration of what Godot has to offer, please check out our assortment of Godot courses. These are designed to help you strengthen your technical expertise and develop industry-relevant skills at your own pace, on any device.

Each step you take with Zenva is a building block towards achieving your game development goals. We’re here to provide the crucial knowledge and practical experience you need. Let’s continue this journey together, turning your vision into reality with each line of code you write!


Your exploration of GLTFSpecGloss and mastery over legacy material systems underscores the pivotal role of adaptability and knowledge in game development. As you equip yourself with these proficiencies, the once daunting task of importing and refining older 3D assets becomes an exciting pathway to enhancing your game’s aesthetic and performance in Godot 4.

By choosing to expand your skills with us at Zenva’s Godot Game Development Mini-Degree, you are setting the stage for success in an ever-evolving industry. We’re here to help illuminate each step, ensuring that your journey from novice to seasoned developer is as smooth and rewarding as possible. Turn your dreams into playable realities, and let’s continue crafting incredible gaming experiences together!

Python Blog Image

FINAL DAYS: Unlock coding courses in Unity, Godot, Unreal, Python and more.