PBR Materials Explained Metallic-Roughness vs Specular-Glossiness

Before PBR, artists tuned material parameters by eye for each lighting setup. Move the object to a different environment and the material breaks. PBR eliminates this problem by grounding shading in measurable physical properties.

The core idea is the bidirectional reflectance distribution function (BRDF), a mathematical model that describes how much light reflects off a surface at any combination of viewing angle and light direction. Modern PBR implementations use the Cook-Torrance microfacet BRDF, which models a surface as a collection of tiny flat mirrors (microfacets) oriented at random angles. The roughness parameter controls how spread out those orientations are.

This model was popularized by Brent Burley's 2012 presentation at SIGGRAPH, where he described the "Disney Principled BRDF" used in Wreck-It Ralph. That work directly influenced the Principled BSDF shader in Blender, the Standard shader in Unity, and the material model in Unreal Engine. The glTF 2.0 specification, published by the Khronos Group in 2017, adopted a simplified version of this model as its core material system.

For anyone working with 3D assets today, understanding PBR is not optional. It is the foundation of every major game engine, web renderer, and AR platform.

The defining rule of physically based shading is that a surface cannot reflect more light than it receives. This is energy conservation, and every PBR material must obey it.

When light hits a surface, it splits into two parts: specular reflection (light that bounces off the surface) and diffuse reflection (light that enters the surface, scatters, and exits). The energy equation requires that specular + diffuse never exceeds the incoming light. In the Cook-Torrance model, this is enforced by computing the Fresnel term first and subtracting it from the diffuse contribution.

Metals are a special case. They absorb all light that penetrates the surface, so metals have zero diffuse reflection. Their entire visible appearance comes from specular reflection, and the reflected light is tinted by the metal's color. Gold reflects more red and green wavelengths than blue, which is why it appears yellow. Copper reflects more red wavelengths, producing its characteristic warm tone.

Non-metals (dielectrics) reflect a small amount of light specularly, typically about 4% at a head-on viewing angle. The rest enters the surface, scatters, and produces the diffuse color we see. This 4% value is consistent across most non-metallic materials, from plastic to skin to wood. It corresponds to an index of refraction of roughly 1.5, which covers glass, acrylic, and most organic materials.

Metallic-roughness is the industry standard. It is the core material model of glTF 2.0, the default in Unity, Unreal Engine, Godot, Blender, and three.js. If you are creating 3D content today, this is almost certainly the workflow you should use.

The model uses two primary parameters to describe a surface:

• Metallic (0.0 to 1.0): A binary classification. Set to 0.0 for non-metals (plastic, wood, fabric, stone, skin) and 1.0 for raw metals (steel, aluminum, gold, copper). Gray values between 0 and 1 should only appear at transition boundaries, like the edge where rust meets bare metal or where paint chips off a metallic surface.
• Roughness (0.0 to 1.0): Controls how blurry or sharp reflections appear. A value of 0.0 creates a perfect mirror surface. A value of 1.0 creates a fully diffuse surface with no visible reflections. Most real materials fall somewhere in between.

A third parameter, base color, provides the surface color. For non-metals, base color is the diffuse albedo (the color of the material itself). For metals, base color defines the specular reflection color. This dual meaning is what makes the metallic parameter so important: it tells the shader how to interpret the base color.

The underlying BRDF is the Cook-Torrance microfacet model with three components:

• Normal Distribution Function (D): The GGX (Trowbridge-Reitz) distribution, which controls the shape and size of specular highlights. Rougher surfaces produce larger, softer highlights.
• Geometry Function (G): The Smith-GGX model, which accounts for microfacet self-shadowing. At high roughness values, microfacets block each other, reducing overall reflectivity.
• Fresnel Term (F): Schlick's approximation, which increases reflectivity at grazing angles. Every surface becomes more reflective when viewed edge-on. For metals, this reflection is colored. For non-metals, it is white.

The full specular BRDF formula is: f = (D * G * F) / (4 * dot(N,V) * dot(N,L)), where N is the surface normal, V is the view direction, and L is the light direction. You never write this yourself; the shader handles it. But understanding it helps explain why certain material values produce the results they do.

The metallic-roughness workflow uses a compact set of texture maps. The glTF 2.0 specification defines the packing format precisely.

Base Color Map: An sRGB encoded texture containing the albedo for non-metals or the specular color for metals. This map should contain no baked lighting, no ambient occlusion, and no directional shadows. Pure, clean color only.

Metallic-Roughness Map: A single texture with two channels packed together. The green channel stores roughness values. The blue channel stores metallic values. The red channel is either unused or reserved for ambient occlusion (in glTF, AO is the red channel of the occlusionTexture, which may share the same image). This texture must be encoded in linear color space, not sRGB, because the values are fed directly into mathematical computations.

Normal Map: A tangent-space normal map in linear RGB. Each pixel encodes a surface direction that adds fine geometric detail without increasing polygon count. Standard convention is X in the red channel, Y in the green channel, and Z in the blue channel.

Occlusion Map: Ambient occlusion stored in the red channel. This darkens areas where indirect light has difficulty reaching, such as crevices and folds. It affects only indirect (ambient) lighting, not direct lights.

Emissive Map: An sRGB texture defining areas that emit light. Used for screens, LEDs, glowing elements, and similar self-illuminating surfaces.

This packing scheme is efficient. Metallic and roughness fit in a single texture, saving a texture slot and GPU memory compared to workflows that store each parameter separately.

The specular-glossiness workflow predates metallic-roughness and was common in game production before the PBR transition. It gives artists direct control over the specular reflection color and the surface smoothness.

The model uses three parameters:

• Diffuse (RGB): The base color of the surface for diffuse reflection. For metals, this should be set to black (0, 0, 0) since metals have no diffuse component.
• Specular (RGB): The Fresnel reflectance at normal incidence (F0). For non-metals, this is typically a uniform gray around sRGB value 56 (approximately 4% linear reflectance). For metals, this is a bright, colored value representing the metal's reflection color.
• Glossiness (0.0 to 1.0): The inverse of roughness. A glossiness of 1.0 means a perfectly smooth mirror. A glossiness of 0.0 means a fully rough, matte surface. The conversion is straightforward: roughness = 1.0 minus glossiness.

The main appeal of specular-glossiness is the full RGB control over specular color. In metallic-roughness, non-metal reflectivity is locked to approximately 4% (configurable only through additional extensions). In specular-glossiness, the artist sets F0 directly, allowing fine-tuned control over edge reflections on materials like gemstones, eyes, or coated surfaces.

That freedom comes at a cost: it is easier to break energy conservation. If the diffuse color and the specular color together exceed the incoming light energy, the material will appear unnaturally bright. The metallic-roughness workflow avoids this problem by design: the metallic parameter enforces the physical constraint that metals have zero diffuse and non-metals have fixed low specular.

The specular-glossiness workflow uses a different set of textures, defined by the glTF KHR_materials_pbrSpecularGlossiness extension (now archived).

Diffuse Map: An RGBA texture in sRGB color space containing the diffuse reflection color. The alpha channel provides base transparency.

Specular-Glossiness Map: An RGBA texture where the RGB channels store the specular color (F0) in sRGB space, and the alpha channel stores glossiness in linear space.

Normal, Occlusion, and Emissive Maps: Identical in format and purpose to their metallic-roughness counterparts.

The texture count is similar, but the specular-glossiness workflow stores more information per texture (full RGB specular rather than a single metallic channel). This can require more memory in practice, especially when the specular map needs high resolution to capture material variation across the surface.

This table summarizes the practical differences between the two workflows.

The following reference values are based on physical measurements documented in Google's Filament rendering engine documentation and the Allegorithmic (now Adobe) PBR Guide. Use them as starting points, then adjust roughness to match the specific condition of the surface (worn, polished, dirty, wet).

A few important rules to remember: base color values for non-metals should generally stay within sRGB 50 to 240. Values below 30 are darker than any real-world material except black velvet. Values above 240 are brighter than fresh snow. Going outside this range breaks the physical plausibility that makes PBR work.

For metals, the base color represents the reflection color. Measured F0 values from physical samples: aluminum is (0.91, 0.92, 0.92), gold is (1.0, 0.85, 0.57), copper is (0.97, 0.74, 0.62), and iron is (0.56, 0.57, 0.58), all in linear color space.

Metallic-roughness has become the universal default across the 3D industry. Here is how the major formats and engines handle PBR materials.

glTF 2.0 and GLB: Metallic-roughness is the core specification. No extension needed. The specular-glossiness workflow was available through KHR_materials_pbrSpecularGlossiness, but the Khronos Group archived that extension in 2021. It remains valid for reading older files but is no longer recommended for new content. The newer KHR_materials_specular and KHR_materials_ior extensions provide specular control on top of the metallic-roughness base when needed.

USD and USDZ: Apple's AR format uses the UsdPreviewSurface schema, which follows the metallic-roughness model with parameters for metallic, roughness, and diffuseColor.

FBX: The FBX format has no standardized PBR material definition. PBR properties are stored through vendor-specific conventions, most commonly the "Stingray PBS" namespace used by Maya's Substance plugin. In practice, FBX material fidelity depends entirely on the exporter and importer pair. Expect PBR data loss when moving FBX files between different tools.

OBJ + MTL: The MTL material format predates PBR entirely. It supports Phong shading parameters (ambient, diffuse, specular, shininess) but has no native concept of metallic, roughness, or physically based reflectance. PBR data is lost when converting to OBJ.

Blender: The Principled BSDF shader implements the metallic-roughness workflow natively. Parameters map directly: Base Color, Metallic, Roughness. Blender's glTF exporter writes these properties into standard glTF 2.0 materials with no conversion needed.

Unity: Both the Standard (Built-in) and HDRP Lit shaders use the metallic-roughness model. Unity calls the parameter "Smoothness," which is the inverse of roughness (smoothness = 1 minus roughness).

Unreal Engine: Uses metallic-roughness natively. The material editor exposes Metallic, Roughness, and Base Color inputs directly.

three.js: MeshStandardMaterial implements the metallic-roughness model with metalness and roughness properties. MeshPhysicalMaterial extends it with clearcoat, sheen, transmission, and IOR.

If you have legacy assets in specular-glossiness, you will eventually need to convert them. The math is straightforward but not perfectly reversible.

Specular-glossiness to metallic-roughness: The metallic map is derived by classifying each pixel as metal or non-metal based on the specular and diffuse values. Where the specular color is bright and the diffuse is dark (near black), the pixel is metal. The base color for metal areas comes from the specular map. For non-metal areas, the base color comes from the diffuse map. Roughness equals 1.0 minus glossiness.

Where information is lost: The metallic-roughness workflow constrains non-metal specular reflectivity to approximately 4%. If the original specular-glossiness material had custom specular values for non-metals (for example, a gemstone with high colored reflectance), that information cannot be represented without the KHR_materials_specular and KHR_materials_ior extensions.

Metallic-roughness to specular-glossiness: This direction preserves more information because specular-glossiness is the more expressive format. Metal areas get their base color as the specular value with black diffuse. Non-metal areas use the base color as diffuse with a default gray specular of about sRGB 56. Glossiness equals 1.0 minus roughness.

Tools that handle conversion: Substance 3D Painter can export to either workflow. Don McCurdy's glTF Transform library converts between formats programmatically. The Khronos glTF Sample Viewer handles both workflows for preview. When converting, always compare the output visually under multiple lighting conditions before shipping.

These problems show up frequently in production assets. Catching them early saves hours of debugging in the engine.

• Baking lighting into the base color map. The base color should contain only the raw color of the material. Directional light, ambient occlusion, and shadows belong in separate maps or are computed by the engine at runtime. Baked lighting in the albedo breaks the material under any other lighting setup.
• Using gray metallic values for large areas. Metallic should be 0 or 1 for any uniform surface. A brushed steel panel is 1.0 everywhere. A plastic case is 0.0 everywhere. Gray values are physically meaningful only at transition boundaries, like the few pixels where rust meets bare metal. Large patches of 0.5 metallic will look like no real material.
• Setting metallic to 1 on painted surfaces. Paint is a dielectric coating. Even paint over metal is non-metallic (metallic 0.0) because the surface the light hits first is the paint, not the metal underneath. Only where paint has chipped away to expose raw metal should metallic be 1.0.
• Base color values that are too dark or too bright. Real non-metallic materials have albedo values between roughly sRGB 50 and 240. Charcoal is around 50. Fresh snow is around 240. Values outside this range violate energy conservation assumptions and can produce artifacts in global illumination.
• Uniform roughness across the entire surface. Real objects have roughness variation. Scratches, fingerprints, wear patterns, and surface coatings all create local differences. A roughness map with visible detail at the microscale is what separates a convincing material from a flat-looking one.
• Multiplying ambient occlusion into the specular map. This was common in older rendering pipelines, but in PBR it breaks energy conservation. AO should be a separate map or channel and should affect only ambient (indirect) lighting.
• Ignoring color space. Base color and emissive maps are sRGB. Metallic, roughness, normal, and occlusion maps must be linear. Importing a roughness map as sRGB will shift values, making rough surfaces look smoother and smooth surfaces look rougher.