Gist d645d3d5abe4993556a6a2132722919a

Gist 20490743a658b8c43752d814c314c79e

This visualization renders uniform polyhedra using a kaleidoscopic construction method. The code computes vertex coordinates, faces, and symmetry groups from fundamental angles, then draws the three-dimensional shapes with projected lines and filled polygons. It uses standard C math and graphics routines for coordinate transformation and rendering, including trigonometric functions for rotation and perspective. The display cycles through different polyhedral types, showing their geometric structure through edge networks and face shading.

71% match

Gist 6dd998ca70e2dc7c80aafed2723a86e7

This example shows a geometric polyhedron, named “Vicious,” rendered with a dark, reflective showroom appearance. The shape begins as a uniform prism-like form and is then modified through a sequence of operations: lacing the faces, scaling and extruding the five-sided faces, and finally applying a Kis operation to those same faces. The visualization uses the Antiprism library’s JSON model format, with parameters such as `PolyType` and `JohnsonPolyType` defining the base solid. The scene is rendered using the Three.js WebGL API, displaying the resulting complex, faceted structure with two-sided surfaces and a hexagonal grid.

68% match

Gist e783e9e7df0dc768c4e7a8bc773de936

This example demonstrates a Tilt Brush tool that generates polyhedral brush strokes in virtual reality. It shows how a Conway polyhedron’s faces are converted into stroke control points and drawn as colored line segments. The code uses PolyhydraBrushHelper to generate the geometry, then iterates over each face’s halfedges to build control points with position, orientation, and pressure data. Strokes are created via the Stroke class and memorized in SketchMemoryScript, with face colors applied from polyHelper.GetFaceColor().

Gist e0ac5557362c4611fc4d9a4b1591189e

An interactive WebGL visualization of Wythoff polyhedra construction, rendered via fragment shaders in GLSL. Users manipulate triangle vertices through spin boxes and a sphere inset, with the main view distance-marching the polyhedron in real time. Mouse input updates vertex positions on the sphere, adjusting barycentric coordinates and selecting special points, while the polyhedron rotates smoothly. The shader pair handles GUI state in one buffer and polyhedron shading in the other, using a Wythoff construction distance estimator to render the resulting geometric shape.

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.

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.

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.

65% match

Gist 8183aad3764bedf7ab23187c08fd1f12

This example renders a 3D mesh of a Brazier-shaped polyhedron, built from a JSON specification and processed through a sequence of geometric operations. The shape starts as a uniform hex grid prism, then applies operations such as `FaceScale`, `Extrude`, and `Kis` to selected upward-facing faces, producing a sculpted, bowl-like form with a faceted interior. The model uses a hex grid type with prism parameters and a "Dirty Metal" appearance preset, suggesting a material-based shading pipeline. The visualization relies on the JSON’s operation list to transform the base geometry, with disabled operations like `Lace` indicating optional refinement steps that remain inactive in the final output.