Qt Quick 3D Custom Material Reference

 bool evalTwoSided()

 float computeIOR()

 float evalCutout()

 vec3 computeNormal()

 void computeTemporaries()

 void initializeLayerVariables()

 void initializeLayerVariablesWithLightmap()

 vec3 computeFrontMaterialEmissive()

 vec3 computeBackMaterialEmissive()

 void computeFrontLayerColor( in vec3 normal, in vec3 lightDir, in vec3 viewDir,
                              in vec3 lightDiffuse, in vec3 lightSpecular,
                              in float materialIOR, in float aoFactor )

 void computeFrontAreaColor( in int lightIdx, in vec4 lightDiffuse, in vec4 lightSpecular )

 void computeFrontLayerEnvironment( in vec3 normal, in vec3 viewDir, in float aoFactor )

 void computeBackLayerColor( in vec3 normal, in vec3 lightDir, in vec3 viewDir,
                             in vec3 lightDiffuse, in vec3 lightSpecular,
                             in float materialIOR, in float aoFactor )

 void computeBackAreaColor( in int lightIdx, in vec4 lightDiffuse, in vec4 lightSpecular )

 void computeBackLayerEnvironment( in vec3 normal, in vec3 viewDir, in float aoFactor )

 vec4 computeLayerWeights( in float alpha )

 vec4 computeGlass( in vec3 normal, in float materialIOR, in float alpha, in vec4 color )

 vec4 computeOpacity( in vec4 color )

 #include "vertexFragmentBase.glsllib"
 #include "SSAOCustomMaterial.glsllib"
 #include "sampleLight.glsllib"
 #include "sampleProbe.glsllib"
 #include "sampleArea.glsllib"

 vec3 normal;
 vec3 surfNormal;
 vec3 texCoord0;
 vec3 tangent;
 vec3 binormal;
 vec3 viewDir;

 vec3 varTexCoord0;
 vec3 varTexCoord1;
 vec3 varNormal;
 vec3 varTangent;
 vec3 varBinormal;
 vec3 varObjTangent;
 vec3 varObjBinormal;
 vec3 varWorldPos;
 vec3 varObjPos;

 #define QSSG_ENABLE_UV0 1/0
 #define QSSG_ENABLE_WORLD_POSITION 1/0
 #define QSSG_ENABLE_TEXTAN 1/0
 #define QSSG_ENABLE_BINORMAL 1/0

 #define QSSG_ENABLE_CG_LIGHTING
 #define QSSG_ENABLE_LIGHT_PROBE
 #define QSSG_ENABLE_SSAO
 #define QSSG_ENABLE_SSDO
 #define QSSG_ENABLE_SSM
 #define QSSG_ENABLE_RNM

Including functionality from a library

The material can import functions from the shader library using the #include directive. Some functionality requires the user to define the constant and structures of the functionality. For example, to use the blendColorLayers function the user must specify the mono_xxx constants and the texture_return and color_layer structure (at least once) before including them in their material.

 #define mono_alpha 0
 #define mono_average 1
 #define mono_luminance 2
 #define mono_maximum 3

 struct texture_return
 {
     vec3 tint;
     float mono;
 };

 struct color_layer
 {
     vec3 layer_color;
     float weight;
     int mode;
 };

 #include "blendColorLayers.glsllib"

 texture_return blendColorLayers( in color_layer colorLayer[1], in vec3 base, in int monoSource );

Some includes require additional functionality to work correctly. For example fileBumpTexture requires these additional includes and defines:

 #include "luminance.glsllib"
 #include "monoChannel.glsllib"
 #define wrap_clamp 0
 #define wrap_repeat 1
 #define wrap_mirrored_repeat 2
 #include "rotationTranslationScale.glsllib"
 #include "transformCoordinate.glsllib"

Includable Functions

microfacetBSDF

 #define scatter_reflect 0
 #define scatter_transmit 1
 #define scatter_reflect_transmit 2

 #include "calculateRoughness.glsllib"
 #include "microfacetBSDF.glsllib"

 vec4 microfacetBSDF( in mat3 tanFrame, in vec3 L, in vec3 V, in vec3 lightSpecular, in float ior,
                      in float roughnessU, in float roughnessV, in int mode )

This function calculates light value for rough surface using microfacet BSDF lighting model. The return value is 4-component rgba vector.

 vec4 microfacetSampledBSDF( in mat3 tanFrame, in vec3 viewDir, in float roughnessU,
                             in float roughnessV, in int mode )

This function calculates light value for rough surface using microfacet BSDF lighting model based on environment map. The environment map is specified with the uEnvironmentMap property. The return value is 4-component rgba vector.

physGlossyBSDF

 #define scatter_reflect 0
 #define scatter_transmit 1
 #define scatter_reflect_transmit 2

 #include "physGlossyBSDF.glsllib"

 vec4 kggxGlossyBSDF( in mat3 tanFrame, in vec3 L, in vec3 V, in vec3 lightSpecular, in float ior,
                      in float roughnessU, in float roughnessV, in int mode )

This function calculates light value for glossy surface using the GGX BSDF. The return value is 4-component rgba vector.

 vec4 wardGlossyBSDF( in mat3 tanFrame, in vec3 L, in vec3 V, in vec3 lightSpecular, in float ior,
                      in float roughnessU, in float roughnessV, in int mode )

This function calculates light value for glossy surface using the Ward BSDF. The return value is 4-component rgba vector.

simpleGlossyBSDF

 #define scatter_reflect 0
 #define scatter_transmit 1
 #define scatter_reflect_transmit 2

 #include "calculateRoughness.glsllib"
 #include "simpleGlossyBSDF.glsllib"

 vec4 simpleGlossyBSDF( in mat3 tanFrame, in vec3 L, vec3 V, in vec3 lightSpecular, in float ior,
                        in float roughnessU, in float roughnessV, in int mode )

This function calculates light value for glossy surface using the simple BSDF. The return value is 4-component rgba vector.

 vec4 simpleGlossyBSDFEnvironment( in mat3 tanFrame, in vec3 viewDir, in float roughnessU,
                                   in float roughnessV, in int mode )

This function calculates light value for glossy surface using simple BSDF lighting model based on environment map. The environment map is specified with the uEnvironmentMap property. The return value is 4-component rgba vector.

sampleProbe

 #include "sampleProbe.glsllib"

 vec4 sampleGlossy( mat3 tanFrame, vec3 viewDir, float roughness )

Calculates specular sample for the light probe. The return value is 4-component rgba vector.

 vec4 sampleDiffuse( mat3 tanFrame )

Calculates diffuse sample for the light probe. The return value is 4-component rgba vector.

sampleArea

 #include "sampleArea.glsllib"

 vec4 sampleAreaGlossy( in mat3 tanFrame, in vec3 pos, in int lightIdx, in vec3 viewDir,
                        in float roughnessU, in float roughnessV )

Computes specular sample for an area light. The return value is 4-component rgba vector.

 vec4 sampleAreaDiffuse( in mat3 tanFrame, in vec3 pos, in int lightIdx )

Computes diffuse sample for an area light. The return value is 4-component rgba vector.

Custom Material with Main Function

It is also possible to write the custom material without the rest of the material system. In this case it is not necessary to write all the functions described above. Each pass needs a main function only.

 out vec4 fragColor;
 void main()
 {
     fragColor = ...
 }

Simple Custom Material Example

 #define QSSG_ENABLE_UV0 1
 #define QSSG_ENABLE_WORLD_POSITION 1
 #define QSSG_ENABLE_TEXTAN 0
 #define QSSG_ENABLE_BINORMAL 0

 #include "vertexFragmentBase.glsllib"
 #include "SSAOCustomMaterial.glsllib"
 #include "sampleLight.glsllib"
 #include "sampleProbe.glsllib"
 #include "sampleArea.glsllib"

 // Set shader output.
 out vec4 fragColor;

 void main()
 {
     vec4 c = texture(basecolor, varTexCoord0.xy);
     c.rgb *= vec3(red_weight, green_weight, blue_weight);
     fragColor = c;
 }

Custom Material Vertex Shaders

Default vertex shader generation can be overridden with a custom vertex shader.

Custom Vertex Shader Example

 in vec3 attr_pos;

 uniform mat4 modelViewProjection;

 out vec3 pos;

 void main() {
     pos = attr_pos;
     pos.x += sin(time * 4.0 + pos.y) * amplitude;
     gl_Position = modelViewProjection * vec4(pos, 1.0);
 }

Default Vertex Shader Inputs

The vertex attributes provided as inputs to the vertex shaders are defined by the mesh files. The following vertex attributes are used by default.

 in vec3 attr_pos;
 in vec3 attr_norm;
 in vec2 attr_uv0;
 in vec3 attr_textan;
 in vec3 attr_binormal;

The following uniforms are provided to shaders.

 uniform mat4 modelMatrix;
 uniform mat4 modelViewProjection;
 uniform mat4 viewMatrix;
 uniform mat3 normalMatrix;
 uniform mat4 viewProjectionMatrix;
 uniform mat4 viewportMatrix;

 uniform vec3 cameraPosition;
 uniform vec2 cameraProperties;

 uniform sampler2D depthTexture;
 uniform sampler2D aoTexture;

 uniform sampler2D lightProbe;
 uniform vec4 lightProbeProperties;
 uniform vec4 lightProbeOptions;
 uniform vec4 lightProbeRotation;
 uniform vec4 lightProbeOffset;

 uniform sampler2D lightProbe2;
 uniform vec4 lightProbe2Properties;

 uniform int lightCount;
 uniform int areaLightCount;
 uniform int shadowMapCount;
 uniform int shadowCubeCount;

 uniform float objectOpacity;

 uniform sampler2D shadowMaps[8];
 uniform samplerCube shadowCubes[8];