Mod-bskin: Fix 0 radius hang out

This reverts commit 2e5b5cc5f2.

release/scripts/startup/bl_ui/properties_data_modifier.py

@@ -1175,6 +1175,18 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         col.prop(md, "use_y_symmetry")
         col.prop(md, "use_z_symmetry")
 
+    def BSKIN(self, layout, ob, md):
+        row = layout.row()
+        row.operator("object.bskin_armature_create", text="Create Armature")
+        row.operator("object.bskin_root_mark", text="Mark Root")
+        row.operator("object.bskin_radii_equalize", text="Equalize skin radius")
+        row = layout.row()
+        row.operator("object.bskin_hole_mark_clear", text="Mark Hole").action = 'HOLE_MARK'
+        row.operator("object.bskin_hole_mark_clear", text="Clear Hole").action = 'HOLE_CLEAR'
+        row = layout.row()
+        row.operator("object.bskin_hole_mark_clear", text="Mark Flat").action = 'FLAT_MARK'
+        row.operator("object.bskin_hole_mark_clear", text="Clear Flat").action = 'FLAT_CLEAR'
+        
     def TRIANGULATE(self, layout, ob, md):
         row = layout.row()
 

source/blender/editors/object/object_intern.h

@@ -184,6 +184,12 @@ void OBJECT_OT_skin_loose_mark_clear(struct wmOperatorType *ot);
 void OBJECT_OT_skin_radii_equalize(struct wmOperatorType *ot);
 void OBJECT_OT_skin_armature_create(struct wmOperatorType *ot);
 void OBJECT_OT_laplaciandeform_bind(struct wmOperatorType *ot);
+void OBJECT_OT_bskin_root_mark(struct wmOperatorType *ot);
+void OBJECT_OT_bskin_armature_create(struct wmOperatorType *ot);
+void OBJECT_OT_bskin_radii_equalize(struct wmOperatorType *ot);
+void OBJECT_OT_bskin_flat_hole_mark_clear(struct wmOperatorType *ot);
+
+
 
 /* object_constraint.c */
 void OBJECT_OT_constraint_add(struct wmOperatorType *ot);

source/blender/editors/object/object_modifier.c

@@ -90,6 +90,8 @@
 #include "object_intern.h"
 
 static void modifier_skin_customdata_delete(struct Object *ob);
+// static void modifier_bskin_customdata_delete(struct Object *ob);
+
 
 /******************************** API ****************************/
 
@@ -169,6 +171,10 @@ ModifierData *ED_object_modifier_add(ReportList *reports, Main *bmain, Scene *sc
 			/* ensure skin-node customdata exists */
 			BKE_mesh_ensure_skin_customdata(ob->data);
 		}
+		else if (type == eModifierType_BSkin) {
+			/* ensure skin-node customdata exists */
+			BKE_mesh_ensure_skin_customdata(ob->data);
+		}
 	}
 
 	DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
@@ -313,6 +319,11 @@ static bool object_modifier_remove(Main *bmain, Object *ob, ModifierData *md,
 		if (object_modifier_safe_to_delete(bmain, ob, md, eModifierType_Skin))
 			modifier_skin_customdata_delete(ob);
 	}
+	else if (md->type == eModifierType_BSkin) {
+		/* Delete MVertSkin layer if not used by another skin modifier */
+		if (object_modifier_safe_to_delete(bmain, ob, md, eModifierType_BSkin))
+			modifier_skin_customdata_delete(ob);
+	}
 
 	if (ELEM(md->type, eModifierType_Softbody, eModifierType_Cloth) &&
 	    BLI_listbase_is_empty(&ob->particlesystem))
@@ -1430,6 +1441,403 @@ void OBJECT_OT_multires_base_apply(wmOperatorType *ot)
 	edit_modifier_properties(ot);
 }
 
+/************************** bskin modifier ***********************/
+#if 0
+static void modifier_bskin_customdata_delete(Object *ob)
+{
+	Mesh *me = ob->data;
+	BMEditMesh *em = me->edit_btmesh;
+
+	if (em)
+		BM_data_layer_free(em->bm, &em->bm->vdata, CD_MVERT_SKIN);
+	else
+		CustomData_free_layer_active(&me->vdata, CD_MVERT_SKIN, me->totvert);
+}
+#endif
+
+static int bskin_poll(bContext *C)
+{
+	return (!CTX_data_edit_object(C) &&
+		edit_modifier_poll_generic(C, &RNA_BSkinModifier, (1 << OB_MESH)));
+}
+
+static int bskin_edit_poll(bContext *C)
+{
+	return (CTX_data_edit_object(C) &&
+		edit_modifier_poll_generic(C, &RNA_BSkinModifier, (1 << OB_MESH)));
+}
+
+static void bskin_root_clear(BMesh *bm, BMVert *bm_vert, GSet *visited)
+{
+	BMEdge *bm_edge;
+	BMIter bm_iter;
+
+	BM_ITER_ELEM(bm_edge, &bm_iter, bm_vert, BM_EDGES_OF_VERT) {
+		BMVert *v2 = BM_edge_other_vert(bm_edge, bm_vert);
+
+		if (!BLI_gset_haskey(visited, v2)) {
+			MVertSkin *vs = CustomData_bmesh_get(&bm->vdata,
+				v2->head.data,
+				CD_MVERT_SKIN);
+
+			/* clear vertex root flag and add to visited set */
+			vs->flag &= ~MVERT_SKIN_ROOT;
+			BLI_gset_insert(visited, v2);
+
+			bskin_root_clear(bm, v2, visited);
+		}
+	}
+}
+
+static int bskin_root_mark_exec(bContext *C, wmOperator *UNUSED(op))
+{
+	Object *ob = CTX_data_edit_object(C);
+	BMEditMesh *em = BKE_editmesh_from_object(ob);
+	BMesh *bm = em->bm;
+	BMVert *bm_vert;
+	BMIter bm_iter;
+	GSet *visited;
+
+	visited = BLI_gset_ptr_new(__func__);
+
+	BKE_mesh_ensure_skin_customdata(ob->data);
+
+	BM_ITER_MESH(bm_vert, &bm_iter, bm, BM_VERTS_OF_MESH) {
+		if (!BLI_gset_haskey(visited, bm_vert) &&
+			BM_elem_flag_test(bm_vert, BM_ELEM_SELECT))
+		{
+			MVertSkin *vs = CustomData_bmesh_get(&bm->vdata,
+				bm_vert->head.data,
+				CD_MVERT_SKIN);
+
+			/* mark vertex as root and add to visited set */
+			vs->flag |= MVERT_SKIN_ROOT;
+			BLI_gset_insert(visited, bm_vert);
+
+			/* clear root flag from all connected vertices (recursively) */
+			bskin_root_clear(bm, bm_vert, visited);
+		}
+	}
+
+	BLI_gset_free(visited, NULL);
+
+	DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
+	WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
+
+	return OPERATOR_FINISHED;
+}
+
+void OBJECT_OT_bskin_root_mark(wmOperatorType *ot)
+{
+	ot->name = "BSkin Root Mark";
+	ot->description = "Mark selected vertices as roots";
+	ot->idname = "OBJECT_OT_bskin_root_mark";
+
+	ot->poll = bskin_edit_poll;
+	ot->exec = bskin_root_mark_exec;
+
+	/* flags */
+	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+}
+
+static void bskin_armature_bone_create(Object *skin_ob,
+	MVert *mvert, MEdge *medge,
+	bArmature *arm,
+	BLI_bitmap *edges_visited,
+	const MeshElemMap *emap,
+	EditBone *parent_bone,
+	int parent_v)
+{
+	int i;
+
+	for (i = 0; i < emap[parent_v].count; i++) {
+		int endx = emap[parent_v].indices[i];
+		const MEdge *e = &medge[endx];
+		EditBone *bone;
+		bDeformGroup *dg;
+		int v;
+
+		/* ignore edge if already visited */
+		if (BLI_BITMAP_TEST(edges_visited, endx))
+			continue;
+		BLI_BITMAP_ENABLE(edges_visited, endx);
+
+		v = (e->v1 == parent_v ? e->v2 : e->v1);
+
+		bone = ED_armature_edit_bone_add(arm, "Bone");
+
+		bone->parent = parent_bone;
+		bone->flag |= BONE_CONNECTED;
+
+		copy_v3_v3(bone->head, mvert[parent_v].co);
+		copy_v3_v3(bone->tail, mvert[v].co);
+		bone->rad_head = bone->rad_tail = 0.25;
+		BLI_snprintf(bone->name, sizeof(bone->name), "Bone.%.2d", endx);
+
+		/* add bDeformGroup */
+		if ((dg = BKE_object_defgroup_add_name(skin_ob, bone->name))) {
+			ED_vgroup_vert_add(skin_ob, dg, parent_v, 1, WEIGHT_REPLACE);
+			ED_vgroup_vert_add(skin_ob, dg, v, 1, WEIGHT_REPLACE);
+		}
+
+		bskin_armature_bone_create(skin_ob,
+			mvert, medge,
+			arm,
+			edges_visited,
+			emap,
+			bone,
+			v);
+	}
+}
+
+static Object *modifier_bskin_armature_create(Main *bmain, Scene *scene, Object *skin_ob)
+{
+	BLI_bitmap *edges_visited;
+	DerivedMesh *deform_dm;
+	MVert *mvert;
+	Mesh *me = skin_ob->data;
+	Object *arm_ob;
+	bArmature *arm;
+	MVertSkin *mvert_skin;
+	MeshElemMap *emap;
+	int *emap_mem;
+	int v;
+
+	deform_dm = mesh_get_derived_deform(scene, skin_ob, CD_MASK_BAREMESH);
+	mvert = deform_dm->getVertArray(deform_dm);
+
+	/* add vertex weights to original mesh */
+	CustomData_add_layer(&me->vdata,
+		CD_MDEFORMVERT,
+		CD_CALLOC,
+		NULL,
+		me->totvert);
+
+	arm_ob = BKE_object_add(bmain, scene, OB_ARMATURE, NULL);
+	BKE_object_transform_copy(arm_ob, skin_ob);
+	arm = arm_ob->data;
+	arm->layer = 1;
+	arm_ob->dtx |= OB_DRAWXRAY;
+	arm->drawtype = ARM_LINE;
+	arm->edbo = MEM_callocN(sizeof(ListBase), "edbo armature");
+
+	mvert_skin = CustomData_get_layer(&me->vdata, CD_MVERT_SKIN);
+	BKE_mesh_vert_edge_map_create(&emap, &emap_mem,
+		me->medge, me->totvert, me->totedge);
+
+	edges_visited = BLI_BITMAP_NEW(me->totedge, "edge_visited");
+
+	/* note: we use EditBones here, easier to set them up and use
+	* edit-armature functions to convert back to regular bones */
+	for (v = 0; v < me->totvert; v++) {
+		if (mvert_skin[v].flag & MVERT_SKIN_ROOT) {
+			EditBone *bone = NULL;
+
+			/* Unless the skin root has just one adjacent edge, create
+			* a fake root bone (have it going off in the Y direction
+			* (arbitrary) */
+			if (emap[v].count > 1) {
+				bone = ED_armature_edit_bone_add(arm, "Bone");
+
+				copy_v3_v3(bone->head, me->mvert[v].co);
+				copy_v3_v3(bone->tail, me->mvert[v].co);
+
+				bone->head[1] = 1.0f;
+				bone->rad_head = bone->rad_tail = 0.25;
+			}
+
+			if (emap[v].count >= 1) {
+				bskin_armature_bone_create(skin_ob,
+					mvert, me->medge,
+					arm,
+					edges_visited,
+					emap,
+					bone,
+					v);
+			}
+		}
+	}
+
+	MEM_freeN(edges_visited);
+	MEM_freeN(emap);
+	MEM_freeN(emap_mem);
+
+	ED_armature_from_edit(arm);
+	ED_armature_edit_free(arm);
+
+	return arm_ob;
+}
+
+static int bskin_armature_create_exec(bContext *C, wmOperator *op)
+{
+	Main *bmain = CTX_data_main(C);
+	Scene *scene = CTX_data_scene(C);
+	Object *ob = CTX_data_active_object(C), *arm_ob;
+	Mesh *me = ob->data;
+	ModifierData *skin_md;
+	ArmatureModifierData *arm_md;
+
+	if (!CustomData_has_layer(&me->vdata, CD_MVERT_SKIN)) {
+		BKE_reportf(op->reports, RPT_WARNING, "Mesh '%s' has no skin vertex data", me->id.name + 2);
+		return OPERATOR_CANCELLED;
+	}
+
+	/* create new armature */
+	arm_ob = modifier_bskin_armature_create(bmain, scene, ob);
+
+	/* add a modifier to connect the new armature to the mesh */
+	arm_md = (ArmatureModifierData *)modifier_new(eModifierType_Armature);
+	if (arm_md) {
+		skin_md = edit_modifier_property_get(op, ob, eModifierType_Skin);
+		BLI_insertlinkafter(&ob->modifiers, skin_md, arm_md);
+
+		arm_md->object = arm_ob;
+		arm_md->deformflag = ARM_DEF_VGROUP | ARM_DEF_QUATERNION;
+		DAG_relations_tag_update(bmain);
+		DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
+	}
+
+	WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
+
+	return OPERATOR_FINISHED;
+}
+
+static int bskin_armature_create_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
+{
+	if (edit_modifier_invoke_properties(C, op))
+		return bskin_armature_create_exec(C, op);
+	else
+		return OPERATOR_CANCELLED;
+}
+
+void OBJECT_OT_bskin_armature_create(wmOperatorType *ot)
+{
+	ot->name = "BSkin Armature Create";
+	ot->description = "Create an armature that parallels the skin layout";
+	ot->idname = "OBJECT_OT_bskin_armature_create";
+
+	ot->poll = bskin_poll;
+	ot->invoke = bskin_armature_create_invoke;
+	ot->exec = bskin_armature_create_exec;
+
+	/* flags */
+	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
+	edit_modifier_properties(ot);
+}
+
+static int bskin_radii_equalize_exec(bContext *C, wmOperator *UNUSED(op))
+{
+	Object *ob = CTX_data_edit_object(C);
+	BMEditMesh *em = BKE_editmesh_from_object(ob);
+	BMesh *bm = em->bm;
+	BMVert *bm_vert;
+	BMIter bm_iter;
+
+	if (!CustomData_has_layer(&bm->vdata, CD_MVERT_SKIN)) {
+		return OPERATOR_CANCELLED;
+	}
+
+	BM_ITER_MESH(bm_vert, &bm_iter, bm, BM_VERTS_OF_MESH) {
+		if (BM_elem_flag_test(bm_vert, BM_ELEM_SELECT)) {
+			MVertSkin *vs = CustomData_bmesh_get(&bm->vdata,
+				bm_vert->head.data,
+				CD_MVERT_SKIN);
+			float avg = (vs->radius[0] + vs->radius[1]) * 0.5f;
+
+			vs->radius[0] = vs->radius[1] = avg;
+		}
+	}
+
+	DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
+	WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
+
+	return OPERATOR_FINISHED;
+}
+
+void OBJECT_OT_bskin_radii_equalize(wmOperatorType *ot)
+{
+	ot->name = "BSkin Radii Equalize";
+	ot->description = "Make skin radii of selected vertices equal on each axis";
+	ot->idname = "OBJECT_OT_bskin_radii_equalize";
+
+	ot->poll = bskin_edit_poll;
+	ot->exec = bskin_radii_equalize_exec;
+
+	/* flags */
+	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+}
+
+typedef enum {
+	BSKIN_HOLE_MARK,
+	BSKIN_HOLE_CLEAR,
+	BSKIN_FLAT_MARK,
+	BSKIN_FLAT_CLEAR,
+} BSkinLooseAction;
+
+static int bskin_hole_mark_clear_exec(bContext *C, wmOperator *op)
+{
+	Object *ob = CTX_data_edit_object(C);
+	BMEditMesh *em = BKE_editmesh_from_object(ob);
+	BMesh *bm = em->bm;
+	BMVert *bm_vert;
+	BMIter bm_iter;
+	BSkinLooseAction action = RNA_enum_get(op->ptr, "action");
+
+	if (!CustomData_has_layer(&bm->vdata, CD_MVERT_SKIN)) {
+		return OPERATOR_CANCELLED;
+	}
+
+	BM_ITER_MESH(bm_vert, &bm_iter, bm, BM_VERTS_OF_MESH) {
+		if (BM_elem_flag_test(bm_vert, BM_ELEM_SELECT)) {
+			MVertSkin *vs = CustomData_bmesh_get(&bm->vdata,
+				bm_vert->head.data,
+				CD_MVERT_SKIN);
+
+			switch (action) {
+			case BSKIN_HOLE_MARK:
+				vs->flag |= MVERT_SKIN_HOLE;
+				break;
+			case BSKIN_HOLE_CLEAR:
+				vs->flag &= ~MVERT_SKIN_HOLE;
+				break;
+			case BSKIN_FLAT_MARK:
+				vs->flag |= MVERT_SKIN_FLAT;
+				break;
+			case BSKIN_FLAT_CLEAR:
+				vs->flag &= ~MVERT_SKIN_FLAT;
+				break;
+			}
+		}
+	}
+
+	DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
+	WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
+
+	return OPERATOR_FINISHED;
+}
+
+void OBJECT_OT_bskin_flat_hole_mark_clear(wmOperatorType *ot)
+{
+	static EnumPropertyItem action_items[] = {
+		{ BSKIN_HOLE_MARK, "HOLE_MARK", 0, "Mark Hole", "Mark selected vertices as hole" },
+		{ BSKIN_HOLE_CLEAR, "HOLE_CLEAR", 0, "Clear Hole", "Set selected vertices as not hole" },
+		{ BSKIN_FLAT_MARK, "FLAT_MARK", 0, "Mark Flat", "Mark selected vertices as flat ending caption" },
+		{ BSKIN_FLAT_CLEAR, "FLAT_CLEAR", 0, "Clear Flat", "Set selected vertices as flat ending caption" },
+		{ 0, NULL, 0, NULL, NULL }
+	};
+
+	ot->name = "BSkin Mark/Clear Hole";
+	ot->description = "Mark/clear selected vertices as hole";
+	ot->idname = "OBJECT_OT_bskin_hole_mark_clear";
+
+	ot->poll = bskin_edit_poll;
+	ot->exec = bskin_hole_mark_clear_exec;
+
+	/* flags */
+	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+
+	RNA_def_enum(ot->srna, "action", action_items, BSKIN_HOLE_MARK, "Action", NULL);
+}
 
 /************************** skin modifier ***********************/
 

source/blender/editors/object/object_ops.c

@@ -143,6 +143,11 @@ void ED_operatortypes_object(void)
 	WM_operatortype_append(OBJECT_OT_skin_loose_mark_clear);
 	WM_operatortype_append(OBJECT_OT_skin_radii_equalize);
 	WM_operatortype_append(OBJECT_OT_skin_armature_create);
+	WM_operatortype_append(OBJECT_OT_bskin_root_mark);
+	WM_operatortype_append(OBJECT_OT_bskin_armature_create);
+	WM_operatortype_append(OBJECT_OT_bskin_radii_equalize);
+	WM_operatortype_append(OBJECT_OT_bskin_flat_hole_mark_clear);
+
 
 	WM_operatortype_append(OBJECT_OT_correctivesmooth_bind);
 	WM_operatortype_append(OBJECT_OT_meshdeform_bind);

source/blender/editors/space_outliner/outliner_draw.c

@@ -1161,6 +1161,8 @@ static void tselem_draw_icon(uiBlock *block, int xmax, float x, float y, TreeSto
 						UI_icon_draw(x, y, ICON_MOD_WARP); break;
 					case eModifierType_Skin:
 						UI_icon_draw(x, y, ICON_MOD_SKIN); break;
+					case eModifierType_BSkin:
+						UI_icon_draw(x, y, ICON_MOD_SKIN); break;
 					case eModifierType_Triangulate:
 						UI_icon_draw(x, y, ICON_MOD_TRIANGULATE); break;
 					case eModifierType_MeshCache:

source/blender/makesdna/DNA_meshdata_types.h

@@ -366,6 +366,13 @@ typedef enum MVertSkinFlag {
 	 * directly hulled together, rather than the default of generating intermediate frames.
 	 */
 	MVERT_SKIN_LOOSE = 2,
+
+	/*Mark a leaf vertex as a hole on its parent vertex*/
+	MVERT_SKIN_HOLE = 4,
+
+	/*Mark a leaf vertex as an ending flat plane*/
+	MVERT_SKIN_FLAT = 8,
+
 } MVertSkinFlag;
 
 typedef struct MVertSkin {

source/blender/makesdna/DNA_modifier_types.h

@@ -85,6 +85,7 @@ typedef enum ModifierType {
 	eModifierType_DataTransfer      = 49,
 	eModifierType_NormalEdit        = 50,
 	eModifierType_CorrectiveSmooth  = 51,
+	eModifierType_BSkin             = 52,
 	NUM_MODIFIER_TYPES
 } ModifierType;
 
@@ -1242,6 +1243,15 @@ enum {
 	MOD_SKIN_SMOOTH_SHADING = 1,
 };
 
+/* Skin modifier */
+typedef struct BSkinModifierData {
+	ModifierData modifier;
+
+	short subdivision_level;
+
+	char pad[6];
+} BSkinModifierData;
+
 /* Triangulate modifier */
 typedef struct TriangulateModifierData {
 	ModifierData modifier;

source/blender/makesrna/RNA_access.h

@@ -93,6 +93,7 @@ extern StructRNA RNA_BooleanModifier;
 extern StructRNA RNA_BoolProperty;
 extern StructRNA RNA_Brush;
 extern StructRNA RNA_BrushTextureSlot;
+extern StructRNA RNA_BSkinModifier;
 extern StructRNA RNA_BuildModifier;
 extern StructRNA RNA_MeshCacheModifier;
 extern StructRNA RNA_Camera;

source/blender/makesrna/intern/rna_modifier.c

@@ -85,6 +85,7 @@ EnumPropertyItem modifier_type_items[] = {
 	{eModifierType_Remesh, "REMESH", ICON_MOD_REMESH, "Remesh", ""},
 	{eModifierType_Screw, "SCREW", ICON_MOD_SCREW, "Screw", ""},
 	{eModifierType_Skin, "SKIN", ICON_MOD_SKIN, "Skin", ""},
+	{eModifierType_BSkin, "BSKIN", ICON_MOD_SKIN, "BSkin", "" },
 	{eModifierType_Solidify, "SOLIDIFY", ICON_MOD_SOLIDIFY, "Solidify", ""},
 	{eModifierType_Subsurf, "SUBSURF", ICON_MOD_SUBSURF, "Subdivision Surface", ""},
 	{eModifierType_Triangulate, "TRIANGULATE", ICON_MOD_TRIANGULATE, "Triangulate", ""},
@@ -362,6 +363,8 @@ static StructRNA *rna_Modifier_refine(struct PointerRNA *ptr)
 			return &RNA_RemeshModifier;
 		case eModifierType_Skin:
 			return &RNA_SkinModifier;
+		case eModifierType_BSkin:
+			return &RNA_BSkinModifier;
 		case eModifierType_LaplacianSmooth:
 			return &RNA_LaplacianSmoothModifier;
 		case eModifierType_Triangulate:
@@ -3930,6 +3933,23 @@ static void rna_def_modifier_ocean(BlenderRNA *brna)
 	/*RNA_def_property_update(prop, 0, "rna_Modifier_update"); */
 	/* XXX how to update? */
 }
+static void rna_def_modifier_bskin(BlenderRNA *brna)
+{
+	StructRNA *srna;
+	PropertyRNA *prop;
+
+	srna = RNA_def_struct(brna, "BSkinModifier", "Modifier");
+	RNA_def_struct_ui_text(srna, "BSkin Modifier", "Generate Skin");
+	RNA_def_struct_sdna(srna, "BSkinModifierData");
+	RNA_def_struct_ui_icon(srna, ICON_MOD_SKIN);
+
+	prop = RNA_def_property(srna, "subdivision_level", PROP_INT, PROP_UNSIGNED);
+	RNA_def_property_int_sdna(prop, NULL, "subdivision_level");
+	RNA_def_property_ui_text(prop, "Subdivision Level", "");
+	RNA_def_property_ui_range(prop, 0, 1, 1, -1);
+	RNA_def_property_range(prop, 0, 1);
+	RNA_def_property_update(prop, 0, "rna_Modifier_update");
+}
 
 static void rna_def_modifier_skin(BlenderRNA *brna)
 {
@@ -4682,6 +4702,7 @@ void RNA_def_modifier(BlenderRNA *brna)
 	rna_def_modifier_ocean(brna);
 	rna_def_modifier_remesh(brna);
 	rna_def_modifier_skin(brna);
+	rna_def_modifier_bskin(brna);
 	rna_def_modifier_laplaciansmooth(brna);
 	rna_def_modifier_triangulate(brna);
 	rna_def_modifier_meshcache(brna);

source/blender/modifiers/CMakeLists.txt

@@ -49,6 +49,7 @@ set(SRC
 	intern/MOD_bevel.c
 	intern/MOD_boolean.c
 	intern/MOD_build.c
+	intern/MOD_bskin.c
 	intern/MOD_cast.c
 	intern/MOD_cloth.c
 	intern/MOD_collision.c

source/blender/modifiers/MOD_modifiertypes.h

@@ -75,6 +75,7 @@ extern ModifierTypeInfo modifierType_WeightVGProximity;
 extern ModifierTypeInfo modifierType_DynamicPaint;
 extern ModifierTypeInfo modifierType_Remesh;
 extern ModifierTypeInfo modifierType_Skin;
+extern ModifierTypeInfo modifierType_BSkin;
 extern ModifierTypeInfo modifierType_LaplacianSmooth;
 extern ModifierTypeInfo modifierType_Triangulate;
 extern ModifierTypeInfo modifierType_UVWarp;

source/blender/modifiers/intern/MOD_util.c

@@ -298,6 +298,7 @@ void modifier_type_init(ModifierTypeInfo *types[])
 	INIT_TYPE(DynamicPaint);
 	INIT_TYPE(Remesh);
 	INIT_TYPE(Skin);
+	INIT_TYPE(BSkin);
 	INIT_TYPE(LaplacianSmooth);
 	INIT_TYPE(Triangulate);
 	INIT_TYPE(UVWarp);