Skip to main content
100%

Gist e2cb06e5430585b148afb12bad4bd0f8

✓ Published0🌍 Public
Aandybak
Last edited Jan 8, 2020
Created on Jan 8, 2020

A single polyhedron, a Small Cubicuboctahedron, is generated and animated using the Antiprism library’s JSON interface. The model is created from a square-grid cube with a "Cross" operation whose animated amount continuously deforms the shape, while a VertexScale operation sets a fixed scaling factor. The visualization appears as a 3D render, driven by the animation parameters defined in the JSON configuration, though the rendering library itself is not specified in the code.

AI-generated description

Similar vizzes

Loading thumbnail…

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.

Aandybak
78% match
Loading thumbnail…

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.

Aandybak
75% 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
74% match
Loading thumbnail…

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.

Aandybak
71% match
Loading thumbnail…

Gist 6ccd9c4ef2c862306f62bc847ac036d3

This WebGL visualization displays 3D models sourced from Google Poly, processed from original scene data into canonical JSON format. Using Python scripts, the code extracts embedded asset information from HTML pages and decomposes transformation matrices into rotation, translation, and scale components. The visualization renders the reconstructed 3D scenes through WebGL, leveraging the parsed model data and file type metadata from the Poly asset structure.

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

Icosahedron

An animated icosahedron rotates beneath a fixed circular clipping boundary, revealing its wireframe edges in a spherical orthographic projection. The shape is generated from a custom D3 geodesic module that subdivides the twenty triangular faces of an icosahedron and projects their vertices onto a sphere. D3’s `d3.geo.orthographic` projection and `d3.geo.path` render the multipolygon geometry as SVG paths, with a `d3.timer` updating the projection’s rotation over time.

Mmbostock
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
64% match