svn merge ^/trunk/blender -r48321:48333
authorCampbell Barton <ideasman42@gmail.com>
Wed, 27 Jun 2012 14:36:06 +0000 (14:36 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Wed, 27 Jun 2012 14:36:06 +0000 (14:36 +0000)
16 files changed:
intern/ghost/intern/GHOST_SystemPathsX11.cpp
source/blender/bmesh/intern/bmesh_opdefines.c
source/blender/bmesh/intern/bmesh_operators_private.h
source/blender/bmesh/operators/bmo_primitive.c
source/blender/bmesh/operators/bmo_removedoubles.c
source/blender/editors/mesh/meshtools.c
source/blender/editors/sculpt_paint/paint_image.c
source/blender/editors/transform/transform_constraints.c
source/blender/python/bmesh/CMakeLists.txt
source/blender/python/bmesh/bmesh_py_api.c
source/blender/python/bmesh/bmesh_py_ops.c [new file with mode: 0644]
source/blender/python/bmesh/bmesh_py_ops.h [new file with mode: 0644]
source/blender/python/bmesh/bmesh_py_types.h
source/blender/python/bmesh/bmesh_py_utils.c
source/blender/python/mathutils/mathutils_geometry.c
source/gameengine/Ketsji/KX_PythonInit.cpp

index cb2e351ab7a8300e850ab43780a9a5e0b582f620..83f7e87977cf822ab9162d8bf889bffbe7378928 100644 (file)
@@ -64,7 +64,7 @@ const GHOST_TUns8 *GHOST_SystemPathsX11::getSystemDir(int, const char *versionst
        if (static_path) {
                static char system_path[PATH_MAX];
                snprintf(system_path, sizeof(system_path), "%s/blender/%s", static_path, versionstr);
-               return (GHOST_TUns8*)system_path;
+               return (GHOST_TUns8 *)system_path;
        }
 
        return NULL;
@@ -81,22 +81,22 @@ const GHOST_TUns8 *GHOST_SystemPathsX11::getUserDir(int version, const char *ver
 
                if (home) {
                        snprintf(user_path, sizeof(user_path), "%s/.blender/%s", home, versionstr);
-                       return (GHOST_TUns8*)user_path;
+                       return (GHOST_TUns8 *)user_path;
                }
 
                return NULL;
        }
        else {
-               const char *home= getenv("XDG_CONFIG_HOME");
+               const char *home = getenv("XDG_CONFIG_HOME");
 
                if (home) {
                        snprintf(user_path, sizeof(user_path), "%s/blender/%s", home, versionstr);
                }
                else {
-                       home= getenv("HOME");
+                       home = getenv("HOME");
 
                        if (home == NULL)
-                               home= getpwuid(getuid())->pw_dir;
+                               home = getpwuid(getuid())->pw_dir;
 
                        snprintf(user_path, sizeof(user_path), "%s/.config/blender/%s", home, versionstr);
                }
index 4186f5d47eb5ba95e00f8c59fec06742ff090b57..f606347baf6e4c2de6cf8b6aeb6488638b279da1 100644 (file)
@@ -245,12 +245,12 @@ static BMOpDefine bmo_finddoubles_def = {
  * Finds groups of vertices closer then dist and merges them together,
  * using the weld verts bmop.
  */
-static BMOpDefine bmo_removedoubles_def = {
-       "removedoubles",
+static BMOpDefine bmo_remove_doubles_def = {
+       "remove_doubles",
        {{BMO_OP_SLOT_ELEMENT_BUF, "verts"}, //input verts
         {BMO_OP_SLOT_FLT,         "dist"}, //minimum distance
         {0, /* null-terminating sentinel */}},
-       bmo_removedoubles_exec,
+       bmo_remove_doubles_exec,
        BMO_OP_FLAG_UNTAN_MULTIRES,
 };
 
@@ -1199,7 +1199,7 @@ BMOpDefine *opdefines[] = {
        &bmo_contextual_create_def,
        &bmo_makevert_def,
        &bmo_weldverts_def,
-       &bmo_removedoubles_def,
+       &bmo_remove_doubles_def,
        &bmo_finddoubles_def,
        &bmo_mirror_def,
        &bmo_edgebisect_def,
index df48ec8468fd409b288a1adc3c3e565d27b91b05..baccb3e9a1078305fb6b4d276d38d11770ca601d 100644 (file)
@@ -57,7 +57,7 @@ void bmo_makevert_exec(BMesh *bm, BMOperator *op);
 void bmo_dissolve_edges_exec(BMesh *bm, BMOperator *op);
 void bmo_dissolve_edgeloop_exec(BMesh *bm, BMOperator *op);
 void bmo_weldverts_exec(BMesh *bm, BMOperator *op);
-void bmo_removedoubles_exec(BMesh *bm, BMOperator *op);
+void bmo_remove_doubles_exec(BMesh *bm, BMOperator *op);
 void bmo_finddoubles_exec(BMesh *bm, BMOperator *op);
 void bmo_mirror_exec(BMesh *bm, BMOperator *op);
 void bmo_edgebisect_exec(BMesh *bm, BMOperator *op);
index 08cd3835b2d238a0cf035eb8bb3fb2ac9633ff63..49b0679be3d94a5c9afe946fe10926eb245c19c0 100644 (file)
@@ -365,7 +365,7 @@ void bmo_create_uvsphere_exec(BMesh *bm, BMOperator *op)
                len2 = len_v3v3(vec, vec2);
 
                /* use shortest segment length divided by 3 as merge threshold */
-               BMO_op_callf(bm, "removedoubles verts=%fv dist=%f", VERT_MARK, MIN2(len, len2) / 3.0f);
+               BMO_op_callf(bm, "remove_doubles verts=%fv dist=%f", VERT_MARK, MIN2(len, len2) / 3.0f);
        }
 
        /* and now do imat */
@@ -661,7 +661,7 @@ void bmo_create_cone_exec(BMesh *bm, BMOperator *op)
        
        BM_face_create_quad_tri(bm, v1, v2, firstv2, firstv1, NULL, FALSE);
 
-       BMO_op_callf(bm, "removedoubles verts=%fv dist=%f", VERT_MARK, 0.000001);
+       BMO_op_callf(bm, "remove_doubles verts=%fv dist=%f", VERT_MARK, 0.000001);
        BMO_slot_buffer_from_enabled_flag(bm, op, "vertout", BM_VERT, VERT_MARK);
 }
 
index 52c693efc846e03f5601b7c4ea41e140179402b1..296d598ae3b425520c58afd0d6d8d0e0b4848e2d 100644 (file)
@@ -557,7 +557,7 @@ void bmesh_finddoubles_common(BMesh *bm, BMOperator *op, BMOperator *optarget, c
        BLI_array_free(verts);
 }
 
-void bmo_removedoubles_exec(BMesh *bm, BMOperator *op)
+void bmo_remove_doubles_exec(BMesh *bm, BMOperator *op)
 {
        BMOperator weldop;
 
index 6d6165e27294bac23cf8afcb979e4effcec9fe01..cdbf5751ea13ad6cf9a6a58eeb7effafb2b1d831 100644 (file)
@@ -898,7 +898,7 @@ int mesh_mirrtopo_table(Object *ob, char mode)
        return 0;
 }
 
-static int mesh_get_x_mirror_vert_spacial(Object *ob, int index)
+static int mesh_get_x_mirror_vert_spatial(Object *ob, int index)
 {
        Mesh *me = ob->data;
        MVert *mvert;
@@ -926,12 +926,12 @@ int mesh_get_x_mirror_vert(Object *ob, int index)
                return mesh_get_x_mirror_vert_topo(ob, index);
        }
        else {
-               return mesh_get_x_mirror_vert_spacial(ob, index);
+               return mesh_get_x_mirror_vert_spatial(ob, index);
        }
        return 0;
 }
 
-static BMVert *editbmesh_get_x_mirror_vert_spacial(Object *ob, BMEditMesh *em, const float co[3])
+static BMVert *editbmesh_get_x_mirror_vert_spatial(Object *ob, BMEditMesh *em, const float co[3])
 {
        float vec[3];
        intptr_t poinval;
@@ -989,7 +989,7 @@ BMVert *editbmesh_get_x_mirror_vert(Object *ob, struct BMEditMesh *em, BMVert *e
                return editbmesh_get_x_mirror_vert_topo(ob, em, eve, index);
        }
        else {
-               return editbmesh_get_x_mirror_vert_spacial(ob, em, co);
+               return editbmesh_get_x_mirror_vert_spatial(ob, em, co);
        }
 }
 
index a1ade77d06815bb197085af8cadf3c0cc7d462ef..6a8f7db5fc9861ea0d6b2bd3f7da2e2c8170edb6 100644 (file)
@@ -4935,7 +4935,7 @@ static int texture_paint_init(bContext *C, wmOperator *op)
                if (BKE_brush_size_get(scene, brush) < 2)
                        BKE_brush_size_set(scene, brush, 2);
 
-               /* allocate and initialize spacial data structures */
+               /* allocate and initialize spatial data structures */
                project_paint_begin(&pop->ps);
                
                if (pop->ps.dm == NULL)
@@ -5728,7 +5728,7 @@ static int texture_paint_camera_project_exec(bContext *C, wmOperator *op)
        undo_paint_push_begin(UNDO_PAINT_IMAGE, op->type->name,
                              image_undo_restore, image_undo_free);
 
-       /* allocate and initialize spacial data structures */
+       /* allocate and initialize spatial data structures */
        project_paint_begin(&ps);
 
        if (ps.dm == NULL) {
index d2910c5b6028595fefea3173111ad5c2906fc0c2..f4c025f71be28a02efbc7534f4e5436596c5d7c7 100644 (file)
@@ -306,7 +306,7 @@ static void planeProjection(TransInfo *t, float in[3], float out[3])
 }
 
 /*
- * Generic callback for constant spacial constraints applied to linear motion
+ * Generic callback for constant spatial constraints applied to linear motion
  *
  * The IN vector in projected into the constrained space and then further
  * projected along the view vector.
@@ -404,9 +404,7 @@ static void applyObjectConstraintVec(TransInfo *t, TransData *td, float in[3], f
 }
 
 /*
- * Generic callback for constant spacial constraints applied to resize motion
- *
- *
+ * Generic callback for constant spatial constraints applied to resize motion
  */
 
 static void applyAxisConstraintSize(TransInfo *t, TransData *td, float smat[3][3])
@@ -430,9 +428,7 @@ static void applyAxisConstraintSize(TransInfo *t, TransData *td, float smat[3][3
 }
 
 /*
- * Callback for object based spacial constraints applied to resize motion
- *
- *
+ * Callback for object based spatial constraints applied to resize motion
  */
 
 static void applyObjectConstraintSize(TransInfo *t, TransData *td, float smat[3][3])
@@ -459,7 +455,7 @@ static void applyObjectConstraintSize(TransInfo *t, TransData *td, float smat[3]
 }
 
 /*
- * Generic callback for constant spacial constraints applied to rotations
+ * Generic callback for constant spatial constraints applied to rotations
  *
  * The rotation axis is copied into VEC.
  *
@@ -501,7 +497,7 @@ static void applyAxisConstraintRot(TransInfo *t, TransData *td, float vec[3], fl
 }
 
 /*
- * Callback for object based spacial constraints applied to rotations
+ * Callback for object based spatial constraints applied to rotations
  *
  * The rotation axis is copied into VEC.
  *
index 40bde7161b69d9cad07b10d5c460971e1dd28613..032a914fb7085d3450635ed6c68b6e81a8dccf8f 100644 (file)
@@ -33,6 +33,7 @@ set(INC_SYS
 
 set(SRC
        bmesh_py_api.c
+       bmesh_py_ops.c
        bmesh_py_types.c
        bmesh_py_types_customdata.c
        bmesh_py_types_meshdata.c
@@ -40,6 +41,7 @@ set(SRC
        bmesh_py_utils.c
 
        bmesh_py_api.h
+       bmesh_py_ops.h
        bmesh_py_types.h
        bmesh_py_types_customdata.h
        bmesh_py_types_meshdata.h
index 4d8d4e3bc23a405517e03df63beb8af22c1052b4..2cfe5847e5535fca92380f41d7e542d6c55f9dc6 100644 (file)
@@ -40,6 +40,7 @@
 #include "bmesh_py_types_customdata.h"
 #include "bmesh_py_types_meshdata.h"
 
+#include "bmesh_py_ops.h"
 #include "bmesh_py_utils.h"
 
 #include "BKE_tessmesh.h"
@@ -143,6 +144,10 @@ PyObject *BPyInit_bmesh(void)
        PyDict_SetItemString(sys_modules, PyModule_GetName(submodule), submodule);
        Py_INCREF(submodule);
 
+       PyModule_AddObject(mod, "ops", (submodule = BPyInit_bmesh_ops()));
+       PyDict_SetItemString(sys_modules, PyModule_GetName(submodule), submodule);
+       Py_INCREF(submodule);
+
        PyModule_AddObject(mod, "utils", (submodule = BPyInit_bmesh_utils()));
        PyDict_SetItemString(sys_modules, PyModule_GetName(submodule), submodule);
        Py_INCREF(submodule);
diff --git a/source/blender/python/bmesh/bmesh_py_ops.c b/source/blender/python/bmesh/bmesh_py_ops.c
new file mode 100644 (file)
index 0000000..b995862
--- /dev/null
@@ -0,0 +1,273 @@
+/*
+ * ***** 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): Campbell Barton
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/python/bmesh/bmesh_py_ops.c
+ *  \ingroup pybmesh
+ *
+ * This file defines the 'bmesh.ops' module.
+ * Operators from 'opdefines' are wrapped.
+ */
+
+#include <Python.h>
+
+#include "BLI_utildefines.h"
+
+#include "MEM_guardedalloc.h"
+
+#include "../generic/py_capi_utils.h"
+
+#include "../mathutils/mathutils.h"
+
+#include "bmesh.h"
+
+#include "bmesh_py_types.h"
+
+#include "bmesh_py_utils.h" /* own include */
+
+static int bpy_bm_op_as_py_error(BMesh *bm)
+{
+       if (BMO_error_occurred(bm)) {
+               const char *errmsg;
+               if (BMO_error_get(bm, &errmsg, NULL)) {
+                       PyErr_Format(PyExc_RuntimeError,
+                                    "bmesh operator: %.200s",
+                                    errmsg);
+                       return -1;
+               }
+       }
+       return 0;
+}
+
+PyDoc_STRVAR(bpy_bm_ops_convex_hull_doc,
+".. method:: convex_hull(bmesh, filter)\n"
+"\n"
+"   Face split with optional intermediate points.\n"
+"\n"
+"   :arg bmesh: The face to cut.\n"
+"   :type bmesh: :class:`bmesh.types.BMFace`\n"
+"   :arg filter: Set containing vertex flags to apply the operator.\n"
+"   :type filter: set\n"
+);
+static PyObject *bpy_bm_ops_convex_hull(PyObject *UNUSED(self), PyObject *args, PyObject *kw)
+{
+       static const char *kwlist[] = {"bmesh", "filter", NULL};
+
+       BPy_BMesh *py_bm;
+       BMesh *bm;
+
+       PyObject *filter;
+       int filter_flags;
+       BMOperator bmop;
+
+       if (!PyArg_ParseTupleAndKeywords(args, kw, "O!O!:convex_hull", (char **)kwlist,
+                                        &BPy_BMesh_Type, &py_bm,
+                                        &PySet_Type,  &filter))
+       {
+               return NULL;
+       }
+
+       BPY_BM_CHECK_OBJ(py_bm);
+       bm = py_bm->bm;
+
+       if (filter != NULL && PyC_FlagSet_ToBitfield(bpy_bm_hflag_all_flags, filter,
+                                                    &filter_flags, "convex_hull") == -1)
+       {
+               return NULL;
+       }
+
+       BMO_op_initf(bm, &bmop,
+                    "convex_hull input=%hv",
+                    filter_flags);
+       BMO_op_exec(bm, &bmop);
+       BMO_op_finish(bm, &bmop);
+
+       if (bpy_bm_op_as_py_error(bm) == -1) {
+               return NULL;
+       }
+
+       /* TODO, return values */
+       Py_RETURN_NONE;
+}
+
+
+
+
+PyDoc_STRVAR(bpy_bm_ops_dissolve_limit_doc,
+".. method:: dissolve_limit(bmesh, filter, dist)\n"
+"\n"
+"   Face split with optional intermediate points.\n"
+"\n"
+"   :arg bmesh: The face to cut.\n"
+"   :type bmesh: :class:`bmesh.types.BMFace`\n"
+"   :arg filter: Set containing vertex flags to apply the operator.\n"
+"   :type filter: set\n"
+"   :arg dist: Distance limit.\n"
+"   :type dist: float\n"
+);
+static PyObject *bpy_bm_ops_dissolve_limit(PyObject *UNUSED(self), PyObject *args, PyObject *kw)
+{
+       static const char *kwlist[] = {"bmesh", "filter_verts", "filter_edges", "angle_limit", NULL};
+
+       BPy_BMesh *py_bm;
+       BMesh *bm;
+
+       PyObject *filter_verts;
+       int filter_verts_flags;
+       PyObject *filter_edges;
+       int filter_edges_flags;
+
+       float angle_limit = 0.0f;
+
+       BMOperator bmop;
+
+       if (!PyArg_ParseTupleAndKeywords(args, kw, "O!O!O!|f:dissolve_limit", (char **)kwlist,
+                                        &BPy_BMesh_Type, &py_bm,
+                                        &PySet_Type, &filter_verts,
+                                        &PySet_Type, &filter_edges,
+                                        &angle_limit))
+       {
+               return NULL;
+       }
+
+       BPY_BM_CHECK_OBJ(py_bm);
+       bm = py_bm->bm;
+
+       if (filter_verts != NULL && PyC_FlagSet_ToBitfield(bpy_bm_hflag_all_flags, filter_verts,
+                                                          &filter_verts_flags, "dissolve_limit") == -1)
+       {
+               return NULL;
+       }
+
+       if (filter_edges != NULL && PyC_FlagSet_ToBitfield(bpy_bm_hflag_all_flags, filter_edges,
+                                                          &filter_edges_flags, "dissolve_limit") == -1)
+       {
+               return NULL;
+       }
+
+       BMO_op_initf(bm, &bmop,
+                    "dissolve_limit verts=%hv edges=%he angle_limit=%f",
+                    filter_verts_flags, filter_edges_flags, angle_limit);
+       BMO_op_exec(bm, &bmop);
+       BMO_op_finish(bm, &bmop);
+
+       if (bpy_bm_op_as_py_error(bm) == -1) {
+               return NULL;
+       }
+
+       /* TODO, return values */
+       Py_RETURN_NONE;
+}
+
+
+
+
+PyDoc_STRVAR(bpy_bm_ops_remove_doubles_doc,
+".. method:: remove_doubles(bmesh, filter, dist)\n"
+"\n"
+"   Face split with optional intermediate points.\n"
+"\n"
+"   :arg bmesh: The face to cut.\n"
+"   :type bmesh: :class:`bmesh.types.BMFace`\n"
+"   :arg filter: Set containing vertex flags to apply the operator.\n"
+"   :type filter: set\n"
+"   :arg dist: Distance limit.\n"
+"   :type dist: float\n"
+);
+static PyObject *bpy_bm_ops_remove_doubles(PyObject *UNUSED(self), PyObject *args, PyObject *kw)
+{
+       static const char *kwlist[] = {"bmesh", "filter", "dist", NULL};
+
+       BPy_BMesh *py_bm;
+       BMesh *bm;
+
+       PyObject *filter;
+       int filter_flags;
+       float dist = 0.0f;
+
+       BMOperator bmop;
+
+       if (!PyArg_ParseTupleAndKeywords(args, kw, "O!O!|f:remove_doubles", (char **)kwlist,
+                                        &BPy_BMesh_Type, &py_bm,
+                                        &PySet_Type,  &filter,
+                                        &dist))
+       {
+               return NULL;
+       }
+
+       BPY_BM_CHECK_OBJ(py_bm);
+       bm = py_bm->bm;
+
+       if (filter != NULL && PyC_FlagSet_ToBitfield(bpy_bm_hflag_all_flags, filter,
+                                                    &filter_flags, "remove_doubles") == -1)
+       {
+               return NULL;
+       }
+
+       BMO_op_initf(bm, &bmop,
+                    "remove_doubles verts=%hv dist=%f",
+                    filter_flags, dist);
+       BMO_op_exec(bm, &bmop);
+       BMO_op_finish(bm, &bmop);
+
+       if (bpy_bm_op_as_py_error(bm) == -1) {
+               return NULL;
+       }
+
+       /* TODO, return values */
+       Py_RETURN_NONE;
+}
+
+static struct PyMethodDef BPy_BM_ops_methods[] = {
+    {"convex_hull", (PyCFunction)bpy_bm_ops_convex_hull, METH_VARARGS | METH_KEYWORDS, bpy_bm_ops_convex_hull_doc},
+    {"dissolve_limit", (PyCFunction)bpy_bm_ops_dissolve_limit, METH_VARARGS | METH_KEYWORDS, bpy_bm_ops_dissolve_limit_doc},
+    {"remove_doubles", (PyCFunction)bpy_bm_ops_remove_doubles, METH_VARARGS | METH_KEYWORDS, bpy_bm_ops_remove_doubles_doc},
+    {NULL, NULL, 0, NULL}
+};
+
+
+PyDoc_STRVAR(BPy_BM_ops_doc,
+             "This module provides access to bmesh operators (EXPEREMENTAL)."
+             );
+static struct PyModuleDef BPy_BM_ops_module_def = {
+    PyModuleDef_HEAD_INIT,
+    "bmesh.ops",  /* m_name */
+    BPy_BM_ops_doc,  /* m_doc */
+    0,  /* m_size */
+    BPy_BM_ops_methods,  /* m_methods */
+    NULL,  /* m_reload */
+    NULL,  /* m_traverse */
+    NULL,  /* m_clear */
+    NULL,  /* m_free */
+};
+
+
+PyObject *BPyInit_bmesh_ops(void)
+{
+       PyObject *submodule;
+
+       submodule = PyModule_Create(&BPy_BM_ops_module_def);
+
+       return submodule;
+}
diff --git a/source/blender/python/bmesh/bmesh_py_ops.h b/source/blender/python/bmesh/bmesh_py_ops.h
new file mode 100644 (file)
index 0000000..56c980b
--- /dev/null
@@ -0,0 +1,35 @@
+/*
+ * ***** 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): Campbell Barton
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/python/bmesh/bmesh_py_ops.h
+ *  \ingroup pybmesh
+ */
+
+#ifndef __BMESH_PY_OPS_H__
+#define __BMESH_PY_OPS_H__
+
+PyObject *BPyInit_bmesh_ops(void);
+
+#endif /* __BMESH_PY_OPS_H__ */
index 85bbd5d7b0915d8f0f34fa420f39ae8752069ee1..947e66bf24e9fbf2efd398f707cd477338e8d810 100644 (file)
@@ -186,4 +186,13 @@ char     *BPy_BMElem_StringFromHType(const char htype);
             ele;                                                                 \
             ele = BM_iter_step(iter))
 
+
+#ifdef __PY_CAPI_UTILS_H__
+struct PyC_FlagSet;
+extern struct PyC_FlagSet bpy_bm_scene_vert_edge_face_flags[];
+extern struct PyC_FlagSet bpy_bm_htype_vert_edge_face_flags[];
+extern struct PyC_FlagSet bpy_bm_htype_all_flags[];
+extern struct PyC_FlagSet bpy_bm_hflag_all_flags[];
+#endif
+
 #endif /* __BMESH_TYPES_H__ */
index 6a2ba90a330572caef46efbf434b0beae9c0bbfe..4417bc2ce8d5a009831cf0ec18653bcd089f937e 100644 (file)
@@ -668,13 +668,13 @@ static struct PyMethodDef BPy_BM_utils_methods[] = {
 };
 
 
-PyDoc_STRVAR(BPy_BM_doc,
+PyDoc_STRVAR(BPy_BM_utils_doc,
 "This module provides access to blenders bmesh data structures."
 );
-static struct PyModuleDef BPy_BM_types_module_def = {
+static struct PyModuleDef BPy_BM_utils_module_def = {
     PyModuleDef_HEAD_INIT,
     "bmesh.utils",  /* m_name */
-    BPy_BM_doc,  /* m_doc */
+    BPy_BM_utils_doc,  /* m_doc */
     0,  /* m_size */
     BPy_BM_utils_methods,  /* m_methods */
     NULL,  /* m_reload */
@@ -688,7 +688,7 @@ PyObject *BPyInit_bmesh_utils(void)
 {
        PyObject *submodule;
 
-       submodule = PyModule_Create(&BPy_BM_types_module_def);
+       submodule = PyModule_Create(&BPy_BM_utils_module_def);
 
        return submodule;
 }
index 4d05b83795205f710510830fd8ae302117971f4b..524515ac4609c29717df32d40194909117e3cc42 100644 (file)
@@ -944,6 +944,109 @@ static PyObject *M_Geometry_barycentric_transform(PyObject *UNUSED(self), PyObje
        return Vector_CreatePyObject(vec, 3, Py_NEW, NULL);
 }
 
+PyDoc_STRVAR(M_Geometry_points_in_planes_doc,
+".. function:: points_in_planes(planes)\n"
+"\n"
+"   Returns a list of points inside all planes given and a list of index values for the planes used.\n"
+"\n"
+"   :arg planes: List of planes (4D vectors).\n"
+"   :type planes: list of :class:`mathutils.Vector`\n"
+"   :return: two lists, once containing the vertices inside the planes, another containing the plane indicies used\n"
+"   :rtype: pair of lists\n"
+);
+/* note: this function could be optimized by some spatial structure */
+static PyObject *M_Geometry_points_in_planes(PyObject *UNUSED(self), PyObject *args)
+{
+       PyObject *py_planes;
+       float (*planes)[4];
+       unsigned int planes_len;
+
+       if (!PyArg_ParseTuple(args, "O:points_in_planes",
+                             &py_planes))
+       {
+               return NULL;
+       }
+
+       if ((planes_len = mathutils_array_parse_alloc_v((float **)&planes, 4, py_planes, "points_in_planes")) == -1) {
+               return NULL;
+       }
+       else {
+               /* note, this could be refactored into plain C easy - py bits are noted */
+               const float eps = 0.0001f;
+               const unsigned int len = (unsigned int)planes_len;
+               unsigned int i, j, k, l;
+
+               float n1n2[3], n2n3[3], n3n1[3];
+               float potentialVertex[3];
+               char *planes_used = MEM_callocN(sizeof(char) * len, __func__);
+
+               /* python */
+               PyObject *py_verts = PyList_New(0);
+               PyObject *py_plene_index = PyList_New(0);
+
+               for (i = 0; i < len; i++) {
+                       const float *N1 = planes[i];
+                       for (j = i + 1; j < len; j++) {
+                               const float *N2 = planes[j];
+                               cross_v3_v3v3(n1n2, N1, N2);
+                               if (len_squared_v3(n1n2) > eps) {
+                                       for (k = j + 1; k < len; k++) {
+                                               const float *N3 = planes[k];
+                                               cross_v3_v3v3(n2n3, N2, N3);
+                                               if (len_squared_v3(n2n3) > eps) {
+                                                       cross_v3_v3v3(n3n1, N3, N1);
+                                                       if (len_squared_v3(n3n1) > eps) {
+                                                               const float quotient = dot_v3v3(N1, n2n3);
+                                                               if (fabsf(quotient) > eps) {
+                                                                       /* potentialVertex = (n2n3 * N1[3] + n3n1 * N2[3] + n1n2 * N3[3]) * (-1.0 / quotient); */
+                                                                       const float quotient_ninv = -1.0f / quotient;
+                                                                       potentialVertex[0] = ((n2n3[0] * N1[3]) + (n3n1[0] * N2[3]) + (n1n2[0] * N3[3])) * quotient_ninv;
+                                                                       potentialVertex[1] = ((n2n3[1] * N1[3]) + (n3n1[1] * N2[3]) + (n1n2[1] * N3[3])) * quotient_ninv;
+                                                                       potentialVertex[2] = ((n2n3[2] * N1[3]) + (n3n1[2] * N2[3]) + (n1n2[2] * N3[3])) * quotient_ninv;
+                                                                       for (l = 0; l < len; l++) {
+                                                                               const float *NP = planes[l];
+                                                                               if ((dot_v3v3(NP, potentialVertex) + NP[3]) > 0.000001f) {
+                                                                                       break;
+                                                                               }
+                                                                       }
+
+                                                                       if (l == len) { /* ok */
+                                                                               /* python */
+                                                                               PyObject *item = Vector_CreatePyObject(potentialVertex, 3, Py_NEW, NULL);
+                                                                               PyList_Append(py_verts, item);
+                                                                               Py_DECREF(item);
+
+                                                                               planes_used[i] = planes_used[j] = planes_used[k] = TRUE;
+                                                                       }
+                                                               }
+                                                       }
+                                               }
+                                       }
+                               }
+                       }
+               }
+
+               PyMem_Free(planes);
+
+               /* now make a list of used planes */
+               for (i = 0; i < len; i++) {
+                       if (planes_used[i]) {
+                               PyObject *item = PyLong_FromLong(i);
+                               PyList_Append(py_plene_index, item);
+                               Py_DECREF(item);
+                       }
+               }
+               MEM_freeN(planes_used);
+
+               {
+                       PyObject *ret = PyTuple_New(2);
+                       PyTuple_SET_ITEM(ret, 0, py_verts);
+                       PyTuple_SET_ITEM(ret, 1, py_plene_index);
+                       return ret;
+               }
+       }
+}
+
 #ifndef MATH_STANDALONE
 
 PyDoc_STRVAR(M_Geometry_interpolate_bezier_doc,
@@ -1279,6 +1382,7 @@ static PyMethodDef M_Geometry_methods[] = {
        {"area_tri", (PyCFunction) M_Geometry_area_tri, METH_VARARGS, M_Geometry_area_tri_doc},
        {"normal", (PyCFunction) M_Geometry_normal, METH_VARARGS, M_Geometry_normal_doc},
        {"barycentric_transform", (PyCFunction) M_Geometry_barycentric_transform, METH_VARARGS, M_Geometry_barycentric_transform_doc},
+       {"points_in_planes", (PyCFunction) M_Geometry_points_in_planes, METH_VARARGS, M_Geometry_points_in_planes_doc},
 #ifndef MATH_STANDALONE
        {"interpolate_bezier", (PyCFunction) M_Geometry_interpolate_bezier, METH_VARARGS, M_Geometry_interpolate_bezier_doc},
        {"tessellate_polygon", (PyCFunction) M_Geometry_tessellate_polygon, METH_O, M_Geometry_tessellate_polygon_doc},
index 2a648303c524346e70a0299fc481651717c9c73d..823363dfd110f141822055f9b32ac2e828ce4c16 100644 (file)
@@ -1130,8 +1130,8 @@ static int getGLSLSettingFlag(const char *setting)
 }
 
 static PyObject* gPySetGLSLMaterialSetting(PyObject*,
-                                                                                       PyObject* args,
-                                                                                       PyObject*)
+                                           PyObject* args,
+                                           PyObject*)
 {
        GlobalSettings *gs= gp_KetsjiEngine->GetGlobalSettings();
        char *setting;
@@ -1142,7 +1142,7 @@ static PyObject* gPySetGLSLMaterialSetting(PyObject*,
        
        flag = getGLSLSettingFlag(setting);
        
-       if  (flag==-1) {
+       if (flag == -1) {
                PyErr_SetString(PyExc_ValueError, "Rasterizer.setGLSLMaterialSetting(string): glsl setting is not known");
                return NULL;
        }
@@ -1173,8 +1173,8 @@ static PyObject* gPySetGLSLMaterialSetting(PyObject*,
 }
 
 static PyObject* gPyGetGLSLMaterialSetting(PyObject*, 
-                                                                        PyObject* args, 
-                                                                        PyObject*)
+                                           PyObject* args,
+                                           PyObject*)
 {
        GlobalSettings *gs= gp_KetsjiEngine->GetGlobalSettings();
        char *setting;
@@ -1185,7 +1185,7 @@ static PyObject* gPyGetGLSLMaterialSetting(PyObject*,
        
        flag = getGLSLSettingFlag(setting);
        
-       if  (flag==-1) {
+       if (flag == -1) {
                PyErr_SetString(PyExc_ValueError, "Rasterizer.getGLSLMaterialSetting(string): glsl setting is not known");
                return NULL;
        }