A PBR texture set can include both a normal map and a height map, but Unity URP does not use them for the same job. The normal map changes the surface direction used for lighting. The height map can drive parallax mapping in the URP Lit shader, shifting the visible texture coordinates to create an additional sense of depth.
That distinction matters because parallax is still a shading technique. It can make brick joints, stone relief, or other recessed detail respond to the camera with more depth than a normal map alone, but it does not add vertices or change the actual silhouette of the mesh. If you are coming from Blender displacement or another renderer that can physically move geometry, Unity's Height Map input can look familiar while doing something quite different.
What the Height Map input does in Unity URP
Unity's current URP Lit shader documentation describes the Height Map input as a parallax-mapping effect. URP uses the height data to shift which part of the surface texture is visible, creating surface-level occlusion as the viewing angle changes.
The mesh itself stays where it is. A flat plane with a brick height map remains a flat plane around its outer edge. What changes is the texture lookup across the visible face. This is why parallax can make mortar appear recessed when you move the camera while still failing to produce a real broken silhouette at the edge of the object.
The value beside the Height Map controls the strength of the effect. Higher values produce more apparent depth, but they also make artifacts easier to see. Unity's documentation recommends treating the setting as a multiplier rather than assuming the full grayscale range of a height texture corresponds to a physically meaningful depth.
How to connect a height map to the URP Lit shader
Create or select a material using Universal Render Pipeline/Lit. In the material inspector, enable the height or parallax-related options exposed by the Lit shader and assign the grayscale height texture to Height Map. Start with a low height value and increase it while looking at the material from several camera angles.
A height map is data rather than display color, so it should be treated as a linear data texture rather than as albedo. Keep its UV scale aligned with the base color, normal, roughness-derived smoothness, and metallic textures. If the brick color tiles four times across an object while the height map tiles once, the apparent depth will no longer line up with the surface features.
The direction of the grayscale data also matters. A conventional height map uses brighter values for higher parts of the surface and darker values for lower parts, but source conventions are not universal. If mortar appears to rise while brick faces sink, verify the source map before compensating with an extreme parallax value.
Height maps and normal maps solve different problems
A tangent-space normal map stores directional information used by the lighting calculation. It can make small pits, scratches, pores, and bevel-like detail react to light without moving the mesh or shifting texture coordinates. Unity imports these through the Normal map texture type and provides a Flip Green Channel option when the source normal uses a different Y convention. The Unity normal-map import documentation covers those import settings.
A height map stores scalar elevation. In URP Lit, that elevation is used for parallax. Because the apparent texture position changes with the camera, parallax can give larger recesses more depth than normal mapping alone. It also costs more and can produce visible distortion when pushed too far.
For many materials, using both is reasonable. The normal map can carry fine surface response while the height map supplies broader camera-dependent relief. The maps should describe the same underlying surface, though. If the normal says a groove runs through one area while the height map places the recess somewhere else, the lighting and parallax will disagree.
Using twirl height maps in Unity URP
twirl currently provides separate albedo, normal, roughness, metallic, and height maps. That gives you the original height data instead of baking a Unity-specific parallax choice into the material. In URP, you can use the height texture in the Lit shader's Height Map input and decide how much parallax makes sense for the scene.
The other maps still need Unity-specific handling. The albedo goes to Base Map, the normal should be imported as a normal map, and roughness needs to be inverted when the shader expects smoothness. Our Unity URP roughness map guide covers that conversion and the current Lit channel-packing layout.
The twirl Unity page covers the broader material workflow. If you need a new tileable source set, the AI PBR material generator creates the separate five-map material. A Unity integration is (coming soon), so URP shader setup and engine-specific packing are currently manual steps.
Parallax is not true displacement
This is the most important limitation to keep in mind when moving a height map between applications. In Blender Cycles, a height texture can be used for true displacement when the material and mesh are configured for it. The renderer can physically move the surface, which can change the silhouette and create geometric relief.
URP Lit's Height Map does not do that. Unity describes the effect as parallax mapping, where visible texture regions are shifted to simulate depth. The geometry is unchanged. If you need a stone edge to physically break the outline of a wall, a standard Lit height map will not create that shape for you.
This difference also affects shadows. Parallax can make the material look deeper from the camera without creating the same geometry that a light would see for shadow casting. For close hero assets where the shape itself matters, modeling the larger forms or using a shader designed for a different displacement technique may be more appropriate than increasing URP parallax strength.
Our normal map vs height map guide is written around Blender, but the underlying distinction between directional normal data, scalar height data, and true geometry displacement is useful when moving the same PBR set between tools.
Why strong parallax starts to look wrong
Parallax works by offsetting texture coordinates based on height and view direction. As the viewing angle becomes more oblique, the offset becomes more noticeable. That is also where the approximation is easiest to expose.
If the height multiplier is too high, surface features can appear to slide, stretch, or separate from the geometry. Sharp jumps in the height map can be especially difficult because the shader is trying to represent abrupt depth changes without actually creating the missing geometry. Older Unity documentation for parallax mapping calls out the same limitation and recommends gradual height transitions and restrained depth values.
This is one reason a height map should not be treated as a generic detail-strength control. If a material feels flat, increasing parallax until it looks dramatic from one camera angle can make it unstable from another. Check the material at the distances and grazing angles that will actually appear in the project.
When a normal map is enough
Small-scale material detail usually does not need parallax. Fine concrete grain, leather pores, brushed marks, shallow scratches, and subtle plaster texture can often be represented efficiently with a normal map because the camera does not need to perceive meaningful depth between the high and low parts of the surface.
Parallax becomes more useful when the surface contains recognizable relief that should shift with viewpoint. Brick mortar, layered stone, deep cracks, cobbles, and pronounced carved patterns are better candidates, especially when the surface is viewed at an angle but does not need a physically displaced silhouette.
Distance matters too. On a wall that occupies a small part of the frame, the extra camera-dependent depth may not survive at all. The normal map can carry the visible lighting detail without paying for an effect the viewer cannot resolve. For close surfaces, the difference is easier to justify.
Height maps are not roughness maps
Both textures are often grayscale, which makes them easy to confuse when filenames are poor. Their values describe unrelated properties. Height represents relative elevation. Roughness represents the microsurface response that controls how broad or sharp reflections appear.
Unity URP commonly uses smoothness rather than roughness, so a roughness map needs to be inverted before it is used in that workflow. That conversion does not turn it into height data. Likewise, inverting a height map does not produce a useful smoothness map.
If a downloaded texture set has ambiguous files, identify the maps before wiring the shader. Height usually follows the visible high and low structure of the material, while roughness follows changes between matte and polished regions. The roughness map vs gloss map guide covers the inverse roughness and smoothness relationship in more detail.
A practical Unity URP height-map workflow
Start by getting the material correct without parallax. Set up Base Map, normal, metallic, and smoothness first so you know the basic surface response is working. Then add the height texture to the URP Lit Height Map input with a low strength.
Move the camera rather than judging the effect from one front-facing view. The useful part of parallax is the way depth changes with view direction, so a straight-on comparison can hide both its benefit and its artifacts. Check the material at the closest expected distance and at the most oblique angle likely to appear in the scene.
If the material only needs fine shading detail, keep the normal map and leave height out. If broader recesses benefit from camera-dependent depth, add restrained parallax. If the actual silhouette has to change, the standard URP Lit Height Map is the wrong tool because the effect never becomes real geometry.
That makes the height map useful without treating it as a required slot in every PBR material. It is source data you can choose to use when the surface, camera, and performance budget make parallax worthwhile.