# Source: FeatureTemplate.js

    /**
     * Effect instances are used to store information required to uniquely identify each created makeup entity.
     * <br/>
     * Effect instances are created from FeatureTemplate and (optional) FinishTemplate instances passed to MakeupEngine::CreateMakeup function in the API.
     * Objects of this type are read only.
     * <br/>
     * <br/>
     * Effect is defined by the following:
     * <br/>
     * - id - unique identifier of the effect
     * <br/>
     * - type - makeup type used to create the effect
     * <br/>
     * - name - name of the effect
     * <br/>
     * - elements - a list of elements comprising the effect
     * @typedef {Object} Effect
     *
     * @prop {number} id
     * Unique identifier of the effect
     *
     * @prop {string} type
     * Makeup type used to create the effect
     *
     * @prop {string} name
     * Name of the effect.
     *
     * @prop {Element[]} elements
     * A list of elements comprising the effect
     *
     * @prop {BoundingBox} boundingBox
     * A bounding box in which this effect is visible
     */

    /**
     * Stores updatable rendering parameters of elements contained in a created makeup effect.
     * Element instances are created from ElementTemplate instances attached to FeatureTemplate and or FinishTemplate used for creating the effect.
     * Each ElementTemplate attached to both FeatureTemplate and FinishTemplate used to create the effect is mapped to a single Element.
     * <br/>
     * <br/>
     * Element is defined by the following:
     * <br/>
     * - name: read-only member used for identification of between different elements
     * <br/>
     * - color: color of the rendered feature
     * <br/>
     * - area : area where the rendering will be performed.
     * <br/>
     * <br/>
     * Color is stored in Color class which contains a 4 dimensional vector specifying red, green, blue and alpha channels.
     * <br/>
     * Area is specified as a name of the image file that contains a greyscale image specifying how much of the color of this Element should be used at each fragment of the mesh used for rendering of the effect containing this Element.
     * For each pixel in the area image, if the pixel is white this 100% of color from this element will be used. If the pixel is black 100% of the color from the previous element will be used. The pixel values in between are lineraly interpolated.
     * <br/>
     * Once an effect is created from a FeatureTemplate each ElementTemplate in the feature is mapped to one Element.
     * The previous element of the first element in an effect is the output of the previous effect. If there are no previous effects displayed, the previous element is raw input image without augmentation.
     * <br/>
     * The location where area images are stored is <path to platform dependent assets folder> + "/Textures/Area/" + Effect.type +  Element.area where Effect.type is type of the effect containing this Element and Element.area is the area parameter of this Element.
     * The location for storing of the color map is <path to platform dependent assets folder> + "/Textures/" + Element.texture  + "/" + Effect.type + "/" + Effect.area. The <path to platform dependent assets folder> is the url passed to the CreateMakeupEngine function in the API.
     * <br/>
     * Since both the area image and the color map are used as a texture on a mesh used for rendering the feature it will only work correctly if the uv mapping used on the mesh matches those images.
     * This means that those images can be reused between effects only if the effects have the same type.
     * Therefore, when specifying a new custom area image or a new color map, the image file needs to be placed in the subfolder specific to the type of the effect the new image was created for.
     * <br/>
     * The available meshes are stored in .obj format in the "Assets/Models" folder of the package. UV maps from these meshes should be used when creating new area images.
     * @typedef {Object} Element
     *
     * @prop {string} name
     * Name of the element.
     *
     * @prop {Color} color
     * Color of the rendered feature.
     *
     * @prop {string} texture
     * Path used to store color map of the rendered feature.
     *
     * @prop {Boolean} useColor
     * Some of the feature elements do not use coloring step in their pipelines.
     * Set to true if element uses (RGB) of the color, otherwise it only uses the alpha channel to control intensity.
     *
     * @prop {Boolean} useTexture
     * Some of the feature elements do not use coloring step in their pipelines.
     * Set to true If element should use the provided color map stored in texture member, otherwise it only uses the alpha channel provided in the color member to control intensity.
     *
     * @prop {string | ImageData} area
     * Name of the image file specifying the area where rendering of this element will be performed.
     */

    /**
     * Stores a definition of template used to create of virtual makeup.
     * <br/>
     * <br/>
     * One makeup feature template contains all information required to render virtual makeup:
     * <br/>
     * - mesh
     * <br/>
     * - area
     * <br/>
     * - color
     * <br/>
     * - description of blending and filtering algorithms required to augment the camera feed with virtual makeup.
     * <br/>
     * <br/>
     * One FeatureTemplate instance can contain multiple rendering elements which share the mesh but can have different application area, color or blending and filtering algorithm.
     * <br/>
     * The simplest use-case for this class is using one of the predefined template specified in FeatureTemplateRepository obtained from MakeupEngine::GetFeatures function and setting the color of each element in elements array, then passing the feature template to MakeupEngine:CreateMakeup function to create the virtual makeup corresponding to the given template.
     * <br/>
     * <br/>
     * FeatureTemplate is defined by the following:
     * <br/>
     * - name: name of the feature. This value is used for identification of templates used for describing different makeup features. Does not have to be unique.
     * <br/>
     * - type: type of the feature. Defines a mesh used to represent this feature when rendering.
     * <br/>
     * - elements: defines a list of elements required for rendering of this feature. Each element uses the same mesh defined by the type parameter.
     * <br/>
     * The following types are supported:
     * - Lipstick
     * <br/>
     * - Lipliner
     * <br/>
     * - Mascara
     * <br/>
     * - Foundation
     * <br/>
     * - Highlighter
     * <br/>
     * - Blush
     * <br/>
     * - Concealer
     * <br/>
     * - Eyeliner
     * <br/>
     * - Eyeshadow
     * <br/>
     * - Eyebrows
     * <br/>
     * - EyebrowLine
     * <br/>
     * - Eyebrows_1 - deprecated
     * <br/>
     * - Eyebrows_2 - deprecated
     * <br/>
     * - Eyebrows_3 - deprecated
     * <br/>
     * Each type maps to a single mesh. The meshes used are stored in .obj format in the "StreamingAssets/Models" folder. The name of the .obj corresponds to the type name.
     * @typedef {Object} FeatureTemplate
     *
     * @property {string} name
     * Name of the feature.
     *
     * @property {string} type
     * Type of the feature.
     * Specifies one of the predefined meshes to use to represent this feature.
     *
     * @property {ElementTemplate[]} elements
     * A list of elements required for rendering this feature.
     */

    /**
     * Contains rendering information of each element of a makeup feature.
     * <br/>
     * <br/>
     * Each element template consists of the following:
     * <br/>
     * - name: the name of the element
     * <br/>
     * - area: the area where rendering will be performed
     * <br/>
     * - color: the color of the area where rendering will be performed
     * <br/>
     * - pipeline: rendering steps to use when rendering this element.
     * <br/>
     * <br/>
     * Color is stored in Color class which contains a 4 dimensional vector specifying red, green, blue and alpha channels.
     * Additionally, color can be provided as a path to a file containign color map to use.
     * <br/>
     * Area is specified as a name of the image file that contains a greyscale image specifying how much of the color of this ElementTemplate should be used at each fragment of the mesh used for rendering of the feature containing this ElementTemplate.
     * For each pixel in the area image, if the pixel is white 100% of color from this element template will be used. If the pixel is black 100% of the color from the previous element will be used. The pixel values in between are lineraly interpolated.
     * <br/>
     * Once an effect is created from a feature each element template in the feature is mapped to one element.
     * The previous element of the first element in an effect is the output of the previous effect. If there are no previous effects displayed, the previous element is raw input image without augmentation.
     * <br/>
     * The location where area images are stored is <path to platform dependent assets folder> + "/Textures/Area/" + FeatureTemplate.type +  ElementTemplate.area where FeatureTemplate.type is type of the feature containing this ElementTemplate and ElementTemplate.area is the area parameter of this ElementTemplate.
     * The location where color maps are <path to platform dependent assets folder> + "/Textures/" + ElementTemplate.texture  + "/" + FeatureTemplate.type + "/" + FeatureTemplate.area. The <path to platform dependent assets folder> is the url passed to the CreateMakeupEngine function in the API.
     * <br/>
     * Since both the area image and the color map are used as a texture on a mesh used for rendering the feature it will only work correctly if the uv mapping used on the mesh matches those images.
     * This means that those images can be reused between features only if the features have the same type.
     * Therefore, when specifying a new custom area image or a new color map, the image file needs to be placed in the subfolder specific to the type of the feature the new image was created for.
     * <br/>
     * The available meshes are stored in .obj format in the "Assets/Models" folder of the package. UV maps from these meshes should be used when creating new area textures.
     * @typedef {Object} ElementTemplate
     *
     * @prop {string} name;
     * Name of the element.
     *
     * @prop {string} area;
     * Name of the image file specifying the area where rendering of this element will be performed.
     *
     * @prop {Color} color;
     * Color of the area where rendering will be performed.
     *
     * @prop {string} texture;
     *  Path used to store color map of the rendered feature.
     *
     * @prop {PipeTemplate} pipeline;
     * Rendering steps to use when rendering this element.
     *
     * @prop {Boolean} useColor;
     * Some of the feature elements do not use coloring step in their pipelines.
     * Set to true if element uses (RGB) of the color, otherwise it only uses the alpha channel to control intensity.
     *
     * @prop {Boolean} useTexture;
     * Some of the feature elements do not use coloring step in their pipelines.
     * Set to true If element should use the provided color map stored in texture member, otherwise it only uses the alpha channel provided in the color member to control intensity.
     */

    /**
     * Class used as a container storing RGBA for color values.
     * <br/>
     * Color is stored as floating point value in 0.0 to 1.0 range.
     * @typedef {Object} Color
     *
     * @prop {number} r
     * Red channel float value.
     *
     * @prop {number} g
     * Green channel float value.
     *
     * @prop {number} b
     * Blue channel float value.
     *
     * @prop {number} a
     * Alpha channel float value.
     */

    /**
     * Stores a list of blending and filtering steps required to render a virtual makeup feature.
     * <br/>
     * <br/>
     * Contains of a list of MaskTemplate objects defining custom masks which can be used as inputs in filters.
     * <br/>
     * Contains a list of FilterQueueTemplate objects each of which define a single step in the rendering procedure.
     * @typedef {Object} PipeTemplate
     *
     * @prop {MaskTemplate[]} masks
     * List storing custom mask definitions.
     *
     * @prop {FilterQueueTemplate[]} filters
     * List storing blending and filtering steps of rendering procedure of a makeup feature.
     */

    /**
     * Contains a definition of a custom mask.
     * <br/>
     * <br/>
     * Custom mask is defined by name and a reference which is used to determine the location of the image file containg the mask.
     * The location for storing of custom masks is <path to platform dependent assets folder> + "/Textures/" + MaskTemnplate.texture  + "/" + FeatureTemplate.type + "/" + FeatureTemplate.area. The <path to platform dependent assets folder> is the url passed to the CreateMakeupEngine function in the API.
     * <br/>
     * The mesh custom mask should use is derived from the type of FeatureTemplate instance this MaskTemplate is contained in.
     * @typedef {Object} MaskTemplate
     *
     * @prop {string} name
     * Name of the custom texture used for identification purposes. Should be unique within a single FeatureTemplate instance.
     *
     * @prop {string} texture
     * Internal texture storage path to base texture.
     */

    /**
     * Contains information defining a single step in the rendering pipeline of each makeup feature element.
     * <br/>
     * <br/>
     * Single step of the rendering pipeline consists of a blend mode, an optional lists of preprocessing and an optional list of postprocessing filters.
     * <br/>
     * <br/>
     * The engine supports the following blend modes:
     * <br/>
     * - Overlay: performs overlay blend mode
     * <br/>
     * - AlphaBlendUseMaskAlpha: performs traditional transparency blending using binary mask as alpha channel
     * <br/>
     * - Screen: performs screen blend mode
     * <br/>
     * <br/>
     * Each blend is performed between the output of the preprocessing stack and the output of the previous blend or previous postprocessing stack. Used blend mode is specified via name member.
     * <br/>
     * Specifically, the initial blend is performed between colored a mesh representing queried makeup feature and the first preprocessing stack.
     * <br/>
     * <br/>
     * Preprocessing filters are applied in sequence starting from raw camera feed. Postprocessing filters are applied in sequence starting from the output of blending.
     * @typedef {Object} FilterQueueTemplate
     *
     * @property {string} blend
     * Name of the used blend mode.
     *
     * @property {string} origin
     * The input image for this filter queue.
     * The following values are supported:
     * <br/>
     * - video: the input image into this filter queue is the input image provided to the engine by the API consumer.
     * <br/>
     * - previous: the input image into this filter queue is the output image of the previous element in the pipeline.
     * <br/>
     * <br/>
     * The default value for origin is `video`.
     *
     * @property {FilterTemplate[]} preprocess
     * List of preprocessing filters to apply.
     *
     * @property {FilterTemplate[]} postprocess
     * List of postprocessing filters to apply.
     *
     * @property {boolean} switchLayers
     * If set to true, the output of preprocess is used as a top layer.
     * Otherwise, output from the previous blend is used as a top layer for blending.
     */

    /**
     * Defines a name and a parameters list specifiying a filter.
     * <br/>
     * <br/>
     * Each filter must take an image as input and returns and image processed by an filtering algorithm. Optionally, a filter can take additional parameters which are stored in parameters member.
     * <br/>
     * <br/>
     * The engine supports the following filters:
     * <br/>
     * - Smoothing: performs face smoothing filter on the input image
     * <br/>
     * - Greyscale: performs greyscale conversion on the input image
     * <br/>
     * - Threshold: performs binary thresholding operation on the input image
     * <br/>
     * - Multply: performs multiplication of the given image with a custom mask texture specified as input parameter
     * <br/>
     * - HighPass: performs gaussian high pass filter on the input image
     * <br/>
     * - Blur - performs gaussian blur on the input image
     * <br/>
     * <br/>
     * The filter applied is defined by name member.
     * <br/>
     * Input parameters of each filter can be set using FilterParameterTemplate class
     * @typedef {Object} FilterTemplate
     *
     * @prop {string} name
     * Name of the filter to apply.
     *
     * @prop {FilterParameterTemplate[]} parameters
     * List of optional filter parameters.
     */

    /**
     * Contains filter parameter information.
     * <br/>
     * <br/>
     * Filter parameter is specified by the following:
     * <br/>
     * - name: name of the parameter to set
     * <br/>
     * - type: type of the parameter. The system currently supports floating point and texture types. Type defines how the given value will be parsed and represented.
     * <br/>
     * - value: value of the parameter. Value is provided as a string, regardless of type. Texture inputs are given by name of the texture. Currently the only supported texture inputs are a custom mask names defined in PipeTemplate object.
     * @typedef {Object} FilterParameterTemplate
     *
     * @prop {string} name
     * Name of the input parameter.
     *
     * @prop {string} value
     * Value of the input parameter.
     *
     * @prop {string} type
     * Type of the input parameter.
     */

    /**
     * Stores a definition of makeup finish.
     * <br/>
     * <br/>
     * Each finish is a named rendering pipeline which can be reused with any of the features.
     * <br/>
     * Provides methods for setup of blending and filtering procedures and parameters for finishes.
     * @typedef {Object} FinishTemplate
     *
     * @property {string} name
     * Name of the finish.
     *
     * @property {number} transparency
     * Transparency of the finish.
     *
     * @property {PipeTemplate} pipeline
     * Rendering steps to use when rendering the finish.
     *
     * @property {boolean} useColor
     *
     * @property {boolean} useTexture
     *
     * @property {string} texture
     * Texture identifier or path used for the finish.
     */

    /**
     * Quuartet specifying bounding box in which this effect is visible.
     * @typedef {Array<number>} BoundingBox
     */

    // non-functional, but required for file to be recognized as a module
    export {}