예제 #1
0
static PyObject *bpy_bmlayercollection_items(BPy_BMLayerCollection *self)
{
	PyObject *ret;
	PyObject *item;
	int index;
	CustomData *data;
	int tot, i;

	BPY_BM_CHECK_OBJ(self);

	data = bpy_bm_customdata_get(self->bm, self->htype);
	index = CustomData_get_layer_index(data, self->type);
	tot = (index != -1) ? CustomData_number_of_layers(data, self->type) : 0;

	ret = PyList_New(tot);

	for (i = 0; tot-- > 0; index++) {
		item = PyTuple_New(2);
		PyTuple_SET_ITEMS(item,
		        PyUnicode_FromString(data->layers[index].name),
		        BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, i));
		PyList_SET_ITEM(ret, i++, item);
	}

	return ret;
}
예제 #2
0
static PyObject *bpy_bmlayercollection_new(BPy_BMLayerCollection *self, PyObject *args)
{
	const char *name = NULL;
	int index;
	CustomData *data;

	BPY_BM_CHECK_OBJ(self);

	if (!PyArg_ParseTuple(args, "|s:new", &name)) {
		return NULL;
	}

	data = bpy_bm_customdata_get(self->bm, self->htype);

	if (CustomData_layertype_is_singleton(self->type) &&
	    CustomData_has_layer(data, self->type))
	{
		PyErr_SetString(PyExc_ValueError,
		                "layers.new(): is a singleton, use verify() instead");
		return NULL;
	}

	if (name) {
		BM_data_layer_add_named(self->bm, data, self->type, name);
	}
	else {
		BM_data_layer_add(self->bm, data, self->type);
	}

	index = CustomData_number_of_layers(data, self->type) - 1;
	BLI_assert(index >= 0);

	return BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, index);
}
예제 #3
0
static PyObject *bpy_bmlayercollection_remove(BPy_BMLayerCollection *self, BPy_BMLayerItem *value)
{
	CustomData *data;

	BPY_BM_CHECK_OBJ(self);

	if (!BPy_BMLayerItem_Check(value)) {
		PyErr_Format(PyExc_TypeError,
		             "layers.remove(x): expected BMLayerItem, not '%.200s'",
		             Py_TYPE(value)->tp_name);
		return NULL;
	}

	BPY_BM_CHECK_OBJ(value);

	if ((self->bm != value->bm) ||
	    (self->type != value->type) ||
	    (self->htype != value->htype))
	{
		PyErr_SetString(PyExc_ValueError,
		                "layers.remove(x): x not in layers");
	}

	data = bpy_bm_customdata_get(self->bm, self->htype);
	BM_data_layer_free_n(self->bm, data, self->type, value->index);

	Py_RETURN_NONE;
}
static PyObject *bpy_bmlayercollection_get(BPy_BMLayerCollection *self, PyObject *args)
{
	const char *key;
	PyObject *def = Py_None;

	BPY_BM_CHECK_OBJ(self);

	if (!PyArg_ParseTuple(args, "s|O:get", &key, &def)) {
		return NULL;
	}
	else {
		CustomData *data;
		int index;

		data = bpy_bm_customdata_get(self->bm, self->htype);
		index = CustomData_get_named_layer_index(data, self->type, key); /* absolute index */

		if (index != -1) {
			index -= CustomData_get_layer_index(data, self->type); /* make relative */
			return BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, index);
		}
	}

	return Py_INCREF(def), def;
}
static PyObject *bpy_bmlayercollection_items(BPy_BMLayerCollection *self)
{
	PyObject *ret;
	PyObject *item;
	int index;
	CustomData *data;

	BPY_BM_CHECK_OBJ(self);

	data = bpy_bm_customdata_get(self->bm, self->htype);
	index = CustomData_get_layer_index(data, self->type);

	ret = PyList_New(0);

	if (index != -1) {
		int tot = CustomData_number_of_layers(data, self->type);
		for ( ; tot-- > 0; index++) {
			item = BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, index);
			PyList_Append(ret, item);
			Py_DECREF(item);
		}
	}

	return ret;
}
static PyObject *bpy_bmlayercollection_values(BPy_BMLayerCollection *self)
{
	PyObject *ret;
	PyObject *item;
	int index;
	CustomData *data;

	BPY_BM_CHECK_OBJ(self);

	data = bpy_bm_customdata_get(self->bm, self->htype);
	index = CustomData_get_layer_index(data, self->type);

	ret = PyList_New(0);

	if (index != -1) {
		int tot = CustomData_number_of_layers(data, self->type);
		for ( ; tot-- > 0; index++) {
			item = PyTuple_New(2);
			PyTuple_SET_ITEM(item, 0, PyUnicode_FromString(data->layers[index].name));
			PyTuple_SET_ITEM(item, 1, BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, index));
			PyList_Append(ret, item);
			Py_DECREF(item);
		}
	}

	return ret;
}
static PyObject *bpy_bmlayercollection_keys(BPy_BMLayerCollection *self)
{
	PyObject *ret;
	PyObject *item;
	int index;
	CustomData *data;

	BPY_BM_CHECK_OBJ(self);

	data = bpy_bm_customdata_get(self->bm, self->htype);
	index = CustomData_get_layer_index(data, self->type); /* absolute, but no need to make relative */

	ret = PyList_New(0);

	if (index != -1) {
		int tot = CustomData_number_of_layers(data, self->type);
		for ( ; tot-- > 0; index++) {
			item = PyUnicode_FromString(data->layers[index].name);
			PyList_Append(ret, item);
			Py_DECREF(item);
		}
	}

	return ret;
}
예제 #8
0
static Py_ssize_t bpy_bmlayercollection_length(BPy_BMLayerCollection *self)
{
	CustomData *data;

	BPY_BM_CHECK_INT(self);

	data = bpy_bm_customdata_get(self->bm, self->htype);

	return CustomData_number_of_layers(data, self->type);
}
예제 #9
0
static CustomDataLayer *bpy_bmlayeritem_get(BPy_BMLayerItem *self)
{
	CustomData *data = bpy_bm_customdata_get(self->bm, self->htype);
	const int index_absolute = CustomData_get_layer_index_n(data, self->type, self->index);
	if (index_absolute != -1) {
		return &data->layers[index_absolute];
	}
	else {
		PyErr_SetString(PyExc_RuntimeError,
		                "layer has become invalid");
		return NULL;
	}
}
예제 #10
0
static PyObject *bpy_bmlayercollection_active_get(BPy_BMLayerItem *self, void *UNUSED(flag))
{
	CustomData *data;
	int index;

	BPY_BM_CHECK_OBJ(self);

	data = bpy_bm_customdata_get(self->bm, self->htype);
	index = CustomData_get_active_layer(data, self->type);  /* type relative */

	if (index != -1) {
		return BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, index);
	}
	else {
		Py_RETURN_NONE;
	}
}
예제 #11
0
static int bpy_bmlayercollection_contains(BPy_BMLayerCollection *self, PyObject *value)
{
	const char *keyname = _PyUnicode_AsString(value);
	CustomData *data;
	int index;

	BPY_BM_CHECK_INT(self);

	if (keyname == NULL) {
		PyErr_SetString(PyExc_TypeError,
		                "BMLayerCollection.__contains__: expected a string");
		return -1;
	}

	data = bpy_bm_customdata_get(self->bm, self->htype);
	index = CustomData_get_named_layer_index(data, self->type, keyname);

	return (index != -1) ? 1 : 0;
}
예제 #12
0
static PyObject *bpy_bmlayercollection_subscript_str(BPy_BMLayerCollection *self, const char *keyname)
{
	CustomData *data;
	int index;

	BPY_BM_CHECK_OBJ(self);

	data = bpy_bm_customdata_get(self->bm, self->htype);
	index = CustomData_get_named_layer(data, self->type, keyname);  /* type relative */

	if (index != -1) {
		return BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, index);
	}
	else {
		PyErr_Format(PyExc_KeyError,
		             "BMLayerCollection[key]: key \"%.200s\" not found", keyname);
		return NULL;
	}
}
예제 #13
0
static PyObject *bpy_bmlayercollection_verify(BPy_BMLayerCollection *self)
{
	int index;
	CustomData *data;

	BPY_BM_CHECK_OBJ(self);

	data = bpy_bm_customdata_get(self->bm, self->htype);

	index = CustomData_get_active_layer(data, self->type);  /* type relative */

	if (index == -1) {
		BM_data_layer_add(self->bm, data, self->type);
		index = 0;
	}

	BLI_assert(index >= 0);

	return BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, index);
}
예제 #14
0
/**
 * helper function for get/set, NULL return means the error is set
 */
static void *bpy_bmlayeritem_ptr_get(BPy_BMElem *py_ele, BPy_BMLayerItem *py_layer)
{
	void *value;
	BMElem *ele = py_ele->ele;
	CustomData *data;

	/* error checking */
	if (UNLIKELY(!BPy_BMLayerItem_Check(py_layer))) {
		PyErr_SetString(PyExc_AttributeError,
		                "BMElem[key]: invalid key, must be a BMLayerItem");
		return NULL;
	}
	else if (UNLIKELY(py_ele->bm != py_layer->bm)) {
		PyErr_SetString(PyExc_ValueError,
		                "BMElem[layer]: layer is from another mesh");
		return NULL;
	}
	else if (UNLIKELY(ele->head.htype != py_layer->htype)) {
		char namestr_1[32], namestr_2[32];
		PyErr_Format(PyExc_ValueError,
		             "Layer/Element type mismatch, expected %.200s got layer type %.200s",
		             BPy_BMElem_StringFromHType_ex(ele->head.htype, namestr_1),
		             BPy_BMElem_StringFromHType_ex(py_layer->htype, namestr_2));
		return NULL;
	}

	data = bpy_bm_customdata_get(py_layer->bm, py_layer->htype);

	value = CustomData_bmesh_get_n(data, ele->head.data, py_layer->type, py_layer->index);

	if (UNLIKELY(value == NULL)) {
		/* this should be fairly unlikely but possible if layers move about after we get them */
		PyErr_SetString(PyExc_KeyError,
		                "BMElem[key]: layer not found");
		return NULL;
	}
	else {
		return value;
	}
}
예제 #15
0
static PyObject *bpy_bmlayercollection_values(BPy_BMLayerCollection *self)
{
	PyObject *ret;
	PyObject *item;
	int index;
	CustomData *data;
	int tot, i;

	BPY_BM_CHECK_OBJ(self);

	data = bpy_bm_customdata_get(self->bm, self->htype);
	index = CustomData_get_layer_index(data, self->type);
	tot = (index != -1) ? CustomData_number_of_layers(data, self->type) : 0;

	ret = PyList_New(tot);

	for (i = 0; tot-- > 0; index++) {
		item = BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, i);
		PyList_SET_ITEM(ret, i++, item);
	}

	return ret;
}
예제 #16
0
static PyObject *bpy_bmlayeritem_copy_from(BPy_BMLayerItem *self, BPy_BMLayerItem *value)
{
	CustomData *data;

	if (!BPy_BMLayerItem_Check(value)) {
		PyErr_Format(PyExc_TypeError,
		             "layer.copy_from(x): expected BMLayerItem, not '%.200s'",
		             Py_TYPE(value)->tp_name);
		return NULL;
	}

	BPY_BM_CHECK_OBJ(self);
	BPY_BM_CHECK_SOURCE_OBJ(self->bm, "layer.copy_from()", value);

	if ((self->htype != value->htype) ||
	    (self->type  != value->type))
	{
		PyErr_SetString(PyExc_ValueError,
		                "layer.copy_from(other): layer type mismatch");
	}

	else if (self->index == value->index) {
		Py_RETURN_NONE;
	}

	data = bpy_bm_customdata_get(self->bm, self->htype);

	if ((bpy_bmlayeritem_get(self) == NULL) ||
	    (bpy_bmlayeritem_get(value) == NULL))
	{
		return NULL;
	}

	BM_data_layer_copy(self->bm, data, self->type, value->index, self->index);

	Py_RETURN_NONE;
}