Skip to content
/ CChromaEditor Public
forked from razerofficial/CChromaEditor

C++ Dynamic library for playing and editing Chroma animations

License

MIT license
1 star 14 forks Branches Tags Activity
Star
Notifications You must be signed in to change notification settings

abdulmajid9523608625/CChromaEditor

BranchesTags
 
 

Repository files navigation

Latest

CChromaEditor - C++ Dynamic Library for playing and editing Chroma animations

Table of Contents

See Also

Docs:

Plugins:

  • CChromaEditor - C++ native MFC library for playing and editing Chroma animations

Frameworks supported

  • Windows ChromaSDK (32-bit)

  • Windows ChromaSDK (64-bit)

Prerequisites

  • Install Synapse

  • Make sure the Chroma Connect module is installed.

image_5

  • If you don't have Chroma hardware, you can see Chroma effects with the Chroma Emulator

  • This library is full source and can build with VS 2015/2017/2019 so make sure you include the corresponding Microsoft Visual C++ Redistributable for Visual Studio with your application for the versions that you build with. The core ChromaSDK is built with VS 2015, so you'll want that redistributable at a minimum.

  • To compile: Install Visual Studio

  • To compile: Install Windows 10 SDK

  • To compile: Install Templates->Other Languages->Visual C++->Visual C++ 2015 Tools for Windows Desktop which can be installed through the Visual Studio New Project Dialog

image_42

  • Use retarget solution to select an available Windows SDK.

Security

The C++ Chroma Editor Library loads the core Razer DLL RzChromaSDK.dll and the Razer stream library RzChromaStreamPlugin.dll. To avoid a 3rd party injecting malicious code, the C++ Chroma Editor Library checks for a valid signature on the Razer libraries. The DLL issuer is validated to be Razer USA Ltd. Init and InitSDK will return RZRESULT_DLL_INVALID_SIGNATURE if the signature check fails.

The sample apps use the CHECK_CHROMA_LIBRARY_SIGNATURE preprocessor definition to enable signature checking on the Chroma Editor Library. Signature checking can be used on the Razer libraries downloaded from Github releases.

#ifdef CHECK_CHROMA_LIBRARY_SIGNATURE
 _sInvalidSignature = !VerifyLibrarySignature::VerifyModule(path);
#endif

Chroma Editor Library

The Chroma Editor Library is a helper library for Chroma animation playback and realtime manipulation of Chroma animations.

The latest versions of the Chroma Editor Library can be found in Releases for Windows-PC and Windows-Cloud.

Windows PC

For Windows PC builds the RzChromaSDK.dll and RzChromaStreamPlugin.dll are not packaged with the build. These libraries are automatically updated and managed by Synapse and the Chroma Connect module. Avoid including these files in your build folder for Windows PC builds.

32-bit libraries

Win32BuildFolder\CChromaEditorLibrary.dll

64-bit libraries

Win64BuildFolder\CChromaEditorLibrary64.dll

Windows Cloud

Windows Cloud builds run on cloud platforms using Windows such as Amazon Luna, Microsoft Game Pass, and NVidia GeForce Now. Game instances run in the cloud without direct access to Chroma hardware. By running the Windows Cloud version of the library Chroma effects can reach your local machine and connected hardware. Cloud instances won't have Synapse installed which requires special cloud versions of the libraries. The Chroma Editor Library uses the core RzChromaSDK low-level library to send Chroma effects to the cloud with the RzChromaStreamPlugin streaming library. Viewers can watch the cloud stream via the Razer Stream Portal.

32-bit libraries

Win32BuildFolder\CChromaEditorLibrary.dll
Win32BuildFolder\RzChromaSDK.dll
Win32BuildFolder\RzChromaStreamPlugin.dll

64-bit libraries

Win64BuildFolder\CChromaEditorLibrary64.dll
Win64BuildFolder\RzChromaSDK64.dll
Win64BuildFolder\RzChromaStreamPlugin64.dll

API Class

The ChromaAnimationAPI class provides a wrapper for the Chroma Editor Library. The wrapper for the API can be found at CConsoleEditor/ChromaAnimationAPI.h and CConsoleEditor/ChromaAnimationAPI.cpp.

Initialization

The ChromaAnimationAPI::InitSDK() method returns RZRESULT_SUCCESS when initialization has succeeded. Avoid making calls to the Chroma API when anything other than success is returned. A unsuccessful result indicates Chroma is not present on the machine.

 APPINFOTYPE appInfo = {};

 _tcscpy_s(appInfo.Title, 256, _T("Sample Game Title"));
 _tcscpy_s(appInfo.Description, 1024, _T("Sample Game Description"));
 _tcscpy_s(appInfo.Author.Name, 256, _T("Company Name"));
 _tcscpy_s(appInfo.Author.Contact, 256, _T("Company Website or Email"));

 //appInfo.SupportedDevice = 
 //    0x01 | // Keyboards
 //    0x02 | // Mice
 //    0x04 | // Headset
 //    0x08 | // Mousepads
 //    0x10 | // Keypads
 //    0x20   // ChromaLink devices
 appInfo.SupportedDevice = (0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20);
 //    0x01 | // Utility. (To specifiy this is an utility application)
 //    0x02   // Game. (To specifiy this is a game);
 appInfo.Category = 0x02;

 RZRESULT result = ChromaAnimationAPI::InitSDK(&appInfo);
 if (result != RZRESULT_SUCCESS)
 {
  ChromaLogger::printf("Failed to initialize Chroma SDK with error=%ld\r\n", result);
 
 // avoid making Chroma API calls after a non-zero init result
  return;
 }

Getting Started

Running the editor application

1 Run the Chroma Editor Installer to associate .chroma animations with the editor.

2 Double-click a .chroma animation file to open in the editor

Building the editor

1 Open CChromaEditor.sln in Visual Studio

2 The CChromaEditorLibrary project builds the native C++ DLL for x64 and x86 platforms

3 The CConsoleEditor project is a console project that uses the DLL and provides a command-line interface. The only parameter is the file path to a Chroma animation file. When no parameter is provided, the editor opens temp.chroma on the desktop.

Assets

The chroma binary file format is supported in multiple engines and can even play on websites. Authoring tools like the Web Chroma Editor can easily record animations for the full device set which can be downloaded in a zip file. The Web Chroma Editor is also able to embed chroma animation files into code for specific languages.

Dialog

The standalone Chroma editor has a MFC dialog that can be used to create Chroma animations for the set of devices.

image_1

File Menu

image_3

New

Start with a new animationName

Open

Open a file dialog and open a Chroma animation

Save

Save the open animation

Save As

Open a file dialog and save the open animation

Import Menu

image_4

Import Image

Import a BMP, JPG, or PNG texture into the grid layout. The images will be stretched to fit the grid.

Import Image Sequence

Import a numbered set of images as an animation.

Import Animation

Import a GIF animation into the grid layout. Multiple frames will be added if they exist in the GIF. The image will be stretched to fit the grid.

Streaming

The Razer Streaming Portal supports streaming Chroma RGB on video streaming platforms and can be embedded on any 3rd party site. In order to stream Chroma RGB, you'll need the latest Synapse and Chroma Connect module. No other software is required to control streaming from the browser or the API below.

Login

The first step is to login into the Razer Streaming Portal with Razer ID.

image_6

Profile

Navigate to the user profile by clicking MY STREAMS.

image_7

Stream Source

Create a Stream Source to broadcast Chroma RGB events.

image_8

Name Your Stream Source

Enter the name of your stream source and enter name of the game to generate the stream thumbnail. Make sure GO LIVE is turned on. The Mature toggle is optional and can be filtered.

image_9

Source

PC games set the source to PC. Cloud Gaming, Console, and Mobile games set the Source to Other.

image_10

Authorize

Authorizing a shortcode is used to allow the broadcast to be toggled on sites outside the Razer Streaming Portal or by games using the API to authorize a ShortCode. Once the Shortcode is authorized, the Stream Id and Stream Key can be obtained before releasing the ShortCode.

image_11

Link Stream Source

The Stream Source can be linked to several social platforms. Enable the toggle for social platforms to appear on your Stream Source tile. Pick a default social platform for yuour Stream Source tile.

image_12

Embed

Chroma RGB streaming can be an Embed on a 3rd party webpage. Click the Embed clipboard icon to add the HTML5 iframe snippet to the clipboard which can be pasted into a 3rd party webpage. The Embed URL must match the URL of the 3rd party webpage address.

Twitch

Add the Razer Streaming Panel Twitch Extension to stream Chroam RGB on Twitch. There's a easily link by clicking the Twitch gear icon.

image_18

Twitch Panel

In order to broadcast via the Twitch panel, use the Authenticate link to authorize the automatic shortcode.

image_20

The shortcode will appear in the code activation popup and then click the AUTHORIZE SHORTCODE button. After the Stream Source has been authorized, the window can be closed.

image_21

If the Stream Source is associated with the logged in Razer ID, authorization will give access to Twitch to allow the broadcast toggle to be used from the Twitch panel.

image_22

Viewers of a live Twitch channel will automatically tune into the Chroma RGB from the broadcast. The streamer and viewers' hardware will be in sync.

image_23

Save

Save the Stream Source settings when finished. You can rename your Stream Source and save the changes. You can reuse the same Stream Source for multiple games by changing the game title / thumbnail. You can create multiple Stream Sources for mulitple games. You can always delete a Stream Source to keep things tidy. If you've accidentally streamed your Stream Key to viewers, you can always delete the Stream Source and create a new Stream Source to generate a new Stream Id and Stream Key.

image_13

Broadcast

Once a Stream Source has been created, the toggle can be used to Broadcast to the social platforms that have been linked. Browse the Chroma Workshop to find games that have Chroma RGB integration. The broadcast toggle for Chroma RGB can be used before launching a game or after, either will work.

image_14

Streams

When the Chroma RGB broadcast is active and game Chroma RGB events are detected, the Stream Source tile will appear on the main page of the portal. The Stream Source can appear in the Favorite Streamers section if the associated streamer has been favorited. The Stream Source can appear in the Favorite Games section if the associated game has been favorited. The Stream Source appears in the Available Stream section sorted by view count and can be found through pagination.

image_15

Favorite Streamers

Clicking the streamer link on the Stream Source navigates to a page where favorites can be toggled via the star icon.

image_16

Favorite Games

Clicking the game link on the Stream Source navigates to a page where favorites can be toggled via the heart icon.

image_17

Watch

Clicking a Stream Source tile opens the watch page. The watch page streams Chroma RGB including audio and video with live chat (if available) when linked to the Stream Source. Chroma is initialized when the page receives focus, and uninitializes Chroma when the page loses focus. The watch page also has a drop down to switch between social channels that are linked with the stream.

image_19

Streaming Logic Flow

By default, any game that implements Chroma RGB on PC is compatible with streaming that can be controlled from the Razer Streaming Portal. Games are also able to control streaming via the API. Using the streaming API is most useful when the instance of the game is running within Cloud Gaming. Streaming can either broadcast or watch a Chroma RGB stream. The API supports broadcasting or watching but not both at the same time. It's recommended that games have a Chroma RGB toggle in the game settings that is on by default. For streaming Chroma RGB, games should be able to display a shortcode for stream authorization and a broadcast toggle.

Step 1. At any time, the game can use StreamGetStatus to get the streaming current status to display to the user.

Step 2. To prepare for broadcasting, the streamer creates a Stream Source on the profile page.

Step 3. The game invokes StreamGetAuthShortcode to display a six digit alpha-numeric shortcode to the streamer. The shortcode will expire within 5 minutes.

On PC, the only streaming platform is "PC".

Cloud gaming platforms are specified below.

"GEFORCE_NOW"
"LUNA"
"STADIA"
"GAME_PASS"

Step 4. The game invokes StreamGetId and StreamGetKey on a 3-second interval while waiting on user authorization.

Step 5. The streamer can edit any Stream Source on the profile page and click AUTHORIZE SHORT CODE.

image_11

Step 6. The streamer enters the shortcode and clicks AUTHORIZE SHORT CODE.

image_21

Step 7. At this point StreamGetId and StreamGetKey return valid data to the game. The Stream Id and Stream Key should be saved in the user settings for feature streaming. To complete the authorization, invoke StreamReleaseShortcode which will prevent any other users from obtaining the auth details corresponding to the shortcode.

Step 8. The game can now invoke StreamBroadcast to begin broadcasting Chroma RGB. Both the Stream Id and Stream Key are needed to broadcast. StreamBroadcastEnd will end the broadcast.

Step 9. The game can invoke StreamWatch to watch the Chroma RGB stream for a given Stream Id. Watching a stream will end by invoking StreamWatchEnd.

API

The API has various methods with the D suffix where double return-type/parameters were used. This is to support engines like GameMaker which have a limited number of data-types.

(Start of automation)

Methods:

PluginAddColor

Return the sum of colors

// DLL Interface
EXPORT_API int PluginAddColor(
 const int color1, const int color2);

// Class Plugin
int result = ChromaAnimationAPI::AddColor(
 const int color1, const int color2);

PluginAddFrame

Adds a frame to the Chroma animation and sets the duration (in seconds). The color is expected to be an array of the dimensions for the deviceType/device. The length parameter is the size of the color array. For EChromaSDKDevice1DEnum the array size should be MAX LEDS. For EChromaSDKDevice2DEnum the array size should be MAX ROW times MAX COLUMN. Returns the animation id upon success. Returns negative one upon failure.

// DLL Interface
EXPORT_API int PluginAddFrame(
 int animationId, float duration, int* colors, int length);

// Class Plugin
int result = ChromaAnimationAPI::AddFrame(
 int animationId, float duration, int* colors, int length);

PluginAddNonZeroAllKeys

Add source color to target where color is not black for frame id, reference source and target by id.

// DLL Interface
EXPORT_API void PluginAddNonZeroAllKeys(
 int sourceAnimationId, int targetAnimationId, int frameId);

// Class Plugin
ChromaAnimationAPI::AddNonZeroAllKeys(
 int sourceAnimationId, int targetAnimationId, int frameId);

PluginAddNonZeroAllKeysAllFrames

Add source color to target where color is not black for all frames, reference source and target by id.

// DLL Interface
EXPORT_API void PluginAddNonZeroAllKeysAllFrames(
 int sourceAnimationId, int targetAnimationId);

// Class Plugin
ChromaAnimationAPI::AddNonZeroAllKeysAllFrames(
 int sourceAnimationId, int targetAnimationId);

PluginAddNonZeroAllKeysAllFramesName

Add source color to target where color is not black for all frames, reference source and target by name.

// DLL Interface
EXPORT_API void PluginAddNonZeroAllKeysAllFramesName(
 const char* sourceAnimation, const char* targetAnimation);

// Class Plugin
ChromaAnimationAPI::AddNonZeroAllKeysAllFramesName(
 const char* sourceAnimation, const char* targetAnimation);

PluginAddNonZeroAllKeysAllFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginAddNonZeroAllKeysAllFramesNameD(
 const char* sourceAnimation, const char* targetAnimation);

// Class Plugin
double result = ChromaAnimationAPI::AddNonZeroAllKeysAllFramesNameD(
 const char* sourceAnimation, const char* targetAnimation);

PluginAddNonZeroAllKeysAllFramesOffset

Add source color to target where color is not black for all frames starting at offset for the length of the source, reference source and target by id.

// DLL Interface
EXPORT_API void PluginAddNonZeroAllKeysAllFramesOffset(
 int sourceAnimationId, int targetAnimationId, int offset);

// Class Plugin
ChromaAnimationAPI::AddNonZeroAllKeysAllFramesOffset(
 int sourceAnimationId, int targetAnimationId, int offset);

PluginAddNonZeroAllKeysAllFramesOffsetName

Add source color to target where color is not black for all frames starting at offset for the length of the source, reference source and target by name.

// DLL Interface
EXPORT_API void PluginAddNonZeroAllKeysAllFramesOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int offset);

// Class Plugin
ChromaAnimationAPI::AddNonZeroAllKeysAllFramesOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int offset);

PluginAddNonZeroAllKeysAllFramesOffsetNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginAddNonZeroAllKeysAllFramesOffsetNameD(
 const char* sourceAnimation, const char* targetAnimation, double offset);

// Class Plugin
double result = ChromaAnimationAPI::AddNonZeroAllKeysAllFramesOffsetNameD(
 const char* sourceAnimation, const char* targetAnimation, double offset);

PluginAddNonZeroAllKeysName

Add source color to target where color is not black for frame id, reference source and target by name.

// DLL Interface
EXPORT_API void PluginAddNonZeroAllKeysName(
 const char* sourceAnimation, const char* targetAnimation, int frameId);

// Class Plugin
ChromaAnimationAPI::AddNonZeroAllKeysName(
 const char* sourceAnimation, const char* targetAnimation, int frameId);

PluginAddNonZeroAllKeysOffset

Add source color to target where color is not black for the source frame and target offset frame, reference source and target by id.

// DLL Interface
EXPORT_API void PluginAddNonZeroAllKeysOffset(
 int sourceAnimationId, int targetAnimationId, int frameId, int offset);

// Class Plugin
ChromaAnimationAPI::AddNonZeroAllKeysOffset(
 int sourceAnimationId, int targetAnimationId, int frameId, int offset);

PluginAddNonZeroAllKeysOffsetName

Add source color to target where color is not black for the source frame and target offset frame, reference source and target by name.

// DLL Interface
EXPORT_API void PluginAddNonZeroAllKeysOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int frameId, int offset);

// Class Plugin
ChromaAnimationAPI::AddNonZeroAllKeysOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int frameId, int offset);

PluginAddNonZeroAllKeysOffsetNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginAddNonZeroAllKeysOffsetNameD(
 const char* sourceAnimation, const char* targetAnimation, double frameId,
 double offset);

// Class Plugin
double result = ChromaAnimationAPI::AddNonZeroAllKeysOffsetNameD(
 const char* sourceAnimation, const char* targetAnimation, double frameId,
 double offset);

PluginAddNonZeroTargetAllKeysAllFrames

Add source color to target where the target color is not black for all frames, reference source and target by id.

// DLL Interface
EXPORT_API void PluginAddNonZeroTargetAllKeysAllFrames(
 int sourceAnimationId, int targetAnimationId);

// Class Plugin
ChromaAnimationAPI::AddNonZeroTargetAllKeysAllFrames(
 int sourceAnimationId, int targetAnimationId);

PluginAddNonZeroTargetAllKeysAllFramesName

Add source color to target where the target color is not black for all frames, reference source and target by name.

// DLL Interface
EXPORT_API void PluginAddNonZeroTargetAllKeysAllFramesName(
 const char* sourceAnimation, const char* targetAnimation);

// Class Plugin
ChromaAnimationAPI::AddNonZeroTargetAllKeysAllFramesName(
 const char* sourceAnimation, const char* targetAnimation);

PluginAddNonZeroTargetAllKeysAllFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginAddNonZeroTargetAllKeysAllFramesNameD(
 const char* sourceAnimation, const char* targetAnimation);

// Class Plugin
double result = ChromaAnimationAPI::AddNonZeroTargetAllKeysAllFramesNameD(
 const char* sourceAnimation, const char* targetAnimation);

PluginAddNonZeroTargetAllKeysAllFramesOffset

Add source color to target where the target color is not black for all frames starting at offset for the length of the source, reference source and target by id.

// DLL Interface
EXPORT_API void PluginAddNonZeroTargetAllKeysAllFramesOffset(
 int sourceAnimationId, int targetAnimationId, int offset);

// Class Plugin
ChromaAnimationAPI::AddNonZeroTargetAllKeysAllFramesOffset(
 int sourceAnimationId, int targetAnimationId, int offset);

PluginAddNonZeroTargetAllKeysAllFramesOffsetName

Add source color to target where the target color is not black for all frames starting at offset for the length of the source, reference source and target by name.

// DLL Interface
EXPORT_API void PluginAddNonZeroTargetAllKeysAllFramesOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int offset);

// Class Plugin
ChromaAnimationAPI::AddNonZeroTargetAllKeysAllFramesOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int offset);

PluginAddNonZeroTargetAllKeysAllFramesOffsetNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginAddNonZeroTargetAllKeysAllFramesOffsetNameD(
 const char* sourceAnimation, const char* targetAnimation, double offset);

// Class Plugin
double result = ChromaAnimationAPI::AddNonZeroTargetAllKeysAllFramesOffsetNameD(
 const char* sourceAnimation, const char* targetAnimation, double offset);

PluginAddNonZeroTargetAllKeysOffset

Add source color to target where target color is not blank from the source frame to the target offset frame, reference source and target by id.

// DLL Interface
EXPORT_API void PluginAddNonZeroTargetAllKeysOffset(
 int sourceAnimationId, int targetAnimationId, int frameId, int offset);

// Class Plugin
ChromaAnimationAPI::AddNonZeroTargetAllKeysOffset(
 int sourceAnimationId, int targetAnimationId, int frameId, int offset);

PluginAddNonZeroTargetAllKeysOffsetName

Add source color to target where target color is not blank from the source frame to the target offset frame, reference source and target by name.

// DLL Interface
EXPORT_API void PluginAddNonZeroTargetAllKeysOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int frameId, int offset);

// Class Plugin
ChromaAnimationAPI::AddNonZeroTargetAllKeysOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int frameId, int offset);

PluginAddNonZeroTargetAllKeysOffsetNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginAddNonZeroTargetAllKeysOffsetNameD(
 const char* sourceAnimation, const char* targetAnimation, double frameId,
 double offset);

// Class Plugin
double result = ChromaAnimationAPI::AddNonZeroTargetAllKeysOffsetNameD(
 const char* sourceAnimation, const char* targetAnimation, double frameId,
 double offset);

PluginAppendAllFrames

Append all source frames to the target animation, reference source and target by id.

// DLL Interface
EXPORT_API void PluginAppendAllFrames(
 int sourceAnimationId, int targetAnimationId);

// Class Plugin
ChromaAnimationAPI::AppendAllFrames(
 int sourceAnimationId, int targetAnimationId);

PluginAppendAllFramesName

Append all source frames to the target animation, reference source and target by name.

// DLL Interface
EXPORT_API void PluginAppendAllFramesName(
 const char* sourceAnimation, const char* targetAnimation);

// Class Plugin
ChromaAnimationAPI::AppendAllFramesName(
 const char* sourceAnimation, const char* targetAnimation);

PluginAppendAllFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginAppendAllFramesNameD(
 const char* sourceAnimation, const char* targetAnimation);

// Class Plugin
double result = ChromaAnimationAPI::AppendAllFramesNameD(
 const char* sourceAnimation, const char* targetAnimation);

PluginClearAll

PluginClearAll will issue a CLEAR effect for all devices.

// DLL Interface
EXPORT_API void PluginClearAll();

// Class Plugin
ChromaAnimationAPI::ClearAll();

PluginClearAnimationType

PluginClearAnimationType will issue a CLEAR effect for the given device.

// DLL Interface
EXPORT_API void PluginClearAnimationType(
 int deviceType, int device);

// Class Plugin
ChromaAnimationAPI::ClearAnimationType(
 int deviceType, int device);

PluginCloseAll

PluginCloseAll closes all open animations so they can be reloaded from disk. The set of animations will be stopped if playing.

// DLL Interface
EXPORT_API void PluginCloseAll();

// Class Plugin
ChromaAnimationAPI::CloseAll();

PluginCloseAnimation

Closes the Chroma animation to free up resources referenced by id. Returns the animation id upon success. Returns negative one upon failure. This might be used while authoring effects if there was a change necessitating re-opening the animation. The animation id can no longer be used once closed.

// DLL Interface
EXPORT_API int PluginCloseAnimation(int animationId);

// Class Plugin
int result = ChromaAnimationAPI::CloseAnimation(int animationId);

PluginCloseAnimationD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginCloseAnimationD(double animationId);

// Class Plugin
double result = ChromaAnimationAPI::CloseAnimationD(double animationId);

PluginCloseAnimationName

Closes the Chroma animation referenced by name so that the animation can be reloaded from disk.

// DLL Interface
EXPORT_API void PluginCloseAnimationName(const char* path);

// Class Plugin
ChromaAnimationAPI::CloseAnimationName(const char* path);

PluginCloseAnimationNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginCloseAnimationNameD(const char* path);

// Class Plugin
double result = ChromaAnimationAPI::CloseAnimationNameD(const char* path);

PluginCloseComposite

PluginCloseComposite closes a set of animations so they can be reloaded from disk. The set of animations will be stopped if playing.

// DLL Interface
EXPORT_API void PluginCloseComposite(const char* name);

// Class Plugin
ChromaAnimationAPI::CloseComposite(const char* name);

PluginCloseCompositeD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginCloseCompositeD(const char* name);

// Class Plugin
double result = ChromaAnimationAPI::CloseCompositeD(const char* name);

PluginCopyAllKeys

Copy source animation to target animation for the given frame. Source and target are referenced by id.

// DLL Interface
EXPORT_API void PluginCopyAllKeys(
 int sourceAnimationId, int targetAnimationId, int frameId);

// Class Plugin
ChromaAnimationAPI::CopyAllKeys(
 int sourceAnimationId, int targetAnimationId, int frameId);

PluginCopyAllKeysName

Copy source animation to target animation for the given frame. Source and target are referenced by id.

// DLL Interface
EXPORT_API void PluginCopyAllKeysName(
 const char* sourceAnimation, const char* targetAnimation, int frameId);

// Class Plugin
ChromaAnimationAPI::CopyAllKeysName(
 const char* sourceAnimation, const char* targetAnimation, int frameId);

PluginCopyAnimation

Copy animation to named target animation in memory. If target animation exists, close first. Source is referenced by id.

// DLL Interface
EXPORT_API int PluginCopyAnimation(
 int sourceAnimationId, const char* targetAnimation);

// Class Plugin
int result = ChromaAnimationAPI::CopyAnimation(
 int sourceAnimationId, const char* targetAnimation);

PluginCopyAnimationName

Copy animation to named target animation in memory. If target animation exists, close first. Source is referenced by name.

// DLL Interface
EXPORT_API void PluginCopyAnimationName(
 const char* sourceAnimation, const char* targetAnimation);

// Class Plugin
ChromaAnimationAPI::CopyAnimationName(
 const char* sourceAnimation, const char* targetAnimation);

PluginCopyAnimationNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginCopyAnimationNameD(
 const char* sourceAnimation, const char* targetAnimation);

// Class Plugin
double result = ChromaAnimationAPI::CopyAnimationNameD(
 const char* sourceAnimation, const char* targetAnimation);

PluginCopyBlueChannelAllFrames

Copy blue channel to other channels for all frames. Intensity range is 0.0 to 1.0. Reference the animation by id.

// DLL Interface
EXPORT_API void PluginCopyBlueChannelAllFrames(
 int animationId, float redIntensity, float greenIntensity);

// Class Plugin
ChromaAnimationAPI::CopyBlueChannelAllFrames(
 int animationId, float redIntensity, float greenIntensity);

PluginCopyBlueChannelAllFramesName

Copy blue channel to other channels for all frames. Intensity range is 0.0 to 1.0. Reference the animation by name.

// DLL Interface
EXPORT_API void PluginCopyBlueChannelAllFramesName(
 const char* path, float redIntensity, float greenIntensity);

// Class Plugin
ChromaAnimationAPI::CopyBlueChannelAllFramesName(
 const char* path, float redIntensity, float greenIntensity);

PluginCopyBlueChannelAllFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginCopyBlueChannelAllFramesNameD(
 const char* path, double redIntensity, double greenIntensity);

// Class Plugin
double result = ChromaAnimationAPI::CopyBlueChannelAllFramesNameD(
 const char* path, double redIntensity, double greenIntensity);

PluginCopyGreenChannelAllFrames

Copy green channel to other channels for all frames. Intensity range is 0.0 to 1.0. Reference the animation by id.

// DLL Interface
EXPORT_API void PluginCopyGreenChannelAllFrames(
 int animationId, float redIntensity, float blueIntensity);

// Class Plugin
ChromaAnimationAPI::CopyGreenChannelAllFrames(
 int animationId, float redIntensity, float blueIntensity);

PluginCopyGreenChannelAllFramesName

Copy green channel to other channels for all frames. Intensity range is 0.0 to 1.0. Reference the animation by name.

// DLL Interface
EXPORT_API void PluginCopyGreenChannelAllFramesName(
 const char* path, float redIntensity, float blueIntensity);

// Class Plugin
ChromaAnimationAPI::CopyGreenChannelAllFramesName(
 const char* path, float redIntensity, float blueIntensity);

PluginCopyGreenChannelAllFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginCopyGreenChannelAllFramesNameD(
 const char* path, double redIntensity, double blueIntensity);

// Class Plugin
double result = ChromaAnimationAPI::CopyGreenChannelAllFramesNameD(
 const char* path, double redIntensity, double blueIntensity);

PluginCopyKeyColor

Copy animation key color from the source animation to the target animation for the given frame. Reference the source and target by id.

// DLL Interface
EXPORT_API void PluginCopyKeyColor(
 int sourceAnimationId, int targetAnimationId, int frameId, int rzkey);

// Class Plugin
ChromaAnimationAPI::CopyKeyColor(
 int sourceAnimationId, int targetAnimationId, int frameId, int rzkey);

PluginCopyKeyColorAllFrames

Copy animation key color from the source animation to the target animation for all frames. Reference the source and target by id.

// DLL Interface
EXPORT_API void PluginCopyKeyColorAllFrames(
 int sourceAnimationId, int targetAnimationId, int rzkey);

// Class Plugin
ChromaAnimationAPI::CopyKeyColorAllFrames(
 int sourceAnimationId, int targetAnimationId, int rzkey);

PluginCopyKeyColorAllFramesName

Copy animation key color from the source animation to the target animation for all frames. Reference the source and target by name.

// DLL Interface
EXPORT_API void PluginCopyKeyColorAllFramesName(
 const char* sourceAnimation, const char* targetAnimation, int rzkey);

// Class Plugin
ChromaAnimationAPI::CopyKeyColorAllFramesName(
 const char* sourceAnimation, const char* targetAnimation, int rzkey);

PluginCopyKeyColorAllFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginCopyKeyColorAllFramesNameD(
 const char* sourceAnimation, const char* targetAnimation, double rzkey);

// Class Plugin
double result = ChromaAnimationAPI::CopyKeyColorAllFramesNameD(
 const char* sourceAnimation, const char* targetAnimation, double rzkey);

PluginCopyKeyColorAllFramesOffset

Copy animation key color from the source animation to the target animation for all frames, starting at the offset for the length of the source animation. Source and target are referenced by id.

// DLL Interface
EXPORT_API void PluginCopyKeyColorAllFramesOffset(
 int sourceAnimationId, int targetAnimationId, int rzkey, int offset);

// Class Plugin
ChromaAnimationAPI::CopyKeyColorAllFramesOffset(
 int sourceAnimationId, int targetAnimationId, int rzkey, int offset);

PluginCopyKeyColorAllFramesOffsetName

Copy animation key color from the source animation to the target animation for all frames, starting at the offset for the length of the source animation. Source and target are referenced by name.

// DLL Interface
EXPORT_API void PluginCopyKeyColorAllFramesOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int rzkey, int offset);

// Class Plugin
ChromaAnimationAPI::CopyKeyColorAllFramesOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int rzkey, int offset);

PluginCopyKeyColorAllFramesOffsetNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginCopyKeyColorAllFramesOffsetNameD(
 const char* sourceAnimation, const char* targetAnimation, double rzkey, double offset);

// Class Plugin
double result = ChromaAnimationAPI::CopyKeyColorAllFramesOffsetNameD(
 const char* sourceAnimation, const char* targetAnimation, double rzkey, double offset);

PluginCopyKeyColorName

Copy animation key color from the source animation to the target animation for the given frame.

// DLL Interface
EXPORT_API void PluginCopyKeyColorName(
 const char* sourceAnimation, const char* targetAnimation, int frameId, int rzkey);

// Class Plugin
ChromaAnimationAPI::CopyKeyColorName(
 const char* sourceAnimation, const char* targetAnimation, int frameId, int rzkey);

PluginCopyKeyColorNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginCopyKeyColorNameD(
 const char* sourceAnimation, const char* targetAnimation, double frameId,
 double rzkey);

// Class Plugin
double result = ChromaAnimationAPI::CopyKeyColorNameD(
 const char* sourceAnimation, const char* targetAnimation, double frameId,
 double rzkey);

PluginCopyKeysColor

Copy animation color for a set of keys from the source animation to the target animation for the given frame. Reference the source and target by id.

// DLL Interface
EXPORT_API void PluginCopyKeysColor(
 int sourceAnimationId, int targetAnimationId, int frameId, const int* keys,
 int size);

// Class Plugin
ChromaAnimationAPI::CopyKeysColor(
 int sourceAnimationId, int targetAnimationId, int frameId, const int* keys,
 int size);

PluginCopyKeysColorAllFrames

Copy animation color for a set of keys from the source animation to the target animation for all frames. Reference the source and target by id.

// DLL Interface
EXPORT_API void PluginCopyKeysColorAllFrames(
 int sourceAnimationId, int targetAnimationId, const int* keys, int size);

// Class Plugin
ChromaAnimationAPI::CopyKeysColorAllFrames(
 int sourceAnimationId, int targetAnimationId, const int* keys, int size);

PluginCopyKeysColorAllFramesName

Copy animation color for a set of keys from the source animation to the target animation for all frames. Reference the source and target by name.

// DLL Interface
EXPORT_API void PluginCopyKeysColorAllFramesName(
 const char* sourceAnimation, const char* targetAnimation, const int* keys,
 int size);

// Class Plugin
ChromaAnimationAPI::CopyKeysColorAllFramesName(
 const char* sourceAnimation, const char* targetAnimation, const int* keys,
 int size);

PluginCopyKeysColorName

Copy animation color for a set of keys from the source animation to the target animation for the given frame. Reference the source and target by name.

// DLL Interface
EXPORT_API void PluginCopyKeysColorName(
 const char* sourceAnimation, const char* targetAnimation, int frameId, const int* keys,
 int size);

// Class Plugin
ChromaAnimationAPI::CopyKeysColorName(
 const char* sourceAnimation, const char* targetAnimation, int frameId, const int* keys,
 int size);

PluginCopyKeysColorOffset

Copy animation color for a set of keys from the source animation to the target animation from the source frame to the target frame. Reference the source and target by id.

// DLL Interface
EXPORT_API void PluginCopyKeysColorOffset(
 int sourceAnimationId, int targetAnimationId, int sourceFrameId, int targetFrameId,
 const int* keys, int size);

// Class Plugin
ChromaAnimationAPI::CopyKeysColorOffset(
 int sourceAnimationId, int targetAnimationId, int sourceFrameId, int targetFrameId,
 const int* keys, int size);

PluginCopyKeysColorOffsetName

Copy animation color for a set of keys from the source animation to the target animation from the source frame to the target frame. Reference the source and target by name.

// DLL Interface
EXPORT_API void PluginCopyKeysColorOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int sourceFrameId,
 int targetFrameId, const int* keys, int size);

// Class Plugin
ChromaAnimationAPI::CopyKeysColorOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int sourceFrameId,
 int targetFrameId, const int* keys, int size);

PluginCopyNonZeroAllKeys

Copy source animation to target animation for the given frame. Source and target are referenced by id.

// DLL Interface
EXPORT_API void PluginCopyNonZeroAllKeys(
 int sourceAnimationId, int targetAnimationId, int frameId);

// Class Plugin
ChromaAnimationAPI::CopyNonZeroAllKeys(
 int sourceAnimationId, int targetAnimationId, int frameId);

PluginCopyNonZeroAllKeysAllFrames

Copy nonzero colors from a source animation to a target animation for all frames. Reference source and target by id.

// DLL Interface
EXPORT_API void PluginCopyNonZeroAllKeysAllFrames(
 int sourceAnimationId, int targetAnimationId);

// Class Plugin
ChromaAnimationAPI::CopyNonZeroAllKeysAllFrames(
 int sourceAnimationId, int targetAnimationId);

PluginCopyNonZeroAllKeysAllFramesName

Copy nonzero colors from a source animation to a target animation for all frames. Reference source and target by name.

// DLL Interface
EXPORT_API void PluginCopyNonZeroAllKeysAllFramesName(
 const char* sourceAnimation, const char* targetAnimation);

// Class Plugin
ChromaAnimationAPI::CopyNonZeroAllKeysAllFramesName(
 const char* sourceAnimation, const char* targetAnimation);

PluginCopyNonZeroAllKeysAllFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginCopyNonZeroAllKeysAllFramesNameD(
 const char* sourceAnimation, const char* targetAnimation);

// Class Plugin
double result = ChromaAnimationAPI::CopyNonZeroAllKeysAllFramesNameD(
 const char* sourceAnimation, const char* targetAnimation);

PluginCopyNonZeroAllKeysAllFramesOffset

Copy nonzero colors from a source animation to a target animation for all frames starting at the offset for the length of the source animation. The source and target are referenced by id.

// DLL Interface
EXPORT_API void PluginCopyNonZeroAllKeysAllFramesOffset(
 int sourceAnimationId, int targetAnimationId, int offset);

// Class Plugin
ChromaAnimationAPI::CopyNonZeroAllKeysAllFramesOffset(
 int sourceAnimationId, int targetAnimationId, int offset);

PluginCopyNonZeroAllKeysAllFramesOffsetName

Copy nonzero colors from a source animation to a target animation for all frames starting at the offset for the length of the source animation. The source and target are referenced by name.

// DLL Interface
EXPORT_API void PluginCopyNonZeroAllKeysAllFramesOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int offset);

// Class Plugin
ChromaAnimationAPI::CopyNonZeroAllKeysAllFramesOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int offset);

PluginCopyNonZeroAllKeysAllFramesOffsetNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginCopyNonZeroAllKeysAllFramesOffsetNameD(
 const char* sourceAnimation, const char* targetAnimation, double offset);

// Class Plugin
double result = ChromaAnimationAPI::CopyNonZeroAllKeysAllFramesOffsetNameD(
 const char* sourceAnimation, const char* targetAnimation, double offset);

PluginCopyNonZeroAllKeysName

Copy nonzero colors from source animation to target animation for the specified frame. Source and target are referenced by id.

// DLL Interface
EXPORT_API void PluginCopyNonZeroAllKeysName(
 const char* sourceAnimation, const char* targetAnimation, int frameId);

// Class Plugin
ChromaAnimationAPI::CopyNonZeroAllKeysName(
 const char* sourceAnimation, const char* targetAnimation, int frameId);

PluginCopyNonZeroAllKeysNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginCopyNonZeroAllKeysNameD(
 const char* sourceAnimation, const char* targetAnimation, double frameId);

// Class Plugin
double result = ChromaAnimationAPI::CopyNonZeroAllKeysNameD(
 const char* sourceAnimation, const char* targetAnimation, double frameId);

PluginCopyNonZeroAllKeysOffset

Copy nonzero colors from the source animation to the target animation from the source frame to the target offset frame. Source and target are referenced by id.

// DLL Interface
EXPORT_API void PluginCopyNonZeroAllKeysOffset(
 int sourceAnimationId, int targetAnimationId, int frameId, int offset);

// Class Plugin
ChromaAnimationAPI::CopyNonZeroAllKeysOffset(
 int sourceAnimationId, int targetAnimationId, int frameId, int offset);

PluginCopyNonZeroAllKeysOffsetName

Copy nonzero colors from the source animation to the target animation from the source frame to the target offset frame. Source and target are referenced by name.

// DLL Interface
EXPORT_API void PluginCopyNonZeroAllKeysOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int frameId, int offset);

// Class Plugin
ChromaAnimationAPI::CopyNonZeroAllKeysOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int frameId, int offset);

PluginCopyNonZeroAllKeysOffsetNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginCopyNonZeroAllKeysOffsetNameD(
 const char* sourceAnimation, const char* targetAnimation, double frameId,
 double offset);

// Class Plugin
double result = ChromaAnimationAPI::CopyNonZeroAllKeysOffsetNameD(
 const char* sourceAnimation, const char* targetAnimation, double frameId,
 double offset);

PluginCopyNonZeroKeyColor

Copy animation key color from the source animation to the target animation for the given frame where color is not zero.

// DLL Interface
EXPORT_API void PluginCopyNonZeroKeyColor(
 int sourceAnimationId, int targetAnimationId, int frameId, int rzkey);

// Class Plugin
ChromaAnimationAPI::CopyNonZeroKeyColor(
 int sourceAnimationId, int targetAnimationId, int frameId, int rzkey);

PluginCopyNonZeroKeyColorName

Copy animation key color from the source animation to the target animation for the given frame where color is not zero.

// DLL Interface
EXPORT_API void PluginCopyNonZeroKeyColorName(
 const char* sourceAnimation, const char* targetAnimation, int frameId, int rzkey);

// Class Plugin
ChromaAnimationAPI::CopyNonZeroKeyColorName(
 const char* sourceAnimation, const char* targetAnimation, int frameId, int rzkey);

PluginCopyNonZeroKeyColorNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginCopyNonZeroKeyColorNameD(
 const char* sourceAnimation, const char* targetAnimation, double frameId,
 double rzkey);

// Class Plugin
double result = ChromaAnimationAPI::CopyNonZeroKeyColorNameD(
 const char* sourceAnimation, const char* targetAnimation, double frameId,
 double rzkey);

PluginCopyNonZeroTargetAllKeys

Copy nonzero colors from the source animation to the target animation where the target color is nonzero for the specified frame. Source and target are referenced by id.

// DLL Interface
EXPORT_API void PluginCopyNonZeroTargetAllKeys(
 int sourceAnimationId, int targetAnimationId, int frameId);

// Class Plugin
ChromaAnimationAPI::CopyNonZeroTargetAllKeys(
 int sourceAnimationId, int targetAnimationId, int frameId);

PluginCopyNonZeroTargetAllKeysAllFrames

Copy nonzero colors from the source animation to the target animation where the target color is nonzero for all frames. Source and target are referenced by id.

// DLL Interface
EXPORT_API void PluginCopyNonZeroTargetAllKeysAllFrames(
 int sourceAnimationId, int targetAnimationId);

// Class Plugin
ChromaAnimationAPI::CopyNonZeroTargetAllKeysAllFrames(
 int sourceAnimationId, int targetAnimationId);

PluginCopyNonZeroTargetAllKeysAllFramesName

Copy nonzero colors from the source animation to the target animation where the target color is nonzero for all frames. Source and target are referenced by name.

// DLL Interface
EXPORT_API void PluginCopyNonZeroTargetAllKeysAllFramesName(
 const char* sourceAnimation, const char* targetAnimation);

// Class Plugin
ChromaAnimationAPI::CopyNonZeroTargetAllKeysAllFramesName(
 const char* sourceAnimation, const char* targetAnimation);

PluginCopyNonZeroTargetAllKeysAllFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginCopyNonZeroTargetAllKeysAllFramesNameD(
 const char* sourceAnimation, const char* targetAnimation);

// Class Plugin
double result = ChromaAnimationAPI::CopyNonZeroTargetAllKeysAllFramesNameD(
 const char* sourceAnimation, const char* targetAnimation);

PluginCopyNonZeroTargetAllKeysAllFramesOffset

Copy nonzero colors from the source animation to the target animation where the target color is nonzero for all frames. Source and target are referenced by name.

// DLL Interface
EXPORT_API void PluginCopyNonZeroTargetAllKeysAllFramesOffset(
 int sourceAnimationId, int targetAnimationId, int offset);

// Class Plugin
ChromaAnimationAPI::CopyNonZeroTargetAllKeysAllFramesOffset(
 int sourceAnimationId, int targetAnimationId, int offset);

PluginCopyNonZeroTargetAllKeysAllFramesOffsetName

Copy nonzero colors from the source animation to the target animation where the target color is nonzero for all frames starting at the target offset for the length of the source animation. Source and target animations are referenced by name.

// DLL Interface
EXPORT_API void PluginCopyNonZeroTargetAllKeysAllFramesOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int offset);

// Class Plugin
ChromaAnimationAPI::CopyNonZeroTargetAllKeysAllFramesOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int offset);

PluginCopyNonZeroTargetAllKeysAllFramesOffsetNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginCopyNonZeroTargetAllKeysAllFramesOffsetNameD(
 const char* sourceAnimation, const char* targetAnimation, double offset);

// Class Plugin
double result = ChromaAnimationAPI::CopyNonZeroTargetAllKeysAllFramesOffsetNameD(
 const char* sourceAnimation, const char* targetAnimation, double offset);

PluginCopyNonZeroTargetAllKeysName

Copy nonzero colors from the source animation to the target animation where the target color is nonzero for the specified frame. The source and target are referenced by name.

// DLL Interface
EXPORT_API void PluginCopyNonZeroTargetAllKeysName(
 const char* sourceAnimation, const char* targetAnimation, int frameId);

// Class Plugin
ChromaAnimationAPI::CopyNonZeroTargetAllKeysName(
 const char* sourceAnimation, const char* targetAnimation, int frameId);

PluginCopyNonZeroTargetAllKeysNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginCopyNonZeroTargetAllKeysNameD(
 const char* sourceAnimation, const char* targetAnimation, double frameId);

// Class Plugin
double result = ChromaAnimationAPI::CopyNonZeroTargetAllKeysNameD(
 const char* sourceAnimation, const char* targetAnimation, double frameId);

PluginCopyNonZeroTargetAllKeysOffset

Copy nonzero colors from the source animation to the target animation where the target color is nonzero for the specified source frame and target offset frame. The source and target are referenced by id.

// DLL Interface
EXPORT_API void PluginCopyNonZeroTargetAllKeysOffset(
 int sourceAnimationId, int targetAnimationId, int frameId, int offset);

// Class Plugin
ChromaAnimationAPI::CopyNonZeroTargetAllKeysOffset(
 int sourceAnimationId, int targetAnimationId, int frameId, int offset);

PluginCopyNonZeroTargetAllKeysOffsetName

Copy nonzero colors from the source animation to the target animation where the target color is nonzero for the specified source frame and target offset frame. The source and target are referenced by name.

// DLL Interface
EXPORT_API void PluginCopyNonZeroTargetAllKeysOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int frameId, int offset);

// Class Plugin
ChromaAnimationAPI::CopyNonZeroTargetAllKeysOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int frameId, int offset);

PluginCopyNonZeroTargetAllKeysOffsetNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginCopyNonZeroTargetAllKeysOffsetNameD(
 const char* sourceAnimation, const char* targetAnimation, double frameId,
 double offset);

// Class Plugin
double result = ChromaAnimationAPI::CopyNonZeroTargetAllKeysOffsetNameD(
 const char* sourceAnimation, const char* targetAnimation, double frameId,
 double offset);

PluginCopyNonZeroTargetZeroAllKeysAllFrames

Copy nonzero colors from the source animation to the target animation where the target color is zero for all frames. Source and target are referenced by id.

// DLL Interface
EXPORT_API void PluginCopyNonZeroTargetZeroAllKeysAllFrames(
 int sourceAnimationId, int targetAnimationId);

// Class Plugin
ChromaAnimationAPI::CopyNonZeroTargetZeroAllKeysAllFrames(
 int sourceAnimationId, int targetAnimationId);

PluginCopyNonZeroTargetZeroAllKeysAllFramesName

Copy nonzero colors from the source animation to the target animation where the target color is zero for all frames. Source and target are referenced by name.

// DLL Interface
EXPORT_API void PluginCopyNonZeroTargetZeroAllKeysAllFramesName(
 const char* sourceAnimation, const char* targetAnimation);

// Class Plugin
ChromaAnimationAPI::CopyNonZeroTargetZeroAllKeysAllFramesName(
 const char* sourceAnimation, const char* targetAnimation);

PluginCopyNonZeroTargetZeroAllKeysAllFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginCopyNonZeroTargetZeroAllKeysAllFramesNameD(
 const char* sourceAnimation, const char* targetAnimation);

// Class Plugin
double result = ChromaAnimationAPI::CopyNonZeroTargetZeroAllKeysAllFramesNameD(
 const char* sourceAnimation, const char* targetAnimation);

PluginCopyRedChannelAllFrames

Copy red channel to other channels for all frames. Intensity range is 0.0 to 1.0. Reference the animation by id.

// DLL Interface
EXPORT_API void PluginCopyRedChannelAllFrames(
 int animationId, float greenIntensity, float blueIntensity);

// Class Plugin
ChromaAnimationAPI::CopyRedChannelAllFrames(
 int animationId, float greenIntensity, float blueIntensity);

PluginCopyRedChannelAllFramesName

Copy green channel to other channels for all frames. Intensity range is 0.0 to 1.0. Reference the animation by name.

// DLL Interface
EXPORT_API void PluginCopyRedChannelAllFramesName(
 const char* path, float greenIntensity, float blueIntensity);

// Class Plugin
ChromaAnimationAPI::CopyRedChannelAllFramesName(
 const char* path, float greenIntensity, float blueIntensity);

PluginCopyRedChannelAllFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginCopyRedChannelAllFramesNameD(
 const char* path, double greenIntensity, double blueIntensity);

// Class Plugin
double result = ChromaAnimationAPI::CopyRedChannelAllFramesNameD(
 const char* path, double greenIntensity, double blueIntensity);

PluginCopyZeroAllKeys

Copy zero colors from source animation to target animation for the frame. Source and target are referenced by id.

// DLL Interface
EXPORT_API void PluginCopyZeroAllKeys(
 int sourceAnimationId, int targetAnimationId, int frameId);

// Class Plugin
ChromaAnimationAPI::CopyZeroAllKeys(
 int sourceAnimationId, int targetAnimationId, int frameId);

PluginCopyZeroAllKeysAllFrames

Copy zero colors from source animation to target animation for all frames. Source and target are referenced by id.

// DLL Interface
EXPORT_API void PluginCopyZeroAllKeysAllFrames(
 int sourceAnimationId, int targetAnimationId);

// Class Plugin
ChromaAnimationAPI::CopyZeroAllKeysAllFrames(
 int sourceAnimationId, int targetAnimationId);

PluginCopyZeroAllKeysAllFramesName

Copy zero colors from source animation to target animation for all frames. Source and target are referenced by name.

// DLL Interface
EXPORT_API void PluginCopyZeroAllKeysAllFramesName(
 const char* sourceAnimation, const char* targetAnimation);

// Class Plugin
ChromaAnimationAPI::CopyZeroAllKeysAllFramesName(
 const char* sourceAnimation, const char* targetAnimation);

PluginCopyZeroAllKeysAllFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginCopyZeroAllKeysAllFramesNameD(
 const char* sourceAnimation, const char* targetAnimation);

// Class Plugin
double result = ChromaAnimationAPI::CopyZeroAllKeysAllFramesNameD(
 const char* sourceAnimation, const char* targetAnimation);

PluginCopyZeroAllKeysAllFramesOffset

Copy zero colors from source animation to target animation for all frames starting at the target offset for the length of the source animation. Source and target are referenced by id.

// DLL Interface
EXPORT_API void PluginCopyZeroAllKeysAllFramesOffset(
 int sourceAnimationId, int targetAnimationId, int offset);

// Class Plugin
ChromaAnimationAPI::CopyZeroAllKeysAllFramesOffset(
 int sourceAnimationId, int targetAnimationId, int offset);

PluginCopyZeroAllKeysAllFramesOffsetName

Copy zero colors from source animation to target animation for all frames starting at the target offset for the length of the source animation. Source and target are referenced by name.

// DLL Interface
EXPORT_API void PluginCopyZeroAllKeysAllFramesOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int offset);

// Class Plugin
ChromaAnimationAPI::CopyZeroAllKeysAllFramesOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int offset);

PluginCopyZeroAllKeysAllFramesOffsetNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginCopyZeroAllKeysAllFramesOffsetNameD(
 const char* sourceAnimation, const char* targetAnimation, double offset);

// Class Plugin
double result = ChromaAnimationAPI::CopyZeroAllKeysAllFramesOffsetNameD(
 const char* sourceAnimation, const char* targetAnimation, double offset);

PluginCopyZeroAllKeysName

Copy zero colors from source animation to target animation for the frame. Source and target are referenced by name.

// DLL Interface
EXPORT_API void PluginCopyZeroAllKeysName(
 const char* sourceAnimation, const char* targetAnimation, int frameId);

// Class Plugin
ChromaAnimationAPI::CopyZeroAllKeysName(
 const char* sourceAnimation, const char* targetAnimation, int frameId);

PluginCopyZeroAllKeysOffset

Copy zero colors from source animation to target animation for the frame id starting at the target offset for the length of the source animation. Source and target are referenced by id.

// DLL Interface
EXPORT_API void PluginCopyZeroAllKeysOffset(
 int sourceAnimationId, int targetAnimationId, int frameId, int offset);

// Class Plugin
ChromaAnimationAPI::CopyZeroAllKeysOffset(
 int sourceAnimationId, int targetAnimationId, int frameId, int offset);

PluginCopyZeroAllKeysOffsetName

Copy zero colors from source animation to target animation for the frame id starting at the target offset for the length of the source animation. Source and target are referenced by name.

// DLL Interface
EXPORT_API void PluginCopyZeroAllKeysOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int frameId, int offset);

// Class Plugin
ChromaAnimationAPI::CopyZeroAllKeysOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int frameId, int offset);

PluginCopyZeroKeyColor

Copy zero key color from source animation to target animation for the specified frame. Source and target are referenced by id.

// DLL Interface
EXPORT_API void PluginCopyZeroKeyColor(
 int sourceAnimationId, int targetAnimationId, int frameId, int rzkey);

// Class Plugin
ChromaAnimationAPI::CopyZeroKeyColor(
 int sourceAnimationId, int targetAnimationId, int frameId, int rzkey);

PluginCopyZeroKeyColorName

Copy zero key color from source animation to target animation for the specified frame. Source and target are referenced by name.

// DLL Interface
EXPORT_API void PluginCopyZeroKeyColorName(
 const char* sourceAnimation, const char* targetAnimation, int frameId, int rzkey);

// Class Plugin
ChromaAnimationAPI::CopyZeroKeyColorName(
 const char* sourceAnimation, const char* targetAnimation, int frameId, int rzkey);

PluginCopyZeroKeyColorNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginCopyZeroKeyColorNameD(
 const char* sourceAnimation, const char* targetAnimation, double frameId,
 double rzkey);

// Class Plugin
double result = ChromaAnimationAPI::CopyZeroKeyColorNameD(
 const char* sourceAnimation, const char* targetAnimation, double frameId,
 double rzkey);

PluginCopyZeroTargetAllKeys

Copy nonzero color from source animation to target animation where target is zero for the frame. Source and target are referenced by id.

// DLL Interface
EXPORT_API void PluginCopyZeroTargetAllKeys(
 int sourceAnimationId, int targetAnimationId, int frameId);

// Class Plugin
ChromaAnimationAPI::CopyZeroTargetAllKeys(
 int sourceAnimationId, int targetAnimationId, int frameId);

PluginCopyZeroTargetAllKeysAllFrames

Copy nonzero color from source animation to target animation where target is zero for all frames. Source and target are referenced by id.

// DLL Interface
EXPORT_API void PluginCopyZeroTargetAllKeysAllFrames(
 int sourceAnimationId, int targetAnimationId);

// Class Plugin
ChromaAnimationAPI::CopyZeroTargetAllKeysAllFrames(
 int sourceAnimationId, int targetAnimationId);

PluginCopyZeroTargetAllKeysAllFramesName

Copy nonzero color from source animation to target animation where target is zero for all frames. Source and target are referenced by name.

// DLL Interface
EXPORT_API void PluginCopyZeroTargetAllKeysAllFramesName(
 const char* sourceAnimation, const char* targetAnimation);

// Class Plugin
ChromaAnimationAPI::CopyZeroTargetAllKeysAllFramesName(
 const char* sourceAnimation, const char* targetAnimation);

PluginCopyZeroTargetAllKeysAllFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginCopyZeroTargetAllKeysAllFramesNameD(
 const char* sourceAnimation, const char* targetAnimation);

// Class Plugin
double result = ChromaAnimationAPI::CopyZeroTargetAllKeysAllFramesNameD(
 const char* sourceAnimation, const char* targetAnimation);

PluginCopyZeroTargetAllKeysName

Copy nonzero color from source animation to target animation where target is zero for the frame. Source and target are referenced by name.

// DLL Interface
EXPORT_API void PluginCopyZeroTargetAllKeysName(
 const char* sourceAnimation, const char* targetAnimation, int frameId);

// Class Plugin
ChromaAnimationAPI::CopyZeroTargetAllKeysName(
 const char* sourceAnimation, const char* targetAnimation, int frameId);

PluginCoreCreateChromaLinkEffect

Direct access to low level API.

// DLL Interface
EXPORT_API RZRESULT PluginCoreCreateChromaLinkEffect(
 ChromaSDK::ChromaLink::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID* pEffectId);

// Class Plugin
RZRESULT result = ChromaAnimationAPI::CoreCreateChromaLinkEffect(
 ChromaSDK::ChromaLink::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID* pEffectId);

PluginCoreCreateEffect

Direct access to low level API.

// DLL Interface
EXPORT_API RZRESULT PluginCoreCreateEffect(
 RZDEVICEID DeviceId, ChromaSDK::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID* pEffectId);

// Class Plugin
RZRESULT result = ChromaAnimationAPI::CoreCreateEffect(
 RZDEVICEID DeviceId, ChromaSDK::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID* pEffectId);

PluginCoreCreateHeadsetEffect

Direct access to low level API.

// DLL Interface
EXPORT_API RZRESULT PluginCoreCreateHeadsetEffect(
 ChromaSDK::Headset::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID* pEffectId);

// Class Plugin
RZRESULT result = ChromaAnimationAPI::CoreCreateHeadsetEffect(
 ChromaSDK::Headset::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID* pEffectId);

PluginCoreCreateKeyboardEffect

Direct access to low level API.

// DLL Interface
EXPORT_API RZRESULT PluginCoreCreateKeyboardEffect(
 ChromaSDK::Keyboard::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID* pEffectId);

// Class Plugin
RZRESULT result = ChromaAnimationAPI::CoreCreateKeyboardEffect(
 ChromaSDK::Keyboard::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID* pEffectId);

PluginCoreCreateKeypadEffect

Direct access to low level API.

// DLL Interface
EXPORT_API RZRESULT PluginCoreCreateKeypadEffect(
 ChromaSDK::Keypad::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID* pEffectId);

// Class Plugin
RZRESULT result = ChromaAnimationAPI::CoreCreateKeypadEffect(
 ChromaSDK::Keypad::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID* pEffectId);

PluginCoreCreateMouseEffect

Direct access to low level API.

// DLL Interface
EXPORT_API RZRESULT PluginCoreCreateMouseEffect(
 ChromaSDK::Mouse::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID* pEffectId);

// Class Plugin
RZRESULT result = ChromaAnimationAPI::CoreCreateMouseEffect(
 ChromaSDK::Mouse::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID* pEffectId);

PluginCoreCreateMousepadEffect

Direct access to low level API.

// DLL Interface
EXPORT_API RZRESULT PluginCoreCreateMousepadEffect(
 ChromaSDK::Mousepad::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID* pEffectId);

// Class Plugin
RZRESULT result = ChromaAnimationAPI::CoreCreateMousepadEffect(
 ChromaSDK::Mousepad::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID* pEffectId);

PluginCoreDeleteEffect

Direct access to low level API.

// DLL Interface
EXPORT_API RZRESULT PluginCoreDeleteEffect(RZEFFECTID EffectId);

// Class Plugin
RZRESULT result = ChromaAnimationAPI::CoreDeleteEffect(RZEFFECTID EffectId);

PluginCoreInit

Direct access to low level API.

// DLL Interface
EXPORT_API RZRESULT PluginCoreInit();

// Class Plugin
RZRESULT result = ChromaAnimationAPI::CoreInit();

PluginCoreInitSDK

Direct access to low level API.

// DLL Interface
EXPORT_API RZRESULT PluginCoreInitSDK(
 ChromaSDK::APPINFOTYPE* AppInfo);

// Class Plugin
RZRESULT result = ChromaAnimationAPI::CoreInitSDK(
 ChromaSDK::APPINFOTYPE* AppInfo);

PluginCoreQueryDevice

Direct access to low level API.

// DLL Interface
EXPORT_API RZRESULT PluginCoreQueryDevice(
 RZDEVICEID DeviceId, ChromaSDK::DEVICE_INFO_TYPE& DeviceInfo);

// Class Plugin
RZRESULT result = ChromaAnimationAPI::CoreQueryDevice(
 RZDEVICEID DeviceId, ChromaSDK::DEVICE_INFO_TYPE& DeviceInfo);

PluginCoreSetEffect

Direct access to low level API.

// DLL Interface
EXPORT_API RZRESULT PluginCoreSetEffect(RZEFFECTID EffectId);

// Class Plugin
RZRESULT result = ChromaAnimationAPI::CoreSetEffect(RZEFFECTID EffectId);

PluginCoreStreamBroadcast

Begin broadcasting Chroma RGB data using the stored stream key as the endpoint. Intended for Cloud Gaming Platforms, restore the streaming key when the game instance is launched to continue streaming. streamId is a null terminated string streamKey is a null terminated string StreamGetStatus() should return the READY status to use this method.

// DLL Interface
EXPORT_API bool PluginCoreStreamBroadcast(
 const char* streamId, const char* streamKey);

// Class Plugin
bool result = ChromaAnimationAPI::CoreStreamBroadcast(
 const char* streamId, const char* streamKey);

PluginCoreStreamBroadcastEnd

End broadcasting Chroma RGB data. StreamGetStatus() should return the BROADCASTING status to use this method.

// DLL Interface
EXPORT_API bool PluginCoreStreamBroadcastEnd();

// Class Plugin
bool result = ChromaAnimationAPI::CoreStreamBroadcastEnd();

PluginCoreStreamGetAuthShortcode

shortcode: Pass the address of a preallocated character buffer to get the streaming auth code. The buffer should have a minimum length of 6. length: Length will return as zero if the streaming auth code could not be obtained. If length is greater than zero, it will be the length of the returned streaming auth code. Once you have the shortcode, it should be shown to the user so they can associate the stream with their Razer ID StreamGetStatus() should return the READY status before invoking this method. platform: is the null terminated string that identifies the source of the stream: { GEFORCE_NOW, LUNA, STADIA, GAME_PASS } title: is the null terminated string that identifies the application or game.

// DLL Interface
EXPORT_API void PluginCoreStreamGetAuthShortcode(
 char* shortcode, unsigned char* length, const wchar_t* platform, const wchar_t* title);

// Class Plugin
ChromaAnimationAPI::CoreStreamGetAuthShortcode(
 char* shortcode, unsigned char* length, const wchar_t* platform, const wchar_t* title);

PluginCoreStreamGetFocus

focus: Pass the address of a preallocated character buffer to get the stream focus. The buffer should have a length of 48 length: Length will return as zero if the stream focus could not be obtained. If length is greater than zero, it will be the length of the returned stream focus.

// DLL Interface
EXPORT_API bool PluginCoreStreamGetFocus(
 char* focus, unsigned char* length);

// Class Plugin
bool result = ChromaAnimationAPI::CoreStreamGetFocus(
 char* focus, unsigned char* length);

PluginCoreStreamGetId

Intended for Cloud Gaming Platforms, store the stream id to persist in user preferences to continue streaming if the game is suspended or closed. shortcode: The shortcode is a null terminated string. Use the shortcode that authorized the stream to obtain the stream id. streamId should be a preallocated buffer to get the stream key. The buffer should have a length of 48. length: Length will return zero if the key could not be obtained. If the length is greater than zero, it will be the length of the returned streaming id. Retrieve the stream id after authorizing the shortcode. The authorization window will expire in 5 minutes. Be sure to save the stream key before the window expires. StreamGetStatus() should return the READY status to use this method.

// DLL Interface
EXPORT_API void PluginCoreStreamGetId(
 const char* shortcode, char* streamId, unsigned char* length);

// Class Plugin
ChromaAnimationAPI::CoreStreamGetId(
 const char* shortcode, char* streamId, unsigned char* length);

PluginCoreStreamGetKey

Intended for Cloud Gaming Platforms, store the streaming key to persist in user preferences to continue streaming if the game is suspended or closed. shortcode: The shortcode is a null terminated string. Use the shortcode that authorized the stream to obtain the stream key. If the status is in the BROADCASTING or WATCHING state, passing a NULL shortcode will return the active streamId. streamKey should be a preallocated buffer to get the stream key. The buffer should have a length of 48. length: Length will return zero if the key could not be obtained. If the length is greater than zero, it will be the length of the returned streaming key. Retrieve the stream key after authorizing the shortcode. The authorization window will expire in 5 minutes. Be sure to save the stream key before the window expires. StreamGetStatus() should return the READY status to use this method.

// DLL Interface
EXPORT_API void PluginCoreStreamGetKey(
 const char* shortcode, char* streamKey, unsigned char* length);

// Class Plugin
ChromaAnimationAPI::CoreStreamGetKey(
 const char* shortcode, char* streamKey, unsigned char* length);

PluginCoreStreamGetStatus

Returns StreamStatus, the current status of the service

// DLL Interface
EXPORT_API ChromaSDK::Stream::StreamStatusType PluginCoreStreamGetStatus();

// Class Plugin
ChromaSDK::Stream::StreamStatusType result = ChromaAnimationAPI::CoreStreamGetStatus();

PluginCoreStreamGetStatusString

Convert StreamStatusType to a printable string

// DLL Interface
EXPORT_API const char* PluginCoreStreamGetStatusString(
 ChromaSDK::Stream::StreamStatusType status);

// Class Plugin
const char* result = ChromaAnimationAPI::CoreStreamGetStatusString(
 ChromaSDK::Stream::StreamStatusType status);

PluginCoreStreamReleaseShortcode

This prevents the stream id and stream key from being obtained through the shortcode. This closes the auth window. shortcode is a null terminated string. StreamGetStatus() should return the READY status to use this method. returns success when shortcode has been released

// DLL Interface
EXPORT_API bool PluginCoreStreamReleaseShortcode(
 const char* shortcode);

// Class Plugin
bool result = ChromaAnimationAPI::CoreStreamReleaseShortcode(
 const char* shortcode);

PluginCoreStreamSetFocus

The focus is a null terminated string. Set the focus identifer for the application designated to automatically change the streaming state. Returns true on success.

// DLL Interface
EXPORT_API bool PluginCoreStreamSetFocus(const char* focus);

// Class Plugin
bool result = ChromaAnimationAPI::CoreStreamSetFocus(const char* focus);

PluginCoreStreamSupportsStreaming

Returns true if the Chroma streaming is supported. If false is returned, avoid calling stream methods.

// DLL Interface
EXPORT_API bool PluginCoreStreamSupportsStreaming();

// Class Plugin
bool result = ChromaAnimationAPI::CoreStreamSupportsStreaming();

PluginCoreStreamWatch

Begin watching the Chroma RGB data using streamID parameter. streamId is a null terminated string. StreamGetStatus() should return the READY status to use this method.

// DLL Interface
EXPORT_API bool PluginCoreStreamWatch(
 const char* streamId, unsigned long long timestamp);

// Class Plugin
bool result = ChromaAnimationAPI::CoreStreamWatch(
 const char* streamId, unsigned long long timestamp);

PluginCoreStreamWatchEnd

End watching Chroma RGB data stream. StreamGetStatus() should return the WATCHING status to use this method.

// DLL Interface
EXPORT_API bool PluginCoreStreamWatchEnd();

// Class Plugin
bool result = ChromaAnimationAPI::CoreStreamWatchEnd();

PluginCoreUnInit

Direct access to low level API.

// DLL Interface
EXPORT_API RZRESULT PluginCoreUnInit();

// Class Plugin
RZRESULT result = ChromaAnimationAPI::CoreUnInit();

PluginCreateAnimation

Creates a Chroma animation at the given path. The deviceType parameter uses EChromaSDKDeviceTypeEnum as an integer. The device parameter uses EChromaSDKDevice1DEnum or EChromaSDKDevice2DEnum as an integer, respective to the deviceType. Returns the animation id upon success. Returns negative one upon failure. Saves a Chroma animation file with the .chroma extension at the given path. Returns the animation id upon success. Returns negative one upon failure.

// DLL Interface
EXPORT_API int PluginCreateAnimation(
 const char* path, int deviceType, int device);

// Class Plugin
int result = ChromaAnimationAPI::CreateAnimation(
 const char* path, int deviceType, int device);

PluginCreateAnimationInMemory

Creates a Chroma animation in memory without creating a file. The deviceType parameter uses EChromaSDKDeviceTypeEnum as an integer. The device parameter uses EChromaSDKDevice1DEnum or EChromaSDKDevice2DEnum as an integer, respective to the deviceType. Returns the animation id upon success. Returns negative one upon failure. Returns the animation id upon success. Returns negative one upon failure.

// DLL Interface
EXPORT_API int PluginCreateAnimationInMemory(
 int deviceType, int device);

// Class Plugin
int result = ChromaAnimationAPI::CreateAnimationInMemory(
 int deviceType, int device);

PluginCreateEffect

Create a device specific effect.

// DLL Interface
EXPORT_API RZRESULT PluginCreateEffect(
 RZDEVICEID deviceId, ChromaSDK::EFFECT_TYPE effect, int* colors, int size,
 ChromaSDK::FChromaSDKGuid* effectId);

// Class Plugin
RZRESULT result = ChromaAnimationAPI::CreateEffect(
 RZDEVICEID deviceId, ChromaSDK::EFFECT_TYPE effect, int* colors, int size,
 ChromaSDK::FChromaSDKGuid* effectId);

PluginDeleteEffect

Delete an effect given the effect id.

// DLL Interface
EXPORT_API RZRESULT PluginDeleteEffect(
 const ChromaSDK::FChromaSDKGuid& effectId);

// Class Plugin
RZRESULT result = ChromaAnimationAPI::DeleteEffect(
 const ChromaSDK::FChromaSDKGuid& effectId);

PluginDuplicateFirstFrame

Duplicate the first animation frame so that the animation length matches the frame count. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginDuplicateFirstFrame(
 int animationId, int frameCount);

// Class Plugin
ChromaAnimationAPI::DuplicateFirstFrame(
 int animationId, int frameCount);

PluginDuplicateFirstFrameName

Duplicate the first animation frame so that the animation length matches the frame count. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginDuplicateFirstFrameName(
 const char* path, int frameCount);

// Class Plugin
ChromaAnimationAPI::DuplicateFirstFrameName(
 const char* path, int frameCount);

PluginDuplicateFirstFrameNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginDuplicateFirstFrameNameD(
 const char* path, double frameCount);

// Class Plugin
double result = ChromaAnimationAPI::DuplicateFirstFrameNameD(
 const char* path, double frameCount);

PluginDuplicateFrames

Duplicate all the frames of the animation to double the animation length. Frame 1 becomes frame 1 and 2. Frame 2 becomes frame 3 and 4. And so on. The animation is referenced by id.

// DLL Interface
EXPORT_API void PluginDuplicateFrames(int animationId);

// Class Plugin
ChromaAnimationAPI::DuplicateFrames(int animationId);

PluginDuplicateFramesName

Duplicate all the frames of the animation to double the animation length. Frame 1 becomes frame 1 and 2. Frame 2 becomes frame 3 and 4. And so on. The animation is referenced by name.

// DLL Interface
EXPORT_API void PluginDuplicateFramesName(const char* path);

// Class Plugin
ChromaAnimationAPI::DuplicateFramesName(const char* path);

PluginDuplicateFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginDuplicateFramesNameD(const char* path);

// Class Plugin
double result = ChromaAnimationAPI::DuplicateFramesNameD(const char* path);

PluginDuplicateMirrorFrames

Duplicate all the animation frames in reverse so that the animation plays forwards and backwards. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginDuplicateMirrorFrames(int animationId);

// Class Plugin
ChromaAnimationAPI::DuplicateMirrorFrames(int animationId);

PluginDuplicateMirrorFramesName

Duplicate all the animation frames in reverse so that the animation plays forwards and backwards. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginDuplicateMirrorFramesName(const char* path);

// Class Plugin
ChromaAnimationAPI::DuplicateMirrorFramesName(const char* path);

PluginDuplicateMirrorFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginDuplicateMirrorFramesNameD(const char* path);

// Class Plugin
double result = ChromaAnimationAPI::DuplicateMirrorFramesNameD(const char* path);

PluginFadeEndFrames

Fade the animation to black starting at the fade frame index to the end of the animation. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginFadeEndFrames(
 int animationId, int fade);

// Class Plugin
ChromaAnimationAPI::FadeEndFrames(
 int animationId, int fade);

PluginFadeEndFramesName

Fade the animation to black starting at the fade frame index to the end of the animation. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginFadeEndFramesName(
 const char* path, int fade);

// Class Plugin
ChromaAnimationAPI::FadeEndFramesName(
 const char* path, int fade);

PluginFadeEndFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginFadeEndFramesNameD(
 const char* path, double fade);

// Class Plugin
double result = ChromaAnimationAPI::FadeEndFramesNameD(
 const char* path, double fade);

PluginFadeStartFrames

Fade the animation from black to full color starting at 0 to the fade frame index. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginFadeStartFrames(
 int animationId, int fade);

// Class Plugin
ChromaAnimationAPI::FadeStartFrames(
 int animationId, int fade);

PluginFadeStartFramesName

Fade the animation from black to full color starting at 0 to the fade frame index. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginFadeStartFramesName(
 const char* path, int fade);

// Class Plugin
ChromaAnimationAPI::FadeStartFramesName(
 const char* path, int fade);

PluginFadeStartFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginFadeStartFramesNameD(
 const char* path, double fade);

// Class Plugin
double result = ChromaAnimationAPI::FadeStartFramesNameD(
 const char* path, double fade);

PluginFillColor

Set the RGB value for all colors in the specified frame. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginFillColor(
 int animationId, int frameId, int color);

// Class Plugin
ChromaAnimationAPI::FillColor(
 int animationId, int frameId, int color);

PluginFillColorAllFrames

Set the RGB value for all colors for all frames. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginFillColorAllFrames(
 int animationId, int color);

// Class Plugin
ChromaAnimationAPI::FillColorAllFrames(
 int animationId, int color);

PluginFillColorAllFramesName

Set the RGB value for all colors for all frames. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginFillColorAllFramesName(
 const char* path, int color);

// Class Plugin
ChromaAnimationAPI::FillColorAllFramesName(
 const char* path, int color);

PluginFillColorAllFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginFillColorAllFramesNameD(
 const char* path, double color);

// Class Plugin
double result = ChromaAnimationAPI::FillColorAllFramesNameD(
 const char* path, double color);

PluginFillColorAllFramesRGB

Set the RGB value for all colors for all frames. Use the range of 0 to 255 for red, green, and blue parameters. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginFillColorAllFramesRGB(
 int animationId, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::FillColorAllFramesRGB(
 int animationId, int red, int green, int blue);

PluginFillColorAllFramesRGBName

Set the RGB value for all colors for all frames. Use the range of 0 to 255 for red, green, and blue parameters. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginFillColorAllFramesRGBName(
 const char* path, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::FillColorAllFramesRGBName(
 const char* path, int red, int green, int blue);

PluginFillColorAllFramesRGBNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginFillColorAllFramesRGBNameD(
 const char* path, double red, double green, double blue);

// Class Plugin
double result = ChromaAnimationAPI::FillColorAllFramesRGBNameD(
 const char* path, double red, double green, double blue);

PluginFillColorName

Set the RGB value for all colors in the specified frame. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginFillColorName(
 const char* path, int frameId, int color);

// Class Plugin
ChromaAnimationAPI::FillColorName(
 const char* path, int frameId, int color);

PluginFillColorNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginFillColorNameD(
 const char* path, double frameId, double color);

// Class Plugin
double result = ChromaAnimationAPI::FillColorNameD(
 const char* path, double frameId, double color);

PluginFillColorRGB

Set the RGB value for all colors in the specified frame. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginFillColorRGB(
 int animationId, int frameId, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::FillColorRGB(
 int animationId, int frameId, int red, int green, int blue);

PluginFillColorRGBName

Set the RGB value for all colors in the specified frame. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginFillColorRGBName(
 const char* path, int frameId, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::FillColorRGBName(
 const char* path, int frameId, int red, int green, int blue);

PluginFillColorRGBNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginFillColorRGBNameD(
 const char* path, double frameId, double red, double green, double blue);

// Class Plugin
double result = ChromaAnimationAPI::FillColorRGBNameD(
 const char* path, double frameId, double red, double green, double blue);

PluginFillNonZeroColor

This method will only update colors in the animation that are not already set to black. Set the RGB value for a subset of colors in the specified frame. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginFillNonZeroColor(
 int animationId, int frameId, int color);

// Class Plugin
ChromaAnimationAPI::FillNonZeroColor(
 int animationId, int frameId, int color);

PluginFillNonZeroColorAllFrames

This method will only update colors in the animation that are not already set to black. Set the RGB value for a subset of colors for all frames. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginFillNonZeroColorAllFrames(
 int animationId, int color);

// Class Plugin
ChromaAnimationAPI::FillNonZeroColorAllFrames(
 int animationId, int color);

PluginFillNonZeroColorAllFramesName

This method will only update colors in the animation that are not already set to black. Set the RGB value for a subset of colors for all frames. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginFillNonZeroColorAllFramesName(
 const char* path, int color);

// Class Plugin
ChromaAnimationAPI::FillNonZeroColorAllFramesName(
 const char* path, int color);

PluginFillNonZeroColorAllFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginFillNonZeroColorAllFramesNameD(
 const char* path, double color);

// Class Plugin
double result = ChromaAnimationAPI::FillNonZeroColorAllFramesNameD(
 const char* path, double color);

PluginFillNonZeroColorAllFramesRGB

This method will only update colors in the animation that are not already set to black. Set the RGB value for a subset of colors for all frames. Use the range of 0 to 255 for red, green, and blue parameters. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginFillNonZeroColorAllFramesRGB(
 int animationId, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::FillNonZeroColorAllFramesRGB(
 int animationId, int red, int green, int blue);

PluginFillNonZeroColorAllFramesRGBName

This method will only update colors in the animation that are not already set to black. Set the RGB value for a subset of colors for all frames. Use the range of 0 to 255 for red, green, and blue parameters. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginFillNonZeroColorAllFramesRGBName(
 const char* path, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::FillNonZeroColorAllFramesRGBName(
 const char* path, int red, int green, int blue);

PluginFillNonZeroColorAllFramesRGBNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginFillNonZeroColorAllFramesRGBNameD(
 const char* path, double red, double green, double blue);

// Class Plugin
double result = ChromaAnimationAPI::FillNonZeroColorAllFramesRGBNameD(
 const char* path, double red, double green, double blue);

PluginFillNonZeroColorName

This method will only update colors in the animation that are not already set to black. Set the RGB value for a subset of colors in the specified frame. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginFillNonZeroColorName(
 const char* path, int frameId, int color);

// Class Plugin
ChromaAnimationAPI::FillNonZeroColorName(
 const char* path, int frameId, int color);

PluginFillNonZeroColorNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginFillNonZeroColorNameD(
 const char* path, double frameId, double color);

// Class Plugin
double result = ChromaAnimationAPI::FillNonZeroColorNameD(
 const char* path, double frameId, double color);

PluginFillNonZeroColorRGB

This method will only update colors in the animation that are not already set to black. Set the RGB value for a subset of colors in the specified frame. Use the range of 0 to 255 for red, green, and blue parameters. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginFillNonZeroColorRGB(
 int animationId, int frameId, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::FillNonZeroColorRGB(
 int animationId, int frameId, int red, int green, int blue);

PluginFillNonZeroColorRGBName

This method will only update colors in the animation that are not already set to black. Set the RGB value for a subset of colors in the specified frame. Use the range of 0 to 255 for red, green, and blue parameters. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginFillNonZeroColorRGBName(
 const char* path, int frameId, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::FillNonZeroColorRGBName(
 const char* path, int frameId, int red, int green, int blue);

PluginFillNonZeroColorRGBNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginFillNonZeroColorRGBNameD(
 const char* path, double frameId, double red, double green, double blue);

// Class Plugin
double result = ChromaAnimationAPI::FillNonZeroColorRGBNameD(
 const char* path, double frameId, double red, double green, double blue);

PluginFillRandomColors

Fill the frame with random RGB values for the given frame. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginFillRandomColors(
 int animationId, int frameId);

// Class Plugin
ChromaAnimationAPI::FillRandomColors(
 int animationId, int frameId);

PluginFillRandomColorsAllFrames

Fill the frame with random RGB values for all frames. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginFillRandomColorsAllFrames(int animationId);

// Class Plugin
ChromaAnimationAPI::FillRandomColorsAllFrames(int animationId);

PluginFillRandomColorsAllFramesName

Fill the frame with random RGB values for all frames. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginFillRandomColorsAllFramesName(const char* path);

// Class Plugin
ChromaAnimationAPI::FillRandomColorsAllFramesName(const char* path);

PluginFillRandomColorsAllFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginFillRandomColorsAllFramesNameD(const char* path);

// Class Plugin
double result = ChromaAnimationAPI::FillRandomColorsAllFramesNameD(const char* path);

PluginFillRandomColorsBlackAndWhite

Fill the frame with random black and white values for the specified frame. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginFillRandomColorsBlackAndWhite(
 int animationId, int frameId);

// Class Plugin
ChromaAnimationAPI::FillRandomColorsBlackAndWhite(
 int animationId, int frameId);

PluginFillRandomColorsBlackAndWhiteAllFrames

Fill the frame with random black and white values for all frames. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginFillRandomColorsBlackAndWhiteAllFrames(int animationId);

// Class Plugin
ChromaAnimationAPI::FillRandomColorsBlackAndWhiteAllFrames(int animationId);

PluginFillRandomColorsBlackAndWhiteAllFramesName

Fill the frame with random black and white values for all frames. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginFillRandomColorsBlackAndWhiteAllFramesName(const char* path);

// Class Plugin
ChromaAnimationAPI::FillRandomColorsBlackAndWhiteAllFramesName(const char* path);

PluginFillRandomColorsBlackAndWhiteAllFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginFillRandomColorsBlackAndWhiteAllFramesNameD(const char* path);

// Class Plugin
double result = ChromaAnimationAPI::FillRandomColorsBlackAndWhiteAllFramesNameD(const char* path);

PluginFillRandomColorsBlackAndWhiteName

Fill the frame with random black and white values for the specified frame. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginFillRandomColorsBlackAndWhiteName(
 const char* path, int frameId);

// Class Plugin
ChromaAnimationAPI::FillRandomColorsBlackAndWhiteName(
 const char* path, int frameId);

PluginFillRandomColorsBlackAndWhiteNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginFillRandomColorsBlackAndWhiteNameD(
 const char* path, double frameId);

// Class Plugin
double result = ChromaAnimationAPI::FillRandomColorsBlackAndWhiteNameD(
 const char* path, double frameId);

PluginFillRandomColorsName

Fill the frame with random RGB values for the given frame. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginFillRandomColorsName(
 const char* path, int frameId);

// Class Plugin
ChromaAnimationAPI::FillRandomColorsName(
 const char* path, int frameId);

PluginFillRandomColorsNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginFillRandomColorsNameD(
 const char* path, double frameId);

// Class Plugin
double result = ChromaAnimationAPI::FillRandomColorsNameD(
 const char* path, double frameId);

PluginFillThresholdColors

Fill the specified frame with RGB color where the animation color is less than the RGB threshold. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginFillThresholdColors(
 int animationId, int frameId, int threshold, int color);

// Class Plugin
ChromaAnimationAPI::FillThresholdColors(
 int animationId, int frameId, int threshold, int color);

PluginFillThresholdColorsAllFrames

Fill all frames with RGB color where the animation color is less than the RGB threshold. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginFillThresholdColorsAllFrames(
 int animationId, int threshold, int color);

// Class Plugin
ChromaAnimationAPI::FillThresholdColorsAllFrames(
 int animationId, int threshold, int color);

PluginFillThresholdColorsAllFramesName

Fill all frames with RGB color where the animation color is less than the RGB threshold. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginFillThresholdColorsAllFramesName(
 const char* path, int threshold, int color);

// Class Plugin
ChromaAnimationAPI::FillThresholdColorsAllFramesName(
 const char* path, int threshold, int color);

PluginFillThresholdColorsAllFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginFillThresholdColorsAllFramesNameD(
 const char* path, double threshold, double color);

// Class Plugin
double result = ChromaAnimationAPI::FillThresholdColorsAllFramesNameD(
 const char* path, double threshold, double color);

PluginFillThresholdColorsAllFramesRGB

Fill all frames with RGB color where the animation color is less than the threshold. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginFillThresholdColorsAllFramesRGB(
 int animationId, int threshold, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::FillThresholdColorsAllFramesRGB(
 int animationId, int threshold, int red, int green, int blue);

PluginFillThresholdColorsAllFramesRGBName

Fill all frames with RGB color where the animation color is less than the threshold. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginFillThresholdColorsAllFramesRGBName(
 const char* path, int threshold, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::FillThresholdColorsAllFramesRGBName(
 const char* path, int threshold, int red, int green, int blue);

PluginFillThresholdColorsAllFramesRGBNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginFillThresholdColorsAllFramesRGBNameD(
 const char* path, double threshold, double red, double green, double blue);

// Class Plugin
double result = ChromaAnimationAPI::FillThresholdColorsAllFramesRGBNameD(
 const char* path, double threshold, double red, double green, double blue);

PluginFillThresholdColorsMinMaxAllFramesRGB

Fill all frames with the min RGB color where the animation color is less than the min threshold AND with the max RGB color where the animation is more than the max threshold. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginFillThresholdColorsMinMaxAllFramesRGB(
 int animationId, int minThreshold, int minRed, int minGreen, int minBlue,
 int maxThreshold, int maxRed, int maxGreen, int maxBlue);

// Class Plugin
ChromaAnimationAPI::FillThresholdColorsMinMaxAllFramesRGB(
 int animationId, int minThreshold, int minRed, int minGreen, int minBlue,
 int maxThreshold, int maxRed, int maxGreen, int maxBlue);

PluginFillThresholdColorsMinMaxAllFramesRGBName

Fill all frames with the min RGB color where the animation color is less than the min threshold AND with the max RGB color where the animation is more than the max threshold. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginFillThresholdColorsMinMaxAllFramesRGBName(
 const char* path, int minThreshold, int minRed, int minGreen, int minBlue,
 int maxThreshold, int maxRed, int maxGreen, int maxBlue);

// Class Plugin
ChromaAnimationAPI::FillThresholdColorsMinMaxAllFramesRGBName(
 const char* path, int minThreshold, int minRed, int minGreen, int minBlue,
 int maxThreshold, int maxRed, int maxGreen, int maxBlue);

PluginFillThresholdColorsMinMaxAllFramesRGBNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginFillThresholdColorsMinMaxAllFramesRGBNameD(
 const char* path, double minThreshold, double minRed, double minGreen, double minBlue,
 double maxThreshold, double maxRed, double maxGreen, double maxBlue);

// Class Plugin
double result = ChromaAnimationAPI::FillThresholdColorsMinMaxAllFramesRGBNameD(
 const char* path, double minThreshold, double minRed, double minGreen, double minBlue,
 double maxThreshold, double maxRed, double maxGreen, double maxBlue);

PluginFillThresholdColorsMinMaxRGB

Fill the specified frame with the min RGB color where the animation color is less than the min threshold AND with the max RGB color where the animation is more than the max threshold. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginFillThresholdColorsMinMaxRGB(
 int animationId, int frameId, int minThreshold, int minRed, int minGreen,
 int minBlue, int maxThreshold, int maxRed, int maxGreen, int maxBlue);

// Class Plugin
ChromaAnimationAPI::FillThresholdColorsMinMaxRGB(
 int animationId, int frameId, int minThreshold, int minRed, int minGreen,
 int minBlue, int maxThreshold, int maxRed, int maxGreen, int maxBlue);

PluginFillThresholdColorsMinMaxRGBName

Fill the specified frame with the min RGB color where the animation color is less than the min threshold AND with the max RGB color where the animation is more than the max threshold. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginFillThresholdColorsMinMaxRGBName(
 const char* path, int frameId, int minThreshold, int minRed, int minGreen,
 int minBlue, int maxThreshold, int maxRed, int maxGreen, int maxBlue);

// Class Plugin
ChromaAnimationAPI::FillThresholdColorsMinMaxRGBName(
 const char* path, int frameId, int minThreshold, int minRed, int minGreen,
 int minBlue, int maxThreshold, int maxRed, int maxGreen, int maxBlue);

PluginFillThresholdColorsMinMaxRGBNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginFillThresholdColorsMinMaxRGBNameD(
 const char* path, double frameId, double minThreshold, double minRed, double minGreen,
 double minBlue, double maxThreshold, double maxRed, double maxGreen, double maxBlue);

// Class Plugin
double result = ChromaAnimationAPI::FillThresholdColorsMinMaxRGBNameD(
 const char* path, double frameId, double minThreshold, double minRed, double minGreen,
 double minBlue, double maxThreshold, double maxRed, double maxGreen, double maxBlue);

PluginFillThresholdColorsName

Fill the specified frame with RGB color where the animation color is less than the RGB threshold. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginFillThresholdColorsName(
 const char* path, int frameId, int threshold, int color);

// Class Plugin
ChromaAnimationAPI::FillThresholdColorsName(
 const char* path, int frameId, int threshold, int color);

PluginFillThresholdColorsNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginFillThresholdColorsNameD(
 const char* path, double frameId, double threshold, double color);

// Class Plugin
double result = ChromaAnimationAPI::FillThresholdColorsNameD(
 const char* path, double frameId, double threshold, double color);

PluginFillThresholdColorsRGB

Fill the specified frame with RGB color where the animation color is less than the RGB threshold. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginFillThresholdColorsRGB(
 int animationId, int frameId, int threshold, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::FillThresholdColorsRGB(
 int animationId, int frameId, int threshold, int red, int green, int blue);

PluginFillThresholdColorsRGBName

Fill the specified frame with RGB color where the animation color is less than the RGB threshold. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginFillThresholdColorsRGBName(
 const char* path, int frameId, int threshold, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::FillThresholdColorsRGBName(
 const char* path, int frameId, int threshold, int red, int green, int blue);

PluginFillThresholdColorsRGBNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginFillThresholdColorsRGBNameD(
 const char* path, double frameId, double threshold, double red, double green,
 double blue);

// Class Plugin
double result = ChromaAnimationAPI::FillThresholdColorsRGBNameD(
 const char* path, double frameId, double threshold, double red, double green,
 double blue);

PluginFillThresholdRGBColorsAllFramesRGB

Fill all frames with RGB color where the animation color is less than the RGB threshold. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginFillThresholdRGBColorsAllFramesRGB(
 int animationId, int redThreshold, int greenThreshold, int blueThreshold,
 int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::FillThresholdRGBColorsAllFramesRGB(
 int animationId, int redThreshold, int greenThreshold, int blueThreshold,
 int red, int green, int blue);

PluginFillThresholdRGBColorsAllFramesRGBName

Fill all frames with RGB color where the animation color is less than the RGB threshold. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginFillThresholdRGBColorsAllFramesRGBName(
 const char* path, int redThreshold, int greenThreshold, int blueThreshold,
 int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::FillThresholdRGBColorsAllFramesRGBName(
 const char* path, int redThreshold, int greenThreshold, int blueThreshold,
 int red, int green, int blue);

PluginFillThresholdRGBColorsAllFramesRGBNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginFillThresholdRGBColorsAllFramesRGBNameD(
 const char* path, double redThreshold, double greenThreshold, double blueThreshold,
 double red, double green, double blue);

// Class Plugin
double result = ChromaAnimationAPI::FillThresholdRGBColorsAllFramesRGBNameD(
 const char* path, double redThreshold, double greenThreshold, double blueThreshold,
 double red, double green, double blue);

PluginFillThresholdRGBColorsRGB

Fill the specified frame with RGB color where the animation color is less than the RGB threshold. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginFillThresholdRGBColorsRGB(
 int animationId, int frameId, int redThreshold, int greenThreshold, int blueThreshold,
 int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::FillThresholdRGBColorsRGB(
 int animationId, int frameId, int redThreshold, int greenThreshold, int blueThreshold,
 int red, int green, int blue);

PluginFillThresholdRGBColorsRGBName

Fill the specified frame with RGB color where the animation color is less than the RGB threshold. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginFillThresholdRGBColorsRGBName(
 const char* path, int frameId, int redThreshold, int greenThreshold, int blueThreshold,
 int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::FillThresholdRGBColorsRGBName(
 const char* path, int frameId, int redThreshold, int greenThreshold, int blueThreshold,
 int red, int green, int blue);

PluginFillThresholdRGBColorsRGBNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginFillThresholdRGBColorsRGBNameD(
 const char* path, double frameId, double redThreshold, double greenThreshold,
 double blueThreshold, double red, double green, double blue);

// Class Plugin
double result = ChromaAnimationAPI::FillThresholdRGBColorsRGBNameD(
 const char* path, double frameId, double redThreshold, double greenThreshold,
 double blueThreshold, double red, double green, double blue);

PluginFillZeroColor

Fill the specified frame with RGB color where the animation color is zero. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginFillZeroColor(
 int animationId, int frameId, int color);

// Class Plugin
ChromaAnimationAPI::FillZeroColor(
 int animationId, int frameId, int color);

PluginFillZeroColorAllFrames

Fill all frames with RGB color where the animation color is zero. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginFillZeroColorAllFrames(
 int animationId, int color);

// Class Plugin
ChromaAnimationAPI::FillZeroColorAllFrames(
 int animationId, int color);

PluginFillZeroColorAllFramesName

Fill all frames with RGB color where the animation color is zero. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginFillZeroColorAllFramesName(
 const char* path, int color);

// Class Plugin
ChromaAnimationAPI::FillZeroColorAllFramesName(
 const char* path, int color);

PluginFillZeroColorAllFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginFillZeroColorAllFramesNameD(
 const char* path, double color);

// Class Plugin
double result = ChromaAnimationAPI::FillZeroColorAllFramesNameD(
 const char* path, double color);

PluginFillZeroColorAllFramesRGB

Fill all frames with RGB color where the animation color is zero. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginFillZeroColorAllFramesRGB(
 int animationId, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::FillZeroColorAllFramesRGB(
 int animationId, int red, int green, int blue);

PluginFillZeroColorAllFramesRGBName

Fill all frames with RGB color where the animation color is zero. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginFillZeroColorAllFramesRGBName(
 const char* path, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::FillZeroColorAllFramesRGBName(
 const char* path, int red, int green, int blue);

PluginFillZeroColorAllFramesRGBNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginFillZeroColorAllFramesRGBNameD(
 const char* path, double red, double green, double blue);

// Class Plugin
double result = ChromaAnimationAPI::FillZeroColorAllFramesRGBNameD(
 const char* path, double red, double green, double blue);

PluginFillZeroColorName

Fill the specified frame with RGB color where the animation color is zero. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginFillZeroColorName(
 const char* path, int frameId, int color);

// Class Plugin
ChromaAnimationAPI::FillZeroColorName(
 const char* path, int frameId, int color);

PluginFillZeroColorNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginFillZeroColorNameD(
 const char* path, double frameId, double color);

// Class Plugin
double result = ChromaAnimationAPI::FillZeroColorNameD(
 const char* path, double frameId, double color);

PluginFillZeroColorRGB

Fill the specified frame with RGB color where the animation color is zero. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginFillZeroColorRGB(
 int animationId, int frameId, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::FillZeroColorRGB(
 int animationId, int frameId, int red, int green, int blue);

PluginFillZeroColorRGBName

Fill the specified frame with RGB color where the animation color is zero. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginFillZeroColorRGBName(
 const char* path, int frameId, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::FillZeroColorRGBName(
 const char* path, int frameId, int red, int green, int blue);

PluginFillZeroColorRGBNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginFillZeroColorRGBNameD(
 const char* path, double frameId, double red, double green, double blue);

// Class Plugin
double result = ChromaAnimationAPI::FillZeroColorRGBNameD(
 const char* path, double frameId, double red, double green, double blue);

PluginGet1DColor

Get the animation color for a frame given the 1D led. The led should be greater than or equal to 0 and less than the MaxLeds. Animation is referenced by id.

// DLL Interface
EXPORT_API int PluginGet1DColor(
 int animationId, int frameId, int led);

// Class Plugin
int result = ChromaAnimationAPI::Get1DColor(
 int animationId, int frameId, int led);

PluginGet1DColorName

Get the animation color for a frame given the 1D led. The led should be greater than or equal to 0 and less than the MaxLeds. Animation is referenced by name.

// DLL Interface
EXPORT_API int PluginGet1DColorName(
 const char* path, int frameId, int led);

// Class Plugin
int result = ChromaAnimationAPI::Get1DColorName(
 const char* path, int frameId, int led);

PluginGet1DColorNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginGet1DColorNameD(
 const char* path, double frameId, double led);

// Class Plugin
double result = ChromaAnimationAPI::Get1DColorNameD(
 const char* path, double frameId, double led);

PluginGet2DColor

Get the animation color for a frame given the 2D row and column. The row should be greater than or equal to 0 and less than the MaxRow. The column should be greater than or equal to 0 and less than the MaxColumn. Animation is referenced by id.

// DLL Interface
EXPORT_API int PluginGet2DColor(
 int animationId, int frameId, int row, int column);

// Class Plugin
int result = ChromaAnimationAPI::Get2DColor(
 int animationId, int frameId, int row, int column);

PluginGet2DColorName

Get the animation color for a frame given the 2D row and column. The row should be greater than or equal to 0 and less than the MaxRow. The column should be greater than or equal to 0 and less than the MaxColumn. Animation is referenced by name.

// DLL Interface
EXPORT_API int PluginGet2DColorName(
 const char* path, int frameId, int row, int column);

// Class Plugin
int result = ChromaAnimationAPI::Get2DColorName(
 const char* path, int frameId, int row, int column);

PluginGet2DColorNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginGet2DColorNameD(
 const char* path, double frameId, double row, double column);

// Class Plugin
double result = ChromaAnimationAPI::Get2DColorNameD(
 const char* path, double frameId, double row, double column);

PluginGetAnimation

Get the animation id for the named animation.

// DLL Interface
EXPORT_API int PluginGetAnimation(const char* name);

// Class Plugin
int result = ChromaAnimationAPI::GetAnimation(const char* name);

PluginGetAnimationCount

PluginGetAnimationCount will return the number of loaded animations.

// DLL Interface
EXPORT_API int PluginGetAnimationCount();

// Class Plugin
int result = ChromaAnimationAPI::GetAnimationCount();

PluginGetAnimationD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginGetAnimationD(const char* name);

// Class Plugin
double result = ChromaAnimationAPI::GetAnimationD(const char* name);

PluginGetAnimationId

PluginGetAnimationId will return the animationId given the index of the loaded animation. The index is zero-based and less than the number returned by PluginGetAnimationCount. Use PluginGetAnimationName to get the name of the animation.

// DLL Interface
EXPORT_API int PluginGetAnimationId(int index);

// Class Plugin
int result = ChromaAnimationAPI::GetAnimationId(int index);

PluginGetAnimationName

PluginGetAnimationName takes an animationId and returns the name of the animation of the .chroma animation file. If a name is not available then an empty string will be returned.

// DLL Interface
EXPORT_API const char* PluginGetAnimationName(int animationId);

// Class Plugin
const char* result = ChromaAnimationAPI::GetAnimationName(int animationId);

PluginGetCurrentFrame

Get the current frame of the animation referenced by id.

// DLL Interface
EXPORT_API int PluginGetCurrentFrame(int animationId);

// Class Plugin
int result = ChromaAnimationAPI::GetCurrentFrame(int animationId);

PluginGetCurrentFrameName

Get the current frame of the animation referenced by name.

// DLL Interface
EXPORT_API int PluginGetCurrentFrameName(const char* path);

// Class Plugin
int result = ChromaAnimationAPI::GetCurrentFrameName(const char* path);

PluginGetCurrentFrameNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginGetCurrentFrameNameD(const char* path);

// Class Plugin
double result = ChromaAnimationAPI::GetCurrentFrameNameD(const char* path);

PluginGetDevice

Returns the EChromaSDKDevice1DEnum or EChromaSDKDevice2DEnum of a Chroma animation respective to the deviceType, as an integer upon success. Returns negative one upon failure.

// DLL Interface
EXPORT_API int PluginGetDevice(int animationId);

// Class Plugin
int result = ChromaAnimationAPI::GetDevice(int animationId);

PluginGetDeviceName

Returns the EChromaSDKDevice1DEnum or EChromaSDKDevice2DEnum of a Chroma animation respective to the deviceType, as an integer upon success. Returns negative one upon failure.

// DLL Interface
EXPORT_API int PluginGetDeviceName(const char* path);

// Class Plugin
int result = ChromaAnimationAPI::GetDeviceName(const char* path);

PluginGetDeviceNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginGetDeviceNameD(const char* path);

// Class Plugin
double result = ChromaAnimationAPI::GetDeviceNameD(const char* path);

PluginGetDeviceType

Returns the EChromaSDKDeviceTypeEnum of a Chroma animation as an integer upon success. Returns negative one upon failure.

// DLL Interface
EXPORT_API int PluginGetDeviceType(int animationId);

// Class Plugin
int result = ChromaAnimationAPI::GetDeviceType(int animationId);

PluginGetDeviceTypeName

Returns the EChromaSDKDeviceTypeEnum of a Chroma animation as an integer upon success. Returns negative one upon failure.

// DLL Interface
EXPORT_API int PluginGetDeviceTypeName(const char* path);

// Class Plugin
int result = ChromaAnimationAPI::GetDeviceTypeName(const char* path);

PluginGetDeviceTypeNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginGetDeviceTypeNameD(const char* path);

// Class Plugin
double result = ChromaAnimationAPI::GetDeviceTypeNameD(const char* path);

PluginGetFrame

Get the frame colors and duration (in seconds) for a Chroma animation referenced by id. The color is expected to be an array of the expected dimensions for the deviceType/device. The length parameter is the size of the color array. For EChromaSDKDevice1DEnum the array size should be MAX LEDS. For EChromaSDKDevice2DEnum the array size should be MAX ROW times MAX COLUMN. Keys are populated only for EChromaSDKDevice2DEnum::DE_Keyboard and EChromaSDKDevice2DEnum::DE_KeyboardExtended. Keys will only use the EChromaSDKDevice2DEnum::DE_Keyboard MAX_ROW times MAX_COLUMN keysLength. Returns the animation id upon success. Returns negative one upon failure.

// DLL Interface
EXPORT_API int PluginGetFrame(
 int animationId, int frameIndex, float* duration, int* colors, int length,
 int* keys, int keysLength);

// Class Plugin
int result = ChromaAnimationAPI::GetFrame(
 int animationId, int frameIndex, float* duration, int* colors, int length,
 int* keys, int keysLength);

PluginGetFrameCount

Returns the frame count of a Chroma animation upon success. Returns negative one upon failure.

// DLL Interface
EXPORT_API int PluginGetFrameCount(int animationId);

// Class Plugin
int result = ChromaAnimationAPI::GetFrameCount(int animationId);

PluginGetFrameCountName

Returns the frame count of a Chroma animation upon success. Returns negative one upon failure.

// DLL Interface
EXPORT_API int PluginGetFrameCountName(const char* path);

// Class Plugin
int result = ChromaAnimationAPI::GetFrameCountName(const char* path);

PluginGetFrameCountNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginGetFrameCountNameD(const char* path);

// Class Plugin
double result = ChromaAnimationAPI::GetFrameCountNameD(const char* path);

PluginGetFrameName

Get the frame colors and duration (in seconds) for a Chroma animation referenced by name. The color is expected to be an array of the expected dimensions for the deviceType/device. The length parameter is the size of the color array. For EChromaSDKDevice1DEnum the array size should be MAX LEDS. For EChromaSDKDevice2DEnum the array size should be MAX ROW times MAX COLUMN. Keys are populated only for EChromaSDKDevice2DEnum::DE_Keyboard and EChromaSDKDevice2DEnum::DE_KeyboardExtended. Keys will only use the EChromaSDKDevice2DEnum::DE_Keyboard MAX_ROW times MAX_COLUMN keysLength. Returns the animation id upon success. Returns negative one upon failure.

// DLL Interface
EXPORT_API int PluginGetFrameName(
 const char* path, int frameIndex, float* duration, int* colors, int length,
 int* keys, int keysLength);

// Class Plugin
int result = ChromaAnimationAPI::GetFrameName(
 const char* path, int frameIndex, float* duration, int* colors, int length,
 int* keys, int keysLength);

PluginGetKeyColor

Get the color of an animation key for the given frame referenced by id.

// DLL Interface
EXPORT_API int PluginGetKeyColor(
 int animationId, int frameId, int rzkey);

// Class Plugin
int result = ChromaAnimationAPI::GetKeyColor(
 int animationId, int frameId, int rzkey);

PluginGetKeyColorD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginGetKeyColorD(
 const char* path, double frameId, double rzkey);

// Class Plugin
double result = ChromaAnimationAPI::GetKeyColorD(
 const char* path, double frameId, double rzkey);

PluginGetKeyColorName

Get the color of an animation key for the given frame referenced by name.

// DLL Interface
EXPORT_API int PluginGetKeyColorName(
 const char* path, int frameId, int rzkey);

// Class Plugin
int result = ChromaAnimationAPI::GetKeyColorName(
 const char* path, int frameId, int rzkey);

PluginGetLibraryLoadedState

Returns RZRESULT_SUCCESS if the plugin has been initialized successfully. Returns RZRESULT_DLL_NOT_FOUND if core Chroma library is not found. Returns RZRESULT_DLL_INVALID_SIGNATURE if core Chroma library has an invalid signature.

// DLL Interface
EXPORT_API RZRESULT PluginGetLibraryLoadedState();

// Class Plugin
RZRESULT result = ChromaAnimationAPI::GetLibraryLoadedState();

PluginGetLibraryLoadedStateD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginGetLibraryLoadedStateD();

// Class Plugin
double result = ChromaAnimationAPI::GetLibraryLoadedStateD();

PluginGetMaxColumn

Returns the MAX COLUMN given the EChromaSDKDevice2DEnum device as an integer upon success. Returns negative one upon failure.

// DLL Interface
EXPORT_API int PluginGetMaxColumn(int device);

// Class Plugin
int result = ChromaAnimationAPI::GetMaxColumn(int device);

PluginGetMaxColumnD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginGetMaxColumnD(double device);

// Class Plugin
double result = ChromaAnimationAPI::GetMaxColumnD(double device);

PluginGetMaxLeds

Returns the MAX LEDS given the EChromaSDKDevice1DEnum device as an integer upon success. Returns negative one upon failure.

// DLL Interface
EXPORT_API int PluginGetMaxLeds(int device);

// Class Plugin
int result = ChromaAnimationAPI::GetMaxLeds(int device);

PluginGetMaxLedsD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginGetMaxLedsD(double device);

// Class Plugin
double result = ChromaAnimationAPI::GetMaxLedsD(double device);

PluginGetMaxRow

Returns the MAX ROW given the EChromaSDKDevice2DEnum device as an integer upon success. Returns negative one upon failure.

// DLL Interface
EXPORT_API int PluginGetMaxRow(int device);

// Class Plugin
int result = ChromaAnimationAPI::GetMaxRow(int device);

PluginGetMaxRowD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginGetMaxRowD(double device);

// Class Plugin
double result = ChromaAnimationAPI::GetMaxRowD(double device);

PluginGetPlayingAnimationCount

PluginGetPlayingAnimationCount will return the number of playing animations.

// DLL Interface
EXPORT_API int PluginGetPlayingAnimationCount();

// Class Plugin
int result = ChromaAnimationAPI::GetPlayingAnimationCount();

PluginGetPlayingAnimationId

PluginGetPlayingAnimationId will return the animationId given the index of the playing animation. The index is zero-based and less than the number returned by PluginGetPlayingAnimationCount. Use PluginGetAnimationName to get the name of the animation.

// DLL Interface
EXPORT_API int PluginGetPlayingAnimationId(int index);

// Class Plugin
int result = ChromaAnimationAPI::GetPlayingAnimationId(int index);

PluginGetRGB

Get the RGB color given red, green, and blue.

// DLL Interface
EXPORT_API int PluginGetRGB(
 int red, int green, int blue);

// Class Plugin
int result = ChromaAnimationAPI::GetRGB(
 int red, int green, int blue);

PluginGetRGBD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginGetRGBD(
 double red, double green, double blue);

// Class Plugin
double result = ChromaAnimationAPI::GetRGBD(
 double red, double green, double blue);

PluginHasAnimationLoop

Check if the animation has loop enabled referenced by id.

// DLL Interface
EXPORT_API bool PluginHasAnimationLoop(int animationId);

// Class Plugin
bool result = ChromaAnimationAPI::HasAnimationLoop(int animationId);

PluginHasAnimationLoopName

Check if the animation has loop enabled referenced by name.

// DLL Interface
EXPORT_API bool PluginHasAnimationLoopName(const char* path);

// Class Plugin
bool result = ChromaAnimationAPI::HasAnimationLoopName(const char* path);

PluginHasAnimationLoopNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginHasAnimationLoopNameD(const char* path);

// Class Plugin
double result = ChromaAnimationAPI::HasAnimationLoopNameD(const char* path);

PluginInit

Initialize the ChromaSDK. Zero indicates success, otherwise failure. Many API methods auto initialize the ChromaSDK if not already initialized.

// DLL Interface
EXPORT_API RZRESULT PluginInit();

// Class Plugin
RZRESULT result = ChromaAnimationAPI::Init();

PluginInitD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginInitD();

// Class Plugin
double result = ChromaAnimationAPI::InitD();

PluginInitSDK

Initialize the ChromaSDK. AppInfo populates the details in Synapse. Zero indicates success, otherwise failure. Many API methods auto initialize the ChromaSDK if not already initialized.

// DLL Interface
EXPORT_API RZRESULT PluginInitSDK(
 ChromaSDK::APPINFOTYPE* AppInfo);

// Class Plugin
RZRESULT result = ChromaAnimationAPI::InitSDK(
 ChromaSDK::APPINFOTYPE* AppInfo);

PluginInsertDelay

Insert an animation delay by duplicating the frame by the delay number of times. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginInsertDelay(
 int animationId, int frameId, int delay);

// Class Plugin
ChromaAnimationAPI::InsertDelay(
 int animationId, int frameId, int delay);

PluginInsertDelayName

Insert an animation delay by duplicating the frame by the delay number of times. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginInsertDelayName(
 const char* path, int frameId, int delay);

// Class Plugin
ChromaAnimationAPI::InsertDelayName(
 const char* path, int frameId, int delay);

PluginInsertDelayNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginInsertDelayNameD(
 const char* path, double frameId, double delay);

// Class Plugin
double result = ChromaAnimationAPI::InsertDelayNameD(
 const char* path, double frameId, double delay);

PluginInsertFrame

Duplicate the source frame index at the target frame index. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginInsertFrame(
 int animationId, int sourceFrame, int targetFrame);

// Class Plugin
ChromaAnimationAPI::InsertFrame(
 int animationId, int sourceFrame, int targetFrame);

PluginInsertFrameName

Duplicate the source frame index at the target frame index. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginInsertFrameName(
 const char* path, int sourceFrame, int targetFrame);

// Class Plugin
ChromaAnimationAPI::InsertFrameName(
 const char* path, int sourceFrame, int targetFrame);

PluginInsertFrameNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginInsertFrameNameD(
 const char* path, double sourceFrame, double targetFrame);

// Class Plugin
double result = ChromaAnimationAPI::InsertFrameNameD(
 const char* path, double sourceFrame, double targetFrame);

PluginInvertColors

Invert all the colors at the specified frame. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginInvertColors(
 int animationId, int frameId);

// Class Plugin
ChromaAnimationAPI::InvertColors(
 int animationId, int frameId);

PluginInvertColorsAllFrames

Invert all the colors for all frames. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginInvertColorsAllFrames(int animationId);

// Class Plugin
ChromaAnimationAPI::InvertColorsAllFrames(int animationId);

PluginInvertColorsAllFramesName

Invert all the colors for all frames. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginInvertColorsAllFramesName(const char* path);

// Class Plugin
ChromaAnimationAPI::InvertColorsAllFramesName(const char* path);

PluginInvertColorsAllFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginInvertColorsAllFramesNameD(const char* path);

// Class Plugin
double result = ChromaAnimationAPI::InvertColorsAllFramesNameD(const char* path);

PluginInvertColorsName

Invert all the colors at the specified frame. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginInvertColorsName(
 const char* path, int frameId);

// Class Plugin
ChromaAnimationAPI::InvertColorsName(
 const char* path, int frameId);

PluginInvertColorsNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginInvertColorsNameD(
 const char* path, double frameId);

// Class Plugin
double result = ChromaAnimationAPI::InvertColorsNameD(
 const char* path, double frameId);

PluginIsAnimationPaused

Check if the animation is paused referenced by id.

// DLL Interface
EXPORT_API bool PluginIsAnimationPaused(int animationId);

// Class Plugin
bool result = ChromaAnimationAPI::IsAnimationPaused(int animationId);

PluginIsAnimationPausedName

Check if the animation is paused referenced by name.

// DLL Interface
EXPORT_API bool PluginIsAnimationPausedName(const char* path);

// Class Plugin
bool result = ChromaAnimationAPI::IsAnimationPausedName(const char* path);

PluginIsAnimationPausedNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginIsAnimationPausedNameD(const char* path);

// Class Plugin
double result = ChromaAnimationAPI::IsAnimationPausedNameD(const char* path);

PluginIsDialogOpen

The editor dialog is a non-blocking modal window, this method returns true if the modal window is open, otherwise false.

// DLL Interface
EXPORT_API bool PluginIsDialogOpen();

// Class Plugin
bool result = ChromaAnimationAPI::IsDialogOpen();

PluginIsDialogOpenD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginIsDialogOpenD();

// Class Plugin
double result = ChromaAnimationAPI::IsDialogOpenD();

PluginIsInitialized

Returns true if the plugin has been initialized. Returns false if the plugin is uninitialized.

// DLL Interface
EXPORT_API bool PluginIsInitialized();

// Class Plugin
bool result = ChromaAnimationAPI::IsInitialized();

PluginIsInitializedD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginIsInitializedD();

// Class Plugin
double result = ChromaAnimationAPI::IsInitializedD();

PluginIsPlatformSupported

If the method can be invoked the method returns true.

// DLL Interface
EXPORT_API bool PluginIsPlatformSupported();

// Class Plugin
bool result = ChromaAnimationAPI::IsPlatformSupported();

PluginIsPlatformSupportedD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginIsPlatformSupportedD();

// Class Plugin
double result = ChromaAnimationAPI::IsPlatformSupportedD();

PluginIsPlaying

PluginIsPlayingName automatically handles initializing the ChromaSDK. The named .chroma animation file will be automatically opened. The method will return whether the animation is playing or not. Animation is referenced by id.

// DLL Interface
EXPORT_API bool PluginIsPlaying(int animationId);

// Class Plugin
bool result = ChromaAnimationAPI::IsPlaying(int animationId);

PluginIsPlayingD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginIsPlayingD(double animationId);

// Class Plugin
double result = ChromaAnimationAPI::IsPlayingD(double animationId);

PluginIsPlayingName

PluginIsPlayingName automatically handles initializing the ChromaSDK. The named .chroma animation file will be automatically opened. The method will return whether the animation is playing or not. Animation is referenced by name.

// DLL Interface
EXPORT_API bool PluginIsPlayingName(const char* path);

// Class Plugin
bool result = ChromaAnimationAPI::IsPlayingName(const char* path);

PluginIsPlayingNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginIsPlayingNameD(const char* path);

// Class Plugin
double result = ChromaAnimationAPI::IsPlayingNameD(const char* path);

PluginIsPlayingType

PluginIsPlayingType automatically handles initializing the ChromaSDK. If any animation is playing for the deviceType and device combination, the method will return true, otherwise false.

// DLL Interface
EXPORT_API bool PluginIsPlayingType(
 int deviceType, int device);

// Class Plugin
bool result = ChromaAnimationAPI::IsPlayingType(
 int deviceType, int device);

PluginIsPlayingTypeD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginIsPlayingTypeD(
 double deviceType, double device);

// Class Plugin
double result = ChromaAnimationAPI::IsPlayingTypeD(
 double deviceType, double device);

PluginLerp

Do a lerp math operation on a float.

// DLL Interface
EXPORT_API float PluginLerp(
 float start, float end, float amt);

// Class Plugin
float result = ChromaAnimationAPI::Lerp(
 float start, float end, float amt);

PluginLerpColor

Lerp from one color to another given t in the range 0.0 to 1.0.

// DLL Interface
EXPORT_API int PluginLerpColor(
 int from, int to, float t);

// Class Plugin
int result = ChromaAnimationAPI::LerpColor(
 int from, int to, float t);

PluginLoadAnimation

Loads Chroma effects so that the animation can be played immediately. Returns the animation id upon success. Returns negative one upon failure.

// DLL Interface
EXPORT_API int PluginLoadAnimation(int animationId);

// Class Plugin
int result = ChromaAnimationAPI::LoadAnimation(int animationId);

PluginLoadAnimationD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginLoadAnimationD(double animationId);

// Class Plugin
double result = ChromaAnimationAPI::LoadAnimationD(double animationId);

PluginLoadAnimationName

Load the named animation.

// DLL Interface
EXPORT_API void PluginLoadAnimationName(const char* path);

// Class Plugin
ChromaAnimationAPI::LoadAnimationName(const char* path);

PluginLoadComposite

Load a composite set of animations.

// DLL Interface
EXPORT_API void PluginLoadComposite(const char* name);

// Class Plugin
ChromaAnimationAPI::LoadComposite(const char* name);

PluginMakeBlankFrames

Make a blank animation for the length of the frame count. Frame duration defaults to the duration. The frame color defaults to color. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginMakeBlankFrames(
 int animationId, int frameCount, float duration, int color);

// Class Plugin
ChromaAnimationAPI::MakeBlankFrames(
 int animationId, int frameCount, float duration, int color);

PluginMakeBlankFramesName

Make a blank animation for the length of the frame count. Frame duration defaults to the duration. The frame color defaults to color. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginMakeBlankFramesName(
 const char* path, int frameCount, float duration, int color);

// Class Plugin
ChromaAnimationAPI::MakeBlankFramesName(
 const char* path, int frameCount, float duration, int color);

PluginMakeBlankFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginMakeBlankFramesNameD(
 const char* path, double frameCount, double duration, double color);

// Class Plugin
double result = ChromaAnimationAPI::MakeBlankFramesNameD(
 const char* path, double frameCount, double duration, double color);

PluginMakeBlankFramesRandom

Make a blank animation for the length of the frame count. Frame duration defaults to the duration. The frame color is random. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginMakeBlankFramesRandom(
 int animationId, int frameCount, float duration);

// Class Plugin
ChromaAnimationAPI::MakeBlankFramesRandom(
 int animationId, int frameCount, float duration);

PluginMakeBlankFramesRandomBlackAndWhite

Make a blank animation for the length of the frame count. Frame duration defaults to the duration. The frame color is random black and white. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginMakeBlankFramesRandomBlackAndWhite(
 int animationId, int frameCount, float duration);

// Class Plugin
ChromaAnimationAPI::MakeBlankFramesRandomBlackAndWhite(
 int animationId, int frameCount, float duration);

PluginMakeBlankFramesRandomBlackAndWhiteName

Make a blank animation for the length of the frame count. Frame duration defaults to the duration. The frame color is random black and white. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginMakeBlankFramesRandomBlackAndWhiteName(
 const char* path, int frameCount, float duration);

// Class Plugin
ChromaAnimationAPI::MakeBlankFramesRandomBlackAndWhiteName(
 const char* path, int frameCount, float duration);

PluginMakeBlankFramesRandomBlackAndWhiteNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginMakeBlankFramesRandomBlackAndWhiteNameD(
 const char* path, double frameCount, double duration);

// Class Plugin
double result = ChromaAnimationAPI::MakeBlankFramesRandomBlackAndWhiteNameD(
 const char* path, double frameCount, double duration);

PluginMakeBlankFramesRandomName

Make a blank animation for the length of the frame count. Frame duration defaults to the duration. The frame color is random. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginMakeBlankFramesRandomName(
 const char* path, int frameCount, float duration);

// Class Plugin
ChromaAnimationAPI::MakeBlankFramesRandomName(
 const char* path, int frameCount, float duration);

PluginMakeBlankFramesRandomNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginMakeBlankFramesRandomNameD(
 const char* path, double frameCount, double duration);

// Class Plugin
double result = ChromaAnimationAPI::MakeBlankFramesRandomNameD(
 const char* path, double frameCount, double duration);

PluginMakeBlankFramesRGB

Make a blank animation for the length of the frame count. Frame duration defaults to the duration. The frame color defaults to color. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginMakeBlankFramesRGB(
 int animationId, int frameCount, float duration, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::MakeBlankFramesRGB(
 int animationId, int frameCount, float duration, int red, int green, int blue);

PluginMakeBlankFramesRGBName

Make a blank animation for the length of the frame count. Frame duration defaults to the duration. The frame color defaults to color. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginMakeBlankFramesRGBName(
 const char* path, int frameCount, float duration, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::MakeBlankFramesRGBName(
 const char* path, int frameCount, float duration, int red, int green, int blue);

PluginMakeBlankFramesRGBNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginMakeBlankFramesRGBNameD(
 const char* path, double frameCount, double duration, double red, double green,
 double blue);

// Class Plugin
double result = ChromaAnimationAPI::MakeBlankFramesRGBNameD(
 const char* path, double frameCount, double duration, double red, double green,
 double blue);

PluginMirrorHorizontally

Flips the color grid horizontally for all Chroma animation frames. Returns the animation id upon success. Returns negative one upon failure.

// DLL Interface
EXPORT_API int PluginMirrorHorizontally(int animationId);

// Class Plugin
int result = ChromaAnimationAPI::MirrorHorizontally(int animationId);

PluginMirrorVertically

Flips the color grid vertically for all Chroma animation frames. This method has no effect for EChromaSDKDevice1DEnum devices. Returns the animation id upon success. Returns negative one upon failure.

// DLL Interface
EXPORT_API int PluginMirrorVertically(int animationId);

// Class Plugin
int result = ChromaAnimationAPI::MirrorVertically(int animationId);

PluginMultiplyColorLerpAllFrames

Multiply the color intensity with the lerp result from color 1 to color 2 using the frame index divided by the frame count for the t parameter. Animation is referenced in id.

// DLL Interface
EXPORT_API void PluginMultiplyColorLerpAllFrames(
 int animationId, int color1, int color2);

// Class Plugin
ChromaAnimationAPI::MultiplyColorLerpAllFrames(
 int animationId, int color1, int color2);

PluginMultiplyColorLerpAllFramesName

Multiply the color intensity with the lerp result from color 1 to color 2 using the frame index divided by the frame count for the t parameter. Animation is referenced in name.

// DLL Interface
EXPORT_API void PluginMultiplyColorLerpAllFramesName(
 const char* path, int color1, int color2);

// Class Plugin
ChromaAnimationAPI::MultiplyColorLerpAllFramesName(
 const char* path, int color1, int color2);

PluginMultiplyColorLerpAllFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginMultiplyColorLerpAllFramesNameD(
 const char* path, double color1, double color2);

// Class Plugin
double result = ChromaAnimationAPI::MultiplyColorLerpAllFramesNameD(
 const char* path, double color1, double color2);

PluginMultiplyIntensity

Multiply all the colors in the frame by the intensity value. The valid the intensity range is from 0.0 to 255.0. RGB components are multiplied equally. An intensity of 0.5 would half the color value. Black colors in the frame will not be affected by this method.

// DLL Interface
EXPORT_API void PluginMultiplyIntensity(
 int animationId, int frameId, float intensity);

// Class Plugin
ChromaAnimationAPI::MultiplyIntensity(
 int animationId, int frameId, float intensity);

PluginMultiplyIntensityAllFrames

Multiply all the colors for all frames by the intensity value. The valid the intensity range is from 0.0 to 255.0. RGB components are multiplied equally. An intensity of 0.5 would half the color value. Black colors in the frame will not be affected by this method.

// DLL Interface
EXPORT_API void PluginMultiplyIntensityAllFrames(
 int animationId, float intensity);

// Class Plugin
ChromaAnimationAPI::MultiplyIntensityAllFrames(
 int animationId, float intensity);

PluginMultiplyIntensityAllFramesName

Multiply all the colors for all frames by the intensity value. The valid the intensity range is from 0.0 to 255.0. RGB components are multiplied equally. An intensity of 0.5 would half the color value. Black colors in the frame will not be affected by this method.

// DLL Interface
EXPORT_API void PluginMultiplyIntensityAllFramesName(
 const char* path, float intensity);

// Class Plugin
ChromaAnimationAPI::MultiplyIntensityAllFramesName(
 const char* path, float intensity);

PluginMultiplyIntensityAllFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginMultiplyIntensityAllFramesNameD(
 const char* path, double intensity);

// Class Plugin
double result = ChromaAnimationAPI::MultiplyIntensityAllFramesNameD(
 const char* path, double intensity);

PluginMultiplyIntensityAllFramesRGB

Multiply all frames by the RBG color intensity. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginMultiplyIntensityAllFramesRGB(
 int animationId, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::MultiplyIntensityAllFramesRGB(
 int animationId, int red, int green, int blue);

PluginMultiplyIntensityAllFramesRGBName

Multiply all frames by the RBG color intensity. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginMultiplyIntensityAllFramesRGBName(
 const char* path, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::MultiplyIntensityAllFramesRGBName(
 const char* path, int red, int green, int blue);

PluginMultiplyIntensityAllFramesRGBNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginMultiplyIntensityAllFramesRGBNameD(
 const char* path, double red, double green, double blue);

// Class Plugin
double result = ChromaAnimationAPI::MultiplyIntensityAllFramesRGBNameD(
 const char* path, double red, double green, double blue);

PluginMultiplyIntensityColor

Multiply the specific frame by the RBG color intensity. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginMultiplyIntensityColor(
 int animationId, int frameId, int color);

// Class Plugin
ChromaAnimationAPI::MultiplyIntensityColor(
 int animationId, int frameId, int color);

PluginMultiplyIntensityColorAllFrames

Multiply all frames by the RBG color intensity. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginMultiplyIntensityColorAllFrames(
 int animationId, int color);

// Class Plugin
ChromaAnimationAPI::MultiplyIntensityColorAllFrames(
 int animationId, int color);

PluginMultiplyIntensityColorAllFramesName

Multiply all frames by the RBG color intensity. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginMultiplyIntensityColorAllFramesName(
 const char* path, int color);

// Class Plugin
ChromaAnimationAPI::MultiplyIntensityColorAllFramesName(
 const char* path, int color);

PluginMultiplyIntensityColorAllFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginMultiplyIntensityColorAllFramesNameD(
 const char* path, double color);

// Class Plugin
double result = ChromaAnimationAPI::MultiplyIntensityColorAllFramesNameD(
 const char* path, double color);

PluginMultiplyIntensityColorName

Multiply the specific frame by the RBG color intensity. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginMultiplyIntensityColorName(
 const char* path, int frameId, int color);

// Class Plugin
ChromaAnimationAPI::MultiplyIntensityColorName(
 const char* path, int frameId, int color);

PluginMultiplyIntensityColorNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginMultiplyIntensityColorNameD(
 const char* path, double frameId, double color);

// Class Plugin
double result = ChromaAnimationAPI::MultiplyIntensityColorNameD(
 const char* path, double frameId, double color);

PluginMultiplyIntensityName

Multiply all the colors in the frame by the intensity value. The valid the intensity range is from 0.0 to 255.0. RGB components are multiplied equally. An intensity of 0.5 would half the color value. Black colors in the frame will not be affected by this method.

// DLL Interface
EXPORT_API void PluginMultiplyIntensityName(
 const char* path, int frameId, float intensity);

// Class Plugin
ChromaAnimationAPI::MultiplyIntensityName(
 const char* path, int frameId, float intensity);

PluginMultiplyIntensityNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginMultiplyIntensityNameD(
 const char* path, double frameId, double intensity);

// Class Plugin
double result = ChromaAnimationAPI::MultiplyIntensityNameD(
 const char* path, double frameId, double intensity);

PluginMultiplyIntensityRGB

Multiply the specific frame by the RBG color intensity. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginMultiplyIntensityRGB(
 int animationId, int frameId, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::MultiplyIntensityRGB(
 int animationId, int frameId, int red, int green, int blue);

PluginMultiplyIntensityRGBName

Multiply the specific frame by the RBG color intensity. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginMultiplyIntensityRGBName(
 const char* path, int frameId, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::MultiplyIntensityRGBName(
 const char* path, int frameId, int red, int green, int blue);

PluginMultiplyIntensityRGBNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginMultiplyIntensityRGBNameD(
 const char* path, double frameId, double red, double green, double blue);

// Class Plugin
double result = ChromaAnimationAPI::MultiplyIntensityRGBNameD(
 const char* path, double frameId, double red, double green, double blue);

PluginMultiplyNonZeroTargetColorLerp

Multiply the specific frame by the color lerp result between color 1 and 2 using the frame color value as the t value. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginMultiplyNonZeroTargetColorLerp(
 int animationId, int frameId, int color1, int color2);

// Class Plugin
ChromaAnimationAPI::MultiplyNonZeroTargetColorLerp(
 int animationId, int frameId, int color1, int color2);

PluginMultiplyNonZeroTargetColorLerpAllFrames

Multiply all frames by the color lerp result between color 1 and 2 using the frame color value as the t value. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginMultiplyNonZeroTargetColorLerpAllFrames(
 int animationId, int color1, int color2);

// Class Plugin
ChromaAnimationAPI::MultiplyNonZeroTargetColorLerpAllFrames(
 int animationId, int color1, int color2);

PluginMultiplyNonZeroTargetColorLerpAllFramesName

Multiply all frames by the color lerp result between color 1 and 2 using the frame color value as the t value. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginMultiplyNonZeroTargetColorLerpAllFramesName(
 const char* path, int color1, int color2);

// Class Plugin
ChromaAnimationAPI::MultiplyNonZeroTargetColorLerpAllFramesName(
 const char* path, int color1, int color2);

PluginMultiplyNonZeroTargetColorLerpAllFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginMultiplyNonZeroTargetColorLerpAllFramesNameD(
 const char* path, double color1, double color2);

// Class Plugin
double result = ChromaAnimationAPI::MultiplyNonZeroTargetColorLerpAllFramesNameD(
 const char* path, double color1, double color2);

PluginMultiplyNonZeroTargetColorLerpAllFramesRGB

Multiply the specific frame by the color lerp result between RGB 1 and 2 using the frame color value as the t value. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginMultiplyNonZeroTargetColorLerpAllFramesRGB(
 int animationId, int red1, int green1, int blue1, int red2, int green2, int blue2);

// Class Plugin
ChromaAnimationAPI::MultiplyNonZeroTargetColorLerpAllFramesRGB(
 int animationId, int red1, int green1, int blue1, int red2, int green2, int blue2);

PluginMultiplyNonZeroTargetColorLerpAllFramesRGBName

Multiply the specific frame by the color lerp result between RGB 1 and 2 using the frame color value as the t value. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginMultiplyNonZeroTargetColorLerpAllFramesRGBName(
 const char* path, int red1, int green1, int blue1, int red2, int green2,
 int blue2);

// Class Plugin
ChromaAnimationAPI::MultiplyNonZeroTargetColorLerpAllFramesRGBName(
 const char* path, int red1, int green1, int blue1, int red2, int green2,
 int blue2);

PluginMultiplyNonZeroTargetColorLerpAllFramesRGBNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginMultiplyNonZeroTargetColorLerpAllFramesRGBNameD(
 const char* path, double red1, double green1, double blue1, double red2,
 double green2, double blue2);

// Class Plugin
double result = ChromaAnimationAPI::MultiplyNonZeroTargetColorLerpAllFramesRGBNameD(
 const char* path, double red1, double green1, double blue1, double red2,
 double green2, double blue2);

PluginMultiplyTargetColorLerp

Multiply the specific frame by the color lerp result between color 1 and 2 using the frame color value as the t value. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginMultiplyTargetColorLerp(
 int animationId, int frameId, int color1, int color2);

// Class Plugin
ChromaAnimationAPI::MultiplyTargetColorLerp(
 int animationId, int frameId, int color1, int color2);

PluginMultiplyTargetColorLerpAllFrames

Multiply all frames by the color lerp result between color 1 and 2 using the frame color value as the t value. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginMultiplyTargetColorLerpAllFrames(
 int animationId, int color1, int color2);

// Class Plugin
ChromaAnimationAPI::MultiplyTargetColorLerpAllFrames(
 int animationId, int color1, int color2);

PluginMultiplyTargetColorLerpAllFramesName

Multiply all frames by the color lerp result between color 1 and 2 using the frame color value as the t value. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginMultiplyTargetColorLerpAllFramesName(
 const char* path, int color1, int color2);

// Class Plugin
ChromaAnimationAPI::MultiplyTargetColorLerpAllFramesName(
 const char* path, int color1, int color2);

PluginMultiplyTargetColorLerpAllFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginMultiplyTargetColorLerpAllFramesNameD(
 const char* path, double color1, double color2);

// Class Plugin
double result = ChromaAnimationAPI::MultiplyTargetColorLerpAllFramesNameD(
 const char* path, double color1, double color2);

PluginMultiplyTargetColorLerpAllFramesRGB

Multiply all frames by the color lerp result between RGB 1 and 2 using the frame color value as the t value. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginMultiplyTargetColorLerpAllFramesRGB(
 int animationId, int red1, int green1, int blue1, int red2, int green2, int blue2);

// Class Plugin
ChromaAnimationAPI::MultiplyTargetColorLerpAllFramesRGB(
 int animationId, int red1, int green1, int blue1, int red2, int green2, int blue2);

PluginMultiplyTargetColorLerpAllFramesRGBName

Multiply all frames by the color lerp result between RGB 1 and 2 using the frame color value as the t value. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginMultiplyTargetColorLerpAllFramesRGBName(
 const char* path, int red1, int green1, int blue1, int red2, int green2,
 int blue2);

// Class Plugin
ChromaAnimationAPI::MultiplyTargetColorLerpAllFramesRGBName(
 const char* path, int red1, int green1, int blue1, int red2, int green2,
 int blue2);

PluginMultiplyTargetColorLerpAllFramesRGBNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginMultiplyTargetColorLerpAllFramesRGBNameD(
 const char* path, double red1, double green1, double blue1, double red2,
 double green2, double blue2);

// Class Plugin
double result = ChromaAnimationAPI::MultiplyTargetColorLerpAllFramesRGBNameD(
 const char* path, double red1, double green1, double blue1, double red2,
 double green2, double blue2);

PluginMultiplyTargetColorLerpName

Multiply the specific frame by the color lerp result between color 1 and 2 using the frame color value as the t value. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginMultiplyTargetColorLerpName(
 const char* path, int frameId, int color1, int color2);

// Class Plugin
ChromaAnimationAPI::MultiplyTargetColorLerpName(
 const char* path, int frameId, int color1, int color2);

PluginOffsetColors

Offset all colors in the frame using the RGB offset. Use the range of -255 to 255 for red, green, and blue parameters. Negative values remove color. Positive values add color.

// DLL Interface
EXPORT_API void PluginOffsetColors(
 int animationId, int frameId, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::OffsetColors(
 int animationId, int frameId, int red, int green, int blue);

PluginOffsetColorsAllFrames

Offset all colors for all frames using the RGB offset. Use the range of -255 to 255 for red, green, and blue parameters. Negative values remove color. Positive values add color.

// DLL Interface
EXPORT_API void PluginOffsetColorsAllFrames(
 int animationId, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::OffsetColorsAllFrames(
 int animationId, int red, int green, int blue);

PluginOffsetColorsAllFramesName

Offset all colors for all frames using the RGB offset. Use the range of -255 to 255 for red, green, and blue parameters. Negative values remove color. Positive values add color.

// DLL Interface
EXPORT_API void PluginOffsetColorsAllFramesName(
 const char* path, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::OffsetColorsAllFramesName(
 const char* path, int red, int green, int blue);

PluginOffsetColorsAllFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginOffsetColorsAllFramesNameD(
 const char* path, double red, double green, double blue);

// Class Plugin
double result = ChromaAnimationAPI::OffsetColorsAllFramesNameD(
 const char* path, double red, double green, double blue);

PluginOffsetColorsName

Offset all colors in the frame using the RGB offset. Use the range of -255 to 255 for red, green, and blue parameters. Negative values remove color. Positive values add color.

// DLL Interface
EXPORT_API void PluginOffsetColorsName(
 const char* path, int frameId, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::OffsetColorsName(
 const char* path, int frameId, int red, int green, int blue);

PluginOffsetColorsNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginOffsetColorsNameD(
 const char* path, double frameId, double red, double green, double blue);

// Class Plugin
double result = ChromaAnimationAPI::OffsetColorsNameD(
 const char* path, double frameId, double red, double green, double blue);

PluginOffsetNonZeroColors

This method will only update colors in the animation that are not already set to black. Offset a subset of colors in the frame using the RGB offset. Use the range of -255 to 255 for red, green, and blue parameters. Negative values remove color. Positive values add color.

// DLL Interface
EXPORT_API void PluginOffsetNonZeroColors(
 int animationId, int frameId, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::OffsetNonZeroColors(
 int animationId, int frameId, int red, int green, int blue);

PluginOffsetNonZeroColorsAllFrames

This method will only update colors in the animation that are not already set to black. Offset a subset of colors for all frames using the RGB offset. Use the range of -255 to 255 for red, green, and blue parameters. Negative values remove color. Positive values add color.

// DLL Interface
EXPORT_API void PluginOffsetNonZeroColorsAllFrames(
 int animationId, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::OffsetNonZeroColorsAllFrames(
 int animationId, int red, int green, int blue);

PluginOffsetNonZeroColorsAllFramesName

This method will only update colors in the animation that are not already set to black. Offset a subset of colors for all frames using the RGB offset. Use the range of -255 to 255 for red, green, and blue parameters. Negative values remove color. Positive values add color.

// DLL Interface
EXPORT_API void PluginOffsetNonZeroColorsAllFramesName(
 const char* path, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::OffsetNonZeroColorsAllFramesName(
 const char* path, int red, int green, int blue);

PluginOffsetNonZeroColorsAllFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginOffsetNonZeroColorsAllFramesNameD(
 const char* path, double red, double green, double blue);

// Class Plugin
double result = ChromaAnimationAPI::OffsetNonZeroColorsAllFramesNameD(
 const char* path, double red, double green, double blue);

PluginOffsetNonZeroColorsName

This method will only update colors in the animation that are not already set to black. Offset a subset of colors in the frame using the RGB offset. Use the range of -255 to 255 for red, green, and blue parameters. Negative values remove color. Positive values add color.

// DLL Interface
EXPORT_API void PluginOffsetNonZeroColorsName(
 const char* path, int frameId, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::OffsetNonZeroColorsName(
 const char* path, int frameId, int red, int green, int blue);

PluginOffsetNonZeroColorsNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginOffsetNonZeroColorsNameD(
 const char* path, double frameId, double red, double green, double blue);

// Class Plugin
double result = ChromaAnimationAPI::OffsetNonZeroColorsNameD(
 const char* path, double frameId, double red, double green, double blue);

PluginOpenAnimation

Opens a Chroma animation file so that it can be played. Returns an animation id >= 0 upon success. Returns negative one if there was a failure. The animation id is used in most of the API methods.

// DLL Interface
EXPORT_API int PluginOpenAnimation(const char* path);

// Class Plugin
int result = ChromaAnimationAPI::OpenAnimation(const char* path);

PluginOpenAnimationD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginOpenAnimationD(const char* path);

// Class Plugin
double result = ChromaAnimationAPI::OpenAnimationD(const char* path);

PluginOpenAnimationFromMemory

Opens a Chroma animation data from memory so that it can be played. Data is a pointer to BYTE array of the loaded animation in memory. Name will be assigned to the animation when loaded. Returns an animation id >= 0 upon success. Returns negative one if there was a failure. The animation id is used in most of the API methods.

// DLL Interface
EXPORT_API int PluginOpenAnimationFromMemory(
 const BYTE* data, const char* name);

// Class Plugin
int result = ChromaAnimationAPI::OpenAnimationFromMemory(
 const BYTE* data, const char* name);

PluginOpenEditorDialog

Opens a Chroma animation file with the .chroma extension. Returns zero upon success. Returns negative one if there was a failure.

// DLL Interface
EXPORT_API int PluginOpenEditorDialog(const char* path);

// Class Plugin
int result = ChromaAnimationAPI::OpenEditorDialog(const char* path);

PluginOpenEditorDialogAndPlay

Open the named animation in the editor dialog and play the animation at start.

// DLL Interface
EXPORT_API int PluginOpenEditorDialogAndPlay(const char* path);

// Class Plugin
int result = ChromaAnimationAPI::OpenEditorDialogAndPlay(const char* path);

PluginOpenEditorDialogAndPlayD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginOpenEditorDialogAndPlayD(const char* path);

// Class Plugin
double result = ChromaAnimationAPI::OpenEditorDialogAndPlayD(const char* path);

PluginOpenEditorDialogD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginOpenEditorDialogD(const char* path);

// Class Plugin
double result = ChromaAnimationAPI::OpenEditorDialogD(const char* path);

PluginOverrideFrameDuration

Sets the duration for all grames in the Chroma animation to the duration parameter. Returns the animation id upon success. Returns negative one upon failure.

// DLL Interface
EXPORT_API int PluginOverrideFrameDuration(
 int animationId, float duration);

// Class Plugin
int result = ChromaAnimationAPI::OverrideFrameDuration(
 int animationId, float duration);

PluginOverrideFrameDurationD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginOverrideFrameDurationD(
 double animationId, double duration);

// Class Plugin
double result = ChromaAnimationAPI::OverrideFrameDurationD(
 double animationId, double duration);

PluginOverrideFrameDurationName

Override the duration of all frames with the duration value. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginOverrideFrameDurationName(
 const char* path, float duration);

// Class Plugin
ChromaAnimationAPI::OverrideFrameDurationName(
 const char* path, float duration);

PluginPauseAnimation

Pause the current animation referenced by id.

// DLL Interface
EXPORT_API void PluginPauseAnimation(int animationId);

// Class Plugin
ChromaAnimationAPI::PauseAnimation(int animationId);

PluginPauseAnimationName

Pause the current animation referenced by name.

// DLL Interface
EXPORT_API void PluginPauseAnimationName(const char* path);

// Class Plugin
ChromaAnimationAPI::PauseAnimationName(const char* path);

PluginPauseAnimationNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginPauseAnimationNameD(const char* path);

// Class Plugin
double result = ChromaAnimationAPI::PauseAnimationNameD(const char* path);

PluginPlayAnimation

Plays the Chroma animation. This will load the animation, if not loaded previously. Returns the animation id upon success. Returns negative one upon failure.

// DLL Interface
EXPORT_API int PluginPlayAnimation(int animationId);

// Class Plugin
int result = ChromaAnimationAPI::PlayAnimation(int animationId);

PluginPlayAnimationD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginPlayAnimationD(double animationId);

// Class Plugin
double result = ChromaAnimationAPI::PlayAnimationD(double animationId);

PluginPlayAnimationFrame

PluginPlayAnimationFrame automatically handles initializing the ChromaSDK. The method will play the animation given the animationId with looping on or off starting at the frameId.

// DLL Interface
EXPORT_API void PluginPlayAnimationFrame(
 int animationId, int frameId, bool loop);

// Class Plugin
ChromaAnimationAPI::PlayAnimationFrame(
 int animationId, int frameId, bool loop);

PluginPlayAnimationFrameName

PluginPlayAnimationFrameName automatically handles initializing the ChromaSDK. The named .chroma animation file will be automatically opened. The animation will play with looping on or off starting at the frameId.

// DLL Interface
EXPORT_API void PluginPlayAnimationFrameName(
 const char* path, int frameId, bool loop);

// Class Plugin
ChromaAnimationAPI::PlayAnimationFrameName(
 const char* path, int frameId, bool loop);

PluginPlayAnimationFrameNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginPlayAnimationFrameNameD(
 const char* path, double frameId, double loop);

// Class Plugin
double result = ChromaAnimationAPI::PlayAnimationFrameNameD(
 const char* path, double frameId, double loop);

PluginPlayAnimationLoop

PluginPlayAnimationLoop automatically handles initializing the ChromaSDK. The method will play the animation given the animationId with looping on or off.

// DLL Interface
EXPORT_API void PluginPlayAnimationLoop(
 int animationId, bool loop);

// Class Plugin
ChromaAnimationAPI::PlayAnimationLoop(
 int animationId, bool loop);

PluginPlayAnimationName

PluginPlayAnimationName automatically handles initializing the ChromaSDK. The named .chroma animation file will be automatically opened. The animation will play with looping on or off.

// DLL Interface
EXPORT_API void PluginPlayAnimationName(
 const char* path, bool loop);

// Class Plugin
ChromaAnimationAPI::PlayAnimationName(
 const char* path, bool loop);

PluginPlayAnimationNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginPlayAnimationNameD(
 const char* path, double loop);

// Class Plugin
double result = ChromaAnimationAPI::PlayAnimationNameD(
 const char* path, double loop);

PluginPlayComposite

PluginPlayComposite automatically handles initializing the ChromaSDK. The named animation files for the .chroma set will be automatically opened. The set of animations will play with looping on or off.

// DLL Interface
EXPORT_API void PluginPlayComposite(
 const char* name, bool loop);

// Class Plugin
ChromaAnimationAPI::PlayComposite(
 const char* name, bool loop);

PluginPlayCompositeD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginPlayCompositeD(
 const char* name, double loop);

// Class Plugin
double result = ChromaAnimationAPI::PlayCompositeD(
 const char* name, double loop);

PluginPreviewFrame

Displays the Chroma animation frame on Chroma hardware given the frameIndex. Returns the animation id upon success. Returns negative one upon failure.

// DLL Interface
EXPORT_API int PluginPreviewFrame(
 int animationId, int frameIndex);

// Class Plugin
int result = ChromaAnimationAPI::PreviewFrame(
 int animationId, int frameIndex);

PluginPreviewFrameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginPreviewFrameD(
 double animationId, double frameIndex);

// Class Plugin
double result = ChromaAnimationAPI::PreviewFrameD(
 double animationId, double frameIndex);

PluginPreviewFrameName

Displays the Chroma animation frame on Chroma hardware given the frameIndex. Animaton is referenced by name.

// DLL Interface
EXPORT_API void PluginPreviewFrameName(
 const char* path, int frameIndex);

// Class Plugin
ChromaAnimationAPI::PreviewFrameName(
 const char* path, int frameIndex);

PluginReduceFrames

Reduce the frames of the animation by removing every nth element. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginReduceFrames(
 int animationId, int n);

// Class Plugin
ChromaAnimationAPI::ReduceFrames(
 int animationId, int n);

PluginReduceFramesName

Reduce the frames of the animation by removing every nth element. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginReduceFramesName(
 const char* path, int n);

// Class Plugin
ChromaAnimationAPI::ReduceFramesName(
 const char* path, int n);

PluginReduceFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginReduceFramesNameD(
 const char* path, double n);

// Class Plugin
double result = ChromaAnimationAPI::ReduceFramesNameD(
 const char* path, double n);

PluginResetAnimation

Resets the Chroma animation to 1 blank frame. Returns the animation id upon success. Returns negative one upon failure.

// DLL Interface
EXPORT_API int PluginResetAnimation(int animationId);

// Class Plugin
int result = ChromaAnimationAPI::ResetAnimation(int animationId);

PluginResumeAnimation

Resume the animation with loop ON or OFF referenced by id.

// DLL Interface
EXPORT_API void PluginResumeAnimation(
 int animationId, bool loop);

// Class Plugin
ChromaAnimationAPI::ResumeAnimation(
 int animationId, bool loop);

PluginResumeAnimationName

Resume the animation with loop ON or OFF referenced by name.

// DLL Interface
EXPORT_API void PluginResumeAnimationName(
 const char* path, bool loop);

// Class Plugin
ChromaAnimationAPI::ResumeAnimationName(
 const char* path, bool loop);

PluginResumeAnimationNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginResumeAnimationNameD(
 const char* path, double loop);

// Class Plugin
double result = ChromaAnimationAPI::ResumeAnimationNameD(
 const char* path, double loop);

PluginReverse

Reverse the animation frame order of the Chroma animation. Returns the animation id upon success. Returns negative one upon failure. Animation is referenced by id.

// DLL Interface
EXPORT_API int PluginReverse(int animationId);

// Class Plugin
int result = ChromaAnimationAPI::Reverse(int animationId);

PluginReverseAllFrames

Reverse the animation frame order of the Chroma animation. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginReverseAllFrames(int animationId);

// Class Plugin
ChromaAnimationAPI::ReverseAllFrames(int animationId);

PluginReverseAllFramesName

Reverse the animation frame order of the Chroma animation. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginReverseAllFramesName(const char* path);

// Class Plugin
ChromaAnimationAPI::ReverseAllFramesName(const char* path);

PluginReverseAllFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginReverseAllFramesNameD(const char* path);

// Class Plugin
double result = ChromaAnimationAPI::ReverseAllFramesNameD(const char* path);

PluginSaveAnimation

Save the animation referenced by id to the path specified.

// DLL Interface
EXPORT_API int PluginSaveAnimation(
 int animationId, const char* path);

// Class Plugin
int result = ChromaAnimationAPI::SaveAnimation(
 int animationId, const char* path);

PluginSaveAnimationName

Save the named animation to the target path specified.

// DLL Interface
EXPORT_API int PluginSaveAnimationName(
 const char* sourceAnimation, const char* targetAnimation);

// Class Plugin
int result = ChromaAnimationAPI::SaveAnimationName(
 const char* sourceAnimation, const char* targetAnimation);

PluginSet1DColor

Set the animation color for a frame given the 1D led. The led should be greater than or equal to 0 and less than the MaxLeds. The animation is referenced by id.

// DLL Interface
EXPORT_API void PluginSet1DColor(
 int animationId, int frameId, int led, int color);

// Class Plugin
ChromaAnimationAPI::Set1DColor(
 int animationId, int frameId, int led, int color);

PluginSet1DColorName

Set the animation color for a frame given the 1D led. The led should be greater than or equal to 0 and less than the MaxLeds. The animation is referenced by name.

// DLL Interface
EXPORT_API void PluginSet1DColorName(
 const char* path, int frameId, int led, int color);

// Class Plugin
ChromaAnimationAPI::Set1DColorName(
 const char* path, int frameId, int led, int color);

PluginSet1DColorNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginSet1DColorNameD(
 const char* path, double frameId, double led, double color);

// Class Plugin
double result = ChromaAnimationAPI::Set1DColorNameD(
 const char* path, double frameId, double led, double color);

PluginSet2DColor

Set the animation color for a frame given the 2D row and column. The row should be greater than or equal to 0 and less than the MaxRow. The column should be greater than or equal to 0 and less than the MaxColumn. The animation is referenced by id.

// DLL Interface
EXPORT_API void PluginSet2DColor(
 int animationId, int frameId, int row, int column, int color);

// Class Plugin
ChromaAnimationAPI::Set2DColor(
 int animationId, int frameId, int row, int column, int color);

PluginSet2DColorName

Set the animation color for a frame given the 2D row and column. The row should be greater than or equal to 0 and less than the MaxRow. The column should be greater than or equal to 0 and less than the MaxColumn. The animation is referenced by name.

// DLL Interface
EXPORT_API void PluginSet2DColorName(
 const char* path, int frameId, int row, int column, int color);

// Class Plugin
ChromaAnimationAPI::Set2DColorName(
 const char* path, int frameId, int row, int column, int color);

PluginSet2DColorNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginSet2DColorNameD(
 const char* path, double frameId, double rowColumnIndex, double color);

// Class Plugin
double result = ChromaAnimationAPI::Set2DColorNameD(
 const char* path, double frameId, double rowColumnIndex, double color);

PluginSetChromaCustomColorAllFrames

When custom color is set, the custom key mode will be used. The animation is referenced by id.

// DLL Interface
EXPORT_API void PluginSetChromaCustomColorAllFrames(int animationId);

// Class Plugin
ChromaAnimationAPI::SetChromaCustomColorAllFrames(int animationId);

PluginSetChromaCustomColorAllFramesName

When custom color is set, the custom key mode will be used. The animation is referenced by name.

// DLL Interface
EXPORT_API void PluginSetChromaCustomColorAllFramesName(const char* path);

// Class Plugin
ChromaAnimationAPI::SetChromaCustomColorAllFramesName(const char* path);

PluginSetChromaCustomColorAllFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginSetChromaCustomColorAllFramesNameD(const char* path);

// Class Plugin
double result = ChromaAnimationAPI::SetChromaCustomColorAllFramesNameD(const char* path);

PluginSetChromaCustomFlag

Set the Chroma custom key color flag on all frames. True changes the layout from grid to key. True changes the layout from key to grid. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginSetChromaCustomFlag(
 int animationId, bool flag);

// Class Plugin
ChromaAnimationAPI::SetChromaCustomFlag(
 int animationId, bool flag);

PluginSetChromaCustomFlagName

Set the Chroma custom key color flag on all frames. True changes the layout from grid to key. True changes the layout from key to grid. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginSetChromaCustomFlagName(
 const char* path, bool flag);

// Class Plugin
ChromaAnimationAPI::SetChromaCustomFlagName(
 const char* path, bool flag);

PluginSetChromaCustomFlagNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginSetChromaCustomFlagNameD(
 const char* path, double flag);

// Class Plugin
double result = ChromaAnimationAPI::SetChromaCustomFlagNameD(
 const char* path, double flag);

PluginSetCurrentFrame

Set the current frame of the animation referenced by id.

// DLL Interface
EXPORT_API void PluginSetCurrentFrame(
 int animationId, int frameId);

// Class Plugin
ChromaAnimationAPI::SetCurrentFrame(
 int animationId, int frameId);

PluginSetCurrentFrameName

Set the current frame of the animation referenced by name.

// DLL Interface
EXPORT_API void PluginSetCurrentFrameName(
 const char* path, int frameId);

// Class Plugin
ChromaAnimationAPI::SetCurrentFrameName(
 const char* path, int frameId);

PluginSetCurrentFrameNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginSetCurrentFrameNameD(
 const char* path, double frameId);

// Class Plugin
double result = ChromaAnimationAPI::SetCurrentFrameNameD(
 const char* path, double frameId);

PluginSetCustomColorFlag2D

Set the custom alpha flag on the color array

// DLL Interface
EXPORT_API RZRESULT PluginSetCustomColorFlag2D(
 int device, int* colors);

// Class Plugin
RZRESULT result = ChromaAnimationAPI::SetCustomColorFlag2D(
 int device, int* colors);

PluginSetDevice

Changes the deviceType and device of a Chroma animation. If the device is changed, the Chroma animation will be reset with 1 blank frame. Returns the animation id upon success. Returns negative one upon failure.

// DLL Interface
EXPORT_API int PluginSetDevice(
 int animationId, int deviceType, int device);

// Class Plugin
int result = ChromaAnimationAPI::SetDevice(
 int animationId, int deviceType, int device);

PluginSetEffect

SetEffect will display the referenced effect id.

// DLL Interface
EXPORT_API RZRESULT PluginSetEffect(
 const ChromaSDK::FChromaSDKGuid& effectId);

// Class Plugin
RZRESULT result = ChromaAnimationAPI::SetEffect(
 const ChromaSDK::FChromaSDKGuid& effectId);

PluginSetEffectCustom1D

SetEffectCustom1D will display the referenced colors immediately

// DLL Interface
EXPORT_API RZRESULT PluginSetEffectCustom1D(
 const int device, const int* colors);

// Class Plugin
RZRESULT result = ChromaAnimationAPI::SetEffectCustom1D(
 const int device, const int* colors);

PluginSetEffectCustom2D

SetEffectCustom2D will display the referenced colors immediately.

// DLL Interface
EXPORT_API RZRESULT PluginSetEffectCustom2D(
 const int device, const int* colors);

// Class Plugin
RZRESULT result = ChromaAnimationAPI::SetEffectCustom2D(
 const int device, const int* colors);

PluginSetEffectKeyboardCustom2D

SetEffectKeyboardCustom2D will display the referenced custom keyboard colors immediately. Colors represent a visual grid layout. Keys represent the hotkeys for any layout.

// DLL Interface
EXPORT_API RZRESULT PluginSetEffectKeyboardCustom2D(
 const int device, const int* colors, const int* keys);

// Class Plugin
RZRESULT result = ChromaAnimationAPI::SetEffectKeyboardCustom2D(
 const int device, const int* colors, const int* keys);

PluginSetIdleAnimation

When the idle animation is used, the named animation will play when no other animations are playing. Reference the animation by id.

// DLL Interface
EXPORT_API void PluginSetIdleAnimation(int animationId);

// Class Plugin
ChromaAnimationAPI::SetIdleAnimation(int animationId);

PluginSetIdleAnimationName

When the idle animation is used, the named animation will play when no other animations are playing. Reference the animation by name.

// DLL Interface
EXPORT_API void PluginSetIdleAnimationName(const char* path);

// Class Plugin
ChromaAnimationAPI::SetIdleAnimationName(const char* path);

PluginSetKeyColor

Set animation key to a static color for the given frame.

// DLL Interface
EXPORT_API void PluginSetKeyColor(
 int animationId, int frameId, int rzkey, int color);

// Class Plugin
ChromaAnimationAPI::SetKeyColor(
 int animationId, int frameId, int rzkey, int color);

PluginSetKeyColorAllFrames

Set the key to the specified key color for all frames. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginSetKeyColorAllFrames(
 int animationId, int rzkey, int color);

// Class Plugin
ChromaAnimationAPI::SetKeyColorAllFrames(
 int animationId, int rzkey, int color);

PluginSetKeyColorAllFramesName

Set the key to the specified key color for all frames. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginSetKeyColorAllFramesName(
 const char* path, int rzkey, int color);

// Class Plugin
ChromaAnimationAPI::SetKeyColorAllFramesName(
 const char* path, int rzkey, int color);

PluginSetKeyColorAllFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginSetKeyColorAllFramesNameD(
 const char* path, double rzkey, double color);

// Class Plugin
double result = ChromaAnimationAPI::SetKeyColorAllFramesNameD(
 const char* path, double rzkey, double color);

PluginSetKeyColorAllFramesRGB

Set the key to the specified key color for all frames. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginSetKeyColorAllFramesRGB(
 int animationId, int rzkey, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::SetKeyColorAllFramesRGB(
 int animationId, int rzkey, int red, int green, int blue);

PluginSetKeyColorAllFramesRGBName

Set the key to the specified key color for all frames. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginSetKeyColorAllFramesRGBName(
 const char* path, int rzkey, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::SetKeyColorAllFramesRGBName(
 const char* path, int rzkey, int red, int green, int blue);

PluginSetKeyColorAllFramesRGBNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginSetKeyColorAllFramesRGBNameD(
 const char* path, double rzkey, double red, double green, double blue);

// Class Plugin
double result = ChromaAnimationAPI::SetKeyColorAllFramesRGBNameD(
 const char* path, double rzkey, double red, double green, double blue);

PluginSetKeyColorName

Set animation key to a static color for the given frame.

// DLL Interface
EXPORT_API void PluginSetKeyColorName(
 const char* path, int frameId, int rzkey, int color);

// Class Plugin
ChromaAnimationAPI::SetKeyColorName(
 const char* path, int frameId, int rzkey, int color);

PluginSetKeyColorNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginSetKeyColorNameD(
 const char* path, double frameId, double rzkey, double color);

// Class Plugin
double result = ChromaAnimationAPI::SetKeyColorNameD(
 const char* path, double frameId, double rzkey, double color);

PluginSetKeyColorRGB

Set the key to the specified key color for the specified frame. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginSetKeyColorRGB(
 int animationId, int frameId, int rzkey, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::SetKeyColorRGB(
 int animationId, int frameId, int rzkey, int red, int green, int blue);

PluginSetKeyColorRGBName

Set the key to the specified key color for the specified frame. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginSetKeyColorRGBName(
 const char* path, int frameId, int rzkey, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::SetKeyColorRGBName(
 const char* path, int frameId, int rzkey, int red, int green, int blue);

PluginSetKeyColorRGBNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginSetKeyColorRGBNameD(
 const char* path, double frameId, double rzkey, double red, double green,
 double blue);

// Class Plugin
double result = ChromaAnimationAPI::SetKeyColorRGBNameD(
 const char* path, double frameId, double rzkey, double red, double green,
 double blue);

PluginSetKeyNonZeroColor

Set animation key to a static color for the given frame if the existing color is not already black.

// DLL Interface
EXPORT_API void PluginSetKeyNonZeroColor(
 int animationId, int frameId, int rzkey, int color);

// Class Plugin
ChromaAnimationAPI::SetKeyNonZeroColor(
 int animationId, int frameId, int rzkey, int color);

PluginSetKeyNonZeroColorName

Set animation key to a static color for the given frame if the existing color is not already black.

// DLL Interface
EXPORT_API void PluginSetKeyNonZeroColorName(
 const char* path, int frameId, int rzkey, int color);

// Class Plugin
ChromaAnimationAPI::SetKeyNonZeroColorName(
 const char* path, int frameId, int rzkey, int color);

PluginSetKeyNonZeroColorNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginSetKeyNonZeroColorNameD(
 const char* path, double frameId, double rzkey, double color);

// Class Plugin
double result = ChromaAnimationAPI::SetKeyNonZeroColorNameD(
 const char* path, double frameId, double rzkey, double color);

PluginSetKeyNonZeroColorRGB

Set the key to the specified key color for the specified frame where color is not black. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginSetKeyNonZeroColorRGB(
 int animationId, int frameId, int rzkey, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::SetKeyNonZeroColorRGB(
 int animationId, int frameId, int rzkey, int red, int green, int blue);

PluginSetKeyNonZeroColorRGBName

Set the key to the specified key color for the specified frame where color is not black. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginSetKeyNonZeroColorRGBName(
 const char* path, int frameId, int rzkey, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::SetKeyNonZeroColorRGBName(
 const char* path, int frameId, int rzkey, int red, int green, int blue);

PluginSetKeyNonZeroColorRGBNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginSetKeyNonZeroColorRGBNameD(
 const char* path, double frameId, double rzkey, double red, double green,
 double blue);

// Class Plugin
double result = ChromaAnimationAPI::SetKeyNonZeroColorRGBNameD(
 const char* path, double frameId, double rzkey, double red, double green,
 double blue);

PluginSetKeyRowColumnColorName

Set animation key by row and column to a static color for the given frame.

// DLL Interface
EXPORT_API void PluginSetKeyRowColumnColorName(
 const char* path, int frameId, int row, int column, int color);

// Class Plugin
ChromaAnimationAPI::SetKeyRowColumnColorName(
 const char* path, int frameId, int row, int column, int color);

PluginSetKeysColor

Set an array of animation keys to a static color for the given frame. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginSetKeysColor(
 int animationId, int frameId, const int* rzkeys, int keyCount, int color);

// Class Plugin
ChromaAnimationAPI::SetKeysColor(
 int animationId, int frameId, const int* rzkeys, int keyCount, int color);

PluginSetKeysColorAllFrames

Set an array of animation keys to a static color for all frames. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginSetKeysColorAllFrames(
 int animationId, const int* rzkeys, int keyCount, int color);

// Class Plugin
ChromaAnimationAPI::SetKeysColorAllFrames(
 int animationId, const int* rzkeys, int keyCount, int color);

PluginSetKeysColorAllFramesName

Set an array of animation keys to a static color for all frames. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginSetKeysColorAllFramesName(
 const char* path, const int* rzkeys, int keyCount, int color);

// Class Plugin
ChromaAnimationAPI::SetKeysColorAllFramesName(
 const char* path, const int* rzkeys, int keyCount, int color);

PluginSetKeysColorAllFramesRGB

Set an array of animation keys to a static color for all frames. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginSetKeysColorAllFramesRGB(
 int animationId, const int* rzkeys, int keyCount, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::SetKeysColorAllFramesRGB(
 int animationId, const int* rzkeys, int keyCount, int red, int green, int blue);

PluginSetKeysColorAllFramesRGBName

Set an array of animation keys to a static color for all frames. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginSetKeysColorAllFramesRGBName(
 const char* path, const int* rzkeys, int keyCount, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::SetKeysColorAllFramesRGBName(
 const char* path, const int* rzkeys, int keyCount, int red, int green, int blue);

PluginSetKeysColorName

Set an array of animation keys to a static color for the given frame.

// DLL Interface
EXPORT_API void PluginSetKeysColorName(
 const char* path, int frameId, const int* rzkeys, int keyCount, int color);

// Class Plugin
ChromaAnimationAPI::SetKeysColorName(
 const char* path, int frameId, const int* rzkeys, int keyCount, int color);

PluginSetKeysColorRGB

Set an array of animation keys to a static color for the given frame. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginSetKeysColorRGB(
 int animationId, int frameId, const int* rzkeys, int keyCount, int red, int green,
 int blue);

// Class Plugin
ChromaAnimationAPI::SetKeysColorRGB(
 int animationId, int frameId, const int* rzkeys, int keyCount, int red, int green,
 int blue);

PluginSetKeysColorRGBName

Set an array of animation keys to a static color for the given frame. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginSetKeysColorRGBName(
 const char* path, int frameId, const int* rzkeys, int keyCount, int red,
 int green, int blue);

// Class Plugin
ChromaAnimationAPI::SetKeysColorRGBName(
 const char* path, int frameId, const int* rzkeys, int keyCount, int red,
 int green, int blue);

PluginSetKeysNonZeroColor

Set an array of animation keys to a static color for the given frame if the existing color is not already black.

// DLL Interface
EXPORT_API void PluginSetKeysNonZeroColor(
 int animationId, int frameId, const int* rzkeys, int keyCount, int color);

// Class Plugin
ChromaAnimationAPI::SetKeysNonZeroColor(
 int animationId, int frameId, const int* rzkeys, int keyCount, int color);

PluginSetKeysNonZeroColorAllFrames

Set an array of animation keys to a static color for the given frame where the color is not black. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginSetKeysNonZeroColorAllFrames(
 int animationId, const int* rzkeys, int keyCount, int color);

// Class Plugin
ChromaAnimationAPI::SetKeysNonZeroColorAllFrames(
 int animationId, const int* rzkeys, int keyCount, int color);

PluginSetKeysNonZeroColorAllFramesName

Set an array of animation keys to a static color for all frames if the existing color is not already black. Reference animation by name.

// DLL Interface
EXPORT_API void PluginSetKeysNonZeroColorAllFramesName(
 const char* path, const int* rzkeys, int keyCount, int color);

// Class Plugin
ChromaAnimationAPI::SetKeysNonZeroColorAllFramesName(
 const char* path, const int* rzkeys, int keyCount, int color);

PluginSetKeysNonZeroColorName

Set an array of animation keys to a static color for the given frame if the existing color is not already black. Reference animation by name.

// DLL Interface
EXPORT_API void PluginSetKeysNonZeroColorName(
 const char* path, int frameId, const int* rzkeys, int keyCount, int color);

// Class Plugin
ChromaAnimationAPI::SetKeysNonZeroColorName(
 const char* path, int frameId, const int* rzkeys, int keyCount, int color);

PluginSetKeysNonZeroColorRGB

Set an array of animation keys to a static color for the given frame where the color is not black. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginSetKeysNonZeroColorRGB(
 int animationId, int frameId, const int* rzkeys, int keyCount, int red, int green,
 int blue);

// Class Plugin
ChromaAnimationAPI::SetKeysNonZeroColorRGB(
 int animationId, int frameId, const int* rzkeys, int keyCount, int red, int green,
 int blue);

PluginSetKeysNonZeroColorRGBName

Set an array of animation keys to a static color for the given frame where the color is not black. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginSetKeysNonZeroColorRGBName(
 const char* path, int frameId, const int* rzkeys, int keyCount, int red,
 int green, int blue);

// Class Plugin
ChromaAnimationAPI::SetKeysNonZeroColorRGBName(
 const char* path, int frameId, const int* rzkeys, int keyCount, int red,
 int green, int blue);

PluginSetKeysZeroColor

Set an array of animation keys to a static color for the given frame where the color is black. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginSetKeysZeroColor(
 int animationId, int frameId, const int* rzkeys, int keyCount, int color);

// Class Plugin
ChromaAnimationAPI::SetKeysZeroColor(
 int animationId, int frameId, const int* rzkeys, int keyCount, int color);

PluginSetKeysZeroColorAllFrames

Set an array of animation keys to a static color for all frames where the color is black. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginSetKeysZeroColorAllFrames(
 int animationId, const int* rzkeys, int keyCount, int color);

// Class Plugin
ChromaAnimationAPI::SetKeysZeroColorAllFrames(
 int animationId, const int* rzkeys, int keyCount, int color);

PluginSetKeysZeroColorAllFramesName

Set an array of animation keys to a static color for all frames where the color is black. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginSetKeysZeroColorAllFramesName(
 const char* path, const int* rzkeys, int keyCount, int color);

// Class Plugin
ChromaAnimationAPI::SetKeysZeroColorAllFramesName(
 const char* path, const int* rzkeys, int keyCount, int color);

PluginSetKeysZeroColorAllFramesRGB

Set an array of animation keys to a static color for all frames where the color is black. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginSetKeysZeroColorAllFramesRGB(
 int animationId, const int* rzkeys, int keyCount, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::SetKeysZeroColorAllFramesRGB(
 int animationId, const int* rzkeys, int keyCount, int red, int green, int blue);

PluginSetKeysZeroColorAllFramesRGBName

Set an array of animation keys to a static color for all frames where the color is black. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginSetKeysZeroColorAllFramesRGBName(
 const char* path, const int* rzkeys, int keyCount, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::SetKeysZeroColorAllFramesRGBName(
 const char* path, const int* rzkeys, int keyCount, int red, int green, int blue);

PluginSetKeysZeroColorName

Set an array of animation keys to a static color for the given frame where the color is black. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginSetKeysZeroColorName(
 const char* path, int frameId, const int* rzkeys, int keyCount, int color);

// Class Plugin
ChromaAnimationAPI::SetKeysZeroColorName(
 const char* path, int frameId, const int* rzkeys, int keyCount, int color);

PluginSetKeysZeroColorRGB

Set an array of animation keys to a static color for the given frame where the color is black. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginSetKeysZeroColorRGB(
 int animationId, int frameId, const int* rzkeys, int keyCount, int red, int green,
 int blue);

// Class Plugin
ChromaAnimationAPI::SetKeysZeroColorRGB(
 int animationId, int frameId, const int* rzkeys, int keyCount, int red, int green,
 int blue);

PluginSetKeysZeroColorRGBName

Set an array of animation keys to a static color for the given frame where the color is black. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginSetKeysZeroColorRGBName(
 const char* path, int frameId, const int* rzkeys, int keyCount, int red,
 int green, int blue);

// Class Plugin
ChromaAnimationAPI::SetKeysZeroColorRGBName(
 const char* path, int frameId, const int* rzkeys, int keyCount, int red,
 int green, int blue);

PluginSetKeyZeroColor

Set animation key to a static color for the given frame where the color is black. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginSetKeyZeroColor(
 int animationId, int frameId, int rzkey, int color);

// Class Plugin
ChromaAnimationAPI::SetKeyZeroColor(
 int animationId, int frameId, int rzkey, int color);

PluginSetKeyZeroColorName

Set animation key to a static color for the given frame where the color is black. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginSetKeyZeroColorName(
 const char* path, int frameId, int rzkey, int color);

// Class Plugin
ChromaAnimationAPI::SetKeyZeroColorName(
 const char* path, int frameId, int rzkey, int color);

PluginSetKeyZeroColorNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginSetKeyZeroColorNameD(
 const char* path, double frameId, double rzkey, double color);

// Class Plugin
double result = ChromaAnimationAPI::SetKeyZeroColorNameD(
 const char* path, double frameId, double rzkey, double color);

PluginSetKeyZeroColorRGB

Set animation key to a static color for the given frame where the color is black. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginSetKeyZeroColorRGB(
 int animationId, int frameId, int rzkey, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::SetKeyZeroColorRGB(
 int animationId, int frameId, int rzkey, int red, int green, int blue);

PluginSetKeyZeroColorRGBName

Set animation key to a static color for the given frame where the color is black. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginSetKeyZeroColorRGBName(
 const char* path, int frameId, int rzkey, int red, int green, int blue);

// Class Plugin
ChromaAnimationAPI::SetKeyZeroColorRGBName(
 const char* path, int frameId, int rzkey, int red, int green, int blue);

PluginSetKeyZeroColorRGBNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginSetKeyZeroColorRGBNameD(
 const char* path, double frameId, double rzkey, double red, double green,
 double blue);

// Class Plugin
double result = ChromaAnimationAPI::SetKeyZeroColorRGBNameD(
 const char* path, double frameId, double rzkey, double red, double green,
 double blue);

PluginSetLogDelegate

Invokes the setup for a debug logging callback so that stdout is redirected to the callback. This is used by Unity so that debug messages can appear in the console window.

// DLL Interface
EXPORT_API void PluginSetLogDelegate(DebugLogPtr fp);

// Class Plugin
ChromaAnimationAPI::SetLogDelegate(DebugLogPtr fp);

PluginSetStaticColor

Sets the target device to the static color.

// DLL Interface
EXPORT_API void PluginSetStaticColor(
 int deviceType, int device, int color);

// Class Plugin
ChromaAnimationAPI::SetStaticColor(
 int deviceType, int device, int color);

PluginSetStaticColorAll

Sets all devices to the static color.

// DLL Interface
EXPORT_API void PluginSetStaticColorAll(int color);

// Class Plugin
ChromaAnimationAPI::SetStaticColorAll(int color);

PluginStaticColor

Sets the target device to the static color.

// DLL Interface
EXPORT_API void PluginStaticColor(
 int deviceType, int device, int color);

// Class Plugin
ChromaAnimationAPI::StaticColor(
 int deviceType, int device, int color);

PluginStaticColorAll

Sets all devices to the static color.

// DLL Interface
EXPORT_API void PluginStaticColorAll(int color);

// Class Plugin
ChromaAnimationAPI::StaticColorAll(int color);

PluginStaticColorD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginStaticColorD(
 double deviceType, double device, double color);

// Class Plugin
double result = ChromaAnimationAPI::StaticColorD(
 double deviceType, double device, double color);

PluginStopAll

PluginStopAll will automatically stop all animations that are playing.

// DLL Interface
EXPORT_API void PluginStopAll();

// Class Plugin
ChromaAnimationAPI::StopAll();

PluginStopAnimation

Stops animation playback if in progress. Returns the animation id upon success. Returns negative one upon failure.

// DLL Interface
EXPORT_API int PluginStopAnimation(int animationId);

// Class Plugin
int result = ChromaAnimationAPI::StopAnimation(int animationId);

PluginStopAnimationD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginStopAnimationD(double animationId);

// Class Plugin
double result = ChromaAnimationAPI::StopAnimationD(double animationId);

PluginStopAnimationName

PluginStopAnimationName automatically handles initializing the ChromaSDK. The named .chroma animation file will be automatically opened. The animation will stop if playing.

// DLL Interface
EXPORT_API void PluginStopAnimationName(const char* path);

// Class Plugin
ChromaAnimationAPI::StopAnimationName(const char* path);

PluginStopAnimationNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginStopAnimationNameD(const char* path);

// Class Plugin
double result = ChromaAnimationAPI::StopAnimationNameD(const char* path);

PluginStopAnimationType

PluginStopAnimationType automatically handles initializing the ChromaSDK. If any animation is playing for the deviceType and device combination, it will be stopped.

// DLL Interface
EXPORT_API void PluginStopAnimationType(
 int deviceType, int device);

// Class Plugin
ChromaAnimationAPI::StopAnimationType(
 int deviceType, int device);

PluginStopAnimationTypeD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginStopAnimationTypeD(
 double deviceType, double device);

// Class Plugin
double result = ChromaAnimationAPI::StopAnimationTypeD(
 double deviceType, double device);

PluginStopComposite

PluginStopComposite automatically handles initializing the ChromaSDK. The named animation files for the .chroma set will be automatically opened. The set of animations will be stopped if playing.

// DLL Interface
EXPORT_API void PluginStopComposite(const char* name);

// Class Plugin
ChromaAnimationAPI::StopComposite(const char* name);

PluginStopCompositeD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginStopCompositeD(const char* name);

// Class Plugin
double result = ChromaAnimationAPI::StopCompositeD(const char* name);

PluginSubtractColor

Return color1 - color2

// DLL Interface
EXPORT_API int PluginSubtractColor(
 const int color1, const int color2);

// Class Plugin
int result = ChromaAnimationAPI::SubtractColor(
 const int color1, const int color2);

PluginSubtractNonZeroAllKeys

Subtract the source color from the target color for the frame where the target color is not black. Source and target are referenced by id.

// DLL Interface
EXPORT_API void PluginSubtractNonZeroAllKeys(
 int sourceAnimationId, int targetAnimationId, int frameId);

// Class Plugin
ChromaAnimationAPI::SubtractNonZeroAllKeys(
 int sourceAnimationId, int targetAnimationId, int frameId);

PluginSubtractNonZeroAllKeysAllFrames

Subtract the source color from the target color for all frames where the target color is not black. Source and target are referenced by id.

// DLL Interface
EXPORT_API void PluginSubtractNonZeroAllKeysAllFrames(
 int sourceAnimationId, int targetAnimationId);

// Class Plugin
ChromaAnimationAPI::SubtractNonZeroAllKeysAllFrames(
 int sourceAnimationId, int targetAnimationId);

PluginSubtractNonZeroAllKeysAllFramesName

Subtract the source color from the target color for all frames where the target color is not black. Source and target are referenced by name.

// DLL Interface
EXPORT_API void PluginSubtractNonZeroAllKeysAllFramesName(
 const char* sourceAnimation, const char* targetAnimation);

// Class Plugin
ChromaAnimationAPI::SubtractNonZeroAllKeysAllFramesName(
 const char* sourceAnimation, const char* targetAnimation);

PluginSubtractNonZeroAllKeysAllFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginSubtractNonZeroAllKeysAllFramesNameD(
 const char* sourceAnimation, const char* targetAnimation);

// Class Plugin
double result = ChromaAnimationAPI::SubtractNonZeroAllKeysAllFramesNameD(
 const char* sourceAnimation, const char* targetAnimation);

PluginSubtractNonZeroAllKeysAllFramesOffset

Subtract the source color from the target color for all frames where the target color is not black starting at offset for the length of the source. Source and target are referenced by id.

// DLL Interface
EXPORT_API void PluginSubtractNonZeroAllKeysAllFramesOffset(
 int sourceAnimationId, int targetAnimationId, int offset);

// Class Plugin
ChromaAnimationAPI::SubtractNonZeroAllKeysAllFramesOffset(
 int sourceAnimationId, int targetAnimationId, int offset);

PluginSubtractNonZeroAllKeysAllFramesOffsetName

Subtract the source color from the target color for all frames where the target color is not black starting at offset for the length of the source. Source and target are referenced by name.

// DLL Interface
EXPORT_API void PluginSubtractNonZeroAllKeysAllFramesOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int offset);

// Class Plugin
ChromaAnimationAPI::SubtractNonZeroAllKeysAllFramesOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int offset);

PluginSubtractNonZeroAllKeysAllFramesOffsetNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginSubtractNonZeroAllKeysAllFramesOffsetNameD(
 const char* sourceAnimation, const char* targetAnimation, double offset);

// Class Plugin
double result = ChromaAnimationAPI::SubtractNonZeroAllKeysAllFramesOffsetNameD(
 const char* sourceAnimation, const char* targetAnimation, double offset);

PluginSubtractNonZeroAllKeysName

Subtract the source color from the target color for the frame where the target color is not black. Source and target are referenced by name.

// DLL Interface
EXPORT_API void PluginSubtractNonZeroAllKeysName(
 const char* sourceAnimation, const char* targetAnimation, int frameId);

// Class Plugin
ChromaAnimationAPI::SubtractNonZeroAllKeysName(
 const char* sourceAnimation, const char* targetAnimation, int frameId);

PluginSubtractNonZeroAllKeysOffset

Subtract the source color from the target where color is not black for the source frame and target offset frame, reference source and target by id.

// DLL Interface
EXPORT_API void PluginSubtractNonZeroAllKeysOffset(
 int sourceAnimationId, int targetAnimationId, int frameId, int offset);

// Class Plugin
ChromaAnimationAPI::SubtractNonZeroAllKeysOffset(
 int sourceAnimationId, int targetAnimationId, int frameId, int offset);

PluginSubtractNonZeroAllKeysOffsetName

Subtract the source color from the target where color is not black for the source frame and target offset frame, reference source and target by name.

// DLL Interface
EXPORT_API void PluginSubtractNonZeroAllKeysOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int frameId, int offset);

// Class Plugin
ChromaAnimationAPI::SubtractNonZeroAllKeysOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int frameId, int offset);

PluginSubtractNonZeroAllKeysOffsetNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginSubtractNonZeroAllKeysOffsetNameD(
 const char* sourceAnimation, const char* targetAnimation, double frameId,
 double offset);

// Class Plugin
double result = ChromaAnimationAPI::SubtractNonZeroAllKeysOffsetNameD(
 const char* sourceAnimation, const char* targetAnimation, double frameId,
 double offset);

PluginSubtractNonZeroTargetAllKeysAllFrames

Subtract the source color from the target color where the target color is not black for all frames. Reference source and target by id.

// DLL Interface
EXPORT_API void PluginSubtractNonZeroTargetAllKeysAllFrames(
 int sourceAnimationId, int targetAnimationId);

// Class Plugin
ChromaAnimationAPI::SubtractNonZeroTargetAllKeysAllFrames(
 int sourceAnimationId, int targetAnimationId);

PluginSubtractNonZeroTargetAllKeysAllFramesName

Subtract the source color from the target color where the target color is not black for all frames. Reference source and target by name.

// DLL Interface
EXPORT_API void PluginSubtractNonZeroTargetAllKeysAllFramesName(
 const char* sourceAnimation, const char* targetAnimation);

// Class Plugin
ChromaAnimationAPI::SubtractNonZeroTargetAllKeysAllFramesName(
 const char* sourceAnimation, const char* targetAnimation);

PluginSubtractNonZeroTargetAllKeysAllFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginSubtractNonZeroTargetAllKeysAllFramesNameD(
 const char* sourceAnimation, const char* targetAnimation);

// Class Plugin
double result = ChromaAnimationAPI::SubtractNonZeroTargetAllKeysAllFramesNameD(
 const char* sourceAnimation, const char* targetAnimation);

PluginSubtractNonZeroTargetAllKeysAllFramesOffset

Subtract the source color from the target color where the target color is not black for all frames starting at the target offset for the length of the source. Reference source and target by id.

// DLL Interface
EXPORT_API void PluginSubtractNonZeroTargetAllKeysAllFramesOffset(
 int sourceAnimationId, int targetAnimationId, int offset);

// Class Plugin
ChromaAnimationAPI::SubtractNonZeroTargetAllKeysAllFramesOffset(
 int sourceAnimationId, int targetAnimationId, int offset);

PluginSubtractNonZeroTargetAllKeysAllFramesOffsetName

Subtract the source color from the target color where the target color is not black for all frames starting at the target offset for the length of the source. Reference source and target by name.

// DLL Interface
EXPORT_API void PluginSubtractNonZeroTargetAllKeysAllFramesOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int offset);

// Class Plugin
ChromaAnimationAPI::SubtractNonZeroTargetAllKeysAllFramesOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int offset);

PluginSubtractNonZeroTargetAllKeysAllFramesOffsetNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginSubtractNonZeroTargetAllKeysAllFramesOffsetNameD(
 const char* sourceAnimation, const char* targetAnimation, double offset);

// Class Plugin
double result = ChromaAnimationAPI::SubtractNonZeroTargetAllKeysAllFramesOffsetNameD(
 const char* sourceAnimation, const char* targetAnimation, double offset);

PluginSubtractNonZeroTargetAllKeysOffset

Subtract the source color from the target color where the target color is not black from the source frame to the target offset frame. Reference source and target by id.

// DLL Interface
EXPORT_API void PluginSubtractNonZeroTargetAllKeysOffset(
 int sourceAnimationId, int targetAnimationId, int frameId, int offset);

// Class Plugin
ChromaAnimationAPI::SubtractNonZeroTargetAllKeysOffset(
 int sourceAnimationId, int targetAnimationId, int frameId, int offset);

PluginSubtractNonZeroTargetAllKeysOffsetName

Subtract the source color from the target color where the target color is not black from the source frame to the target offset frame. Reference source and target by name.

// DLL Interface
EXPORT_API void PluginSubtractNonZeroTargetAllKeysOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int frameId, int offset);

// Class Plugin
ChromaAnimationAPI::SubtractNonZeroTargetAllKeysOffsetName(
 const char* sourceAnimation, const char* targetAnimation, int frameId, int offset);

PluginSubtractNonZeroTargetAllKeysOffsetNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginSubtractNonZeroTargetAllKeysOffsetNameD(
 const char* sourceAnimation, const char* targetAnimation, double frameId,
 double offset);

// Class Plugin
double result = ChromaAnimationAPI::SubtractNonZeroTargetAllKeysOffsetNameD(
 const char* sourceAnimation, const char* targetAnimation, double frameId,
 double offset);

PluginSubtractThresholdColorsMinMaxAllFramesRGB

Subtract all frames with the min RGB color where the animation color is less than the min threshold AND with the max RGB color where the animation is more than the max threshold. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginSubtractThresholdColorsMinMaxAllFramesRGB(
 const int animationId, const int minThreshold, const int minRed, const int minGreen,
 const int minBlue, const int maxThreshold, const int maxRed, const int maxGreen,
 const int maxBlue);

// Class Plugin
ChromaAnimationAPI::SubtractThresholdColorsMinMaxAllFramesRGB(
 const int animationId, const int minThreshold, const int minRed, const int minGreen,
 const int minBlue, const int maxThreshold, const int maxRed, const int maxGreen,
 const int maxBlue);

PluginSubtractThresholdColorsMinMaxAllFramesRGBName

Subtract all frames with the min RGB color where the animation color is less than the min threshold AND with the max RGB color where the animation is more than the max threshold. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginSubtractThresholdColorsMinMaxAllFramesRGBName(
 const char* path, const int minThreshold, const int minRed, const int minGreen,
 const int minBlue, const int maxThreshold, const int maxRed, const int maxGreen,
 const int maxBlue);

// Class Plugin
ChromaAnimationAPI::SubtractThresholdColorsMinMaxAllFramesRGBName(
 const char* path, const int minThreshold, const int minRed, const int minGreen,
 const int minBlue, const int maxThreshold, const int maxRed, const int maxGreen,
 const int maxBlue);

PluginSubtractThresholdColorsMinMaxAllFramesRGBNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginSubtractThresholdColorsMinMaxAllFramesRGBNameD(
 const char* path, double minThreshold, double minRed, double minGreen, double minBlue,
 double maxThreshold, double maxRed, double maxGreen, double maxBlue);

// Class Plugin
double result = ChromaAnimationAPI::SubtractThresholdColorsMinMaxAllFramesRGBNameD(
 const char* path, double minThreshold, double minRed, double minGreen, double minBlue,
 double maxThreshold, double maxRed, double maxGreen, double maxBlue);

PluginSubtractThresholdColorsMinMaxRGB

Subtract the specified frame with the min RGB color where the animation color is less than the min threshold AND with the max RGB color where the animation is more than the max threshold. Animation is referenced by id.

// DLL Interface
EXPORT_API void PluginSubtractThresholdColorsMinMaxRGB(
 const int animationId, const int frameId, const int minThreshold, const int minRed,
 const int minGreen, const int minBlue, const int maxThreshold, const int maxRed,
 const int maxGreen, const int maxBlue);

// Class Plugin
ChromaAnimationAPI::SubtractThresholdColorsMinMaxRGB(
 const int animationId, const int frameId, const int minThreshold, const int minRed,
 const int minGreen, const int minBlue, const int maxThreshold, const int maxRed,
 const int maxGreen, const int maxBlue);

PluginSubtractThresholdColorsMinMaxRGBName

Subtract the specified frame with the min RGB color where the animation color is less than the min threshold AND with the max RGB color where the animation is more than the max threshold. Animation is referenced by name.

// DLL Interface
EXPORT_API void PluginSubtractThresholdColorsMinMaxRGBName(
 const char* path, const int frameId, const int minThreshold, const int minRed,
 const int minGreen, const int minBlue, const int maxThreshold, const int maxRed,
 const int maxGreen, const int maxBlue);

// Class Plugin
ChromaAnimationAPI::SubtractThresholdColorsMinMaxRGBName(
 const char* path, const int frameId, const int minThreshold, const int minRed,
 const int minGreen, const int minBlue, const int maxThreshold, const int maxRed,
 const int maxGreen, const int maxBlue);

PluginSubtractThresholdColorsMinMaxRGBNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginSubtractThresholdColorsMinMaxRGBNameD(
 const char* path, const int frameId, const int minThreshold, const int minRed,
 const int minGreen, const int minBlue, const int maxThreshold, const int maxRed,
 const int maxGreen, const int maxBlue);

// Class Plugin
double result = ChromaAnimationAPI::SubtractThresholdColorsMinMaxRGBNameD(
 const char* path, const int frameId, const int minThreshold, const int minRed,
 const int minGreen, const int minBlue, const int maxThreshold, const int maxRed,
 const int maxGreen, const int maxBlue);

PluginTrimEndFrames

Trim the end of the animation. The length of the animation will be the lastFrameId plus one. Reference the animation by id.

// DLL Interface
EXPORT_API void PluginTrimEndFrames(
 int animationId, int lastFrameId);

// Class Plugin
ChromaAnimationAPI::TrimEndFrames(
 int animationId, int lastFrameId);

PluginTrimEndFramesName

Trim the end of the animation. The length of the animation will be the lastFrameId plus one. Reference the animation by name.

// DLL Interface
EXPORT_API void PluginTrimEndFramesName(
 const char* path, int lastFrameId);

// Class Plugin
ChromaAnimationAPI::TrimEndFramesName(
 const char* path, int lastFrameId);

PluginTrimEndFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginTrimEndFramesNameD(
 const char* path, double lastFrameId);

// Class Plugin
double result = ChromaAnimationAPI::TrimEndFramesNameD(
 const char* path, double lastFrameId);

PluginTrimFrame

Remove the frame from the animation. Reference animation by id.

// DLL Interface
EXPORT_API void PluginTrimFrame(
 int animationId, int frameId);

// Class Plugin
ChromaAnimationAPI::TrimFrame(
 int animationId, int frameId);

PluginTrimFrameName

Remove the frame from the animation. Reference animation by name.

// DLL Interface
EXPORT_API void PluginTrimFrameName(
 const char* path, int frameId);

// Class Plugin
ChromaAnimationAPI::TrimFrameName(
 const char* path, int frameId);

PluginTrimFrameNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginTrimFrameNameD(
 const char* path, double frameId);

// Class Plugin
double result = ChromaAnimationAPI::TrimFrameNameD(
 const char* path, double frameId);

PluginTrimStartFrames

Trim the start of the animation starting at frame 0 for the number of frames. Reference the animation by id.

// DLL Interface
EXPORT_API void PluginTrimStartFrames(
 int animationId, int numberOfFrames);

// Class Plugin
ChromaAnimationAPI::TrimStartFrames(
 int animationId, int numberOfFrames);

PluginTrimStartFramesName

Trim the start of the animation starting at frame 0 for the number of frames. Reference the animation by name.

// DLL Interface
EXPORT_API void PluginTrimStartFramesName(
 const char* path, int numberOfFrames);

// Class Plugin
ChromaAnimationAPI::TrimStartFramesName(
 const char* path, int numberOfFrames);

PluginTrimStartFramesNameD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginTrimStartFramesNameD(
 const char* path, double numberOfFrames);

// Class Plugin
double result = ChromaAnimationAPI::TrimStartFramesNameD(
 const char* path, double numberOfFrames);

PluginUninit

Uninitializes the ChromaSDK. Returns 0 upon success. Returns negative one upon failure.

// DLL Interface
EXPORT_API RZRESULT PluginUninit();

// Class Plugin
RZRESULT result = ChromaAnimationAPI::Uninit();

PluginUninitD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginUninitD();

// Class Plugin
double result = ChromaAnimationAPI::UninitD();

PluginUnloadAnimation

Unloads Chroma effects to free up resources. Returns the animation id upon success. Returns negative one upon failure. Reference the animation by id.

// DLL Interface
EXPORT_API int PluginUnloadAnimation(int animationId);

// Class Plugin
int result = ChromaAnimationAPI::UnloadAnimation(int animationId);

PluginUnloadAnimationD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginUnloadAnimationD(double animationId);

// Class Plugin
double result = ChromaAnimationAPI::UnloadAnimationD(double animationId);

PluginUnloadAnimationName

Unload the animation effects. Reference the animation by name.

// DLL Interface
EXPORT_API void PluginUnloadAnimationName(const char* path);

// Class Plugin
ChromaAnimationAPI::UnloadAnimationName(const char* path);

PluginUnloadComposite

Unload the the composite set of animation effects. Reference the animation by name.

// DLL Interface
EXPORT_API void PluginUnloadComposite(const char* name);

// Class Plugin
ChromaAnimationAPI::UnloadComposite(const char* name);

PluginUnloadLibrarySDK

Unload the Razer Chroma SDK Library before exiting the application.

// DLL Interface
EXPORT_API void PluginUnloadLibrarySDK();

// Class Plugin
ChromaAnimationAPI::UnloadLibrarySDK();

PluginUnloadLibraryStreamingPlugin

Unload the Razer Chroma Streaming Plugin Library before exiting the application.

// DLL Interface
EXPORT_API void PluginUnloadLibraryStreamingPlugin();

// Class Plugin
ChromaAnimationAPI::UnloadLibraryStreamingPlugin();

PluginUpdateFrame

Updates the frameIndex of the Chroma animation referenced by id and sets the duration (in seconds). The color is expected to be an array of the dimensions for the deviceType/device. The length parameter is the size of the color array. For EChromaSDKDevice1DEnum the array size should be MAX LEDS. For EChromaSDKDevice2DEnum the array size should be MAX ROW times MAX COLUMN. Keys are populated only for EChromaSDKDevice2DEnum::DE_Keyboard and EChromaSDKDevice2DEnum::DE_KeyboardExtended. Keys will only use the EChromaSDKDevice2DEnum::DE_Keyboard MAX_ROW times MAX_COLUMN keysLength. Returns the animation id upon success. Returns negative one upon failure.

// DLL Interface
EXPORT_API int PluginUpdateFrame(
 int animationId, int frameIndex, float duration, int* colors, int length,
 int* keys, int keysLength);

// Class Plugin
int result = ChromaAnimationAPI::UpdateFrame(
 int animationId, int frameIndex, float duration, int* colors, int length,
 int* keys, int keysLength);

PluginUpdateFrameName

Update the frameIndex of the Chroma animation referenced by name and sets the duration (in seconds). The color is expected to be an array of the dimensions for the deviceType/device. The length parameter is the size of the color array. For EChromaSDKDevice1DEnum the array size should be MAX LEDS. For EChromaSDKDevice2DEnum the array size should be MAX ROW times MAX COLUMN. Keys are populated only for EChromaSDKDevice2DEnum::DE_Keyboard and EChromaSDKDevice2DEnum::DE_KeyboardExtended. Keys will only use the EChromaSDKDevice2DEnum::DE_Keyboard MAX_ROW times MAX_COLUMN keysLength. Returns the animation id upon success. Returns negative one upon failure.

// DLL Interface
EXPORT_API int PluginUpdateFrameName(
 const char* path, int frameIndex, float duration, int* colors, int length,
 int* keys, int keysLength);

// Class Plugin
int result = ChromaAnimationAPI::UpdateFrameName(
 const char* path, int frameIndex, float duration, int* colors, int length,
 int* keys, int keysLength);

PluginUseIdleAnimation

When the idle animation flag is true, when no other animations are playing, the idle animation will be used. The idle animation will not be affected by the API calls to PluginIsPlaying, PluginStopAnimationType, PluginGetPlayingAnimationId, and PluginGetPlayingAnimationCount. Then the idle animation flag is false, the idle animation is disabled. Device uses EChromaSDKDeviceEnum enums.

// DLL Interface
EXPORT_API void PluginUseIdleAnimation(
 int device, bool flag);

// Class Plugin
ChromaAnimationAPI::UseIdleAnimation(
 int device, bool flag);

PluginUseIdleAnimations

Set idle animation flag for all devices.

// DLL Interface
EXPORT_API void PluginUseIdleAnimations(bool flag);

// Class Plugin
ChromaAnimationAPI::UseIdleAnimations(bool flag);

PluginUsePreloading

Set preloading animation flag, which is set to true by default. Reference animation by id.

// DLL Interface
EXPORT_API void PluginUsePreloading(
 int animationId, bool flag);

// Class Plugin
ChromaAnimationAPI::UsePreloading(
 int animationId, bool flag);

PluginUsePreloadingName

Set preloading animation flag, which is set to true by default. Reference animation by name.

// DLL Interface
EXPORT_API void PluginUsePreloadingName(
 const char* path, bool flag);

// Class Plugin
ChromaAnimationAPI::UsePreloadingName(
 const char* path, bool flag);



(End of automation)



PluginPlayComposite

PluginPlayComposite automatically handles initializing the ChromaSDK. The named animation files for the .chroma set will be automatically opened. The set of animations will play with looping on or off.

EXPORT_API void PluginPlayComposite(const char* name, bool loop);

// Given "Random" this will invoke:
// PluginPlayAnimationName("Random_ChromaLink.chroma", loop);
// PluginPlayAnimationName("Random_Headset.chroma", loop);
// PluginPlayAnimationName("Random_Keyboard.chroma", loop);
// PluginPlayAnimationName("Random_Keypad.chroma", loop);
// PluginPlayAnimationName("Random_Mouse.chroma", loop);
// PluginPlayAnimationName("Random_Mousepad.chroma", loop);

PluginStopComposite

PluginStopComposite automatically handles initializing the ChromaSDK. The named animation files for the .chroma set will be automatically opened. The set of animations will be stopped if playing.

EXPORT_API void PluginStopComposite(const char* name);

// Given "Random" this will invoke:
// PluginStopAnimationName("Random_ChromaLink.chroma");
// PluginStopAnimationName("Random_Headset.chroma");
// PluginStopAnimationName("Random_Keyboard.chroma");
// PluginStopAnimationName("Random_Keypad.chroma");
// PluginStopAnimationName("Random_Mouse.chroma");
// PluginStopAnimationName("Random_Mousepad.chroma");

PluginCloseComposite

PluginCloseComposite closes a set of animations so they can be reloaded from disk. The set of animations will be stopped if playing.

EXPORT_API void PluginCloseComposite(const char* name);

// Given "Random" this will invoke:
// PluginCloseAnimationName("Random_ChromaLink.chroma");
// PluginCloseAnimationName("Random_Headset.chroma");
// PluginCloseAnimationName("Random_Keyboard.chroma");
// PluginCloseAnimationName("Random_Keypad.chroma");
// PluginCloseAnimationName("Random_Mouse.chroma");
// PluginCloseAnimationName("Random_Mousepad.chroma");

EChromaSDKDeviceTypeEnum

The supported device types are 1D and 2D.

enum EChromaSDKDeviceTypeEnum
{
    DE_1D = 0,
    DE_2D,
};

EChromaSDKDevice1DEnum

1D devices are ChromaLink, Headset, and Mousepad.

enum EChromaSDKDevice1DEnum
{
    DE_ChromaLink = 0,
    DE_Headset,
    DE_Mousepad,
};

EChromaSDKDevice2DEnum

2D devices are Keyboard, Keypad, and Mouse.

enum EChromaSDKDevice2DEnum
{
    DE_Keyboard = 0,
    DE_Keypad,
    DE_Mouse,
};

(Auto-documentation needs sample snippet section)

PluginSetKeysColorName

Set an array of animation keys to a static color for the given frame.

EXPORT_API void PluginSetKeysColorName(const char* path, int frameId, const int* rzkeys, int keyCount, int color);

Usage:

const char* animationName = "Blank_Keyboard.chroma";
int frameCount = _gMethodGetFrameCountName(animationName);

int wasdKeys[4] =
{
  (int)Keyboard::RZKEY::RZKEY_W,
  (int)Keyboard::RZKEY::RZKEY_A,
  (int)Keyboard::RZKEY::RZKEY_S,
  (int)Keyboard::RZKEY::RZKEY_D,
};
for (int i = 0; i < frameCount; ++i)
{
  _gMethodSetKeysColorName(animationName, i, wasdKeys, size(wasdKeys), 0xFF);
}
_gMethodPlayAnimationName(animationName, false);

PluginSetKeysNonZeroColorName

Set an array of animation keys to a static color for the given frame if the existing color is not already black.

EXPORT_API void PluginSetKeysNonZeroColorName(const char* path, int frameId,
  const int* rzkeys, int keyCount, int color);

Usage:

const char* animationName = "Blank_Keyboard.chroma";
int frameCount = _gMethodGetFrameCountName(animationName);

int wasdKeys[4] =
{
  (int)Keyboard::RZKEY::RZKEY_W,
  (int)Keyboard::RZKEY::RZKEY_A,
  (int)Keyboard::RZKEY::RZKEY_S,
  (int)Keyboard::RZKEY::RZKEY_D,
};
for (int i = 0; i < frameCount; ++i)
{
  _gMethodSetKeysNonZeroColorName(animationName, i, wasdKeys, size(wasdKeys), 0xFF);
}
_gMethodPlayAnimationName(animationName, false);

File Format

Version: (int)

EChromaSDKDeviceTypeEnum: (byte)

enum EChromaSDKDeviceTypeEnum
{
    DE_1D = 0,
    DE_2D,
};
  • Depending on the EChromaSDKDeviceTypeEnum, the file will use either the 1D or 2D file format.

1D File Format

EChromaSDKDevice1DEnum: (byte)

enum EChromaSDKDevice1DEnum
{
    DE_ChromaLink = 0,
    DE_Headset,
    DE_Mousepad,
};

Frame Count: (unsigned int)

Frames: (FChromaSDKColorFrame1D[])

struct FChromaSDKColorFrame1D
{
    float Duration;
    std::vector<COLORREF> Colors;
};

Duration: (float)

Color Array: (int[])

2D File Format

EChromaSDKDevice2DEnum: (byte)

enum EChromaSDKDevice2DEnum
{
    DE_Keyboard = 0,
    DE_Keypad,
    DE_Mouse,
};

Frame Count: (unsigned int)

Frames: (FChromaSDKColorFrame2D[])

struct FChromaSDKColors
{
    std::vector<COLORREF> Colors;
};
struct FChromaSDKColorFrame2D
{
    float Duration;
    std::vector<FChromaSDKColors> Colors;
};

Duration: (float)

Color Array: (int[][])

About

C++ Dynamic library for playing and editing Chroma animations

Resources

Readme

License

MIT license
Activity

Stars

1 star

Watchers

1 watching

Forks

0 forks
Report repository

Releases

24 tags

Packages

No packages published

Languages

  • C++ 62.1%
  • C 37.8%
  • Other 0.1%