References

AjaxRequest class

BinaryRequest class

The abstract superclass for Core Animation animations.

An object that allows multiple animations to be grouped and run concurrently.

An object that provides basic, single-keyframe animation capabilities for a layer property.

An object that provides keyframe animation capabilities for a layer object.

A function that defines the pacing of an animation as a timing curve.

An abstract subclass of CAAnimation for creating animations that manipulate the value of layer properties.

Defines the standard transform matrix used throughout Core Animation.

A mutable graphics path: a mathematical description of shapes or lines to be drawn in a graphics context.

An immutable graphics path: a mathematical description of shapes or lines to be drawn in a graphics context.

A structure that contains a point in a two-dimensional coordinate system.

A structure that contains the location and dimensions of a rectangle.

A structure that contains width and height values.

A structure that contains a two-dimensional vector.

DispatchObject is the base class for many dispatch types, including DispatchQueue, DispatchGroup, and DispatchSource.

DispatchQueue manages the execution of work items.

DispatchTime represents a point in time relative to the default clock with nanosecond precision.

A representation of a physical game controller, connected to the device either physically or through a wireless connection.

A control element measuring movement along a particular axis.

A control element measuring a button press.

A control element associated with a directional pad or a thumbstick.

An input associated with a physical control, such as a button or thumbstick.

The extended set of gamepad controls.

The standard set of gamepad controls.

The controls provided by the Siri Remote.

dummy class for NSKeyedArchiver/Unarchiver

The NSCoder abstract class declares the interface used by concrete subclasses to transfer objects and other values between memory and some other format.

dummy class for NSKeyedArchiver/Unarchiver

dummy class for NSColorSpace

dummy class for NSKeyedArchiver/Unarchiver

dummy class for NSKeyedArchiver/Unarchiver

NSKeyedArchiver, a concrete subclass of NSCoder, provides a way to encode objects (and scalar values) into an architecture-independent format that can be stored in a file.

NSKeyedUnarchiver, a concrete subclass of NSCoder, defines methods for decoding a set of named objects (and scalar values) from a keyed archive.

dummy class for NSKeyedArchiver/Unarchiver

dummy class for NSKeyedArchiver/Unarchiver

dummy class for NSKeyedArchiver/Unarchiver

An object containing information broadcast to registered observers that bridges to Notification; use NSNotification when you need reference semantics or other Foundation-specific behavior.

The root class of most Objective-C class hierarchies, from which subclasses inherit a basic interface to the runtime system and the ability to behave as Objective-C objects.

dummy class for NSURL

An NSValue object is a simple container for a single C or Objective-C data item.

A notification dispatch mechanism that enables the broadcast of information to registered observers.

A simple, reusable animation that changes attributes of any node you attach it to.

A container for a closure to be executed at a specific time during playback of an animation.

A controller for playback of a positional audio source in a SceneKit scene.

A simple, reusable audio source—music or sound effects loaded from a file—for use in positional audio playback.

Options for locking the orientation of nodes affected by a billboard constraint.

A constraint that orients a node to always point toward the current camera.

A six-sided polyhedron geometry whose faces are all rectangles, optionally with rounded edges and corners.

A set of camera attributes that can be attached to a node to provide a point of view for displaying the scene.

A right circular cylinder geometry whose ends are capped with hemispheres.

A right circular cone or frustum geometry.

The abstract superclass for objects that automatically adjust the position, rotation, or scale of a node based on rules you define.

A right circular cylinder geometry.

Options for drawing overlays with SceneKit content that can aid in debugging, used with the debugOptions property.

An infinite plane that can optionally display a reflection of the scene above it.

A three-dimensional shape (also called a model or mesh) that can be displayed in a scene, with attached materials that define its appearance.

A container for index data describing how vertices connect to define a three-dimensional object, or geometry.

A container for vertex data forming part of the definition for a three-dimensional object, or geometry.

Detailed information about a result from searching for elements of a scene located at a specified point, or along a specified line segment (or ray).

A constraint that applies inverse kinematics to make a chain of nodes “reach” toward a target point.

A Core Animation layer that renders a SceneKit scene as its content.

An object that defines alternate resolutions for a geometry that SceneKit can automatically substitute to improve rendering performance.

A light source that can be attached to a node to illuminate the scene.

A constraint that orients a node to always point toward a specified other node.

A set of shading attributes that define the appearance of a geometry's surface when rendered.

A container for the color or texture of one of a material’s visual properties.

A representation of a 4 x 4 matrix.

An object that manages smooth transitions between a node's base geometry and one or more target geometries.

A structural element of a scene graph, representing a position and transform in a 3D coordinate space, to which you can attach geometry, lights, cameras, or other displayable content.

An animation for a single property of the individual particles rendered by a particle system.

Manages the animation and rendering of a system of small image sprites, or particles, using a high-level simulation whose general behavior you specify.

A physics behavior that connects two physics bodies and allows them to pivot around each other in any direction.

The abstract superclass for joints, vehicle simulations, and other high-level behaviors that incorporate multiple physics bodies.

A set of physics simulation attributes attached to a scene graph node.

Default values for a physics body’s categoryBitMask and collisionBitMask properties.

Detailed information about a contact between two physics bodies in a scene’s physics simulation.

An object that applies forces, such as gravitation, electromagnetism, and turbulence, to physics bodies within a certain area of effect.

A physics behavior that connects two bodies and allows them to pivot around each other on a single axis.

An abstraction of a physics body’s solid volume for use in tuning or optimizing collision detection.

A physics behavior that connects two bodies and allows them to slide against each other and rotate around their connecting points.

A physics behavior that modifies a physics body to behave like a car, motorcycle, or other wheeled vehicle.

The appearance and physical characteristics of an individual wheel associated with an physics vehicle behavior.

The global simulation of collisions, gravity, joints, and other physics effects in a scene.

A rectangular, one-sided plane geometry of specified width and height.

A complete Metal or OpenGL shader program that replaces SceneKit's rendering of a geometry or material.

A right rectangular pyramid geometry.

A scene graph node that serves as a placeholder for content to be loaded from a separate scene file.

A renderer for displaying SceneKit scene in an an existing Metal workflow or OpenGL context.

A scene graph—a hierarchy of nodes with attached geometries, lights, cameras and other attributes that together form a displayable 3D scene.

Manages the data-reading tasks associated with loading scene contents from a file or data.

A geometry based on a two-dimensional path, optionally extruded to create a three-dimensional object.

An object that manages the relationship between skeletal animations and the nodes and geometries they animate.

A sphere (or ball or globe) geometry.

A specification for augmenting or postprocessing SceneKit's rendering of a scene using additional drawing passes with custom Metal or OpenGL shaders.

A geometry based on a string of text, optionally extruded to create a three-dimensional object.

A torus, or ring-shaped geometry.

The SCNTransaction class defines SceneKit’s mechanism for batching scene graph modifications into atomic updates.

A constraint that runs a specified closure to compute a new transform (position, rotation, and scale) for each node that the constraint affects.

A tube or pipe geometry—a right circular cylinder with a circular hole along its central axis.

A representation of a three-component vector.

A representation of a four-component vector.

A view for displaying 3D SceneKit content.

An object that is executed by an SKNode to change its structure or content.

An object that stores color data and sometimes opacity (that is, alpha value).

A node that can apply Core Image filters or SKWarpGeometry distortions to its children.

A node that displays a text label.

The SKNode class is the fundamental building block of most SpriteKit content.

The root node for all Sprite Kit objects displayed in a view.

A node that renders a shape defined by a Core Graphics path.

A node that draws a rectangular texture, image or color.

A representation of an image for use in SpriteKit.

BinaryReader class

An interface that allows objects to respond to actions triggered by a CALayer.

Methods your app can implement to respond when animations start and stop.

Methods that model a hierarchical timing system, allowing objects to map time between their parent and local time.

Methods for running actions on nodes.

The common interface for attaching animations to nodes, geometries, materials, and other SceneKit objects.

Properties for measuring an object's location and size, expressed as either a box or a sphere.

An object that manages a Metal buffer used by a custom shader program.

Methods you can implement to use your own custom Metal or OpenGL drawing code to render content for a node.

Methods you can implement to respond when a contact or collision occurs between two physics bodies in a scene.

The interface for tracking errors that occur when compiling shader source code.

Methods you can implement to participate in the process of exporting a scene to a file.

Methods and properties common to the SCNView, SCNLayer and SCNRenderer classes.

Methods your app can implement to participate in SceneKit’s animation loop or perform additional rendering.

Methods for customizing SceneKit's rendering of geometry and materials using Metal or OpenGL shader programs.

The common interface for SceneKit objects that support multipass rendering using SCNTechnique objects.

Returns the current absolute time, in seconds.

Defines a callback function that can view an element in a graphics path.

Your block must return a floating-point value between 0.0 and 1.0, where 0.0 represents the starting state of the action’s animation and 1.0 represents the end state.

Signature for the block called when an animation event triggers.

Call handleBinding(ofSymbol:handler:) or handleUnbinding(ofSymbol:handler:) to associate a handler block with a GLSL symbol for a SceneKit geometry or material.

A block SceneKit calls at render time for working with buffers in a Metal shader, used by the handleBinding(ofBufferNamed:frequency:handler:) method.

Your block uses these parameters to compute and return an SCNVector3 force vector, which SceneKit then applies to the object affected by the field.

This function performs a numeric (not bitwise) comparison of each pair of elements.

Returns a SceneKit matrix corresponding to a GLKit matrix.

Returns the inverse of the specified matrix.

Returns a Boolean value that indicates whether the specified matrix is equal to the identity matrix.

Returns a matrix describing a rotation transformation.

Returns a matrix describing a scale transformation.

Returns a matrix describing a translation transformation.

Matrix multiplication is not commutative.

The resulting transformation consists of the specified rotation followed by the transformation represented by the mat parameter.

The resulting transformation consists of the specified scale followed by the transformation represented by the mat parameter.

Returns a GLKit matrix corresponding to a SceneKit matrix.

The resulting transformation consists of the specified translation followed by the transformation represented by the mat parameter.

Use this block to change properties of individual particles when they are spawned, when they collide with scene geometry, or when they die (that is, reach the end of their life spans and are removed from the scene).

Use this block to change properties of individual particles on each frame of simulation.ImportantRunning your own code to update particle properties every frame can have a severe impact on rendering performance.

stopSet *stop to true inside the block to cancel export.

The signature for the block that SceneKit calls periodically to report progress while loading a scene.

This function performs a numeric (not bitwise) comparison of each pair of component values.

Returns a three-element SceneKit vector structure corresponding to a GLKit vector structure.

Returns a new three-component vector created from individual component values.

Returns a three-element GLKit vector structure corresponding to a SceneKit vector structure.

This function performs a numeric (not bitwise) comparison of each pair of component values.

Returns a four-element SceneKit vector structure corresponding to a GLKit vector structure.

Returns a new four-component vector created from individual component values.

Returns a four-element GLKit vector structure corresponding to a SceneKit vector structure.

A quaternion is a mathematical construct useful for describing rotations in three-dimensional space.

Compositing operations for images.

Styles for rendering the endpoint of a stroked line.

Junction types for stroked lines.

Rules for determining which regions are interior to a path, used by the fillPath(using:) and clip(using:) methods.

DispatchTimeInterval represents a number of seconds, millisconds, microseconds, or nanoseconds.

The partitioning mode used by the tessellator to derive the number and spacing of segments used to subdivide a corresponding edge.

The type of the color-space mode constants listed in Color Space Models.

Constants affecting the animation curve of an action, used by the timingMode property.

Modes for antialiased rendering of the view’s scene, used by the SCNView property.

Modes that describe how SceneKit blends source colors rendered using a material with destination colors already in a rendering target, used by the blendMode property.

Options for how often SceneKit should execute the binding handler you provide with the handleBinding(ofBufferNamed:frequency:handler:) method.

Options for which edges of an extruded shape are chamfered, used by the chamferMode property.

The modes SceneKit uses to determine which polygons to render in a surface, used by the cullMode property.

Texture filtering modes, used by the the minificationFilter, magnificationFilter, and mipFilter properties.

The drawing primitive that connects vertices when rendering a geometry element, used by the primitiveType property to specify how SceneKit interprets the geometry element’s data.

The interpolation formulas for blending between target geometries.

Values that inform SceneKit’s rendering for movement-related effects, used by the movabilityHint property.

Options for the initial direction of each emitted particle, used by the birthDirection property.

Options for the initial location of each emitted particle, used by the birthLocation property.

Options for combining source and destination pixel colors when compositing particles during rendering, used by the blendMode property.

Significant events in the life spans of simulate particles, used by the handle(_:forProperties:handler:) method.

Options for animating each particle with a sequence of images, used by the imageSequenceAnimationMode property.

Options for the input value of the property controller’s animation, used by the inputMode property.

Stages of SceneKit’s particle simulation process into which you can insert modifier blocks, used by the addModifier(forProperties:at:modifier:) method.

Options for restricting the orientation of particles, used by the orientationMode property.

Options for the rendering order of particles, used by the sortingMode property.

Constants that determine how a physics body interacts with forces and other bodies, used by the type property and when creating a physics body.

Options for defining the region of space affected by a physics field, used by the scope property.

Options for when to load the reference node’s content, used by the loadingPolicy property.

Options for choosing the graphics technology for an SCNView object (or other SceneKit renderer) to use for drawing its contents.

Constants identifying phases of SceneKit’s scene loading process, used in a SCNSceneSourceStatusHandler block.

Options for SceneKit’s rendering of shadows cast by a light, used by the shadowMode property.

The modes SceneKit uses to calculate the opacity of pixels rendered with a material, used by the transparencyMode property.

Modes to apply to texture wrapping, used by the wrapT and wrapS properties.

The modes that an action can use to adjust the apparent timing of the action.

The modes that describe how the source and destination pixel colors are used to calculate the new destination color.

Options for aligning text horizontally.

Options for aligning text vertically.

The modes that determine how the scene’s area is mapped to the view that presents it.

Texture filtering modes to use when the texture is drawn in a size other than its native size.