PBR (physically based rendering) approximates how real materials react to light and is used in most modern games. True PBR is a part of Community Shaders that has several benefits:
To use PBR you will need to obtain Community Shaders (included in base CS) and True PBR texture packs. But remember, those texture packs will not work without Community Shaders enabled (that means it won't render correctly in tools like the Creation Kit, Outfit Studio, and Bodyslide). If you are not a texture creator you can safely ignore everything else described below.
All the following sections are only relevant to you if are creating textures for Skyrim yourself.
To generate a set of True PBR textures you need to do two things:
For a mesh to be recognized as PBR, it must have in BSLightingShaderProperty:
To tweak PBR settings for the mesh the following parameters of BSShaderProperty can be used:
To set up PBR meshes in batch, you can use PGPatcher (formerly ParallxGen). Patching is useful when retexturing vanilla meshes because there are thousands of them and users might have custom mesh additions or mesh fixes using the same textures. Check the PG mod author wiki for details on the json configs.
To get descriptions for PBR properties and basic rendering of PBR in Nifscope, use this version of Nifskope: Nifskope with PBR support.
In that version, flags and properties are renamed to match their function for PBR if you have the PBR flag enabled.
Be aware that the PBR rendering of this Nifskope version is incorrect - there is no cubemap (no shiny environment reflections visible) and the diffuse colour is brighter than it should be. Special features like subsurface scattering, fuzz, hair, and dual layer material aren't rendered at all in that version (or in a very broken way). So don't rely it as a reference for how your texture looks in the game.
Texture slot (starts at 1) - description of the texture
Textures that represent colours in the game (base colour, emission, fuzz colour, coat colour, subsurface colour) should be in sRGB colour space (also called "gamma" or gamma 2.2 in some software) and should be saved with the sRGB DDS flag.
You can also export your textures in linear space and save them in the linear DDS format, but that makes you lose colour precision in the parts of the spectrum most relevant for human vision.
All textures that do not represent colours in the game (normal maps, displacement, rmaos) should always be in linear space and saved in the linear DDS format.
Landscape texture is assumed to be PBR if a json file with the same name as the texture set record's EDID is found in 'data\PBRTextureSets'. For 'LandscapeDirt02 [TXST:00000C0F]' it would be 'LandscapeDirt02.json'
The texture paths are defined in the texture set record in the ESP:
Texture slot in the ESP (starts at 0) - descriptions of the texture
The texture set json file contains the values that are normally defined in the mesh:
{
"roughnessScale" : 1.0,
"displacementScale" : 0.25,
"specularLevel" : 0.04
}
Since landscape textures are also used on nifs, you also need matching entries for the same textures in a PBRNifPatcher json, so that PGPatcher can apply the textures to the nifs.
If you want an easier start into landscapes, you can use Faultier's PBR landscape modders resource. It includes a json file for PGPatcher, a set of jsons for the texture set records, a set of jsons for the material objects (projected snow and ash), and a plugin with patched texture paths in the texture set records used for landscape.
If any of the textures in a quad is PBR, then the entire quad is rendered as PBR. If there is a vanilla-style texture among them, there is some internal conversion going on to make it look not too wrong, but a rule of thumb is to only release complete landscape mods - so make sure to also cover DLCs, because those DLC places heavily reuse textures from the base game. Also, landscape LOD will not be rendered as PBR (blends together in the distance) - Dyndolod and xlodgen will create vanilla-style LOD textures out of your PBR textures (on the user side).
Subsurface Scattering is a rendering technique that simulates the scattering of light inside objects. It's somewhat similar to vanilla soft lighting and back lighting.
It's most useful for foilage (trees, plants), some fabrics (like banners), or candles (wax), dragon wings (vanilla uses back lighting there).
Be aware that it always has the backlighting effect, so if your glass armor has subsurface scattering, it will look like the light passes through the player. So make sure to use it only where it actually makes sense to pass through.
You can also use baked thickness or transmission textures to create the textures.
Parameters:
Subsurface scattering is incompatible with dual layer material, fuzz, and glint, but compatible with parallax and emission.
Glint as a rendering technique refers to the simulation of small, bright highlights or sparkles on a surface, typically due to the interaction of light with fine details or textures. These highlights are often seen on materials with very small, reflective features like glitter, polished metals, or certain fabrics. Glint effects are important in creating realistic materials in computer graphics, especially in cases where the surface has microscopic variations that cause light to scatter and reflect in a particular way.
Very useful for snow and sand, but can also be nice on some types of rock.
There is no special texture for it, so it's applied to the entire bstrishape, replacing the standard specular model.
The glint algorithm that CS uses is a modified version of this (Youtube video)
Parameters:
Glint on landscape can be tweaked in real time via the texture set json editor in the CS menu (advanced section). Since texturing software doesn't support glint (or not the same one as CS), this is the only way to tweak glint settings with direct visual feedback. So even if you want to use it on something other than landscape, it's easiest to test it on a landscape texture to find the right values, then copy them to wherever you want to use glint.
Glint is incompatible with dual layer material or fuzz, but compatible with subsurface scattering, parallax, and emission.
[
{
"texture": "landscape\\snow01", "emissive": false, "parallax": true, "subsurface": false,
"glint":
{
"screen_space_scale": 2.0,
"log_microfacet_density": 10.0,
"microfacet_roughness": 1.0,
"density_randomization": 5.0
},
"specular_level" : 0.02, "subsurface_color": [1,1,1], "roughness_scale" : 1, "subsurface_opacity" : 1, "displacement_scale" : 0.2
}
]
Fuzz as a rendering technique is used to simulate the appearance of soft, fibrous materials, such as velvet, some furs, peach fuzz, or certain types of cloth. This effect is crucial for rendering surfaces that have a fine layer of fibers or tiny hairs that interact with light in a distinctive way, producing a soft, diffuse reflection.
Parameters:
Fuzz is incompatible with dual layer material or glint, but compatible with subsurface, parallax, and emission.
{
"texture": "clothes\\example", "emissive": false, "parallax": false, "subsurface": false, "specular_level" : 0.04, "subsurface_color": [1,1,1], "roughness_scale" : 1, "subsurface_opacity" : 1, "displacement_scale" : 0,
"fuzz":
{
"texture": true,
"color": [1.25,1.25,1.25],
"weight": 1.0
}
}
The hair model in True PBR uses the Marschner hair model, which simulates diffuse, specular, and light scattering in 3D hair.
CS PBR has hair model shading which is in experimental state.
Parameters:
Hair model is a completely different shading model so incompatible with anything else. Be aware that it's only useful for actual 3D hair or fur. The usual painted on fur that you find on vanilla armors is not the right place for this shader.
For actual character hair, use the Hair Specular feature of CS instead. It uses a similar (but more fleshed out) version of the same technique.
Dual Layer Material (True PBR's equivalent to Multilayer Parallax) is used to render a semitransparent coat over a regular PBR material. It can be used in multiple ways:
Dual Layer Material can be used with normal meshes (like crystals, ice cave walls, stalhrim armor), but not with terrain.
Not compatible with glint, fuzz, or subsurface scattering, but compatible with parallax and emission (the glow will come from the lower layer).
Parameters:
So as a summary, the extra textures are as follows:
("coat parallax" in the json actually refers to the interlayer parallax)
[
{
"texture": "icicle", "emissive": false, "parallax": true, "subsurface": false,
"specular_level" : 0.02, "subsurface_color": [1,1,1], "roughness_scale" : 1, "subsurface_opacity" : 1, "displacement_scale" : 1.0,
"multilayer": true,
"coat_strength": 1.0,
"coat_roughness": 1.0,
"coat_specular_level": 0.02,
"coat_diffuse": true,
"coat_parallax": true,
"coat_normal": true
}
]
Material Objects (MATO) are records in Bethesda plugins like ESPs and ESMs. Only MATOs with the 'single pass' flag can be rendered as PBR - the effect will be rendered on top of the underlying material, wrapping to its normal map and parallax. Note that single pass MATOs are incompatible with vanilla multilayer parallax and with the parallax shader type. They are compatible with complex material, though. MATOs can only be rendered as PBR if they are applied to PBR-enabled surfaces.
A MATO is enabled for PBR by setting it to single pass in the plugin and placing a json with the same name as its editor ID into data/PBRMaterialObjects.
Inside that json, you can multiply the colour, the specular strength, roughness scale, and optionally enable glint or fuzz (only without a texture).
{
"baseColorScale": [
0.98,
0.98,
1.0
],
"glintParameters": {
"densityRandomization": 5.0,
"enabled": true,
"logMicrofacetDensity": 13.0,
"microfacetRoughness": 1.0,
"screenSpaceScale": 1.0
},
"roughness": 0.7,
"specularLevel": 0.02
}
Many programs can be used to work with PBR textures. To generate textures from scratch, you can use for example Substance Designer or Material Maker (free). To edit, mix and apply materials to meshes, you can use Quixel Mixer (free), ArmorPaint (free, if you compile it yourself), InstaMat (free), or Substance Painter. In this short guide I will show the workflow I use to retexture vanilla meshes.
The following workflow is based on Quixel Mixer and Chainner:
Optionally change percentages of Resize nodes to downscale your textures before saving.
To make batch changes more easily and quickly while testing, set up a testing folder and set up PGtools (mod author tool that is part of PGPatcher). More info in the PGPatcher Github wiki.
To pick the correct specular strengths for your materials, you can use this table.
Change the engine (top left corner) to Unreal Engine. A specular strength of 0.5 in the table equals 0.04 in CS's system. According to that, most materials should use 0.04, and snow, ice, and water should use 0.02, and diamond 0.16.
Auto Parallax: If you have the experimental option of Auto Parallax enabled (available in the settings ini), it enables parallax (switches to the parallax shader type and enables the parallax flag) on meshes that use the default shader type and don't have an alpha property, if it finds a _p texture. That is often the case for PBR-enabled meshes, resulting in very dark looking, vanilla-rendered textures. Solution: disable that option, or disable Auto Parallax entirely - PGPatcher replaces its functionality anyway.
Terrain Parallax Blending fix and Falskaar: If you use PBR landscapes, they're applied via the vanilla texture set records that are used on landscape. If a mod now changes which texture set records are used on landscape (by editing the LTEX records), then your textures won't be used. Solution: uninstall Terrain Parallax Blending fix. It's completely unncessary if you're using PBR landscapes, because PBR preserves the vanilla decal behavior (parallax is a separate texture, so transparency can be in the alpha channel of the base colour map, just like in vanilla). And in Falskaar's case, there's a mod that reverts it back to using vanilla landscape texture sets, so that texture mods work with it.
Mods that mess with specular or glossiness values of meshes at runtime (to simulate wetness): with PBR, these values mean different things and you'd use wildly different values than in vanilla, resulting completely borked presentation when these mods are used. They need specific settings tuned for PBR to work as intended.
complex material landscape mod winning the ESP conflict vs your PBR landscape ESP: a complex material mod that changes the texture paths of vanilla landscape texture set records will conflict with your PBR landscape mod. The texture set jsons are still there though, so the complex material textures will be rendered by the PBR shader. Because the blue channel (metalness for CM) for landscape is usually zeroed, you get full strength AO everywhere (killing all ambient lighting), which leads to all terrain in the shadows appearing black. Solution: tell users to uninstall the CM landscape mod, or to let your plugin win the load order conflict.
For more details I recommend this article.
You use the specular texture if you have materials like gems or ice in the same texture as surfaces with other specular values (like wood or leather). In that case, set the specular strength in the mesh to the highest among the materials in your texture.
If you have a diamond (0.16) and some leather (0.04) in your texture, set the specular strength to 0.16, make the diamond part in the specular map to 1 (fully white) and the leather parts to 0.25 (dark grey). The dark grey (0.25) of the leather will be multiplied with the specular strength of 0.16, resulting in 0.04 - the correct specular strength for leather.
If there is only one type of surface in your texture, you can leave the specular map at 1 (fully opaque) and set the specular scale in the nif/json configuration. In that case you can save your rmaos as BC1, cutting the file size in half.
Specular maps can also be used artistically to weaking reflections in cavities. The visual impact is on the subtle side, and it leads to doubling the file size of your rmaos texture (because you can't use BC1 in that case).
To pick the correct specular strengths for your materials, you can use this table.
Change the engine (top left corner) to Unreal Engine. A specular strength of 0.5 in the table equals 0.04 in CS's system. According to that, most materials should use 0.04, and snow, ice, and water should use 0.02, and diamond 0.16.
If you want to change the parallax scale of your texture because it looks to flat, instead of changing the displacement map better try to adjust parallax scale in the json for the nif patcher. This usually creates good results. Only touch the texture if you want to tweak the relative height of things inside your texture.
No, only default PBR (no cubemap), parallax, and glow. No subsurface, fuzz, glint or other fancy effects. And the diffuse colour is too bright.