Custom Plugins

In addition to its suite of core plugins, the Art Engine 2.0 extends an invitation to developers to leverage their creativity through the creation of custom plugins. In this section, we delve into the mechanics of the core plugins, dissecting their distinct roles and collaborative dynamics. Moreover, we'll provide a comprehensive guide to implementing the core interfaces for each plugin category, empowering developers to confidently craft their own plugins and contribute to the plugin ecosystem.

Plugins types

Inputs

The inputs are responsible for loading and providing data to the Art Engine. They act as a bridge or adapter, enabling the engine to read and utilize various types of data. Depending on the input plugin used, you can load data from different sources such as images from files, Photoshop files, music files, videos, and more. This flexibility allows artists and developers to work with diverse data formats and sources to create unique NFT art.

Generators

The generators play a key role in the art generation process by creating attributes or properties for each item in the artwork. They generate variations and unique features for the NFTs, making each piece distinct and appealing. Depending on the generator used, you can define the quantity of media files to be generated, enabling efficient and dynamic NFT creation.

Renderers

The renderers combine the attributes generated by the generators with the input data to produce the final visual representation of the artwork. They determine how the attributes and media files are combined to create the desired visual effect. Additionally, renderers leverage temporary storage for rendering the metadata and media files during the generation process.

Exporters

The exporters handle the final output of the generated artwork and metadata. They export the media files and metadata in the desired formats, making them ready for use in NFT marketplaces and other platforms. Exporters also act as the last step for data or media manipulation to achieve the desired output.

Art Engine Execution Process

The Art Engine operates as a dynamic framework that orchestrates the plugin-based generation of NFT art and metadata. Understanding the inner workings of how the Art Engine runs plugins can provide developers with valuable insights to create custom plugins and extend its capabilities.

1. Seed Initialization

The Art Engine initiates its workflow by generating a seed file. This seed is a unique value that can be utilized across different plugins for deterministic results or as a source of randomness.

2. Input Plugins Loop

The engine proceeds by iterating over the list of input plugins provided in the configuration.
For each input plugin:
- The Art Engine calls the init() function on the input plugin, allowing it to set up any necessary internal structures or configurations. The seed can be passed here for optional use within the plugin.
- Following initialization, the Art Engine calls the load() function on the input plugin. This function retrieves data from external sources, which might include images, attributes, or other data relevant to the generation process.
- The data returned by the load() function is stored for further use in a data structure.

3. Generators Loop

Once the input data from all input plugins has been collected, the Art Engine moves on to the generator phase.
For each generator plugin:
- The Art Engine calls the init() function on the generator, providing it with the previously generated seed and an inputsManager instance. The inputsManager offers access to the data gathered from input plugins, enabling generators to use this data as a basis for content generation.
- The generate() function of the generator plugin is then invoked. This function generates various attributes, traits, or characteristics based on the input data. The generated data is returned and stored as a key-value pair for each item in the dataset.

4. Renderers Loop

After the data has been generated by the generators, the Art Engine progresses to the rendering phase.
For each renderer plugin:
- The Art Engine invokes the init() function on the renderer, passing the seed, cachePath, and attributesGetter. The cachePath can be used to store intermediate or temporary data if needed. The attributesGetter provides access to the data generated by the generators, allowing renderers to use this data to produce visual representations.
- Subsequently, the render() function of the renderer plugin is called. This function generates visual content, such as layered images, using the attributes and traits provided by the generator plugins. The generated visual data is stored as a key-value pair for each item in the dataset.

5. Exporters Loop

With the visual content rendered, the Art Engine enters the exporting phase.
For each exporter plugin:
- The Art Engine invokes the init() function on the exporter, providing the seed, outputPath, and rendersGetter. The outputPath designates the directory where the exported content should be stored, and the rendersGetter gives access to the visual data generated by the renderers.
- The export() function of the exporter plugin is executed. This function finalizes the generated content, prepares it for export, and places it in the specified outputPath.

Visual Execution Process

+------------------------+
|   Seed Initialization  |
+------------------------+
            |
            v
+------------------------+
|      Input Plugins     |
+------------------------+
            |
            v
+------------------------+
|    Generator Plugins   |
+------------------------+
            |
            v
+------------------------+
|    Renderer Plugins    |
+------------------------+
            |
            v
+------------------------+
|    Exporter Plugins    |
+------------------------+

Plugin Interactions

It is important to note that different plugins within the Art Engine are designed to be used together, forming a cohesive ecosystem for NFT art generation. Each plugin is built with a specific output and interface in mind. Therefore, it is crucial to understand what a plugin outputs and how it interacts with other plugins.

For example, generators produce attributes that may be consumed by renderers to create meaningful metadata or used as input for other generators to add further complexity to the artwork. Similarly, exporters depend on the output generated by the renderers to produce the final media files and metadata in the desired formats.

To ensure a smooth art generation process, it is essential to comprehend the flow of data between plugins and the expected interfaces they use. The documentation for each core plugin will provide insights into its outputs, inputs, and how it fits within the larger context of the Art Engine's plugin-based architecture.

Development Considerations

The Art Engine 2.0 is an actively developing tool, and new core plugins may be added over time to enhance its capabilities. As a result, updates to the Art Engine may introduce changes that could impact existing implementations. We recommend staying updated with the latest releases and following the documentation closely for any potential breaking changes.

Images Interface