griefith/test2
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

code cleanup: split foreach object data iterator functions out of drawobject.c (since they are used for selection too), into their own file: object_iterators.c

Browse Source
This commit is contained in:
Campbell Barton
2012-10-10 03:13:02 +00:00
parent b3bf6b527b
commit 22bf1e13db
6 changed files with 496 additions and 403 deletions
Download Patch File Download Diff File Expand all files Collapse all files

68
source/blender/editors/include/ED_object.h
View File

@@ -35,22 +35,31 @@
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

18
source/blender/editors/include/ED_view3d.h
View 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);

1
source/blender/editors/mesh/editmesh_select.c
View 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"

1
source/blender/editors/object/CMakeLists.txt
View 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

429
source/blender/editors/object/object_iterators.c Normal file
View File

@@ -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);
}
}
}
}

382
source/blender/editors/space_view3d/drawobject.c
View File

@@ -27,10 +27,6 @@
* \ingroup spview3d
*/
#include <string.h>
#include <math.h>
#include "MEM_guardedalloc.h"
#include "DNA_camera_types.h"
@@ -40,21 +36,14 @@
#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"
@@ -79,13 +68,10 @@
#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"
@@ -100,16 +86,13 @@
#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,