Skip to main content
100%

Gist 163847197f2c33368934a7c89ba711bc

✓ Published0🌍 Public
Aandybak
Last edited Apr 20, 2022
Created on Apr 20, 2022

This example visualizes a particle system and its interactions, built with the Unity game engine. It uses Unity's built-in modules for rendering, physics, and user interface elements, including the TextMeshPro and UI systems. The visualization is driven by Unity's component-based architecture, with a manifest that declares the package dependencies. The work does not use typical JavaScript data-visualization libraries like D3 or Three.js; instead, it leverages Unity's own animation, audio, and particle system modules to create the interactive scene.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist ab6507a572fdeb4a2e01886d889f2ef8

This visualization presents an interactive particle system where glowing nodes drift and cluster across a dark canvas, creating an organic, flowing network. It shows the emergent structure of connected data points as they respond to simulated physical forces. The code uses `d3.forceSimulation` with charge and link forces to position the particles, while a custom rendering loop draws each node with fading trails on a 2D canvas context. The visualization also incorporates mouse interaction, allowing viewers to influence the particle movement by dragging or hovering. The design draws inspiration from modern agency portfolios, emphasizing smooth motion and aesthetic appeal over literal data mapping.

Aamazingandyyy
73% match
Loading thumbnail…

Gist df46ffa14c337c3656ded7dad051324e

A looping particle system in Unity creates an orbital motion effect, showing glowing particles circling a central point over a five-second cycle. The preset file configures the particle simulation to loop continuously, with physics-based velocity using rigid bodies and automatic random seeding. The scene relies on Unity's Particle System API, as configured through a YAML preset, to control simulation speed, start delay, and looping behavior. The visualization demonstrates a procedural, code-defined orbital animation rather than imported data.

Aandybak
69% match
Loading thumbnail…

Gist 4e55f8e8b799944cb6b33e98fd168250

This visualization shows a networked 3D scene assembled from GLTF assets, with a grid of nodes representing interactive media frames, text labels, and environmental elements like water, sky, and lighting. The code defines a complete virtual space using Three.js-style scene-graph components, including spawn points, waypoints, audio zones, particle emitters, and colliders. A central box-collider acts as a ground plane, while the scene includes a nav-mesh for navigation and a hidden trigger volume. The setup demonstrates how MIXED REALITY components—such as networked objects, media frames, and physics properties—combine to create a shareable, interactive environment with URLs for external image, video, and audio assets.

Aandybak
68% match
Loading thumbnail…

Gist 73e5cb2c456084a9c356f9c3f89f8803

An interactive particle field visualizes the gravitational attraction between a cursor and thousands of moving points. The code uses D3's quadtree for spatial indexing and d3.forceSimulation with custom force functions to compute particle velocities and positions, while a Vue component manages the animation loop and canvas rendering. The display updates in real time, with particles flowing toward and around the pointer position based on distance-based force calculations, creating a dynamic, organic swarm effect on a dark background.

MMAKIO135
68% match
Loading thumbnail…

Gist ac6609815065d552b0fb

This visualization animates a simulated physics system where nodes are connected by links and pushed apart by collision forces, with each node tracking a changing color value over time. The code uses `d3.forceSimulation` to manage node positions and velocities, while a canvas renderer draws the network each frame. A color scale maps per-node data to RGB values, and the simulation updates continuously through tick events, redrawing the scene with `context.clearRect` and `context.fillRect`. The example relies on the Force-directed graph API from D3.js and raw Canvas 2D drawing methods, with no external data source visible in the provided code snippet.

Aandybak
67% match
Loading thumbnail…

Gist ff5ecb0cfd5b540608efaf7cdaad30d3

This visualization maps Unity shader properties onto a force-directed network, showing how different shader materials relate through shared parameters. Using d3.forceSimulation, nodes represent individual shader names like Bubbles, Fire, and Ink, with edges likely connecting shaders that share property types. Each node’s properties—such as float, color, texture, or vector—are parsed from the gist text, revealing patterns in shader design. The layout groups similar shaders spatially, making it easy to spot clusters of materials with common attributes like emission or specular settings.

Aandybak
66% match
Loading thumbnail…

Gist 1458002

This visualization shows a chaotic swarm of small particles moving across a dark canvas, with their positions and velocities computed through a force-directed simulation. The particles appear to be influenced by repulsive and attractive forces, creating organic, flowing clusters that shift over time. The code uses D3.js’s `d3.forceSimulation` to manage the particle physics, and renders each point as a colored circle via SVG, with the simulation loop updating positions each frame. The data is generated procedurally—no external dataset is loaded—and the example is written in CoffeeScript, though it relies on standard D3 v4 API calls for force layout and rendering.

Aabernier
66% 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
66% match