Skip to main content
100%

Hex dots shader for unity. From: https://www.reddit.com/r/Unity3D/comments/9h07rh/i_made_a_shader_that_draws_a_bunch_of_dots_in_a/

✓ Published0🌍 Public
Aandybak
Last edited Sep 19, 2018
Created on Sep 19, 2018

A Unity shader renders a grid of animated dots in a hexagonal pattern, with the dot size, count, speed, and top/bottom colors adjustable via shader properties. The fragment shader uses trigonometric functions—cosines of the UV coordinates multiplied by the dot count—to generate intersecting line patterns that form the dots, then thresholds and scales the values to create crisp circular shapes. It blends between the background and foreground colors based on the dot alpha, using the built-in UnityCG.cginc library and a standard transparent pass with alpha blending.

AI-generated description

Similar vizzes

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

Hexagonal SVG gradient experiment

A grid of hexagons fills the page, each one displaying a linear gradient oriented along one of three angles, with colors randomly drawn from a dark rainbow palette. The animation progressively reveals hexagons starting from the center, growing outward in a wave-like pattern. Built with D3 v5 and SVG, the code constructs hexagon paths using trigonometric calculations and applies randomized gradient definitions through the SVG `defs` element.

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

Hexagonal Binning

This example demonstrates hexagonal binning, aggregating 10,000 randomly generated points from `d3.randomNormal` into a grid of hexagons using the `d3-hexbin` plugin for D3 4.0. Each hexagon’s fill color reflects the local point density via a sequential `d3.scaleSequential` with the `d3.interpolateMagma` color scheme. The SVG rendering includes white hexagon strokes for visual separation, plus top and left axes built with `d3.axisTop` and `d3.axisLeft` on identity scales.

Mmbostock
61% match
Loading thumbnail…

Dynamic Hexbin

Two thousand points sampled from a normal distribution drift in a circular path as the distribution’s center moves over time. A dynamic hexbin grid aggregates the points, with each hexagon’s fill color mapped sequentially from white to steelblue based on the number of points it contains. Built with D3 v4 and the d3-hexbin plugin, the animation uses d3.randomNormal to regenerate twenty points per frame and d3.timer to update the SVG paths continuously.

Mmbostock
60% match
Loading thumbnail…

500 glowing dots

Five hundred glowing dots scatter across a dark, square SVG canvas. Each dot consists of a larger outer circle filled with a cyan radial gradient and a smaller, brighter white inner circle created using SVG `radialGradient` definitions. A plain `for` loop generates the dots at random positions within a fixed boundary, using D3 v4 to append `circle` elements and apply CSS classes for styling. The result is a dense, luminous field of varied-sized orbs against a near-black background.

PPatrick Wojda
60% match
Loading thumbnail…

Gist 1825fd83399f5e4df6f8b0d10399f465

This example displays a hexagon grid built from scratch, with two layout modes: flat-topped and pointy-topped hexagons. The visualization shows how hexagonal tiling can be generated programmatically, calculating exact vertex positions and cell centers based on geometric constants. The HexGrid class handles both orientations, spacing cells in a brick-like pattern that accounts for row offsets. Using custom math rather than a charting library, the grid’s points are derived from basic trigonometry and coordinate arithmetic. The code logs grid dimensions and counts to the console, revealing the underlying structure of the hexagonal lattice.

MMAKIO135
59% match