Adobe after effects cc 2015 specifications free download.Top 10 RECOMMENDED SPECS FOR ADOBE AFTER EFFECTS CC Answers

Looking for:

Adobe after effects cc 2015 specifications free download 

Click here to DOWNLOAD

    ❿  

Adobe after effects cc 2015 specifications free download

 

Persisto Shows how to read and write information from the After Effects preferences file. ProjDumper Creates a text file representing every element in an After Effects project. Projector Imports the fictitious. Note: There are some hardcoded paths in Projector. If you don't set these to refer to actual media on disk, you WILL get errors while running this plug-in. Don't blame us; change them! Streamie Manipulates streams, both dynamic and fixed.

Text Twiddler Manipulates text layers and their contents. This is an important concept for all effects with layer parameters. Premiere Pro compatible. Convolutrix Exercises our image convolution callbacks. Gamma Table Shows how to manage sequence data, and uses our iteration callbacks. Paramarama Exercises wayward param types not used in other sample.

PathMaster Shows how to access paths from within an effect. Portable Shows how to detect and respond to several different plug-in hosts. Resizer Resizer resizes surprise! Transformer Exercises our image transformation callbacks. Effect Template Skeleton Skeleton is the starting point for developing effects. Effects with Custom UI CCU Implements a custom user interface in the composition and layer windows, supporting pixel aspect ratio and downsample ratios. ColorGrid Shows how to use arbitrary data type parameters.

Also has a nice custom UI. Histogrid New for CC An example of how custom UI can access asynchronously-rendered upstream frames for lightweight processing in CC and later. This effect calculates a sampled 10x10 color grid from the upstream frame, and displays a preview of that color grid. In render, a higher- quality grid is calculated and used to modify the output image, creating a blend of a color grid with the original image.

Supervisor Shows how to control parameters both values and UI based on the value of other parameters. Use this as a starting point for adding support to output video from the composition panel to video hardware. For Mac OS, it is Buildall.

Windows installers should follow the guidelines here. Under Build Location choose Custom, and fill in the path. In the new dialog, hit the Environment Variables button. Log out of Windows and log back in so that the variable will be set. Specify After Effects as the application to run during debug sessions. On Windows, in the Visual Studio solution, in the Solution Explorer panel, right-click on the project, and choose Properties.

Set the Executable Path to the After Effects executable file. This makes the latest suites and API functionality available to your plug-ins. When a new version of After Effects is released, you generally will not need to provide a new version unless you wish to take advantage of new functionality exposed through the new SDK.

However, you should always test your plug-in in new versions of After Effects before claiming compatibility with new versions. You should test your plug-in thoroughly in each version of After Effects supported by your plug-in. Also, see the chapter on compatibility with Premiere Pro and other hosts. Starting in CC, display names can be up to 47 characters long.

Previously, they were limited to 31 characters. In the interest of cross-platform compatibility, use a single. On Windows, PiPLs are compiled by processing a. The Windows sample projects all contain custom build steps which generate a. Base your development on an existing sample plug-in and the build step will be correctly implemented. If the plug-in supports multiple platforms e.

There is no need for a Windows. The macros defined in entry. NET with pipltool-generated resources, include the output of the custom build steps into the Microsoft-generated. Also, if you need to update one plug-in, do you really want to ship a new build of all your plug-ins? We recommend one PiPL, and one plug-in, per code fragment. Be nice, perform scrupulous memory management, and only use your powers for good.

If you follow our advice and base your projects on the SDK samples, you can simply change the. Feel the love. Or, if you ever tinker with the custom build steps, feel the pain. After Effects will crash immediately if one is thrown from within a plug-in. You may have good reason to install your plug-in for only After Effects, for example, if your plug-in depends on suites and functionality not available in Premiere Pro. We strongly recommend that you use the common folder whenever possible, but for certain cases, the AE- specific plug-in folder is still available.

Mac OS aliases are traversed, but Windows shortcuts are not. Try as you might to build a fence between AE and Premiere Pro, users will still find ways to get across using our lovely integration goodness - Your effects will still be available to Premiere Pro users who create a dynamically linked AE composition with your effect, and put it in a Premiere Pro sequence. For these non-Unicode strings, AE interprets strings as being multi-byte encoded using the application's current locale.

For Mac, set targeted language to the primary language in the preferred language list, and then install AE in the according language. We will cover the basics of effects plug-ins in the next chapter.

These details are fundamental to every effect plug-in. Pointers to numerous interface and image manipulation functions are also provided. These values are only valid during certain selectors this is noted in the selector descriptions. Parameters are discussed at length here. Only valid during certain selectors. Used primarily for event management and parameter supervision. Responses to some selectors are required; most are optional, though recall that we did add them for a reason During events, they receive event-specific information in extra.

Do not rely on this message to determine when your plug-in is being removed from memory; use OS-specific entry points. On Mac OS, the current resource file will be set to your effects module during this selector. Also, register custom user interface elements. Sequence Selectors These control sequence data handling. Sent when the effect is first applied.

Sent after sequence data is read from disk, during pre-composition, or when the effect is copied; After Effects flattens sequence data before duplication. Flatten sequence data containing pointers or handles so it can be written to disk. This will saved with the project file. Flat data must be correctly byte-ordered for file storage. As of 6. In this case, After Effects will dispose of your flat sequence data. Frame Selectors Passed for each frame or set of audio samples to be rendered by your plug-in.

This is sent immediately before each frame is rendered, to allow for frame-specific setup data. If your effect changes the size of its output buffer, specify the new output height, width, and relative origin. All parameters except the input layer are valid. This is so we know whether or not the given layer will be visible.

This render call can only support 8-bit or bit per channel rendering. Request a time span of input audio. Allocate and initialize any sequence-specific data. Identify the area s of input the effect will need to produce its output, based on whatever criteria the effect implements.

Perform rendering and provide output for the area s the effect was asked to render. Messaging The communication channel between After Effects and your plug-in.

A parameter can be modified by different actions. This might occur after opening the ECP or moving to a new time within the composition.

Only cosmetic changes may be made in response to this command. NOTE: Never check out parameters during this selector.

Recursive badness is almost guaranteed to result. The extra parameter indicates which handler function is being called. Custom data types are discussed further in Implementation.

Return just a NULL pointer for the string handle if there are no dependencies to report. The extra parameter points to whatever parameter the AEGP sent. AEGPs can only communicate with effects which respond to this selector. This selector will be sent at arbitrary times. This structure is updated before each command selector is sent to a plug-in. This very useful function suite is described in Interaction Callback Functions.

This pointer is defined at all times. After Effects uses this to identify your plug-in. Effects should perform faster in LO, and more accurately in HI. The graphics utility callbacks perform differently between LO and HI quality; so should your effect! This field is defined during all frame and sequence selectors. Use this to test whether your plug-in, licensed for use with one application, is being used with another.

Undefined on Windows. This is the current time in the layer, not in any composition. If a layer starts at other than time 0 or is time-stretched, layer time and composition time are distinct. To handle time stretching, composition frame rate changes, and time remapping, After Effects may ask effects to render at non-integral times between two frames. Can be negative if the layer is time-reversed.

Can vary from one frame to the next if time remapping is applied on a nested composition. For example, this could occur when an inner composition is nested within an outer composition with a different frame rate, or time remapping is applied to the outer composition. If time remapping is enabled, this value will be the duration of the composition.

Affected by any time stretch applied to a layer. Check this field to see if you can process just the upper or lower field. Values range from 0 to 1, which represents degrees. Will be zero unless motion blur is enabled and checked for the target layer.

See the section on Motion Blur for details on how to implement motion blur in your effect. Buffer resizing effects can cause this height difference. Not affected by downsampling. Iterating over only this rectangle of pixels can speed your effect dramatically. See notes later in this chapter regarding proper usage. Non-zero only when the effect changes the origin.

Locked and unlocked by After Effects before and after calling the plug-in. Non-zero only if one or more effects that preceded this effect on the same layer resized the output buffer and moved the origin. NOTE: Checked-out point parameters are adjusted for the pre-effect origin at the current time, not the time being checked out.

Add a mask to your layer and move it around. Account for downsampling when computing output size; users must be able to render at full resolution. If the output buffer exceeds 30, by 30,, clamp it to that size, and consider displaying an alert dialog. Once your code behaves correctly, enable the cache and see how frequently the effect needs to re-render. Consider a drop shadow; users frequently apply a static drop shadow to a still image.

Point parameters are adjusted for this shift automatically. Apply a buffer expander such as Gaussian Blur or the Resizer SDK sample, before your effect, and use a large resize value. For most effects this works transparently. However, if a buffer expansion changes over time as with an animated blur amount , the origin shift will move non-animated points. Consider this when designing effects which cache point parameter values between frames. Valid times for altering these fields are noted.

After Effects uses this data to decide which of duplicate effects to load. Otherwise, this memory is rarely used. To create a 5- pixel drop shadow up and left, set origin to 5, 5. OR together multiple values. In previous versions they were also used to send rudimentary messages, e.

These capabilities have been supplanted by function suites, and all new messaging functions will come in that format. However, capability flags are still contained in the PiPL. Update both the PiPL and your source code when you make a change. Many of these flags can be changed during an After Effects session. If you use a parameter including layer parameters from another time, set this flag.

Otherwise, After Effects will cache your output to be used to render other frames, if possible. Set this flag if output varies based on something besides a parameter value.

If the effect produces changing frames when applied to a still image and all parameters are constant, that's a sure sign that this bit should be set e. Wave Warp.

Particle effects, for example, will need this. Turn this off whenever possible to improve performance. You can use arbitrary data with a custom UI, should such changes become necessary. See details at the end of the chapter for proper usage. Note: Obsolete for SmartFX. Set after any command, and can be used during debugging. This is also a good way to implement nag messages for tryout versions. Note: Only set this flag if you need to; it drastically reduces caching efficiency.

As an example, color correction effects are typically pixel independent, distortions are not. It can provide dramatic performance improvements. This is of limited use; while saving an allocation, it invalidates some pipeline caching. After Effects will perform any required format conversion. This is true if output at a given time depends on output from previous times. The filter can access parameters from that earlier time, and should cache them along with interim audio in sequence data.

The filter can update its delay line using the parameters and the input audio. But those individual settings will not be honored unless the effect sets this bit.

Otherwise, all parameter groups will be collapsed by default. Note: this flag can cause the size of the output buffer to change. Set this flag if the effect can take pixels with zero alpha and reveal the RGB data in them like our Set Channels effect.

This tells After Effects not to trim such pixels when determining the input for the effect. If your effect can reveal such pixels, tell AE not to throw away these RGB values by setting this flag.

If your effect does not always reveal such pixels, set this bit dynamically. To see if your effect needs this bit set, apply a mask significantly smaller than the layer to a solid, then apply the effect and set it to its alpha-modifying state. If the rectangular bounding box of the mask becomes visible, this bit needs to be set.

When set, all parameter checkouts are tracked so over-time dependencies are known by the host, and much more efficient. This is needed so After Effects knows to invalidate your output when a mask is modified that doesn't appear to be referenced by your effect. One of the best aspects of the After Effects effect API is the parameter interpolation and management. How much does the shutter angle change during one-fourth of a Not your problem; leave it to After Effects.

You may have up to approximately 38 kajillion parameters, or as many as your users are willing to sift through before demanding a refund.

Choose wisely. When used as effect parameters, these appear as a pull-down menu with which the user selects a layer within the current composition.

The pull-down menu contents are generated by After Effects. NOTE: This is a reference to a layer which contains pixels and audio samples, not actual pixels and audio samples. For many years, we promoted fixed sliders. Specify the UI decimal places independently.

Specify a minimum and maximum value, and the user can move a slider or types a number to specify the setting. The point provides x and y values in destination layer space. New in td CS5. Dusty history lesson to follow: Prior to API specification version Specifying 50,50 in fixed point yields the center of the image. The value you are returned for a point control is in absolute pixels with some number of bits of fixed point accuracy. Thus, if you gave 50,50 as the default position and the user applied the effect to a by layer, the default value you would be sent would be , in Fixed point.

Plug-ins which specify API versions before These entries cannot be modified once the parameter is added. In PPro 8. One group can be nested within another.

Each twirly can be spun open or closed by the user, or programatically by the effect. The effect may choose to have certain groups initialized with the twirly spun open, and others with the twirly spun closed. A simple push button. Unsupported in Premiere Pro. A three-dimensional point. If so, did you convert your mins and maxs to reasonable fixed values? Even if the ECP UI indicates the value of the point parameter is 0,0 , the offset has already been factored in. The values in the params array are only valid during some selectors this is noted in the selector descriptions.

Only valid during drag not click! Can be changed during event handling. Yes, longer parameter names have been requested since After Effects 1. Think of adequately describing your world-altering effect in 31 mere characters as a language challenge, like haiku.

See Events for more details. You might want to do this to control something in your sequence data with a standard control.

Or in your arb data, or custom UI in the comp window, or to group-set multiple other controls. Presumably, you are setting the value of the parameter through some other method e.

In AE, this doesn't affect keyframe visibility in the timeline. In PPro it does remove the entire row, so you won't see keyframes. Set this flag if you'd like a thick line above this parameter in the effect control window. This is provided so that parameters can be grouped visually, if needed without adding groups.

Display parameter as a radio-button group. Flags which may be set during events are noted. You can still use discontinuous hold interpolation. Useful for parameters which are either on or off. Accelerates rendering. See Parameter Supervision for more information. This is useful for when you want a parameter to default to one value but need it set to something else to preserve rendering behavior for older projects.

Indicates that a layer param is used as a track-matte with applied filters. Ignored in After Effects. After Effects uses this behavior internally when paint strokes are made, so as not to distract the user by revealing the parameter. However, in another case, when turning on Time Remapping, that parameter is revealed.

So we provide you the same control over parameters in your own effects. Normally effects cannot alter input image data; only output. Do not access directly; use the accessor macros. Image data in After Effects is always organized in sequential words each containing Alpha, Red, Green, Blue from the low byte to the high byte. The block of pixels contains height lines each with width pixels followed by some bytes of padding.

The width pixels times four, because each pixel is four bytes long plus optional extra padding adds up to rowbytes bytes. Use this value to traverse the image data. Platform-specific padding at the end of rows makes it unwise to traverse the entire buffer. Instead, find the beginning of each row using height and rowbytes. NOTE: This value does not vary based on whether field rendering is active.

NOTE: Input and output worlds with the same dimensions can use different rowbytes values. This defines the area which needs to be output. If your plug-in varies with extent like a diffusion dither , ignore this and render the full frame each time. Platform-specific reference information. On Windows, this contains an opaque value. Patience, my pet. The output buffer will have larger rowbytes than the input though it will still have the same logical size.

Effects will never receive input and output worlds with differing bit depths, nor will they receive worlds with higher bit depth than they have claimed to be able to handle. It is, emphatically, not safe to simply cast pointers of one type into another!

To make it work at all requires a cast, and there's nothing that prevents you from casting it incorrectly. The returned pixel pointer will be NULL if the world is not bpc.

The returned pixel pointer will be NULL if the world is not 8- bpc. Plug-ins must pass all errors back to After Effects. Note that RAM preview will cause this condition, so After Effects will be expecting to receive this error from your plug-in. Out-of-memory errors are never reported by After Effects. Error reporting is always suppressed during RAM preview, and when After Effects is running in - noui mode.

Doing so will enter your error into the render log, and prevent system hangs in renders driven by a render engine or scripting. Now you have a basic understanding of effect plug-ins, and are ready to start experimenting with some real code.

Go ahead and get started! After getting the basics of your plug-in setup, you may have some questions about reuseable code, advanced functionality, and how to optimize your code to make it faster. To this end, After Effects exposes a tremendous amount of its internal functionality via function suites. By relying on After Effects code for utility functions, you should be able to get your image processing algorithms implemented quickly.

This will discussed in the next chapter. Not every section will be relevant to every plug-in, so feel free to use the PDF document bookmarks to skip to the sections pertinent to your current project.

Use our function suites and callbacks to obtain the value of parameters including source footage at different times. Use our memory allocation suite to avoid competing with the host for resources. Use our image processing suites to copy, fill, blend and convolve images, and convert between color spaces. Obtain information about the masks applied to a layer. ANSI emulation and math utility suites are also provided, as well as information about the application, user, serial number, and current drawing context.

Previous versions of After Effects have provided functions for many common tasks. As we moved to support deeper color, these were moved to function suites. Use the newer function suites whenever possible; things will just be better. Using our function suites keeps your plug-in compact; you write and test less code. The functions are tested, optimized, and used by our own plug-ins. The functions are distributed to multiple processors and take advantage of available hardware acceleration.

No, really, use the provided functions. Though each new version of a suite supercedes the old one, feel free to acquire multiple versions of the same suite; we never remove or alter previously shipped suites. Note that support for these suites in other hosts of After Effects plug-ins is a maze of twisty caves and passages, all alike.

For small allocations, you can use new and delete, but this is the exception, not the rule. By using our memory allocation functions, After Effects can know when to free cached images, to avoid memory swapping.

Failing to use our functions for sizable allocations can cause lock-ups, crashes, and tech support calls. Instead provide an allocator as part of the template definition. After Effects will also manage progress reporting and user cancellation automatically. Make sure the pixel processing functions you pass to these iterator callbacks are re- entrant. You give a refcon, and the function is invoked with that refcon, plus the x and y coordinates of the current pixel, plus pointers to that pixel in the source and destination images.

If you pass a NULL source, it will iterate over the dst. This function is quality independent. The image may be subset to different CPUs, so consider all the parameters except dst to be read-only while After Effects is processing. Only call abort and progress functions from thread index 0. Note: You can iterate over more than pixels. Internally, we use it for row- based image processing, and for once-per-entity updates of complex sequence data.

Do not use if the source is the destination. Describe the convolution using kernel flags. The matrices pointer points to a matrix array used for motion-blur. When is a transform not a transform? These matrices can be in any format. The kernel flags describe how the matrices should be created and used. OR together any flags you need. The first entry in the left column is always the default and has value 0. If the rect is null, it fills the entire image.

Quality independent. Nearest neighbor sampling is used in low quality. Because the sampling routine, if used, will typically be called many times, it is convenient to copy the function pointer out to the callbacks structure and into a register or onto the stack to speed up your inner loop.

See the sample code for an example. NOTE: The sampling assumes that 0,0 is the center of the top left pixel. Because of overflow issues, this can only average a maximum of a x pixel area i. NOTE: the sampling radius must be at least one in both x and y. We give function pointers to a large number of math functions trig functions, square root, logs, etc.

All functions return a double. See how stringent we are about deprecating macro usage? Returns non-zero if you should suspend or abort your current processing; return that value to After Effects.

Call once per scanline, unless your effect is very slow. After Effects makes caching decisions based on the checkout state of parameters.

Masks are not included with checked- out layers. Do not check out layer parameters during UI event handling. If you ask for the time that references the upper field, you will receive back the upper field with a filter used to generate the extra scanlines. For example, assuming line 0 and 2 are upper fields, and line 1 is a lower field, if you check out the upper fields, line 0 and 2 will be passed back directly from the source footage, and line 1 will be calculated by averaging lines 0 and 2.

What happens when checking out a layer at a time that is not frame-aligned? All items have essentially infinite time resolution, so when asking for a time at any value, AE renders the item at that time.

For a composition, that involves interpolating all of the keyframes values to the subframe time. For footage, AE returns a full image that corresponds to the time asked, which is the nearest-to-left frame.

If the user has frame-blending on that layer, an interpolated frame is generated. Not doing so causes dismal performance and leaks memory. See Events. After Effects will perform any necessary resampling. This callback is for visual effects that read audio information. To alter audio, write an audio filter. The output from effect[n-1] is the input param[0] of effect[n]. However, when a SmartFX effect checks out its input parameter params[0] , previous effects are applied.

A 10fps layer checked out in a 30fps composition will only need to be refreshed every third frame. Consider an instance where the Checkout sample plug-in is applied to a layer in composition B, and B is pre-composed into composition A where Checkout is applied to it as well.

Presto, recursion! Even different layer parameters can have different pixel aspect ratios! Point parameters are given to the effect scaled for downsample factor and pixel aspect ratio; they are in the coordinate system of the input buffer. But effects that use absolute pixel measurements or geometry must take a deeper look at the relationship between the input buffer and the final rendered image. The final rendered image can be stretched or squashed horizontally, relative to the pixels your effect processes.

Circles will appear as ellipses, squares as rectangles. The distance between two points varies based on their angle in this coordinate system; anything rotated in this system is skewed, in the final output. This means that any slider which defines a size in pixels will be a problem when the image is rendered downsampled; the width of anti-aliasing filters changes based on downsample factor.

Sometimes these issues aren't a problem. Any effect that colors pixels based solely on a linear function of the x and y coordinates need not bother with pixel aspect ratio and downsample factor at all. Staying in the input coordinate space is an option, though you must account for pixel aspect ratio and downsample factor elsewhere.

Suppose you're writing a particle system effect that sprays textured sprites from a source position defined by an effect control point. Using pixel coordinates to represent the particle positions seems fine as long as the particles don't have to rotate around a point , but when you go to actually render the particle textures, you'll have to scale them by pixel aspect ratio and downsample factor.

If an effect already has coordinate transformation machinery in its pipeline, there's an alternative that's often simpler. Many algorithms require some sort of coordinate transformation; using matrices to set up a transformation, for example. But there are other easily adaptable algorithms, for example a texture generation effect that computes the value of each pixel based solely on its position.

In this case, the code must take the raw pixel position and account for pixel aspect ratio and downsample factor. Since point parameters are always reported in input buffer coordinates, convert them to full-resolution square coordinates before use. With this approach you don't need to worry about sliders which define a size in pixels; just interpret them as defining size in full-resolution vertical pixels.

Note that you're not actually dealing with pixels in this stage; you're just manipulating coordinates or coordinate transformations. Do this as late as possible, so as little code as possible needs to deal with this non-square space. If you're using matrices, this would be a final output transformation.

For an effect which renders something based on the coordinate of each pixel, iterate over the output pixels and convert pixel coordinates to square coordinates before doing any processing for that pixel. This may seem like extra work, but most reasonably complex effects like this have a coordinate transformation step anyway; and if they don't, they still need one to handle pixel aspect ratio and downsample factor correctly. Use an anamorphic pixel aspect ratio composition to track down bugs in pixel aspect ratio handling it really makes them obvious , and be sure to test with different horizontal and vertical downsample factors.

Check for zero before dividing. Yeah, right. Do not attempt to modify the original. After Effects will not honor changes made at other times. This change will be also update the UI, and will be undoable by the user.

At least some of these functions are provided by several third- party hosts. These functions are especially handy for effects with supervised parameters. Starting in CS6, when a plug-in disables a parameter, we now save that state in the UI flags so that the plug-in can check that flag in the future to see if it is disabled.

NOTE: Never pass param[0] to this function. You can specify a range of time to consider or all of time. Pass a specific layer parameter index to include that as the only layer parameter tested. Passing in NULL for both start and duration indicates all time. Contrary to the name, the call does not provide a way to test a single parameter.

At a minimum, all non-layer parameters will be tested. Note: the times need not be contiguous; there could be different intervening values. The last three parameters are optional. Consider carefully where you store information; choosing poorly can impact performance, or make your plug-in confusing to the user. Use global data for information common to all instances of the effect: static variables and data, bitmaps, pointers to other DLLs or external applications. Frame data is used for information specific to rendering a given frame.

This has fallen into disuse, as most machines are capable of loading an entire frame into memory at a time. Of course, your IMAX-generating users will still appreciate any optimizations you can make. Pointers within sequence data which point to external data are, in all likelihood, invalid upon re- opening the project, and must be re-connected. If a parameter is changed, certain calculated data may no longer be valid, but it would also be wasteful to blindly recalculate everything after every change.

This is done efficiently, as the change tracking is done with timestamps. If the inputs have not changed, you can safely use your cache, AND the internal caching system will assume that you have a temporal dependency on the passed range. RAM Preview to fill the cache, then change one of the keyframes. The related frame and all dependent frames e. Similarly, upstream changes to sources of layer parameters should cause time-selective invalidation of the cache. This is analogous to creating your own miniature file format.

If your sequence data contains a pointer to a long, allocate 4 bytes in which to store the flattened data. You must handle platform-specific byte ordering. Remember, your users the ones who bought two copies of your plug-in, anyway may want the same project to work on Mac OS and Windows.

You can rely on our interpolation engine and parameter management, without having to force your data into a pre-defined parameter type. You must respond to all selectors detailed here if you use arb data. These functions deal with custom data structure management. You will be passed two handles, but only the source handle contains a valid instance. You must create a new instance, copy the values from the source, and put it in the destination handle.

If you are passed a NULL handle, create a default instance of your arb data. You are also passed a float indicating where, between 0 and 1, your interpreted value should be. Allocate an instance and fill it with interpolated data. The velocity curves have already been accounted for when the normalized time value was calculated. This can be as elaborate as you would like. Your plug-in should emulate the cut-and-paste behavior for pasting text representations of parameter settings into a Microsoft Excel spreadsheet, for example displayed by the plug-ins shipped with After Effects.

You have a great deal of flexibility in how you format your output. This is transparent for other parameter types, as After Effects manages their representing data. Writing an arb data plug-in will give you insight into the vast amount of parameter management After Effects performs, and the sequence in which those managing actions occur. It may even cause you to rethink your implementation, and use the parameter types After Effects manages for you.

Populate it with appropriate default values. Invoke a secondary event handler, HandleArbitrary. Your plug-in code must be recursively re-entrant to support custom data types, since it could be called by After Effects for numerous reasons.

Your plug-in could check out a layer that, in turn, depends on another instance of your effect. Watch out for calls to C run-time libraries that rely on static values accessed through global variables.

After Effects has user- controllable UI brightness. Or set the cursor to add mask vertices, just to confuse people? Heh heh heh. But that would be wrong. Retrieves the active displayed language of AE UI so plug- in can match. Only valid while handling a non-drawing event in the effect. The redraw will happen at the next available idle moment after returning from the event. Use only during custom UI event handling. Our API impurity is your gain.

Note that although the Composition panel will be refreshed, this does not guarantee a new frame will be sent to External Monitor Preview plug-ins. In fact, these are the same functions we use internally. Always, always, always check the data back in. They must check out their own parameters at other times to examine their change over the shutter interval. In addition to checking them out and in like layer parameters , you must use our path data function suites to obtain the details of the path at a given time.

Like layer parameters, they must be checked out and in! N segments means there are segments [0. The range of points is [0. Math is hard.

Always do this, regardless of any error conditions encountered. Every checkout must be balanced by a checkin, or pain will ensue. Here are the supported formats. HLS values are scaled from 0 to 1 in fixed point. Y is 0 to 1 in fixed point, I is Hue Given an RGB pixel, eturns its hue angle mapped from 0 to , where 0 is 0 degrees and is degrees.

Lightness Given an RGB pixel, returns its lightness value 0 to Saturation Given an RGB pixel, returns its saturation value 0 to However, some advance planning on your part is necessary to allow for such changes. Your users and technical support staff will appreciate the effort. You must first create a parameter array index.

Create another enumeration for disk IDs. The order of this enumeration must not be changed, though you may add to the end of this list. Note that the order of this list need not correspond with that of the parameter array index. Parameter disk IDs should range from 1 to Why not zero? Long story If no value is specified, After Effects makes parameters sequential starting with 1. To delete a parameter without forcing re-application, remove the code which creates it and its entry in the parameter array index list.

However, do not remove its entry in the disk ID list. To add a new parameter, add an entry in the appropriate location in the parameter array indices list, add the parameter creation code, and append the disk ID to the end of the disk ID enumeration. To re-order, change the parameter array index list and reorder the parameter creation code appropriately.

Instant support call. Save it to the name by which you want users to find the plug-in. Your preset will show up when users search for the name to which it was saved. Below is one way to sample the pixel at a given x,y location; similar code could be used to write to the given location.

Deeeeeep, man. After Effects rotates around the upper left corner of the upper left pixel when the anchor point see User Documentation is 0,0. However, the subpixel sample and area sample callbacks actually treat. To compensate for this, subtract 0. When translating an image by a subpixel amount, make the output layer one pixel wider than its input, and leave the origin at 0,0.

Supporting dynamic outflags can greatly improve performance, preventing After Effects from invalidating your effect's cache as aggressively as it otherwise would.

Confirm that your plug-in performs well with different After Effects cache settings. A user may have a disk cache of the buggy frame and it needs to be invalidated. What to do? Update your plug-in's effect version. This value and the AE build number is part of the cache key, so if you update it any frames cached containing content from your plug-in will no longer match.

It is expressed in the local layer time system. Comp duration is a factor only when Time Remapping TR is on. If the time stretch is negative, these values are negative. This works as if Time Stretch was above a filter, but below an outer comp. PFR does not alter the effect of Time Stretch. It has nothing to do with the actual time map, just whether or not it's enabled.

The biggest variation comes from being nested in an outer comp, unless PFR is on. When PFR is on, a filter is completely isolated from time variations in an outer comp.

It may skip frames or go backwards. This may be any value, including 0. This can be interpreted as an instantaneous time rate, rather than a duration. This is the current time in the layer, not in any comp. It can never be zero, but it can be negative. It can have any value, positive, negative, or zero, and can be different for every frame of the outer comp. It is affected only by the comp frame rate, although presumably all the time values could be scaled proportionately for any reason.

A layer's intrinsic frame rate if it has one is not visible anywhere, although it's usually the same as the comp frame rate. If a filter needs to access the actual frames of a clip, it can do so only by being in a comp of the same frame rate, and with no Time Stretch or Time Remapping applied to its layer.

Consider the ripple effect. If the user interpolates the speed over time, you should integrate the velocity function from time zero to the current time. The cost of checking out many parameter values is negligible compared to rendering, and is the recommended approach.

If you check out parameter values at other times, or use layer parameters at all, you must check in those parameters when finished, even if an error has occurred. Remember, checked- out parameters are read-only. Does your plug-in handle running out of memory gracefully? What happens when your video effect is applied to an audio-only layer? Test with projects created using older versions of your plug-in. This extension of the effect API is the way to implement bit per channel support in After Effects.

Normal effect plug-ins are given a full-sized input buffer, and asked to render a full-sized output buffer. However, using the legacy effects API, there is no way for After Effects to know this, so the entire layer is passed to the plug-in.

These extra pixels can be extremely expensive and wasteful to compute, especially in the case of prior effects or nested comps. The effect is told how much of its output is required, and must explicitly ask the host for the inputs it needs. Either run the installer program from its current location, or save it to disk and then execute it from wherever you saved it.

Follow the instructions given by the installer. Download the additional emitter libraries Windows installer 81 Mb. Download and install these after installing particleIllusion for AE. The installer for particleIllusion for AE includes just a single emitter library — where the presets are contained.

There are dozens of additional libraries consisting of over emitter presets available using the following installers. Restart your host application, and the new plug-in should appear in your effects menu. New in 1.

❿     ❿