Skip to main content
100%

Gist 3743ce0f15cabc0331dce136e0db4168

✓ Published0🌍 Public
Aandybak
Last edited Nov 17, 2019
Created on Nov 17, 2019

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.

AI-generated description

Similar vizzes

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
68% 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
68% match
Loading thumbnail…

Gist a33a5c0eb38ae642af46a478b3951163

A Unity shader demonstrates a mesh-spherization effect by morphing a flat textured surface into a sphere. The vertex shader normalizes each vertex position, scales it by a configurable radius, and blends between the original and spherical coordinates using an amount parameter. The fragment shader samples the main texture and halves its color output. The shader uses Unity's `UnityObjectToClipPos` for projection and applies fog through standard CG macros. The material exposes radius and amount properties for interactive control.

Aandybak
64% 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
63% match
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
62% match
Loading thumbnail…

a triplanar / procedural UV / world space UV shader for Unity, cobbled together bits from @QuickFingerz and @Farfarer

This shader demonstrates triplanar texturing, projecting three separate textures onto an object’s surface based on its world-space normal direction. It blends side, top, and bottom texture samples using a power-saturated normal projection, with side textures sampled from the X and Z axes and top/bottom textures from the Y axis. The Unity shader uses a surface shader with Lambert lighting, and it applies world position coordinates to compute UVs, scaling each texture independently. The result is seamless, stretch-free texturing for arbitrary geometry without relying on traditional UV mapping.

Aandybak
62% match
Loading thumbnail…

Gist 660f765a1eaf8b00dd819920da0c2613

This example converts a selected PNG texture into a 3D mesh using Unity’s Sprite API. It shows how the image’s alpha channel defines a tight sprite outline, which becomes the mesh’s vertex geometry, while the original texture is applied as a material. The code uses `Sprite.Create`, `SpriteMeshType.Tight`, and `Mesh` to build the object, then assigns the Standard shader and recalculates normals, bounds, and tangents. It runs only when a .png asset is selected via the editor menu.

Aandybak
61% 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
61% match