Skip to main content
100%

Gist f05cafe1da03a8d334462f2fa63825f4

✓ Published0🌍 Public
Aandybak
Last edited Aug 31, 2020
Created on Aug 31, 2020

This shader effect creates a flowing, directional distortion of an input texture by sampling it multiple times around each pixel. It computes eight rotated sample offsets, gathers luminance from both inner and outer rings, and accumulates a motion vector that steers the final texture lookup. The result is a smeared, energy-driven displacement that makes the image appear to shift and swirl based on its own brightness. The implementation uses GLSL in Shadertoy’s `mainImage` function, relying on `texture` calls to `iChannel0` and arithmetic on normalized pixel coordinates (`fragCoord` and `iResolution.xy`).

AI-generated description

Similar vizzes

Loading thumbnail…

Gist c08a235f038fea8e1aed05be87241736

This animated WebGL shader piece generates a sequence of vibrant, radial visual effects. Using fragment shaders, it computes pixel colors in real time based on normalized coordinates, time, and mouse position. The first effect creates a pulsing red-orange ring with rotating angular patterns, while the others layer polar modular repetitions, wave distortions, and sine-based color modulation to produce intricate, evolving mandala-like forms. The result is a dynamic, abstract composition with flowing shapes and shifting hues.

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

Gist 92b2b6610d2371b2da7c34152657f751

This visualization demonstrates Möbius transformations applied to a 3D object in real time. A shader written in Unity’s ShaderLab and CG/HLSL takes each vertex, performs a reverse stereographic projection onto a 3-sphere, rotates the hypersphere in 4D space, then projects back to flat 3D. The user controls the rotation amount via the `_Amount` slider. The surface shader uses the Standard lighting model and applies vertex colors, with adjustable saturation, smoothness, and metallic properties through exposed parameters.

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

Gist 9f1866b3965ddc7be2705538ed72f3c9

This visualization renders a raymarched shader scene in Unity, showing two intersecting spheres whose sizes and positions are modulated by a repeating sine wave. The code in `spheres.cginc` defines a distance function that combines a static sphere with a second sphere whose radius oscillates via `_SinTime`, using a smooth maximum operation to merge their shapes. The scene is generated entirely on the GPU through the shader, with no external data source, and the repeating pattern is created by applying a modulo operation to the position coordinates.

Aandybak
63% match
Loading thumbnail…

direction shader for OpenCV flows

This example visualizes optical flow direction and magnitude as a color-coded image, showing flow orientation through hue and flow strength through saturation. The GLSL shader reads horizontal and vertical flow components from two texture samplers, `xTex` and `yTex`, and computes per-pixel angle via `atan` and magnitude via `length`. It converts these values to HSL and then RGB using custom conversion functions, producing a smooth, rainbow-like representation of the flow field. The code relies on OpenCV-generated flow data passed as textures to the shader for real-time rendering.

RRandomEtc
62% match
Loading thumbnail…

Gist 308bcb11118691fecda084c5b1aba814

This visualization shows a raymarched 3D scene where a box and a sphere blend together, with a small protective void around the object. The shape repeats in a mirrored grid pattern that scrolls over time, driven by the `_Time.x` uniform. The code defines signed distance functions in a Unity shader file (`weirdboxes.cginc`), using custom `fBox`, `fBoxCheap`, and `pModMirror2` functions to compute the scene geometry, with a guard term that adds a thin hollow shell around the result.

Aandybak
61% match