Instancer

Brief Description

The instancer is a swiss-army knife used to replicate a source image many times. The Dimension Size is useful to give for each dimension the number of instances to create. Note that this is multiplicative: Setting Number of Dimensions to 2 with Dimension 1 Size to 5 and Dimension 2 Size to 3 will create 15 instances. The Number of Dimensions is useful in tandem with the Instance Transform for each dimension. The Accumulate Transform parameter is very important: For each instance the transform is applied one more time than the previous instance. For example, to make a Grid of instances, the Instance Transform 1 can be used to move instances along the X axis and the Instance Transform 2 can be used to move instances along the Y axis.

For a full tutorial on the instancer, please take a look at the dedicated section on the Academy

Controls

Parameter / Script Name	Type	Default	Function
`Enabled / enabled`	Boolean	On
`Instance Mode / instanceMode`	Choice	Source	- *Source: Instantiate the whole composition. - Source Sub-Layers*: Instanciate specific layers of the composition.
`Template / instance_template`	Image	-
`Num. Dimensions / numDimensions`	Choice	1	- 1 - 2 - 3 - 4
`Dimension 1 Size / dim0_size`	Float	3
`Dimension 2 Size / dim1_size`	Float	1
`Dimension 3 Size / dim2_size`	Float	1
`Dimension 4 Size / dim3_size`	Float	1
`Instance Origin / layersOriginMode`	Choice	Global Origin	- *Invividual Origins: Each instance transform is relative to its rectangle position selected by Origin - Global Origin*: The anchor point is global to all elements
`Instance Origin X / originX`	Choice	Center	- *Left* - *Middle Left* - *Center* - *Middle Right* - *Right*
`Instance Origin Y / originY`	Choice	Center	- *Bottom* - *Middle Bottom* - *Center* - *Middle Top* - *Top*
`Instance Transform 1 / transformDim0`
`Accumulate Transform 1 / accumTransform`	Boolean	Off	When checked, each instance have the transform applied as many times as its instance index + 1
`Centered Accumulation 1 / accumCentered`	Boolean	Off	When checked, the accumulation is centered
`Transform First Instance 1 / appliesToFirstInstance`	Boolean	Off	When checked, the instance transform is also applied to the first instance
`Instance Transform 2 / transformDim1`
`Accumulate Transform 2 / accumTransform1`	Boolean	Off	When checked, each instance have the transform applied as many times as its instance index + 1
`Centered Accumulation 2 / accumCentered1`	Boolean	Off	When checked, the accumulation is centered
`Transform First Instance 2 / appliesToFirstInstance1`	Boolean	Off	When checked, the instance transform is also applied to the first instance
`Instance Transform 3 / transformDim2`
`Accumulate Transform 3 / accumTransform2`	Boolean	Off	When checked, each instance have the transform applied as many times as its instance index + 1
`Centered Accumulation 3 / accumCentered2`	Boolean	Off	When checked, the accumulation is centered
`Transform First Instance 3 / appliesToFirstInstance2`	Boolean	Off	When checked, the instance transform is also applied to the first instance
`Instance Transform 4 / transformDim3`
`Accumulate Transform 4 / accumTransform3`	Boolean	Off	When checked, each instance have the transform applied as many times as its instance index + 1
`Centered Accumulation 4 / accumCentered3`	Boolean	Off	When checked, the accumulation is centered
`Transform First Instance 4 / appliesToFirstInstance3`	Boolean	Off	When checked, the instance transform is also applied to the first instance
`Motion-Blur Settings / motionBlurSettings`	Choice	Disabled	- *Disabled: Disable motion-blur for the instance transform - Use Composition Settings: The motion-blur quality and shutter settings of the Composition are used - Custom Settings*: The motion-blur quality and shutter settings are local to this layer
`Motion-Blur Quality Mode / mbQualityMode`	Choice	Adaptive	Determines how the number of samples in the motion-blur computation. Adaptive uses a varying number of samples based on the speed of the element. In this mode the Motion-Blur Quality acts as a multiplier on the adaptive number of samples. Samples Count uses a user-supplied number of samples. - *Adaptive* - *Samples Count*
`Samples Count / mbSamples`	Float	90	Number of samples used to process the motion-blur. Higher means higher quality but longer to render. 0 disables motion-blur.
`Motion-Blur Quality / mbQuality`	Float	0.6	Quality of the adaptive motion-blur sampling. 0 disables motion-blur. This acts as a multiplier on the number of samples determined by the adaptive mode.
`Shutter Angle / shutterAngle`	Float	180	The shutter angle controls the time period over which light can pass. A wider angle increases motion-blur
`Shutter Phase / shutterPhaseType`	Choice	Centered	- *Centered: The shutter opens half the shutter duration before the current time and closes half the shutter duration after - Start: The shutter opens at the current time and closes after the shutter duration is elapsed - End: The shutter opens at the current time minus the shutter duration and closes at the current time - Custom*: The shutter opens at the time determined by a custom phase: the phase is an offset on the shutter angle, assuming the shutter opens at 0
`Custom Phase / customPhase`	Float	-90	An offset to the shutter angle, assuming the shutter opens at 0°: A Shutter angle of 180° with a phase of -90° means that the shutter will be opened half a frame, centered around the current time
`Layer Index Mode / layerIndexMode`	Choice	Bottom To Top	- *Bottom To Top: Source elements are instanciated from the bottom of the list to the top - Top To Bottom: Source elements are instanciated from the top of the list to the bottom - Random: Source elements are instanciated in a pseudo-random fashion, controlled by the seed - Custom*: Source elements are controlled by the Layer Instance Index parameter
`Instance Index / layerIndex`	Float	0
`Layer Index Start Offset / layerIndexStartOffset`	Float	0
`Layer Index Step / layerIndexStep`	Float	1
`Layer Index Wrap / layerIndexWrapMode`	Choice	Loop	- *Clamp* - *Loop* - *Mirror* - *Stop*
`Layer Index Seed / layerIndexRandomSeed`	Float	0
`Index Mode / instanceIndexMode`	Choice	Forward	How to iterate through instances. This affects Accumulate Transform, Accumulate Time Offset , Accumulate Opacity and blending order - *Forward: Instances are iterated from 0 to the total number of instances - 1 - Backward: Instances are iterated from the total number of instances -1 to 0 - Shuffle*: Instances are spawned in a random order, controlled by Shuffle Seed
`Shuffle Seed / instanceShuffleSeed`	Float	0
`Instance Time Offset / timeOffset`	Time	0	Apply a Time Offset to each instance. It is useful when used in combination with Accumulate Time Offset or with a generator using the Instance Index
`Accumulate Time Offset / accumTimeOffset`	Boolean	Off	When checked, each instance have the time offset applied as many times as its instance index + 1
`Accumulate Time Offset Mode / timeOffsetMode`	Choice	Stacking Index	Whether to use the Instance Index or the Stacking Index to accumulate the time offset. Stacking Index is always a distribution between 0 and Number of instances - 1, whereas the Instance Index can be randomized with Index Mode. - *Instance Index* - *Stacking Index*
`Apply Time Offset To First Instance / applyTimeOffsetToFirst`	Boolean	On	When checked and if Accumulate Time Offset is checked, the Time Offset is also applied to the first instance
`Instance Start Time / instanceStartTime`	Time	0	Limits the lifetime of each instance in the range from Instance Start Time + Instance Time Offset for a duration of instance Duration. This is useful mostly to optimize the performances when the Instancer has many instances but visually only a few of them are visible at a given time because they are out of the format. A value of 0 will make all instances live forever (except if themselves they have a time range)
`Instance Duration / instanceDuration`	Time	0	Limits the lifetime of each instance in the range from Instance Start Time + Instance Time Offset for a duration of instance Duration. This is useful mostly to optimize the performances when the Instancer has many instances but visually only a few of them are visible at a given time because they are out of the format. A value of 0 will make all instances live forever (except if themselves they have a time range)
`Instance Opacity / opacity`	Float	1
`Accumulate Opacity / accumOpacity`	Boolean	Off	When checked, each instance have the opacity applied as many times as its instance index + 1
`Apply Opacity To First Instance / applyOpacityToFirst`	Boolean	Off	When checked and if Accumulate Opacity is checked, the Instance Opacity is also applied to the first instance
`Invert Instance Opacity / invertInstanceOpacity`	Boolean	Off	When checked and if Accumulate Opacity is checked, the Instance Opacity is accumulated as 1 - Instance opacity instead
`Instance Blend Mode / blendMode`	Choice	Normal	- *Add*: Ac + Dc
The source is added to the destination and replaces the destination. This operator is useful for animating a dissolve between two images. - *Color Dodge*: if Ac < 1
min(1,Bc / (1 - Ac))
else
1
Brightens the backdrop color to reflect the source color. Painting with black produces no changes. - *Lighten*: max(Ac, Bc)
The resultant color is the lighter of source or destination colors. If the source is lighter, it replaces the destination. Otherwise, the destination is preserved. - *Linear Dodge*: min(Ac + Bc, 1)
Lightens the source image to reflect the destination image color - *Screen: Ac + Bc - Ac Bc
The source and destination colors are complemented, multiplied and the resultant color replaces the destination. The resultant color is always at least as light as either the source or destination colour. - *Hard-light*: if Ac <= 0.5
multiply(Ac)
else
screen(Ac)
The source color is used to determine if the resultant is either a multiplication or screening of the colors. If the source color is lighter than 0.5, the destination is lightened as if it were screened. If the source color is darker than 0.5, the destination is darkened, as if it were multiplied. - *Hard Mix: if vivid-light(Ac,Bc) < 0.5 then 0 else 1 - Linear Light*: if Ac < 0.5
linear-burn(2 * Ac, Bc)
else
linear-dodge(2 * (Ac - 0.5), Bc)
Use linear-burn to decrease brightness on dark colors and linear-dodge to increase brightness on lighter colors - *Overlay*: if Bc <= 0.5
2 * Ac * Bc
else
1 - 2 * (1 - Bc) * (1 - Sc)
The destination color is used to determine if the resultant is either a multiplication or screening of the colors. Source colors overlay the destination whilst preserving its highlights and shadows - *Pin Light*: if B >= 0.5
lighten(Ac, 2 * Bc - 1)
else
darken(Ac, Bc * 2.0)
A mix of full strength Lighten and Darken blend modes: It completely removes all mid tones - *Soft Light: if 2 Ac <= 1
Bc - (1 - 2 * Ac) * Bc * (1 - Bc)
else if 4 * Bc <= 1
Bc + (2 * Ac - 1) * (4 * Bc * (4 * Bc + 1) * (Bc - 1) + 7 * Bc
else
Bc + (2 * Ac - 1) * (sqrt(Bc) - Bc)
The source colour is used to determine if the resultant color is darkened or lightened. If the source color is lighter than 0.5, the destination is lightened. If the source color is darker than 0.5, the destination is darkened, as if it were burned in. The degree of darkening or lightening is proportional to the difference between the source color and 0.5. If it is equal to 0.5, the destination is unchanged - *Vivid Light*: if Ac < 0.5
color-burn(2 * Ac, Bc)
else
color-dodge(2 * (Ac - 0.5), Bc)
A mix of color dodge and Burn. It’s a more intense and saturated contrast mode and can add more saturation to unsaturated images. - *Difference*: abs(A - B)
The resultant color is the absolute difference between the source and destination colors - *Divide*: if Dc > 0 and Ac > 0
Ac / Bc
else
0
Divides the values of the image A by the values of the image B. Stops 2 negative values from becoming a positive value - *Exclusion: Ac + Bc - 2 Ac * Bc
The resultant color is similar to that of the difference operation. However, the exclusion resultant color appears as a lower contrast than that of the difference resultant color. - *Minus*: Ac - Bc
Image B is subtracted from image A - *Subtract*: Bc - Ac
Subtract the A image values from the B image values. - *Color*: SetLum(Ac, Lum(Bc))
Creates a color with the hue and saturation of the source color and the luminosity of the backdrop color. This preserves the gray levels of the backdrop and is useful for coloring monochrome images or tinting color images. - *Hue*: SetLum(SetSat(Ac, Sat(Bc)), Lum(Bc))
Creates a color with the hue of the source color and the saturation and luminosity of the backdrop color - *Luminosity*: SetLum(Bc, Lum(Ac))
Creates a color with the luminosity of the source color and the hue and saturation of the backdrop color. This produces an inverse effect to that of the Color mode. - *Saturation*: SetLum(SetSat(Bc, Sat(Ac)), Lum(Bc))
Creates a color with the saturation of the source color and the hue and luminosity of the backdrop color. Painting with this mode in an area of the backdrop that is a pure gray (no saturation) produces no change. - *Replace*: Ac
Replace the background image by the foreground image - *Destination Atop*: Bca × Aa + Aca × (1 - Ba)
The part of the destination lying inside of the source is composited over the source and replaces the destination - *Destination Out: Ba Bc * (1 - Aa)
The part of the destination lying outside of the source replaces the destination. - *Destination Over: Aa (1 - Ba) + Bc
The destination is composited over the source and the result replaces the destination - *Destination In: Bc Aa
The part of the destination lying inside of the source replaces the destination. - *Source Atop: Ac Ba + Bc * (1 - Aa)
The part of the source lying inside of the destination is composited onto the destination - *Source Out: Ac (1 - Ba)
The part of the source lying outside of the destination replaces the destination. - *Normal: Ac + Bc (1 - Aa)
The source is composited over the destination - *Source In: Ac Ba
The part of the source lying inside of the destination replaces the destination. - *Xor: Ac (1 - Ba) + Bc * (1 - Aa)
The part of the source that lies outside of the destination is combined with the part of the destination that lies outside of the source. - *Average*: (Ac + Bc) / 2
The average of the 2 images - *Conjoint Over*: if Aa <= Ba
Ac + Bc * (1 - Aa / Da) / b
else
Ac
Same as the normal over mode, except that when partially covered by both A and B, A hides B - *Disjoint Over*: if Aa + Ba >= 1
Ac + Bc * (1 - Aa) / Ba
else
Ac + Bc
Same as the normal over operation, except that when partially covered by both A and B, the 2 images do not overlap - *Geometric: 2 Ac * Bc / (Ac + Bc)
Similar to average but only where A and B overlap - *Grain-Extract*: Bc - Ac + 0.5
Extracts grain from image A and adds it ontop of the image B - *Grain-Merge*: Bc + Ac - 0.5
Merges a grain layer (for example extracted from the Grain-Extract mode) on-top of the B image. This is the opposite of the Grain-extract mode - *Hypot: sqrt(Ac Ac + Bc * Bc)
In-between the Plus and Screen operators - *Reflect: Aa Aa / (1 - Ba)
Darkens the output image using values from the source image. - *Color Burn*: if Ac > 0
1 - min(1, (1 - Bc) / Ac)
else
0
Darkens the backdrop color to reflect the source color. Painting with white produces no change. - *Darken*: min(Ac, Bc)
The resultant color is the darker of source or destination colors. If the source is darker, it replaces the destination. Otherwise, the destination is preserved. - *Linear Burn*: Bc + Ac -1
Darkens the source image and reflects the destination image - *Multiply*: if Ac < 0 and Bc < 0
0
else
Ac * Bc
The source color is multiplied by the destination color and replaces the destination. The resultant color is always at least as dark as either the source or destination color. Stops 2 negative values from becoming a positive value - *Multiply (Math): Ac Bc
The source color is multiplied by the destination color and replaces the destination. Unlike Multiply, 2 negative values become a positive
`Use Composition Format / crop_to_comp`	Boolean	On	The output image will be set to the composition format. Useful to increase performances when a lot of elements are instanced outside the Composition