Why Does My Roughness Map Look Too Shiny? A Diagnostic Field Guide

The fastest diagnosis separates texture bytes from material behavior

A flat scalar value is more useful than an artistic repaint because it removes the image as a variable. If known flat values produce the expected sharp-to-broad sequence, the shader can respond correctly and the remaining problem is in the authored values, inversion, packing, or import. If flat values fail, editing the texture cannot repair the graph or scene.

Keep the camera, environment, exposure, material class, normal map, and clear-coat state fixed during each A/B. Roughness controls the angular spread of reflected light. It does not switch reflections off, and it does not replace metalness or dielectric base reflectance.

The measured PLAYTEX AI source stays in a deliberately rough range

The evidence set uses a repository PLAYTEX AI PBR Map Generator output at 1024 × 1024. After deterministic Rec. 709 luminance extraction, the roughness values span 0.6275 to 0.9804, with mean 0.7421 and standard deviation 0.0453. No pixels fall below 0.05 and no pixels exceed 0.95.

Those figures do not prove physical accuracy. They prove which bytes entered the two delivery contracts. The exact 8-bit inversion produced a maximum round-trip delta of 0 bytes, so the Unity smoothness alpha can be traced back to the canonical roughness source without an unrecorded transform.

Unity and Unreal consume different delivery contracts

For the Unity evidence export, metallic occupies RGB and smoothness occupies alpha. Smoothness is computed as 255 minus each roughness byte, and the packed texture is treated as linear data with sRGB disabled. The export sheet is a byte-verified contract proof, not a Unity viewport capture: the installed Unity 2022.3.42f1 editor could not render unattended without local license activation.

For the Unreal evidence export, the canonical roughness is delivered directly and sampled with sRGB disabled using mask or linear-color semantics. Unreal material graphs remain configurable, so a project can choose another channel; the proof describes the documented direct-input setup rather than every possible graph.

What this evidence does and does not establish

The downloadable manifest records source paths, dimensions, method, metrics, SHA-256 digests, engine versions, and expected import settings. It makes the export reproducible and catches inversion or channel-layout mistakes. The images are lossless 8-bit PNGs generated from the same approved source maps.

The test does not claim cross-engine pixel equivalence. BRDF implementation, reflection filtering, normal filtering, exposure, tone mapping, mipmaps, GPU compression, clear coat, and project lighting can all change the visible result. The destination renderer and shipping build remain the final review surface.

Controls that can make a correct map look glossy

Source-value checks

These controls change the values before engine-specific packing.

• Output convention: Roughness keeps black smooth and white rough; smoothness reverses that direction. Invert exactly once only when the destination explicitly expects smoothness or gloss.
• Black point: Sets where values begin reaching the smooth end of the range. Raise it carefully when isolated dark noise creates pin-sharp sparkles. Do not crush valid coated or polished regions.
• White point: Sets where values reach the roughest end of the range. Lower it when genuinely rough regions never become broad enough under the controlled scene.
• Contrast: Expands or compresses local differences around the middle of the range. Reduce it when the material looks patchy, sparkles at distance, or flips abruptly between wet and dry.

Import and shader checks

A correct PNG can produce the wrong material when its bytes are interpreted incorrectly.

• sRGB / color-space flag: An sRGB decode reshapes midrange bytes before the material receives them. Turn sRGB off for roughness, smoothness, metallic, AO, and packed numeric textures.
• Sampled channel: Selects which component actually drives the roughness or smoothness input. Match the export contract: direct R for a standalone map, G for common ORM, or A for Unity metallic smoothness.
• Compression and mipmaps: Quantize and filter roughness variation for runtime use. Inspect them when block-shaped highlights appear or the surface changes finish as the camera moves away.

Run the shortest test that can isolate the failure

If a roughness map looks too shiny, first confirm that a smoothness or gloss map is not connected to a roughness input. Then verify linear data import, the sampled channel, the scalar range, and the lighting used for judgment. In a roughness map, black is smooth and white is rough.

Step 1: Lock the comparison scene

Use one neutral dielectric material, fixed camera and exposure, and a high-contrast environment with recognizable reflected shapes. Disable artistic post effects while diagnosing. A changing light rig can hide or imitate a roughness change.

Step 2: Replace the texture with a flat 0.7 value

A roughness value around 0.7 should produce a broad, soft response in a conventional metallic-roughness shader. If it still appears sharp, the texture is not the first suspect: inspect the socket, material model, metalness or F0, normal strength, reflection environment, and tone mapping.

Step 3: Compare the map with its exact inverse

If the inverse immediately restores the expected response, the source was smoothness or gloss, or the pipeline inverted roughness twice. Use Roughness Map Generator to preview the direction, but keep only one documented inversion in production.

Inspect and invert roughness

Step 4: Prove the imported scalar bytes

Disable sRGB for standalone roughness and packed material data. Confirm the shader reads the intended channel. A mid-gray test patch should remain the intended numeric value after import; color decoding must not reshape it.

Step 5: Restore one material input at a time

Reconnect roughness, then normal, metallic, AO, and other layers separately. This identifies cross-channel problems such as a metallic mask connected to roughness, a packed-channel mismatch, or normal detail that makes highlights look unnaturally tight.

Step 6: Export the destination contract and retest at distance

Review the coordinated stack in PBR Map Generator, then create the Unity or Unreal layout with PBR Engine Converter. Inspect the imported texture, mip levels, and runtime compression at representative camera distances before approval.

Build the coordinated material

Common fixes that create a second problem

• Inverting first without proving the destination convention; a second inversion restores the original failure under a new filename.
• Leaving sRGB enabled because the map is visually grayscale; grayscale appearance does not make scalar data a color texture.
• Judging roughness under an empty, uniform, or overexposed environment that contains no readable reflected shapes.
• Using metallic as a general shininess slider; material class and reflection spread solve different problems.
• Assuming a packed texture uses the same channels in every renderer. ORM, Unity masks, and custom Unreal graphs are different contracts.
• Repainting albedo to hide a fixed highlight before the roughness socket and reflection environment have been tested.
• Approving only the source PNG and never checking the imported mip chain or runtime compression.

Why does my roughness map make everything shiny?

The most common causes are a smoothness or gloss map used as roughness, sRGB decoding on scalar data, the wrong packed channel, values clustered near black, or a material and lighting setup that makes reflections look stronger than expected. Test a flat 0.7 roughness value before editing the texture.

Should a roughness map be inverted?

Only when the source is actually smoothness or gloss, or when the destination specifically expects smoothness. For normalized data, smoothness equals one minus roughness. Keep that conversion at one named handoff step.

Should roughness use sRGB?

No. Roughness stores numeric material data and should normally use linear or non-color sampling. The same rule applies when roughness is packed with AO and metallic.

Which channel should contain roughness?

A standalone grayscale file can use red. Common ORM stores roughness in green. Unreal material graphs are configurable. Unity metallic workflows commonly store smoothness—not roughness—in alpha. The shader contract is authoritative.

Why does the material still look glossy with a white roughness map?

Confirm the white map is connected and sampled as linear data. Then inspect the environment, exposure, tone mapping, metalness or specular F0, clear-coat layers, and normal map. Rough surfaces still reflect light; roughness spreads the reflection rather than deleting it.

Can base-color brightness generate correct roughness?

Not by itself. A photograph combines lighting, exposure, pigment color, shadows, and reflections rather than measuring microscopic surface slopes. Luminance can seed an editable map, but material references and a lit review are still required.