After Effects

https://docs.rs/after-effects/latest/
Admin
After Effects is a Rust library providing high-level bindings for the Adobe After Effects and...
Tokens:7,409,736
Snippets:39,956
Trust Score:9.7
Update:9 months ago
Show doc for...
Tokens:
Raw
### PR_InstanceSetupFunc

Source: https://docs.rs/after-effects/latest/-sys/0.2.1/index

Explains that PR_InstanceSetupFunc is analogous to an Effect's Sequence setup call and sets up the renderer's instance data.

```APIDOC
## PR_InstanceSetupFunc

### Description
Analogous to an Effect’s Sequence setup call. This sets up the renderer’s instance data.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A
```

--------------------------------

### Get Track Item Start Time in Rust

Source: https://docs.rs/after-effects/latest/0.2.1/src/after_effects/pf/suites/utility.rs_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets the start time of the track item in ticks. This function takes an effect reference and returns the start time as an i32.

```rust
pub fn track_item_start(&self, effect_ref: impl AsPtr<PF_ProgPtr>) -> Result<i32, Error> {
    Ok(call_suite_fn_single!(self, GetTrackItemStart -> A_long, effect_ref.as_ptr())? as i32)
}
```

--------------------------------

### AudioSetup Command Description (Rust)

Source: https://docs.rs/after-effects/latest/0.2.1/after_effects/pf/enum.Command_search=std%3A%3Avec

Performs setup operations related to audio processing for the plug-in.

```rust
AudioSetup
```

--------------------------------

### Get Track Item Start Time

Source: https://docs.rs/after-effects/latest/latest/after_effects/pf/suites/struct.Utility_search=

Gets the start time of the track item in ticks. This function is useful for determining the timing of specific elements within a timeline.

```rust
pub fn track_item_start( &self, effect_ref: impl AsPtr<PF_ProgPtr>, ) -> Result<i32, Error>
```

--------------------------------

### Parameter Setup in Rust After Effects Plugin

Source: https://docs.rs/after-effects/latest/0.2.1/src/after_effects/plugin_base.rs_search=std%3A%3Avec

This Rust code snippet demonstrates the parameter setup process for an After Effects plugin. It initializes a Parameters object, calls the plugin's `params_setup` method, and updates global and output data with the parameter information.

```rust
if cmd == RawCommand::ParamsSetup {
                let mut params = Parameters::<$params_type>::new();
                params.set_in_data(in_data_ptr);
                global_inst.plugin_instance.params_setup(&mut params, InData::from_raw(in_data_ptr), OutData::from_raw(out_data_ptr))?;
                global_inst.params_num = params.num_params();
                (*out_data_ptr).num_params = params.num_params() as i32;
                global_inst.params_map.set((*params.map).clone()).unwrap();
            }
```

--------------------------------

### EffectSuite: Get Next Installed Effect

Source: https://docs.rs/after-effects/latest/0.2.1/after_effects/aegp/suites/struct.Effect

Retrieves the `InstalledEffectKey` for the next installed effect in the sequence. Pass `InstalledEffectKey::None` to get the first effect's key.

```rust
pub fn next_installed_effect( &self, installed_effect_key: InstalledEffectKey, ) -> Result<InstalledEffectKey, Error>
```

--------------------------------

### Get After Effects Output Specification Start Frame

Source: https://docs.rs/after-effects/latest/-sys/0.2.1/after_effects_sys/struct.AEGP_IOOutSuite4

Fetches the starting frame number for the output specification.

```rust
AEGP_GetOutSpecStartFrame: Option<unsafe extern "C" fn(outH: AEIO_OutSpecH, start_frameP: *mut A_long) -> A_Err>
```

--------------------------------

### Command::AudioSetup

Source: https://docs.rs/after-effects/latest/0.2.1/after_effects/pf/enum.Command

Sent before each audio render to request input audio time spans and allocate/initialize sequence-specific data.

```APIDOC
## POST /commands/audiosetup

### Description
Sent before every audio render. This command is used to request a time span of input audio and to allocate and initialize any sequence-specific data. If the effect requires input from a time span different from the output time span, the `startsampL` and `endsampL` fields in `OutData` should be updated.

### Method
POST

### Endpoint
/commands/audiosetup

### Parameters
*This command involves setting audio time span information in `OutData`.*

### Response
#### Success Response (200)
- **audio_setup_status** (string) - Indicates the success of the audio setup operation.
```

--------------------------------

### Get Clip Start Time - Rust

Source: https://docs.rs/after-effects/latest/latest/src/after_effects/pf/suites/utility.rs

Retrieves the start time of the clip in ticks. This is the effective start time, potentially affected by retiming.

```rust
/// Retrieves the start time of the clip.
pub fn clip_start(&self, effect_ref: impl AsPtr<PF_ProgPtr>) -> Result<i32, Error> {
    Ok(call_suite_fn_single!(self, GetClipStart -> A_long, effect_ref.as_ptr())? as i32)
}
```

--------------------------------

### Rust: Initialize and Use GPUDeviceSuite

Source: https://docs.rs/after-effects/latest/0.2.1/src/after_effects/pf/suites/gpu_device.rs

Demonstrates how to initialize the GPUDeviceSuite and use its methods to interact with GPU devices. It covers acquiring the suite, checking device count, and obtaining device info. The suite is automatically released when it goes out of scope.

```rust
use crate::*;
use ae_sys:: { A_u_long, PF_EffectWorld, PF_InData, PF_ProgPtr };

define_suite!(
    GPUDeviceSuite,
    PF_GPUDeviceSuite1,
    kPFGPUDeviceSuite,
    kPFGPUDeviceSuiteVersion1
);

impl GPUDeviceSuite {
    /// Acquire this suite from the host. Returns error if the suite is not available.
    /// Suite is released on drop.
    pub fn new() -> Result<Self, Error> {
        crate::Suite::new()
    }

    /// This will return the number of gpu devices the host supports.
    /// * `effect_ref` - Effect reference from [`InData`](crate::InData::effect_ref).
    /// Returns the number of available devices.
    pub fn device_count(&self, effect_ref: impl AsPtr<PF_ProgPtr>) -> Result<usize, Error> {
        Ok(call_suite_fn_single!(self, GetDeviceCount -> A_u_long, effect_ref.as_ptr())? as usize)
    }

    /// This will return the device info with given device index, which includes necessary context/queue information
    /// needed to dispatch task to the device. Refer PF_GPUDeviceInfo for details.
    /// * `effect_ref`   - Effect reference from [`InData`](crate::InData::effect_ref).
    /// * `device_index` - The device index for the requested device.
    /// Returns the device info will to be filled.
    pub fn device_info(&self, effect_ref: impl AsPtr<PF_ProgPtr>, device_index: usize) -> Result<ae_sys::PF_GPUDeviceInfo, Error> {
        call_suite_fn_single!(self, GetDeviceInfo -> ae_sys::PF_GPUDeviceInfo, effect_ref.as_ptr(), device_index as _)
    }

    /// Acquire/release exclusive access to `device_index`. All calls below this point generally require access be held.
    /// For full GPU plugins (those that use a separate entry point for GPU rendering) exclusive access is always held.
    /// These calls do not need to be made in that case.
    /// * `effect_ref`   - Effect reference from [`InData`](crate::InData::effect_ref).
    /// * `device_index` - The device index for the requested device.
    pub fn acquire_exclusive_device_access(&self, effect_ref: impl AsPtr<PF_ProgPtr>, device_index: usize) -> Result<(), Error> {
        call_suite_fn!(self, AcquireExclusiveDeviceAccess, effect_ref.as_ptr(), device_index as _)
    }

    /// Acquire/release exclusive access to `device_index`. All calls below this point generally require access be held.
    /// For full GPU plugins (those that use a separate entry point for GPU rendering) exclusive access is always held.
    /// These calls do not need to be made in that case.
    /// * `effect_ref`   - Effect reference from [`InData`](crate::InData::effect_ref).
    /// * `device_index` - The device index for the requested device.
    pub fn release_exclusive_device_access(&self, effect_ref: impl AsPtr<PF_ProgPtr>, device_index: usize) -> Result<(), Error> {
        call_suite_fn!(self, ReleaseExclusiveDeviceAccess, effect_ref.as_ptr(), device_index as _)
    }

    /// All device memory must be allocated through this suite. 
    /// Purge should be called only in emergency situations when working with GPU memory that cannot be allocated through this suite (eg OpenGL memory).
    /// Returned pointer value represents memory allocated through cuMemAlloc or clCreateBuffer.
    /// * `effect_ref` - Effect reference from [`InData`](crate::InData::effect_ref).
    /// * `device_index` - The device index for the requested device.
    /// * `size_bytes` - The size of the memory to allocate.
    /// Returns the pointer to the allocated memory.
    pub fn allocate_device_memory(&self, effect_ref: impl AsPtr<PF_ProgPtr>, device_index: usize, size_bytes: usize) -> Result<*mut c_void, Error> {
        call_suite_fn_single!(self, AllocateDeviceMemory -> *mut c_void, effect_ref.as_ptr(), device_index as _, size_bytes)
    }

    /// Free the device memory.
    /// * `effect_ref` - Effect reference from [`InData`](crate::InData::effect_ref).
    /// * `device_index` - The device index for the requested device.
    /// * `memory` - The pointer to the memory to free.
    pub fn free_device_memory(&self, effect_ref: impl AsPtr<PF_ProgPtr>, device_index: usize, memory: *mut c_void) -> Result<(), Error> {
        call_suite_fn!(self, FreeDeviceMemory, effect_ref.as_ptr(), device_index as _, memory)
    }

    /// Purge the device memory.
    /// * `effect_ref` - Effect reference from [`InData`](crate::InData::effect_ref).
    /// * `device_index` - The device index for the requested device.
    /// * `size_bytes` - The size of the memory to purge.
    /// Returns the number of bytes purged.
    pub fn purge_device_memory(&self, effect_ref: impl AsPtr<PF_ProgPtr>, device_index: usize, size_bytes: usize) -> Result<usize, Error> {
        // Note: This function signature seems incomplete in the provided code snippet.
        // The actual implementation would likely call a suite function to purge memory.
        // For documentation purposes, we represent the intended functionality.
        unimplemented!("purge_device_memory not fully implemented in snippet");
    }
}
```

--------------------------------

### Rust: SourceSettingsSuite Initialization and Command Execution

Source: https://docs.rs/after-effects/latest/latest/after_effects/pf/suites/struct.SourceSettings_search=u32+-%3E+bool

Demonstrates acquiring the SourceSettingsSuite from the host and executing a source settings command. The suite is released upon dropping the instance. Error handling is included for suite acquisition.

```rust
use after_effects::pf::suites::SourceSettingsSuite;
use std::os::raw::c_void;

// Example of acquiring the suite and executing a command
fn manage_source_settings(effect_ref: impl after_effects::AsPtr<after_effects::PF_ProgPtr>) -> Result<(), after_effects::Error> {
    let source_settings_suite = SourceSettingsSuite::new()?;
    
    let command_struct: *mut c_void = std::ptr::null_mut(); // Replace with actual command struct
    let data_size: usize = 0; // Replace with actual data size

    source_settings_suite.perform_source_settings_command(effect_ref, command_struct, data_size)?;

    Ok(())
}

// The suite is automatically released when it goes out of scope (due to Drop trait implementation)
```

--------------------------------

### Get Composition Display Start Time

Source: https://docs.rs/after-effects/latest/0.2.1/src/after_effects/aegp/suites/comp.rs_search=

Retrieves the display start time of the given composition.

```APIDOC
## GET /api/comps/{comp_handle}/display_start_time

### Description
Retrieves the display start time of a composition.

### Method
GET

### Endpoint
`/api/comps/{comp_handle}/display_start_time`

### Parameters
#### Path Parameters
- **comp_handle** (AEGP_CompH) - Required - Handle to the composition.

### Response
#### Success Response (200)
- **time** (Time) - The display start time of the composition.

#### Response Example
```json
{
  "time": {"value": 0, "scale": 1}
}
```
```

--------------------------------

### Get Composition Display Start Time (Rust)

Source: https://docs.rs/after-effects/latest/0.2.1/src/after_effects/aegp/suites/comp.rs_search=

Retrieves the display start time of a composition.

```rust
pub fn comp_display_start_time(&self, comp_handle: impl AsPtr<AEGP_CompH>) -> Result<Time, Error> {
        call_suite_fn_single!(self, AEGP_GetCompDisplayStartTime -> ae_sys::A_Time, comp_handle.as_ptr()).map(|t| t.into())
    }
```

--------------------------------

### Rust: After Effects EffectMain Entry Point

Source: https://docs.rs/after-effects/latest/latest/src/after_effects/plugin_base.rs

This function serves as the main entry point for After Effects plugins written in Rust. It handles commands, particularly `GLOBAL_SETUP`, to initialize plugin properties and set up debugging/logging. It also includes conditional compilation for threaded rendering and panic catching for robust execution.

```rust
        #[no_mangle]
        #[allow(non_snake_case)]
        pub unsafe extern "C" fn EffectMain(
            cmd: $crate::sys::PF_Cmd,
            in_data_ptr: *mut $crate::sys::PF_InData,
            out_data_ptr: *mut $crate::sys::PF_OutData,
            params: *mut *mut $crate::sys::PF_ParamDef,
            output: *mut $crate::sys::PF_LayerDef,
            extra: *mut std::ffi::c_void) -> $crate::sys::PF_Err
        {
            if cmd == $crate::sys::PF_Cmd_GLOBAL_SETUP as $crate::sys::PF_Cmd {
                (*out_data_ptr).my_version = env!("PIPL_VERSION")  .parse::<u32>().unwrap();
                (*out_data_ptr).out_flags  = env!("PIPL_OUTFLAGS") .parse::<i32>().unwrap();
                (*out_data_ptr).out_flags2 = env!("PIPL_OUTFLAGS2").parse::<i32>().unwrap();

                #[cfg(debug_assertions)]
                {
                    #[cfg(target_os = "windows")]
                    {
                        let _ = $crate::log::set_logger(&$crate::win_dbg_logger::DEBUGGER_LOGGER);
                    }
                    #[cfg(target_os = "macos")]
                    {
                        let _ = $crate::oslog::OsLogger::new(env!("CARGO_PKG_NAME")).init();
                    }
                    $crate::log::set_max_level($crate::log::LevelFilter::Debug);

                    std::panic::set_hook(Box::new(|_| {
                        *BACKTRACE_STR.write().unwrap() = std::backtrace::Backtrace::force_capture().to_string();
                    }));
                }
            }

            #[cfg(threaded_rendering)]
            {
                fn assert_impl<T: Sync>() { }
                assert_impl::<$global_type>();
                assert_impl::<$sequence_type>();
            }

            define_effect!(check_size: $sequence_type);

            #[cfg(any(debug_assertions, feature = "catch-panics"))]
            {
                let result = std::panic::catch_unwind(|| {
                    handle_effect_main::<$global_type, $sequence_type, $params_type>(cmd, in_data_ptr, out_data_ptr, params, output, extra)
                });
                match result {
                    Ok(Ok(_)) => $crate::sys::PF_Err_NONE as $crate::sys::PF_Err,
                    Ok(Err(e)) => {
                        $crate::log::error!("EffectMain returned error: {e:?}");

                        if e != Error::InterruptCancel && !out_data_ptr.is_null() {
                            $crate::OutData::from_raw(out_data_ptr).set_error_msg(&format!("EffectMain returned error: {e:?}"));
                        }

                        e as $crate::sys::PF_Err
                    }
                    Err(e) => {
                        let s = if let Some(s) = e.downcast_ref::<&str>() { s.to_string() }
                           else if let Some(s) = e.downcast_ref::<String>() { s.clone() }
                           else { format!("{e:?}") };

                        let mut msg = format!("EffectMain panicked! {s}");

                        #[cfg(debug_assertions)]
                        {
                            $crate::log::error!("{msg}, backtrace: {}", BACKTRACE_STR.read().unwrap());
                        }

                        if msg.len() > 255 {

```

--------------------------------

### Get Display Start Time of Composition (Rust)

Source: https://docs.rs/after-effects/latest/0.2.1/after_effects/aegp/struct.Composition_search=

Retrieves the currently displayed start time of the composition.

```rust
pub fn display_start_time(&self) -> Result<Time, Error>
```

--------------------------------

### PFInterface Suite Initialization and Management

Source: https://docs.rs/after-effects/latest/latest/after_effects/aegp/suites/struct.PFInterface_search=

Demonstrates how to acquire and release the PFInterface suite. The `new` function obtains the suite from the host application, returning an error if unavailable, and the suite is automatically released when the `PFInterface` is dropped.

```rust
pub fn new() -> Result<Self, Error>
// Acquire this suite from the host. Returns error if the suite is not available. Suite is released on drop.
```

```rust
fn drop(&mut self)
// Executes the destructor for this type.
```

--------------------------------

### Get Clip Start Time in Rust

Source: https://docs.rs/after-effects/latest/0.2.1/src/after_effects/pf/suites/utility.rs_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves the start time of the clip in ticks. This function takes an effect reference and returns the start time as an i32.

```rust
pub fn clip_start(&self, effect_ref: impl AsPtr<PF_ProgPtr>) -> Result<i32, Error> {
    Ok(call_suite_fn_single!(self, GetClipStart -> A_long, effect_ref.as_ptr())? as i32)
}
```

--------------------------------

### Rust: After Effects Light Suite Initialization and Management

Source: https://docs.rs/after-effects/latest/0.2.1/src/after_effects/aegp/suites/light.rs

Demonstrates how to initialize and manage the After Effects LightSuite in Rust. This includes acquiring the suite from the host application and releasing it upon dropping the suite instance. It relies on the `Suite::new()` function for acquisition.

```Rust
use crate::*;
use ae_sys::AEGP_LayerH;

define_suite!(
    /// Get and set the type of lights in a composition.
    ///
    /// ## Notes On Light Behavior
    /// The formula for parallel lights is found in Foley and Van Dam's "Introduction to Computer Graphics" (ISBN 0-201-60921-5) as is the formula for point lights.
    ///
    /// We use the half angle variant proposed by Jim Blinn instead.
    ///
    /// Suppose we have a point on a layer and want to shade it with the light.
    ///
    /// Let V be the unit vector from the layer point to the eye point.
    /// Let L be the unit vector to the light (in the parallel light case this is constant). Let H be (V+L)/2 (normalized).
    /// Let N be the unit normal vector to the layer.
    ///
    /// The amount of specular reflected light is S * power(H Dot N, shine), where S is the specular coefficient.
    LightSuite,
    AEGP_LightSuite2,
    kAEGPLightSuite,
    kAEGPLightSuiteVersion2
);

impl LightSuite {
    /// Acquire this suite from the host. Returns error if the suite is not available.
    /// Suite is released on drop.
    pub fn new() -> Result<Self, Error> {
        crate::Suite::new()
    }

    // ... other methods ...
}

define_enum! {
    ae_sys::AEGP_LightType,
    LightType {
        None     = ae_sys::AEGP_LightType_NONE,
        Parallel = ae_sys::AEGP_LightType_PARALLEL,
        Spot     = ae_sys::AEGP_LightType_SPOT,
        Point    = ae_sys::AEGP_LightType_POINT,
        Ambient  = ae_sys::AEGP_LightType_AMBIENT,
    }
}
```

--------------------------------

### GlobalSetup Command Description (Rust)

Source: https://docs.rs/after-effects/latest/0.2.1/after_effects/pf/enum.Command_search=std%3A%3Avec

The 'GlobalSetup' command allows the plug-in to set up global flags and `OutData` fields, defining its overall behavior within After Effects.

```rust
GlobalSetup
```

--------------------------------

### After Effects: Get Installed Effect Name

Source: https://docs.rs/after-effects/latest/-sys/0.2.1/after_effects_sys/struct.AEGP_EffectSuite1

Retrieves the user-friendly name of an installed effect. This function takes the installed effect key and a buffer to store the name string.

```rust
AEGP_GetEffectName: Option<unsafe extern "C" fn(installed_effect_key: AEGP_InstalledEffectKey, nameZ: *mut A_char) -> A_Err>
```

--------------------------------

### Utility Suite Initialization and Basic Functions (Rust)

Source: https://docs.rs/after-effects/latest/0.2.1/src/after_effects/aegp/suites/utility.rs_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to initialize the UtilitySuite and use basic reporting functions like `report_info` and `report_info_unicode`. It also covers acquiring the main window handle and managing floating palettes.

```rust
use crate::*;
use crate::aegp::*;

pub struct ErrReportState((ae_sys::AEGP_ErrReportState, bool));
impl Drop for ErrReportState {
    fn drop(&mut self) {
        if let Ok(util) = UtilitySuite::new() {
            let _ = util.end_quiet_errors(self.0.0, self.0.1);
        }
    }
}
define_suite!(
    /// The Utility suite supplies error message handling, AEGP version checking and access to the undo stack.
    ///
    /// Everything you need to keep After Effects and your plug-in tidy.
    UtilitySuite,
    AEGP_UtilitySuite6,
    kAEGPUtilitySuite,
    kAEGPUtilitySuiteVersion6
);

impl UtilitySuite {
    /// Acquire this suite from the host. Returns error if the suite is not available.
    /// Suite is released on drop.
    pub fn new() -> Result<Self, Error> {
        crate::Suite::new()
    }

    /// Displays dialog with name of the AEGP followed by the string passed.
    pub fn report_info(&self, plugin_id: PluginId, info_string: &str) -> Result<(), Error> {
        let info_string = CString::new(info_string).map_err(|_| Error::InvalidParms)?;
        call_suite_fn!(self, AEGP_ReportInfo, plugin_id, info_string.as_ptr())
    }

    /// New in CC. Displays dialog with name of the AEGP followed by the unicode string passed.
    pub fn report_info_unicode(&self, plugin_id: PluginId, info_string: &str) -> Result<(), Error> {
        let info_string = U16CString::from_str(info_string).map_err(|_| Error::InvalidParms)?;
        call_suite_fn!(self, AEGP_ReportInfoUnicode, plugin_id, info_string.as_ptr())
    }
    
    /// Retrieves After Effects' HWND; useful when displaying your own dialog on Windows.
    /// If you don't use After Effects' HWND, your modal dialog will not prevent interaction with the windows behind, and pain will ensue.
    pub fn main_hwnd(&self) -> Result<*mut std::ffi::c_void, Error> {
        let mut hwnd = std::ptr::null_mut();
        call_suite_fn!(self, AEGP_GetMainHWND, &mut hwnd as *mut _ as *mut _)?;
        Ok(hwnd)
    }

    /// Toggles whether or not floating palettes are displayed.
    ///
    /// Use this with care; users get twitchy when you unexpectedly change the UI on them.
    pub fn show_hide_all_floaters(&self, include_tool_pal: bool) -> Result<(), Error> {
        call_suite_fn!(self, AEGP_ShowHideAllFloaters, include_tool_pal as _)
    }
}
```

--------------------------------

### Query Installed Effects in After Effects

Source: https://docs.rs/after-effects/latest/latest/src/after_effects/aegp/suites/effect.rs_search=u32+-%3E+bool

Utilities for querying information about installed effects in After Effects. This includes getting the total count of installed effects and iterating through them using their keys.

```rust
impl Effect {
    /// Returns the count of effects installed in After Effects.
    pub fn num_installed_effects() -> Result<i32, Error> {
        EffectSuite::new()?.num_installed_effects()
    }

    /// Returns the [`InstalledEffectKey`] of the next installed effect.
    ///
    /// Pass [`InstalledEffectKey::None`] as the first parameter to obtain the first [`InstalledEffectKey`].
    pub fn next_installed_effect(installed_effect_key: InstalledEffectKey) -> Result<InstalledEffectKey, Error> {
        EffectSuite::new()?.next_installed_effect(installed_effect_key)
    }

    /// Get name of the effect. `name` can be up to `48` characters long.
    ///
    /// Note: use [`suites::DynamicStream::set_stream_name()`](aegp::suites::DynamicStream::set_stream_name) to change the display name of an effect.

```

--------------------------------

### Rust: Initialize and Use Camera Suite

Source: https://docs.rs/after-effects/latest/0.2.1/src/after_effects/aegp/suites/camera.rs_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to initialize the CameraSuite in Rust and use its methods to retrieve camera information. This involves acquiring the suite from the host and releasing it upon drop.

```rust
use crate::*; 
use crate::aegp::*; 
use ae_sys::{ AEGP_LayerH, PR_RenderContextH }; 

define_suite!( 
    /// Obtains the camera geometry, including camera properties (type, lens, depth of field, focal distance, aperture, et cetera). 
    /// 
    /// # Notes Regarding Camera Behavior 
    /// Camera orientation is in composition coordinates, and the rotations are in layer (the camera's layer) coordinates. 
    /// 
    /// If the camera layer has a parent, the position is in a coordinate space relative to the parent. 
    /// 
    /// # Orthographic Camera Matrix 
    /// Internally, we use composition width and height to set the matrix described by the OpenGL specification as 
    /// ```ignore 
    ///     glOrtho(-width/2, width/2, -height/2, height/2, -1, 100); 
    /// ``` 
    /// The orthographic matrix describes the projection. The position of the camera is described by another, scaled matrix. The inverse of the camera position matrix provides the "eye" coordinates. 
    /// 
    /// # Focus On Focal 
    /// Remember, focal length affects field of view; focal distance only affects depth of field. 
    /// 
    /// # Film Size 
    /// In the real world, film size is measured in millimeters. In After Effects, it's measured in pixels. Multiply by 72 and divide by 25.4 to move from millimeters to pixels. 
    /// 
    /// Field of view is more complex; 
    /// 
    /// * ϴ = 1/2 field of view 
    /// * tan(ϴ) = 1/2 composition height / focal length 
    /// * focal length = 2 tan(ϴ) / composition height 
    CameraSuite, 
    AEGP_CameraSuite2, 
    kAEGPCameraSuite, 
    kAEGPCameraSuiteVersion2 
);

impl CameraSuite {
    /// Acquire this suite from the host. Returns error if the suite is not available. 
    /// Suite is released on drop. 
    pub fn new() -> Result<Self, Error> {
        crate::Suite::new()
    }

    /// Given a layer handle and time, returns the current camera layer handle. 
    pub fn camera(&self, render_context_handle: impl AsPtr<PR_RenderContextH>, time: Time) -> Result<LayerHandle, Error> {
        let camera_layer_handle = call_suite_fn_single!(self, AEGP_GetCamera -> ae_sys::AEGP_LayerH, render_context_handle.as_ptr(), &time as *const _ as *const ae_sys::A_Time)?;
        if camera_layer_handle.is_null() {
            Err(Error::Generic)
        } else {
            Ok(LayerHandle::from_raw(camera_layer_handle))
        }
    }

    /// Given a layer, returns the camera type of the layer. 
    pub fn camera_type(&self, camera_layer_handle: impl AsPtr<AEGP_LayerH>) -> Result<CameraType, Error> {
        Ok(call_suite_fn_single!(self, AEGP_GetCameraType -> ae_sys::AEGP_CameraType, camera_layer_handle.as_ptr())?.into())
    }

    /// Retrieves the size (and units used to measure that size) of the film used by the designated camera. 
    pub fn camera_film_size(&self, camera_layer_handle: impl AsPtr<AEGP_LayerH>) -> Result<(FilmSizeUnits, f64), Error> {
        let mut film_size_units: ae_sys::AEGP_FilmSizeUnits = 0;
        let mut film_size: ae_sys::A_FpLong = 0.0;

        call_suite_fn!(self, AEGP_GetCameraFilmSize, camera_layer_handle.as_ptr(), &mut film_size_units, &mut film_size)?;

        Ok((film_size_units.into(), film_size))
    }

    /// Sets the size (and unites used to measure that size) of the film used by the designated camera. 
    pub fn set_camera_film_size(&self, camera_layer_handle: impl AsPtr<AEGP_LayerH>, film_size_units: FilmSizeUnits, mut film_size: f64) -> Result<(), Error> {
        call_suite_fn!(self, AEGP_SetCameraFilmSize, camera_layer_handle.as_ptr(), film_size_units.into(), &mut film_size)
    }

    /// Given a composition handle, returns the camera distance to the image plane. 
    pub fn default_camera_distance_to_image_plane(&self, comp_handle: &CompHandle) -> Result<f64, Error> {
        call_suite_fn_single!(self, AEGP_GetDefaultCameraDistanceToImagePlane -> f64, comp_handle.as_ptr())
    }
}

// ――――――――――――――――――――――――――――――――――――――― Types ――――――――――――――――――――――――――――――――――――――――

define_enum! {
    ae_sys::AEGP_FilmSizeUnits,
    FilmSizeUnits {
        None       = ae_sys::AEGP_FilmSizeUnits_NONE,
        Horizontal = ae_sys::AEGP_FilmSizeUnits_HORIZONTAL,
        Vertical   = ae_sys::AEGP_FilmSizeUnits_VERTICAL,
        Diagonal   = ae_sys::AEGP_FilmSizeUnits_DIAGONAL,
    }
}

define_enum! {
    ae_sys::AEGP_CameraType,
    CameraType {
        None         = ae_sys::AEGP_CameraType_NONE,
        Perspective  = ae_sys::AEGP_CameraType_PERSPECTIVE,
        Orthographic = ae_sys::AEGP_CameraType_ORTHOGRAPHIC,
    }
}

define_suite_item_wrapper!(
    ae_sys::AEGP_LayerH, LayerHandle,
    suite: CameraSuite,

```

--------------------------------

### Get Unscaled Clip Start Time

Source: https://docs.rs/after-effects/latest/latest/after_effects/pf/suites/struct.Utility_search=

Retrieves the start time of the clip, unaffected by any speed or retiming changes. This function provides the original start time in ticks.

```rust
pub fn unscaled_clip_start( &self, effect_ref: impl AsPtr<PF_ProgPtr>, ) -> Result<i32, Error>
```

--------------------------------

### ParamsSetup Command Description (Rust)

Source: https://docs.rs/after-effects/latest/0.2.1/after_effects/pf/enum.Command_search=std%3A%3Avec

Responsible for defining and registering plug-in parameters using `params.add()`, and also for registering custom user interface elements.

```rust
ParamsSetup
```

--------------------------------

### Input Specification Native Start Time

Source: https://docs.rs/after-effects/latest/latest/src/after_effects/aegp/suites/io_in.rs_search=

APIs for getting, setting, and clearing the native start time of an input specification.

```APIDOC
## GET /websites/rs_after-effects/in_spec_native_start_time

### Description
Retrieves the native start time of the footage associated with the input specification handle.

### Method
GET

### Endpoint
/websites/rs_after-effects/in_spec_native_start_time

### Parameters
#### Path Parameters
- **in_spec_handle** (impl AsPtr<AEIO_InSpecH>) - Required - Handle to the input specification.

### Response
#### Success Response (200)
- **Time** (Time) - The native start time of the footage.

#### Response Example
{
  "example": "{\"seconds\": 5, \"sub_seconds\": 0}"
}

## POST /websites/rs_after-effects/set_in_spec_native_start_time

### Description
Assigns a native start time to the footage for the given input specification handle.

### Method
POST

### Endpoint
/websites/rs_after-effects/set_in_spec_native_start_time

### Parameters
#### Path Parameters
- **in_spec_handle** (impl AsPtr<AEIO_InSpecH>) - Required - Handle to the input specification.

#### Request Body
- **start_time** (Time) - Required - The native start time to set.

### Request Example
{
  "example": "{\"seconds\": 5, \"sub_seconds\": 0}"
}

### Response
#### Success Response (200)
- **()** - Indicates successful setting of the start time.

## POST /websites/rs_after-effects/clear_in_spec_native_start_time

### Description
Clears the native start time of the footage for the given input specification handle. This is distinct from setting it to 0.

### Method
POST

### Endpoint
/websites/rs_after-effects/clear_in_spec_native_start_time

### Parameters
#### Path Parameters
- **in_spec_handle** (impl AsPtr<AEIO_InSpecH>) - Required - Handle to the input specification.

### Response
#### Success Response (200)
- **()** - Indicates successful clearing of the start time.
```

--------------------------------

### Rust: Navigate Installed Effects

Source: https://docs.rs/after-effects/latest/0.2.1/after_effects/aegp/struct.Effect_search=u32+-%3E+bool

Functions to retrieve the next installed effect in the sequence and to get the name or match name of an installed effect. These are useful for iterating through and identifying effects.

```rust
pub fn next_installed_effect( installed_effect_key: InstalledEffectKey, ) -> Result<InstalledEffectKey, Error>
```

```rust
pub fn name_of( installed_effect_key: InstalledEffectKey, ) -> Result<String, Error>
```

```rust
pub fn match_name_of( installed_effect_key: InstalledEffectKey, ) -> Result<String, Error>
```

--------------------------------

### Handle Parameter Setup for After Effects Plugin (Rust)

Source: https://docs.rs/after-effects/latest/latest/src/after_effects/plugin_base.rs

This code block manages the setup of plugin parameters. It creates a new `Parameters` instance, calls the plugin's `params_setup` method, and updates global instance information. Dependencies include `Parameters`, `InData`, and `OutData` structs.

```rust
if cmd == RawCommand::ParamsSetup {
    let mut params = Parameters::<$params_type>::new();
    params.set_in_data(in_data_ptr);
    global_inst.plugin_instance.params_setup(&mut params, InData::from_raw(in_data_ptr), OutData::from_raw(out_data_ptr))?; // Call to plugin's setup logic
    global_inst.params_num = params.num_params();
    (*out_data_ptr).num_params = params.num_params() as i32;
    global_inst.params_map.set((*params.map).clone()).unwrap(); // Store parameter map
}
```

--------------------------------

### Image Resampling Setup

Source: https://docs.rs/after-effects/latest/0.2.1/src/after_effects/pf/util_callbacks.rs_search=

Prepares the system for a series of image resampling operations by optimizing settings like quality and mode flags. This can involve initializing hardware or pre-calculating data structures for faster processing.

```APIDOC
## POST /ae/sampling/begin

### Description
Call this routine before performing a large number of image resamplings. Depending on the platform, this might initialize DSP chips or compute index tables to speed up image resampling.

### Method
POST

### Endpoint
`/ae/sampling/begin`

### Parameters
#### Request Body
- **quality** (Quality) - Required - The desired resampling quality (e.g., 'Draft', 'Good', 'Best').
- **mode_flags** (ModeFlags) - Required - Flags specifying resampling modes.

### Request Example
```json
{
  "quality": "Good",
  "mode_flags": "Unknown"
}
```

### Response
#### Success Response (200)
- **sampling_context** (Sampling) - An opaque context handle for subsequent operations.

#### Response Example
```json
{
  "sampling_context": "<sampling_context_handle>"
}
```
```

--------------------------------

### After Effects: Get Installed Effect Category

Source: https://docs.rs/after-effects/latest/-sys/0.2.1/after_effects_sys/struct.AEGP_EffectSuite1

Retrieves the category an installed effect belongs to. This can be used for organizing or filtering effects. It takes the installed effect key and a buffer for the category name.

```rust
AEGP_GetEffectCategory: Option<unsafe extern "C" fn(installed_effect_key: AEGP_InstalledEffectKey, categoryZ: *mut A_char) -> A_Err>
```

--------------------------------

### Rust: Initialize and Use App Suite

Source: https://docs.rs/after-effects/latest/latest/after_effects/pf/suites/struct.App

Demonstrates how to acquire an instance of the AppSuite from the After Effects host and perform basic operations. This suite is essential for integrating custom UI and accessing host-specific data.

```rust
use after_effects::pf::suites::AppSuite;
use after_effects::error::Error;

fn get_app_color() -> Result<after_effects::pf::suites::PF_App_Color, Error> {
    let app_suite = AppSuite::new()?;
    app_suite.bg_color()
}
```

--------------------------------

### Comp Suite - Work Area Start

Source: https://docs.rs/after-effects/latest/0.2.1/after_effects/aegp/suites/struct.Comp_search=u32+-%3E+bool

Function to get the start time of the current work area in a composition.

```APIDOC
## POST /aegp/suites/comp/comp_work_area_start

### Description
Gets the time where the current work area starts in the composition.

### Method
POST

### Endpoint
/aegp/suites/comp/comp_work_area_start

### Parameters
#### Request Body
- **comp_handle** (object) - Required - The handle to the composition.

### Request Example
```json
{
  "comp_handle": "<CompHandle>"
}
```

### Response
#### Success Response (200)
- **start_time** (object) - The start time of the work area.

#### Response Example
```json
{
  "start_time": {
    "seconds": 0,
    "scale": {
      "numerator": 1,
      "denominator": 1
    }
  }
}
```
```

--------------------------------

### After Effects: Get Next Installed Effect

Source: https://docs.rs/after-effects/latest/-sys/0.2.1/after_effects_sys/struct.AEGP_EffectSuite1

Iterates through the installed effects in After Effects. Given an installed effect key, it returns the key for the next effect in the list. This is used in conjunction with `AEGP_GetNumInstalledEffects` for enumeration.

```rust
AEGP_GetNextInstalledEffect: Option<unsafe extern "C" fn(installed_effect_key: AEGP_InstalledEffectKey, next_effectPH: *mut AEGP_InstalledEffectKey) -> A_Err>
```

--------------------------------

### IOInSuite Initialization and Management (Rust)

Source: https://docs.rs/after-effects/latest/0.2.1/src/after_effects/aegp/suites/io_in.rs_search=u32+-%3E+bool

Provides methods for initializing and managing the IOInSuite, which handles input specifications for After Effects. It includes acquiring the suite and releasing it on drop.

```Rust
impl IOInSuite {
    /// Acquire this suite from the host. Returns error if the suite is not available.
    /// Suite is released on drop.
    pub fn new() -> Result<Self, Error> {
        crate::Suite::new()
    }
}
```

--------------------------------

### PR_GlobalSetupFunc

Source: https://docs.rs/after-effects/latest/-sys/0.2.1/index

Explains that PR_GlobalSetupFunc is called after main, once after the plugin is loaded, and that global data is common across all plugin instances.

```APIDOC
## PR_GlobalSetupFunc

### Description
Called after main. This happens just once, after the plugin is loaded. The global data is common across all instances of the plugin.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A
```

--------------------------------

### Get Source Track Media Actual Start Time

Source: https://docs.rs/after-effects/latest/0.2.1/src/after_effects/pf/suites/utility.rs

Retrieves the actual start time of the media for a specific layer parameter.

```APIDOC
## GET /websites/rs_after-effects/source_track_media_actual_start_time

### Description
Retrieves the actual start time of the media for the specified layer parameter, considering the sequence time.

### Method
GET

### Endpoint
`/websites/rs_after-effects/source_track_media_actual_start_time`

### Parameters
#### Query Parameters
- **effect_ref** (PF_ProgPtr) - Required - A reference to the effect.
- **layer_param_index** (u32) - Required - The index of the layer parameter.
- **sequence_time** (PrTime) - Required - The current time within the sequence.

### Response
#### Success Response (200)
- **actual_start_time** (PrTime) - The actual media start time.

#### Response Example
```json
{
  "actual_start_time": 0
}
```
```

--------------------------------

### Get Source Track Media Actual Start Time

Source: https://docs.rs/after-effects/latest/0.2.1/src/after_effects/pf/suites/utility.rs_search=std%3A%3Avec

Retrieves the actual start time of the media for a specified layer parameter.

```APIDOC
## GET /websites/rs_after-effects/source_track_media_actual_start_time

### Description
Retrieves the precise start time of the media associated with a layer parameter within the source track.

### Method
GET

### Endpoint
`/websites/rs_after-effects/source_track_media_actual_start_time`

### Parameters
#### Query Parameters
- **effect_ref** (PF_ProgPtr) - Required - Reference to the effect.
- **layer_param_index** (u32) - Required - The index of the layer parameter.
- **sequence_time** (PrTime) - Required - The time within the sequence.

### Response
#### Success Response (200)
- **start_time** (PrTime) - The actual media start time.
```

--------------------------------

### Helper2 Suite Initialization

Source: https://docs.rs/after-effects/latest/latest/after_effects/pf/suites/struct.Helper2_search=u32+-%3E+bool

Acquires the Helper2 suite from the host application. Returns an error if the suite is not available. The suite is automatically released when it is dropped.

```APIDOC
## POST /helper2/new

### Description
Acquires the Helper2 suite from the host. Returns error if the suite is not available. Suite is released on drop.

### Method
POST

### Endpoint
/helper2/new

### Parameters
#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{}
```

### Response
#### Success Response (200)
- **suite** (HelperSuite2) - The acquired Helper2 suite.

#### Response Example
```json
{
  "suite": "HelperSuite2_instance"
}
```
```

--------------------------------

### Rust: IOIn Suite Initialization and Management

Source: https://docs.rs/after-effects/latest/latest/after_effects/aegp/suites/struct.IOIn_search=

Demonstrates how to acquire and manage the IOIn suite in Rust. The suite is obtained from the host and automatically released when it goes out of scope. Error handling is included for cases where the suite might not be available.

```Rust
use after_effects::aegp::suites::IOIn;

// Acquire the IOIn suite from the host.
match IOIn::new() {
    Ok(io_in_suite) => {
        // Use the io_in_suite here...
        // The suite will be automatically released when io_in_suite goes out of scope.
    },
    Err(error) => {
        eprintln!("Failed to acquire IOIn suite: {:?}", error);
    }
}
```

--------------------------------

### Get Installed Effect Count (Rust)

Source: https://docs.rs/after-effects/latest/0.2.1/src/after_effects/aegp/suites/effect.rs_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns the total number of effects currently installed in After Effects. The result is returned as an i32.

```rust
pub fn num_installed_effects(&self) -> Result<i32, Error> {
    Ok(call_suite_fn_single!(self, AEGP_GetNumInstalledEffects -> ae_sys::A_long)? as i32)
}
```

--------------------------------

### Begin Sampling

Source: https://docs.rs/after-effects/latest/0.2.1/src/after_effects/pf/util_callbacks.rs_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Prepares the system for a series of image resampling operations. This function can optimize performance by initializing necessary hardware or data structures.

```APIDOC
## POST /effects/begin_sampling

### Description
Prepares the system for a series of image resampling operations. This function can optimize performance by initializing necessary hardware or data structures.

### Method
POST

### Endpoint
`/effects/begin_sampling`

### Parameters
#### Query Parameters
- **quality** (Quality) - Required - The desired quality level for resampling.
- **mode_flags** (ModeFlags) - Required - Flags to control sampling behavior.

### Request Body
(Not applicable, parameters are passed as arguments)

### Response
#### Success Response (200)
- **Sampling** (Sampling) - An opaque structure containing sampling parameters. This should be passed to subsequent sampling operations.

#### Response Example
(Not applicable, returns Sampling struct)
```

--------------------------------

### Get Clip Start Time

Source: https://docs.rs/after-effects/latest/0.2.1/after_effects/pf/suites/struct.Utility_search=std%3A%3Avec

Retrieves the starting time of the clip. This is useful for determining the temporal position of the clip within a sequence.

```rust
pub fn clip_start(&self, effect_ref: impl AsPtr<PF_ProgPtr>) -> Result<i32, Error>
```

--------------------------------

### EffectSuite: Get Number of Installed Effects

Source: https://docs.rs/after-effects/latest/0.2.1/after_effects/aegp/suites/struct.Effect

Returns the total count of effects that are currently installed and available within the After Effects application.

```rust
pub fn num_installed_effects(&self) -> Result<i32, Error>
```

--------------------------------

### Command Implementation: from_entry_point

Source: https://docs.rs/after-effects/latest/latest/after_effects/pf/enum.Command_search=std%3A%3Avec

This function constructs a `Command` from entry point data, including raw command, input data, parameters, output layer, and extra data.

```APIDOC
## Command Implementation: from_entry_point

### Description
This function is responsible for creating a `Command` instance from the various data provided at the entry point of an After Effects plugin operation. It allows for the creation of commands that encapsulate specific actions or data processing steps.

### Method
`pub fn from_entry_point(cmd: impl Into<RawCommand>, in_data_ptr: *const PF_InData, params: *mut *mut PF_ParamDef, output: *mut PF_LayerDef, extra: *mut c_void,) -> Self`

### Parameters

- **cmd** (*impl Into<RawCommand>*) - Required - The raw command to be converted into a `Command` type.
- **in_data_ptr** (**const PF_InData*) - Required - A pointer to the input data structure.
- **params** (**mut *mut PF_ParamDef*) - Required - A pointer to an array of parameter definitions.
- **output** (**mut PF_LayerDef*) - Required - A pointer to the output layer definition.
- **extra** (**mut c_void*) - Required - A pointer to additional, arbitrary extra data.

### Return Value
Returns a `Self` (the `Command` instance).

```
Tokens:
Raw