Skip to main content
100%

Gist a0da4f5f6a6476db55c3fb6a80baadd7

✓ Published0🌍 Public
Aandybak
Last edited May 29, 2019
Created on May 29, 2019

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.

AI-generated description

Similar vizzes

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
73% 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
71% 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
70% 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
69% match
Loading thumbnail…

Gist 409cdc37f3f7116d93eac738995d14ab

This example shows a Unity-based 3D modeling interface where users subdivide a cube or quad primitive into finer meshes. A grid of buttons lets the user choose different subdivision resolutions (from 2x2 up to 6x5), with the current state highlighted. Selecting a subdivision switches the mesh and opens a vertex-mover dialog for fine-grained editing, while an intermediate confirmation step is shown if vertex changes already exist. The included JSON conversion functions demonstrate how changed vertex positions and smoothing angles are serialized and restored, including reference-based deduplication of shared vertex patterns.

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

Gist d645d3d5abe4993556a6a2132722919a

This example demonstrates a mesh-subdivision algorithm that transforms a Conway polyhedron by offsetting its vertices and adding new faces at edge midpoints. It shows how the original geometry is refined into a smoother, more complex structure while preserving the polyhedron’s topological connectivity. The code uses custom `ConwayPoly`, `Face`, `Halfedge`, and `Vector3` classes, along with LINQ operations like `Select` and `Find`, to manipulate vertex positions and face indices. The rendering approach relies on the polyhedron’s internal data structures, with the offset parameter controlling the inflation of each vertex along its normal.

Aandybak
65% 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
64% match