Differential D2795 Diff 9167 source/blender/editors/transform/transform_snap_object.c

Changeset View

Standalone View

source/blender/editors/transform/transform_snap_object.c

Context not available.
	#include "DNA_curve_types.h"	#include "DNA_curve_types.h"
	#include "DNA_scene_types.h"	#include "DNA_scene_types.h"
	#include "DNA_object_types.h"	#include "DNA_object_types.h"
		#include "DNA_mesh_types.h"
	#include "DNA_meshdata_types.h"	#include "DNA_meshdata_types.h"
	#include "DNA_screen_types.h"	#include "DNA_screen_types.h"
	#include "DNA_view3d_types.h"	#include "DNA_view3d_types.h"
Context not available.
	#include "BKE_anim.h" /* for duplis */	#include "BKE_anim.h" /* for duplis */
	#include "BKE_editmesh.h"	#include "BKE_editmesh.h"
	#include "BKE_main.h"	#include "BKE_main.h"
		#include "BKE_mesh.h"
	#include "BKE_tracking.h"	#include "BKE_tracking.h"
	#include "BKE_context.h"	#include "BKE_context.h"

	#include "DEG_depsgraph.h"	#include "DEG_depsgraph.h"

	#include "ED_transform.h"	#include "ED_armature.h"
		#include "ED_space_api.h"
	#include "ED_transform_snap_object_context.h"	#include "ED_transform_snap_object_context.h"
	#include "ED_view3d.h"	#include "ED_view3d.h"
	#include "ED_armature.h"

	#include "transform.h"	#include <GL/glew.h>
		#include "GPU_draw.h"
	enum eViewProj {	#include "GPU_shader.h"
	VIEW_PROJ_NONE = -1,	#include "GPU_framebuffer.h"
	VIEW_PROJ_ORTHO = 0,	#include "GPU_texture.h"
	VIEW_PROJ_PERSP = -1,	#include "GPU_matrix.h"
	};

	typedef struct SnapData {	#define DRAW_FRAMEBUFFER_ON_SCREEN 1 /* For DEBUG */
	short snap_to;	#define SNAP_VERT 1 << 0
	float mval[2];	#define SNAP_EDGE 1 << 1
	float ray_origin[3];	#define SNAP_FACE 1 << 2
	float ray_start[3];
	float ray_dir[3];
	float pmat[4][4]; /* perspective matrix */
	float win_half[2];/* win x and y */
	enum eViewProj view_proj;
	float depth_range[2];
	} SnapData;

	typedef struct SnapObjectData {	typedef struct SnapObjectData {
	enum {	enum {
	SNAP_MESH = 1,	SNAP_MESH = 1,
	SNAP_EDIT_MESH,	SNAP_EDIT_MESH,
	} type;	} type;
	} SnapObjectData;

	typedef struct SnapObjectData_Mesh {	union {
	SnapObjectData sd;	BVHTreeFromMesh from_mesh;
	BVHTreeFromMesh *bvh_trees[3];	BVHTreeFromEditMesh from_editmesh;
	MPoly *mpoly;	} bvhtree;
	bool poly_allocated;
		int vao;
		int vbo;
		int ebo_tris;
		int ebo_edges;
		int ebo_verts;

		uint vbo_len_capacity;
		uint tot_tri_elem;
		uint tot_edge_elem;
		uint tot_vert_elem;

		} SnapObjectData;

	} SnapObjectData_Mesh;

	typedef struct SnapObjectData_EditMesh {	typedef struct SnapObjectDraw {
	SnapObjectData sd;	struct SnapObjectDraw next, prev;
	BVHTreeFromEditMesh *bvh_trees[3];	unsigned int index_offset;
		float obmat[4][4];
		Object *ob;
		SnapObjectData *sod;
		} SnapObjectDraw;

	} SnapObjectData_EditMesh;

	struct SnapObjectContext {	struct SnapObjectContext {
	Main *bmain;	Main *bmain;
	Scene *scene;	Scene *scene;
	EvaluationContext eval_ctx;	EvaluationContext eval_ctx;

	int flag;	SnapSelect snap_select;
		bool use_object_edit_cage;

	/* Optional: when performing screen-space projection.	/* Optional: when performing screen-space projection.
	* otherwise this doesn't take viewport into account. */	* otherwise this doesn't take viewport into account. */
Context not available.
	MemArena *mem_arena;	MemArena *mem_arena;
	} cache;	} cache;

		struct {
		unsigned short snap_to_flag;
		float dist_px;
		float pmat[4][4]; /* To check the drawing must be updated */
		float pmat_resized[4][4]; /* Projection matrix with edge offset values applied */
		float mval[2];
		float ray_orig[3];
		float ray_dir[3];
		float depth_range[2];

		ListBase snap_obj_list; /* SnapObjectDraw - Same objects, but with different matrices */
		SnapObjectDraw last_sodraw; / Last object that was drawn - for index_offset */
		} dinamic;

	/* Filter data, returns true to check this value */	/* Filter data, returns true to check this value */
	struct {	struct {
	struct {	struct {
Context not available.
	} edit_mesh;	} edit_mesh;
	} callbacks;	} callbacks;

		bool nearest2d_inited;
		struct {
		GPUFrameBuffer *fbo;
		GPUTexture *depth;
		GPUTexture *indices;
		int sizex, sizey;
		int out_bound_dist; /* search for out-of-bounds elements */
		} fbo;

		GPUShader *tris_depth_shader;
		GPUShader *indices_shader;

		#ifdef DRAW_FRAMEBUFFER_ON_SCREEN
		GLuint debug_program;
		GLuint debug_vert;
		GLuint debug_geom;
		GLuint debug_frag;
		GLuint debug_vao;
		void *draw_callback_px;
		#endif
	};	};

		#if DRAW_FRAMEBUFFER_ON_SCREEN
		static void snap_object_draw_callback(const struct bContext UNUSED(C), ARegion UNUSED(ar), void *userdata)
		{
		SnapObjectContext *sctx = userdata;
		glUseProgram(sctx->debug_program);
		GPU_texture_bind(sctx->fbo.indices, 0);
		int viewport[4];
		glGetIntegerv(GL_VIEWPORT, viewport);
		viewport[0] -= sctx->fbo.out_bound_dist;
		viewport[1] -= sctx->fbo.out_bound_dist;
		glUniform4iv(glGetUniformLocation(sctx->debug_program, "viewport"), 1, viewport);
		glBindVertexArray(sctx->debug_vao);
		glDrawArrays(GL_POINTS, 0, 1);
		GPU_texture_unbind(sctx->fbo.indices);
		glEnable(GL_DEPTH_TEST);
		}
		static void init_debug_drawing(SnapObjectContext *sctx)
		{
		const char *screen_vertSrc =
		"#version 330 core\n"
		"void main(){}";
		const char *screen_geomSrc =
		"#version 330 core\n"
		"layout(triangle_strip, max_vertices = 4) out;"
		"void main() {"
		" gl_Position = vec4(-1.0, -1.0, 0.0, 1.0);"
		" EmitVertex();"
		" gl_Position = vec4(-1.0, 3.0, 0.0, 1.0);"
		" EmitVertex();"
		" gl_Position = vec4(3.0, -1.0, 0.0, 1.0);"
		" EmitVertex();"
		" EndPrimitive();"
		"}";
		const char *screen_fragSrc =
		"#version 330 core\n"
		"out vec3 FragColor;"
		"uniform ivec4 viewport;"
		"uniform usampler2D screenTexture;"
		"void main() {"
		" ivec2 px_coord = ivec2(gl_FragCoord.x - viewport[0], gl_FragCoord.y - viewport[1]);"
		" uint index = texelFetch(screenTexture, px_coord, 0).r;"
		" if (index) {"
		" FragColor = vec3(0.0, 0.0, 0.0);"
		" if (index % 3 == 0) {"
		" FragColor[2] = 1.0;"
		" }"
		" else if (index % 2 == 0) {"
		" FragColor[1] = 1.0;"
		" }"
		" else {"
		" FragColor[0] = 1.0;"
		" }"
		" }"
		" else {"
		" discard;"
		" }"
		"}";
		sctx->debug_program = glCreateProgram();
		sctx->debug_vert = glCreateShader(GL_VERTEX_SHADER);
		sctx->debug_geom = glCreateShader(GL_GEOMETRY_SHADER);
		sctx->debug_frag = glCreateShader(GL_FRAGMENT_SHADER);
		glShaderSource(sctx->debug_vert, 1, &screen_vertSrc, NULL);
		glShaderSource(sctx->debug_geom, 1, &screen_geomSrc, NULL);
		glShaderSource(sctx->debug_frag, 1, &screen_fragSrc, NULL);
		glCompileShader(sctx->debug_vert);
		glCompileShader(sctx->debug_geom);
		glCompileShader(sctx->debug_frag);
		glAttachShader(sctx->debug_program, sctx->debug_vert);
		glAttachShader(sctx->debug_program, sctx->debug_geom);
		glAttachShader(sctx->debug_program, sctx->debug_frag);
		glLinkProgram(sctx->debug_program);
		glGenVertexArrays(1, &sctx->debug_vao);
		sctx->draw_callback_px = ED_region_draw_cb_activate(
		sctx->v3d_data.ar->type, snap_object_draw_callback, sctx, REGION_DRAW_POST_PIXEL);
		}
		static void destroy_debug_drawing(SnapObjectContext *sctx)
		{
		glDetachShader(sctx->debug_program, sctx->debug_vert);
		glDetachShader(sctx->debug_program, sctx->debug_geom);
		glDetachShader(sctx->debug_program, sctx->debug_frag);
		glDeleteShader(sctx->debug_vert);
		glDeleteShader(sctx->debug_geom);
		glDeleteShader(sctx->debug_frag);
		glDeleteProgram(sctx->debug_program);
		glDeleteVertexArrays(1, &sctx->debug_vao);
		ED_region_draw_cb_exit(sctx->v3d_data.ar->type, sctx->draw_callback_px);
		}

		static void UNUSED_print_array(unsigned int *array, int threshold)
		{
		printf("\n %d \n", threshold);
		for (int y = threshold - 1; y >= 0; y--) {
		for (int x = 0; x < threshold; x++) {
		unsigned int value = array[y * threshold + x];
		if (value) printf("%d", value);
		else printf(" ");
		}
		printf("\n");
		}
		}
		#endif

	/** \} */	/** \} */


Context not available.
	*/	*/
	static void iter_snap_objects(	static void iter_snap_objects(
	SnapObjectContext *sctx,	SnapObjectContext *sctx,
	const SnapSelect snap_select,
	Object *obedit,
	IterSnapObjsCallback sob_callback,	IterSnapObjsCallback sob_callback,
	void *data)	void *data)
	{	{
	Base *base_act = sctx->eval_ctx.scene_layer->basact;	Base *base_act = sctx->eval_ctx.scene_layer->basact;
		Object *obedit = sctx->use_object_edit_cage ? sctx->scene->obedit : NULL;
		SnapSelect snap_select = sctx->snap_select;
		bool use_obedit;

	/* Need an exception for particle edit because the base is flagged with BA_HAS_RECALC_DATA	/* Need an exception for particle edit because the base is flagged with BA_HAS_RECALC_DATA
	* which makes the loop skip it, even the derived mesh will never change	* which makes the loop skip it, even the derived mesh will never change
	*	*
Context not available.
	!((snap_select == SNAP_NOT_SELECTED && ((base->flag & BASE_SELECTED) \|\| (base->flag_legacy & BA_WAS_SEL))) \|\|	!((snap_select == SNAP_NOT_SELECTED && ((base->flag & BASE_SELECTED) \|\| (base->flag_legacy & BA_WAS_SEL))) \|\|
	(snap_select == SNAP_NOT_ACTIVE && base == base_act)))	(snap_select == SNAP_NOT_ACTIVE && base == base_act)))
	{	{
	bool use_obedit;
	Object *obj = base->object;	Object *obj = base->object;
	if (obj->transflag & OB_DUPLI) {	if (obj->transflag & OB_DUPLI) {
	DupliObject *dupli_ob;	DupliObject *dupli_ob;
	ListBase *lb = object_duplilist(&sctx->eval_ctx, sctx->scene, obj);	ListBase *lb = object_duplilist(sctx->bmain->eval_ctx, sctx->scene, obj);
	for (dupli_ob = lb->first; dupli_ob; dupli_ob = dupli_ob->next) {	for (dupli_ob = lb->first; dupli_ob; dupli_ob = dupli_ob->next) {
	use_obedit = obedit && dupli_ob->ob->data == obedit->data;	use_obedit = obedit && dupli_ob->ob->data == obedit->data;
	sob_callback(sctx, use_obedit, use_obedit ? obedit : dupli_ob->ob, dupli_ob->mat, data);	sob_callback(sctx, use_obedit, use_obedit ? obedit : dupli_ob->ob, dupli_ob->mat, data);
Context not available.
	}	}


	/**
	* Generates a struct with the immutable parameters that will be used on all objects.
	*
	* \param snap_to: Element to snap, Vertice, Edge or Face.
	* \param view_proj: ORTHO or PERSP.
	* Currently only works one at a time, but can eventually operate as flag.
	*
	* \param mval: Mouse coords.
	* (When NULL, ray-casting is handled without any projection matrix correction.)
	* \param ray_origin: ray_start before being moved toward the ray_normal at the distance from vew3d clip_min.
	* \param ray_start: ray_origin moved for the start clipping plane (clip_min).
	* \param ray_direction: Unit length direction of the ray.
	* \param depth_range: distances of clipe plane min and clip plane max;
	*/
	static void snap_data_set(
	SnapData *snapdata,
	const ARegion *ar, const unsigned short snap_to, const enum eViewProj view_proj,
	const float mval[2], const float ray_origin[3], const float ray_start[3],
	const float ray_direction[3], const float depth_range[2])
	{
	copy_m4_m4(snapdata->pmat, ((RegionView3D *)ar->regiondata)->persmat);
	snapdata->win_half[0] = ar->winx / 2;
	snapdata->win_half[1] = ar->winy / 2;
	copy_v2_v2(snapdata->mval, mval);
	snapdata->snap_to = snap_to;
	copy_v3_v3(snapdata->ray_origin, ray_origin);
	copy_v3_v3(snapdata->ray_start, ray_start);
	copy_v3_v3(snapdata->ray_dir, ray_direction);
	snapdata->view_proj = view_proj;
	copy_v2_v2(snapdata->depth_range, depth_range);
	}


	MINLINE float depth_get(const float co[3], const float ray_start[3], const float ray_dir[3])	MINLINE float depth_get(const float co[3], const float ray_start[3], const float ray_dir[3])
	{	{
	float dvec[3];	float dvec[3];
Context not available.
	}	}
	}	}


	static int dm_looptri_to_poly_index(DerivedMesh dm, const MLoopTri lt);

	/** \} */	/** \} */


Context not available.
	}	}


		static int dm_looptri_to_poly_index(DerivedMesh dm, const MLoopTri lt)
		{
		const int *index_mp_to_orig = dm->getPolyDataArray(dm, CD_ORIGINDEX);
		return index_mp_to_orig ? index_mp_to_orig[lt->poly] : lt->poly;
		}


	static bool raycastDerivedMesh(	static bool raycastDerivedMesh(
	SnapObjectContext *sctx,	SnapObjectContext *sctx,
	const float ray_start[3], const float ray_dir[3],	const float ray_start[3], const float ray_dir[3],
Context not available.
	}	}
	}	}

	SnapObjectData_Mesh *sod = NULL;	SnapObjectData *sod = NULL;
	BVHTreeFromMesh *treedata;	BVHTreeFromMesh *treedata;

	void **sod_p;	void **sod_p;
Context not available.
	}	}
	else {	else {
	sod = sod_p = BLI_memarena_calloc(sctx->cache.mem_arena, sizeof(sod));	sod = sod_p = BLI_memarena_calloc(sctx->cache.mem_arena, sizeof(sod));
	sod->sd.type = SNAP_MESH;	sod->type = SNAP_MESH;
	}

	if (sod->bvh_trees[2] == NULL) {
	sod->bvh_trees[2] = BLI_memarena_calloc(sctx->cache.mem_arena, sizeof(*treedata));
	}	}

	treedata = sod->bvh_trees[2];	treedata = &sod->bvhtree.from_mesh;

	if (treedata) {	/* the tree is owned by the DM and may have been freed since we last used! */
	/* the tree is owned by the DM and may have been freed since we last used! */	if (treedata->tree) {
	if (treedata->tree) {	if (treedata->cached && !bvhcache_has_tree(dm->bvhCache, treedata->tree)) {
	if (treedata->cached && !bvhcache_has_tree(dm->bvhCache, treedata->tree)) {	free_bvhtree_from_mesh(treedata);
	free_bvhtree_from_mesh(treedata);
	}
	else {
	if (treedata->vert == NULL) {
	treedata->vert = DM_get_vert_array(dm, &treedata->vert_allocated);
	}
	if (treedata->loop == NULL) {
	treedata->loop = DM_get_loop_array(dm, &treedata->loop_allocated);
	}
	if (treedata->looptri == NULL) {
	if (sod->mpoly == NULL) {
	sod->mpoly = DM_get_poly_array(dm, &sod->poly_allocated);
	}
	treedata->looptri = dm->getLoopTriArray(dm);
	treedata->looptri_allocated = false;
	}
	}
	}	}
		}

	if (treedata->tree == NULL) {	if (treedata->tree == NULL) {
	bvhtree_from_mesh_looptri(treedata, dm, 0.0f, 4, 6);	bvhtree_from_mesh_looptri(treedata, dm, 0.0f, 4, 6);

	if (treedata->tree == NULL) {	if (treedata->tree == NULL) {
	return retval;	return retval;
	}
	}	}
	}	}
	else {
	return retval;
	}

	/* Only use closer ray_start in case of ortho view! In perspective one, ray_start may already	/* Only use closer ray_start in case of ortho view! In perspective one, ray_start may already
	* been inside boundbox, leading to snap failures (see T38409).	* been inside boundbox, leading to snap failures (see T38409).
Context not available.
	if (len_diff == 0.0f) { /* do_ray_start_correction */	if (len_diff == 0.0f) { /* do_ray_start_correction */
	/* We need a reasonably valid len_diff in this case.	/* We need a reasonably valid len_diff in this case.
	* Get the distance to bvhtree root */	* Get the distance to bvhtree root */
	if (!isect_ray_bvhroot_v3(treedata->tree, ray_start_local, ray_normal_local, &len_diff)) {	if (!isect_ray_bvhroot_v3(treedata->tree, ray_start_local, ray_normal_local, &len_diff))
		{
	return retval;	return retval;
	}	}
	}	}
Context not available.
	return retval;	return retval;
	}	}

	SnapObjectData_EditMesh *sod = NULL;	SnapObjectData *sod = NULL;
	BVHTreeFromEditMesh *treedata = NULL;	BVHTreeFromEditMesh *treedata = NULL;

	void **sod_p;	void **sod_p;
Context not available.
	}	}
	else {	else {
	sod = sod_p = BLI_memarena_calloc(sctx->cache.mem_arena, sizeof(sod));	sod = sod_p = BLI_memarena_calloc(sctx->cache.mem_arena, sizeof(sod));
	sod->sd.type = SNAP_EDIT_MESH;	sod->type = SNAP_EDIT_MESH;
	}	}

	if (sod->bvh_trees[2] == NULL) {	treedata = &sod->bvhtree.from_editmesh;
	sod->bvh_trees[2] = BLI_memarena_calloc(sctx->cache.mem_arena, sizeof(*treedata));
	}
	treedata = sod->bvh_trees[2];

	if (treedata) {	if (treedata->tree == NULL) {
	if (treedata->tree == NULL) {	BLI_bitmap *elem_mask = NULL;
	BLI_bitmap *elem_mask = NULL;	int looptri_num_active = -1;
	int looptri_num_active = -1;

	if (sctx->callbacks.edit_mesh.test_face_fn) {
	elem_mask = BLI_BITMAP_NEW(em->tottri, __func__);
	looptri_num_active = BM_iter_mesh_bitmap_from_filter_tessface(
	em->bm, elem_mask,
	sctx->callbacks.edit_mesh.test_face_fn, sctx->callbacks.edit_mesh.user_data);
	}
	bvhtree_from_editmesh_looptri_ex(treedata, em, elem_mask, looptri_num_active, 0.0f, 4, 6, NULL);

	if (elem_mask) {	if (sctx->callbacks.edit_mesh.test_face_fn) {
	MEM_freeN(elem_mask);	elem_mask = BLI_BITMAP_NEW(em->tottri, __func__);
	}	looptri_num_active = BM_iter_mesh_bitmap_from_filter_tessface(
		em->bm, elem_mask,
		sctx->callbacks.edit_mesh.test_face_fn, sctx->callbacks.edit_mesh.user_data);
	}	}
	if (treedata->tree == NULL) {	bvhtree_from_editmesh_looptri_ex(treedata, em, elem_mask, looptri_num_active, 0.0f, 4, 6, NULL);
	return retval;
		if (elem_mask) {
		MEM_freeN(elem_mask);
	}	}
	}	}
	else {	if (treedata->tree == NULL) {
	return retval;	return retval;
	}	}

Context not available.
	if (sctx->use_v3d && !((RegionView3D )sctx->v3d_data.ar->regiondata)->is_persp) { / do_ray_start_correction */	if (sctx->use_v3d && !((RegionView3D )sctx->v3d_data.ar->regiondata)->is_persp) { / do_ray_start_correction */
	/* We need a reasonably valid len_diff in this case.	/* We need a reasonably valid len_diff in this case.
	* Get the distance to bvhtree root */	* Get the distance to bvhtree root */
	if (!isect_ray_bvhroot_v3(treedata->tree, ray_start_local, ray_normal_local, &len_diff)) {	if (!isect_ray_bvhroot_v3(treedata->tree, ray_start_local, ray_normal_local, &len_diff))
		{
	return retval;	return retval;
	}	}
	/* You need to make sure that ray_start is really far away,	/* You need to make sure that ray_start is really far away,
Context not available.
	retval = true;	retval = true;

	if (r_index) {	if (r_index) {
	*r_index = hit.index;	*r_index = BM_elem_index_get(em->looptris[hit.index][0]->f);
	}	}
	}	}
	}	}
Context not available.
	static bool raycastObjects(	static bool raycastObjects(
	SnapObjectContext *sctx,	SnapObjectContext *sctx,
	const float ray_start[3], const float ray_dir[3],	const float ray_start[3], const float ray_dir[3],
	const SnapSelect snap_select, const bool use_object_edit_cage,
	/* read/write args */	/* read/write args */
	float *ray_depth,	float *ray_depth,
	/* return args */	/* return args */
Context not available.
	Object **r_ob, float r_obmat[4][4],	Object **r_ob, float r_obmat[4][4],
	ListBase *r_hit_list)	ListBase *r_hit_list)
	{	{
	Object *obedit = use_object_edit_cage ? sctx->scene->obedit : NULL;

	struct RaycastObjUserData data = {	struct RaycastObjUserData data = {
	.ray_start = ray_start,	.ray_start = ray_start,
	.ray_dir = ray_dir,	.ray_dir = ray_dir,
Context not available.
	.ret = false,	.ret = false,
	};	};

	iter_snap_objects(sctx, snap_select, obedit, raycast_obj_cb, &data);	iter_snap_objects(sctx, raycast_obj_cb, &data);

	return data.ret;	return data.ret;
	}	}
Context not available.
	dist_squared_ray_to_seg_v3(ray_start, ray_dir, va, vb, tmp_co, &depth);	dist_squared_ray_to_seg_v3(ray_start, ray_dir, va, vb, tmp_co, &depth);
	return test_projected_vert_dist(depth_range, mval, tmp_co, pmat, win_half, is_persp, dist_px_sq, r_co);	return test_projected_vert_dist(depth_range, mval, tmp_co, pmat, win_half, is_persp, dist_px_sq, r_co);
	}	}
	typedef struct Nearest2dPrecalc {
	float ray_origin_local[3];
	float ray_direction_local[3];
	float ray_inv_dir[3];

	float ray_min_dist;
	float pmat[4][4]; /* perspective matrix multiplied by object matrix */
	bool is_persp;
	float win_half[2];

	float mval[2];
	bool sign[3];
	} Nearest2dPrecalc;

	/**	/**
	* \param lpmat: Perspective matrix multiplied by object matrix	* \param MVP: Perspective matrix multiplied by object matrix
	*/	*/
	static void dist_squared_to_projected_aabb_precalc(
	struct Nearest2dPrecalc *neasrest_precalc,
	float lpmat[4][4], bool is_persp, const float win_half[2],
	const float ray_min_dist, const float mval[2],
	const float ray_origin_local[3], const float ray_direction_local[3])
	{
	copy_m4_m4(neasrest_precalc->pmat, lpmat);
	neasrest_precalc->is_persp = is_persp;
	copy_v2_v2(neasrest_precalc->win_half, win_half);
	neasrest_precalc->ray_min_dist = ray_min_dist;

	copy_v3_v3(neasrest_precalc->ray_origin_local, ray_origin_local);
	copy_v3_v3(neasrest_precalc->ray_direction_local, ray_direction_local);
	copy_v2_v2(neasrest_precalc->mval, mval);

	for (int i = 0; i < 3; i++) {
	neasrest_precalc->ray_inv_dir[i] =
	(neasrest_precalc->ray_direction_local[i] != 0.0f) ?
	(1.0f / neasrest_precalc->ray_direction_local[i]) : FLT_MAX;
	neasrest_precalc->sign[i] = (neasrest_precalc->ray_inv_dir[i] < 0.0f);
	}
	}

	/* Returns the distance from a 2d coordinate to a BoundBox (Projected) */	static bool isect_boundbox_threshold(
	static float dist_squared_to_projected_aabb(	const SnapObjectContext *sctx,
	struct Nearest2dPrecalc *data,	float MVP[4][4],
	const float bbmin[3], const float bbmax[3],	const float ray_origin_local[3], const float ray_direction_local[3],
	bool r_axis_closest[3])	const float bbmin[3], const float bbmax[3])
	{	{
	float local_bvmin[3], local_bvmax[3];	float local_bvmin[3], local_bvmax[3];
	if (data->sign[0]) {	float tmin[3], tmax[3];

		if (ray_direction_local[0] < 0.0f) {
	local_bvmin[0] = bbmax[0];	local_bvmin[0] = bbmax[0];
	local_bvmax[0] = bbmin[0];	local_bvmax[0] = bbmin[0];
	}	}
Context not available.
	local_bvmin[0] = bbmin[0];	local_bvmin[0] = bbmin[0];
	local_bvmax[0] = bbmax[0];	local_bvmax[0] = bbmax[0];
	}	}
	if (data->sign[1]) {	if (ray_direction_local[1] < 0.0f) {
	local_bvmin[1] = bbmax[1];	local_bvmin[1] = bbmax[1];
	local_bvmax[1] = bbmin[1];	local_bvmax[1] = bbmin[1];
	}	}
Context not available.
	local_bvmin[1] = bbmin[1];	local_bvmin[1] = bbmin[1];
	local_bvmax[1] = bbmax[1];	local_bvmax[1] = bbmax[1];
	}	}
	if (data->sign[2]) {	if (ray_direction_local[2] < 0.0f) {
	local_bvmin[2] = bbmax[2];	local_bvmin[2] = bbmax[2];
	local_bvmax[2] = bbmin[2];	local_bvmax[2] = bbmin[2];
	}	}
Context not available.
	local_bvmax[2] = bbmax[2];	local_bvmax[2] = bbmax[2];
	}	}

	const float tmin[3] = {	if (ray_direction_local[0]) {
	(local_bvmin[0] - data->ray_origin_local[0]) * data->ray_inv_dir[0],	tmin[0] = (local_bvmin[0] - ray_origin_local[0]) / ray_direction_local[0];
	(local_bvmin[1] - data->ray_origin_local[1]) * data->ray_inv_dir[1],	tmax[0] = (local_bvmax[0] - ray_origin_local[0]) / ray_direction_local[0];
	(local_bvmin[2] - data->ray_origin_local[2]) * data->ray_inv_dir[2],	}
	};	else {
	const float tmax[3] = {	tmin[0] = tmax[0] = FLT_MAX;
	(local_bvmax[0] - data->ray_origin_local[0]) * data->ray_inv_dir[0],	}
	(local_bvmax[1] - data->ray_origin_local[1]) * data->ray_inv_dir[1],
	(local_bvmax[2] - data->ray_origin_local[2]) * data->ray_inv_dir[2],	if (ray_direction_local[1]) {
	};	tmin[1] = (local_bvmin[1] - ray_origin_local[1]) / ray_direction_local[1];
		tmax[1] = (local_bvmax[1] - ray_origin_local[1]) / ray_direction_local[1];
		}
		else {
		tmin[1] = tmax[1] = FLT_MAX;
		}

		if (ray_direction_local[2]) {
		tmin[2] = (local_bvmin[2] - ray_origin_local[2]) / ray_direction_local[2];
		tmax[2] = (local_bvmax[2] - ray_origin_local[2]) / ray_direction_local[2];
		}
		else {
		tmin[2] = tmax[2] = FLT_MAX;
		}

	/* `va` and `vb` are the coordinates of the AABB edge closest to the ray */	/* `va` and `vb` are the coordinates of the AABB edge closest to the ray */
	float va[3], vb[3];	float va[3], vb[3];
	/* `rtmin` and `rtmax` are the minimum and maximum distances of the ray hits on the AABB */	/* `rtmin` and `rtmax` are the minimum and maximum distances of the ray hits on the AABB */
Context not available.
	rtmax = tmax[0];	rtmax = tmax[0];
	va[0] = vb[0] = local_bvmax[0];	va[0] = vb[0] = local_bvmax[0];
	main_axis = 3;	main_axis = 3;
	r_axis_closest[0] = data->sign[0];
	}	}
	else if ((tmax[1] <= tmax[0]) && (tmax[1] <= tmax[2])) {	else if ((tmax[1] <= tmax[0]) && (tmax[1] <= tmax[2])) {
	rtmax = tmax[1];	rtmax = tmax[1];
	va[1] = vb[1] = local_bvmax[1];	va[1] = vb[1] = local_bvmax[1];
	main_axis = 2;	main_axis = 2;
	r_axis_closest[1] = data->sign[1];
	}	}
	else {	else {
	rtmax = tmax[2];	rtmax = tmax[2];
	va[2] = vb[2] = local_bvmax[2];	va[2] = vb[2] = local_bvmax[2];
	main_axis = 1;	main_axis = 1;
	r_axis_closest[2] = data->sign[2];
	}	}

	if ((tmin[0] >= tmin[1]) && (tmin[0] >= tmin[2])) {	if ((tmin[0] >= tmin[1]) && (tmin[0] >= tmin[2])) {
	rtmin = tmin[0];	rtmin = tmin[0];
	va[0] = vb[0] = local_bvmin[0];	va[0] = vb[0] = local_bvmin[0];
	main_axis -= 3;	main_axis -= 3;
	r_axis_closest[0] = !data->sign[0];
	}	}
	else if ((tmin[1] >= tmin[0]) && (tmin[1] >= tmin[2])) {	else if ((tmin[1] >= tmin[0]) && (tmin[1] >= tmin[2])) {
	rtmin = tmin[1];	rtmin = tmin[1];
	va[1] = vb[1] = local_bvmin[1];	va[1] = vb[1] = local_bvmin[1];
	main_axis -= 1;	main_axis -= 1;
	r_axis_closest[1] = !data->sign[1];
	}	}
	else {	else {
	rtmin = tmin[2];	rtmin = tmin[2];
	va[2] = vb[2] = local_bvmin[2];	va[2] = vb[2] = local_bvmin[2];
	main_axis -= 2;	main_axis -= 2;
	r_axis_closest[2] = !data->sign[2];
	}	}
	if (main_axis < 0) {	if (main_axis < 0) {
	main_axis += 3;	main_axis += 3;
Context not available.
	#define IGNORE_BEHIND_RAY	#define IGNORE_BEHIND_RAY
	#ifdef IGNORE_BEHIND_RAY	#ifdef IGNORE_BEHIND_RAY
	/* `if rtmax < depth_min`, the hit is behind us */	/* `if rtmax < depth_min`, the hit is behind us */
	if (rtmax < data->ray_min_dist) {	if (rtmax < sctx->dinamic.depth_range[0]) {
	/* Test if the entire AABB is behind us */	/* Test if the entire AABB is behind us */
	float depth = depth_get(	float depth = depth_get(
	local_bvmax, data->ray_origin_local, data->ray_direction_local);	local_bvmax, ray_origin_local, ray_direction_local);
	if (depth < (data->ray_min_dist)) {	if (depth < sctx->dinamic.depth_range[0]) {
	return FLT_MAX;	return false;
	}	}
	}	}
	#endif	#endif
	const float proj = rtmin * data->ray_direction_local[main_axis];	return true;
	r_axis_closest[main_axis] = (proj - va[main_axis]) < (vb[main_axis] - proj);
	return 0.0f;
	}	}
	#ifdef IGNORE_BEHIND_RAY	#ifdef IGNORE_BEHIND_RAY
	/* `if rtmin < depth_min`, the hit is behing us */	/* `if rtmin < depth_min`, the hit is behing us */
	else if (rtmin < data->ray_min_dist) {	else if (rtmin < sctx->dinamic.depth_range[0]) {
	/* Test if the entire AABB is behind us */	/* Test if the entire AABB is behind us */
	float depth = depth_get(	float depth = depth_get(
	local_bvmax, data->ray_origin_local, data->ray_direction_local);	local_bvmax, ray_origin_local, ray_direction_local);
	if (depth < (data->ray_min_dist)) {	if (depth < sctx->dinamic.depth_range[0]) {
	return FLT_MAX;	return false;
	}	}
	}	}
	#endif	#endif
	#undef IGNORE_BEHIND_RAY	#undef IGNORE_BEHIND_RAY
	if (data->sign[main_axis]) {	if (ray_direction_local[main_axis] < 0.0f) {
	va[main_axis] = local_bvmax[main_axis];	va[main_axis] = local_bvmax[main_axis];
	vb[main_axis] = local_bvmin[main_axis];	vb[main_axis] = local_bvmin[main_axis];
	}	}
Context not available.
	va[main_axis] = local_bvmin[main_axis];	va[main_axis] = local_bvmin[main_axis];
	vb[main_axis] = local_bvmax[main_axis];	vb[main_axis] = local_bvmax[main_axis];
	}	}
	float scale = fabsf(local_bvmax[main_axis] - local_bvmin[main_axis]);

	float (*pmat)[4] = data->pmat;	const float win_half[2] = {
		sctx->v3d_data.ar->winx / 2,
		sctx->v3d_data.ar->winy / 2,
		};

		float scale = fabsf(local_bvmax[main_axis] - local_bvmin[main_axis]);

	float va2d[2] = {	float va2d[2] = {
	(dot_m4_v3_row_x(pmat, va) + pmat[3][0]),	(dot_m4_v3_row_x(MVP, va) + MVP[3][0]),
	(dot_m4_v3_row_y(pmat, va) + pmat[3][1]),	(dot_m4_v3_row_y(MVP, va) + MVP[3][1]),
	};	};
	float vb2d[2] = {	float vb2d[2] = {
	(va2d[0] + pmat[main_axis][0] * scale),	(va2d[0] + MVP[main_axis][0] * scale),
	(va2d[1] + pmat[main_axis][1] * scale),	(va2d[1] + MVP[main_axis][1] * scale),
	};	};

	if (data->is_persp) {	float depth_a = mul_project_m4_v3_zfac(MVP, va);
	float depth_a = mul_project_m4_v3_zfac(pmat, va);	float depth_b = depth_a + MVP[main_axis][3] * scale;
	float depth_b = depth_a + pmat[main_axis][3] * scale;	va2d[0] /= depth_a;
	va2d[0] /= depth_a;	va2d[1] /= depth_a;
	va2d[1] /= depth_a;	vb2d[0] /= depth_b;
	vb2d[0] /= depth_b;	vb2d[1] /= depth_b;
	vb2d[1] /= depth_b;
	}

	va2d[0] += 1.0f;	va2d[0] += 1.0f;
	va2d[1] += 1.0f;	va2d[1] += 1.0f;
	vb2d[0] += 1.0f;	vb2d[0] += 1.0f;
	vb2d[1] += 1.0f;	vb2d[1] += 1.0f;

	va2d[0] *= data->win_half[0];	va2d[0] *= win_half[0];
	va2d[1] *= data->win_half[1];	va2d[1] *= win_half[1];
	vb2d[0] *= data->win_half[0];	vb2d[0] *= win_half[0];
	vb2d[1] *= data->win_half[1];	vb2d[1] *= win_half[1];

	float dvec[2], edge[2], lambda, rdist;
	sub_v2_v2v2(dvec, data->mval, va2d);
	sub_v2_v2v2(edge, vb2d, va2d);
	lambda = dot_v2v2(dvec, edge);
	if (lambda != 0.0f) {
	lambda /= len_squared_v2(edge);
	if (lambda <= 0.0f) {
	rdist = len_squared_v2v2(data->mval, va2d);
	r_axis_closest[main_axis] = true;
	}
	else if (lambda >= 1.0f) {
	rdist = len_squared_v2v2(data->mval, vb2d);
	r_axis_closest[main_axis] = false;
	}
	else {
	va2d[0] += edge[0] * lambda;
	va2d[1] += edge[1] * lambda;
	rdist = len_squared_v2v2(data->mval, va2d);
	r_axis_closest[main_axis] = lambda < 0.5f;
	}
	}
	else {
	rdist = len_squared_v2v2(data->mval, va2d);
	}
	return rdist;
	}

	static float dist_squared_to_projected_aabb_simple(
	float lpmat[4][4], const float win_half[2],
	const float ray_min_dist, const float mval[2],
	const float ray_origin_local[3], const float ray_direction_local[3],
	const float bbmin[3], const float bbmax[3])
	{
	struct Nearest2dPrecalc data;
	dist_squared_to_projected_aabb_precalc(
	&data, lpmat, true, win_half, ray_min_dist,
	mval, ray_origin_local, ray_direction_local);

	bool dummy[3] = {true, true, true};	return dist_squared_to_line_segment_v2(sctx->dinamic.mval, va2d, vb2d) < SQUARE(sctx->dinamic.dist_px);
	return dist_squared_to_projected_aabb(&data, bbmin, bbmax, dummy);
	}	}

	/** \} */	/** \} */
Context not available.

	/* -------------------------------------------------------------------- */	/* -------------------------------------------------------------------- */

	/** Walk DFS
	* \{ */

	typedef void (Nearest2DGetEdgeVertsCallback)(const int index, const float v_pair[2], void *data);
	typedef void (Nearest2DCopyVertNoCallback)(const int index, float r_no[3], void data);

	typedef struct Nearest2dUserData {
	struct Nearest2dPrecalc data_precalc;

	float dist_px_sq;

	bool r_axis_closest[3];

	float depth_range[2];

	void *userdata;
	Nearest2DGetEdgeVertsCallback get_edge_verts;
	Nearest2DCopyVertNoCallback copy_vert_no;

	int index;
	float co[3];
	float no[3];
	} Nearest2dUserData;


	static bool cb_walk_parent_snap_project(const BVHTreeAxisRange bounds, void user_data)
	{
	Nearest2dUserData *data = user_data;
	const float bbmin[3] = {bounds[0].min, bounds[1].min, bounds[2].min};
	const float bbmax[3] = {bounds[0].max, bounds[1].max, bounds[2].max};
	const float rdist = dist_squared_to_projected_aabb(
	&data->data_precalc, bbmin, bbmax, data->r_axis_closest);
	return rdist < data->dist_px_sq;
	}

	static bool cb_walk_leaf_snap_vert(const BVHTreeAxisRange bounds, int index, void userdata)
	{
	struct Nearest2dUserData *data = userdata;
	struct Nearest2dPrecalc *neasrest_precalc = &data->data_precalc;
	const float co[3] = {
	(bounds[0].min + bounds[0].max) / 2,
	(bounds[1].min + bounds[1].max) / 2,
	(bounds[2].min + bounds[2].max) / 2,
	};

	if (test_projected_vert_dist(
	data->depth_range,
	neasrest_precalc->mval, co,
	neasrest_precalc->pmat,
	neasrest_precalc->win_half,
	neasrest_precalc->is_persp,
	&data->dist_px_sq,
	data->co))
	{
	data->copy_vert_no(index, data->no, data->userdata);
	data->index = index;
	}
	return true;
	}

	static bool cb_walk_leaf_snap_edge(const BVHTreeAxisRange UNUSED(bounds), int index, void userdata)
	{
	struct Nearest2dUserData *data = userdata;
	struct Nearest2dPrecalc *neasrest_precalc = &data->data_precalc;

	const float *v_pair[2];
	data->get_edge_verts(index, v_pair, data->userdata);

	if (test_projected_edge_dist(
	data->depth_range,
	neasrest_precalc->mval,
	neasrest_precalc->pmat,
	neasrest_precalc->win_half,
	neasrest_precalc->is_persp,
	neasrest_precalc->ray_origin_local,
	neasrest_precalc->ray_direction_local,
	v_pair[0], v_pair[1],
	&data->dist_px_sq,
	data->co))
	{
	sub_v3_v3v3(data->no, v_pair[0], v_pair[1]);
	data->index = index;
	}
	return true;
	}

	static bool cb_nearest_walk_order(const BVHTreeAxisRange UNUSED(bounds), char axis, void userdata)
	{
	const bool r_axis_closest = ((struct Nearest2dUserData )userdata)->r_axis_closest;
	return r_axis_closest[axis];
	}

	/** \} */

	/* -------------------------------------------------------------------- */

	/** \name Internal Object Snapping API	/** \name Internal Object Snapping API
	* \{ */	* \{ */

	static bool snapArmature(	static bool snapArmature(
	SnapData *snapdata,	const SnapObjectContext *sctx,
	Object ob, bArmature arm, float obmat[4][4],	Object ob, bArmature arm, float obmat[4][4], float *dist_px_sq,
	/* read/write args */
	float ray_depth, float dist_px,
	/* return args */	/* return args */
	float r_loc[3], float *UNUSED(r_no))	float r_loc[3], float *UNUSED(r_no))
	{	{
	bool retval = false;	bool retval = false;

	float ray_start_local[3], ray_normal_local[3]; /* Used only in the snap to edges */	float ray_start_local[3], ray_normal_local[3]; /* Used only in the snap to edges */
	if (snapdata->snap_to == SCE_SNAP_MODE_EDGE) {	if (sctx->dinamic.snap_to_flag & SCE_SNAP_MODE_EDGE) {
	float imat[4][4];	float imat[4][4];
	invert_m4_m4(imat, obmat);	invert_m4_m4(imat, obmat);

	copy_v3_v3(ray_start_local, snapdata->ray_origin);	copy_v3_v3(ray_start_local, sctx->dinamic.ray_orig);
	copy_v3_v3(ray_normal_local, snapdata->ray_dir);	copy_v3_v3(ray_normal_local, sctx->dinamic.ray_dir);
	mul_m4_v3(imat, ray_start_local);	mul_m4_v3(imat, ray_start_local);
	mul_mat3_m4_v3(imat, ray_normal_local);	mul_mat3_m4_v3(imat, ray_normal_local);
	}	}
	else if (snapdata->snap_to != SCE_SNAP_MODE_VERTEX) { /* Currently only edge and vert */	else if (!(sctx->dinamic.snap_to_flag & SCE_SNAP_MODE_VERTEX)) { /* Currently only edge and vert */
	return retval;	return retval;
	}	}

	bool is_persp = snapdata->view_proj == VIEW_PROJ_PERSP;	bool is_persp = ((RegionView3D *)sctx->v3d_data.ar->regiondata)->is_persp;
	float lpmat[4][4], dist_px_sq;	float MVP[4][4];
	mul_m4_m4m4(lpmat, snapdata->pmat, obmat);	mul_m4_m4m4(MVP, sctx->dinamic.pmat, obmat);
	dist_px_sq = SQUARE(*dist_px);
		const float win_half[2] = {
		sctx->fbo.sizex / 2,
		sctx->fbo.sizey / 2,
		};

	if (arm->edbo) {	if (arm->edbo) {
	for (EditBone *eBone = arm->edbo->first; eBone; eBone = eBone->next) {	for (EditBone *eBone = arm->edbo->first; eBone; eBone = eBone->next) {
	if (eBone->layer & arm->layer) {	if (eBone->layer & arm->layer) {
	/* skip hidden or moving (selected) bones */	/* skip hidden or moving (selected) bones */
	if ((eBone->flag & (BONE_HIDDEN_A \| BONE_ROOTSEL \| BONE_TIPSEL)) == 0) {	if ((eBone->flag & (BONE_HIDDEN_A \| BONE_ROOTSEL \| BONE_TIPSEL)) == 0) {
	switch (snapdata->snap_to) {	switch (sctx->dinamic.snap_to_flag) {
	case SCE_SNAP_MODE_VERTEX:	case SCE_SNAP_MODE_VERTEX:
	retval \|= test_projected_vert_dist(	retval \|= test_projected_vert_dist(
	snapdata->depth_range, snapdata->mval, eBone->head,	sctx->dinamic.depth_range, sctx->dinamic.mval, eBone->head,
	lpmat, snapdata->win_half, is_persp, &dist_px_sq,	MVP, win_half, is_persp, dist_px_sq,
	r_loc);	r_loc);
	retval \|= test_projected_vert_dist(	retval \|= test_projected_vert_dist(
	snapdata->depth_range, snapdata->mval, eBone->tail,	sctx->dinamic.depth_range, sctx->dinamic.mval, eBone->tail,
	lpmat, snapdata->win_half, is_persp, &dist_px_sq,	MVP, win_half, is_persp, dist_px_sq,
	r_loc);	r_loc);
	break;	break;
	case SCE_SNAP_MODE_EDGE:	case SCE_SNAP_MODE_EDGE:
	retval \|= test_projected_edge_dist(	retval \|= test_projected_edge_dist(
	snapdata->depth_range, snapdata->mval, lpmat,	sctx->dinamic.depth_range, sctx->dinamic.mval, MVP,
	snapdata->win_half, is_persp, ray_start_local, ray_normal_local,	win_half, is_persp, ray_start_local, ray_normal_local,
	eBone->head, eBone->tail,	eBone->head, eBone->tail,
	&dist_px_sq, r_loc);	dist_px_sq, r_loc);
	break;	break;
	}	}
	}	}
Context not available.
	const float *head_vec = pchan->pose_head;	const float *head_vec = pchan->pose_head;
	const float *tail_vec = pchan->pose_tail;	const float *tail_vec = pchan->pose_tail;

	switch (snapdata->snap_to) {	switch (sctx->dinamic.snap_to_flag) {
	case SCE_SNAP_MODE_VERTEX:	case SCE_SNAP_MODE_VERTEX:
	retval \|= test_projected_vert_dist(	retval \|= test_projected_vert_dist(
	snapdata->depth_range, snapdata->mval, head_vec,	sctx->dinamic.depth_range, sctx->dinamic.mval, head_vec,
	lpmat, snapdata->win_half, is_persp, &dist_px_sq,	MVP, win_half, is_persp, dist_px_sq,
	r_loc);	r_loc);
	retval \|= test_projected_vert_dist(	retval \|= test_projected_vert_dist(
	snapdata->depth_range, snapdata->mval, tail_vec,	sctx->dinamic.depth_range, sctx->dinamic.mval, tail_vec,
	lpmat, snapdata->win_half, is_persp, &dist_px_sq,	MVP, win_half, is_persp, dist_px_sq,
	r_loc);	r_loc);
	break;	break;
	case SCE_SNAP_MODE_EDGE:	case SCE_SNAP_MODE_EDGE:
	retval \|= test_projected_edge_dist(	retval \|= test_projected_edge_dist(
	snapdata->depth_range, snapdata->mval, lpmat,	sctx->dinamic.depth_range, sctx->dinamic.mval, MVP,
	snapdata->win_half, is_persp, ray_start_local, ray_normal_local,	win_half, is_persp, ray_start_local, ray_normal_local,
	head_vec, tail_vec,	head_vec, tail_vec,
	&dist_px_sq, r_loc);	dist_px_sq, r_loc);
	break;	break;
	}	}
	}	}
	}	}
	}	}
	if (retval) {	if (retval) {
	*dist_px = sqrtf(dist_px_sq);
	mul_m4_v3(obmat, r_loc);	mul_m4_v3(obmat, r_loc);
	*ray_depth = depth_get(r_loc, snapdata->ray_start, snapdata->ray_dir);
	return true;	return true;
	}	}
	return false;	return false;
	}	}

	static bool snapCurve(	static bool snapCurve(
	SnapData *snapdata,	const SnapObjectContext *sctx,
	Object ob, Curve cu, float obmat[4][4],	Object ob, Curve cu, float obmat[4][4], float *dist_px_sq,
	/* read/write args */
	float ray_depth, float dist_px,
	/* return args */	/* return args */
	float r_loc[3], float *UNUSED(r_no))	float r_loc[3], float *UNUSED(r_no))
	{	{
	bool retval = false;	bool retval = false;

	/* only vertex snapping mode (eg control points and handles) supported for now) */	/* only vertex snapping mode (eg control points and handles) supported for now) */
	if (snapdata->snap_to != SCE_SNAP_MODE_VERTEX) {	if (!(sctx->dinamic.snap_to_flag & SCE_SNAP_MODE_VERTEX)) {
	return retval;	return retval;
	}	}

	bool is_persp = snapdata->view_proj == VIEW_PROJ_PERSP;	bool is_persp = ((RegionView3D *)sctx->v3d_data.ar->regiondata)->is_persp;
	float lpmat[4][4], dist_px_sq;	float MVP[4][4];
	mul_m4_m4m4(lpmat, snapdata->pmat, obmat);	mul_m4_m4m4(MVP, sctx->dinamic.pmat, obmat);
	dist_px_sq = SQUARE(*dist_px);
		const float win_half[2] = {
		sctx->fbo.sizex / 2,
		sctx->fbo.sizey / 2,
		};

	for (Nurb *nu = (ob->mode == OB_MODE_EDIT ? cu->editnurb->nurbs.first : cu->nurb.first); nu; nu = nu->next) {	for (Nurb *nu = (ob->mode == OB_MODE_EDIT ? cu->editnurb->nurbs.first : cu->nurb.first); nu; nu = nu->next) {
	for (int u = 0; u < nu->pntsu; u++) {	for (int u = 0; u < nu->pntsu; u++) {
	switch (snapdata->snap_to) {	switch (sctx->dinamic.snap_to_flag) {
	case SCE_SNAP_MODE_VERTEX:	case SCE_SNAP_MODE_VERTEX:
	{	{
	if (ob->mode == OB_MODE_EDIT) {	if (ob->mode == OB_MODE_EDIT) {
Context not available.
	break;	break;
	}	}
	retval \|= test_projected_vert_dist(	retval \|= test_projected_vert_dist(
	snapdata->depth_range, snapdata->mval, nu->bezt[u].vec[1],	sctx->dinamic.depth_range, sctx->dinamic.mval, nu->bezt[u].vec[1],
	lpmat, snapdata->win_half, is_persp, &dist_px_sq,	MVP, win_half, is_persp, dist_px_sq,
	r_loc);	r_loc);
	/* don't snap if handle is selected (moving), or if it is aligning to a moving handle */	/* don't snap if handle is selected (moving), or if it is aligning to a moving handle */
	if (!(nu->bezt[u].f1 & SELECT) &&	if (!(nu->bezt[u].f1 & SELECT) &&
	!(nu->bezt[u].h1 & HD_ALIGN && nu->bezt[u].f3 & SELECT))	!(nu->bezt[u].h1 & HD_ALIGN && nu->bezt[u].f3 & SELECT))
	{	{
	retval \|= test_projected_vert_dist(	retval \|= test_projected_vert_dist(
	snapdata->depth_range, snapdata->mval, nu->bezt[u].vec[0],	sctx->dinamic.depth_range, sctx->dinamic.mval, nu->bezt[u].vec[0],
	lpmat, snapdata->win_half, is_persp, &dist_px_sq,	MVP, win_half, is_persp, dist_px_sq,
	r_loc);	r_loc);
	}	}
	if (!(nu->bezt[u].f3 & SELECT) &&	if (!(nu->bezt[u].f3 & SELECT) &&
	!(nu->bezt[u].h2 & HD_ALIGN && nu->bezt[u].f1 & SELECT))	!(nu->bezt[u].h2 & HD_ALIGN && nu->bezt[u].f1 & SELECT))
	{	{
	retval \|= test_projected_vert_dist(	retval \|= test_projected_vert_dist(
	snapdata->depth_range, snapdata->mval, nu->bezt[u].vec[2],	sctx->dinamic.depth_range, sctx->dinamic.mval, nu->bezt[u].vec[2],
	lpmat, snapdata->win_half, is_persp, &dist_px_sq,	MVP, win_half, is_persp, dist_px_sq,
	r_loc);	r_loc);
	}	}
	}	}
Context not available.
	break;	break;
	}	}
	retval \|= test_projected_vert_dist(	retval \|= test_projected_vert_dist(
	snapdata->depth_range, snapdata->mval, nu->bp[u].vec,	sctx->dinamic.depth_range, sctx->dinamic.mval, nu->bp[u].vec,
	lpmat, snapdata->win_half, is_persp, &dist_px_sq,	MVP, win_half, is_persp, dist_px_sq,
	r_loc);	r_loc);
	}	}
	}	}
Context not available.
	if (nu->pntsu > 1) {	if (nu->pntsu > 1) {
	if (nu->bezt) {	if (nu->bezt) {
	retval \|= test_projected_vert_dist(	retval \|= test_projected_vert_dist(
	snapdata->depth_range, snapdata->mval, nu->bezt[u].vec[1],	sctx->dinamic.depth_range, sctx->dinamic.mval, nu->bezt[u].vec[1],
	lpmat, snapdata->win_half, is_persp, &dist_px_sq,	MVP, win_half, is_persp, dist_px_sq,
	r_loc);	r_loc);
	}	}
	else {	else {
	retval \|= test_projected_vert_dist(	retval \|= test_projected_vert_dist(
	snapdata->depth_range, snapdata->mval, nu->bp[u].vec,	sctx->dinamic.depth_range, sctx->dinamic.mval, nu->bp[u].vec,
	lpmat, snapdata->win_half, is_persp, &dist_px_sq,	MVP, win_half, is_persp, dist_px_sq,
	r_loc);	r_loc);
	}	}
	}	}
	}	}
	break;	break;
	}	}
	default:
	break;
	}	}
	}	}
	}	}
	if (retval) {	if (retval) {
	*dist_px = sqrtf(dist_px_sq);
	mul_m4_v3(obmat, r_loc);	mul_m4_v3(obmat, r_loc);
	*ray_depth = depth_get(r_loc, snapdata->ray_start, snapdata->ray_dir);
	return true;	return true;
	}	}
	return false;	return false;
Context not available.

	/* may extend later (for now just snaps to empty center) */	/* may extend later (for now just snaps to empty center) */
	static bool snapEmpty(	static bool snapEmpty(
	SnapData *snapdata,	SnapObjectContext *sctx,
	Object *ob, float obmat[4][4],	Object ob, float obmat[4][4], float dist_px_sq,
	/* read/write args */
	float ray_depth, float dist_px,
	/* return args */	/* return args */
	float r_loc[3], float *UNUSED(r_no))	float r_loc[3], float *UNUSED(r_no))
	{	{
Context not available.
	}	}

	/* for now only vertex supported */	/* for now only vertex supported */
	switch (snapdata->snap_to) {	if (sctx->dinamic.snap_to_flag & SCE_SNAP_MODE_VERTEX) {
	case SCE_SNAP_MODE_VERTEX:	bool is_persp = ((RegionView3D *)sctx->v3d_data.ar->regiondata)->is_persp;
		float tmp_co[3];
		copy_v3_v3(tmp_co, obmat[3]);

		const float win_half[2] = {
		sctx->fbo.sizex / 2,
		sctx->fbo.sizey / 2,
		};

		if (test_projected_vert_dist(
		sctx->dinamic.depth_range, sctx->dinamic.mval, tmp_co,
		sctx->dinamic.pmat, win_half, is_persp, dist_px_sq,
		r_loc))
	{	{
	bool is_persp = snapdata->view_proj == VIEW_PROJ_PERSP;	retval = true;
	float dist_px_sq = SQUARE(*dist_px);
	float tmp_co[3];
	copy_v3_v3(tmp_co, obmat[3]);
	if (test_projected_vert_dist(
	snapdata->depth_range, snapdata->mval, tmp_co,
	snapdata->pmat, snapdata->win_half, is_persp, &dist_px_sq,
	r_loc))
	{
	*dist_px = sqrtf(dist_px_sq);
	*ray_depth = depth_get(r_loc, snapdata->ray_start, snapdata->ray_dir);
	retval = true;
	}
	break;
	}	}
	default:
	break;
	}	}

	return retval;	return retval;
	}	}

	static bool snapCamera(	static bool snapCamera(
	const SnapObjectContext sctx, SnapData snapdata,	SnapObjectContext *sctx,
	Object *object, float obmat[4][4],	Object object, float obmat[4][4], float dist_px_sq,
	/* read/write args */
	float ray_depth, float dist_px,
	/* return args */	/* return args */
	float r_loc[3], float *UNUSED(r_no))	float r_loc[3], float *UNUSED(r_no))
	{	{
	Scene *scene = sctx->scene;	Scene *scene = sctx->scene;

	bool is_persp = snapdata->view_proj == VIEW_PROJ_PERSP;	bool is_persp = ((RegionView3D *)sctx->v3d_data.ar->regiondata)->is_persp;
	float dist_px_sq = SQUARE(*dist_px);

	float orig_camera_mat[4][4], orig_camera_imat[4][4], imat[4][4];	float orig_camera_mat[4][4], orig_camera_imat[4][4], imat[4][4];
	bool retval = false;	bool retval = false;
Context not available.
	invert_m4_m4(orig_camera_imat, orig_camera_mat);	invert_m4_m4(orig_camera_imat, orig_camera_mat);
	invert_m4_m4(imat, obmat);	invert_m4_m4(imat, obmat);

	switch (snapdata->snap_to) {	switch (sctx->dinamic.snap_to_flag) {
	case SCE_SNAP_MODE_VERTEX:	case SCE_SNAP_MODE_VERTEX:
	{	{
		const float win_half[2] = {
		sctx->fbo.sizex / 2,
		sctx->fbo.sizey / 2,
		};

	MovieTrackingObject *tracking_object;	MovieTrackingObject *tracking_object;

	for (tracking_object = tracking->objects.first;	for (tracking_object = tracking->objects.first;
Context not available.

	mul_m4_v3(vertex_obmat, bundle_pos);	mul_m4_v3(vertex_obmat, bundle_pos);
	retval \|= test_projected_vert_dist(	retval \|= test_projected_vert_dist(
	snapdata->depth_range, snapdata->mval, bundle_pos,	sctx->dinamic.depth_range, sctx->dinamic.mval, bundle_pos,
	snapdata->pmat, snapdata->win_half, is_persp, &dist_px_sq,	sctx->dinamic.pmat, win_half, is_persp, dist_px_sq,
	r_loc);	r_loc);
	}	}
	}	}
Context not available.
	break;	break;
	}	}

	if (retval) {	return retval;
	*dist_px = sqrtf(dist_px_sq);
	*ray_depth = depth_get(r_loc, snapdata->ray_start, snapdata->ray_dir);
	return true;
	}
	return false;
	}	}

	static int dm_looptri_to_poly_index(DerivedMesh dm, const MLoopTri lt)
	{
	const int *index_mp_to_orig = dm->getPolyDataArray(dm, CD_ORIGINDEX);
	return index_mp_to_orig ? index_mp_to_orig[lt->poly] : lt->poly;
	}

	static bool snapDerivedMesh(	static bool snap_object(
	SnapObjectContext sctx, SnapData snapdata,	SnapObjectContext *sctx,
	Object ob, DerivedMesh dm, float obmat[4][4],	Object ob, float obmat[4][4], float dist_px_sq,
	/* read/write args */
	float ray_depth, float dist_px,
	/* return args */	/* return args */
	float r_loc[3], float r_no[3])	float r_loc[3], float r_no[3],
		Object **r_ob, float r_obmat[4][4])
	{	{
	bool retval = false;	bool retval = false;
		if (ob->type == OB_ARMATURE) {
	if (snapdata->snap_to == SCE_SNAP_MODE_EDGE) {	retval = snapArmature(
	if (dm->getNumEdges(dm) == 0) {	sctx,
	return retval;	ob, ob->data, obmat, dist_px_sq,
	}	r_loc, r_no);
	}	}
	else {	else if (ob->type == OB_CURVE) {
	if (dm->getNumVerts(dm) == 0) {	retval = snapCurve(
	return retval;	sctx,
	}	ob, ob->data, obmat, dist_px_sq,
		r_loc, r_no);
		}
		else if (ob->type == OB_EMPTY) {
		retval = snapEmpty(
		sctx,
		ob, obmat, dist_px_sq,
		r_loc, r_no);
		}
		else if (ob->type == OB_CAMERA) {
		retval = snapCamera(
		sctx, ob, obmat, dist_px_sq,
		r_loc, r_no);
	}	}

	float imat[4][4];	if (retval) {
	float timat[3][3]; /* transpose inverse matrix for normals */	if (r_ob) {
	float ray_normal_local[3];	*r_ob = ob;
	float local_scale;	copy_m4_m4(r_obmat, obmat);
		}
	invert_m4_m4(imat, obmat);	}
	transpose_m3_m4(timat, imat);

	copy_v3_v3(ray_normal_local, snapdata->ray_dir);	return retval;
		}

	mul_mat3_m4_v3(imat, ray_normal_local);

	/* local scale in normal direction */	/**
	local_scale = normalize_v3(ray_normal_local);	* This function tests the snap on non-Mesh objects
		*
		* While the drawing of these other types of objects is not implemented,
		* their snap must be done here
		*/
		static bool snap_non_mesh_objects(
		SnapObjectContext *sctx,
		/* return args */
		float r_loc[3], float r_no[3],
		Object **r_ob, float r_obmat[4][4])
		{
		bool retval = false;
		float dist_px_sq = SQUARE(sctx->dinamic.dist_px);

	float lpmat[4][4];	SnapObjectDraw *sodraw = sctx->dinamic.snap_obj_list.first;
	float ray_org_local[3];	for (; sodraw; sodraw = sodraw->next) {
	float ray_min_dist;	retval \|= snap_object(
		sctx, sodraw->ob, sodraw->obmat, &dist_px_sq,
		r_loc, r_no, r_ob, r_obmat);
		}

	mul_m4_m4m4(lpmat, snapdata->pmat, obmat);	sctx->dinamic.dist_px = sqrtf(dist_px_sq);
	ray_min_dist = snapdata->depth_range[0] * local_scale;	return retval;
		}

	copy_v3_v3(ray_org_local, snapdata->ray_origin);
	mul_m4_v3(imat, ray_org_local);

	/* Test BoundBox */	static unsigned short snap_object_drawn_get_returns(
	BoundBox *bb = BKE_object_boundbox_get(ob);	SnapObjectContext *sctx, unsigned int index,
	if (bb) {	float r_loc[3], float r_no[3],
	/* In vertex and edges you need to get the pixel distance from ray to BoundBox, see: T46099, T46816 */	Object *r_ob, float r_obmat[4][4], unsigned int r_index)
	float dist_px_sq = dist_squared_to_projected_aabb_simple(	{
	lpmat, snapdata->win_half, ray_min_dist, snapdata->mval,	unsigned short elem_type = 0;
	ray_org_local, ray_normal_local, bb->vec[0], bb->vec[6]);	SnapObjectDraw *sodraw = sctx->dinamic.snap_obj_list.first;
	if (dist_px_sq > SQUARE(*dist_px)) {	for (; sodraw != sctx->dinamic.last_sodraw; sodraw = sodraw->next) {
	return retval;	if (index <= sodraw->next->index_offset) {
		break;
	}	}
	}	}
		index -= sodraw->index_offset + 1;

	SnapObjectData_Mesh *sod = NULL;	SnapObjectData *sod = sodraw->sod;
	BVHTreeFromMesh *treedata = NULL;	if (sctx->dinamic.snap_to_flag & SNAP_EDGE && index >= sod->tot_vert_elem) {
		elem_type = SCE_SELECT_EDGE;
		int vert[2];
		float ray_org[3], ray_dir[3], v1[3], v2[3];

	void **sod_p;	glBindVertexArray(sod->vao);
	if (BLI_ghash_ensure_p(sctx->cache.object_map, ob, &sod_p)) {	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, sod->ebo_edges);
	sod = *sod_p;	glGetBufferSubData(GL_ELEMENT_ARRAY_BUFFER, (index - sod->tot_vert_elem) * sizeof(vert), sizeof(vert), vert);
	}	glBindBuffer(GL_ARRAY_BUFFER, sod->vbo);
	else {	glGetBufferSubData(GL_ARRAY_BUFFER, vert[0] * sizeof(v1), sizeof(v1), v1);
	sod = sod_p = BLI_memarena_calloc(sctx->cache.mem_arena, sizeof(sod));	glGetBufferSubData(GL_ARRAY_BUFFER, vert[1] * sizeof(v2), sizeof(v2), v2);
	sod->sd.type = SNAP_MESH;	glBindVertexArray(0);
	}

	int tree_index = -1;	mul_m4_v3(sodraw->obmat, v1);
	switch (snapdata->snap_to) {	mul_m4_v3(sodraw->obmat, v2);
	case SCE_SNAP_MODE_EDGE:
	tree_index = 1;	ED_view3d_win_to_origin(sctx->v3d_data.ar, sctx->dinamic.mval, ray_org);
	break;	ED_view3d_win_to_vector(sctx->v3d_data.ar, sctx->dinamic.mval, ray_dir);
	case SCE_SNAP_MODE_VERTEX:
	tree_index = 0;	float dummy_depth;
	break;	dist_squared_ray_to_seg_v3(ray_org, ray_dir, v1, v2, r_loc, &dummy_depth);
		if (r_no) {
		sub_v3_v3v3(r_no, v2, v1);
		normalize_v3(r_no);
		}
		if (r_index) {
		*r_index = index - sod->tot_vert_elem;
		}
	}	}
	if (tree_index != -1) {	if ((sctx->dinamic.snap_to_flag & SNAP_VERT) && index < sod->tot_vert_elem) {
	if (sod->bvh_trees[tree_index] == NULL) {	elem_type = SCE_SELECT_VERTEX;
	sod->bvh_trees[tree_index] = BLI_memarena_calloc(sctx->cache.mem_arena, sizeof(*treedata));	glBindVertexArray(sod->vao);
		if (sod->ebo_verts != -1) {
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, sod->ebo_verts);
		glGetBufferSubData(GL_ELEMENT_ARRAY_BUFFER, index * sizeof(index), sizeof(index), &index);
	}	}
	treedata = sod->bvh_trees[tree_index];	glBindBuffer(GL_ARRAY_BUFFER, sod->vbo);
		glGetBufferSubData(GL_ARRAY_BUFFER, index * 12, 12, r_loc);
	/* the tree is owned by the DM and may have been freed since we last used! */	glBindVertexArray(0);
	if (treedata && treedata->tree) {	mul_m4_v3(sodraw->obmat, r_loc);
	if (treedata->cached && !bvhcache_has_tree(dm->bvhCache, treedata->tree)) {	if (r_no) {
	free_bvhtree_from_mesh(treedata);	Mesh *me = sodraw->ob->data;
		if (sodraw->sod->type == SNAP_EDIT_MESH) {
		BMVert *eve = BM_vert_at_index(me->edit_btmesh->bm, index);
		mul_v3_mat3_m4v3(r_no, sodraw->obmat, eve->no);
		//mul_transposed_mat3_m4_v3
	}	}
	else {	else {
	if (treedata->vert == NULL) {	normal_short_to_float_v3(r_no, me->mvert[index].no);
	treedata->vert = DM_get_vert_array(dm, &treedata->vert_allocated);	mul_mat3_m4_v3(sodraw->obmat, r_no);
	}
	if ((tree_index == 1) && (treedata->edge == NULL)) {
	treedata->edge = DM_get_edge_array(dm, &treedata->edge_allocated);
	}
	}	}
		normalize_v3(r_no);
		}

		if (r_index) {
		*r_index = index;
	}	}
	}	}

	if (treedata) {	if (r_ob)
	if (treedata->tree == NULL) {	*r_ob = sodraw->ob;
	switch (snapdata->snap_to) {	if (r_obmat)
	case SCE_SNAP_MODE_EDGE:	copy_m4_m4(r_obmat, sodraw->obmat);
	bvhtree_from_mesh_edges(treedata, dm, 0.0f, 2, 6);
	break;
	case SCE_SNAP_MODE_VERTEX:
	bvhtree_from_mesh_verts(treedata, dm, 0.0f, 2, 6);
	break;
	}
	}
	if (treedata->tree == NULL) {
	return retval;
	}
	}
	else {
	return retval;
	}

	/* Warning: the depth_max is currently being used only in perspective view.
	* It is not correct to limit the maximum depth for elements obtained with nearest
	* since this limitation depends on the normal and the size of the occlusion face.
	* And more... ray_depth is being confused with Z-depth here... (varies only the precision) */
	const float ray_depth_max_global = *ray_depth + snapdata->depth_range[0];

	Nearest2dUserData neasrest2d = {
	.dist_px_sq = SQUARE(*dist_px),
	.r_axis_closest = {1.0f, 1.0f, 1.0f},
	.depth_range = {snapdata->depth_range[0], ray_depth_max_global},
	.userdata = treedata,
	.get_edge_verts = (Nearest2DGetEdgeVertsCallback)get_dm_edge_verts,
	.copy_vert_no = (Nearest2DCopyVertNoCallback)copy_dm_vert_no,
	.index = -1};

	dist_squared_to_projected_aabb_precalc(
	&neasrest2d.data_precalc, lpmat,
	snapdata->view_proj == VIEW_PROJ_PERSP, snapdata->win_half,
	ray_min_dist, snapdata->mval, ray_org_local, ray_normal_local);

	BVHTree_WalkLeafCallback cb_walk_leaf =
	(snapdata->snap_to == SCE_SNAP_MODE_VERTEX) ?
	cb_walk_leaf_snap_vert : cb_walk_leaf_snap_edge;

	BLI_bvhtree_walk_dfs(
	treedata->tree,
	cb_walk_parent_snap_project, cb_walk_leaf, cb_nearest_walk_order, &neasrest2d);

	if (neasrest2d.index != -1) {
	copy_v3_v3(r_loc, neasrest2d.co);
	mul_m4_v3(obmat, r_loc);
	if (r_no) {
	copy_v3_v3(r_no, neasrest2d.no);
	mul_m3_v3(timat, r_no);
	normalize_v3(r_no);
	}
	*dist_px = sqrtf(neasrest2d.dist_px_sq);
	*ray_depth = depth_get(r_loc, snapdata->ray_start, snapdata->ray_dir);

	retval = true;
	}

	return retval;	return elem_type;
	}	}

	static bool snapEditMesh(
	SnapObjectContext sctx, SnapData snapdata,
	Object ob, BMEditMesh em, float obmat[4][4],
	/* read/write args */
	float ray_depth, float dist_px,
	/* return args */
	float r_loc[3], float r_no[3])
	{
	bool retval = false;

	if (snapdata->snap_to == SCE_SNAP_MODE_EDGE) {
	if (em->bm->totedge == 0) {
	return retval;
	}
	}
	else {
	if (em->bm->totvert == 0) {
	return retval;
	}
	}

	float imat[4][4];
	float timat[3][3]; /* transpose inverse matrix for normals */
	float ray_normal_local[3];

	invert_m4_m4(imat, obmat);	static void snap_mesh_draw_init(
	transpose_m3_m4(timat, imat);	SnapObjectContext sctx, Mesh me, SnapObjectData *sod,
		const unsigned short snap_to_flag)
		{
		{
		sod->ebo_tris = sod->ebo_edges = sod->ebo_verts = -1;
		sod->tot_tri_elem = sod->tot_edge_elem = sod->tot_vert_elem = 0;

	copy_v3_v3(ray_normal_local, snapdata->ray_dir);	glGenVertexArrays(1, &sod->vao);
		glBindVertexArray(sod->vao);
		glGenBuffers(1, &sod->vbo);
		glBindBuffer(GL_ARRAY_BUFFER, sod->vbo);

	mul_mat3_m4_v3(imat, ray_normal_local);	GLuint attr_pos = glGetAttribLocation(GPU_shader_get_program(sctx->tris_depth_shader), "pos");
		glEnableVertexAttribArray(attr_pos);
		glVertexAttribPointer(attr_pos, 3, GL_FLOAT, GL_FALSE, 0, NULL);

	/* local scale in normal direction */	attr_pos = glGetAttribLocation(GPU_shader_get_program(sctx->indices_shader), "pos");
	float local_scale = normalize_v3(ray_normal_local);	glEnableVertexAttribArray(attr_pos);
		glVertexAttribPointer(attr_pos, 3, GL_FLOAT, GL_FALSE, 0, NULL);
	SnapObjectData_EditMesh *sod = NULL;
	BVHTreeFromEditMesh *treedata = NULL;

	void **sod_p;	if (sod->type == SNAP_MESH) {
	if (BLI_ghash_ensure_p(sctx->cache.object_map, ob, &sod_p)) {	const int vbo_len_capacity = sod->vbo_len_capacity = me->totvert;
	sod = *sod_p;	{
	}	float (data)[3] = MEM_mallocN(vbo_len_capacity sizeof(*data), __func__);
	else {	MVert *mvert = me->mvert;
	sod = sod_p = BLI_memarena_calloc(sctx->cache.mem_arena, sizeof(sod));	for (int i = 0; i < vbo_len_capacity; ++i) {
	sod->sd.type = SNAP_EDIT_MESH;	copy_v3_v3(data[i], mvert[i].co);
	}	}
		glBufferData(GL_ARRAY_BUFFER, vbo_len_capacity * sizeof(*data), data, GL_STATIC_DRAW);
		MEM_freeN(data);
		}
		/* CACHE TRIS */
		{
		int tri_len = poly_to_tri_count(me->totpoly, me->totloop);
		sod->tot_tri_elem = tri_len * 3;
		uint (data)[3] = MEM_mallocN(tri_len sizeof(*data), __func__);
		MLoopTri mlooptri = MEM_mallocN(sizeof(MLoopTri) tri_len, __func__);
		BKE_mesh_recalc_looptri(me->mloop, me->mpoly, me->mvert, me->totloop, me->totpoly, mlooptri);
		const MLoopTri *mlt = &mlooptri[0];
		for (int i = 0; i < tri_len; i++, mlt++) {
		data[i][0] = me->mloop[mlt->tri[0]].v;
		data[i][1] = me->mloop[mlt->tri[1]].v;
		data[i][2] = me->mloop[mlt->tri[2]].v;
		}
		glGenBuffers(1, &sod->ebo_tris);
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, sod->ebo_tris);
		glBufferData(GL_ELEMENT_ARRAY_BUFFER, tri_len * sizeof(*data), data, GL_STATIC_DRAW);
		MEM_freeN(mlooptri);
		MEM_freeN(data);
		}
		/* CACHE EDGES */
		if (snap_to_flag & SNAP_EDGE) {
		const int edge_len = me->totedge;
		sod->tot_edge_elem = edge_len * 2;
		uint (data)[2] = MEM_mallocN(edge_len sizeof(*data), __func__);
		const MEdge *ed = me->medge;
		for (int i = 0; i < edge_len; i++, ed++) {
		data[i][0] = ed->v1;
		data[i][1] = ed->v2;
		}
		glGenBuffers(1, &sod->ebo_edges);
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, sod->ebo_edges);
		glBufferData(GL_ELEMENT_ARRAY_BUFFER, edge_len * sizeof(*data), data, GL_STATIC_DRAW);
		MEM_freeN(data);
		}

	int tree_index = -1;	/* CACHE VERTS */
	switch (snapdata->snap_to) {	if (snap_to_flag & SNAP_VERT) {
	case SCE_SNAP_MODE_EDGE:	/* use vao */
	tree_index = 1;	sod->tot_vert_elem = vbo_len_capacity;
	break;	}
	case SCE_SNAP_MODE_VERTEX:
	tree_index = 0;
	break;
	}
	if (tree_index != -1) {
	if (sod->bvh_trees[tree_index] == NULL) {
	sod->bvh_trees[tree_index] = BLI_memarena_calloc(sctx->cache.mem_arena, sizeof(*treedata));
	}	}
	treedata = sod->bvh_trees[tree_index];	else { /* sod->type == SNAP_EDIT_MESH */
	}	BMEditMesh *embm = me->edit_btmesh;
		BMesh *bm = embm->bm;
		BMIter iter;
		BMVert *eve;
		uint i;
		const int vbo_len_capacity = sod->vbo_len_capacity = bm->totvert;
		{
		float (data)[3] = MEM_mallocN(vbo_len_capacity sizeof(*data), __func__);
		BM_ITER_MESH_INDEX(eve, &iter, bm, BM_VERTS_OF_MESH, i) {
		copy_v3_v3(data[i], eve->co);
		}
		BLI_assert(i == vbo_len_capacity);
		glBufferData(GL_ARRAY_BUFFER, vbo_len_capacity * sizeof(*data), data, GL_STATIC_DRAW);
		MEM_freeN(data);
		}
		/* CACHE TRIS */
		{
		int tottri = embm->tottri;
		int looptri_num_active = 0;
		BLI_bitmap *mask = NULL;
		if (sctx->callbacks.edit_mesh.test_face_fn) {
		/* Obtain the actual amount of primitives */
		mask = BLI_BITMAP_NEW(tottri, __func__);
		looptri_num_active = BM_iter_mesh_bitmap_from_filter_tessface(
		bm, mask,
		sctx->callbacks.edit_mesh.test_face_fn, sctx->callbacks.edit_mesh.user_data);
		}
		else {
		looptri_num_active = tottri;
		}

	if (treedata) {	if (looptri_num_active) {
	if (treedata->tree == NULL) {	sod->tot_tri_elem = looptri_num_active * 3;
	BLI_bitmap *elem_mask = NULL;	uint (data)[3] = MEM_mallocN(looptri_num_active sizeof(*data), __func__);
	switch (snapdata->snap_to) {	uint *tri = data[0];
	case SCE_SNAP_MODE_EDGE:	for (int i = 0; i < tottri; ++i) {
	{	const BMLoop ltri = (const BMLoop )embm->looptris[i];
	int edges_num_active = -1;	if (mask) {
	if (sctx->callbacks.edit_mesh.test_edge_fn) {	if (!BLI_BITMAP_TEST_BOOL(mask, i))
	elem_mask = BLI_BITMAP_NEW(em->bm->totedge, __func__);	continue;
	edges_num_active = BM_iter_mesh_bitmap_from_filter(	}
	BM_EDGES_OF_MESH, em->bm, elem_mask,	else if (BM_elem_flag_test(ltri[0]->f, BM_ELEM_HIDDEN)) { /* RESIZE looptri_num_active??? */
	(bool ()(BMElem , void *))sctx->callbacks.edit_mesh.test_edge_fn,	continue;
	sctx->callbacks.edit_mesh.user_data);	}
		tri[0] = BM_elem_index_get(ltri[0]->v);
		tri[1] = BM_elem_index_get(ltri[1]->v);
		tri[2] = BM_elem_index_get(ltri[2]->v);
		tri += 3;
	}	}
	bvhtree_from_editmesh_edges_ex(treedata, em, elem_mask, edges_num_active, 0.0f, 2, 6);	glGenBuffers(1, &sod->ebo_tris);
	break;	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, sod->ebo_tris);
		glBufferData(GL_ELEMENT_ARRAY_BUFFER, looptri_num_active * sizeof(*data), data, GL_STATIC_DRAW);
		MEM_freeN(data);
	}	}
	case SCE_SNAP_MODE_VERTEX:	if (mask)
	{	MEM_freeN(mask);
	int verts_num_active = -1;	}
	if (sctx->callbacks.edit_mesh.test_vert_fn) {	/* CACHE EDGES */
	elem_mask = BLI_BITMAP_NEW(em->bm->totvert, __func__);	if (snap_to_flag & SNAP_EDGE) {
	verts_num_active = BM_iter_mesh_bitmap_from_filter(	int edge_len;
	BM_VERTS_OF_MESH, em->bm, elem_mask,	BLI_bitmap *mask = NULL;
	(bool ()(BMElem , void *))sctx->callbacks.edit_mesh.test_vert_fn,	BMEdge *eed;
	sctx->callbacks.edit_mesh.user_data);	if (sctx->callbacks.edit_mesh.test_edge_fn) {
		/* Obtain the actual amount of primitives */
		mask = BLI_BITMAP_NEW(bm->totedge, __func__);
		edge_len = BM_iter_mesh_bitmap_from_filter(
		BM_EDGES_OF_MESH, bm, mask,
		(bool()(BMElem , void *))sctx->callbacks.edit_mesh.test_edge_fn,
		sctx->callbacks.edit_mesh.user_data);
		}
		else {
		edge_len = bm->totedge;
		}

		if (edge_len) {
		sod->tot_edge_elem = edge_len * 2;
		uint (data)[2] = MEM_mallocN(edge_len sizeof(*data), __func__);
		uint *edg = data[0];
		BM_ITER_MESH_INDEX(eed, &iter, bm, BM_EDGES_OF_MESH, i) {
		if (mask && !BLI_BITMAP_TEST_BOOL(mask, i)) {
		continue;
		}
		edg[0] = BM_elem_index_get(eed->v1);
		edg[1] = BM_elem_index_get(eed->v2);
		edg += 2;
	}	}
	bvhtree_from_editmesh_verts_ex(treedata, em, elem_mask, verts_num_active, 0.0f, 2, 6);	glGenBuffers(1, &sod->ebo_edges);
	break;	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, sod->ebo_edges);
		glBufferData(GL_ELEMENT_ARRAY_BUFFER, edge_len * sizeof(*data), data, GL_STATIC_DRAW);
		MEM_freeN(data);
	}	}
		if (mask)
		MEM_freeN(mask);
	}	}
	if (elem_mask) {
	MEM_freeN(elem_mask);	/* CACHE VERTS */
		if (snap_to_flag & SNAP_VERT) {
		BLI_bitmap *mask = NULL;
		if (sctx->callbacks.edit_mesh.test_vert_fn) {
		mask = BLI_BITMAP_NEW(bm->totvert, __func__);
		int vert_len = BM_iter_mesh_bitmap_from_filter(
		BM_VERTS_OF_MESH, bm, mask,
		(bool()(BMElem , void *))sctx->callbacks.edit_mesh.test_vert_fn,
		sctx->callbacks.edit_mesh.user_data);

		if (vert_len) {
		sod->tot_vert_elem = vert_len;
		uint data = MEM_mallocN(vert_len sizeof(*data), __func__);
		uint *v = &data[0];
		BM_ITER_MESH_INDEX(eve, &iter, bm, BM_VERTS_OF_MESH, i) {
		if (BLI_BITMAP_TEST_BOOL(mask, i)) {
		v[0] = BM_elem_index_get(eve);
		v++;
		}
		}
		glGenBuffers(1, &sod->ebo_verts);
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, sod->ebo_verts);
		glBufferData(GL_ELEMENT_ARRAY_BUFFER, vert_len * sizeof(*data), data, GL_STATIC_DRAW);
		MEM_freeN(data);
		}
		if (mask)
		MEM_freeN(mask);
		}
		else {
		/* use vbo */
		sod->tot_vert_elem = vbo_len_capacity;
		}
	}	}
	}	}
	if (treedata->tree == NULL) {	glBindVertexArray(0);
	return retval;	}
		}


		static void snap_mesh_draw_depth(SnapObjectContext sctx, SnapObjectData sod)
		{
		glUseProgram(GPU_shader_get_program(sctx->tris_depth_shader));
		gpuBindMatrices(GPU_shader_get_interface(sctx->tris_depth_shader));
		glBindVertexArray(sod->vao);
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, sod->ebo_tris);
		glDrawElements(GL_TRIANGLES, sod->tot_tri_elem, GL_UNSIGNED_INT, NULL);
		glUseProgram(0);
		}

		static void snap_mesh_draw_indices(SnapObjectContext *sctx,
		SnapObjectData *sod, const unsigned int index_offset, const unsigned short snap_to_flag)
		{
		glUseProgram(GPU_shader_get_program(sctx->indices_shader));
		gpuBindMatrices(GPU_shader_get_interface(sctx->indices_shader));
		glBindVertexArray(sod->vao);

		if ((snap_to_flag & SNAP_VERT) && sod->tot_vert_elem) {
		glUniform1ui(GPU_shader_get_uniform(sctx->indices_shader, "offset"), index_offset);
		if (sod->ebo_verts != -1) {
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, sod->ebo_verts);
		glDrawElements(GL_POINTS, sod->tot_vert_elem, GL_UNSIGNED_INT, NULL);
		}
		else {
		glBindBuffer(GL_ARRAY_BUFFER, sod->vbo);
		glDrawArrays(GL_POINTS, 0, sod->tot_vert_elem);
	}	}
	}	}
	else {	if ((snap_to_flag & SNAP_EDGE) && sod->tot_edge_elem) {
	return retval;	glUniform1ui(GPU_shader_get_uniform(sctx->indices_shader, "offset"), index_offset + sod->tot_vert_elem);
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, sod->ebo_edges);
		glDrawElements(GL_LINES, sod->tot_edge_elem, GL_UNSIGNED_INT, NULL);
	}	}
		glUseProgram(0);
		}

	float ray_org_local[3];
	copy_v3_v3(ray_org_local, snapdata->ray_origin);
	mul_m4_v3(imat, ray_org_local);

	Nearest2dUserData neasrest2d = {
	.dist_px_sq = SQUARE(*dist_px),
	.r_axis_closest = {1.0f, 1.0f, 1.0f},
	.depth_range = {snapdata->depth_range[0], *ray_depth + snapdata->depth_range[0]},
	.userdata = treedata,
	.get_edge_verts = (Nearest2DGetEdgeVertsCallback)get_bedge_verts,
	.copy_vert_no = (Nearest2DCopyVertNoCallback)copy_bvert_no,
	.index = -1};

	float lpmat[4][4];
	mul_m4_m4m4(lpmat, snapdata->pmat, obmat);
	dist_squared_to_projected_aabb_precalc(
	&neasrest2d.data_precalc, lpmat,
	snapdata->view_proj == VIEW_PROJ_PERSP, snapdata->win_half,
	(snapdata->depth_range[0] * local_scale), snapdata->mval,
	ray_org_local, ray_normal_local);

	BVHTree_WalkLeafCallback cb_walk_leaf =
	(snapdata->snap_to == SCE_SNAP_MODE_VERTEX) ?
	cb_walk_leaf_snap_vert : cb_walk_leaf_snap_edge;

	BLI_bvhtree_walk_dfs(
	treedata->tree,
	cb_walk_parent_snap_project, cb_walk_leaf, cb_nearest_walk_order, &neasrest2d);

	if (neasrest2d.index != -1) {
	copy_v3_v3(r_loc, neasrest2d.co);
	mul_m4_v3(obmat, r_loc);
	if (r_no) {
	copy_v3_v3(r_no, neasrest2d.no);
	mul_m3_v3(timat, r_no);
	normalize_v3(r_no);
	}
	*dist_px = sqrtf(neasrest2d.dist_px_sq);
	*ray_depth = depth_get(r_loc, snapdata->ray_start, snapdata->ray_dir);

	retval = true;	static unsigned int sctx_offset_get(SnapObjectContext *sctx)
		{
		SnapObjectDraw *prev_sodraw = sctx->dinamic.last_sodraw;
		if (prev_sodraw) {
		SnapObjectData *prev_sod = prev_sodraw->sod;
		unsigned int prev_index_ct = 0;
		if (sctx->dinamic.snap_to_flag & SNAP_VERT) {
		prev_index_ct = prev_sod->tot_vert_elem;
		}
		if (sctx->dinamic.snap_to_flag & SNAP_EDGE) {
		prev_index_ct += prev_sod->tot_edge_elem / 2;
		}
		return prev_sodraw->index_offset + prev_index_ct;
	}	}
		return 0;
	return retval;
	}	}

	/**
	* \param use_obedit: Uses the coordinates of BMesh (if any) to do the snapping;
	*
	* \note Duplicate args here are documented at #snapObjectsRay
	*/
	static bool snapObject(
	SnapObjectContext sctx, SnapData snapdata,
	Object *ob, float obmat[4][4],
	bool use_obedit,
	/* read/write args */
	float ray_depth, float dist_px,
	/* return args */
	float r_loc[3], float r_no[3],
	Object **r_ob, float r_obmat[4][4])
	{
	bool retval = false;

	if (ob->type == OB_MESH) {	static void snap_object_draw_imp(SnapObjectContext sctx, SnapObjectDraw sodraw, bool is_obedit)
	BMEditMesh *em;	{
		if (sodraw->ob->type == OB_MESH) {
		BLI_assert(sodraw->sod == NULL);
		float MVP[4][4];
		mul_m4_m4m4(MVP, sctx->dinamic.pmat, sodraw->obmat);

		/* Test BoundBox */
		BoundBox *bb = BKE_object_boundbox_get(sodraw->ob);
		if (bb) {
		float imat[4][4];
		float ray_dir_local[3], ray_org_local[3];

		invert_m4_m4(imat, sodraw->obmat);
		mul_v3_m4v3(ray_org_local, imat, sctx->dinamic.ray_orig);
		mul_v3_mat3_m4v3(ray_dir_local, imat, sctx->dinamic.ray_dir);

		/* In vertex and edges you need to get the pixel distance from ray to BoundBox, see: T46099, T46816 */
		if (!isect_boundbox_threshold(sctx, MVP, ray_org_local, ray_dir_local, bb->vec[0], bb->vec[6])) {
		return;
		}
		}

	if (use_obedit) {	void **sod_p;
	em = BKE_editmesh_from_object(ob);	if (BLI_ghash_ensure_p(sctx->cache.object_map, sodraw->ob, &sod_p)) {
	retval = snapEditMesh(	sodraw->sod = *sod_p;
	sctx, snapdata, ob, em, obmat,	if (sodraw->sod->vao == 0) {
	ray_depth, dist_px,	/* It may have been created on raycast */
	r_loc, r_no);	snap_mesh_draw_init(sctx, sodraw->ob->data, sodraw->sod, sctx->dinamic.snap_to_flag);
		}
	}	}
	else {	else {
	/* in this case we want the mesh from the editmesh, avoids stale data. see: T45978.	sodraw->sod = sod_p = BLI_memarena_calloc(sctx->cache.mem_arena, sizeof(sodraw->sod));
	* still set the 'em' to NULL, since we only want the 'dm'. */	sodraw->sod->type = is_obedit ? SNAP_EDIT_MESH : SNAP_MESH;
	DerivedMesh *dm;	snap_mesh_draw_init(sctx, sodraw->ob->data, sodraw->sod, sctx->dinamic.snap_to_flag);
	em = BKE_editmesh_from_object(ob);
	if (em) {
	editbmesh_get_derived_cage_and_final(&sctx->eval_ctx, sctx->scene, ob, em, CD_MASK_BAREMESH, &dm);
	}
	else {
	dm = mesh_get_derived_final(&sctx->eval_ctx, sctx->scene, ob, CD_MASK_BAREMESH);
	}
	retval = snapDerivedMesh(
	sctx, snapdata, ob, dm, obmat,
	ray_depth, dist_px,
	r_loc, r_no);

	dm->release(dm);
	}	}
		sodraw->index_offset = sctx_offset_get(sctx);

		BLI_remlink(&sctx->dinamic.snap_obj_list, sodraw);
		BLI_insertlinkafter(&sctx->dinamic.snap_obj_list, sctx->dinamic.last_sodraw, sodraw);
		sctx->dinamic.last_sodraw = sodraw;

		gpuLoadMatrix(sodraw->obmat);
		snap_mesh_draw_depth(sctx, sodraw->sod);
		glDepthRange(-0.00005, 0.99995);
		snap_mesh_draw_indices(sctx, sodraw->sod, sodraw->index_offset, sctx->dinamic.snap_to_flag);
		glDepthRange(0.0, 1.0);
	}	}
	else if (snapdata->snap_to != SCE_SNAP_MODE_FACE) {	}
	if (ob->type == OB_ARMATURE) {
	retval = snapArmature(
	snapdata,	static void snap_object_create_list_cb(
	ob, ob->data, obmat,	SnapObjectContext *sctx,
	ray_depth, dist_px,	bool UNUSED(is_obedit), Object ob, float obmat[4][4], void UNUSED(data))
	r_loc, r_no);	{
	}	SnapObjectDraw sodraw = MEM_callocN(sizeof(sodraw), __func__);
	else if (ob->type == OB_CURVE) {	copy_m4_m4(sodraw->obmat, obmat);
	retval = snapCurve(	sodraw->ob = ob;
	snapdata,	BLI_addtail(&sctx->dinamic.snap_obj_list, sodraw);
	ob, ob->data, obmat,	}
	ray_depth, dist_px,
	r_loc, r_no);
	}	static void draw_mesh_objects(struct SnapObjectContext *sctx)
	else if (ob->type == OB_EMPTY) {	{
	retval = snapEmpty(	//glGetIntegerv(GL_FRAMEBUFFER_BINDING, &cur_fb); /* The bounded framebuffer can not be the default */
	snapdata,	GPU_framebuffer_bind(sctx->fbo.fbo);
	ob, obmat,
	ray_depth, dist_px,	/* Temporarily change the viewport value
	r_loc, r_no);	* This is necessary because the viewport is not part of the framebuffer state */
		gpuPushAttrib(GPU_DEPTH_BUFFER_BIT \| GPU_SCISSOR_BIT \| GPU_VIEWPORT_BIT);
		glViewport(0, 0, sctx->fbo.sizex, sctx->fbo.sizey);
		glEnable(GL_DEPTH_TEST);
		glDisable(GL_SCISSOR_TEST);

		//glLineWidth(2);
		glPointSize(2);

		RegionView3D *rv3d = sctx->v3d_data.ar->regiondata;
		const float (*pmat)[4] = rv3d->persmat;
		if (!compare_m4m4(sctx->dinamic.pmat, pmat, FLT_EPSILON)) { /* Viewport changed position */
		copy_m4_m4(sctx->dinamic.pmat, pmat);

		/* Restarts drawing */
		sctx->dinamic.last_sodraw = NULL;
		glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);

		if (sctx->fbo.out_bound_dist) {
		/* Transform matrix to draw offsets of pixels outside the viewport limit */
		float offset = 2 * sctx->fbo.out_bound_dist;
		copy_m4_m4(sctx->dinamic.pmat_resized, rv3d->winmat);
		sctx->dinamic.pmat_resized[0][0] *= sctx->fbo.sizex / (sctx->fbo.sizex + offset);
		sctx->dinamic.pmat_resized[1][1] *= sctx->fbo.sizey / (sctx->fbo.sizey + offset);
		sctx->dinamic.pmat_resized[2][0] *= 1.0f - offset / sctx->fbo.sizex;
		sctx->dinamic.pmat_resized[2][1] *= 1.0f - offset / sctx->fbo.sizey;
		mul_m4_m4_post(sctx->dinamic.pmat_resized, rv3d->viewmat);
	}	}
	else if (ob->type == OB_CAMERA) {	else {
	retval = snapCamera(	copy_m4_m4(sctx->dinamic.pmat_resized, pmat);
	sctx, snapdata, ob, obmat,
	ray_depth, dist_px,
	r_loc, r_no);
	}	}
	}	}

	if (retval) {	Object *obedit = sctx->use_object_edit_cage ? sctx->scene->obedit : NULL;
	if (r_ob) {
	*r_ob = ob;	gpuPushProjectionMatrix();
	copy_m4_m4(r_obmat, obmat);	gpuLoadProjectionMatrix(sctx->dinamic.pmat_resized);
	}	gpuPushMatrix();

		SnapObjectDraw *sodraw =
		sctx->dinamic.last_sodraw ? /* No need to test the bound box of objects already drawn */
		sctx->dinamic.last_sodraw->next :
		sctx->dinamic.snap_obj_list.first;

		for (; sodraw; sodraw = sodraw->next) {
		bool is_obedit = obedit && sodraw->ob->data == obedit->data;
		snap_object_draw_imp(sctx, sodraw, is_obedit);
	}	}

	return retval;	gpuPopMatrix();
		gpuPopProjectionMatrix();

		//glLineWidth(1);

		/* Reset framebuffer and viewport */
		gpuPopAttrib();
		glBindFramebuffer(GL_FRAMEBUFFER, 0);
	}	}


	struct SnapObjUserData {	static unsigned int get_nearest_pixel(unsigned int *pixels, const int threshold, int dist_px) {
	SnapData *snapdata;	/* First check if the list is empty */
	/* read/write args */	int x, y, d, m = threshold * threshold;
	float *ray_depth;	for (d = 0; d < m; d++) {
	float *dist_px;	if (pixels[d]) goto spiral_loop;
	/* return args */	}
	float *r_loc;	return 0;
	float *r_no;	spiral_loop:
	Object **r_ob;	/* Starting from the center of the threshold,
	float (*r_obmat)[4];	* the loop goes around the pixel in the form of a spiral square */
	bool ret;	x = dist_px;
	};	y = dist_px;
		d = 1;
		m = 1 + 2 * dist_px;
		unsigned int value;
		while (true) {
		while (2 * x * d < m) {
		value = pixels[y * threshold + x];
		if (value) return value;
		x += d;
		}
		while (2 * y * d < m) {
		value = pixels[y * threshold + x];
		if (value) return value;
		y += d;
		}
		d *= -1;
		m += 4 * dist_px * d + 1;
		}
		return 0; /* unnecessary return */
		}


	static void sanp_obj_cb(SnapObjectContext sctx, bool is_obedit, Object ob, float obmat[4][4], void *data)	static unsigned int snap_object_read_framebuffer(SnapObjectContext *sctx)
	{	{
	struct SnapObjUserData *dt = data;	int offset = sctx->fbo.out_bound_dist - sctx->dinamic.dist_px;
	dt->ret \|= snapObject(	int x = sctx->dinamic.mval[0] + offset;
	sctx, dt->snapdata,	int y = sctx->dinamic.mval[1] + offset;
	ob, obmat, is_obedit,	int threshold = 2 * sctx->dinamic.dist_px + 1;
	/* read/write args */
	dt->ray_depth, dt->dist_px,	unsigned int pixels = MEM_callocN(sizeof(pixels) * SQUARE(threshold), __func__);
	/* return args */
	dt->r_loc, dt->r_no,	GPU_framebuffer_bind(sctx->fbo.fbo);
	dt->r_ob, dt->r_obmat);	glReadPixels(x, y, threshold, threshold, GL_RED_INTEGER, GL_UNSIGNED_INT, pixels);
		GPU_framebuffer_restore();

		//print_array(pixels, threshold);
		unsigned int index = get_nearest_pixel(pixels, threshold, sctx->dinamic.dist_px);
		MEM_freeN(pixels);

		return index;
	}	}


Context not available.
	* \param r_obmat: Object matrix (may not be #Object.obmat with dupli-instances).	* \param r_obmat: Object matrix (may not be #Object.obmat with dupli-instances).
	*	*
	*/	*/
	static bool snapObjectsRay(	static unsigned int snapObjectsRay(
	SnapObjectContext sctx, SnapData snapdata,	SnapObjectContext *sctx,
	const SnapSelect snap_select, const bool use_object_edit_cage,
	/* read/write args */
	float ray_depth, float dist_px,
	/* return args */	/* return args */
	float r_loc[3], float r_no[3],	float r_loc[3], float r_no[3],
	Object **r_ob, float r_obmat[4][4])	Object *r_ob, float r_obmat[4][4], int r_index)
	{	{
	Object *obedit = use_object_edit_cage ? sctx->scene->obedit : NULL;	unsigned int retval = 0;

	struct SnapObjUserData data = {	if (snap_non_mesh_objects(sctx, r_loc, r_no, r_ob, r_obmat)) { /* TODO: All objects should be drawn */
	.snapdata = snapdata,	retval = SCE_SELECT_POINT;
	.ray_depth = ray_depth,	*r_index = 0;
	.dist_px = dist_px,	}
	.r_loc = r_loc,
	.r_no = r_no,
	.r_ob = r_ob,
	.r_obmat = r_obmat,
	.ret = false,
	};

	iter_snap_objects(sctx, snap_select, obedit, sanp_obj_cb, &data);	draw_mesh_objects(sctx);

	return data.ret;	unsigned int index = snap_object_read_framebuffer(sctx);
		if (index) {
		retval = snap_object_drawn_get_returns(sctx, index, r_loc, r_no, r_ob, r_obmat, r_index);
		}

		return retval;
		}


		static void init_nearest2d_search(SnapObjectContext *sctx)
		{
		const ARegion *ar = sctx->v3d_data.ar;

		iter_snap_objects(sctx, snap_object_create_list_cb, NULL); /* Stores a list of all objects to snap */

		sctx->tris_depth_shader = GPU_shader_get_builtin_shader(GPU_SHADER_3D_OUTPUT_0_U32);
		sctx->indices_shader = GPU_shader_get_builtin_shader(GPU_SHADER_3D_PRIMITIVE_ID_UNIFORM_OFFSET_U32);

		sctx->fbo.depth = GPU_texture_create_depth(sctx->fbo.sizex, sctx->fbo.sizey, __func__);
		sctx->fbo.indices = GPU_texture_create_2D_custom(
		sctx->fbo.sizex, sctx->fbo.sizey, 1, GPU_R32UI, NULL, __func__);

		sctx->fbo.fbo = GPU_framebuffer_create();
		GPU_framebuffer_texture_attach(sctx->fbo.fbo, sctx->fbo.depth, 0, 0);
		GPU_framebuffer_texture_attach(sctx->fbo.fbo, sctx->fbo.indices, 0, 0);

		#if DRAW_FRAMEBUFFER_ON_SCREEN
		init_debug_drawing(sctx);
		#endif
	}	}

	/** \} */	/** \} */
Context not available.
	* \{ */	* \{ */

	SnapObjectContext *ED_transform_snap_object_context_create(	SnapObjectContext *ED_transform_snap_object_context_create(
	Main bmain, Scene scene, SceneLayer *sl, int flag)	Main bmain, Scene scene, SceneLayer *sl, const SnapSelect snap_select, bool use_object_edit_cage)
	{	{
	SnapObjectContext sctx = MEM_callocN(sizeof(sctx), __func__);	SnapObjectContext sctx = MEM_callocN(sizeof(sctx), __func__); /* TODO: sizeof is much larger than necessary */

	sctx->flag = flag;

	sctx->bmain = bmain;	sctx->bmain = bmain;
	sctx->scene = scene;	sctx->scene = scene;

	DEG_evaluation_context_init_from_scene(&sctx->eval_ctx, scene, sl, DAG_EVAL_VIEWPORT);	DEG_evaluation_context_init_from_scene(&sctx->eval_ctx, scene, sl, DAG_EVAL_VIEWPORT);

		sctx->snap_select = snap_select;
		sctx->use_object_edit_cage = use_object_edit_cage;

	sctx->cache.object_map = BLI_ghash_ptr_new(__func__);	sctx->cache.object_map = BLI_ghash_ptr_new(__func__);
	sctx->cache.mem_arena = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, __func__);	sctx->cache.mem_arena = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, __func__);

Context not available.
	}	}

	SnapObjectContext *ED_transform_snap_object_context_create_view3d(	SnapObjectContext *ED_transform_snap_object_context_create_view3d(
	Main bmain, Scene scene, SceneLayer *sl, int flag,	Main bmain, Scene scene, SceneLayer *sl, const SnapSelect snap_select, bool use_object_edit_cage,
	/* extra args for view3d */	/* extra args for view3d */
	const ARegion ar, const View3D v3d)	const ARegion ar, const View3D v3d, const int out_bound_dist)
	{	{
	SnapObjectContext *sctx = ED_transform_snap_object_context_create(bmain, scene, sl, flag);	assert(out_bound_dist < (ar->winy / 2) && out_bound_dist < (ar->winx / 2)); /* out_bound_dist has a direct influence on memory */

		SnapObjectContext *sctx = ED_transform_snap_object_context_create(bmain, scene, sl, snap_select, use_object_edit_cage);

	sctx->use_v3d = true;	sctx->use_v3d = true;
	sctx->v3d_data.ar = ar;	sctx->v3d_data.ar = ar;
	sctx->v3d_data.v3d = v3d;	sctx->v3d_data.v3d = v3d;

		sctx->fbo.sizex = ar->winx + 2 * out_bound_dist;
		sctx->fbo.sizey = ar->winy + 2 * out_bound_dist;
		sctx->fbo.out_bound_dist = out_bound_dist;

		//init_nearest2d_search(sctx);

	return sctx;	return sctx;
	}	}

	static void snap_object_data_free(void *sod_v)	static void snap_object_data_free(void *sod_v)
	{	{
	switch (((SnapObjectData *)sod_v)->type) {	SnapObjectData *sod = sod_v;
		switch (sod->type) {
	case SNAP_MESH:	case SNAP_MESH:
	{	free_bvhtree_from_mesh(&sod->bvhtree.from_mesh);
	SnapObjectData_Mesh *sod = sod_v;
	for (int i = 0; i < ARRAY_SIZE(sod->bvh_trees); i++) {
	if (sod->bvh_trees[i]) {
	free_bvhtree_from_mesh(sod->bvh_trees[i]);
	}
	}
	if (sod->poly_allocated) {
	MEM_freeN(sod->mpoly);
	}
	break;	break;
	}
	case SNAP_EDIT_MESH:	case SNAP_EDIT_MESH:
		brechtUnsubmitted Done Inline Actions This should be `outColor = 0u;` brecht: This should be `outColor = 0u;`
	{	free_bvhtree_from_editmesh(&sod->bvhtree.from_editmesh);
	SnapObjectData_EditMesh *sod = sod_v;
	for (int i = 0; i < ARRAY_SIZE(sod->bvh_trees); i++) {
	if (sod->bvh_trees[i]) {
	free_bvhtree_from_editmesh(sod->bvh_trees[i]);
	}
	}
	break;	break;
	}	}
		if (sod->vao) {
		if (sod->vbo != -1) glDeleteBuffers(1, &sod->vbo);
		if (sod->ebo_tris != -1) glDeleteBuffers(1, &sod->ebo_tris);
		if (sod->ebo_edges != -1) glDeleteBuffers(1, &sod->ebo_edges);
		if (sod->ebo_verts != -1) glDeleteBuffers(1, &sod->ebo_verts);
		glDeleteVertexArrays(1, &sod->vao);
	}	}
	}	}


	void ED_transform_snap_object_context_destroy(SnapObjectContext *sctx)	void ED_transform_snap_object_context_destroy(SnapObjectContext *sctx)
	{	{
	BLI_ghash_free(sctx->cache.object_map, NULL, snap_object_data_free);	BLI_ghash_free(sctx->cache.object_map, NULL, snap_object_data_free);
	BLI_memarena_free(sctx->cache.mem_arena);	BLI_memarena_free(sctx->cache.mem_arena);

		if (sctx->use_v3d && sctx->nearest2d_inited) {
		GPU_framebuffer_free(sctx->fbo.fbo);
		GPU_texture_free(sctx->fbo.depth);
		GPU_texture_free(sctx->fbo.indices);

		BLI_freelistN(&sctx->dinamic.snap_obj_list);
		#if DRAW_FRAMEBUFFER_ON_SCREEN
		destroy_debug_drawing(sctx);
		#endif
		}

	MEM_freeN(sctx);	MEM_freeN(sctx);
	}	}

Context not available.

	bool ED_transform_snap_object_project_ray_ex(	bool ED_transform_snap_object_project_ray_ex(
	SnapObjectContext *sctx,	SnapObjectContext *sctx,
	const struct SnapObjectParams *params,
	const float ray_start[3], const float ray_normal[3],	const float ray_start[3], const float ray_normal[3],
	float *ray_depth,	float *ray_depth,
	float r_loc[3], float r_no[3], int *r_index,	float r_loc[3], float r_no[3], int *r_index,
Context not available.
	return raycastObjects(	return raycastObjects(
	sctx,	sctx,
	ray_start, ray_normal,	ray_start, ray_normal,
	params->snap_select, params->use_object_edit_cage,
	ray_depth, r_loc, r_no, r_index, r_ob, r_obmat, NULL);	ray_depth, r_loc, r_no, r_index, r_ob, r_obmat, NULL);
	}	}

Context not available.
	*/	*/
	bool ED_transform_snap_object_project_ray_all(	bool ED_transform_snap_object_project_ray_all(
	SnapObjectContext *sctx,	SnapObjectContext *sctx,
	const struct SnapObjectParams *params,
	const float ray_start[3], const float ray_normal[3],	const float ray_start[3], const float ray_normal[3],
	float ray_depth, bool sort,	float ray_depth, bool sort,
	ListBase *r_hit_list)	ListBase *r_hit_list)
Context not available.
	bool retval = raycastObjects(	bool retval = raycastObjects(
	sctx,	sctx,
	ray_start, ray_normal,	ray_start, ray_normal,
	params->snap_select, params->use_object_edit_cage,
	&ray_depth, NULL, NULL, NULL, NULL, NULL,	&ray_depth, NULL, NULL, NULL, NULL, NULL,
	r_hit_list);	r_hit_list);

Context not available.
	*/	*/
	static bool transform_snap_context_project_ray_impl(	static bool transform_snap_context_project_ray_impl(
	SnapObjectContext *sctx,	SnapObjectContext *sctx,
	const struct SnapObjectParams *params,
	const float ray_start[3], const float ray_normal[3], float *ray_depth,	const float ray_start[3], const float ray_normal[3], float *ray_depth,
	float r_co[3], float r_no[3])	float r_co[3], float r_no[3])
	{	{
Context not available.
	/* try snap edge, then face if it fails */	/* try snap edge, then face if it fails */
	ret = ED_transform_snap_object_project_ray_ex(	ret = ED_transform_snap_object_project_ray_ex(
	sctx,	sctx,
	params,
	ray_start, ray_normal, ray_depth,	ray_start, ray_normal, ray_depth,
	r_co, r_no, NULL,	r_co, r_no, NULL,
	NULL, NULL);	NULL, NULL);
Context not available.

	bool ED_transform_snap_object_project_ray(	bool ED_transform_snap_object_project_ray(
	SnapObjectContext *sctx,	SnapObjectContext *sctx,
	const struct SnapObjectParams *params,
	const float ray_origin[3], const float ray_direction[3], float *ray_depth,	const float ray_origin[3], const float ray_direction[3], float *ray_depth,
	float r_co[3], float r_no[3])	float r_co[3], float r_no[3])
	{	{
Context not available.

	return transform_snap_context_project_ray_impl(	return transform_snap_context_project_ray_impl(
	sctx,	sctx,
	params,
	ray_origin, ray_direction, ray_depth,	ray_origin, ray_direction, ray_depth,
	r_co, r_no);	r_co, r_no);
	}	}

	static bool transform_snap_context_project_view3d_mixed_impl(
	SnapObjectContext *sctx,
	const unsigned short snap_to_flag,
	const struct SnapObjectParams *params,
	const float mval[2], float *dist_px,
	bool use_depth,
	float r_co[3], float r_no[3])
	{
	float ray_depth = BVH_RAYCAST_DIST_MAX;
	bool is_hit = false;

	const int elem_type[3] = {SCE_SNAP_MODE_VERTEX, SCE_SNAP_MODE_EDGE, SCE_SNAP_MODE_FACE};

	BLI_assert(snap_to_flag != 0);
	BLI_assert((snap_to_flag & ~(1 \| 2 \| 4)) == 0);

	if (use_depth) {
	const float dist_px_orig = dist_px ? *dist_px : 0;
	for (int i = 2; i >= 0; i--) {
	if (snap_to_flag & (1 << i)) {
	if (i == 0) {
	BLI_assert(dist_px != NULL);
	*dist_px = dist_px_orig;
	}
	if (ED_transform_snap_object_project_view3d(
	sctx,
	elem_type[i], params,
	mval, dist_px, &ray_depth,
	r_co, r_no))
	{
	/* 0.01 is a random but small value to prioritizing
	* the first elements of the loop */
	ray_depth += 0.01f;
	is_hit = true;
	}
	}
	}
	}
	else {
	for (int i = 0; i < 3; i++) {
	if (snap_to_flag & (1 << i)) {
	if (ED_transform_snap_object_project_view3d(
	sctx,
	elem_type[i], params,
	mval, dist_px, &ray_depth,
	r_co, r_no))
	{
	is_hit = true;
	break;
	}
	}
	}
	}

	return is_hit;
	}

	/**	/**
	* Convenience function for performing snapping.	* Convenience function for performing snapping.
	*	*
Context not available.
	bool ED_transform_snap_object_project_view3d_mixed(	bool ED_transform_snap_object_project_view3d_mixed(
	SnapObjectContext *sctx,	SnapObjectContext *sctx,
	const unsigned short snap_to_flag,	const unsigned short snap_to_flag,
	const struct SnapObjectParams *params,
	const float mval_fl[2], float *dist_px,	const float mval_fl[2], float *dist_px,
	bool use_depth,	bool UNUSED(use_depth),
	float r_co[3], float r_no[3])	float r_co[3], float r_no[3])
	{	{
	return transform_snap_context_project_view3d_mixed_impl(	float ray_depth = BVH_RAYCAST_DIST_MAX;

		BLI_assert(snap_to_flag != 0);
		BLI_assert((snap_to_flag & ~(1 \| 2 \| 4)) == 0);

		return ED_transform_snap_object_project_view3d_ex(
	sctx,	sctx,
	snap_to_flag, params,	snap_to_flag,
	mval_fl, dist_px, use_depth,	mval_fl, dist_px, &ray_depth,
	r_co, r_no);	r_co, r_no, NULL);
	}	}

	bool ED_transform_snap_object_project_view3d_ex(	unsigned short ED_transform_snap_object_project_view3d_ex(
	SnapObjectContext *sctx,	SnapObjectContext *sctx,
	const unsigned short snap_to,	const unsigned short snap_to_flag,
	const struct SnapObjectParams *params,
	const float mval[2], float *dist_px,	const float mval[2], float *dist_px,
	float *ray_depth,	float *ray_depth,
	float r_loc[3], float r_no[3], int *r_index)	float r_loc[3], float r_no[3], int *r_index)
	{	{
	float ray_origin[3], ray_start[3], ray_normal[3], depth_range[2], ray_end[3];	unsigned short retval = false;
		float ray_origin[3], ray_normal[3], depth_range[2];

	const ARegion *ar = sctx->v3d_data.ar;	const ARegion *ar = sctx->v3d_data.ar;
	const RegionView3D *rv3d = ar->regiondata;

	ED_view3d_win_to_origin(ar, mval, ray_origin);	ED_view3d_win_to_origin(ar, mval, ray_origin);
	ED_view3d_win_to_vector(ar, mval, ray_normal);	ED_view3d_win_to_vector(ar, mval, ray_normal);
Context not available.
	sctx->v3d_data.v3d, sctx->v3d_data.ar->regiondata,	sctx->v3d_data.v3d, sctx->v3d_data.ar->regiondata,
	&depth_range[0], &depth_range[1], false);	&depth_range[0], &depth_range[1], false);

	madd_v3_v3v3fl(ray_start, ray_origin, ray_normal, depth_range[0]);	if (snap_to_flag & SNAP_FACE) {
	madd_v3_v3v3fl(ray_end, ray_origin, ray_normal, depth_range[1]);	float ray_start[3], ray_end[3];
		const RegionView3D *rv3d = ar->regiondata;

	if (!ED_view3d_clip_segment(rv3d, ray_start, ray_end)) {	madd_v3_v3v3fl(ray_start, ray_origin, ray_normal, depth_range[0]);
	return false;	madd_v3_v3v3fl(ray_end, ray_origin, ray_normal, depth_range[1]);
	}

	float ray_depth_fallback;	if (!ED_view3d_clip_segment(rv3d, ray_start, ray_end)) {
	if (ray_depth == NULL) {	return false;
	ray_depth_fallback = BVH_RAYCAST_DIST_MAX;	}
	ray_depth = &ray_depth_fallback;
	}

	if (snap_to == SCE_SNAP_MODE_FACE) {	float ray_depth_fallback;
	return raycastObjects(	if (ray_depth == NULL) {
		ray_depth_fallback = BVH_RAYCAST_DIST_MAX;
		ray_depth = &ray_depth_fallback;
		}
		if (raycastObjects(
	sctx,	sctx,
	ray_start, ray_normal,	ray_start, ray_normal,
	params->snap_select, params->use_object_edit_cage,	ray_depth, r_loc, r_no, r_index, NULL, NULL, NULL))
	ray_depth, r_loc, r_no, r_index, NULL, NULL, NULL);	{
		retval = SCE_SELECT_FACE;
		}
	}	}
	else {	if (snap_to_flag & (SNAP_EDGE \| SNAP_VERT)) {
	SnapData snapdata;	if (!sctx->nearest2d_inited) {
	const enum eViewProj view_proj = ((RegionView3D *)ar->regiondata)->is_persp ? VIEW_PROJ_PERSP : VIEW_PROJ_ORTHO;	sctx->nearest2d_inited = true;
	snap_data_set(&snapdata, ar, snap_to, view_proj, mval,	init_nearest2d_search(sctx);
	ray_origin, ray_start, ray_normal, depth_range);	}
		unsigned short t_elem;
		sctx->dinamic.snap_to_flag = snap_to_flag;
		copy_v3_v3(sctx->dinamic.mval, mval);
		copy_v3_v3(sctx->dinamic.ray_orig, ray_origin);
		copy_v3_v3(sctx->dinamic.ray_dir, ray_normal);
		copy_v2_v2(sctx->dinamic.depth_range, depth_range);
		sctx->dinamic.dist_px = *dist_px;

		t_elem = snapObjectsRay(
		sctx, r_loc, r_no, NULL, NULL, r_index);

	return snapObjectsRay(	*dist_px = sctx->dinamic.dist_px;
	sctx, &snapdata,
	params->snap_select, params->use_object_edit_cage,	if (t_elem) {
	ray_depth, dist_px, r_loc, r_no, NULL, NULL);	retval = t_elem;
		}
	}	}

		return retval;
	}	}

	bool ED_transform_snap_object_project_view3d(	bool ED_transform_snap_object_project_view3d(
	SnapObjectContext *sctx,	SnapObjectContext *sctx,
	const unsigned short snap_to,	const unsigned short snap_to,
	const struct SnapObjectParams *params,
	const float mval[2], float *dist_px,	const float mval[2], float *dist_px,
	float *ray_depth,	float *ray_depth,
	float r_loc[3], float r_no[3])	float r_loc[3], float r_no[3])
	{	{
		const unsigned short snap_to_flag = 1 << (snap_to - 1);
	return ED_transform_snap_object_project_view3d_ex(	return ED_transform_snap_object_project_view3d_ex(
	sctx,	sctx,
	snap_to,	snap_to_flag,
	params,
	mval, dist_px,	mval, dist_px,
	ray_depth,	ray_depth,
	r_loc, r_no, NULL);	r_loc, r_no, NULL);
Context not available.
	*/	*/
	bool ED_transform_snap_object_project_all_view3d_ex(	bool ED_transform_snap_object_project_all_view3d_ex(
	SnapObjectContext *sctx,	SnapObjectContext *sctx,
	const struct SnapObjectParams *params,
	const float mval[2],	const float mval[2],
	float ray_depth, bool sort,	float ray_depth, bool sort,
	ListBase *r_hit_list)	ListBase *r_hit_list)
Context not available.

	return ED_transform_snap_object_project_ray_all(	return ED_transform_snap_object_project_ray_all(
	sctx,	sctx,
	params,
	ray_start, ray_normal, ray_depth, sort,	ray_start, ray_normal, ray_depth, sort,
	r_hit_list);	r_hit_list);
	}	}
Context not available.