Gist e083a79675354e15292c0628307c723f

100%

Gist e083a79675354e15292c0628307c723f

✓ Published0🌍 Public

Last edited May 21, 2020

Created on May 21, 2020

This example demonstrates a workflow for converting live Networked Drawings into pinned 3D objects within a Three.js-based scene. It shows how each drawing element, selected via `document.querySelectorAll("[networked-drawing]")`, is serialized through the component’s `serializeDrawing()` method and then removed from the view. The resulting GLB data is applied to the most recent networked entity by setting its `pinnable` attribute with `pinned:true`, effectively freezing the drawing as a persistent object. The code relies on the A-Frame component API and JavaScript promises to handle asynchronous serialization.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist 273ca366149f0a36c75674dd230980ea

This example demonstrates how to copy and clone pinned 3D objects between rooms in a WebVR scene. It shows the process of serializing object metadata—source, position, rotation, and scale—from the current room, then reconstructing those objects in a target scene. The code uses A-Frame’s `media-loader`, `networked`, and `pinnable` components, along with the browser’s `document.querySelectorAll` and `console.log`. It also directly modifies the `networked-counter` component to raise the default 20-item limit before loading clones, enabling batch duplication of interactive media within the same scene.

UUtopiah

68% match

Loading thumbnail…

Gist b6c4be8ae9172f3c3eb4a599c8dc8756

This example demonstrates a proof-of-concept integration of D3.js and p5.js, allowing custom p5 drawing functions to render D3 data joins on a canvas. It shows three colored rectangles whose dimensions and attributes (such as radius and spikes) are controlled by an array of color and width data. The code registers a custom `p5renderedElement` via `d3.registerP5Element`, then uses `d3.selectAll` and `.data()` to bind the dataset, with `.attr()` calls updating properties. A `draw()` function invokes `.render()` to execute the p5-based `elementDefinition`, while `mousePressed()` modifies attributes without immediate rendering.

SSciutoAlex

63% match

Loading thumbnail…

Gist 6db8115f185f7e57cb4395da0474fbf6

This example presents an interactive visualization of a network graph, where nodes are connected by curved links and can be dragged by the user. The code builds the layout using `d3.forceSimulation` for physics-based positioning and renders the scene with `d3.select` and SVG elements, including `transition.attrTween` for smooth link animations. It reads a JSON dataset of node and edge data from an external file, and uses `d3.zoom` for panning and scaling the view. The visualization shows how force-directed algorithms distribute connected nodes while user input adjusts the simulation in real time.

11wheel

63% match

Loading thumbnail…

Gist 56275be8d8f834fd4fc14d0b3723c4c7

This example visualizes a data-flow network where nodes and edges are drawn on an HTML5 Canvas, using a force-directed layout to position the interconnected elements. The code relies on the D3.js library for the simulation, specifically invoking `d3.forceSimulation` to compute physical forces like repulsion and attraction between linked nodes. The rendering is handled through Canvas’s `getImageData` method, which samples pixel data to construct the final image, giving the network a granular, rasterized appearance. The data itself is sourced from a fixed array embedded in the gist, representing a small set of named entities and their relationships.

MMistyBlunch

63% match

Loading thumbnail…

Gist 97384

This example visualizes a force-directed network graph where nodes and links are rendered as animated dots and lines. It uses d3.forceSimulation to compute node positions and d3.line to draw the connections, with the entire scene updated on each simulation tick. The code pulls node coordinates from the simulation and redraws SVG elements, showing how real-time physics-based layout can be paired with D3’s data-binding for interactive node-link diagrams.

CCaged

63% match

Loading thumbnail…

Gist e993403d27f2ac83367cff9794c2ece0

The animation shows a 3D scene that updates live as a new 3D model is exported from Blender. It polls a timestamp file over HTTP via `fetch`; when the timestamp changes, it removes previously uploaded assets and loads the new `model.glb` file into an A-Frame scene. The code uses `AFRAME.scenes[0]`, the `media-loader` component, and the `networked` component to place and share the model, with `setAttribute` positioning it at `0 1 0`.

UUtopiah

62% match

Loading thumbnail…

Gist e30aac4bd8656b6d68668de3e25042f7

This visualization showcases 3D photogrammetry assets converted from FBX files to GLB format for web display. It uses the FBX2glTF command-line tool to convert models, then generates an HTML scene with A-Frame’s `<a-gltf-model>` component to load the resulting GLTF files. The shell script also converts PNG textures to JPG using ImageMagick, rewrites the GLTF references accordingly, and packs models into binary GLB files with the gltf-import-export library, creating a gallery of textured 3D objects.

UUtopiah

62% match

Loading thumbnail…

Gist c609bd5ef4cd0e97247a

This example shows a force-directed network graph where nodes are connected by curved links, with the graph’s layout recalculated in real time. It uses `d3.forceSimulation` to position the nodes and `d3.forceLink` to manage the edges, while a custom `d3.geoPath`-like projection is not used; instead, the graph is rendered on an HTML5 Canvas via `getImageData` for background pixel manipulation. The code also employs `requestAnimationFrame` to animate the simulation and applies a drag interaction using `d3.drag` to let users reposition nodes dynamically. The data appears to be synthetic, generated in-memory without an external dataset.

KKatiRG

62% match