Merge remote-tracking branch 'origin/master' into soc-2014-fluid

Conflicts:
	.gitignore
	intern/cycles/CMakeLists.txt
	source/blender/blenkernel/intern/smoke.c
	source/blender/python/intern/bpy_interface.c
	source/creator/CMakeLists.txt

1 files changed, 97 insertions, 54 deletions

diff --git a/source/blender/blenkernel/intern/customdata.c b/source/blender/blenkernel/intern/customdata.c
index fd4350123b4..7684c5a3a42 100644
--- a/source/blender/blenkernel/intern/customdata.c
+++ b/source/blender/blenkernel/intern/customdata.c
@@ -129,21 +129,24 @@ typedef struct LayerTypeInfo {
 	void (*set_default)(void *data, int count);
 
 	/** functions necessary for geometry collapse */
-	bool (*equal)(void *data1, void *data2);
+	bool (*equal)(const void *data1, const void *data2);
 	void (*multiply)(void *data, float fac);
 	void (*initminmax)(void *min, void *max);
-	void (*add)(void *data1, void *data2);
-	void (*dominmax)(void *data1, void *min, void *max);
-	void (*copyvalue)(void *source, void *dest);
+	void (*add)(void *data1, const void *data2);
+	void (*dominmax)(const void *data1, void *min, void *max);
+	void (*copyvalue)(const void *source, void *dest);
 
 	/** a function to read data from a cdf file */
 	int (*read)(CDataFile *cdf, void *data, int count);
 
 	/** a function to write data to a cdf file */
-	int (*write)(CDataFile *cdf, void *data, int count);
+	int (*write)(CDataFile *cdf, const void *data, int count);
 
 	/** a function to determine file size */
-	size_t (*filesize)(CDataFile *cdf, void *data, int count);
+	size_t (*filesize)(CDataFile *cdf, const void *data, int count);
+
+	/** a function to determine max allowed number of layers, should be NULL or return -1 if no limit */
+	int (*layers_max)(void);
 } LayerTypeInfo;
 
 static void layerCopy_mdeformvert(const void *source, void *dest,
@@ -379,6 +382,11 @@ static void layerDefault_tface(void *data, int count)
 		tf[i] = default_tf;
 }
 
+static int layerMaxNum_tface(void)
+{
+	return MAX_MTFACE;
+}
+
 static void layerCopy_propFloat(const void *source, void *dest,
                                 int count)
 {
@@ -552,9 +560,9 @@ static int layerRead_mdisps(CDataFile *cdf, void *data, int count)
 	return 1;
 }
 
-static int layerWrite_mdisps(CDataFile *cdf, void *data, int count)
+static int layerWrite_mdisps(CDataFile *cdf, const void *data, int count)
 {
-	MDisps *d = data;
+	const MDisps *d = data;
 	int i;
 
 	for (i = 0; i < count; ++i) {
@@ -567,9 +575,9 @@ static int layerWrite_mdisps(CDataFile *cdf, void *data, int count)
 	return 1;
 }
 
-static size_t layerFilesize_mdisps(CDataFile *UNUSED(cdf), void *data, int count)
+static size_t layerFilesize_mdisps(CDataFile *UNUSED(cdf), const void *data, int count)
 {
-	MDisps *d = data;
+	const MDisps *d = data;
 	size_t size = 0;
 	int i;
 
@@ -612,9 +620,10 @@ static void layerFree_grid_paint_mask(void *data, int count, int UNUSED(size))
 }
 
 /* --------- */
-static void layerCopyValue_mloopcol(void *source, void *dest)
+static void layerCopyValue_mloopcol(const void *source, void *dest)
 {
-	MLoopCol *m1 = source, *m2 = dest;
+	const MLoopCol *m1 = source;
+	MLoopCol *m2 = dest;
 	
 	m2->r = m1->r;
 	m2->g = m1->g;
@@ -622,9 +631,9 @@ static void layerCopyValue_mloopcol(void *source, void *dest)
 	m2->a = m1->a;
 }
 
-static bool layerEqual_mloopcol(void *data1, void *data2)
+static bool layerEqual_mloopcol(const void *data1, const void *data2)
 {
-	MLoopCol *m1 = data1, *m2 = data2;
+	const MLoopCol *m1 = data1, *m2 = data2;
 	float r, g, b, a;
 
 	r = m1->r - m2->r;
@@ -645,9 +654,10 @@ static void layerMultiply_mloopcol(void *data, float fac)
 	m->a = (float)m->a * fac;
 }
 
-static void layerAdd_mloopcol(void *data1, void *data2)
+static void layerAdd_mloopcol(void *data1, const void *data2)
 {
-	MLoopCol *m = data1, *m2 = data2;
+	MLoopCol *m = data1;
+	const MLoopCol *m2 = data2;
 
 	m->r += m2->r;
 	m->g += m2->g;
@@ -655,9 +665,9 @@ static void layerAdd_mloopcol(void *data1, void *data2)
 	m->a += m2->a;
 }
 
-static void layerDoMinMax_mloopcol(void *data, void *vmin, void *vmax)
+static void layerDoMinMax_mloopcol(const void *data, void *vmin, void *vmax)
 {
-	MLoopCol *m = data;
+	const MLoopCol *m = data;
 	MLoopCol *min = vmin, *max = vmax;
 
 	if (m->r < min->r) min->r = m->r;
@@ -743,16 +753,22 @@ static void layerInterp_mloopcol(void **sources, const float *weights,
 	mc->a = (int)col.a;
 }
 
-static void layerCopyValue_mloopuv(void *source, void *dest)
+static int layerMaxNum_mloopcol(void)
 {
-	MLoopUV *luv1 = source, *luv2 = dest;
+	return MAX_MCOL;
+}
+
+static void layerCopyValue_mloopuv(const void *source, void *dest)
+{
+	const MLoopUV *luv1 = source;
+	MLoopUV *luv2 = dest;
 
 	copy_v2_v2(luv2->uv, luv1->uv);
 }
 
-static bool layerEqual_mloopuv(void *data1, void *data2)
+static bool layerEqual_mloopuv(const void *data1, const void *data2)
 {
-	MLoopUV *luv1 = data1, *luv2 = data2;
+	const MLoopUV *luv1 = data1, *luv2 = data2;
 
 	return len_squared_v2v2(luv1->uv, luv2->uv) < 0.00001f;
 }
@@ -771,16 +787,18 @@ static void layerInitMinMax_mloopuv(void *vmin, void *vmax)
 	INIT_MINMAX2(min->uv, max->uv);
 }
 
-static void layerDoMinMax_mloopuv(void *data, void *vmin, void *vmax)
+static void layerDoMinMax_mloopuv(const void *data, void *vmin, void *vmax)
 {
-	MLoopUV *min = vmin, *max = vmax, *luv = data;
+	const MLoopUV *luv = data;
+	MLoopUV *min = vmin, *max = vmax;
 
 	minmax_v2v2_v2(min->uv, max->uv, luv->uv);
 }
 
-static void layerAdd_mloopuv(void *data1, void *data2)
+static void layerAdd_mloopuv(void *data1, const void *data2)
 {
-	MLoopUV *l1 = data1, *l2 = data2;
+	MLoopUV *l1 = data1;
+	const MLoopUV *l2 = data2;
 
 	add_v2_v2(l1->uv, l2->uv);
 }
@@ -815,16 +833,17 @@ static void layerInterp_mloopuv(void **sources, const float *weights,
 }
 
 /* origspace is almost exact copy of mloopuv's, keep in sync */
-static void layerCopyValue_mloop_origspace(void *source, void *dest)
+static void layerCopyValue_mloop_origspace(const void *source, void *dest)
 {
-	OrigSpaceLoop *luv1 = source, *luv2 = dest;
+	const OrigSpaceLoop *luv1 = source;
+	OrigSpaceLoop *luv2 = dest;
 
 	copy_v2_v2(luv2->uv, luv1->uv);
 }
 
-static bool layerEqual_mloop_origspace(void *data1, void *data2)
+static bool layerEqual_mloop_origspace(const void *data1, const void *data2)
 {
-	OrigSpaceLoop *luv1 = data1, *luv2 = data2;
+	const OrigSpaceLoop *luv1 = data1, *luv2 = data2;
 
 	return len_squared_v2v2(luv1->uv, luv2->uv) < 0.00001f;
 }
@@ -843,16 +862,18 @@ static void layerInitMinMax_mloop_origspace(void *vmin, void *vmax)
 	INIT_MINMAX2(min->uv, max->uv);
 }
 
-static void layerDoMinMax_mloop_origspace(void *data, void *vmin, void *vmax)
+static void layerDoMinMax_mloop_origspace(const void *data, void *vmin, void *vmax)
 {
-	OrigSpaceLoop *min = vmin, *max = vmax, *luv = data;
+	const OrigSpaceLoop *luv = data;
+	OrigSpaceLoop *min = vmin, *max = vmax;
 
 	minmax_v2v2_v2(min->uv, max->uv, luv->uv);
 }
 
-static void layerAdd_mloop_origspace(void *data1, void *data2)
+static void layerAdd_mloop_origspace(void *data1, const void *data2)
 {
-	OrigSpaceLoop *l1 = data1, *l2 = data2;
+	OrigSpaceLoop *l1 = data1;
+	const OrigSpaceLoop *l2 = data2;
 
 	add_v2_v2(l1->uv, l2->uv);
 }
@@ -1085,12 +1106,12 @@ static const LayerTypeInfo LAYERTYPEINFO[CD_NUMTYPES] = {
 	/* 4: CD_MFACE */
 	{sizeof(MFace), "MFace", 1, NULL, NULL, NULL, NULL, NULL, NULL},
 	/* 5: CD_MTFACE */
-	{sizeof(MTFace), "MTFace", 1, N_("UVMap"), layerCopy_tface, NULL,
-	 layerInterp_tface, layerSwap_tface, layerDefault_tface},
+	{sizeof(MTFace), "MTFace", 1, N_("UVMap"), layerCopy_tface, NULL, layerInterp_tface, layerSwap_tface,
+	 layerDefault_tface, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, layerMaxNum_tface},
 	/* 6: CD_MCOL */
 	/* 4 MCol structs per face */
 	{sizeof(MCol) * 4, "MCol", 4, N_("Col"), NULL, NULL, layerInterp_mcol,
-	 layerSwap_mcol, layerDefault_mcol},
+	 layerSwap_mcol, layerDefault_mcol, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, layerMaxNum_mloopcol},
 	/* 7: CD_ORIGINDEX */
 	{sizeof(int), "", 0, NULL, NULL, NULL, NULL, NULL, layerDefault_origindex},
 	/* 8: CD_NORMAL */
@@ -1111,15 +1132,16 @@ static const LayerTypeInfo LAYERTYPEINFO[CD_NUMTYPES] = {
 	{sizeof(float) * 3, "", 0, NULL, NULL, NULL, NULL, NULL, NULL},
 	/* 15: CD_MTEXPOLY */
 	/* note, when we expose the UV Map / TexFace split to the user, change this back to face Texture */
-	{sizeof(MTexPoly), "MTexPoly", 1, N_("UVMap") /* "Face Texture" */, NULL, NULL, NULL, NULL, NULL},
+	{sizeof(MTexPoly), "MTexPoly", 1, N_("UVMap") /* "Face Texture" */, NULL, NULL, NULL, NULL, NULL,
+	 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, layerMaxNum_tface},
 	/* 16: CD_MLOOPUV */
 	{sizeof(MLoopUV), "MLoopUV", 1, N_("UVMap"), NULL, NULL, layerInterp_mloopuv, NULL, NULL,
 	 layerEqual_mloopuv, layerMultiply_mloopuv, layerInitMinMax_mloopuv, 
-	 layerAdd_mloopuv, layerDoMinMax_mloopuv, layerCopyValue_mloopuv},
+	 layerAdd_mloopuv, layerDoMinMax_mloopuv, layerCopyValue_mloopuv, NULL, NULL, NULL, layerMaxNum_tface},
 	/* 17: CD_MLOOPCOL */
 	{sizeof(MLoopCol), "MLoopCol", 1, N_("Col"), NULL, NULL, layerInterp_mloopcol, NULL,
 	 layerDefault_mloopcol, layerEqual_mloopcol, layerMultiply_mloopcol, layerInitMinMax_mloopcol, 
-	 layerAdd_mloopcol, layerDoMinMax_mloopcol, layerCopyValue_mloopcol},
+	 layerAdd_mloopcol, layerDoMinMax_mloopcol, layerCopyValue_mloopcol, NULL, NULL, NULL, layerMaxNum_mloopcol},
 	/* 18: CD_TANGENT */
 	{sizeof(float) * 4 * 4, "", 0, NULL, NULL, NULL, NULL, NULL, NULL},
 	/* 19: CD_MDISPS */
@@ -1311,7 +1333,8 @@ bool CustomData_merge(const struct CustomData *source, struct CustomData *dest,
 	/*const LayerTypeInfo *typeInfo;*/
 	CustomDataLayer *layer, *newlayer;
 	void *data;
-	int i, type, number = 0, lasttype = -1, lastactive = 0, lastrender = 0, lastclone = 0, lastmask = 0, lastflag = 0;
+	int i, type, lasttype = -1, lastactive = 0, lastrender = 0, lastclone = 0, lastmask = 0, lastflag = 0;
+	int number = 0, maxnumber = -1;
 	bool changed = false;
 
 	for (i = 0; i < source->totlayer; ++i) {
@@ -1322,6 +1345,7 @@ bool CustomData_merge(const struct CustomData *source, struct CustomData *dest,
 
 		if (type != lasttype) {
 			number = 0;
+			maxnumber = CustomData_layertype_layers_max(type);
 			lastactive = layer->active;
 			lastrender = layer->active_rnd;
 			lastclone = layer->active_clone;
@@ -1334,6 +1358,7 @@ bool CustomData_merge(const struct CustomData *source, struct CustomData *dest,
 
 		if (lastflag & CD_FLAG_NOCOPY) continue;
 		else if (!(mask & CD_TYPE_AS_MASK(type))) continue;
+		else if ((maxnumber != -1) && (number >= maxnumber)) continue;
 		else if (CustomData_get_layer_named(dest, type, layer->name)) continue;
 
 		switch (alloctype) {
@@ -2546,12 +2571,12 @@ void CustomData_bmesh_free_block(CustomData *data, void **block)
 /**
  * Same as #CustomData_bmesh_free_block but zero the memory rather then freeing.
  */
-void CustomData_bmesh_free_block_data(CustomData *data, void **block)
+void CustomData_bmesh_free_block_data(CustomData *data, void *block)
 {
 	const LayerTypeInfo *typeInfo;
 	int i;
 
-	if (*block == NULL)
+	if (block == NULL)
 		return;
 
 	for (i = 0; i < data->totlayer; ++i) {
@@ -2560,13 +2585,13 @@ void CustomData_bmesh_free_block_data(CustomData *data, void **block)
 
 			if (typeInfo->free) {
 				int offset = data->layers[i].offset;
-				typeInfo->free((char *)*block + offset, 1, typeInfo->size);
+				typeInfo->free((char *)block + offset, 1, typeInfo->size);
 			}
 		}
 	}
 
 	if (data->totsize)
-		memset(*block, 0, data->totsize);
+		memset(block, 0, data->totsize);
 }
 
 static void CustomData_bmesh_alloc_block(CustomData *data, void **block)
@@ -2661,7 +2686,7 @@ void *CustomData_bmesh_get_layer_n(const CustomData *data, void *block, int n)
 	return (char *)block + data->layers[n].offset;
 }
 
-bool CustomData_layer_has_math(struct CustomData *data, int layer_n)
+bool CustomData_layer_has_math(const struct CustomData *data, int layer_n)
 {
 	const LayerTypeInfo *typeInfo = layerType_getInfo(data->layers[layer_n].type);
 	
@@ -2674,7 +2699,7 @@ bool CustomData_layer_has_math(struct CustomData *data, int layer_n)
 	return false;
 }
 
-bool CustomData_layer_has_interp(struct CustomData *data, int layer_n)
+bool CustomData_layer_has_interp(const struct CustomData *data, int layer_n)
 {
 	const LayerTypeInfo *typeInfo = layerType_getInfo(data->layers[layer_n].type);
 
@@ -2685,7 +2710,7 @@ bool CustomData_layer_has_interp(struct CustomData *data, int layer_n)
 	return false;
 }
 
-bool CustomData_has_math(struct CustomData *data)
+bool CustomData_has_math(const struct CustomData *data)
 {
 	int i;
 
@@ -2700,7 +2725,7 @@ bool CustomData_has_math(struct CustomData *data)
 }
 
 /* a non bmesh version would have to check layer->data */
-bool CustomData_bmesh_has_free(struct CustomData *data)
+bool CustomData_bmesh_has_free(const struct CustomData *data)
 {
 	const LayerTypeInfo *typeInfo;
 	int i;
@@ -2716,7 +2741,7 @@ bool CustomData_bmesh_has_free(struct CustomData *data)
 	return false;
 }
 
-bool CustomData_has_interp(struct CustomData *data)
+bool CustomData_has_interp(const struct CustomData *data)
 {
 	int i;
 
@@ -2732,7 +2757,7 @@ bool CustomData_has_interp(struct CustomData *data)
 
 /* copies the "value" (e.g. mloopuv uv or mloopcol colors) from one block to
  * another, while not overwriting anything else (e.g. flags)*/
-void CustomData_data_copy_value(int type, void *source, void *dest)
+void CustomData_data_copy_value(int type, const void *source, void *dest)
 {
 	const LayerTypeInfo *typeInfo = layerType_getInfo(type);
 
@@ -2744,7 +2769,7 @@ void CustomData_data_copy_value(int type, void *source, void *dest)
 		memcpy(dest, source, typeInfo->size);
 }
 
-bool CustomData_data_equals(int type, void *data1, void *data2)
+bool CustomData_data_equals(int type, const void *data1, const void *data2)
 {
 	const LayerTypeInfo *typeInfo = layerType_getInfo(type);
 
@@ -2762,7 +2787,7 @@ void CustomData_data_initminmax(int type, void *min, void *max)
 }
 
 
-void CustomData_data_dominmax(int type, void *data, void *min, void *max)
+void CustomData_data_dominmax(int type, const void *data, void *min, void *max)
 {
 	const LayerTypeInfo *typeInfo = layerType_getInfo(type);
 
@@ -2780,7 +2805,7 @@ void CustomData_data_multiply(int type, void *data, float fac)
 }
 
 
-void CustomData_data_add(int type, void *data1, void *data2)
+void CustomData_data_add(int type, void *data1, const void *data2)
 {
 	const LayerTypeInfo *typeInfo = layerType_getInfo(type);
 
@@ -3031,6 +3056,24 @@ bool CustomData_layertype_is_singleton(int type)
 	return typeInfo->defaultname == NULL;
 }
 
+/**
+ * \return Maximum number of layers of given \a type, -1 means 'no limit'.
+ */
+int CustomData_layertype_layers_max(const int type)
+{
+	const LayerTypeInfo *typeInfo = layerType_getInfo(type);
+
+	/* Same test as for singleton above. */
+	if (typeInfo->defaultname == NULL) {
+		return 1;
+	}
+	else if (typeInfo->layers_max == NULL) {
+		return -1;
+	}
+
+	return typeInfo->layers_max();
+}
+
 static bool CustomData_is_property_layer(int type)
 {
 	if ((type == CD_PROP_FLT) || (type == CD_PROP_INT) || (type == CD_PROP_STR))