remaining mask files from tomato. these wont get svn history carried over.
authorCampbell Barton <ideasman42@gmail.com>
Mon, 4 Jun 2012 15:49:58 +0000 (15:49 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Mon, 4 Jun 2012 15:49:58 +0000 (15:49 +0000)
source/blender/compositor/nodes/COM_MaskNode.cpp [new file with mode: 0644]
source/blender/compositor/nodes/COM_MaskNode.h [new file with mode: 0644]
source/blender/compositor/operations/COM_MaskOperation.cpp [new file with mode: 0644]
source/blender/compositor/operations/COM_MaskOperation.h [new file with mode: 0644]
source/blender/editors/include/ED_mask.h [new file with mode: 0644]
source/blender/makesdna/DNA_mask_types.h [new file with mode: 0644]
source/blender/makesrna/intern/rna_mask.c [new file with mode: 0644]
source/blender/nodes/composite/nodes/node_composite_mask.c [new file with mode: 0644]

diff --git a/source/blender/compositor/nodes/COM_MaskNode.cpp b/source/blender/compositor/nodes/COM_MaskNode.cpp
new file mode 100644 (file)
index 0000000..991c3f7
--- /dev/null
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2012, Blender Foundation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Contributor:
+ *             Jeroen Bakker
+ *             Monique Dewanchand
+ *             Sergey Sharybin
+ */
+
+#include "COM_MaskNode.h"
+#include "COM_ExecutionSystem.h"
+#include "COM_MaskOperation.h"
+
+extern "C" {
+       #include "DNA_mask_types.h"
+}
+
+MaskNode::MaskNode(bNode *editorNode): Node(editorNode)
+{
+}
+
+void MaskNode::convertToOperations(ExecutionSystem *graph, CompositorContext * context)
+{
+       const RenderData *data = &context->getScene()->r;
+
+       InputSocket *inputImage = this->getInputSocket(0);
+       OutputSocket *outputMask = this->getOutputSocket(0);
+
+       bNode *editorNode = this->getbNode();
+       Mask *mask = (Mask *)editorNode->id;
+
+       // always connect the output image
+       MaskOperation *operation = new MaskOperation();
+
+       if (inputImage->isConnected()) {
+               inputImage->relinkConnections(operation->getInputSocket(0), 0, graph);
+       }
+       else {
+               operation->setMaskWidth(data->xsch * data->size / 100.0f);
+               operation->setMaskHeight(data->ysch * data->size / 100.0f);
+       }
+
+       if (outputMask->isConnected()) {
+               outputMask->relinkConnections(operation->getOutputSocket());
+       }
+
+       operation->setMask(mask);
+       operation->setFramenumber(context->getFramenumber());
+
+       graph->addOperation(operation);
+}
diff --git a/source/blender/compositor/nodes/COM_MaskNode.h b/source/blender/compositor/nodes/COM_MaskNode.h
new file mode 100644 (file)
index 0000000..9d2ea18
--- /dev/null
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2012, Blender Foundation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Contributor:
+ *             Jeroen Bakker
+ *             Monique Dewanchand
+ *             Sergey Sharybin
+ */
+
+#include "COM_Node.h"
+#include "DNA_node_types.h"
+
+/**
+  * @brief MaskNode
+  * @ingroup Node
+  */
+class MaskNode : public Node {
+
+
+public:
+       MaskNode(bNode *editorNode);
+       void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
+
+};
diff --git a/source/blender/compositor/operations/COM_MaskOperation.cpp b/source/blender/compositor/operations/COM_MaskOperation.cpp
new file mode 100644 (file)
index 0000000..a742306
--- /dev/null
@@ -0,0 +1,124 @@
+/*
+ * Copyright 2012, Blender Foundation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Contributor:
+ *             Jeroen Bakker
+ *             Monique Dewanchand
+ *             Sergey Sharybin
+ */
+
+#include "COM_MaskOperation.h"
+
+#include "MEM_guardedalloc.h"
+
+#include "BLI_listbase.h"
+#include "BLI_math.h"
+
+#include "DNA_scene_types.h"
+
+extern "C" {
+       #include "BKE_mask.h"
+}
+
+MaskOperation::MaskOperation(): NodeOperation()
+{
+       this->addInputSocket(COM_DT_COLOR);
+       this->addOutputSocket(COM_DT_COLOR);
+       this->mask = NULL;
+       this->maskWidth = 0;
+       this->maskHeight = 0;
+       this->framenumber = 0;
+       this->rasterizedMask = NULL;
+       setComplex(true);
+}
+
+void MaskOperation::initExecution()
+{
+       initMutex();
+       this->rasterizedMask = NULL;
+}
+
+void MaskOperation::deinitExecution()
+{
+       if (this->rasterizedMask) {
+               MEM_freeN(rasterizedMask);
+               this->rasterizedMask = NULL;
+       }
+}
+
+void *MaskOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+{
+       if (this->rasterizedMask)
+               return this->rasterizedMask;
+
+       if (!this->mask)
+               return NULL;
+
+       BLI_mutex_lock(getMutex());
+       if (this->rasterizedMask == NULL) {
+               int width = this->getWidth();
+               int height = this->getHeight();
+               float *buffer;
+
+               buffer = (float *)MEM_callocN(sizeof(float) * width * height, "rasterized mask");
+               BKE_mask_rasterize(mask, width, height, buffer);
+
+               this->rasterizedMask = buffer;
+       }
+       BLI_mutex_unlock(getMutex());
+
+       return this->rasterizedMask;
+}
+
+void MaskOperation::determineResolution(unsigned int resolution[], unsigned int preferredResolution[])
+{
+       if (maskWidth == 0 || maskHeight == 0) {
+               NodeOperation::determineResolution(resolution, preferredResolution);
+       }
+       else {
+               unsigned int nr[2];
+
+               nr[0] = maskWidth;
+               nr[1] = maskHeight;
+
+               NodeOperation::determineResolution(resolution, nr);
+
+               resolution[0] = maskWidth;
+               resolution[1] = maskHeight;
+       }
+}
+
+void MaskOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+{
+       if (!data) {
+               color[0] = 0;
+               color[1] = 0;
+               color[2] = 0;
+               color[3] = 1.0f;
+       }
+       else {
+               float *buffer = (float*) data;
+               int index = (y * this->getWidth() + x);
+
+               color[0] = buffer[index];
+               color[1] = buffer[index];
+               color[2] = buffer[index];
+               color[3] = 1.0f;
+       }
+}
+
+
diff --git a/source/blender/compositor/operations/COM_MaskOperation.h b/source/blender/compositor/operations/COM_MaskOperation.h
new file mode 100644 (file)
index 0000000..9f2c7f5
--- /dev/null
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2012, Blender Foundation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Contributor:
+ *             Jeroen Bakker
+ *             Monique Dewanchand
+ *             Sergey Sharybin
+ */
+
+
+#ifndef _COM_MaskOperation_h
+#define _COM_MaskOperation_h
+
+#include "COM_NodeOperation.h"
+#include "DNA_scene_types.h"
+#include "DNA_mask_types.h"
+#include "BLI_listbase.h"
+#include "IMB_imbuf_types.h"
+
+/**
+  * Class with implementation of mask rasterization
+  */
+class MaskOperation : public NodeOperation {
+protected:
+       Mask *mask;
+       int maskWidth;
+       int maskHeight;
+       int framenumber;
+       float *rasterizedMask;
+
+       /**
+         * Determine the output resolution. The resolution is retrieved from the Renderer
+         */
+       void determineResolution(unsigned int resolution[], unsigned int preferredResolution[]);
+
+public:
+       MaskOperation();
+
+       void initExecution();
+       void deinitExecution();
+
+       void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+
+       void setMask(Mask *mask) {this->mask = mask;}
+       void setMaskWidth(int width) {this->maskWidth = width;}
+       void setMaskHeight(int height) {this->maskHeight = height;}
+       void setFramenumber(int framenumber) {this->framenumber = framenumber;}
+
+       void executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data);
+};
+
+#endif
diff --git a/source/blender/editors/include/ED_mask.h b/source/blender/editors/include/ED_mask.h
new file mode 100644 (file)
index 0000000..0c4c2f4
--- /dev/null
@@ -0,0 +1,47 @@
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2012 Blender Foundation.
+ * All rights reserved.
+ *
+ * Contributor(s): Blender Foundation,
+ *                 Sergey Sharybin
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file ED_mask.h
+ *  \ingroup editors
+ */
+
+#ifndef __ED_MASK_H__
+#define __ED_MASK_H__
+
+struct wmKeyConfig;
+
+/* mask_editor.c */
+void ED_operatortypes_mask(void);
+void ED_keymap_mask(struct wmKeyConfig *keyconf);
+void ED_operatormacros_mask(void);
+
+/* mask_draw.c */
+void ED_mask_draw(const bContext *C, const char draw_flag, const char draw_type);
+
+/* mask_shapekey.c */
+int ED_mask_layer_shape_auto_key_all(struct Mask *mask, const int frame);
+
+#endif /* ED_TEXT_H */
diff --git a/source/blender/makesdna/DNA_mask_types.h b/source/blender/makesdna/DNA_mask_types.h
new file mode 100644 (file)
index 0000000..28fc946
--- /dev/null
@@ -0,0 +1,163 @@
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2012 Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): Blender Foundation,
+ *                 Sergey Sharybin
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file DNA_mask_types.h
+ *  \ingroup DNA
+ *  \since march-2012
+ *  \author Sergey Sharybin
+ */
+
+#ifndef __DNA_MASK_TYPES_H__
+#define __DNA_MASK_TYPES_H__
+
+#include "DNA_defs.h"
+#include "DNA_ID.h"
+#include "DNA_listBase.h"
+#include "DNA_curve_types.h"
+
+typedef struct Mask {
+       ID id;
+       struct AnimData *adt;
+       ListBase masklayers;   /* mask layers */
+       int masklay_act;     /* index of active mask layer (-1 == None) */
+       int masklay_tot;     /* total number of mask layers */
+} Mask;
+
+typedef struct MaskParent {
+       int flag;             /* parenting flags */
+       int id_type;          /* type of parenting */
+       ID *id;               /* ID block of entity to which mask/spline is parented to
+                              * in case of parenting to movie tracking data set to MovieClip datablock */
+       char parent[64];      /* entity of parent to which parenting happened
+                              * in case of parenting to movie tracking data contains name of layer */
+       char sub_parent[64];  /* sub-entity of parent to which parenting happened
+                              * in case of parenting to movie tracking data contains name of track */
+       float parent_orig[2]; /* track location at the moment of parenting */
+} MaskParent;
+
+typedef struct MaskSplinePointUW {
+       float u, w;            /* u coordinate along spline segment and weight of this point */
+       int flag;              /* different flags of this point */
+} MaskSplinePointUW;
+
+typedef struct MaskSplinePoint {
+       BezTriple bezt;        /* actual point coordinates and it's handles  */
+       int pad;
+       int tot_uw;            /* number of uv feather values */
+       MaskSplinePointUW *uw; /* feather UV values */
+       MaskParent parent;     /* parenting information of particular spline point */
+} MaskSplinePoint;
+
+typedef struct MaskSpline {
+       struct MaskSpline *next, *prev;
+
+       int flag;                /* defferent spline flag (closed, ...) */
+       int tot_point;           /* total number of points */
+       MaskSplinePoint *points; /* points which defines spline itself */
+       MaskParent parent;       /* parenting information of the whole spline */
+
+       int weight_interp, pad;  /* weight interpolation */
+
+       MaskSplinePoint *points_deform; /* deformed copy of 'points' BezTriple data - not saved */
+} MaskSpline;
+
+/* one per frame */
+typedef struct MaskLayerShape {
+       struct MaskLayerShape *next, *prev;
+
+       float *data;             /* u coordinate along spline segment and weight of this point */
+       int    tot_vert;         /* to ensure no buffer overruns's: alloc size is (tot_vert * MASK_OBJECT_SHAPE_ELEM_SIZE) */
+       int    frame;            /* different flags of this point */
+       char   flag;
+       char   pad[7];
+} MaskLayerShape;
+
+typedef struct MaskLayer {
+       struct MaskLayer *next, *prev;
+
+       char name[64];                     /* name of the mask layer (64 = MAD_ID_NAME - 2) */
+
+       ListBase splines;                  /* list of splines which defines this mask layer */
+       ListBase splines_shapes;
+
+       struct MaskSpline *act_spline;     /* active spline */
+       struct MaskSplinePoint *act_point; /* active point */
+
+       /* blending options */
+       float  alpha;
+       char   blend;
+       char   blend_flag;
+
+       //char   flag;             /* not used yet */
+       char   restrictflag;     /* matching 'Object' flag of the same name - eventually use in the outliner  */
+       char   pad[1];
+} MaskLayer;
+
+/* MaskParent->flag */
+#define MASK_PARENT_ACTIVE  (1 << 0)
+
+/* MaskSpline->flag */
+/* reserve (1 << 0) for SELECT */
+#define MASK_SPLINE_CYCLIC  (1 << 1)
+
+/* MaskSpline->weight_interp */
+#define MASK_SPLINE_INTERP_LINEAR   1
+#define MASK_SPLINE_INTERP_EASE     2
+
+#define MASK_OBJECT_SHAPE_ELEM_SIZE 8 /* 3x 2D points + weight + radius == 8 */
+
+/* ob->restrictflag */
+#define MASK_RESTRICT_VIEW      1
+#define MASK_RESTRICT_SELECT    2
+#define MASK_RESTRICT_RENDER    4
+
+/* SpaceClip->mask_draw_flag */
+#define MASK_DRAWFLAG_SMOOTH    1
+
+/* copy of eSpaceImage_UVDT */
+/* SpaceClip->mask_draw_type */
+enum {
+       MASK_DT_OUTLINE = 0,
+       MASK_DT_DASH,
+       MASK_DT_BLACK,
+       MASK_DT_WHITE
+};
+
+/* masklay->blend */
+enum {
+       MASK_BLEND_ADD      = 0,
+       MASK_BLEND_SUBTRACT = 1
+};
+
+/* masklay->blend_flag */
+enum {
+       MASK_BLENDFLAG_INVERT = (1 << 0)
+};
+
+
+#endif // __DNA_MASK_TYPES_H__
diff --git a/source/blender/makesrna/intern/rna_mask.c b/source/blender/makesrna/intern/rna_mask.c
new file mode 100644 (file)
index 0000000..c356cae
--- /dev/null
@@ -0,0 +1,657 @@
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Contributor(s): Blender Foundation,
+ *                 Sergey Sharybin
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/makesrna/intern/rna_mask.c
+ *  \ingroup RNA
+ */
+
+
+#include <stdlib.h>
+#include <limits.h>
+
+#include "MEM_guardedalloc.h"
+
+#include "BKE_movieclip.h"
+#include "BKE_tracking.h"
+
+#include "RNA_define.h"
+
+#include "rna_internal.h"
+
+#include "DNA_mask_types.h"
+#include "DNA_object_types.h"  /* SELECT */
+#include "DNA_scene_types.h"
+
+#include "WM_types.h"
+
+#include "IMB_imbuf_types.h"
+#include "IMB_imbuf.h"
+
+#ifdef RNA_RUNTIME
+
+#include "DNA_mask_types.h"
+
+#include "BKE_depsgraph.h"
+#include "BKE_mask.h"
+
+#include "RNA_access.h"
+
+#include "WM_api.h"
+
+static void rna_Mask_update_data(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
+{
+       Mask *mask = ptr->id.data;
+
+       WM_main_add_notifier(NC_MASK|ND_DATA, mask);
+       DAG_id_tag_update( &mask->id, 0);
+}
+
+/* note: this function exists only to avoid id refcounting */
+static void rna_MaskParent_id_set(PointerRNA *ptr, PointerRNA value)
+{
+       MaskParent *mpar = (MaskParent*) ptr->data;
+
+       mpar->id = value.data;
+}
+
+static StructRNA *rna_MaskParent_id_typef(PointerRNA *ptr)
+{
+       MaskParent *mpar = (MaskParent*) ptr->data;
+
+       return ID_code_to_RNA_type(mpar->id_type);
+}
+
+static void rna_MaskParent_id_type_set(PointerRNA *ptr, int value)
+{
+       MaskParent *mpar = (MaskParent*) ptr->data;
+
+       /* change ID-type to the new type */
+       mpar->id_type = value;
+
+       /* clear the id-block if the type is invalid */
+       if ((mpar->id) && (GS(mpar->id->name) != mpar->id_type))
+               mpar->id = NULL;
+}
+
+static void rna_Mask_layers_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
+{
+       Mask *mask = (Mask *)ptr->id.data;
+
+       rna_iterator_listbase_begin(iter, &mask->masklayers, NULL);
+}
+
+static int rna_Mask_layer_active_index_get(PointerRNA *ptr)
+{
+       Mask *mask = (Mask *)ptr->id.data;
+
+       return mask->masklay_act;
+}
+
+static void rna_Mask_layer_active_index_set(PointerRNA *ptr, int value)
+{
+       Mask *mask = (Mask *)ptr->id.data;
+
+       mask->masklay_act = value;
+}
+
+static void rna_Mask_layer_active_index_range(PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
+{
+       Mask *mask = (Mask *)ptr->id.data;
+
+       *min = 0;
+       *max = mask->masklay_tot - 1;
+       *max = MAX2(0, *max);
+
+       *softmin = *min;
+       *softmax = *max;
+}
+
+static char *rna_MaskLayer_path(PointerRNA *ptr)
+{
+       return BLI_sprintfN("layers[\"%s\"]", ((MaskLayer *)ptr->data)->name);
+}
+
+static PointerRNA rna_Mask_layer_active_get(PointerRNA *ptr)
+{
+       Mask *mask = (Mask *)ptr->id.data;
+       MaskLayer *masklay = BKE_mask_layer_active(mask);
+
+       return rna_pointer_inherit_refine(ptr, &RNA_MaskLayer, masklay);
+}
+
+static void rna_Mask_layer_active_set(PointerRNA *ptr, PointerRNA value)
+{
+       Mask *mask = (Mask *)ptr->id.data;
+       MaskLayer *masklay = (MaskLayer *)value.data;
+
+       BKE_mask_layer_active_set(mask, masklay);
+}
+
+static void rna_MaskLayer_splines_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
+{
+       MaskLayer *masklay = (MaskLayer *)ptr->data;
+
+       rna_iterator_listbase_begin(iter, &masklay->splines, NULL);
+}
+
+void rna_MaskLayer_name_set(PointerRNA *ptr, const char *value)
+{
+       Mask *mask = (Mask *)ptr->id.data;
+       MaskLayer *masklay = (MaskLayer *)ptr->data;
+
+       BLI_strncpy(masklay->name, value, sizeof(masklay->name));
+
+       BKE_mask_layer_unique_name(mask, masklay);
+}
+
+static PointerRNA rna_MaskLayer_active_spline_get(PointerRNA *ptr)
+{
+       MaskLayer *masklay = (MaskLayer *)ptr->data;
+
+       return rna_pointer_inherit_refine(ptr, &RNA_MaskSpline, masklay->act_spline);
+}
+
+static void rna_MaskLayer_active_spline_set(PointerRNA *ptr, PointerRNA value)
+{
+       MaskLayer *masklay = (MaskLayer *)ptr->data;
+       MaskSpline *spline = (MaskSpline *)value.data;
+       int index = BLI_findindex(&masklay->splines, spline);
+
+       if (index >= 0)
+               masklay->act_spline = spline;
+       else
+               masklay->act_spline = NULL;
+}
+
+static PointerRNA rna_MaskLayer_active_spline_point_get(PointerRNA *ptr)
+{
+       MaskLayer *masklay = (MaskLayer *)ptr->data;
+
+       return rna_pointer_inherit_refine(ptr, &RNA_MaskSplinePoint, masklay->act_point);
+}
+
+static void rna_MaskLayer_active_spline_point_set(PointerRNA *ptr, PointerRNA value)
+{
+       MaskLayer *masklay = (MaskLayer *)ptr->data;
+       MaskSpline *spline;
+       MaskSplinePoint *point = (MaskSplinePoint *)value.data;
+
+       masklay->act_point = NULL;
+
+       for (spline = masklay->splines.first; spline; spline = spline->next) {
+               if (point >= spline->points && point < spline->points + spline->tot_point) {
+                       masklay->act_point = point;
+
+                       break;
+               }
+       }
+}
+
+static void rna_MaskSplinePoint_handle1_get(PointerRNA *ptr, float *values)
+{
+       MaskSplinePoint *point = (MaskSplinePoint*) ptr->data;
+       BezTriple *bezt = &point->bezt;
+
+       values[0] = bezt->vec[0][0];
+       values[1] = bezt->vec[0][1];
+       values[2] = bezt->vec[0][2];
+}
+
+static void rna_MaskSplinePoint_handle1_set(PointerRNA *ptr, const float *values)
+{
+       MaskSplinePoint *point = (MaskSplinePoint*) ptr->data;
+       BezTriple *bezt = &point->bezt;
+
+       bezt->vec[0][0] = values[0];
+       bezt->vec[0][1] = values[1];
+       bezt->vec[0][2] = values[2];
+}
+
+static void rna_MaskSplinePoint_handle2_get(PointerRNA *ptr, float *values)
+{
+       MaskSplinePoint *point = (MaskSplinePoint*) ptr->data;
+       BezTriple *bezt = &point->bezt;
+
+       values[0] = bezt->vec[2][0];
+       values[1] = bezt->vec[2][1];
+       values[2] = bezt->vec[2][2];
+}
+
+static void rna_MaskSplinePoint_handle2_set(PointerRNA *ptr, const float *values)
+{
+       MaskSplinePoint *point = (MaskSplinePoint*) ptr->data;
+       BezTriple *bezt = &point->bezt;
+
+       bezt->vec[2][0] = values[0];
+       bezt->vec[2][1] = values[1];
+       bezt->vec[2][2] = values[2];
+}
+
+static void rna_MaskSplinePoint_ctrlpoint_get(PointerRNA *ptr, float *values)
+{
+       MaskSplinePoint *point = (MaskSplinePoint*) ptr->data;
+       BezTriple *bezt = &point->bezt;
+
+       values[0] = bezt->vec[1][0];
+       values[1] = bezt->vec[1][1];
+       values[2] = bezt->vec[1][2];
+}
+
+static void rna_MaskSplinePoint_ctrlpoint_set(PointerRNA *ptr, const float *values)
+{
+       MaskSplinePoint *point = (MaskSplinePoint*) ptr->data;
+       BezTriple *bezt = &point->bezt;
+
+       bezt->vec[1][0] = values[0];
+       bezt->vec[1][1] = values[1];
+       bezt->vec[1][2] = values[2];
+}
+
+static int rna_MaskSplinePoint_handle_type_get(PointerRNA *ptr)
+{
+       MaskSplinePoint *point = (MaskSplinePoint*) ptr->data;
+       BezTriple *bezt = &point->bezt;
+
+       return bezt->h1;
+}
+
+static void rna_MaskSplinePoint_handle_type_set(PointerRNA *ptr, int value)
+{
+       MaskSplinePoint *point = (MaskSplinePoint*) ptr->data;
+       BezTriple *bezt = &point->bezt;
+
+       bezt->h1 = bezt->h2 = value;
+}
+
+/* ** API **  */
+
+static MaskLayer *rna_Mask_layer_new(Mask *mask, const char *name)
+{
+       MaskLayer *masklay = BKE_mask_layer_new(mask, name);
+
+       WM_main_add_notifier(NC_MASK|NA_EDITED, mask);
+
+       return masklay;
+}
+
+void rna_Mask_layer_remove(Mask *mask, MaskLayer *masklay)
+{
+       BKE_mask_layer_remove(mask, masklay);
+
+       WM_main_add_notifier(NC_MASK|NA_EDITED, mask);
+}
+
+static void rna_MaskLayer_spline_add(ID *id, MaskLayer *masklay, int number)
+{
+       Mask *mask = (Mask*) id;
+       int i;
+
+       for (i = 0; i < number; i++)
+               BKE_mask_spline_add(masklay);
+
+       WM_main_add_notifier(NC_MASK|NA_EDITED, mask);
+}
+
+#else
+
+static void rna_def_maskParent(BlenderRNA *brna)
+{
+       StructRNA *srna;
+       PropertyRNA *prop;
+
+       static EnumPropertyItem mask_id_type_items[] = {
+               {ID_MC, "MOVIECLIP", ICON_SEQUENCE, "Movie Clip", ""},
+               {0, NULL, 0, NULL, NULL}};
+
+       srna = RNA_def_struct(brna, "MaskParent", NULL);
+       RNA_def_struct_ui_text(srna, "Mask Parent", "Parenting settings for maskign element");
+
+       /* use_parent */
+       prop = RNA_def_property(srna, "use_parent", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", MASK_PARENT_ACTIVE);
+       RNA_def_property_ui_text(prop, "Use Parent", "Use parenting for this layer");
+       RNA_def_property_update(prop, 0, "rna_Mask_update_data");
+
+       /* Target Properties - ID-block to Drive */
+       prop = RNA_def_property(srna, "id", PROP_POINTER, PROP_NONE);
+       RNA_def_property_struct_type(prop, "ID");
+       RNA_def_property_flag(prop, PROP_EDITABLE);
+       // RNA_def_property_editable_func(prop, "rna_maskSpline_id_editable");
+       /* note: custom set function is ONLY to avoid rna setting a user for this. */
+       RNA_def_property_pointer_funcs(prop, NULL, "rna_MaskParent_id_set", "rna_MaskParent_id_typef", NULL);
+       RNA_def_property_ui_text(prop, "ID", "ID-block to which masking element would be parented to or to it's property");
+       RNA_def_property_update(prop, 0, "rna_Mask_update_data");
+
+       prop = RNA_def_property(srna, "id_type", PROP_ENUM, PROP_NONE);
+       RNA_def_property_enum_sdna(prop, NULL, "id_type");
+       RNA_def_property_enum_items(prop, mask_id_type_items);
+       RNA_def_property_enum_default(prop, ID_MC);
+       RNA_def_property_enum_funcs(prop, NULL, "rna_MaskParent_id_type_set", NULL);
+       //RNA_def_property_editable_func(prop, "rna_MaskParent_id_type_editable");
+       RNA_def_property_ui_text(prop, "ID Type", "Type of ID-block that can be used");
+       RNA_def_property_update(prop, 0, "rna_Mask_update_data");
+
+       /* parent */
+       prop = RNA_def_property(srna, "parent", PROP_STRING, PROP_NONE);
+       RNA_def_property_ui_text(prop, "Parent", "Name of parent object in specified data block to which parenting happens");
+       RNA_def_property_string_maxlength(prop, MAX_ID_NAME - 2);
+       RNA_def_property_update(prop, 0, "rna_Mask_update_data");
+
+       /* sub_parent */
+       prop = RNA_def_property(srna, "sub_parent", PROP_STRING, PROP_NONE);
+       RNA_def_property_ui_text(prop, "Sub Parent", "Name of parent sub-object in specified data block to which parenting happens");
+       RNA_def_property_string_maxlength(prop, MAX_ID_NAME - 2);
+       RNA_def_property_update(prop, 0, "rna_Mask_update_data");
+}
+
+static void rna_def_maskSplinePointUW(BlenderRNA *brna)
+{
+       StructRNA *srna;
+       PropertyRNA *prop;
+
+       srna = RNA_def_struct(brna, "MaskSplinePointUW", NULL);
+       RNA_def_struct_ui_text(srna, "Mask Spline UW Point", "Single point in spline segment defining feather");
+
+       /* u */
+       prop = RNA_def_property(srna, "u", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "u");
+       RNA_def_property_range(prop, 0.0, 1.0);
+       RNA_def_property_ui_text(prop, "U", "U coordinate of point along spline segment");
+       RNA_def_property_update(prop, 0, "rna_Mask_update_data");
+
+       /* weight */
+       prop = RNA_def_property(srna, "weight", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "w");
+       RNA_def_property_range(prop, 0.0, 1.0);
+       RNA_def_property_ui_text(prop, "Weight", "Weight of feather point");
+       RNA_def_property_update(prop, 0, "rna_Mask_update_data");
+
+       /* select */
+       prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
+       RNA_def_property_ui_text(prop, "Select", "Selection status");
+       RNA_def_property_update(prop, 0, "rna_Mask_update_data");
+}
+
+static void rna_def_maskSplinePoint(BlenderRNA *brna)
+{
+       StructRNA *srna;
+       PropertyRNA *prop;
+
+       static EnumPropertyItem handle_type_items[] = {
+               {HD_AUTO, "AUTO", 0, "Auto", ""},
+               {HD_VECT, "VECTOR", 0, "Vector", ""},
+               {HD_ALIGN, "ALIGNED", 0, "Aligned", ""},
+               {0, NULL, 0, NULL, NULL}};
+
+       rna_def_maskSplinePointUW(brna);
+
+       srna = RNA_def_struct(brna, "MaskSplinePoint", NULL);
+       RNA_def_struct_ui_text(srna, "Mask Spline Point", "Single point in spline used for defining mask");
+
+       /* Vector values */
+       prop = RNA_def_property(srna, "handle_left", PROP_FLOAT, PROP_TRANSLATION);
+       RNA_def_property_array(prop, 3);
+       RNA_def_property_float_funcs(prop, "rna_MaskSplinePoint_handle1_get", "rna_MaskSplinePoint_handle1_set", NULL);
+       RNA_def_property_ui_text(prop, "Handle 1", "Coordinates of the first handle");
+       RNA_def_property_update(prop, 0, "rna_Mask_update_data");
+
+       prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
+       RNA_def_property_array(prop, 3);
+       RNA_def_property_float_funcs(prop, "rna_MaskSplinePoint_ctrlpoint_get", "rna_MaskSplinePoint_ctrlpoint_set", NULL);
+       RNA_def_property_ui_text(prop, "Control Point", "Coordinates of the control point");
+       RNA_def_property_update(prop, 0, "rna_Mask_update_data");
+
+       prop = RNA_def_property(srna, "handle_right", PROP_FLOAT, PROP_TRANSLATION);
+       RNA_def_property_array(prop, 3);
+       RNA_def_property_float_funcs(prop, "rna_MaskSplinePoint_handle2_get", "rna_MaskSplinePoint_handle2_set", NULL);
+       RNA_def_property_ui_text(prop, "Handle 2", "Coordinates of the second handle");
+       RNA_def_property_update(prop, 0, "rna_Mask_update_data");
+
+       /* handle_type */
+       prop = RNA_def_property(srna, "handle_type", PROP_ENUM, PROP_NONE);
+       RNA_def_property_enum_funcs(prop, "rna_MaskSplinePoint_handle_type_get", "rna_MaskSplinePoint_handle_type_set", NULL);
+       RNA_def_property_enum_items(prop, handle_type_items);
+       RNA_def_property_ui_text(prop, "Handle Type", "Handle type");
+       RNA_def_property_update(prop, 0, "rna_Mask_update_data");
+
+       /* select */
+       prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "bezt.f1", SELECT);
+       RNA_def_property_ui_text(prop, "Select", "Selection status");
+       RNA_def_property_update(prop, 0, "rna_Mask_update_data");
+
+       /* parent */
+       prop = RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE);
+       RNA_def_property_struct_type(prop, "MaskParent");
+
+       /* feather points */
+       prop = RNA_def_property(srna, "feather_points", PROP_COLLECTION, PROP_NONE);
+       RNA_def_property_struct_type(prop, "MaskSplinePointUW");
+       RNA_def_property_collection_sdna(prop, NULL, "uw", "tot_uw");
+       RNA_def_property_ui_text(prop, "Feather Points", "Points defining feather");
+}
+
+static void rna_def_mask_splines(BlenderRNA *brna)
+{
+       StructRNA *srna;
+       FunctionRNA *func;
+       PropertyRNA *prop;
+
+       srna = RNA_def_struct(brna, "MaskSplines", NULL);
+       RNA_def_struct_sdna(srna, "MaskLayer");
+       RNA_def_struct_ui_text(srna, "Mask Splines", "Collection of masking splines");
+
+       func = RNA_def_function(srna, "add", "rna_MaskLayer_spline_add");
+       RNA_def_function_flag(func, FUNC_USE_SELF_ID);
+       RNA_def_function_ui_description(func, "Add a number of splines to mask layer");
+       RNA_def_int(func, "count", 1, 0, INT_MAX, "Number", "Number of splines to add to the layer", 0, INT_MAX);
+
+       /* active spline */
+       prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
+       RNA_def_property_struct_type(prop, "MaskSpline");
+       RNA_def_property_pointer_funcs(prop, "rna_MaskLayer_active_spline_get", "rna_MaskLayer_active_spline_set", NULL, NULL);
+       RNA_def_property_flag(prop, PROP_EDITABLE|PROP_NEVER_UNLINK);
+       RNA_def_property_ui_text(prop, "Active Spline", "Active spline of masking layer");
+
+       /* active point */
+       prop = RNA_def_property(srna, "active_point", PROP_POINTER, PROP_NONE);
+       RNA_def_property_struct_type(prop, "MaskSplinePoint");
+       RNA_def_property_pointer_funcs(prop, "rna_MaskLayer_active_spline_point_get", "rna_MaskLayer_active_spline_point_set", NULL, NULL);
+       RNA_def_property_flag(prop, PROP_EDITABLE|PROP_NEVER_UNLINK);
+       RNA_def_property_ui_text(prop, "Active Spline", "Active spline of masking layer");
+}
+
+static void rna_def_maskSpline(BlenderRNA *brna)
+{
+       static EnumPropertyItem spline_interpolation_items[] = {
+               {MASK_SPLINE_INTERP_LINEAR, "LINEAR", 0, "Linear", ""},
+               {MASK_SPLINE_INTERP_EASE, "EASE", 0, "Ease", ""},
+               {0, NULL, 0, NULL, NULL}
+       };
+
+       StructRNA *srna;
+       PropertyRNA *prop;
+
+       rna_def_maskSplinePoint(brna);
+
+       srna = RNA_def_struct(brna, "MaskSpline", NULL);
+       RNA_def_struct_ui_text(srna, "Mask spline", "Single spline used for defining mash shape");
+
+       /* weight interpolation */
+       prop = RNA_def_property(srna, "weight_interpolation", PROP_ENUM, PROP_NONE);
+       RNA_def_property_enum_sdna(prop, NULL, "weight_interp");
+       RNA_def_property_enum_items(prop, spline_interpolation_items);
+       RNA_def_property_ui_text(prop, "Weight Interpolation", "The type of weight interpolation for spline");
+       RNA_def_property_update(prop, 0, "rna_Mask_update_data");
+
+       /* cyclic */
+       prop = RNA_def_property(srna, "use_cyclic", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", MASK_SPLINE_CYCLIC);
+       RNA_def_property_ui_text(prop, "Cyclic", "Make this spline a closed loop");
+       RNA_def_property_update(prop, 0, "rna_Mask_update_data");
+}
+
+static void rna_def_mask_layer(BlenderRNA *brna)
+{
+       static EnumPropertyItem masklay_blend_mode_items[] = {
+               {MASK_BLEND_ADD, "ADD", 0, "Add", ""},
+               {MASK_BLEND_SUBTRACT, "SUBTRACT", 0, "Subtract", ""},
+               {0, NULL, 0, NULL, NULL}
+       };
+
+       StructRNA *srna;
+       PropertyRNA *prop;
+
+       rna_def_maskSpline(brna);
+       rna_def_mask_splines(brna);
+
+       srna = RNA_def_struct(brna, "MaskLayer", NULL);
+       RNA_def_struct_ui_text(srna, "Mask Layer", "Single layer used for masking pixels");
+       RNA_def_struct_path_func(srna, "rna_MaskLayer_path");
+
+       /* name */
+       prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
+       RNA_def_property_ui_text(prop, "Name", "Unique name of layer");
+       RNA_def_property_string_funcs(prop, NULL, NULL, "rna_MaskLayer_name_set");
+       RNA_def_property_string_maxlength(prop, MAX_ID_NAME - 2);
+       RNA_def_property_update(prop, 0, "rna_Mask_update_data");
+       RNA_def_struct_name_property(srna, prop);
+
+       /* splines */
+       prop = RNA_def_property(srna, "splines", PROP_COLLECTION, PROP_NONE);
+       RNA_def_property_collection_funcs(prop, "rna_MaskLayer_splines_begin", "rna_iterator_listbase_next", "rna_iterator_listbase_end", "rna_iterator_listbase_get", 0, 0, 0, 0);
+       RNA_def_property_struct_type(prop, "MaskSpline");
+       RNA_def_property_ui_text(prop, "Splines", "Collection of splines which defines this layer");
+       RNA_def_property_srna(prop, "MaskSplines");
+
+       /* restrict */
+       prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "restrictflag", MASK_RESTRICT_VIEW);
+       RNA_def_property_ui_text(prop, "Restrict View", "Restrict visibility in the viewport");
+       RNA_def_property_ui_icon(prop, ICON_RESTRICT_VIEW_OFF, 1);
+       RNA_def_property_update(prop, NC_MASK | ND_DRAW, NULL);
+
+       prop = RNA_def_property(srna, "hide_select", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "restrictflag", MASK_RESTRICT_SELECT);
+       RNA_def_property_ui_text(prop, "Restrict Select", "Restrict selection in the viewport");
+       RNA_def_property_ui_icon(prop, ICON_RESTRICT_SELECT_OFF, 1);
+       RNA_def_property_update(prop, NC_MASK | ND_DRAW, NULL);
+
+       prop = RNA_def_property(srna, "hide_render", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "restrictflag", MASK_RESTRICT_RENDER);
+       RNA_def_property_ui_text(prop, "Restrict Render", "Restrict renderability");
+       RNA_def_property_ui_icon(prop, ICON_RESTRICT_RENDER_OFF, 1);
+       RNA_def_property_update(prop, NC_MASK | NA_EDITED, NULL);
+
+       /* render settings */
+       prop = RNA_def_property(srna, "alpha", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "alpha");
+       RNA_def_property_range(prop, 0.0, 1.0f);
+       RNA_def_property_ui_text(prop, "Opacity", "Render Opacity");
+       RNA_def_property_update(prop, NC_MASK | NA_EDITED, NULL);
+
+       /* weight interpolation */
+       prop = RNA_def_property(srna, "blend", PROP_ENUM, PROP_NONE);
+       RNA_def_property_enum_sdna(prop, NULL, "blend");
+       RNA_def_property_enum_items(prop, masklay_blend_mode_items);
+       RNA_def_property_ui_text(prop, "Blend", "Method of blending mask layers");
+       RNA_def_property_update(prop, 0, "rna_Mask_update_data");
+       RNA_def_property_update(prop, NC_MASK | NA_EDITED, NULL);
+
+       prop = RNA_def_property(srna, "invert", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "blend_flag", MASK_BLENDFLAG_INVERT);
+       RNA_def_property_ui_text(prop, "Restrict View", "Restrict visibility in the viewport");
+       RNA_def_property_update(prop, NC_MASK | NA_EDITED, NULL);
+
+}
+
+static void rna_def_masklayers(BlenderRNA *brna, PropertyRNA *cprop)
+{
+       StructRNA *srna;
+       PropertyRNA *prop;
+
+       FunctionRNA *func;
+       PropertyRNA *parm;
+
+       RNA_def_property_srna(cprop, "MaskLayers");
+       srna = RNA_def_struct(brna, "MaskLayers", NULL);
+       RNA_def_struct_sdna(srna, "Mask");
+       RNA_def_struct_ui_text(srna, "Mask Layers", "Collection of layers used by mask");
+
+       func = RNA_def_function(srna, "new", "rna_Mask_layer_new");
+       RNA_def_function_ui_description(func, "Add layer to this mask");
+       RNA_def_string(func, "name", "", 0, "Name", "Name of new layer");
+       parm = RNA_def_pointer(func, "layer", "MaskLayer", "", "New mask layer");
+       RNA_def_function_return(func, parm);
+
+       func = RNA_def_function(srna, "remove", "rna_Mask_layer_remove");
+       RNA_def_function_ui_description(func, "Remove layer from this mask");
+       RNA_def_pointer(func, "layer", "MaskLayer", "", "Shape to be removed");
+
+       /* active layer */
+       prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
+       RNA_def_property_struct_type(prop, "MaskLayer");
+       RNA_def_property_pointer_funcs(prop, "rna_Mask_layer_active_get", "rna_Mask_layer_active_set", NULL, NULL);
+       RNA_def_property_flag(prop, PROP_EDITABLE|PROP_NEVER_UNLINK);
+       RNA_def_property_ui_text(prop, "Active Shape", "Active layer in this mask");
+}
+
+static void rna_def_mask(BlenderRNA *brna)
+{
+       StructRNA *srna;
+       PropertyRNA *prop;
+
+       rna_def_mask_layer(brna);
+
+       srna = RNA_def_struct(brna, "Mask", "ID");
+       RNA_def_struct_ui_text(srna, "Mask", "Mask datablock defining mask for compositing");
+       RNA_def_struct_ui_icon(srna, ICON_MOD_MASK);
+
+       /* mask layers */
+       prop = RNA_def_property(srna, "layers", PROP_COLLECTION, PROP_NONE);
+       RNA_def_property_collection_funcs(prop, "rna_Mask_layers_begin", "rna_iterator_listbase_next", "rna_iterator_listbase_end", "rna_iterator_listbase_get", 0, 0, 0, 0);
+       RNA_def_property_struct_type(prop, "MaskLayer");
+       RNA_def_property_ui_text(prop, "Layers", "Collection of layers which defines this mask");
+       rna_def_masklayers(brna, prop);
+
+       /* active masklay index */
+       prop = RNA_def_property(srna, "active_layer_index", PROP_INT, PROP_NONE);
+       RNA_def_property_int_sdna(prop, NULL, "masklay_act");
+       RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
+       RNA_def_property_int_funcs(prop, "rna_Mask_layer_active_index_get", "rna_Mask_layer_active_index_set", "rna_Mask_layer_active_index_range");
+       RNA_def_property_ui_text(prop, "Active Shape Index", "Index of active layer in list of all mask's layers");
+
+       /* pointers */
+       rna_def_animdata_common(srna);
+}
+
+void RNA_def_mask(BlenderRNA *brna)
+{
+       rna_def_maskParent(brna);
+       rna_def_mask(brna);
+}
+
+#endif
diff --git a/source/blender/nodes/composite/nodes/node_composite_mask.c b/source/blender/nodes/composite/nodes/node_composite_mask.c
new file mode 100644 (file)
index 0000000..c90c791
--- /dev/null
@@ -0,0 +1,101 @@
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. 
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2012 Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): Blender Foundation,
+ *                 Sergey Sharybin
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/nodes/composite/nodes/node_composite_mask.c
+ *  \ingroup cmpnodes
+ */
+
+#include "BLF_translation.h"
+
+#include "DNA_mask_types.h"
+
+#include "BKE_mask.h"
+
+#include "node_composite_util.h"
+
+/* **************** Translate  ******************** */
+
+static bNodeSocketTemplate cmp_node_mask_in[] = {
+       {   SOCK_RGBA, 1, "Image",          0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
+       {   -1, 0, ""   }
+};
+
+static bNodeSocketTemplate cmp_node_mask_out[] = {
+       {   SOCK_RGBA, 0, "Image"},
+       {   -1, 0, ""   }
+};
+
+static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out)
+{
+       if (node->id) {
+               Mask *mask = (Mask *)node->id;
+               CompBuf *stackbuf;
+               RenderData *rd = data;
+               float *res;
+               int sx, sy;
+
+               if (!out[0]->hasoutput) {
+                       /* the node's output socket is not connected to anything...
+                        * do not execute any further, just exit the node immediately
+                        */
+                       return;
+               }
+
+               if (in[0]->hasinput && in[0]->data) {
+                       CompBuf *cbuf = typecheck_compbuf(in[0]->data, CB_RGBA);
+
+                       sx = cbuf->x;
+                       sy = cbuf->y;
+               }
+               else {
+                       sx = (rd->size * rd->xsch) / 100;
+                       sy = (rd->size * rd->ysch) / 100;
+               }
+
+               /* allocate the output buffer */
+               stackbuf = alloc_compbuf(sx, sy, CB_VAL, TRUE);
+               res = stackbuf->rect;
+
+               BKE_mask_rasterize(mask, sx, sy, res);
+
+               /* pass on output and free */
+               out[0]->data = stackbuf;
+       }
+}
+
+void register_node_type_cmp_mask(bNodeTreeType *ttype)
+{
+       static bNodeType ntype;
+
+       node_type_base(ttype, &ntype, CMP_NODE_MASK, "Mask", NODE_CLASS_INPUT, NODE_OPTIONS);
+       node_type_socket_templates(&ntype, cmp_node_mask_in, cmp_node_mask_out);
+       node_type_size(&ntype, 140, 100, 320);
+       node_type_exec(&ntype, exec);
+
+       nodeRegisterType(ttype, &ntype);
+}