Skip to main content
100%

Generic server listener for Blender

✓ Published0🌍 Public
Aandybak
Last edited Dec 16, 2024
Created on Dec 16, 2024

This example demonstrates a Blender add-on that runs a local HTTP server to receive 3D model import requests from an external source. It shows how Blender can act as a live listener, accepting OBJ or GLB file URLs via POST requests and queuing them for import. The code uses Python’s `http.server` and `socketserver` for the network layer, with a background thread processing a `queue.Queue` of incoming model URLs, while also tracking recent imports to prevent duplicates and exposing `/ping` and `/status` endpoints for monitoring.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist 55d11f1b29079ced31e8868aac3bd9e9

This example shows a Blender add-on that receives 3D drawing strokes from Open Brush via HTTP and renders them as grease pencil strokes in the 3D viewport. A Python HTTP server with a custom `RequestHandler` listens for POST requests containing multipart form data, parses stroke point coordinates from JSON, and converts them into Blender Grease Pencil layers and frames using the `bpy.types.GreasePencil` and `GPencilLayer` APIs. The add-on provides start and stop operators to control the server connection on port 8080.

Aandybak
66% match
Loading thumbnail…

Gist c700120232ca68a90adc791f75c8a16c

This example demonstrates a Python client for controlling a 3D drawing environment through a local HTTP API. It shows how to remotely manipulate a brush, spectator camera, and user position using simple method calls that construct URLs with query parameters. The code uses `urllib.request.urlopen` to send commands to a server at `localhost:40074`, enabling actions like drawing strokes, moving the brush, turning the camera, and toggling spectator mode. It also provides shortcuts for showing folders, exporting sketches, and listening for stroke data, making it a toolkit for interactive visualization scripting.

Aandybak
59% match
Loading thumbnail…

Gist 48d689f1ba856686fff5

This example demonstrates a simple WebSocket-based message exchange between a server and a browser client. The server sends a `server_ping` event with a `Hello bob` payload, and the client’s JavaScript listens for that event, logs the incoming message to the console, and also handles disconnections. The visualization itself is minimal, relying on the browser console for output rather than graphical rendering. The code uses the raw WebSocket API through a channel object (likely from a library like Socket.IO or similar) and standard `console.log` for feedback.

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

from Blender to WebVR in 1 click

A single click in Blender exports the current 3D scene as a glTF model and publishes it to a remote server, producing a WebVR experience viewable in a browser. The script uses the Blender glTF exporter, the A-Frame library with the aframe-extras animation-mixer component, and Python’s requests module to upload the model, binary, and generated HTML files. The generated page includes an A-Frame scene with a lightblue sky and the model positioned in space, with animation-mixer removed if no actions exist. The backend is a simple PHP file that stores uploads and returns a shareable URL.

UUtopiah
53% match
Loading thumbnail…

Gist 75fe6f98cacb874f8d9ebce7248b1b66

This example presents a web-based client-server application that serves static files and handles socket connections. The server is built with Express and Socket.IO, listening on a configurable port, and delegates all routes to a single `index.html` file. It uses the `body-parser` middleware for JSON parsing and the `path` module to resolve file locations. The rendering approach is not specified, but the code clearly establishes the infrastructure for delivering a front-end visualization, with the server acting as the backbone for real-time communication and static asset delivery.

RRonolibert
51% match
Loading thumbnail…

Gist 2492d95a9b8f1ea7c4829b30d896982a

This example shows a live-updating 3D model in a Hubs virtual room, where the displayed GLB asset refreshes automatically whenever new data arrives. It uses an EventSource (Server-Sent Events) to listen for messages from a remote Glitch server, and on each message it updates the `media-loader` component’s `src` attribute by appending a timestamp to the GLB URL, forcing a reload. The code relies on the custom `hubs_utils` helper to find the first matching element, and it demonstrates a simple SSE-driven pipeline for dynamic scene updates without manual intervention.

UUtopiah
50% match
Loading thumbnail…

simple buzzPost listener

This example demonstrates a minimal event-listener setup that subscribes to a live message stream and logs each incoming event to the browser console. It shows how a single JavaScript file can establish a real-time connection to a remote hub using the native EventSource API, which handles the server-sent events protocol. The code defines a fixed channel list—alfa, bravo, and charlie—via the URL string, then attaches an `onmessage` handler to print every message object as it arrives. No visualization or data transformation occurs; the focus is purely on the listening and logging mechanism.

Aandrew-psch
50% match