HLSL intrinsics#

abs(x)#

• Mathematical Definition: \(|x| = x \text{ when } x \geq 0,\; |x| = -x \text{ when } x < 0\)
• Use case: Calculating symmetrical gradients or absolute differences.

  float distanceToCenter = abs(uv.x - 0.5f); // 0.0 at center, rises towards sides
  

sqrt(x)#

• Mathematical Definition: \(\sqrt{x}\)
• Use case: Computing Euclidean distances or physical falloff curves.

  float dist = sqrt(x*x + y*y);
  

pow(x, y)#

• Mathematical Definition: \(x^y\)
• Use case: Applying gamma correction or adjusting falloff contrast curves.

  float spotlightIntensity = pow(dotProduct, 16.0f); // Tight, sharp spotlight beam
  

log(x)#

• Mathematical Definition: \(\ln(x)\) (Natural logarithm, base \(e\))
• Use case: Simulating human sensory perception (such as volume or exposure curves).

  float perceivedBrightness = log(hdrColor + 1.0f);
  

exp(x)#

• Mathematical Definition: \(e^x\)
• Use case: Modeling exponential growth or atmospheric attenuation.

  float atmosphericFog = exp(-density * distance);
  

floor(x)#

• Mathematical Definition: \(\lfloor x \rfloor\) (Greatest integer \(\leq x\))
• Use case: Quantizing colors or UV coordinates to achieve pixelated or cell-shaded styles.

  float2 pixelatedUV = floor(uv * 128.0f) / 128.0f;
  

ceil(x)#

• Mathematical Definition: \(\lceil x \rceil\) (Smallest integer \(\geq x\))
• Use case: Generating stepped thresholds or bounds checks.

  float visibilityMask = ceil(opacity - 0.01f); // 1 if opacity > 0, else 0
  

round(x)#

• Mathematical Definition: Evaluates to the nearest integer. If the fraction is exactly 0.5, rounds to the nearest even integer.
• Use case: Snapping coordinates to integer screen pixel grids.

  float2 snappedPixelPos = round(input.position.xy);
  

frac(x)#

• Mathematical Definition: \(x - \lfloor x \rfloor\)
• Use case: Creating repeating patterns, tiled textures, or periodic wave motions.

  float repeatingStripes = frac(uv.y * 10.0f); // Ramps from 0 to 1 ten times
  

sin(x)#

• Mathematical Definition: \(\sin(x)\) where \(x\) is in radians.
• Use case: Generating oscillations for animation, wind sways, or blinking lights.

  float heartbeat = sin(u_time * 3.0f);
  

cos(x)#

• Mathematical Definition: \(\cos(x)\) where \(x\) is in radians.
• Use case: Combining with sine to perform 2D circular rotations.

  float2 offset = float2(sin(u_time), cos(u_time));
  

tan(x)#

• Mathematical Definition: \(\tan(x) = \sin(x) / \cos(x)\)
• Use case: Projecting coordinates or setting up camera field-of-view matrices.

  // Calculate physical vertical displacement based on projection angle
  float heightOffset = tan(angleRadians) * distance;
  

asin(x)#

• Mathematical Definition: \(\operatorname{arcsin}(x) = y \text{ such that } \sin(y) = x \text{ for } y \in [-\pi/2,\, \pi/2]\)
• Use case: Converting rectangular spatial positions to angular coordinate dimensions.

  // Convert normalized vertical height coordinate back to radians
  float verticalAngle = asin(normalizedY);
  

acos(x)#

• Mathematical Definition: \(\operatorname{arccos}(x) = y \text{ such that } \cos(y) = x \text{ for } y \in [0,\, \pi]\)
• Use case: Direct calculation of angles between normalized vectors.

  float angleRadians = acos(dot(vectorA, vectorB));
  

atan(x)#

• Mathematical Definition: \(\operatorname{arctan}(x) = y \text{ such that } \tan(y) = x \text{ for } y \in \left(-\pi/2,\, \pi/2\right)\)
• Use case: Calculating angles of continuous scalar slopes.

  // Calculate slope angle from vertical and horizontal offsets
  float slopeAngle = atan(verticalOffset / horizontalOffset);
  

atan2(y, x)#

• Mathematical Definition: Computes the angle \(\theta \in ]-\pi, \pi]\) of the point \((x,y)\) relative to the positive x-axis.
• Use case: Converting Cartesian coordinates to radial polar angles.

  float angle = atan2(centeredUV.y, centeredUV.x); // Useful for radial blur
  

dot(v1, v2)#

• Mathematical Definition: \(\vec{a} \cdot \vec{b} = \sum a_i b_i\)
• Use case: Computing diffuse lighting intensities or projection lengths.

  float brightness = dot(normal, lightDirection);
  

cross(v1, v2)#

• Mathematical Definition: \(\vec{a} \times \vec{b} = (a_y b_z - a_z b_y, a_z b_x - a_x b_z, a_x b_y - a_y b_x)\)
• Use case: Calculating perpendicular vectors (e.g. generating tangent planes).

  float3 tangent = cross(normal, float3(0, 1, 0));
  

• Protip: to know which way the cross product point, put your right hand on the first vector and rotate it to the second vector, your thumb will point to the direction of the cross product (Right Hand Rule Video).

length(v)#

• Mathematical Definition: Length of the vector \(\|\vec{v}\|_2 = \sqrt{v_x^2 + v_y^2 + \dots}\)
• Use case: Determining distance from a coordinate point to a central source.

  float distToCenter = length(centeredUV); // Center vignette mask
  

normalize(v)#

• Mathematical Definition: \(\frac{\vec{v}}{\|\vec{v}\|_2}\)
• Use case: Gives a unit vector in the direction of \(\vec{v}\)

  float3 lightDir = normalize(lightPos - fragmentPos);
  

distance(p1, p2)#

• Mathematical Definition: \(\|\vec{p_1} - \vec{p_2}\| = \sqrt{\sum (p_{1i} - p_{2i})^2}\)
• Use case: Generating point-light range masks or impact circles.

  float force = 1.0f - saturate(distance(impactPos, currentPos) / radius);
  

reflect(i, n)#

• Mathematical Definition: \(\vec{I} - 2(\vec{N} \cdot \vec{I})\vec{N}\)
• Use case: Computing mirror reflection directions for specular maps.

  float3 reflectDir = reflect(incidentLightVector, surfaceNormal);
  

refract(i, n, eta)#

• Mathematical Definition: \(\eta \vec{I} - (\eta (\vec{N} \cdot \vec{I}) + \sqrt{1 - \eta^2 (1 - (\vec{N} \cdot \vec{I})^2)}) \vec{N}\) (Snell's Law refraction direction)
• Use case: Simulating light bending through glass or water.

  float3 refractDir = refract(ray, normal, indexRefraction);
  

lerp(a, b, t)#

• Mathematical Definition: \(a + t(b - a)\) (Linear interpolation)
• Use case: Blending between two colors or texture profiles based on a mask.

  float3 finalColor = lerp(sceneColor, fogColor, fogFactor);
  

step(edge, x)#

• Mathematical Definition: \(0 \text{ when } x < \text{edge},\; 1 \text{ when } x \geq \text{edge}\)
• Use case: Creating a sharp vertical split to divide a texture or screen in half.

  float isLeftHalf = step(0.5f, uv.x);
  

smoothstep(edge0, edge1, x)#

• Mathematical Definition: \(t = \text{saturate}\left(\frac{x - \text{edge}_0}{\text{edge}_1 - \text{edge}_0}\right)\), returning \(3t^2 - 2t^3\) (the cubic polynomial \(t^2(3 - 2t)\) creates a smooth S-curve transition between \(\text{edge}_0\) and \(\text{edge}_1\) with flat zero-gradients/derivatives at both endpoints \(t=0\) and \(t=1\))
• Use case: Creating smooth transitions, vignettes, or soft fog boundaries.

  float vignette = smoothstep(0.4f, 0.8f, distFromCenter);
  

saturate(x)#

• Mathematical Definition: \(\min(\max(x, 0.0), 1.0)\)
• Use case: Clamping computed ranges to standard color parameters [0.0, 1.0].

  float3 safeColor = saturate(computedColor);
  

clamp(x, minVal, maxVal)#

• Mathematical Definition: \(\min(\max(x, \text{minVal}), \text{maxVal})\)
• Use case: Restricting HDR auto-exposure levels within a safe functional window between 0.2 and 2.5.

  float exposure = clamp(autoExposure, 0.2f, 2.5f);
  

min(a, b)#

• Mathematical Definition: \(a \text{ when } a < b,\; \text{otherwise } b\)
• Use case: Capping color parameter limits.

  float highlightCap = min(colorVal, 1.5f);
  

max(a, b)#

• Mathematical Definition: \(a \text{ when } a > b,\; \text{otherwise } b\)
• Use case: Preventing divisions by zero or negative color values.

  float brightness = max(diffuseLighting, 0.0f);
  

mul(a, b)#

• Mathematical Definition: Matrix multiplication (\(\mathbf{A} \times \mathbf{B}\))
• Use case: Transforming positions between local/world space and projection clip space.

  float4 clipPos = mul(projectionMatrix, viewSpacePos);
  

transpose(m)#

• Mathematical Definition: Transposition of matrix \(\mathbf{M}\) (\(\mathbf{M}^T\))
• Use case: Swapping row-major to column-major layout formats.

  float3x3 colMajorMatrix = transpose(rowMajorMatrix);
  

determinant(m)#

• Mathematical Definition: Determinant of matrix \(\mathbf{M}\) (\(|\mathbf{M}|\))
• Use case: Measuring scaling factors to determine volume/area changes of transformations.

  float scalingFactor = determinant(localToWorldMatrix);