Skip to main content
100%

https://unity3d.com/how-to/novel-lighting-workflow-in-Unity

✓ Published0🌍 Public
Aandybak
Last edited Jul 16, 2018
Created on Jul 16, 2018

This example shows a custom lighting calculation for vertex-lit objects in Unity, reducing the cost of multiple directional lights by packing their data into vector4 arrays. The `ShadeVertexLightsAtten.cginc` file defines a function that computes diffuse lighting and distance-based attenuation for four lights simultaneously, using arithmetic on `float4` types to process all lights in parallel. It reads light positions, colors, and squared attenuation factors, then sums the weighted contributions into a single output color. The code relies on Unity’s shader language (CG/HLSL) and its built-in vertex lighting pipeline.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist 2cf3965eedaf296437ff9c2c7ca7ca8a

This Unity shader example demonstrates a custom lighting model with diffuse reflection for both vertex and pixel lights. It shows how materials respond to multiple light sources, combining ambient, directional, and point/spot lighting using additive blending. The shader uses Unity's CGPROGRAM syntax, leveraging built-in variables like `unity_4LightPosX0` and `unity_LightColor` for vertex lighting, while `_WorldSpaceLightPos0` handles additional light attenuation. The code includes two passes: a ForwardBase pass for ambient and vertex lights, and a ForwardAdd pass for supplementary lights, with linear distance-based attenuation for point sources.

Aandybak
76% match
Loading thumbnail…

Template shader to use as guide to create Lightweight Pipeline ready shaders.

This shader template provides a starting point for authoring physically based shaders compatible with Unity’s Lightweight Pipeline, using HLSL. It shows the required shader properties, keyword definitions, and pass structure for forward rendering, including surface options like metallic/specular workflow, albedo, normal mapping, occlusion, and emission. The code references the LightweightPipeline tag and LightweightForward pass, with multi_compile directives for additional lights, shadows, and fog. It is intended as a reference only, not a performance-complete standard shader.

Aandybak
60% match
Loading thumbnail…

Gist 8dde5bfea433aa824444246c47f0d46f

A custom Unity shader renders double-sided foliage with a spherical normal trick, replacing each vertex’s normal with a direction from the model origin to the vertex. It combines alpha-cutout transparency with Fresnel-based edge fading, using `clip` to discard pixels below a cutoff. The shader applies Lambert diffuse lighting from `_WorldSpaceLightPos0` plus ambient light via `ShadeSH9`, while normals are offset by a vector property. The material is intended for tree models, as noted in the author’s comments, and supports alpha testing in the `TransparentCutout` render queue.

Aandybak
56% match
Loading thumbnail…

Gist d5d76528348514dffd9547a2cd438944

This visualization renders a 3D raymarched scene using a single shader written in HLSL. It displays a collection of geometric primitives—planes, spheres, boxes, ellipsoids, tori, cylinders, cones, prisms, capsules, and pyramids—each defined by signed distance functions (SDFs) and composited in a shader. The code includes multiple SDF implementations with both distance-bound and correct-distance variants, demonstrating how shape intersections and subtractions are computed. The scene is rendered through a fragment shader that applies raymarching techniques, with an anti-aliasing toggle controlled by the `AA` constant.

Aandybak
55% match
Loading thumbnail…

Gist a3b086e4ec021188c08a4afa990e988e

This example shows a Unity shader that applies triplanar texture mapping to surfaces, blending three planar projections based on each fragment’s local normal direction. The shader, written in HLSL with the Standard Surface shader model, samples a main texture, normal map, and occlusion map across the X, Y, and Z axes, then weights the results by the normalized absolute normal components. It supports transparency, metallic, glossiness, and occlusion parameters, and relies on Unity’s `surf` and `vert` functions. The code is adapted from keijiro’s StandardTriplanar shader and runs in the Unity engine.

Aandybak
55% match
Loading thumbnail…

Gist 8b0da6e9acc76b7251547a0ad1dad5f1

This shader example demonstrates a technique for snapping pixel-art sprites to a fixed pixel grid in a 3D game engine. It shows how vertex positions are aligned to integer multiples of a tunable “pixels per unit” value prior to rendering, preventing visual distortion or shimmering when sprites are placed in world space. The code is written for Unity’s proprietary shader language and uses a Cginc/UnityCG-style vertex and fragment program, aligning object-space vertices before passing them through the standard MVP matrix. The shader samples a main texture and optionally an external alpha texture, tinting the result with a `_Color` property.

FFrozenfire92
54% match
Loading thumbnail…

Gist 3743ce0f15cabc0331dce136e0db4168

This example demonstrates a custom outline effect for the Unity Universal Render Pipeline (URP). It consists of a `ScriptableRendererFeature` that injects a depth-normals prepass, which renders the scene’s depth and normal information into a texture. A Shader Graph custom node exposes this `_CameraDepthNormalsTexture` as an input, and an HLSL function compares depth and normal values at neighboring screen-space texels to detect edges. The effect produces a stylized outline by thresholding depth discontinuities and normal differences, with adjustable scale, depth threshold, normal threshold, and texel size.

Aandybak
53% match
Loading thumbnail…

Gist 845aa64e9d9aa6080eadd256e863d835

This example visualizes gradient vectors computed from a three-dimensional signed distance field, showing normal directions as RGB colors sampled from a Unity Texture3D. The code uses Unity’s `Texture3D.GetPixel` to read distance values and central differences to approximate the gradient along each axis, storing the result in a new `Texture3D` with `TextureFormat.RGBAFloat`. A `ContextMenu` attribute triggers the bake operation, and `AssetDatabase.CreateAsset` saves the output as a reusable gradient texture asset.

Aandybak
53% match