Tamito Kajiyama
f84e8e7640
New "face marks" and "edge marks" have been introduced in mesh data blocks. In the edit mode of a mesh object, face marks can be put to selected faces by choosing Mesh >> Faces >> Mark Freestyle Face from the menu of a 3D View window or Ctrl-F >> Mark Freestyle Face from the context menu. Similarly, edge marks can be put to selected edges by Mesh >> Edges >> Mark Freestyle Edge or Ctrl-E >> Mark Freestyle Edge. These marks should work fine with the Subdivision surface modifier. Moreover, two new conditions for feature edge selection have been added to the Parameter Editor mode as described below: 1. The Selection by Edge Types option has now the new Edge Mark type, which can be used to (de)select feature edges having edge marks. This option can be used to add to (or remove from) the view map arbitrary edges of mesh objects. 2. Selection by Face Marks option has been newly introduced, in which face marks are used for feature edge selection in two ways. One option is called "One Face" which is to (de)select feature edges if one of faces on the left and right of each feature edge has a face mark. The other option is "Both Faces" to (de)select feature edges if both faces on the left and right have a face mark.
241 lines
7.8 KiB
C++
241 lines
7.8 KiB
C++
#include "BPy_FEdgeSmooth.h"
|
|
|
|
#include "../../BPy_Convert.h"
|
|
#include "../../Interface0D/BPy_SVertex.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//------------------------INSTANCE METHODS ----------------------------------
|
|
|
|
static char FEdgeSmooth___doc__[] =
|
|
"Class hierarchy: :class:`Interface1D` > :class:`FEdge` > :class:`FEdgeSmooth`\n"
|
|
"\n"
|
|
"Class defining a smooth edge. This kind of edge typically runs across\n"
|
|
"a face of the input mesh. It can be a silhouette, a ridge or valley,\n"
|
|
"a suggestive contour.\n"
|
|
"\n"
|
|
".. method:: __init__()\n"
|
|
"\n"
|
|
" Default constructor.\n"
|
|
"\n"
|
|
".. method:: __init__(iBrother)\n"
|
|
"\n"
|
|
" Copy constructor.\n"
|
|
"\n"
|
|
" :arg iBrother: An FEdgeSmooth object.\n"
|
|
" :type iBrother: :class:`FEdgeSmooth`\n"
|
|
"\n"
|
|
".. method:: __init__(vA, vB)\n"
|
|
"\n"
|
|
" Builds an FEdgeSmooth going from vA to vB.\n"
|
|
"\n"
|
|
" :arg vA: The first SVertex object.\n"
|
|
" :type vA: :class:`SVertex`\n"
|
|
" :arg vB: The second SVertex object.\n"
|
|
" :type vB: :class:`SVertex`\n";
|
|
|
|
static int FEdgeSmooth___init__(BPy_FEdgeSmooth *self, PyObject *args, PyObject *kwds)
|
|
{
|
|
PyObject *obj1 = 0, *obj2 = 0;
|
|
|
|
if (! PyArg_ParseTuple(args, "|OO", &obj1, &obj2) )
|
|
return -1;
|
|
|
|
if( !obj1 ){
|
|
self->fes = new FEdgeSmooth();
|
|
|
|
} else if( !obj2 && BPy_FEdgeSmooth_Check(obj1) ) {
|
|
self->fes = new FEdgeSmooth(*( ((BPy_FEdgeSmooth *) obj1)->fes ));
|
|
|
|
} else if( obj2 && BPy_SVertex_Check(obj1) && BPy_SVertex_Check(obj2) ) {
|
|
self->fes = new FEdgeSmooth( ((BPy_SVertex *) obj1)->sv, ((BPy_SVertex *) obj2)->sv );
|
|
|
|
} else {
|
|
PyErr_SetString(PyExc_TypeError, "invalid argument(s)");
|
|
return -1;
|
|
}
|
|
|
|
self->py_fe.fe = self->fes;
|
|
self->py_fe.py_if1D.if1D = self->fes;
|
|
self->py_fe.py_if1D.borrowed = 0;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static char FEdgeSmooth_normal___doc__[] =
|
|
".. method:: normal()\n"
|
|
"\n"
|
|
" Returns the normal to the Face it is running accross.\n"
|
|
"\n"
|
|
" :return: The normal to the Face it is running accross.\n"
|
|
" :rtype: :class:`mathutils.Vector`\n";
|
|
|
|
static PyObject * FEdgeSmooth_normal( BPy_FEdgeSmooth *self ) {
|
|
Vec3r v( self->fes->normal() );
|
|
return Vector_from_Vec3r( v );
|
|
}
|
|
|
|
static char FEdgeSmooth_materialIndex___doc__[] =
|
|
".. method:: materialIndex()\n"
|
|
"\n"
|
|
" Returns the index of the material of the face it is running accross.\n"
|
|
"\n"
|
|
" :return: The index of the material of the face it is running accross.\n"
|
|
" :rtype: int\n";
|
|
|
|
static PyObject * FEdgeSmooth_materialIndex( BPy_FEdgeSmooth *self ) {
|
|
return PyLong_FromLong( self->fes->frs_materialIndex() );
|
|
}
|
|
|
|
static char FEdgeSmooth_material___doc__[] =
|
|
".. method:: material()\n"
|
|
"\n"
|
|
" Returns the material of the face it is running accross.\n"
|
|
"\n"
|
|
" :return: The material of the face it is running accross.\n"
|
|
" :rtype: :class:`Material`\n";
|
|
|
|
static PyObject * FEdgeSmooth_material( BPy_FEdgeSmooth *self ) {
|
|
FrsMaterial m( self->fes->frs_material() );
|
|
return BPy_FrsMaterial_from_FrsMaterial(m);
|
|
}
|
|
|
|
static char FEdgeSmooth_faceMark___doc__[] =
|
|
".. method:: faceMark()\n"
|
|
"\n"
|
|
" Returns the face mark of the face it is running across.\n"
|
|
"\n"
|
|
" :return: The face mark of the face it is running across.\n"
|
|
" :rtype: bool\n";
|
|
|
|
static PyObject * FEdgeSmooth_faceMark( BPy_FEdgeSmooth *self ) {
|
|
return PyBool_from_bool( self->fes->faceMark() );
|
|
}
|
|
|
|
static char FEdgeSmooth_setNormal___doc__[] =
|
|
".. method:: setNormal(iNormal)\n"
|
|
"\n"
|
|
" Sets the normal to the Face it is running accross.\n"
|
|
"\n"
|
|
" :arg iNormal: A three-dimensional vector.\n"
|
|
" :type iNormal: :class:`mathutils.Vector`, list or tuple of 3 real numbers\n";
|
|
|
|
static PyObject * FEdgeSmooth_setNormal( BPy_FEdgeSmooth *self, PyObject *args ) {
|
|
PyObject *obj = 0;
|
|
|
|
if(!( PyArg_ParseTuple(args, "O", &obj) ))
|
|
return NULL;
|
|
Vec3r *v = Vec3r_ptr_from_PyObject(obj);
|
|
if( !v ) {
|
|
PyErr_SetString(PyExc_TypeError, "argument 1 must be a 3D vector (either a list of 3 elements or Vector)");
|
|
return NULL;
|
|
}
|
|
self->fes->setNormal( *v );
|
|
delete v;
|
|
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static char FEdgeSmooth_setMaterialIndex___doc__[] =
|
|
".. method:: setMaterialIndex(i)\n"
|
|
"\n"
|
|
" Sets the index of the material of the face it is running accross.\n"
|
|
"\n"
|
|
" :arg i: The index of the material of the face it is running accross.\n"
|
|
" :type i: int\n";
|
|
|
|
static PyObject * FEdgeSmooth_setMaterialIndex( BPy_FEdgeSmooth *self, PyObject *args ) {
|
|
unsigned int i;
|
|
|
|
if(!( PyArg_ParseTuple(args, "I", &i) ))
|
|
return NULL;
|
|
|
|
self->fes->setFrsMaterialIndex( i );
|
|
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static char FEdgeSmooth_setFaceMark___doc__[] =
|
|
".. method:: setFaceMark(i)\n"
|
|
"\n"
|
|
" Sets the face mark of the face it is running across.\n"
|
|
"\n"
|
|
" :arg i: A face mark.\n"
|
|
" :type i: bool\n";
|
|
|
|
static PyObject * FEdgeSmooth_setFaceMark( BPy_FEdgeSmooth *self, PyObject *args ) {
|
|
PyObject *obj;
|
|
|
|
if(!( PyArg_ParseTuple(args, "O", &obj) ))
|
|
return NULL;
|
|
|
|
self->fes->setFaceMark( bool_from_PyBool(obj) );
|
|
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
/*----------------------FEdgeSmooth instance definitions ----------------------------*/
|
|
static PyMethodDef BPy_FEdgeSmooth_methods[] = {
|
|
{"normal", ( PyCFunction ) FEdgeSmooth_normal, METH_NOARGS, FEdgeSmooth_normal___doc__},
|
|
{"materialIndex", ( PyCFunction ) FEdgeSmooth_materialIndex, METH_NOARGS, FEdgeSmooth_materialIndex___doc__},
|
|
{"material", ( PyCFunction ) FEdgeSmooth_material, METH_NOARGS, FEdgeSmooth_material___doc__},
|
|
{"faceMark", ( PyCFunction ) FEdgeSmooth_faceMark, METH_NOARGS, FEdgeSmooth_faceMark___doc__},
|
|
{"setNormal", ( PyCFunction ) FEdgeSmooth_setNormal, METH_VARARGS, FEdgeSmooth_setNormal___doc__},
|
|
{"setMaterialIndex", ( PyCFunction ) FEdgeSmooth_setMaterialIndex, METH_VARARGS, FEdgeSmooth_setMaterialIndex___doc__},
|
|
{"setFaceMark", ( PyCFunction ) FEdgeSmooth_setFaceMark, METH_VARARGS, FEdgeSmooth_setFaceMark___doc__},
|
|
{NULL, NULL, 0, NULL}
|
|
};
|
|
|
|
/*-----------------------BPy_FEdgeSmooth type definition ------------------------------*/
|
|
|
|
PyTypeObject FEdgeSmooth_Type = {
|
|
PyVarObject_HEAD_INIT(NULL, 0)
|
|
"FEdgeSmooth", /* tp_name */
|
|
sizeof(BPy_FEdgeSmooth), /* tp_basicsize */
|
|
0, /* tp_itemsize */
|
|
0, /* tp_dealloc */
|
|
0, /* tp_print */
|
|
0, /* tp_getattr */
|
|
0, /* tp_setattr */
|
|
0, /* tp_reserved */
|
|
0, /* tp_repr */
|
|
0, /* tp_as_number */
|
|
0, /* tp_as_sequence */
|
|
0, /* tp_as_mapping */
|
|
0, /* tp_hash */
|
|
0, /* tp_call */
|
|
0, /* tp_str */
|
|
0, /* tp_getattro */
|
|
0, /* tp_setattro */
|
|
0, /* tp_as_buffer */
|
|
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
|
|
FEdgeSmooth___doc__, /* tp_doc */
|
|
0, /* tp_traverse */
|
|
0, /* tp_clear */
|
|
0, /* tp_richcompare */
|
|
0, /* tp_weaklistoffset */
|
|
0, /* tp_iter */
|
|
0, /* tp_iternext */
|
|
BPy_FEdgeSmooth_methods, /* tp_methods */
|
|
0, /* tp_members */
|
|
0, /* tp_getset */
|
|
&FEdge_Type, /* tp_base */
|
|
0, /* tp_dict */
|
|
0, /* tp_descr_get */
|
|
0, /* tp_descr_set */
|
|
0, /* tp_dictoffset */
|
|
(initproc)FEdgeSmooth___init__, /* tp_init */
|
|
0, /* tp_alloc */
|
|
0, /* tp_new */
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|