Skip to main content
100%

Gist 845aa64e9d9aa6080eadd256e863d835

✓ Published0🌍 Public
Aandybak
Last edited Aug 23, 2019
Created on Aug 23, 2019

This example visualizes gradient vectors computed from a three-dimensional signed distance field, showing normal directions as RGB colors sampled from a Unity Texture3D. The code uses Unity’s `Texture3D.GetPixel` to read distance values and central differences to approximate the gradient along each axis, storing the result in a new `Texture3D` with `TextureFormat.RGBAFloat`. A `ContextMenu` attribute triggers the bake operation, and `AssetDatabase.CreateAsset` saves the output as a reusable gradient texture asset.

AI-generated description

Similar vizzes

Loading thumbnail…

A Material Property Drawer for the [Gradient] attribute which lets you edit gradients and adds them to the shader as textures. More information here: https://twitter.com/totallyRonja/status/1368704187580682240

This drawer adds a gradient editor to Unity’s Material Inspector for shader properties marked with the `[Gradient]` attribute. It converts the edited gradient into a 1D texture, bakes it using `Texture2D.SetPixel` and `Apply`, and assigns it to the material via `Material.SetTexture`. The tool stores and reloads gradients by encoding them as JSON in the texture’s asset name, using `JsonUtility` and `AssetDatabase` for persistence, with a fallback blue-to-red default.

Aandybak
69% match
Loading thumbnail…

Gist 660f765a1eaf8b00dd819920da0c2613

This example converts a selected PNG texture into a 3D mesh using Unity’s Sprite API. It shows how the image’s alpha channel defines a tight sprite outline, which becomes the mesh’s vertex geometry, while the original texture is applied as a material. The code uses `Sprite.Create`, `SpriteMeshType.Tight`, and `Mesh` to build the object, then assigns the Standard shader and recalculates normals, bounds, and tangents. It runs only when a .png asset is selected via the editor menu.

Aandybak
68% 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
65% match
Loading thumbnail…

Hello WebGL III

This example demonstrates WebGL’s ability to generate a gradient directly on the GPU, where the fragment shader colors each pixel based on its x and y coordinates relative to the canvas size. Using a minimal vertex shader and a full-screen triangle fan, it renders a smooth color transition without any external data. The code compiles and links shaders manually via the WebGL API, sets uniform and attribute locations, and calls `drawArrays` to produce the final image.

Mmbostock
63% match
Loading thumbnail…

Gist a3b086e4ec021188c08a4afa990e988e

This example shows a Unity shader that applies triplanar texture mapping to surfaces, blending three planar projections based on each fragment’s local normal direction. The shader, written in HLSL with the Standard Surface shader model, samples a main texture, normal map, and occlusion map across the X, Y, and Z axes, then weights the results by the normalized absolute normal components. It supports transparency, metallic, glossiness, and occlusion parameters, and relies on Unity’s `surf` and `vert` functions. The code is adapted from keijiro’s StandardTriplanar shader and runs in the Unity engine.

Aandybak
63% 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
63% 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
62% 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
61% match