Skip to main content
100%

Gist 308bcb11118691fecda084c5b1aba814

✓ Published0🌍 Public
Aandybak
Last edited Aug 29, 2017
Created on Aug 29, 2017

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.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist 327439fea1dac34da901622a2fbe7ff8

This example renders a 3D scene of a box and a sphere using a signed distance function. The shader code defines `fBox` and `fBoxCheap` to compute box distances, while `DistanceFunction` combines a sphere, a box, and a guard region with an absolute offset. The scene is visualized by ray marching, likely through a graphics API such as OpenGL or Vulkan, as the code is written in a CGINC shader include file. The final image shows the primitive shapes intersecting, with the guard acting as a thin shell around the box’s interior.

Aandybak
83% 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
79% 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
78% match
Loading thumbnail…

Gist 9ac5da62d5cfb04afdbd9a658b9ff06a

A raymarched SDF scene animates a rotating polar-mirrored structure, alternating between a box and a sphere while a central guard region constrains the shape. The effect relies on a custom distance function in `polar.cginc`, using `pModPolar` for angular repetition, `Box` and `Sphere` primitives, and a `fBoxCheap` guard. Time-driven rotation via `_Time.x` continuously modifies the mirror angle. The rendering approach is typical of shader-based raymarching, with no external data source or JavaScript library involved.

Aandybak
77% 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
71% 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
71% match
Loading thumbnail…

Gist 1cea47db296b24afb0772e2314185ace

This visualization renders a 3D Menger sponge fractal that morphs through successive recursive iterations. It uses a custom distance function defined in a Unity shader file (menger.cginc) to calculate the fractal’s geometry, with the iteration depth driven by `_Time.x` to animate the transformation. The scene is drawn using raymarching, a rendering approach that evaluates the distance function along each view ray to determine surface intersections, producing a continuously evolving solid fractal. The code relies on Unity’s shader pipeline and time-based input to cycle the sponge through levels of detail.

Aandybak
70% match
Loading thumbnail…

Gist e4337d3399b3937aa809a0179293bd13

This visualization reads a CSV file containing x, y, z position, width, height, depth, and RGB color columns, then plots each row as a colored 3D box in Unity. The data points are normalized to a 0–1 range, scaled by a plotScale factor, and instantiated as prefabs with their original size and color from the file. The code uses Unity’s `GameObject.Instantiate`, `Transform`, and `Renderer.material.color` to place and style each box, with positions and scales derived from the CSV values.

Aandybak
66% match