Glossary

This glossary covers key technical terms and concepts covered in the Power of Pops course. Point Operators (Pops) are TouchDesigner’s next-generation GPU-based tools for working with points in real-time. They enable faster, more scalable geometry processing, using compute shaders and a new workflow focused on attributes and point-level logic.

Use this glossary as a reference to understand the building blocks of Pops — from attributes and built-in variables to specialized operators like Math Mix, Particle Pop, and Ray Pop. Whether you’re debugging a network or writing custom GLSL, these definitions will help you navigate the Pops ecosystem with clarity and confidence.

Pops (Point Operators): A new and exciting family of GPU-based operators in TouchDesigner that operate primarily on points. They offer significantly faster performance compared to traditional CPU-based SOPS. Pops leverage compute shaders for their operations.

Points: The fundamental unit that Point Operators (Pops) primarily operate on. A point is essentially a position in 3D space defined by X, Y, and Z coordinates. Points can carry various attributes.

Attributes: A unit of information that you can embed in a point, expressed with numbers. There is no limit to how many attributes can be added to a point, but more attributes consume more memory. Attributes are the only mechanism to create data in points with Pops. Examples include P (position), N (normal), and text (texture coordinates). You should minimize the number of attributes being outputted at the end of your chain to save memory.

Built-in Attributes: Predefined attributes accessed with an underscore (e.g., _pointI, _pointU, _stepSeconds, _pi). These can be explicitly converted to conventional attributes (e.g., via Math Mix) to be used in instancing.

_pointI: Provides the actual point index.

_pointU: Provides the normalized point index, ranging from 0 to 1.

_stepSeconds: A variable that adapts to frame drops, ensuring consistent animation speed for time-dependent operations, unlike 1 / me.time.rate which is a constant. It’s essentially one over the current frame rate but accounts for drops.

GLSL (OpenGL Shading Language): A programming language used for writing shaders. In Pops, GLSL can achieve results in fewer, more explicit lines of code when Pop operator setups become complicated and less readable. It makes writing code easier and can be more desirable than making very complicated operator chains.

Compute Shaders: The type of GLSL shaders used by Pops, offering much more flexibility than fragment or vertex shaders.

Uniforms: Values that are applied equally to every single point in a shader. In the Pop GLSL environment, uniforms declared in the operator’s parameters do not need to be explicitly declared in the GLSL code itself.

Accessing Data in GLSL: To read from an input, use TDin_ followed by the attribute name, input number, and point ID (e.g., TDin_P(0, TDindex)). For template attributes in GLSL Copy pop, use TDtemplateAttributes.

Pop Operators: Specific nodes within the Pops family designed for various operations.

Attribute Pop: Used to create new attributes and initialize them with values. These values can be overwritten later.

Math Pop: An operator that applies mathematical functions to one attribute at a time.

Math Mix Pop: A more powerful version of Math Pop that allows for stacking multiple operations and combining attributes from different inputs. It also allows explicitly deleting new attributes to save memory.

Math Combine Pop: Similar to Math Mix, but even more powerful, allowing attributes to be created directly within the operator. It can seamlessly operate on matrices.

Convert Pop: Enables conversion of primitives (e.g., triangles to line strips, or deleting all visual primitives to save memory while keeping abstract data).

Delete Pop: Allows for deleting points based on various conditions, such as a bounding box or a pattern.

Copy Pop: Works similarly to instancing, allowing copies of a source geometry onto template points, but is slower than traditional instancing. It can copy attributes from the template to the copied objects.

GLSL Copy Pop: A GLSL version of the Copy Pop that allows for custom copy logic, enabling each copy to behave drastically differently (e.g., having its own frequency of growth or size).

Pattern Pop: Similar to the Pattern CHOP, it allows selecting different types of functions to operate on point attributes across different dimensions.

Lookup Texture/Channel Pops: Allow reading data from textures (Lookup Texture) or CHOPs (Lookup Channel) based on a point’s attribute (e.g., text or _pointU) and mapping it to another attribute like scale or color.

Field Pop: Generates a field around a certain condition and outputs weights for that field, which can be used to alter geometry based on proximity.

Facet Pop: Changes the way primitives and points are computed, for example, by making points unique to achieve a low-poly look. It can use groups to target specific parts of geometry.

Particle Pop: A very powerful pop for serious particle systems, significantly more capable than the particle SOP. It handles the updating process for particles internally, often requiring a feedback loop where the output is fed back into the update input.

Trails Pop: Generates a trail of the motion of some point. It’s crucial to map trails to use an attribute name for its behavior (e.g., particleID) when used with particles to ensure strict tracking of individual points.

Ray Pop: Allows computing projections (shooting rays) from one point to another point or a collision geometry. It can provide information like the point intersection distance.

Neighbour Pop: A powerful pop that detects points within a defined vicinity. It provides an array of neighbor IDs (neNeighbors) and the count of actual neighbors (numNeighbors). This is highly useful for optimizing simulations like flocking by avoiding brute-force checks.

Instancing: A traditional TouchDesigner technique for efficiently copying geometry. It is generally faster than the Copy Pop.

Vertices: A link between a primitive and a point. Multiple vertices can refer to the same point, distinguishing them from points themselves.

Primitives: The geometric shapes built from vertices (e.g., lines, triangles, quads, line strips).

Groups: A concept allowing the grouping of points together based on conditions (e.g., bounding boxes, attributes). Groups can then be targeted by operators to selectively alter parts of the geometry.

Eulerian Integration: A simple method for simulating particle physics where acceleration, velocity, and position are updated iteratively in a loop. It involves adding acceleration to velocity and velocity to position over time.

Feedback Loop: A necessary mechanism for updating things on particles or other systems over time. In Pops, the Particle Pop uses feedback internally via the “Target Particles Update POP” field, but for other systems you need to explicitly use a Feedback POP to loop other output of a node back to an input.