MaterialsV-Ray for 3ds Max

V-Ray for 3ds Max

GLSL Support

The V-Ray extensions for GLSL (vrayGLSL for short) add several functions and variables that can be used in GLSL shaders with the GLSL Map | VRayGLSLTex texture and the VRayGLSLMtl material. See the Examples section for some samples.

Last updated 23 April 2026

Overview

Additional Preprocessor Defines

__VRAY_GLSL__=110

__VRAY_HOST__=300

Additional Type Qualifiers

__channel

<code data-v-c2b1f83f="">#version 110 __channel vec2 UVSpace = vec2(0.314);void main() { UVSpace = vec2(gl_TexCoord[0]); gl_FragColor = vec4(0.3, 0.8, 0.2, 1.0);}</code>

__persistent

<code data-v-c2b1f83f="">#version 110 __persistent __channel vec2 UVSpace = vec2(0.314); void main() { UVSpace = vec2(gl_TexCoord[0]); discard; gl_FragColor = vec4(0.3, 0.8, 0.2, 1.0);}</code>

__color

Built-In Varying Variables

<code data-v-c2b1f83f="">varying vec4 gl_TexCoord[16];</code>

<code data-v-c2b1f83f="">varying vec3 vr_Position;</code>

<code data-v-c2b1f83f="">varying vec3 vr_Normal;</code>

<code data-v-c2b1f83f="">varying vec3 vr_TexTangent;</code>

<code data-v-c2b1f83f="">varying vec3 vr_TexBinormal;</code>

<code data-v-c2b1f83f="">varying vec3 vr_Direction;</code>

<code data-v-c2b1f83f="">varying vec3 vr_Velocity;</code>

<code data-v-c2b1f83f="">varying int vr_TotalRayDepth;</code>

<code data-v-c2b1f83f="">varying int vr_DiffuseRayDepth;</code>

<code data-v-c2b1f83f="">varying int vr_NumSuperSamples;</code>

<code data-v-c2b1f83f="">varying int vr_SuperSampleIndex;</code>

<code data-v-c2b1f83f="">varying int vr_RayFlags;</code>

<code data-v-c2b1f83f="">varying vec3 vr_Origin;</code>

<code data-v-c2b1f83f="">varying vec3 vr_GeomNormal;</code>

<code data-v-c2b1f83f="">varying vec3 vr_TextureDu[16];</code>

<code data-v-c2b1f83f="">varying vec3 vr_TextureDv[16];</code>

Built-In Uniform Variables

<code data-v-c2b1f83f="">uniform int vr_NumLights;</code>

<code data-v-c2b1f83f="">uniform mat4 vr_CameraToWorld;</code>

<code data-v-c2b1f83f="">uniform mat4 vr_WorldToCamera;</code>

<code data-v-c2b1f83f="">uniform mat4 vr_CameraToObject;</code>

<code data-v-c2b1f83f="">uniform mat4 vr_ObjectToCamera;</code>

<code data-v-c2b1f83f="">uniform vr_FrameDataSettings vr_FrameData;</code>

Built-In Constants

<code data-v-c2b1f83f="">const int VR_TRACE_REFRACT;</code>

<code data-v-c2b1f83f="">const int VR_TRACE_REFLECT;</code>

<code data-v-c2b1f83f="">const int VR_TRACE_TRANSPARENT;</code>

<code data-v-c2b1f83f="">const int VR_TRACE_ENVIRONMENT;</code>

<code data-v-c2b1f83f="">const int VR_REFLECT_FLAG;</code>

<code data-v-c2b1f83f="">const int VR_REFRACT_FLAG;</code>

<code data-v-c2b1f83f="">const int VR_SHADOW_FLAG;</code>

<code data-v-c2b1f83f="">const int VR_INDIRECT_FLAG;</code>

<code data-v-c2b1f83f="">const int VR_GLOSSY_FLAG;</code>

<code data-v-c2b1f83f="">const int VR_ENVIRONMENT_FLAG;</code>

<code data-v-c2b1f83f="">const int VR_SPECULAR_DISPERSAL;</code>

<code data-v-c2b1f83f="">const int VR_GLOSSY_DISPERSAL;</code>

<code data-v-c2b1f83f="">const int VR_DIFFUSE_DISPERSAL;</code>

Built-In Types

<code data-v-c2b1f83f="">struct vr_LightIterator { vec3 direction; // unit vector pointing towards the light source in camera coordinates. float dot_nl; // dot product of the surface normal (possibly bumped) and the light direction. vec3 contribution; // the direct light contribution from this light including atmospheric effects and distance falloff.};</code>

<code data-v-c2b1f83f="">struct vr_FrameDataSettings { int frameIndex; // Current frame index. float frameTime; // Time of the current frame in ticks. float frameStart; // Start of the frame in time. Usually frameStart <= frameTime <= frameEnd. float frameEnd; // End of the frame in time. Usually frameStart <= frameTime <= frameEnd. bool isOrthographic; // True if camera rays are parallel. float focalLength; // The camera's focal length. float aperture; // The camera's aperture. float aspectRatio; // The pixel aspect ratio. vec2 imagePlaneOffset; // The camera plane offset. float dofRadius; // The depth of field radius. float dofFocus; // The distance from the camera position to the focal plane. ivec2 imageResolution; // Width and height of the entire output image in pixels ignoring the render region. ivec4 regionMargin; // Render region margin in pixels.};</code>

<code data-v-c2b1f83f="">struct vr_Color { float r; // Red color component. float g; // Green color component. float b; // Blue color component. float a; // Alpha color component.};</code>

<code data-v-c2b1f83f="">uniform vr_Color diffuse_color = vr_Color(0.9, 0.2, 0.8, 1.0);</code>

<code data-v-c2b1f83f="">struct vr_DiffuseBRDFSettings { vec3 color; // The diffuse color for the BRDF. Default value is vec3(1.0, 1.0, 1.0). vec3 normal; // The normal for which to calculate the BRDF. Default value is vec3(1.0, 1.0, 1.0). float roughness; // Diffuse deviation in the [0.0, 1.0] range. Default value is 0.0. vec3 transparency; // The transparency of the BRDF. Default value is vec3(0.0, 0.0, 0.0).};</code>

<code data-v-c2b1f83f="">struct vr_GlossyBRDFSettings { vec3 color; // The specular(reflection) color for the BRDF. Default value is vec3(1.0, 1.0, 1.0). vec3 normal; // The normal for which to calculate the BRDF. Default value is vec3(1.0, 1.0, 1.0). float highlightGlossiness; // Highlight glossiness of the BRDF in the [0.0, 1.0] range. Default value is 0.7. float reflectionGlossiness; // Reflection glossiness of the BRDF in the [0.0, 1.0] range. Default value is 0.7. int subdivs; // Amount of samples for the glossy reflection. Default value is 8. float anisotropy; // Anisotropy of the BRDF in the (-1.0, 1.0) range. Default value is 0.0. bool traceReflections; // Set if the BRDF should trace reflections. Default value is true. vec3 transparency; // The transparency of the BRDF. Default value is vec3(0.0, 0.0, 0.0). float softenEdge; // Amount of softening the transition from dark to bright areas in specular reflections in the [-1.0, 1.0] range. Default value is 0.001. float anisoRotation; // Rotation of the BRDF anisotropy in degrees. Default value is 0.0.};</code>

<code data-v-c2b1f83f="">struct vr_MirrorBRDFSettings { vec3 color; // Filter color of the BRDF. Default value is vec3(1.0, 1.0, 1.0). vec3 normal; // The normal for which to calculate the BRDF. Default value is vec3(1.0, 1.0, 1.0). vec3 transparency; // The transparency of the BRDF. Default value is vec3(0.0, 0.0, 0.0).};</code>

<code data-v-c2b1f83f="">struct vr_GlassBRDFSettings { vec3 color; // Filter color of the BRDF. Default value is vec3(1.0, 1.0, 1.0). vec3 normal; // The normal for which to calculate the BRDF. Default value is vec3(1.0, 1.0, 1.0). float glossiness; // Glossiness of the BRDF in the [0.0, 1.0] range. Default value is 0.7. float ior; // Surface index of refraction for the BRDF. Default value is 1.5. int subdivs; // Amount of samples for the glossy reflections/refraction. Default value is 8. vec3 transparency; // The transparency of the BRDF. Default value is vec3(0.0, 0.0, 0.0).};</code>

<code data-v-c2b1f83f="">struct vr_LightBRDFSettings { vec3 color; // Light color of the BRDF. Default value is vec3(1.0, 1.0, 1.0). vec3 transparency; // The transparency of the BRDF. Default value is vec3(0.0, 0.0, 0.0). bool doubleSided; // Makes the BRDF double sided. Default value is false. bool emitOnBackSide; // Makes the BRDF emit light from its back side as well. If this is off, the material is rendered as black on the back sides. Default value is true.};</code>

<code data-v-c2b1f83f="">struct vr_TraceOptions { int rayType; // One of the built-in constants VR_TRACE_REFLECT, VR_TRACE_REFRACT, VR_TRACE_TRANSPARENT or VR_TRACE_ENVIRONMENT. See Built-in constants. Default values is VR_TRACE_REFLECT. int rayGroup; // One of the VR_SPECULAR_DISPERSAL or VR_GLOSSY_DISPERSAL built-in constants. See Built-in constants. Default value is VR_SPECULAR_DISPERSAL. float ior; // Surface index of refraction at the current hit point. Ignored unless tracing a refracted ray. Default value is 1.44. vec3 ray; // User specified ray to be traced. Must be a unit vector in camera space. Default value is vec3(0.0, 0.0, 0.0). vec3 normal; // The surface normal (possibly bumped) according to which the reflections/refraction will be calculated. Must be a unit vector in camera space. Default value is vec3(0.0, 0.0, 0.0).};</code>

<code data-v-c2b1f83f="">struct vr_OcclusionOptions { float radius; // This parameters determines the amount of area (in units) where the ambient occlusion is calculated. Default value is 10.0. float distribution; // This parameter forces the sampling rays to gather closer to the surface normal. For evenly distributed samples use 0.0. For maximum surface normal concentrated sampling use 1.0. Allowed value range is [0.0, 1.0]. Default value is 0.0. float falloff; // This parameter controls the speed of the transition between occluded and unoccluded areas. Default value is 0.0. int subdivs; // This parameter holds the number of samples that V-Ray takes to calculate the occlusion effect. Lower values render faster but produce a more noisy result. Default value is 8.};</code>

Built-In Functions

<code data-v-c2b1f83f="">void vr_evalLight(int lightIndex, vec3 position, vec3 normal, out vr_LightIterator light);</code>

<code data-v-c2b1f83f="">vec4 vr_trace(vr_TraceOptions traceOptions);</code>

<code data-v-c2b1f83f="">vec3 vr_irradiance(vec3 normal, float importance);</code>

<code data-v-c2b1f83f="">vec3 vr_randomSample(int sampleIndex, int totalSamples)</code>

<code data-v-c2b1f83f="">vec3 vr_textureSize(sampler1D sampler);</code>

<code data-v-c2b1f83f="">float vr_occlusion(vr_OcclusionOptions options);</code>

<code data-v-c2b1f83f="">vec4 textureCube(samplerCube sampler, vec3 sampleDir);</code>

Built-in BRDF functions

<code data-v-c2b1f83f="">void vr_brdf_diffuse(vr_DiffuseBRDFSettings brdfSettings);</code>

<code data-v-c2b1f83f="">void vr_brdf_phong(vr_GlossyBRDFSettings brdfSettings);</code>

<code data-v-c2b1f83f="">void vr_brdf_blinn(vr_GlossyBRDFSettings brdfSettings);</code>

<code data-v-c2b1f83f="">void vr_brdf_ward(vr_GlossyBRDFSettings brdfSettings);</code>

<code data-v-c2b1f83f="">void vr_brdf_glass(vr_GlassBRDFSettings brdfSettings);</code>

<code data-v-c2b1f83f="">void vr_brdf_mirror(vr_MirrorBRDFSettings brdfSettings);</code>

<code data-v-c2b1f83f="">void vr_brdf_light(vr_LightBRDFSettings brdfSettings);</code>

Unsupported GLSL Features

<code data-v-c2b1f83f="">vec3 tangent = vr_TexTangent;vec3 binormal = vr_TexBinormal;vec3 normal = (gl_FrontFacing) ? vr_Normal : -vr_Normal;mat3 vr_TextureToCamera = mat3(tangent, binormal, normal);</code>

GPU Support

Feature	GPU Support

Feature	GPU Support
Built-in variables
gl_NormalMatrix	Always identity matrix.
gl_ModelViewMatrixTranspose	Always identity matrix.
gl_TextureMatrix	Always identity matrix.
gl_TextureMatrixInverse	Always identity matrix.
gl_TextureMatrixInverseTranspose	Always identity matrix.
gl_TextureMatrixTranspose	Always identity matrix.
gl_ModelViewMatrixInverseTranspose	Always identity matrix.
gl_FogFragCoord	Always is a zero.
gl_TexCoord[]	All gl_TexCoord[] elements are identical, i.e. multiple UVW channels are not supported. 1
Built-in functions
dFdx(); dFdy()	Always return zero.
fwidth()	Always returns zero.
V-Ray extensions to GLSL
vr_Velocity	Always is a zero.
vr_NumSuperSamples	Always is 1.
vr_SuperSampleIndex	Always is 1.
vr_TextureDu[]	Not supported.
vr_TextureDv[]	Not supported.
vr_VertexData[]	Not supported.
vr_FrameData	Only the following are supported: vr_FrameData.focalLength vr_FrameData.aperture vr_FrameData.dofFocus vr_FrameData.dofRadius vr_FrameData.imageResolution vr_FrameData.imagePlaneOffset
vr_trace()	Not supported.
vr_evalLight()	Not supported. If attempted to call it will assign the following constants to the output light iterator: light.dot_nl = -1.0 light.contribution = vec3(0.0, 0.0, 0.0) light.direction = vec3(0.0, 0.0, 0.0)
vr_intersect()	Not supported.
BRDF	Only the following BRDF calls are supported 2: vr_brdf_diffuse() vr_brdf_glass() vr_brdf_mirror() vr_brdf_ggx()
Keywords	The following keywords are ignored: __channel __persistent

Examples

Example: Cool Metallic

Rendered shader

Shader parameters

<code data-v-c2b1f83f="">#version 110__color uniform vec4 front_color = vec4(1.0, 1.0, 0.0, 1.0);__color uniform vec4 background_color = vec4(1.0, 0.0, 1.0, 1.0);uniform float amount = 0.8;uniform float diffuse_scalar = 0.7;uniform float specular_scalar = 0.06;uniform float specular_shininess = 200.0;float phong_specular(vec3 light_dir, vec3 view_dir, vec3 normal, float specular_shininess) { vec3 reflection = reflect(view_dir, normal); float cos_rl = clamp(dot(reflection, light_dir), 0.0, 1.0); return (pow(cos_rl, specular_shininess) * (specular_shininess + 2.0));}void main() { vec3 normal = (gl_FrontFacing) ? vr_Normal : -vr_Normal; vec3 position = vr_Position; vec3 direction = vr_Direction; float dot_dn = clamp(-dot(direction, normal), 0.0, 1.0); float mix_value = 1.0 - pow(dot_dn, 1.0 / amount); vec4 diffuse_color = mix(front_color, background_color, mix_value); vec4 specular_color = vec4(1.0, 1.0, 1.0, 1.0); vec4 diffuse = vec4(0.0, 0.0, 0.0, 1.0); vec4 specular = vec4(0.0, 0.0, 0.0, 1.0); vec4 raw_diffuse = vec4(vec3(diffuse_color) * diffuse_scalar, 1.0); vec4 raw_specular = vec4(vec3(specular_color) * specular_scalar, 1.0); vec4 temp = raw_diffuse + raw_specular; float max_color_comp = max(max(temp.r,temp.g),temp.b); if (max_color_comp > 1.0) { raw_diffuse.rgb /= max_color_comp; raw_specular.rgb /= max_color_comp; } vr_LightIterator light; for (int i = 0; i < vr_NumLights; ++i) { vr_evalLight(i, position, normal, light); float cos_nl = clamp(light.dot_nl, 0.0, 1.0); if (cos_nl > 0.0) { diffuse += vec4(vec3(cos_nl) * light.contribution, 0.0); float specular_coeff = phong_specular(light.direction, direction, normal, specular_shininess); specular += vec4(vec3(specular_coeff * cos_nl) * light.contribution, 0.0); } } diffuse *= raw_diffuse; specular *= raw_specular; vec3 gi_contribution = vr_irradiance(normal, 1.0); diffuse += vec4(raw_diffuse.rgb * gi_contribution, 0.0); gl_FragColor = diffuse + specular;}</code>

Example: Generator Stripe

Rendered shader

Shader parameters

<code data-v-c2b1f83f="">#version 110__color uniform vec4 strip_color = vec4(1.0, 0.5, 1.0, 1.0);__color uniform vec4 background_color = vec4(1.0, 1.0, 0.2, 1.0);uniform float width = 0.5;uniform float fuzz = 0.5;uniform float scale = 5.0;uniform float diffuse_scalar = 0.7;uniform float specular_scalar = 0.06;uniform float specular_shininess = 10.0; float phong_specular(vec3 light_dir, vec3 view_dir, vec3 normal, float specular_shininess) { vec3 reflection = reflect(view_dir, normal); float cos_rl = clamp(dot(reflection, light_dir), 0.0, 1.0); return (pow(cos_rl, specular_shininess) * (specular_shininess + 2.0));}void main() { vec3 normal = (gl_FrontFacing) ? vr_Normal : -vr_Normal; vec3 position = vr_Position; vec3 direction = vr_Direction; float scaled_coord_t = fract(gl_TexCoord[0].t * scale); float fract1 = clamp(scaled_coord_t / fuzz, 0.0, 1.0); float fract2 = clamp((scaled_coord_t - width) / fuzz, 0.0, 1.0); fract1 *= (1.0 - fract2); fract1 = smoothstep(0.0, 1.0, fract1); vec4 diffuse_color = mix(strip_color, background_color, fract1); vec4 specular_color = vec4(1.0, 1.0, 1.0, 1.0); vec4 diffuse = vec4(0.0, 0.0, 0.0, 1.0); vec4 specular = vec4(0.0, 0.0, 0.0, 1.0); vec4 raw_diffuse = vec4(vec3(diffuse_color) * diffuse_scalar, 1.0); vec4 raw_specular = vec4(vec3(specular_color) * specular_scalar, 1.0); vec4 temp = raw_diffuse + raw_specular; float max_color_comp = max(max(temp.r,temp.g),temp.b); if (max_color_comp > 1.0) { raw_diffuse.rgb /= max_color_comp; raw_specular.rgb /= max_color_comp; } vr_LightIterator light; for(int i = 0; i < vr_NumLights; ++i) { vr_evalLight(i, position, normal, light); float cos_nl = clamp(light.dot_nl, 0.0, 1.0); if (cos_nl > 0.0) { diffuse += vec4(vec3(cos_nl) * light.contribution, 0.0); float specular_coeff = phong_specular(light.direction, direction, normal, specular_shininess); specular += vec4(vec3(specular_coeff * cos_nl) * light.contribution, 0.0); } } diffuse *= raw_diffuse; specular *= raw_specular; vec3 gi_contribution = vr_irradiance(normal, 1.0); diffuse += vec4(raw_diffuse.rgb * gi_contribution, 0.0); gl_FragColor = diffuse + specular;}</code>

Example: Glossy Glass

Rendered shader

Shader parameters

<code data-v-c2b1f83f="">#version 110const int requiredSamples = 8;uniform float refraction_ior = 1.44;uniform float amount = 0.1;uniform float blend = 1.0;void main() { vec3 normal = (gl_FrontFacing) ? vr_Normal : -vr_Normal; vec3 direction = vr_Direction; vr_TraceOptions options; options.rayGroup = VR_SPECULAR_DISPERSAL; options.ior = refraction_ior; options.normal = normal; if((vr_RayFlags & VR_INDIRECT_FLAG) != 0) { options.rayType = VR_TRACE_REFLECT; vec4 reflection = vr_trace(options); options.rayType = VR_TRACE_REFRACT; vec4 refraction = vr_trace(options); float cos_dn = clamp(-dot(direction, normal), 0.0, 1.0); float lerpFactor = (1.0 - pow(cos_dn, 1.0 / blend)); gl_FragColor = mix(refraction, reflection, lerpFactor); return; } vec3 tangent = vr_TexTangent; vec3 binormal = vr_TexBinormal; int numSuperSamples = vr_NumSuperSamples; int superSampleIndex = vr_SuperSampleIndex; float sum = 0.0; float weights[requiredSamples]; vec4 samples[requiredSamples]; vec4 result = vec4(0.0); // determine how much more samples will be taken for this hit point int nSamples = (requiredSamples > numSuperSamples) ? requiredSamples : numSuperSamples; // max nSamples /= numSuperSamples; int startSampleIndex = superSampleIndex * nSamples; options.rayGroup = VR_GLOSSY_DISPERSAL; for(int i = 0; i < nSamples; ++i) { vec3 randomSample = vr_randomSample(startSampleIndex + i, nSamples); vec2 offset = randomSample.xy - 0.5; offset *= (2.0 * amount); vec3 bumpedNormal = normal + offset.x * tangent + offset.y * binormal; options.normal = bumpedNormal; options.rayType = VR_TRACE_REFLECT; vec4 reflection = vr_trace(options); options.rayType = VR_TRACE_REFRACT; vec4 refraction = vr_trace(options); float cos_dn = clamp(-dot(direction, bumpedNormal), 0.0, 1.0); float lerpFactor = (1.0 - pow(cos_dn, 1.0 / blend)); samples[i] = mix(refraction, reflection, lerpFactor); weights[i] = dot(normal, bumpedNormal); sum += weights[i]; } float inverseSum = 1.0 / sum; for(int i = 0; i < nSamples; ++i) { weights[i] *= inverseSum; result += weights[i] * samples[i]; } gl_FragColor = result;}</code>

Example: Glossy Phong

Shader parameters

<code data-v-c2b1f83f="">#version 110uniform float amount = 0.1;uniform float diffuse_scalar = 0.7;__color uniform vec4 diffuse_color = vec4(0.9, 0.2, 0.8, 1.0);uniform float specular_scalar = 0.06;uniform float specular_shininess = 20.0;const int requiredSamples = 16;float phong_specular(vec3 light_dir, vec3 direction, vec3 normal) { vec3 reflection = reflect(direction, normal); float cos_rl = clamp(dot(reflection, light_dir), 0.0, 1.0); return (pow(cos_rl, specular_shininess) * (specular_shininess + 2.0));}void main() { bool isGIRay = ((vr_RayFlags & VR_INDIRECT_FLAG) != 0); vec3 normal = (gl_FrontFacing) ? vr_Normal : -vr_Normal; vec3 direction = vr_Direction; vec3 position = vr_Position; vec4 raw_diffuse = vec4(vec3(diffuse_color) * diffuse_scalar, 1.0); vec4 raw_specular = vec4(vec3(specular_scalar), 1.0); vec4 temp = raw_diffuse + raw_specular; float max_color_comp = max(max(temp.r,temp.g),temp.b); if (max_color_comp > 1.0) { raw_diffuse.rgb /= max_color_comp; raw_specular.rgb /= max_color_comp; } vec4 diffuse_contrib = vec4(0.0, 0.0, 0.0, 1.0); vec4 specular_contrib = vec4(0.0, 0.0, 0.0, 1.0); // if this is a GI ray do not try to estimate glossy highlights accurately if(isGIRay) { vr_LightIterator light; for(int j = 0; j < vr_NumLights; ++j) { vr_evalLight(j, position, normal, light); float cos_nl = clamp(light.dot_nl, 0.0, 1.0); if (cos_nl > 0.0) { diffuse_contrib += vec4(cos_nl * light.contribution, 0.0); float specular_coeff = phong_specular(light.direction, direction, normal); specular_contrib += vec4(specular_coeff * cos_nl * light.contribution, 0.0); } } } else { vec3 tangent = vr_TexTangent; vec3 binormal = vr_TexBinormal; int numSuperSamples = vr_NumSuperSamples; int superSampleIndex = vr_SuperSampleIndex; float sum = 0.0; float weights[requiredSamples]; vec4 specular_samples[requiredSamples]; // determine how much more samples will be taken for this hit point int nSamples = (requiredSamples > numSuperSamples) ? requiredSamples : numSuperSamples; // max nSamples /= numSuperSamples; int startSampleIndex = superSampleIndex * nSamples; for(int i = 0; i < nSamples; ++i) { vec3 randomSample = vr_randomSample(startSampleIndex + i, nSamples); vec2 offset = (randomSample.xy - 0.5) * 2.0; offset *= amount; vec3 bumpedNormal = normalize(normal + offset.x * tangent + offset.y * binormal); vr_LightIterator light; for(int j = 0; j < vr_NumLights; ++j) { vr_evalLight(j, position, bumpedNormal, light); float cos_nl = clamp(light.dot_nl, 0.0, 1.0); if(cos_nl > 0.0) { diffuse_contrib += vec4(cos_nl * light.contribution, 0.0); float specular_coeff = phong_specular(light.direction, direction, bumpedNormal); specular_samples[i] += vec4(specular_coeff * light.contribution, 0.0); } } weights[i] = dot(normal, bumpedNormal); sum += weights[i]; } float inverseSum = 1.0 / sum; for(int i = 0; i < nSamples; ++i) { weights[i] *= inverseSum; specular_contrib += weights[i] * specular_samples[i]; } diffuse_contrib /= float(nSamples); } diffuse_contrib += vec4(vr_irradiance(normal, 1.0), 0.0); diffuse_contrib *= raw_diffuse; specular_contrib *= raw_specular; gl_FragColor = diffuse_contrib + specular_contrib;}</code>

Example: Glossy Reflection

Rendered shader

Shader parameters

Example: Oren-Nayar

Rendered shader

Shader parameters

<code data-v-c2b1f83f="">#version 110__color uniform vec4 diffuse_color = vec4(1.0, 1.0, 0.0, 1.0);uniform float diffuse_scalar = 0.7;__color uniform vec4 specular_color = vec4(1.0, 1.0, 1.0 ,1.0);uniform float specular_scalar = 0.06;uniform float diffuse_deviation = 0.5;uniform float specular_shininess = 10.0;float orennayar_diffuse(vec3 light_dir, vec3 view_dir, vec3 normal) { float sigma_sqred = diffuse_deviation * diffuse_deviation; float A = 1.0 - (sigma_sqred / (2.0 * (sigma_sqred + 0.33))); float B = (0.45 * sigma_sqred) / (sigma_sqred + 0.09); float cosThetaI = dot(light_dir, normal); float cosThetaO = -dot(view_dir, normal); float sinThetaI = sqrt(max(0.0, 1.0 - (cosThetaI * cosThetaI))); float sinThetaO = sqrt(max(0.0, 1.0 - (cosThetaO * cosThetaO))); float cosPhiI = dot(light_dir, vr_TexTangent); float cosPhiO = -dot(view_dir, vr_TexTangent); float sinPhiI = sqrt(max(0.0, 1.0 - (cosPhiI * cosPhiI))); float sinPhiO = sqrt(max(0.0, 1.0 - (cosPhiO * cosPhiO))); float temp = max(0.0, (cosPhiI * cosPhiO) + (sinPhiI * sinPhiO)); float sinAlpha; float tanBeta; if (cosThetaI > cosThetaO) { sinAlpha = sinThetaO; tanBeta = (sinThetaI / cosThetaI); } else { sinAlpha = sinThetaI; tanBeta = (sinThetaO / cosThetaO); } float result = (A + (B * temp * sinAlpha * tanBeta)); return clamp(result, 0.0, 1.0);} float phong_specular(vec3 light_dir, vec3 view_dir, vec3 normal) { vec3 reflection = reflect(view_dir, normal); float cos_rl = clamp(dot(reflection, light_dir), 0.0, 1.0); return (pow(cos_rl, specular_shininess) * (specular_shininess + 2.0));}void main() { vec3 normal = (gl_FrontFacing) ? vr_Normal : -vr_Normal; vec4 diffuse = vec4(0.0, 0.0, 0.0, 1.0); vec4 specular = vec4(0.0, 0.0, 0.0, 1.0); vec4 diffuse_contrib = vec4(vec3(diffuse_color) * diffuse_scalar, 1.0); vec4 specular_contrib = vec4(vec3(specular_color) * specular_scalar, 1.0); vec4 temp = diffuse_contrib + specular_contrib; float max_color_component = max(max(temp.r,temp.g),temp.b); if (max_color_component > 1.0) { diffuse_contrib.rgb /= max_color_component; specular_contrib.rgb /= max_color_component; } vec3 view_dir = vr_Direction; vr_LightIterator lightIter; for(int i = 0; i < vr_NumLights; ++i) { vr_evalLight(i, vr_Position, normal, lightIter); float cos_nl = clamp(lightIter.dot_nl, 0.0, 1.0); if (cos_nl > 0.0) { float diffuse_term = orennayar_diffuse(lightIter.direction, view_dir, normal); diffuse += vec4(vec3(diffuse_term * cos_nl) * lightIter.contribution, 0.0); float specular_term = phong_specular(lightIter.direction, view_dir, normal); specular += vec4(vec3(specular_term * cos_nl) * lightIter.contribution, 0.0); } } diffuse *= diffuse_contrib; specular *= specular_contrib; vec3 gi_contrib = vr_irradiance(normal, 1.0); diffuse += vec4(vec3(diffuse_contrib) * gi_contrib, 0.0); gl_FragColor = diffuse + specular;}</code>

Example: Turbulence

Rendered shader

Shader parameters

<code data-v-c2b1f83f="">#version 110uniform float noise_scale = 2.0;uniform float noise_gain = 0.8;uniform float noise_lacunarity = 3.0;__color uniform vec4 color1 = vec4(1.0, 1.0, 0.0, 1.0);__color uniform vec4 color2 = vec4(1.0, 0.0, 0.0, 1.0);uniform float diffuse_scalar = 0.8;uniform float specular_scalar = 0.02;uniform float specular_shininess = 10.0;const int octaves_count = 4;float phong_specular(vec3 light_dir, vec3 view_dir, vec3 normal, float specular_shininess) { vec3 reflection = reflect(view_dir, normal); float cos_rl = clamp(dot(reflection, light_dir), 0.0, 1.0); return (pow(cos_rl, specular_shininess) * (specular_shininess + 2.0));}void main() { vec3 normal = (gl_FrontFacing) ? vr_Normal : -vr_Normal; vec3 position = vr_Position; vec3 direction = vr_Direction; vec3 noise_position = vec3(gl_TexCoord[0]); vec3 scaled_position = noise_position * vec3(noise_scale); float noise_amplitude = 2.0; float noise_frequency = 0.5; vec3 noise_value = vec3(0.0); if((vr_RayFlags & VR_INDIRECT_FLAG) != 0) { noise_value = vec3(0.5); } else { for (int i = 0; i < octaves_count; ++i) { noise_value += abs(noise3(scaled_position * vec3(noise_frequency))) * vec3(noise_amplitude); noise_frequency *= noise_lacunarity; noise_amplitude *= noise_gain; } } vec4 diffuse_color = mix(color1, color2, vec4(noise_value, 1.0)); vec4 specular_color = vec4(1.0, 1.0, 1.0, 1.0); vec4 diffuse = vec4(0.0, 0.0, 0.0, 1.0); vec4 specular = vec4(0.0, 0.0, 0.0, 1.0); vec4 raw_diffuse = vec4(vec3(diffuse_color) * diffuse_scalar, 1.0); vec4 raw_specular = vec4(vec3(specular_color) * specular_scalar, 1.0); vec4 temp = raw_diffuse + raw_specular; float max_color_comp = max(max(temp.r,temp.g),temp.b); if (max_color_comp > 1.0) { raw_diffuse.rgb /= max_color_comp; raw_specular.rgb /= max_color_comp; } vr_LightIterator light; for(int i = 0; i < vr_NumLights; ++i) { vr_evalLight(i, position, normal, light); float cos_nl = clamp(light.dot_nl, 0.0, 1.0); if (cos_nl > 0.0) { diffuse += vec4(vec3(cos_nl) * light.contribution, 0.0); float specular_coeff = phong_specular(light.direction, direction, normal, specular_shininess); specular += vec4(vec3(specular_coeff * cos_nl) * light.contribution, 0.0); } } diffuse *= raw_diffuse; specular *= raw_specular; vec3 gi_contribution = vr_irradiance(normal, 1.0); diffuse += vec4(raw_diffuse.rgb * gi_contribution, 0.0); gl_FragColor = diffuse + specular;}</code>

Example: Blinn Material

Rendered shader

Shader parameters

<code data-v-c2b1f83f="">#version 110uniform sampler2D diffuseTex;__color uniform vec4 specular = vec4(1.0, 1.0, 1.0, 1.0);uniform float highlightGlossiness = 0.8;uniform sampler2D anisotropyTex;void main() { vec3 normal = (gl_FrontFacing) ? vr_Normal : -vr_Normal; vec2 uv_coords = vec2(gl_TexCoord[0]); vr_DiffuseBRDFSettings diffuseSettings; diffuseSettings.color = vec3(texture2D(diffuseTex, uv_coords)); diffuseSettings.normal = normal; vr_brdf_diffuse(diffuseSettings); vr_GlossyBRDFSettings blinnSettings; blinnSettings.color = vec3(specular); blinnSettings.normal = normal; blinnSettings.highlightGlossiness = highlightGlossiness; blinnSettings.anisotropy = 2.0 * texture2D(anisotropyTex, uv_coords).x - 1.0; blinnSettings.traceReflections = false; vr_brdf_blinn(blinnSettings); gl_FragColor = vec4(vec3(0.0), 1.0);}</code>

Example: Transparent Material

Rendered shader

Shader parameters

<code data-v-c2b1f83f="">#version 110__color uniform vec4 diffuse = vec4(0.6, 0.2, 1.0, 1.0);uniform sampler2D transparency;void main() { vec3 normal = (gl_FrontFacing) ? vr_Normal : -vr_Normal; vr_DiffuseBRDFSettings diffuseSettings; diffuseSettings.color = vec3(diffuse); diffuseSettings.normal = normal; vr_brdf_diffuse(diffuseSettings); vec3 textureSample = vec3(texture2D(transparency, vec2(gl_TexCoord[0]))); float alpha = dot(textureSample, vec3(0.3333333)); gl_FragColor = vec4(vec3(0.0), alpha);}</code>

Example: Render Channels

Rendered shader

Shader parameters

<code data-v-c2b1f83f="">#version 110__color uniform vec4 diffuse = vec4(0.3, 0.8, 0.2, 1.0);__channel vec3 NormalSpace = vec3(0.314);void main() { vec3 normal = (gl_FrontFacing) ? vr_Normal : -vr_Normal; NormalSpace = normal; vr_DiffuseBRDFSettings diffuseSettings; diffuseSettings.color = vec3(diffuse); diffuseSettings.normal = normal; vr_brdf_diffuse(diffuseSettings); gl_FragColor.a = 1.0;}</code>

Notes

OpenGL Shading Language specification officially supported is 1.10.59
texture() is a synonym for texture2D(). It was added for compatibility with shaders written in GLSL 1.5. The V-Ray implementation of GLSL follows the GLSL 1.10 specification, but with a bunch of extensions to support more modern codebases. The texture() function overload is one of them. Additionally, there is another set of texture overloads: vec4 texture2D(sampler2D sampler, int reserved) and vec4 texture(sampler2D sampler, int reserved), which are equivalent. They can be used to sample the given texture at the current UV-coordinates of the current intersection point, as these overloads do not require to explicitly specify a coord argument. The reserved parameter is not used and should be -1. These fixed-coordinates sampling functions are only available in V-Ray though and ideally one should guard such calls in #ifdef _VRAY_GLSL_ blocks.

Overview

Additional Preprocessor Defines

Additional Type Qualifiers

Built-In Varying Variables

Built-In Uniform Variables

Built-In Constants

Built-In Types

Built-In Functions

Built-in BRDF functions

Unsupported GLSL Features

GPU Support

Examples

Example: Cool Metallic

Example: Generator Stripe

Example: Glossy Glass

Example: Glossy Phong

Example: Glossy Reflection

Example: Oren-Nayar

Example: Turbulence

Example: Blinn Material

Example: Transparent Material

Example: Render Channels

Notes

Related articles

OpenPBR Shading Mode

OSL Support

VRay2SidedMtl

VRayALSurfaceMtl

VRayBlendMtl