Skip to content

Graphics

  • glsl The glsl object simplifies the creation of OpenGL Shading Language (GLSL) programs by wrapping various GLSL compilers and the linker into a single, easy-to-use interface.
  • pix_snap The pix_snap object captures the current content of the GEM (Graphics Environment for Multimedia) rendering buffer, effectively taking a screenshot.
  • part_follow The part_follow object is a GEM particle system component that enables particles to follow each other, creating dynamic visual effects.
  • pix_dot The pix_dot object simplifies an input image by segmenting it and representing each segment with a white dot.
  • multimodel The multimodel object loads and renders multiple 3D Alias/Wavefront (.obj) models.
  • pix_add The pix_add object combines two input images of the same size by adding their pixel values.
  • part_move The part_move object is a core component of the GEM particle system.
  • scope~ The scope~ object visualizes audio signals in the style of an oscilloscope.
  • newWave The newWave object renders a dynamic, waving square using a mass-spring system, acting as a geometric object within GEM.
  • pix_blur The pix_blur object applies a blur effect to an image or video stream within Pure Data's GEM environment.
  • pix_buffer_write The pix_buffer_write object writes incoming image data (a gemlist) into a specified pix_buffer at a given index.
  • pix_diff The pix_diff object calculates the absolute difference between two input images, which must be of the same size.
  • pix_curve The pix_curve object applies color curves to an image, modifying its RGBA channels.
  • rgb2hsv The rgb2hsv object converts color values from the RGB (Red, Green, Blue) color space to the HSV (Hue, Saturation, Value/Luminance) color space.
  • pix_imageInPlace The pix_imageInPlace object efficiently loads multiple image files (TIFF, JPEG, PNG) into texture RAM, enabling very fast switching between them.
  • text3d The text3d object in Pure Data renders a single line of text within a 3D graphical environment, leveraging GEM's transformations.
  • part_draw The part_draw object is used to render a particle system within Pure Data's GEM environment.
  • sphere The sphere object renders a 3D sphere within the GEM (Graphics Environment for Multimedia) context.
  • rgb2yuv The rgb2yuv object converts color values from the RGB (Red, Green, Blue) color space to the YUV (Luma, Chroma) color space.
  • pix_mano The pix_mano object tracks light-reflecting objects within a video stream by applying a threshold and analyzing their contours.
  • gemmanager The gemmanager object is an internal helper designed to interact with Gem's global state.
  • pix_offset The pix_offset object adds an offset to the color channels of an incoming image (gemlist).
  • light The light object in GEM adds a local point-light source to a 3D scene, allowing for realistic lighting effects.
  • gemmacwindow The gemmacwindow object is a legacy Pure Data external designed for macOS (up to OSX 10.6) that creates and manages graphical windows using the Carbon API.
  • pix_levels The pix_levels object performs image level adjustments, similar to brightness and contrast controls.
  • pix_buf The pix_buf object, also known as pix_separator, buffers image data (pixes) to store the results of time-consuming processing operations.
  • rotateXYZ The rotateXYZ object in GEM applies a 3D rotation to the current transformation matrix.
  • pix_draw The pix_draw object directly draws pixels onto the screen without applying any texture mapping.
  • pix_deinterlace The pix_deinterlace object applies a deinterlacing algorithm to incoming images, primarily by averaging neighboring rows.
  • pix_multiply The pix_multiply object in Pure Data multiplies two input images (pixes) together, requiring them to be of the same size.
  • linear_path The linear_path object reads out values from a specified table.
  • render_trigger The render_trigger object provides timing signals related to the rendering process within a gemlist.
  • pix_2grey The pix_2grey object converts an incoming pixel image (represented as a gemlist) to grayscale.
  • part_killold The part_killold object is a GEM particle system utility that removes particles older than a specified "kill time." This allows for controlling the lifespan of particles, making them disappear after a set duration within a visual context..
  • pix_indycam The pix_indycam object captures video signals from an SGI video camera, outputting them as pixel data within Pure Data.
  • shearZX The shearZX object is a GEM manipulation object that applies a shear transformation to the current transformation matrix.
  • spot_light The spot_light object adds a customizable spot-light to a GEM scene, allowing control over its position, color (via RGB list), and properties like linear attenuation, cone cutoff angle, and decay at edges.
  • part_velcone The part_velcone object is a GEM object designed to set properties for a cone, likely within a particle system, by interacting with a partList.
  • ortho ortho is a GEM object in Pure Data that controls the rendering projection for subsequent graphical objects.
  • gemmouse The gemmouse object captures and outputs mouse events occurring within a GEM (Graphics Environment for Multimedia) window.
  • pix_histo pix_histo calculates the histogram (density function) of an input image, storing the results in Pure Data tables.
  • emissionRGB The emissionRGB object sets the emission color for subsequent vertex operations within a GEM (Graphics Environment for Multimedia) context.
  • pix_equal The pix_equal object processes an input RGBA image, generating a binary output image.
  • part_velocity The part_velocity object in Pure Data, part of the GEM library, sets the initial velocity of newly emitted particles.
  • pix_film The pix_film object loads and plays digital video files, providing frames as textures for use within Pure Data's GEM environment.
  • modelfiler The modelfiler object loads 3D model data from Alias/Wavefront OBJ files into Pure Data tables.
  • pqtorusknots The pqtorusknots object renders a customizable 3D torus knot within a GEM (Graphics Environment for Multimedia) context.
  • gemhead The gemhead object initiates and manages a GEM (Graphics Environment for Multimedia) rendering chain.
  • fluid.plotter The fluid.plotter object provides a native graphical user interface for plotting and querying two-dimensional datasets.
  • pix_motionblur The pix_motionblur object applies a simple and fast motion blur effect to an incoming image stream.
  • pix_a_2grey The pix_a_2grey object converts an input RGBA image to grayscale based on its alpha channel.
  • slideSquares The slideSquares object renders a series of sliding rectangles within a GEM patch.
  • pix_rgba The pix_rgba object converts the color space of an incoming image to RGBA format, which is the native color space for GEM.
  • pix_sig2pix~ pix_sig2pix~ converts up to four incoming audio signals into an image, treating each signal as a color channel (red, green, blue, alpha).
  • gemlist_info The gemlist_info object takes a gemlist as input and decomposes its current transformation matrix into basic transformations.
  • spectrograph~ The spectrograph~ object visualizes FFT amplitudes from 0 Hz to Nyquist, using a Hann window for spectral analysis.
  • pix_hsv2rgb The pix_hsv2rgb object converts an image's color representation from HSV (Hue, Saturation, Value) to RGB (Red, Green, Blue).
  • gemorb The gemorb object connects to a SpaceOrb 3D controller via a specified serial port (comport).
  • shearYX The shearYX object applies a shear transformation to a GEM object's current transformation matrix.
  • pix_threshold_bernsen pix_threshold_bernsen applies a dynamic tiled threshold filter to greyscale images for binarization.
  • scope3d~ The scope3d~ object visualizes audio signals in a three-dimensional space, allowing users to observe the interplay of up to three input signals (X, Y, Z axes).
  • gemwin The gemwin object manages the output window for GEM (Graphics Environment for Multimedia), controlling its properties like size, fullscreen mode, and title.
  • part_color The part_color object is a component of the GEM particle system, designed to define the visual color of particles.
  • textextruded The textextruded object renders a single line of extruded text within the GEM environment, applying current color and 3D transformations.
  • pix_hit The pix_hit object performs hit tests on incoming GEM pixel data, allowing users to define specific areas (circles, lines, rectangles) within an image or video stream.
  • pix_mix The pix_mix object functions as a video mixer, blending two input images based on provided mixing factors.
  • gemreceive gemreceive is an ordered message receiver for the GEM (Graphics Environment for Multimedia) environment.
  • pix_colorclassify The pix_colorclassify object analyzes an input RGBA image, classifying each pixel into one of six primary color categories (red, green, blue, yellow, black, white) or marking it as 'uncertain'.
  • part_orbitpoint The part_orbitpoint object is a GEM particle system object that causes particles to orbit a specified 3D position (x, y, z).
  • pix_rectangle pix_rectangle is a GEM object that renders a rectangle onto an existing image buffer (pix-buffer).
  • pix_duotone The pix_duotone object processes a pixImage to reduce its colors to a duotone palette.
  • square The square object renders a square within the GEM graphical environment.
  • graph~ graph~ is a simple abstraction designed for visualizing audio signals.
  • pix_scanline The pix_scanline object processes image rows, either duplicating or removing them.
  • specularRGB The specularRGB object in GEM sets the specular color for subsequent OpenGL vertex operations.
  • pix_roi The pix_roi object sets a region of interest (ROI) on an image using normalized coordinates.
  • gemglutwindow The gemglutwindow object creates and manages an OpenGL rendering window using the GLUT (OpenGL Utility Toolkit) library.
  • ambient The ambient object is a GEM manipulation object that sets the ambient color for all subsequent vertex operations in a 3D scene.
  • cylinder The cylinder object renders a 3D cylinder shape within the GEM environment, utilizing OpenGL.
  • gemrepeat The gemrepeat object is a GEM manipulation object designed to duplicate incoming gemlist messages.
  • pix_image The pix_image object loads image files (like TIFFs and JPEGs) into Pure Data, primarily for use as textures or for bitblitting operations within the GEM environment.
  • cube The cube object renders a 3D cube within the GEM (Graphics Environment for Multimedia) context.
  • pix_yuv The pix_yuv object converts the colorspace of an image to the YUV format.
  • part_size The part_size object controls the size of particles within a particle system, typically used in graphical contexts like GEM.
  • ambientRGB The ambientRGB object in Pure Data sets the ambient color for subsequent vertex operations within a GEM (Graphics Environment for Multimedia) patch.
  • shearYZ The shearYZ object applies a shear transformation to the current OpenGL transformation matrix, affecting subsequent graphical rendering.
  • accumrotate The accumrotate object is a GEM utility that applies accumulated rotations to a 3D transformation matrix.
  • curve3d The curve3d object renders a 3D Bezier curve.
  • world_light world_light adds a directional light source to a GEM scene, simulating light rays from an infinite distance (parallel rays).
  • pix_lumaoffset The pix_lumaoffset object offsets pixels in the y-direction based on their luminance, creating a visual effect where brighter areas are shifted more.
  • pix_convolve The pix_convolve object applies a convolution kernel to a GEM pix (image).
  • part_render The part_render object is used within the GEM environment to draw particle systems.
  • pix_biquad The pix_biquad object applies a time-based Infinite Impulse Response (IIR) filter to images, functioning similarly to the audio biquad~ object but for visual data.
  • pix_writer The pix_writer object saves the current GEM texture (image) to a file on disk.
  • pix_bitmask The pix_bitmask object applies a bitmask to incoming image data (gemlist), allowing selective modification or filtering of pixels.
  • ___textbbox__ The _textbbox object is a helper for visualizing bounding box information generated by Pure Data's text* objects.
  • glsl_geometry The glsl_geometry object loads and compiles a GLSL geometry shader from a specified file.
  • pix_coloralpha The pix_coloralpha object calculates and sets the alpha channel of an RGBA image.
  • fluid.waveform The fluid.waveform object visualizes multichannel audio waveforms, feature data, slices, and spectrograms within Pure Data.
  • pix_buffer_filmopen The pix_buffer_filmopen object reads a movie file into a named pix_buffer for subsequent image processing within GEM.
  • pix_puzzle The pix_puzzle object shuffles an input image by cutting it into rectangular pieces and rearranging them.
  • gemw32window The gemw32window object is a GEM (Graphics Environment for Multimedia) object specific to Microsoft Windows, used for creating and managing a graphical output window.
  • pix_set The pix_set object allows you to create or modify image data by providing a flat list of pixel values.
  • pix_rds The pix_rds object generates black and white random dot stereograms, commonly known as "magic eye" images.
  • primTri The primTri object renders a triangle with gradient colors.
  • vertex_program The vertex_program object in Pure Data loads and applies an ARB or NV vertex shader, enabling custom vertex processing within GEM.
  • pix_coordinate pix_coordinate is a GEM object designed to set and remap the S and T texture coordinates for a pix object.
  • pix_dump The pix_dump object processes an incoming GEM image and outputs its raw pixel data as a single, long list of color component values.
  • gemglxwindow gemglxwindow is a Gem object designed for direct interaction with the X-window system, enabling the creation and management of an OpenGL rendering window.
  • pix_multiimage The pix_multiimage object loads multiple image files (TIFF, JPEG, PNG) into memory, which can then be used as textures or for bitblitting within GEM.
  • disk The disk object renders a flat disk, optionally with a central hole, at the current GEM OpenGL position using the current color.
  • pix_background The pix_background object removes a static background from an incoming video stream by comparing it to a stored reference image.
  • pix_tIIR The pix_tIIR object implements a time-based Infinite Impulse Response (IIR) filter for image processing within GEM.
  • imageVert The imageVert object maps an input image (pix) to a 3D geometric representation.
  • pix_takealpha The pix_takealpha object transfers the alpha channel from a second input image to a first input image.
  • pix_resize The pix_resize object resizes an image to specified dimensions.
  • emission The emission object in Pure Data, part of the GEM library, sets the emission color for subsequent OpenGL vertex operations.
  • polygon_smooth The polygon_smooth object controls antialiasing for polygons within GEM, effectively smoothing their edges.
  • pix_convert The pix_convert object transforms the color space of an image within GEM.
  • diffuseRGB The diffuseRGB object in Pure Data sets the diffuse color for subsequent vertex operations within a GEM (Graphics Environment for Multimedia) context.
  • mesh_line The mesh_line object renders a line mesh within the GEM environment, drawing it at the current position with the current color.
  • part_gravity The part_gravity object sets a gravitational vector for a particle system.
  • part_targetsize The part_targetsize object is a GEM particle object that dynamically adjusts the size of particles over time.
  • tLink3D The tLink3D object in Pure Data is designed for 3D physical modeling, simulating a link between two masses.
  • gemlist The gemlist object stores a list of GEM graphics commands or data.
  • glsl_vertex The glsl_vertex object loads and compiles a GLSL vertex shader into a module.
  • cuboid The cuboid object renders a 3D box within GEM (Graphics Environment for Multimedia) at the current position and with the current color.
  • part_head The part_head object initializes and manages a particle system within GEM.
  • pix_grey The pix_grey object converts the color space of an incoming image to grayscale.
  • pix_posterize pix_posterize applies a posterization effect to images within the GEM environment.
  • part_velsphere The part_velsphere object is a GEM object designed to set a sphere with a specified radius for a particle list.
  • part_information The part_information object provides detailed data for all particles within a particle system, typically set up using part_head and other part_ objects.
  • pix_movie The pix_movie object loads and plays digital video files, making their frames available as textures for real-time graphics rendering within GEM.
  • part_info The part_info object provides detailed information about each particle within a particle system, typically set up with part_head and other part_ objects.
  • pix_blobtracker The pix_blobtracker object in Pure Data is a video analysis tool designed to detect and track multiple distinct regions (blobs) within an incoming video stream.
  • pix_multitexture The pix_multitexture object applies multiple texture mappings within a GEM (Graphics Environment for Multimedia) network.
  • pix_record The pix_record object in Pure Data is used to record sequences of video frames (pixes) to an output file, pipe, or video device.
  • ripple The ripple object is a GEM geometric object that renders and distorts a square.
  • pix_frei0r The pix_frei0r object loads and applies Frei0r video effects, a minimalistic plugin API for real-time video processing.
  • part_killslow The part_killslow object is a GEM particle system utility designed to manage particle populations.
  • pix_video The pix_video object captures live video input from various cameras (USB, FireWire, capture cards) supported by the operating system.
  • tube The tube object in Pure Data renders a 3D tube shape.
  • gemmacoswindow The gemmacoswindow object is a macOS-specific Pure Data external that creates and manages graphical windows using Cocoa.
  • pix_refraction The pix_refraction object processes an input image by dividing it into rectangular cells and scaling the image content within each cell.
  • pix_clearblock The pix_clearblock object, part of the GEM (Graphics Environment for Multimedia) library, clears the visual content of an image while preserving its underlying texture information and setup.
  • pix_texture The pix_texture object applies texture mapping to GEM graphics.
  • spline_path The spline_path object reads interpolated values from a multi-dimensional table, treating it as a spline.
  • pix_composite The pix_composite object alpha-blends two input images (gemlists) of the same size.
  • teapot The teapot object renders a 3D teapot shape within a GEM patch.
  • rectangle The rectangle object is a GEM (Graphics Environment for Multimedia) object that renders a rectangular shape.
  • mesh_square The mesh_square object renders a square mesh at the current position and color, with its size controllable via the second inlet.
  • pix_share_write The pix_share_write object writes pixel data to a shared memory region, identified by a unique ID, width, height, and colorspace.
  • model The model object in Pure Data renders 3D models saved in the Alias/Wavefront OBJ format.
  • pix_subtract The pix_subtract object subtracts the pixel values of one image from another, requiring both input images to be of the same size.
  • pix_write The pix_write object captures a snapshot of the current GEM frame buffer and saves it to a file.
  • pix_aging The pix_aging object applies a Super8-like aging effect to images or video streams, simulating the look of old film.
  • triangle The triangle object in Pure Data is a GEM (Graphics Environment for Multimedia) object that renders an isosceles triangle.
  • pix_delay The pix_delay object creates a frame-based delay line for images, allowing a series of images to be delayed.
  • scaleXYZ The scaleXYZ object scales a GEM (Graphics Environment for Multimedia) object along its X, Y, and Z axes.
  • alpha The alpha object in Pure Data enables and controls alpha blending for graphical rendering within GEM.
  • pix_zoom The pix_zoom object, part of the GEM library, allows for magnifying or minifying pixels.
  • curve The curve object in Pure Data generates and renders a Bezier curve within the GEM environment.
  • diffuse The diffuse object in Pure Data sets the diffuse color for subsequent vertex operations within a GEM (Graphics Environment for Multimedia) context.
  • pix_crop The pix_crop object is a GEM utility that extracts a sub-image from an incoming image.
  • pix_snap2tex The pix_snap2tex object captures a snapshot of the current GEM render buffer and applies it as a texture to attached geometric objects.
  • pix_rgb2hsv The pix_rgb2hsv object converts an RGB (Red, Green, Blue) image into the HSV (Hue, Saturation, Value) color space.
  • pix_flip The pix_flip object is a GEM object designed to flip images along a specified axis.
  • gemsdlwindow gemsdlwindow is a Pure Data object that utilizes the SDL (Simple DirectMedia Layer) toolkit to create and manage graphical windows.
  • pix_alpha The pix_alpha object in Pure Data modifies the alpha channel of an RGBA image based on RGB color thresholding.
  • trapezoid The trapezoid object in Pure Data renders a trapezoidal shape in a graphical environment, taking its position and color from the current rendering state.
  • glsl_program The glsl_program object compiles and links GLSL shader modules (from glsl_fragment, glsl_vertex, and glsl_geometry) into an OpenGL 2.0 shader program.
  • pix_freeframe The pix_freeframe object loads and applies FreeFrame video effects in real-time.
  • zbiplot The zbiplot object visualizes biquad filter coefficients by plotting their poles and zeros in the complex plane.
  • gemsdl2window The gemsdl2window object creates and manages a graphical window using the SDL2 toolkit, providing an OpenGL context for rendering.
  • glsl_fragment The glsl_fragment object loads and compiles GLSL fragment shaders, outputting a module ID for use with glsl_program.
  • pix_backlight The pix_backlight object applies a backlighting effect to images by radially displacing pixels based on their luminance.
  • pix_metaimage The pix_metaimage object processes an input image to create an output composed of many smaller, scaled versions of the original, each altered to match the color of its corresponding area.
  • pix_gain The pix_gain object applies a gain multiplier to the pixel values of an image (pix).
  • part_source The part_source object creates a source for particles within a particle system, emitting new particles at a specified rate per rendering frame.
  • color The color object in Pure Data sets the color for all subsequent GEM (Graphics Environment for Multimedia) shape and vertex operations.
  • pix_normalize The pix_normalize object processes image data to enhance visual contrast.
  • pix_invert The pix_invert object inverts the colors of an input image, transforming black pixels to white and vice-versa.
  • colorSquare The colorSquare object renders a square at the current position within a GEM (Graphics Environment for Multimedia) context.
  • shininess The shininess object in GEM sets the shininess property of materials for subsequent OpenGL vertex operations.
  • pix_test The pix_test object generates test images, primarily featuring SMPTE colorbars and black/white gradients.
  • sphere3d The sphere3d object renders a deformable 3D sphere within GEM.
  • specular The specular object sets the specular color for subsequent 3D vertex operations within a GEM (Graphics Environment for Multimedia) context.
  • pix_buffer pix_buffer is a named storage object for images, functioning similarly to a table but without direct visual access to its contents.
  • part_targetcolor The part_targetcolor object is a GEM object designed for particle systems, enabling dynamic color changes for particles.
  • pix_compare The pix_compare object compares two input image streams pixel by pixel based on their luminance.
  • hsv2rgb The hsv2rgb object converts color values from the Hue, Saturation, Value (HSV) color space to the Red, Green, Blue (RGB) color space.
  • rubber The rubber object is a GEM object that renders and distorts a square.
  • pix_rtx The pix_rtx object performs a real-time "Time-X transformation" on incoming video frames, effectively swapping the time axis with the x-axis of the image.
  • pix_threshold The pix_threshold object applies a threshold filter to incoming image data.
  • cone The cone object renders a 3D cone at the current OpenGL position using the current color.
  • pix_color The pix_color object sets the color of each pixel in an input image to a specified RGBA value.
  • pix_contrast pix_contrast is a GEM object designed to adjust the contrast and saturation of an input image.
  • biplot The biplot object visualizes the frequency response of a biquad filter.
  • pix_mean_color The pix_mean_color object calculates the average color of an incoming image.
  • shearXZ The shearXZ object applies a shear transformation to a GEM list, modifying the current OpenGL transformation matrix.
  • gemcocoawindow The gemcocoawindow object creates and manages a graphical window on macOS using the Cocoa framework, specifically for GEM (Graphics Environment for Multimedia).
  • yuv2rgb The yuv2rgb object converts video signals between the YUV and RGB color spaces.
  • pix_chroma_key The pix_chroma_key object performs real-time video compositing by comparing pixels from two input streams.
  • gemglfw2window The gemglfw2window object creates and manages a graphical window using GLFW (version 2) within Pure Data's GEM environment.
  • pix_drum The pix_drum object analyzes incoming video streams, specifically detecting black pixels from the top of the image.
  • pix_data The pix_data object retrieves the color of a specified pixel within an image when triggered.
  • surface3d The surface3d object renders a 3D bicubic curve, with its shape controlled by a matrix of control points.
  • part_sink The part_sink object defines a spatial region within a particle system where particles will be removed or "vanish." Users can specify various geometric shapes (domains) such as points, lines, spheres, or boxes, along with their corresponding arguments (e.g., coordinates, radii).
  • part_damp The part_damp object is a GEM particle system utility that modifies the velocity of particles.
  • gemglfw3window The gemglfw3window object uses GLFW (version 3) to create and manage graphical windows within Pure Data, primarily for OpenGL rendering.
  • textoutline The textoutline object renders a single line of outlined text within a GEM (Graphics Environment for Multimedia) context.
  • pix_mask The pix_mask object applies a mask to an image using the luminance of a second image.
  • camera The camera object in Pure Data is used to access and control video camera input.
  • gemvertexbuffer The gemvertexbuffer object efficiently renders geometric objects by managing a Vertex Buffer Object (VBO).
  • pix_blob The pix_blob object calculates the "center of gravity" of an image.
  • Gem The Gem object serves as a meta-object for the Pure Data Graphics Environment for Multimedia (GEM).
  • pix_colorreduce The pix_colorreduce object reduces the number of colors in a pixImage based on its statistical information.
  • GLdefine The GLdefine object retrieves the numerical value of an OpenGL configuration constant, specified by its name (e.g., GL_LINES, GL_POLYGON).
  • depth The depth object controls OpenGL's depth testing (Z-buffering) within GEM.
  • torus The torus object renders a 3D torus (doughnut shape) within a GEM environment.
  • polygon The polygon object in Pure Data renders a polygon graphic within the GEM environment.
  • pix_roll The pix_roll object scrolls or rolls an image, wrapping its content around the edges.
  • part_vertex The part_vertex object is a core component for GEM-based particle systems.
  • separator The separator object in Pure Data's GEM library isolates transformation effects between parallel rendering chains.
  • pix_movement The pix_movement object is a time-based IIR filter that detects movement between consecutive video frames.
  • pix_fiducialtrack The pix_fiducialtrack object detects and tracks fiducial markers in black and white grayscale images, utilizing a system similar to reacTable.
  • gemcubeframebuffer The gemcubeframebuffer object renders a 3D scene onto the faces of a GL cubemap texture.
  • pix_buffer_read The pix_buffer_read object reads image data from a named pix_buffer.
  • shearXY The shearXY object applies a shear transformation to graphical objects within GEM (Graphics Environment for Multimedia).
  • GEMgl The GEMgl objects in Pure Data provide direct wrappers for OpenGL functions, enabling users to access low-level graphics rendering commands within their patches.
  • gemframebuffer The gemframebuffer object renders a graphical scene into an off-screen texture, which can then be used as an input for further rendering operations.
  • fragment_program The fragment_program object loads and applies ARB or NV fragment shaders, which perform per-pixel operations within OpenGL.
  • pix_movement2 The pix_movement2 object is a time-based IIR filter designed for motion detection in video streams.
  • pmpd3d The pmpd3d object implements 3D physical models based on a mass-spring-damper system.
  • text2d The text2d object in Pure Data renders a line of text using TrueType fonts within a GEM environment.
  • pix_colormatrix The pix_colormatrix object transforms pixel values using a matrix.
  • pix_share_read The pix_share_read object reads pixel data from a shared memory region, identified by a unique ID.
  • shearZY The shearYZ object applies a shear transformation to a gemlist, modifying the current OpenGL transformation matrix.
  • pix_halftone The pix_halftone object applies a halftone effect to an incoming image, transforming it into patterns of dots or diamonds, similar to those found in newspaper prints.
  • pix_kaleidoscope The pix_kaleidoscope object applies a visual kaleidoscope effect to an input image, reflecting a selected portion multiple times around a central point.
  • scopeXYZ~ The scopeXYZ~ object functions as a 3-dimensional oscilloscope, visualizing three input signals as excursions along the X, Y, and Z axes.
  • pix_pix2sig~ The pix_pix2sig~ object converts incoming image data, typically from GEM, into audio signals.
  • pix_multiblob The pix_multiblob object detects multiple "blobs" within an image, defined as adjacent pixels exceeding a specified luminance threshold and minimum blobSize.
  • pix_info The pix_info object retrieves metadata about the current image in GEM, such as its dimensions, pixel size, color space (format), and a pointer to the image data.
  • colorRGB The colorRGB object in Pure Data's GEM environment sets the color for subsequent graphical shapes and vertex operations.
  • translateXYZ The translateXYZ object applies a 3D translation to the current transformation matrix within GEM (Graphics Environment for Multimedia).
  • gemlist_matrix gemlist_matrix is a Pure Data object within the GEM library that retrieves the current transformation matrix of an incoming gemlist.
  • pix_noise The pix_noise object generates a uniform noise image, with adjustable width and height.
  • translate The translate object in Pure Data is a GEM manipulation object that applies a translation to the current transformation matrix.