C++ Native MFC Library for playing and editing Chroma animations
Clone or download
Latest commit c82584e Jan 9, 2019

README.md

CChromaEditor - C++ Native MFC Library for playing and editing Chroma animations

Table of Contents

See Also

Apps:

Plugins:

Frameworks supported

  • Windows ChromaSDK (32-bit)

  • Windows ChromaSDK (64-bit)

Prerequisites

image_42

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

This library supports the Chroma animation exports from UE4, Unity, and GameMaker.

Dialog

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 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.

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.

Methods:


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 * MAX COLUMN. Returns the animation id upon success. Returns -1 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);

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);

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 -1 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);

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);

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);

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);

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);

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);

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);

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();

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);

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 -1 upon failure. Saves a Chroma animation file with the .chroma extension at the given path. Returns the animation id upon success. Returns -1 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 -1 upon failure. Returns the animation id upon success. Returns -1 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 -1 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 -1 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 -1 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 -1 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

Gets the frame colors and duration (in seconds) for a Chroma animation. 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 * MAX COLUMN. Returns the animation id upon success. Returns -1 upon failure.

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

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

PluginGetFrameCount

Returns the frame count of a Chroma animation upon success. Returns -1 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 -1 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);

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);

PluginGetMaxColumn

Returns the MAX COLUMN given the EChromaSDKDevice2DEnum device as an integer upon success. Returns -1 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 -1 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 -1 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 int PluginInit();

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

PluginInitD

D suffix for limited data types.

// DLL Interface
EXPORT_API double PluginInitD();

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

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 -1 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 -1 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 -1 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);

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 -1 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);

PluginOpenEditorDialog

Opens a Chroma animation file with the .chroma extension. Returns zero upon success. Returns -1 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 -1 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 -1 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 -1 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 -1 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 -1 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);

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 -1 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);

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);

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);

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 -1 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);

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);

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);

PluginTrimEndFrames

Trim the end of the animation. The length of the animation will be the lastFrameId

    1. 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

    1. 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 -1 upon failure.

// DLL Interface
EXPORT_API int PluginUninit();

// Class Plugin
int 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 -1 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);

PluginUpdateFrame

Updates the frameIndex of 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

  • MAX COLUMN. Returns the animation id upon success. Returns -1 upon failure.
// DLL Interface
EXPORT_API int PluginUpdateFrame(
	int animationId, int frameIndex, float duration, int* colors, int length);

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




  • (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[][])