Skip to main content
100%

Gist 117c6f1a891bf4503093a2e35d73a593

✓ Published0🌍 Public
Aandybak
Last edited Mar 6, 2019
Created on Mar 6, 2019

This example presents a Unity Visual Effect Graph block that blends particle colors using 16 different Photoshop-style blend modes, including Screen, Multiply, Overlay, and Difference. It shows how the block reads and writes the particle color attribute through the VFXAttributeInfo API, while exposing a blend color input and a mode selector via VFXSetting. The code implements each mode as a custom HLSL snippet, with conditional expressions for modes like SoftLight and HardLight, applied directly to the color value in the particle update or output context.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist 163847197f2c33368934a7c89ba711bc

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.

Aandybak
64% match
Loading thumbnail…

Gist b44b034e2ab3689f897d3c0d9d41569a

This example shows a Unity script that animates a post-processing vignette effect on a camera, smoothly fading its intensity in or out based on a boolean input. The code uses the DOTween tweening library to interpolate a `vignIntensity` field over a specified duration, while a `PostProcessingBehaviour` component references its attached `PostProcessingProfile` to update the vignette settings in real time. The animation updates the profile’s `VignetteModel.Settings` each frame, and on completion clears the tween reference. The script reads the profile directly from the camera’s behavior, making it suitable for runtime effects.

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

Gist 3743ce0f15cabc0331dce136e0db4168

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.

Aandybak
59% match
Loading thumbnail…

particle modified.py 1.py

This interactive particle visualization shows colorful bubbles that appear and drift upward as the user moves their fingers across the screen. The code uses Pythonista’s `scene` module with custom `Particle` and `Particles` classes, relying on the `touch_moved` event to spawn particles at touch locations. Each particle’s hue starts at 0.9 and increments over time, while its alpha fades until removal, creating a subtle color shift. The rendering draws a white circle image with tinted colors derived from `hsv_to_rgb` and applies additive blending (`BLEND_ADD`) for luminous, overlapping effects.

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

Color blending - Hexagon

Overlapping circles of varying colors and sizes drift within a hexagonal boundary, blending via the `mix-blend-mode` of `screen` to create luminous color transitions as they intersect. Animated with D3 v4’s `transition` system and random durations, each circle follows a random walk, while a clipped SVG group confines the motion. The piece uses a dark background and nine distinct hues to showcase additive blending effects.

AAjayyy
57% match