For a brief tutorial on shaders see: https://github.com/mtijanic/nwnee-shader-tutorials

NWN:EE shaders are the Open GL Shading Language (GLSL) code blocks which are run by the game to render scenes.

Shader Types

There are a few types of shader which run at different points in the rendering process.

As an editor, you have access to three types of shader.

Vertex Shader

This shader helps a scene determine where vertices should be relative to where the client is looking.

Everything rendered between the vertices needs to have this part first so it knows where those vertices will be and can then interpolate what screen pixel will see what texture pixels.

Everything between vertices will be handled by a fragment shader later after getting base information from this shader.

Vertex shaders handle model transforms, such as those passed in from the toolset, those applied by runtime transform effects, and the bones inside skinned models.

Vertex shaders also handle base lighting functions related to how that vertex is oriented with respect to any given light.

Before a vertex shader is run on any given vertex in a mesh, the meshes available are first clipped to the view prism. This is a shape which includes what the engine expects you can see within your visible range, up, down, left and right. Anything not in that view prism will be omitted from the vertex shader for the scene, so you cannot shift distant objects into the view of a player if they're previously clipped. While you can modify how the content in the view prism is drawn, you cannot modify the view prism from inside the vertex shader. Any attempt to see beyond the hardcoded view prism will result in your final scene missing objects that were clipped away.

Each mesh will run its own copy of a vertex shader, which will differ based on what is being rendered. By default, different mesh types will be sent through specific shaders.

You can modify which vertex shader is used via material files. To change the vertex shader, use the command "customshadervs" followed by the name of the shader you want to use.

Fragment Shader

You can think of your screen as a 3D array. You have screen width X screen height X screen depth.

Each mesh or particle anywhere in the depth that needs to be considered for drawing is a fragment.

The fragment shader gets position and base lighting information from the vertex shader, and then finishes most of the rest of drawing.

Fragment shaders only have access to vertex information which is passed forward to them by their vertex shader counterpart.

Each fragment will run its own copy of a fragment shader, which will differ based on what is being rendered. By default, different mesh and particle types will be sent through specific shaders.

You can modify which shaders meshes are sent through using material files. To change the fragment shader, use the command "customshaderfs" followed by the name of the shader you want to use.

Post Processing Shader

Post Processing is what happens after the scene is built with the fragment shaders. This is where you add final touches to the final image.

This is actually a series of connected shader chunks which you can enable/disable. The standard functions currently include:

• Sharpen
• Vibrance
• Depth of Field Blurring
• Screen Space Ambient Occlusion (SSAO)
• Dynamic Contrast
• Gamma Correction
• Special Filters (ex. Toon Filter)

There is only one post processing shader that is used by the whole screen, so cannot define a separate post processing shader for each material.

Post processing shaders do not have access to vertex and fragment information from the individual meshes and particles. They only access the current frame being finished, or the frame buffers of a previous frame.

Standard Uniforms Available to Shaders

Standard Defines Available

Shader Include Files and Hierarchy

The OC shaders have include files which include other include files, not unlike supermodel structure in models and their animations.

ERROR: 1:4352: error(#198) Redefinition error: moduleMinutesPerHour

Include Files

Include Heirarchy

The current stable structure is:

The current patch structure is:

*Only when #define FOG = 1

The current patch water structure:

Red denotes repeated branch. Blue denotes the first instance of an include within the standard tree structure.

Please note that custom and post processing shaders have other structures, sometimes using these includes out of order.

Archived Lists:

Uniforms

* int screenWidth, int screenHeight
Viewport size.

* float nearClip, float farClip
Render clipping cutoff.

* int sceneCurrentFrame
The current render frame. No guarantees to limits or wrapping behaviour.

* int worldtimerTimeOfDay
The current time of day as seen from the game world, in milliseconds. This value will pause when the game pauses.

(MerricksDad: this value is the number of ticks since the client was started. The value is equal to 1444000 ticks per day divided by the number of moduleMinutesPerHour. The additional value appears to be a multi-hour error value related to the number in moduleMinutesPerHour, )

* int windPointSourcesCount (max: 128)
A wind point source is a "explosion" source. You can see this with some spells that bend grass around you.
This is the number of wind point sources for the current frame; you need this to walk the following vectors:

* float windPointSourcesPosition[windPointSourcesCount*3]
A vector of X, Y, Z positions for each windPointSource.

* float windPointSourcesRadius[windPointSourcesCount]
The radius for each windPointSource.

* float windPointSourcesIntensity[windPointSourcesCount]
The intensity for each windPointSource.

* float windPointSourcesTimeRemaining[windPointSourcesCount]
The time remaining for each windPointSource.

* int moduleDawnHour
The module dawn hour (usually something like 8).

* int moduleDuskHour
The module dusk hour (usually something like 16).

* int moduleMinutesPerHour
Minutes per hour. You can use this to calculate the dawn/dusk progression.

* vec3 areaGlobalWind
The global wind vector for the current area (including magnitude).

* int areaWeatherType
The weather type: 0 = clear, 1 = rain, 2 = snow.

* float areaWeatherDensity
The weather density as determined by the engine.

* int areaFlags
A mask of area flags: 1 = interior, 2 = underground, 4 = natural

* int moduleYear
(MerricksDad: testing of moduleYear has shown that it does not always get sent to the shader with correct value. Using this value for any purpose can result in counted effects being misrendered.)

* int moduleMonth
* int moduleDay
* int moduleHour

The module time as seen by the player.

(MerricksDad: moduleHour is the integer value of the true module time. Being converted from a float originally, this value will have loss. Testing has shown the offset in module hour to be multiple seconds forward or backward, meaning this value cannot be used as an exact match for the true moduleHour. The lower moduleMinutesPerHour is, the larger the error will appear.)

* float moduleTimeIntoTransition

(MerricksDad: This value counts up from the last transition, such as moduleDuskHour or moduleDawnHour. It has a few issues. The first issue is that it resets to 0 at multiple points: moduleDawnHour, moduleDawnHour+1, moduleDuskHour, and moduleDuskHour+1. It also resets to 0 when the client enters the game, so its initial value is not useful before the first transition it reached.)
* float moduleTransitionTime
This describes the day/dusk/dawn/night transition animations for areas.

* ivec2 userinputMousePosition
Mouse coordinates.

* int userinputMouseButtons
A mask of mouse buttons currently down: 1 = left, 2 = right, 4 = middle.

* int fogEnabled
1 if fog is enabled.

* int fogMode
Fog mode (0 = linear, 1 = exp, 2 = exp2).

* float fogStart, float fogEnd
Fog render distances.

* vec4 fogColor
The current fog colour.

* int numLights
The number of dynamic lights currently in the scene.

* vec4 globalColor
The global/world colour.

* vec4 frontLightModelProductSceneColor
The scene colour (ambient light).

* vec4 materialFrontAmbient
* vec4 materialFrontDiffuse
* vec4 materialFrontSpecular
* vec4 materialFrontEmissive
* float materialFrontShininess
Material source components.

* vec4 lightAmbient
* vec4 lightDiffuse
* vec4 lightSpecular
* vec4 lightPosition
* vec4 lightHalfVector
* float lightConstantAtten
* float lightLinearAtten
* float lightQuadraticAtten
Light source parameters.

* int texUnitXX (where 0 <= XX < 14)
* int texUnitEnv
* int textureXXBound (where 0 <= XX < 14)
Bound textures.

* vec4 texCoordOffset0, vec4 texCoordOffset1
* float texCoordRot0, float texCoordRot1
Bound textures position and rotation.

* mat4 m_m
* mat4 m_mv
* mat4 m_mvp
Model, ModelView and ModelViewProjection matrices for vertex transformations.

* mat3 m_normal
Matrix for vertex normal transformations.

In addition to the uniforms, the following vertex attributes are exposed:

* vec4 vPos
Vertex position in object space.

* vec2 vTcIn
Texture coordinates for current texture.

* vec4 vColor
Active colour for the vertex.

* vec3 vNormal
Current vertex untransformed normal.

UPDATE: info posted by Sherincall on the nwvault #custom-content Discord channel on Monday 17 Feb, 2020:

📎 uniforms available to all shaders:

sceneCurrentFrame
worldtimerTimeOfDay
windPointSourcesCount
windPointSourcesPosition
windPointSourcesRadius
windPointSourcesIntensity
windPointSourcesTimeRemaining
moduleDawnHour
moduleDuskHour
moduleMinutesPerHour
moduleYear
moduleMonth
moduleDay
moduleHour
moduleTimeIntoTransition
moduleTransitionTime
areaGlobalWind
areaWeatherType
areaWeatherDensity
areaFlags
userinputMousePosition
userinputMouseButtons
m_mvp
m_mv
m_m
m_normal
m_texture
m_view
m_proj
m_vp
m_view_inv
m_proj_inv
m_vp_inv
m_bones[128]
idxmap[128]
lightAmbient[8]
lightDiffuse[8]
lightPosition[8]
lightQuadraticAtten[8]
numLights
FragmentLighting
GammaCorrection
materialFrontAmbient
materialFrontDiffuse
materialFrontSpecular
materialFrontEmissive
materialFrontShininess
frontLightModelProductSceneColor
globalColor
texUnit{0..14}
texUnitEnv
texture{0..15}Bound
fSchemeRow{0..14}
fogEnd
fogMode
fogStart
fogColor
fogEnabled
cameraPitch
cameraYaw
cameraPosition
cameraViewAngle
cameraDialogState
startFadePitch
keyholeCanDissolve
keyholeRadius
nearClip
farClip
screenWidth
screenHeight
AORadius
AOIntensity
AOColor
blackPoint
whitePoint
Vibrance
RGBBalance
DOFAmount
Gamma
playerPosition
playerOrientation
playerInCutscene
playerCameraDist

(plus whatever MTR+nwscript pass, for individual objects)