code cleanup: split `foreach` object data iterator functions out of drawobject.c...
authorCampbell Barton <ideasman42@gmail.com>
Wed, 10 Oct 2012 03:13:02 +0000 (03:13 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Wed, 10 Oct 2012 03:13:02 +0000 (03:13 +0000)
source/blender/editors/include/ED_object.h
source/blender/editors/include/ED_view3d.h
source/blender/editors/mesh/editmesh_select.c
source/blender/editors/object/CMakeLists.txt
source/blender/editors/object/object_iterators.c [new file with mode: 0644]
source/blender/editors/space_view3d/drawobject.c

index 9836d690e53451fe1bc0d92e243df242cfd40bfd..aa145dfd9063796b23a7d5fc8b30e24430af3a56 100644 (file)
 extern "C" {
 #endif
 
+struct BMEdge;
+struct BMFace;
+struct BMVert;
+struct BPoint;
 struct Base;
-struct bConstraint;
-struct bContext;
-struct bPoseChannel;
+struct BezTriple;
 struct Curve;
+struct EditBone;
 struct EnumPropertyItem;
 struct ID;
 struct KeyBlock;
 struct Lattice;
 struct Main;
 struct Mesh;
+struct MetaElem;
 struct ModifierData;
+struct Nurb;
 struct Object;
 struct ReportList;
 struct Scene;
 struct View3D;
+struct ViewContext;
+struct bConstraint;
+struct bContext;
+struct bPoseChannel;
 struct wmEvent;
 struct wmKeyConfig;
 struct wmKeyMap;
@@ -82,8 +91,10 @@ typedef enum eParentType {
        PAR_TRIA
 } eParentType;
 
+#ifdef __RNA_TYPES_H__
 extern struct EnumPropertyItem prop_clear_parent_types[];
 extern struct EnumPropertyItem prop_make_parent_types[];
+#endif
 
 int ED_object_parent_set(struct ReportList *reports, struct Main *bmain, struct Scene *scene, struct Object *ob,
                          struct Object *par, int partype, int xmirror, int keep_transform);
@@ -183,9 +194,58 @@ int ED_object_iter_other(struct Main *bmain, struct Object *orig_ob, int include
 
 int ED_object_multires_update_totlevels_cb(struct Object *ob, void *totlevel_v);
 
-/* ibject_select.c */
+/* object_select.c */
 void ED_object_select_linked_by_id(struct bContext *C, struct ID *id);
 
+
+/* object_iterators.c */
+
+/* enum for passing to foreach functions to test RV3D_CLIPPING */
+typedef enum eV3DClipTest {
+       V3D_CLIP_TEST_OFF =            0, /* clipping is off */
+       V3D_CLIP_TEST_RV3D_CLIPPING =  1, /* clip single points */
+       V3D_CLIP_TEST_REGION =         2  /* use for edges to check if both verts are in the view, but not RV3D_CLIPPING */
+} eV3DClipTest;
+
+/* foreach iterators */
+void mesh_foreachScreenVert(
+        struct ViewContext *vc,
+        void (*func)(void *userData, struct BMVert *eve, const float screen_co[2], int index),
+        void *userData, eV3DClipTest clipVerts);
+void mesh_foreachScreenEdge(
+        struct ViewContext *vc,
+        void (*func)(void *userData, struct BMEdge *eed, const float screen_co_a[2], const float screen_co_b[2],
+                     int index),
+        void *userData, eV3DClipTest clipVerts);
+void mesh_foreachScreenFace(
+        struct ViewContext *vc,
+        void (*func)(void *userData, struct BMFace *efa, const float screen_co[2], int index),
+        void *userData);
+void nurbs_foreachScreenVert(
+        struct ViewContext *vc,
+        void (*func)(void *userData, struct Nurb *nu, struct BPoint *bp, struct BezTriple *bezt,
+                     int beztindex, const float screen_co[2]),
+        void *userData);
+void mball_foreachScreenElem(
+        struct ViewContext *vc,
+        void (*func)(void *userData, struct MetaElem *ml, const float screen_co[2]),
+        void *userData);
+void lattice_foreachScreenVert(
+        struct ViewContext *vc,
+        void (*func)(void *userData, struct BPoint *bp,
+                     const float screen_co[2]),
+        void *userData);
+void armature_foreachScreenBone(
+        struct ViewContext *vc,
+        void (*func)(void *userData, struct EditBone *ebone,
+                     const float screen_co_a[2], const float screen_co_b[2]),
+        void *userData);
+void pose_foreachScreenBone(
+        struct ViewContext *vc,
+        void (*func)(void *userData, struct bPoseChannel *pchan,
+                     const float screen_co_a[2], const float screen_co_b[2]),
+        void *userData);
+
 #ifdef __cplusplus
 }
 #endif
index c02bc1dcf73422bc036c8d8830a68308ee162c63..ce8b874ae27db2b723e0a78a716de9a916d36e12 100644 (file)
@@ -80,13 +80,6 @@ typedef struct ViewDepths {
        char damaged;
 } ViewDepths;
 
-/* enum for passing to foreach functions to test RV3D_CLIPPING */
-typedef enum eV3DClipTest {
-       V3D_CLIP_TEST_OFF =            0, /* clipping is off */
-       V3D_CLIP_TEST_RV3D_CLIPPING =  1, /* clip single points */
-       V3D_CLIP_TEST_REGION =         2  /* use for edges to check if both verts are in the view, but not RV3D_CLIPPING */
-} eV3DClipTest;
-
 float *give_cursor(struct Scene *scene, struct View3D *v3d);
 
 int initgrabz(struct RegionView3D *rv3d, float x, float y, float z);
@@ -166,17 +159,6 @@ void ED_view3d_ob_project_mat_get(struct RegionView3D *v3d, struct Object *ob, f
 void ED_view3d_calc_camera_border(struct Scene *scene, struct ARegion *ar, struct View3D *v3d, struct RegionView3D *rv3d, struct rctf *viewborder_r, short no_shift);
 void ED_view3d_calc_camera_border_size(struct Scene *scene, struct ARegion *ar, struct View3D *v3d, struct RegionView3D *rv3d, float size_r[2]);
 
-/* drawobject.c iterators */
-void mesh_foreachScreenVert(struct ViewContext *vc, void (*func)(void *userData, struct BMVert *eve, const float screen_co[2], int index), void *userData, eV3DClipTest clipVerts);
-void mesh_foreachScreenEdge(struct ViewContext *vc, void (*func)(void *userData, struct BMEdge *eed, const float screen_co_a[2], const float screen_co_b[2], int index), void *userData, eV3DClipTest clipVerts);
-void mesh_foreachScreenFace(struct ViewContext *vc, void (*func)(void *userData, struct BMFace *efa, const float screen_co[2], int index), void *userData);
-void nurbs_foreachScreenVert(struct ViewContext *vc, void (*func)(void *userData, struct Nurb *nu, struct BPoint *bp, struct BezTriple *bezt, int beztindex, const float screen_co[2]), void *userData);
-void mball_foreachScreenElem(struct ViewContext *vc, void (*func)(void *userData, struct MetaElem *ml, const float screen_co[2]), void *userData);
-void lattice_foreachScreenVert(struct ViewContext *vc, void (*func)(void *userData, struct BPoint *bp, const float screen_co[2]), void *userData);
-void armature_foreachScreenBone(struct ViewContext *vc, void (*func)(void *userData, struct EditBone *ebone, const float screen_co_a[2], const float screen_co_b[2]), void *userData);
-void pose_foreachScreenBone(struct ViewContext *vc, void (*func)(void *userData, struct bPoseChannel *pchan, const float screen_co_a[2], const float screen_co_b[2]), void *userData);
-
-
 void ED_view3d_clipping_calc(struct BoundBox *bb, float planes[4][4], struct bglMats *mats, const struct rcti *rect);
 void ED_view3d_clipping_local(struct RegionView3D *rv3d, float mat[][4]);
 int  ED_view3d_clipping_test(struct RegionView3D *rv3d, const float vec[3], const int is_local);
index 2e40419cb168ef29aaa249854504b0ab02d5d549..e6a2c065bbf6f995ba1432b27badc85c43c7ae56 100644 (file)
@@ -57,6 +57,7 @@
 #include "ED_mesh.h"
 #include "ED_screen.h"
 #include "ED_uvedit.h"
+#include "ED_object.h"
 #include "ED_view3d.h"
 
 #include "BIF_gl.h"
index 05c042a4182248b0cd92b1ce7ffaf416a9f64481..a6745f95ea0e383cfe51c54e57efa40890542350 100644 (file)
@@ -46,6 +46,7 @@ set(SRC
        object_edit.c
        object_group.c
        object_hook.c
+       object_iterators.c
        object_lattice.c
        object_modifier.c
        object_ops.c
diff --git a/source/blender/editors/object/object_iterators.c b/source/blender/editors/object/object_iterators.c
new file mode 100644 (file)
index 0000000..7e0d00e
--- /dev/null
@@ -0,0 +1,429 @@
+/*
+ * ***** 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.
+ *
+ * Contributor(s): Blender Foundation, full recode and added functions
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/editors/object/object_iterators.c
+ *  \ingroup edobj
+ */
+
+#include "DNA_curve_types.h"
+#include "DNA_lattice_types.h"
+#include "DNA_meta_types.h"
+#include "DNA_armature_types.h"
+#include "DNA_object_types.h"
+
+#include "BLI_utildefines.h"
+#include "BLI_blenlib.h"
+
+#include "BKE_armature.h"
+#include "BKE_curve.h"
+#include "BKE_DerivedMesh.h"
+#include "BKE_displist.h"
+
+#include "bmesh.h"
+
+#include "ED_mesh.h"
+#include "ED_screen.h"
+#include "ED_armature.h"
+#include "ED_object.h"
+#include "ED_view3d.h"
+
+
+typedef struct foreachScreenVert_userData {
+       void (*func)(void *userData, BMVert *eve, const float screen_co_b[2], int index);
+       void *userData;
+       ViewContext vc;
+       eV3DClipTest clipVerts;
+} foreachScreenVert_userData;
+
+/* user data structures for derived mesh callbacks */
+typedef struct foreachScreenEdge_userData {
+       void (*func)(void *userData, BMEdge *eed, const float screen_co_a[2], const float screen_co_b[2], int index);
+       void *userData;
+       ViewContext vc;
+       rctf win_rect; /* copy of: vc.ar->winx/winy, use for faster tests, minx/y will always be 0 */
+       eV3DClipTest clipVerts;
+} foreachScreenEdge_userData;
+
+typedef struct foreachScreenFace_userData {
+       void (*func)(void *userData, BMFace *efa, const float screen_co_b[2], int index);
+       void *userData;
+       ViewContext vc;
+} foreachScreenFace_userData;
+
+
+/* Note! - foreach funcs should be called while drawing or directly after
+ * if not, ED_view3d_init_mats_rv3d() can be used for selection tools
+ * but would not give correct results with dupli's for eg. which don't
+ * use the object matrix in the usual way */
+
+/* ------------------------------------------------------------------------ */
+
+static void mesh_foreachScreenVert__mapFunc(void *userData, int index, const float co[3],
+                                            const float UNUSED(no_f[3]), const short UNUSED(no_s[3]))
+{
+       foreachScreenVert_userData *data = userData;
+       BMVert *eve = EDBM_vert_at_index(data->vc.em, index);
+
+       if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) {
+               const eV3DProjTest flag = (data->clipVerts == V3D_CLIP_TEST_OFF) ?
+                           V3D_PROJ_TEST_NOP :
+                           V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN;
+               float screen_co[2];
+
+               if (ED_view3d_project_float_object(data->vc.ar, co, screen_co, flag) != V3D_PROJ_RET_OK) {
+                       return;
+               }
+
+               data->func(data->userData, eve, screen_co, index);
+       }
+}
+
+void mesh_foreachScreenVert(
+        ViewContext *vc,
+        void (*func)(void *userData, BMVert *eve, const float screen_co[2], int index),
+        void *userData, eV3DClipTest clipVerts)
+{
+       foreachScreenVert_userData data;
+       DerivedMesh *dm = editbmesh_get_derived_cage(vc->scene, vc->obedit, vc->em, CD_MASK_BAREMESH);
+
+       data.vc = *vc;
+       data.func = func;
+       data.userData = userData;
+       data.clipVerts = clipVerts;
+
+       if (clipVerts != V3D_CLIP_TEST_OFF)
+               ED_view3d_clipping_local(vc->rv3d, vc->obedit->obmat);  /* for local clipping lookups */
+
+       EDBM_index_arrays_init(vc->em, 1, 0, 0);
+       dm->foreachMappedVert(dm, mesh_foreachScreenVert__mapFunc, &data);
+       EDBM_index_arrays_free(vc->em);
+
+       dm->release(dm);
+}
+
+/* ------------------------------------------------------------------------ */
+
+static void mesh_foreachScreenEdge__mapFunc(void *userData, int index, const float v0co[3], const float v1co[3])
+{
+       foreachScreenEdge_userData *data = userData;
+       BMEdge *eed = EDBM_edge_at_index(data->vc.em, index);
+
+       if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) {
+               float screen_co_a[2];
+               float screen_co_b[2];
+
+               const eV3DProjTest flag = (data->clipVerts == V3D_CLIP_TEST_RV3D_CLIPPING) ?
+                           V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN :
+                           V3D_PROJ_TEST_NOP;
+
+               if (ED_view3d_project_float_object(data->vc.ar, v0co, screen_co_a, flag) != V3D_PROJ_RET_OK) {
+                       return;
+               }
+               if (ED_view3d_project_float_object(data->vc.ar, v1co, screen_co_b, flag) != V3D_PROJ_RET_OK) {
+                       return;
+               }
+
+               if (data->clipVerts == V3D_CLIP_TEST_RV3D_CLIPPING) {
+                       /* pass */
+               }
+               else {
+                       if (data->clipVerts == V3D_CLIP_TEST_REGION) {
+                               if (!BLI_rctf_isect_segment(&data->win_rect, screen_co_a, screen_co_b)) {
+                                       return;
+                               }
+                       }
+               }
+
+               data->func(data->userData, eed, screen_co_a, screen_co_b, index);
+       }
+}
+
+void mesh_foreachScreenEdge(
+        ViewContext *vc,
+        void (*func)(void *userData, BMEdge *eed, const float screen_co_a[2], const float screen_co_b[2], int index),
+        void *userData, eV3DClipTest clipVerts)
+{
+       foreachScreenEdge_userData data;
+       DerivedMesh *dm = editbmesh_get_derived_cage(vc->scene, vc->obedit, vc->em, CD_MASK_BAREMESH);
+
+       data.vc = *vc;
+
+       data.win_rect.xmin = 0;
+       data.win_rect.ymin = 0;
+       data.win_rect.xmax = vc->ar->winx;
+       data.win_rect.ymax = vc->ar->winy;
+
+       data.func = func;
+       data.userData = userData;
+       data.clipVerts = clipVerts;
+
+       if (clipVerts != V3D_CLIP_TEST_OFF)
+               ED_view3d_clipping_local(vc->rv3d, vc->obedit->obmat);  /* for local clipping lookups */
+
+       EDBM_index_arrays_init(vc->em, 0, 1, 0);
+       dm->foreachMappedEdge(dm, mesh_foreachScreenEdge__mapFunc, &data);
+       EDBM_index_arrays_free(vc->em);
+
+       dm->release(dm);
+}
+
+/* ------------------------------------------------------------------------ */
+
+static void mesh_foreachScreenFace__mapFunc(void *userData, int index, const float cent[3], const float UNUSED(no[3]))
+{
+       foreachScreenFace_userData *data = userData;
+       BMFace *efa = EDBM_face_at_index(data->vc.em, index);
+
+       if (efa && !BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
+               float screen_co[2];
+               if (ED_view3d_project_float_object(data->vc.ar, cent, screen_co,
+                                                  V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
+               {
+                       data->func(data->userData, efa, screen_co, index);
+               }
+       }
+}
+
+void mesh_foreachScreenFace(
+        ViewContext *vc,
+        void (*func)(void *userData, BMFace *efa, const float screen_co_b[2], int index),
+        void *userData)
+{
+       foreachScreenFace_userData data;
+       DerivedMesh *dm = editbmesh_get_derived_cage(vc->scene, vc->obedit, vc->em, CD_MASK_BAREMESH);
+
+       data.vc = *vc;
+       data.func = func;
+       data.userData = userData;
+
+       ED_view3d_init_mats_rv3d(vc->obedit, vc->rv3d);
+
+       EDBM_index_arrays_init(vc->em, 0, 0, 1);
+       dm->foreachMappedFaceCenter(dm, mesh_foreachScreenFace__mapFunc, &data);
+       EDBM_index_arrays_free(vc->em);
+
+       dm->release(dm);
+}
+
+/* ------------------------------------------------------------------------ */
+
+void nurbs_foreachScreenVert(
+        ViewContext *vc,
+        void (*func)(void *userData, Nurb *nu, BPoint *bp, BezTriple *bezt, int beztindex, const float screen_co_b[2]),
+        void *userData)
+{
+       Curve *cu = vc->obedit->data;
+       Nurb *nu;
+       int i;
+       ListBase *nurbs = BKE_curve_editNurbs_get(cu);
+
+       ED_view3d_clipping_local(vc->rv3d, vc->obedit->obmat); /* for local clipping lookups */
+
+       for (nu = nurbs->first; nu; nu = nu->next) {
+               if (nu->type == CU_BEZIER) {
+                       for (i = 0; i < nu->pntsu; i++) {
+                               BezTriple *bezt = &nu->bezt[i];
+
+                               if (bezt->hide == 0) {
+                                       float screen_co[2];
+
+                                       if (cu->drawflag & CU_HIDE_HANDLES) {
+                                               if (ED_view3d_project_float_object(vc->ar, bezt->vec[1], screen_co,
+                                                                                  V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
+                                               {
+                                                       func(userData, nu, NULL, bezt, 1, screen_co);
+                                               }
+                                       }
+                                       else {
+                                               if (ED_view3d_project_float_object(vc->ar, bezt->vec[0], screen_co,
+                                                                                  V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
+                                               {
+                                                       func(userData, nu, NULL, bezt, 0, screen_co);
+                                               }
+                                               if (ED_view3d_project_float_object(vc->ar, bezt->vec[1], screen_co,
+                                                                                  V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
+                                               {
+                                                       func(userData, nu, NULL, bezt, 1, screen_co);
+                                               }
+                                               if (ED_view3d_project_float_object(vc->ar, bezt->vec[2], screen_co,
+                                                                                  V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
+                                               {
+                                                       func(userData, nu, NULL, bezt, 2, screen_co);
+                                               }
+                                       }
+                               }
+                       }
+               }
+               else {
+                       for (i = 0; i < nu->pntsu * nu->pntsv; i++) {
+                               BPoint *bp = &nu->bp[i];
+
+                               if (bp->hide == 0) {
+                                       float screen_co[2];
+                                       if (ED_view3d_project_float_object(vc->ar, bp->vec, screen_co,
+                                                                          V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
+                                       {
+                                               func(userData, nu, bp, NULL, -1, screen_co);
+                                       }
+                               }
+                       }
+               }
+       }
+}
+
+/* ------------------------------------------------------------------------ */
+
+/* ED_view3d_init_mats_rv3d must be called first */
+void mball_foreachScreenElem(
+        struct ViewContext *vc,
+        void (*func)(void *userData, struct MetaElem *ml, const float screen_co_b[2]),
+        void *userData)
+{
+       MetaBall *mb = (MetaBall *)vc->obedit->data;
+       MetaElem *ml;
+
+       for (ml = mb->editelems->first; ml; ml = ml->next) {
+               float screen_co[2];
+               if (ED_view3d_project_float_object(vc->ar, &ml->x, screen_co,
+                                                  V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
+               {
+                       func(userData, ml, screen_co);
+               }
+       }
+}
+
+/* ------------------------------------------------------------------------ */
+
+void lattice_foreachScreenVert(ViewContext *vc, void (*func)(void *userData, BPoint *bp, const float screen_co[2]), void *userData)
+{
+       Object *obedit = vc->obedit;
+       Lattice *lt = obedit->data;
+       BPoint *bp = lt->editlatt->latt->def;
+       DispList *dl = BKE_displist_find(&obedit->disp, DL_VERTS);
+       float *co = dl ? dl->verts : NULL;
+       int i, N = lt->editlatt->latt->pntsu * lt->editlatt->latt->pntsv * lt->editlatt->latt->pntsw;
+
+       ED_view3d_clipping_local(vc->rv3d, obedit->obmat); /* for local clipping lookups */
+
+       for (i = 0; i < N; i++, bp++, co += 3) {
+               if (bp->hide == 0) {
+                       float screen_co[2];
+                       if (ED_view3d_project_float_object(vc->ar, dl ? co : bp->vec, screen_co,
+                                                          V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
+                       {
+                               func(userData, bp, screen_co);
+                       }
+               }
+       }
+}
+
+/* ------------------------------------------------------------------------ */
+
+/* ED_view3d_init_mats_rv3d must be called first */
+void armature_foreachScreenBone(
+        struct ViewContext *vc,
+        void (*func)(void *userData, struct EditBone *ebone, const float screen_co_a[2], const float screen_co_b[2]),
+        void *userData)
+{
+       bArmature *arm = vc->obedit->data;
+       EditBone *ebone;
+
+       for (ebone = arm->edbo->first; ebone; ebone = ebone->next) {
+               if (EBONE_VISIBLE(arm, ebone)) {
+                       float screen_co_a[2], screen_co_b[2];
+                       int points_proj_tot = 0;
+
+                       /* project head location to screenspace */
+                       if (ED_view3d_project_float_object(vc->ar, ebone->head, screen_co_a,
+                                                          V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
+                       {
+                               points_proj_tot++;
+                       }
+                       else {
+                               screen_co_a[0] = IS_CLIPPED;  /* weak */
+                               /* screen_co_a[1]: intentionally dont set this so we get errors on misuse */
+                       }
+
+                       /* project tail location to screenspace */
+                       if (ED_view3d_project_float_object(vc->ar, ebone->tail, screen_co_b,
+                                                          V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
+                       {
+                               points_proj_tot++;
+                       }
+                       else {
+                               screen_co_b[0] = IS_CLIPPED;  /* weak */
+                               /* screen_co_b[1]: intentionally dont set this so we get errors on misuse */
+                       }
+
+                       if (points_proj_tot) {  /* at least one point's projection worked */
+                               func(userData, ebone, screen_co_a, screen_co_b);
+                       }
+               }
+       }
+}
+
+/* ------------------------------------------------------------------------ */
+
+/* ED_view3d_init_mats_rv3d must be called first */
+/* almost _exact_ copy of #armature_foreachScreenBone */
+void pose_foreachScreenBone(
+        struct ViewContext *vc,
+        void (*func)(void *userData, struct bPoseChannel *pchan, const float screen_co_a[2], const float screen_co_b[2]),
+        void *userData)
+{
+       bArmature *arm = vc->obact->data;
+       bPose *pose = vc->obact->pose;
+       bPoseChannel *pchan;
+
+       for (pchan = pose->chanbase.first; pchan; pchan = pchan->next) {
+               if (PBONE_VISIBLE(arm, pchan->bone)) {
+                       float screen_co_a[2], screen_co_b[2];
+                       int points_proj_tot = 0;
+
+                       /* project head location to screenspace */
+                       if (ED_view3d_project_float_object(vc->ar, pchan->pose_head, screen_co_a,
+                                                          V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
+                       {
+                               points_proj_tot++;
+                       }
+                       else {
+                               screen_co_a[0] = IS_CLIPPED;  /* weak */
+                               /* screen_co_a[1]: intentionally dont set this so we get errors on misuse */
+                       }
+
+                       /* project tail location to screenspace */
+                       if (ED_view3d_project_float_object(vc->ar, pchan->pose_tail, screen_co_b,
+                                                          V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
+                       {
+                               points_proj_tot++;
+                       }
+                       else {
+                               screen_co_b[0] = IS_CLIPPED;  /* weak */
+                               /* screen_co_b[1]: intentionally dont set this so we get errors on misuse */
+                       }
+
+                       if (points_proj_tot) {  /* at least one point's projection worked */
+                               func(userData, pchan, screen_co_a, screen_co_b);
+                       }
+               }
+       }
+}
index fb308db09268ec8805ea8be23017e976efe9c335..eb17aa2b8ceabaece03977b04d40b698106c48ca 100644 (file)
  *  \ingroup spview3d
  */
 
-
-#include <string.h>
-#include <math.h>
-
 #include "MEM_guardedalloc.h"
 
 #include "DNA_camera_types.h"
 #include "DNA_lattice_types.h"
 #include "DNA_material_types.h"
 #include "DNA_mesh_types.h"
-#include "DNA_meshdata_types.h"
 #include "DNA_meta_types.h"
 #include "DNA_scene_types.h"
 #include "DNA_smoke_types.h"
-#include "DNA_speaker_types.h"
 #include "DNA_world_types.h"
-#include "DNA_armature_types.h"
 #include "DNA_object_types.h"
 
-#include "BLI_utildefines.h"
 #include "BLI_blenlib.h"
 #include "BLI_math.h"
-#include "BLI_edgehash.h"
-#include "BLI_rand.h"
-#include "BLI_utildefines.h"
 
 #include "BKE_anim.h"  /* for the where_on_path function */
 #include "BKE_armature.h"
 #include "BKE_pointcache.h"
 #include "BKE_scene.h"
 #include "BKE_unit.h"
-#include "BKE_movieclip.h"
 #include "BKE_tracking.h"
 
 #include "BKE_tessmesh.h"
 
-#include "smoke_API.h"
-
 #include "IMB_imbuf.h"
 #include "IMB_imbuf_types.h"
 
 #include "ED_screen.h"
 #include "ED_sculpt.h"
 #include "ED_types.h"
-#include "ED_curve.h" /* for curve_editnurbs */
-#include "ED_armature.h"
 
 #include "UI_resources.h"
 
 #include "WM_api.h"
-#include "wm_subwindow.h"
 #include "BLF_api.h"
 
-#include "view3d_intern.h"  /* own include */
+#include "view3d_intern.h"  /* bad level include */
 
 typedef enum eWireDrawMode {
        OBDRAW_WIRE_OFF = 0,
@@ -117,28 +100,6 @@ typedef enum eWireDrawMode {
        OBDRAW_WIRE_ON_DEPTH = 2
 } eWireDrawMode;
 
-/* user data structures for derived mesh callbacks */
-typedef struct foreachScreenVert_userData {
-       void (*func)(void *userData, BMVert *eve, const float screen_co_b[2], int index);
-       void *userData;
-       ViewContext vc;
-       eV3DClipTest clipVerts;
-} foreachScreenVert_userData;
-
-typedef struct foreachScreenEdge_userData {
-       void (*func)(void *userData, BMEdge *eed, const float screen_co_a[2], const float screen_co_b[2], int index);
-       void *userData;
-       ViewContext vc;
-       rctf win_rect; /* copy of: vc.ar->winx/winy, use for faster tests, minx/y will always be 0 */
-       eV3DClipTest clipVerts;
-} foreachScreenEdge_userData;
-
-typedef struct foreachScreenFace_userData {
-       void (*func)(void *userData, BMFace *efa, const float screen_co_b[2], int index);
-       void *userData;
-       ViewContext vc;
-} foreachScreenFace_userData;
-
 typedef struct drawDMVerts_userData {
        BMEditMesh *em; /* BMESH BRANCH ONLY */
 
@@ -1870,29 +1831,6 @@ static void lattice_draw_verts(Lattice *lt, DispList *dl, short sel)
        bglEnd();
 }
 
-void lattice_foreachScreenVert(ViewContext *vc, void (*func)(void *userData, BPoint *bp, const float screen_co[2]), void *userData)
-{
-       Object *obedit = vc->obedit;
-       Lattice *lt = obedit->data;
-       BPoint *bp = lt->editlatt->latt->def;
-       DispList *dl = BKE_displist_find(&obedit->disp, DL_VERTS);
-       float *co = dl ? dl->verts : NULL;
-       int i, N = lt->editlatt->latt->pntsu * lt->editlatt->latt->pntsv * lt->editlatt->latt->pntsw;
-
-       ED_view3d_clipping_local(vc->rv3d, obedit->obmat); /* for local clipping lookups */
-
-       for (i = 0; i < N; i++, bp++, co += 3) {
-               if (bp->hide == 0) {
-                       float screen_co[2];
-                       if (ED_view3d_project_float_object(vc->ar, dl ? co : bp->vec, screen_co,
-                                                          V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
-                       {
-                               func(userData, bp, screen_co);
-                       }
-               }
-       }
-}
-
 static void drawlattice__point(Lattice *lt, DispList *dl, int u, int v, int w, int use_wcol)
 {
        int index = ((w * lt->pntsv + v) * lt->pntsu) + u;
@@ -1979,53 +1917,6 @@ static void drawlattice(Scene *scene, View3D *v3d, Object *ob)
 
 /* ***************** ******************** */
 
-/* Note! - foreach funcs should be called while drawing or directly after
- * if not, ED_view3d_init_mats_rv3d() can be used for selection tools
- * but would not give correct results with dupli's for eg. which don't
- * use the object matrix in the usual way */
-static void mesh_foreachScreenVert__mapFunc(void *userData, int index, const float co[3],
-                                            const float UNUSED(no_f[3]), const short UNUSED(no_s[3]))
-{
-       foreachScreenVert_userData *data = userData;
-       BMVert *eve = EDBM_vert_at_index(data->vc.em, index);
-
-       if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) {
-               const eV3DProjTest flag = (data->clipVerts == V3D_CLIP_TEST_OFF) ?
-                           V3D_PROJ_TEST_NOP :
-                           V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN;
-               float screen_co[2];
-
-               if (ED_view3d_project_float_object(data->vc.ar, co, screen_co, flag) != V3D_PROJ_RET_OK) {
-                       return;
-               }
-
-               data->func(data->userData, eve, screen_co, index);
-       }
-}
-
-void mesh_foreachScreenVert(
-        ViewContext *vc,
-        void (*func)(void *userData, BMVert *eve, const float screen_co[2], int index),
-        void *userData, eV3DClipTest clipVerts)
-{
-       foreachScreenVert_userData data;
-       DerivedMesh *dm = editbmesh_get_derived_cage(vc->scene, vc->obedit, vc->em, CD_MASK_BAREMESH);
-       
-       data.vc = *vc;
-       data.func = func;
-       data.userData = userData;
-       data.clipVerts = clipVerts;
-
-       if (clipVerts != V3D_CLIP_TEST_OFF)
-               ED_view3d_clipping_local(vc->rv3d, vc->obedit->obmat);  /* for local clipping lookups */
-
-       EDBM_index_arrays_init(vc->em, 1, 0, 0);
-       dm->foreachMappedVert(dm, mesh_foreachScreenVert__mapFunc, &data);
-       EDBM_index_arrays_free(vc->em);
-
-       dm->release(dm);
-}
-
 /*  draw callback */
 static void drawSelectedVertices__mapFunc(void *userData, int index, const float co[3],
                                           const float UNUSED(no_f[3]), const short UNUSED(no_s[3]))
@@ -2054,277 +1945,6 @@ static void drawSelectedVertices(DerivedMesh *dm, Mesh *me)
        glEnd();
 }
 
-static void mesh_foreachScreenEdge__mapFunc(void *userData, int index, const float v0co[3], const float v1co[3])
-{
-       foreachScreenEdge_userData *data = userData;
-       BMEdge *eed = EDBM_edge_at_index(data->vc.em, index);
-
-       if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) {
-               float screen_co_a[2];
-               float screen_co_b[2];
-
-               const eV3DProjTest flag = (data->clipVerts == V3D_CLIP_TEST_RV3D_CLIPPING) ?
-                           V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN :
-                           V3D_PROJ_TEST_NOP;
-
-               if (ED_view3d_project_float_object(data->vc.ar, v0co, screen_co_a, flag) != V3D_PROJ_RET_OK) {
-                       return;
-               }
-               if (ED_view3d_project_float_object(data->vc.ar, v1co, screen_co_b, flag) != V3D_PROJ_RET_OK) {
-                       return;
-               }
-
-               if (data->clipVerts == V3D_CLIP_TEST_RV3D_CLIPPING) {
-                       /* pass */
-               }
-               else {
-                       if (data->clipVerts == V3D_CLIP_TEST_REGION) {
-                               if (!BLI_rctf_isect_segment(&data->win_rect, screen_co_a, screen_co_b)) {
-                                       return;
-                               }
-                       }
-               }
-
-               data->func(data->userData, eed, screen_co_a, screen_co_b, index);
-       }
-}
-
-void mesh_foreachScreenEdge(
-        ViewContext *vc,
-        void (*func)(void *userData, BMEdge *eed, const float screen_co_a[2], const float screen_co_b[2], int index),
-        void *userData, eV3DClipTest clipVerts)
-{
-       foreachScreenEdge_userData data;
-       DerivedMesh *dm = editbmesh_get_derived_cage(vc->scene, vc->obedit, vc->em, CD_MASK_BAREMESH);
-
-       data.vc = *vc;
-
-       data.win_rect.xmin = 0;
-       data.win_rect.ymin = 0;
-       data.win_rect.xmax = vc->ar->winx;
-       data.win_rect.ymax = vc->ar->winy;
-
-       data.func = func;
-       data.userData = userData;
-       data.clipVerts = clipVerts;
-
-       if (clipVerts != V3D_CLIP_TEST_OFF)
-               ED_view3d_clipping_local(vc->rv3d, vc->obedit->obmat);  /* for local clipping lookups */
-
-       EDBM_index_arrays_init(vc->em, 0, 1, 0);
-       dm->foreachMappedEdge(dm, mesh_foreachScreenEdge__mapFunc, &data);
-       EDBM_index_arrays_free(vc->em);
-
-       dm->release(dm);
-}
-
-static void mesh_foreachScreenFace__mapFunc(void *userData, int index, const float cent[3], const float UNUSED(no[3]))
-{
-       foreachScreenFace_userData *data = userData;
-       BMFace *efa = EDBM_face_at_index(data->vc.em, index);
-
-       if (efa && !BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
-               float screen_co[2];
-               if (ED_view3d_project_float_object(data->vc.ar, cent, screen_co,
-                                                  V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
-               {
-                       data->func(data->userData, efa, screen_co, index);
-               }
-       }
-}
-
-void mesh_foreachScreenFace(
-        ViewContext *vc,
-        void (*func)(void *userData, BMFace *efa, const float screen_co_b[2], int index),
-        void *userData)
-{
-       foreachScreenFace_userData data;
-       DerivedMesh *dm = editbmesh_get_derived_cage(vc->scene, vc->obedit, vc->em, CD_MASK_BAREMESH);
-
-       data.vc = *vc;
-       data.func = func;
-       data.userData = userData;
-
-       ED_view3d_init_mats_rv3d(vc->obedit, vc->rv3d);
-
-       EDBM_index_arrays_init(vc->em, 0, 0, 1);
-       dm->foreachMappedFaceCenter(dm, mesh_foreachScreenFace__mapFunc, &data);
-       EDBM_index_arrays_free(vc->em);
-
-       dm->release(dm);
-}
-
-void nurbs_foreachScreenVert(
-        ViewContext *vc,
-        void (*func)(void *userData, Nurb *nu, BPoint *bp, BezTriple *bezt, int beztindex, const float screen_co_b[2]),
-        void *userData)
-{
-       Curve *cu = vc->obedit->data;
-       Nurb *nu;
-       int i;
-       ListBase *nurbs = BKE_curve_editNurbs_get(cu);
-
-       ED_view3d_clipping_local(vc->rv3d, vc->obedit->obmat); /* for local clipping lookups */
-
-       for (nu = nurbs->first; nu; nu = nu->next) {
-               if (nu->type == CU_BEZIER) {
-                       for (i = 0; i < nu->pntsu; i++) {
-                               BezTriple *bezt = &nu->bezt[i];
-
-                               if (bezt->hide == 0) {
-                                       float screen_co[2];
-                                       
-                                       if (cu->drawflag & CU_HIDE_HANDLES) {
-                                               if (ED_view3d_project_float_object(vc->ar, bezt->vec[1], screen_co,
-                                                                                  V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
-                                               {
-                                                       func(userData, nu, NULL, bezt, 1, screen_co);
-                                               }
-                                       }
-                                       else {
-                                               if (ED_view3d_project_float_object(vc->ar, bezt->vec[0], screen_co,
-                                                                                  V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
-                                               {
-                                                       func(userData, nu, NULL, bezt, 0, screen_co);
-                                               }
-                                               if (ED_view3d_project_float_object(vc->ar, bezt->vec[1], screen_co,
-                                                                                  V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
-                                               {
-                                                       func(userData, nu, NULL, bezt, 1, screen_co);
-                                               }
-                                               if (ED_view3d_project_float_object(vc->ar, bezt->vec[2], screen_co,
-                                                                                  V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
-                                               {
-                                                       func(userData, nu, NULL, bezt, 2, screen_co);
-                                               }
-                                       }
-                               }
-                       }
-               }
-               else {
-                       for (i = 0; i < nu->pntsu * nu->pntsv; i++) {
-                               BPoint *bp = &nu->bp[i];
-
-                               if (bp->hide == 0) {
-                                       float screen_co[2];
-                                       if (ED_view3d_project_float_object(vc->ar, bp->vec, screen_co,
-                                                                          V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
-                                       {
-                                               func(userData, nu, bp, NULL, -1, screen_co);
-                                       }
-                               }
-                       }
-               }
-       }
-}
-
-/* ED_view3d_init_mats_rv3d must be called first */
-void mball_foreachScreenElem(
-        struct ViewContext *vc,
-        void (*func)(void *userData, struct MetaElem *ml, const float screen_co_b[2]),
-        void *userData)
-{
-       MetaBall *mb = (MetaBall *)vc->obedit->data;
-       MetaElem *ml;
-
-       for (ml = mb->editelems->first; ml; ml = ml->next) {
-               float screen_co[2];
-               if (ED_view3d_project_float_object(vc->ar, &ml->x, screen_co,
-                                                  V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
-               {
-                       func(userData, ml, screen_co);
-               }
-       }
-}
-
-/* ED_view3d_init_mats_rv3d must be called first */
-void armature_foreachScreenBone(
-        struct ViewContext *vc,
-        void (*func)(void *userData, struct EditBone *ebone, const float screen_co_a[2], const float screen_co_b[2]),
-        void *userData)
-{
-       bArmature *arm = vc->obedit->data;
-       EditBone *ebone;
-
-       for (ebone = arm->edbo->first; ebone; ebone = ebone->next) {
-               if (EBONE_VISIBLE(arm, ebone)) {
-                       float screen_co_a[2], screen_co_b[2];
-                       int points_proj_tot = 0;
-
-                       /* project head location to screenspace */
-                       if (ED_view3d_project_float_object(vc->ar, ebone->head, screen_co_a,
-                                                          V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
-                       {
-                               points_proj_tot++;
-                       }
-                       else {
-                               screen_co_a[0] = IS_CLIPPED;  /* weak */
-                               /* screen_co_a[1]: intentionally dont set this so we get errors on misuse */
-                       }
-
-                       /* project tail location to screenspace */
-                       if (ED_view3d_project_float_object(vc->ar, ebone->tail, screen_co_b,
-                                                          V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
-                       {
-                               points_proj_tot++;
-                       }
-                       else {
-                               screen_co_b[0] = IS_CLIPPED;  /* weak */
-                               /* screen_co_b[1]: intentionally dont set this so we get errors on misuse */
-                       }
-
-                       if (points_proj_tot) {  /* at least one point's projection worked */
-                               func(userData, ebone, screen_co_a, screen_co_b);
-                       }
-               }
-       }
-}
-
-/* ED_view3d_init_mats_rv3d must be called first */
-/* almost _exact_ copy of #armature_foreachScreenBone */
-void pose_foreachScreenBone(
-        struct ViewContext *vc,
-        void (*func)(void *userData, struct bPoseChannel *pchan, const float screen_co_a[2], const float screen_co_b[2]),
-        void *userData)
-{
-       bArmature *arm = vc->obact->data;
-       bPose *pose = vc->obact->pose;
-       bPoseChannel *pchan;
-
-       for (pchan = pose->chanbase.first; pchan; pchan = pchan->next) {
-               if (PBONE_VISIBLE(arm, pchan->bone)) {
-                       float screen_co_a[2], screen_co_b[2];
-                       int points_proj_tot = 0;
-
-                       /* project head location to screenspace */
-                       if (ED_view3d_project_float_object(vc->ar, pchan->pose_head, screen_co_a,
-                                                          V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
-                       {
-                               points_proj_tot++;
-                       }
-                       else {
-                               screen_co_a[0] = IS_CLIPPED;  /* weak */
-                               /* screen_co_a[1]: intentionally dont set this so we get errors on misuse */
-                       }
-
-                       /* project tail location to screenspace */
-                       if (ED_view3d_project_float_object(vc->ar, pchan->pose_tail, screen_co_b,
-                                                          V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
-                       {
-                               points_proj_tot++;
-                       }
-                       else {
-                               screen_co_b[0] = IS_CLIPPED;  /* weak */
-                               /* screen_co_b[1]: intentionally dont set this so we get errors on misuse */
-                       }
-
-                       if (points_proj_tot) {  /* at least one point's projection worked */
-                               func(userData, pchan, screen_co_a, screen_co_b);
-                       }
-               }
-       }
-}
-
 /* ************** DRAW MESH ****************** */
 
 /* First section is all the "simple" draw routines,