Gist bdb66899015ed6b7ab9d04034580909a

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.

69% match

Gist e052414ca97f9d5f835b6090330c968d

A procedural town is generated from a jittered grid, producing extruded houses with window openings, domed roofs, ground patterns, and building edging. The example uses the `Grids.Grids` API to create the base grid, then applies `Loft`, `FaceSlide`, `FaceRemove`, `Shell`, `Dual`, `Bevel`, `Medial`, and `FaceScale` operations from the `ConwayPoly` geometry library. Random building heights and dome profiles are driven by `Random.Range` and an easing function, with all parts assembled into a single `ConwayPoly` object for display.

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 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.

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.

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.

63% match

Gist 0870263c0c476205b6f7a471f00ee1dc

This example shows a node-based procedural geometry editor that generates primitive meshes and combines them into model groups. It uses the XNode framework to define a graph where a `Primitive` node creates dodecahedra, octahedra, or cubes via the ProceduralToolkit `MeshDraft` API, while a `RandomPrimitive` node supplies the primitive type. The `Primitive` node reads inputs for primitive type, radius, and material, then outputs a `ModelGroup` containing a single `Model` with an assigned material. The graph structure is visible in how node ports connect inputs and outputs, demonstrating how procedural mesh generation can be controlled through a visual scripting system.

62% match

Gist 69cfbb7f237e72e9bcbd21744278a5f8

Procedurally generated from a base grid, this scene depicts a small town of varied houses topped with domes, built using the Antimony graph modeling library. The code constructs a jittered grid, extrudes random-height house blocks, and splits them into walls and domes, which are then shaped with lofting, shelling, and dome operations. A beveled and medial ground plane is added, and the final model appends all parts together. The example demonstrates Antimony’s grid, face-selection, and transformation APIs for generative architectural form.