griefith/test
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

remaining mask files from tomato. these wont get svn history carried over.

Browse Source
This commit is contained in:
Campbell Barton
2012-06-04 15:49:58 +00:00
parent 070d2122b0
commit 489fa2d108
8 changed files with 1261 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
source/blender/compositor/nodes/COM_MaskNode.cpp Normal file
View File

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

38
source/blender/compositor/nodes/COM_MaskNode.h Normal file
View File

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

124
source/blender/compositor/operations/COM_MaskOperation.cpp Normal file
View File

@@ -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;
}
}

66
source/blender/compositor/operations/COM_MaskOperation.h Normal file
View File

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

47
source/blender/editors/include/ED_mask.h Normal file
View File

@@ -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 */

163
source/blender/makesdna/DNA_mask_types.h Normal file
View File

@@ -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__

657
source/blender/makesrna/intern/rna_mask.c Normal file
View File

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

101
source/blender/nodes/composite/nodes/node_composite_mask.c Normal file
View File

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