Skip to main content
100%

Gist 660f765a1eaf8b00dd819920da0c2613

✓ Published0🌍 Public
Aandybak
Last edited Jun 4, 2019
Created on Jun 4, 2019

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.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist a0da4f5f6a6476db55c3fb6a80baadd7

This example shows how to convert a 3D mesh into a point cloud by changing its topology. It displays the original geometry as a set of discrete vertices instead of connected triangles. The code uses Unity’s `MeshFilter` and `Mesh` APIs, setting the mesh’s indices to cover every vertex and applying `MeshTopology.Points` to render each vertex as an individual point. It operates both in edit mode and during play, updating the shared mesh or the active mesh accordingly, making the conversion immediate and visible in the scene.

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

Gist 845aa64e9d9aa6080eadd256e863d835

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.

Aandybak
68% match
Loading thumbnail…

Gist 38e049a8e58056d8542d9ee67c7957e0

This example shows a simple 3D pyramid whose apex moves upward or downward when the user presses the arrow keys. It demonstrates how to create and update a mesh at runtime using Unity’s Mesh API, with vertex data stored in a `NativeArray<float3>` for efficient modification. The code sets up a triangle-based submesh, defines vertex and index buffers via `SetVertexBufferParams` and `SetIndexBufferParams`, and redraws the mesh each frame with `Graphics.DrawMesh`. The pyramid is rendered using a provided material, and only the top vertex’s position is altered in response to input.

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

Gist d458751b92cc86c44bc44f8540a8b29b

This example displays a tetrahedron built from four triangular faces, with each face defined by three vertices and connected to form a closed 3D shape. The code uses Unity’s MeshFilter and MeshRenderer components, creating a new Mesh object and assigning vertex positions and triangle indices manually. It computes the geometry using vector math, including square roots for equilateral triangle proportions, then calls RecalculateNormals and RecalculateBounds to prepare the mesh for rendering. The script runs in edit mode via ExecuteInEditMode, so the tetrahedron appears immediately in the Unity editor without requiring playback.

Aandybak
65% match
Loading thumbnail…

Gist a54028cfd44222a5c43a6bab02aad770

This example showcases a collection of procedurally generated grid-based polyhedral meshes, including hex, square, triangle, rhombille, Cairo, and Penrose tilings, each rendered as a 3D Unity mesh. It demonstrates how the Sylves library constructs and bounds different grid types, converting them into PolyMesh data via `grid.BoundBy(bound).ToMeshData()` and processing the resulting indices based on topology (triangles, quads, or NGons). The code uses Unity’s `MeshFilter` and `MeshRenderer` components, along with the Polyhydra Core library, to visualize each grid’s cell layout at a user-defined size.

Aandybak
62% match