Skip to main content
100%

Gist e052414ca97f9d5f835b6090330c968d

✓ Published0🌍 Public
Aandybak
Last edited Sep 17, 2020
Created on Sep 17, 2020

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.

AI-generated description

Similar vizzes

Loading thumbnail…

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.

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

Gist bdb66899015ed6b7ab9d04034580909a

This example procedurally generates 3D spaceship models using the Conway polyhedron and Johnson solid libraries in Unity. The code builds a base prism, then applies random operations—lofting, lacing, truncating, and adding wings or engines—across multiple sections to create varied ship silhouettes. It uses Unity’s `MeshFilter`, `MeshRenderer`, and `Random` APIs to construct and display the final mesh, with adjustable parameters like nose length, sharpness, and segment complexity. The generator runs automatically on validation and exposes seed-based randomness for reproducible variations.

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

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.

Aandybak
62% match
Loading thumbnail…

Gist 1825fd83399f5e4df6f8b0d10399f465

This example displays a hexagon grid built from scratch, with two layout modes: flat-topped and pointy-topped hexagons. The visualization shows how hexagonal tiling can be generated programmatically, calculating exact vertex positions and cell centers based on geometric constants. The HexGrid class handles both orientations, spacing cells in a brick-like pattern that accounts for row offsets. Using custom math rather than a charting library, the grid’s points are derived from basic trigonometry and coordinate arithmetic. The code logs grid dimensions and counts to the console, revealing the underlying structure of the hexagonal lattice.

MMAKIO135
62% match
Loading thumbnail…

Gist 350b55fdacbabd690b789c7958fb7995

This visualization generates downloadable 3D building models from a geospatial database. It queries building footprints within a specified radius of a given latitude and longitude, extrudes each polygon to a height proportional to the building’s height, and centers the resulting scene on the buildings’ centroid. The code uses Django’s GeoDjango for spatial queries, Shapely for polygon manipulation, and trimesh for scene creation and GLB export. The final output is a binary glTF file containing the extruded building geometry.

Aandybak
62% match
Loading thumbnail…

Gist 63540e65c30a453a7e2e9b0345aa42ce

This example renders a 3D cityscape from geospatial building footprints, showing extruded building volumes colored in a uniform teal tone. It queries buildings within a given distance of a latitude/longitude point using Django’s GeoQuerySet (`outline__dwithin`) and converts each polygon outline with Shapely, then extrudes it with Trimesh’s `creation.extrude_polygon`. The scene is centered via a translation matrix, scaled, and exported as a GLB file using Trimesh’s `exchange.gltf.export_glb`. The visualization highlights building heights relative to their footprint areas.

Aandybak
61% match