[Bf-blender-cvs] [5ff33ecdf0e] blender2.8: Merge branch 'master' into blender2.8

Campbell Barton noreply at git.blender.org
Wed Jan 10 03:53:44 CET 2018


Commit: 5ff33ecdf0ed319db2e589926a614f67738531a6
Author: Campbell Barton
Date:   Wed Jan 10 13:57:26 2018 +1100
Branches: blender2.8
https://developer.blender.org/rB5ff33ecdf0ed319db2e589926a614f67738531a6

Merge branch 'master' into blender2.8

===================================================================



===================================================================

diff --cc source/blender/windowmanager/manipulators/intern/wm_manipulator_map.c
index bf9b5b72c67,00000000000..d051c93d892
mode 100644,000000..100644
--- a/source/blender/windowmanager/manipulators/intern/wm_manipulator_map.c
+++ b/source/blender/windowmanager/manipulators/intern/wm_manipulator_map.c
@@@ -1,1211 -1,0 +1,1211 @@@
 +/*
 + * ***** BEGIN GPL LICENSE BLOCK *****
 + *
 + * This program is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU General Public License
 + * as published by the Free Software Foundation; either version 2
 + * of the License, or (at your option) any later version.
 + *
 + * This program is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 + * GNU General Public License for more details.
 + *
 + * You should have received a copy of the GNU General Public License
 + * along with this program; if not, write to the Free Software Foundation,
 + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 + *
 + * The Original Code is Copyright (C) 2014 Blender Foundation.
 + * All rights reserved.
 + *
 + * Contributor(s): Blender Foundation
 + *
 + * ***** END GPL LICENSE BLOCK *****
 + */
 +
 +/** \file blender/windowmanager/manipulators/intern/wm_manipulator_map.c
 + *  \ingroup wm
 + */
 +
 +#include <string.h>
 +
 +#include "BLI_listbase.h"
 +#include "BLI_math.h"
 +#include "BLI_rect.h"
 +#include "BLI_string.h"
 +#include "BLI_ghash.h"
 +
 +#include "BKE_context.h"
 +#include "BKE_global.h"
 +
 +#include "ED_screen.h"
 +#include "ED_view3d.h"
 +
 +#include "GPU_glew.h"
 +#include "GPU_matrix.h"
 +#include "GPU_select.h"
 +
 +#include "MEM_guardedalloc.h"
 +
 +#include "WM_api.h"
 +#include "WM_types.h"
 +#include "wm_event_system.h"
 +
 +/* for tool-tips */
 +#include "UI_interface.h"
 +
 +#include "DEG_depsgraph.h"
 +
 +/* own includes */
 +#include "wm_manipulator_wmapi.h"
 +#include "wm_manipulator_intern.h"
 +
 +/**
 + * Store all manipulator-maps here. Anyone who wants to register a manipulator for a certain
 + * area type can query the manipulator-map to do so.
 + */
 +static ListBase manipulatormaptypes = {NULL, NULL};
 +
 +/**
 + * Update when manipulator-map types change.
 + */
 +/* so operator removal can trigger update */
 +typedef enum eWM_ManipulatorGroupTypeGlobalFlag {
 +	WM_MANIPULATORMAPTYPE_GLOBAL_UPDATE_INIT = (1 << 0),
 +	WM_MANIPULATORMAPTYPE_GLOBAL_UPDATE_REMOVE = (1 << 1),
 +} eWM_ManipulatorGroupTypeGlobalFlag;
 +
 +static eWM_ManipulatorGroupTypeGlobalFlag wm_mmap_type_update_flag = 0;
 +
 +/**
 + * Manipulator-map update tagging.
 + */
 +enum {
 +	/** #manipulatormap_prepare_drawing has run */
 +	MANIPULATORMAP_IS_PREPARE_DRAW = (1 << 0),
 +	MANIPULATORMAP_IS_REFRESH_CALLBACK = (1 << 1),
 +};
 +
 +
 +/* -------------------------------------------------------------------- */
 +/** \name wmManipulatorMap Selection Array API
 + *
 + * Just handle ``wm_manipulatormap_select_array_*``, not flags or callbacks.
 + *
 + * \{ */
 +
 +static void wm_manipulatormap_select_array_ensure_len_alloc(wmManipulatorMap *mmap, int len)
 +{
 +	wmManipulatorMapSelectState *msel = &mmap->mmap_context.select;
 +	if (len <= msel->len_alloc) {
 +		return;
 +	}
 +	msel->items = MEM_reallocN(msel->items, sizeof(*msel->items) * len);
 +	msel->len_alloc = len;
 +}
 +
 +void wm_manipulatormap_select_array_clear(wmManipulatorMap *mmap)
 +{
 +	wmManipulatorMapSelectState *msel = &mmap->mmap_context.select;
 +	MEM_SAFE_FREE(msel->items);
 +	msel->len = 0;
 +	msel->len_alloc = 0;
 +}
 +
 +void wm_manipulatormap_select_array_shrink(wmManipulatorMap *mmap, int len_subtract)
 +{
 +	wmManipulatorMapSelectState *msel = &mmap->mmap_context.select;
 +	msel->len -= len_subtract;
 +	if (msel->len <= 0) {
 +		wm_manipulatormap_select_array_clear(mmap);
 +	}
 +	else {
 +		if (msel->len < msel->len_alloc / 2) {
 +			msel->items = MEM_reallocN(msel->items, sizeof(*msel->items) * msel->len);
 +			msel->len_alloc = msel->len;
 +		}
 +	}
 +}
 +
 +void wm_manipulatormap_select_array_push_back(wmManipulatorMap *mmap, wmManipulator *mpr)
 +{
 +	wmManipulatorMapSelectState *msel = &mmap->mmap_context.select;
 +	BLI_assert(msel->len <= msel->len_alloc);
 +	if (msel->len == msel->len_alloc) {
 +		msel->len_alloc = (msel->len + 1) * 2;
 +		msel->items = MEM_reallocN(msel->items, sizeof(*msel->items) * msel->len_alloc);
 +	}
 +	msel->items[msel->len++] = mpr;
 +}
 +
 +void wm_manipulatormap_select_array_remove(wmManipulatorMap *mmap, wmManipulator *mpr)
 +{
 +	wmManipulatorMapSelectState *msel = &mmap->mmap_context.select;
 +	/* remove manipulator from selected_manipulators array */
 +	for (int i = 0; i < msel->len; i++) {
 +		if (msel->items[i] == mpr) {
 +			for (int j = i; j < (msel->len - 1); j++) {
 +				msel->items[j] = msel->items[j + 1];
 +			}
 +			wm_manipulatormap_select_array_shrink(mmap, 1);
 +			break;
 +		}
 +	}
 +
 +}
 +
 +/** \} */
 +
 +
 +/* -------------------------------------------------------------------- */
 +/** \name wmManipulatorMap
 + *
 + * \{ */
 +
 +/**
 + * Creates a manipulator-map with all registered manipulators for that type
 + */
 +wmManipulatorMap *WM_manipulatormap_new_from_type(
 +        const struct wmManipulatorMapType_Params *mmap_params)
 +{
 +	wmManipulatorMapType *mmap_type = WM_manipulatormaptype_ensure(mmap_params);
 +	wmManipulatorMap *mmap;
 +
 +	mmap = MEM_callocN(sizeof(wmManipulatorMap), "ManipulatorMap");
 +	mmap->type = mmap_type;
 +	WM_manipulatormap_tag_refresh(mmap);
 +
 +	/* create all manipulator-groups for this manipulator-map. We may create an empty one
 +	 * too in anticipation of manipulators from operators etc */
 +	for (wmManipulatorGroupTypeRef *wgt_ref = mmap_type->grouptype_refs.first; wgt_ref; wgt_ref = wgt_ref->next) {
 +		wm_manipulatorgroup_new_from_type(mmap, wgt_ref->type);
 +	}
 +
 +	return mmap;
 +}
 +
 +void wm_manipulatormap_remove(wmManipulatorMap *mmap)
 +{
 +	/* Clear first so further calls don't waste time trying to maintain correct array state. */
 +	wm_manipulatormap_select_array_clear(mmap);
 +
 +	for (wmManipulatorGroup *mgroup = mmap->groups.first, *mgroup_next; mgroup; mgroup = mgroup_next) {
 +		mgroup_next = mgroup->next;
 +		BLI_assert(mgroup->parent_mmap == mmap);
 +		wm_manipulatorgroup_free(NULL, mgroup);
 +	}
 +	BLI_assert(BLI_listbase_is_empty(&mmap->groups));
 +
 +	MEM_freeN(mmap);
 +}
 +
 +
 +wmManipulatorGroup *WM_manipulatormap_group_find(
 +        struct wmManipulatorMap *mmap,
 +        const char *idname)
 +{
 +	wmManipulatorGroupType *wgt = WM_manipulatorgrouptype_find(idname, false);
 +	if (wgt) {
 +		return WM_manipulatormap_group_find_ptr(mmap, wgt);
 +	}
 +	return NULL;
 +}
 +
 +wmManipulatorGroup *WM_manipulatormap_group_find_ptr(
 +        struct wmManipulatorMap *mmap,
 +        const struct wmManipulatorGroupType *wgt)
 +{
 +	for (wmManipulatorGroup *mgroup = mmap->groups.first; mgroup; mgroup = mgroup->next) {
 +		if (mgroup->type == wgt) {
 +			return mgroup;
 +		}
 +	}
 +	return NULL;
 +}
 +
 +const ListBase *WM_manipulatormap_group_list(wmManipulatorMap *mmap)
 +{
 +	return &mmap->groups;
 +}
 +
 +bool WM_manipulatormap_is_any_selected(const wmManipulatorMap *mmap)
 +{
 +	return mmap->mmap_context.select.len != 0;
 +}
 +
 +/**
 + * \note We could use a callback to define bounds, for now just use matrix location.
 + */
 +bool WM_manipulatormap_minmax(
 +        const wmManipulatorMap *mmap, bool UNUSED(use_hidden), bool use_select,
 +        float r_min[3], float r_max[3])
 +{
 +	if (use_select) {
 +		int i;
 +		for (i = 0; i < mmap->mmap_context.select.len; i++) {
 +			minmax_v3v3_v3(r_min, r_max, mmap->mmap_context.select.items[i]->matrix_basis[3]);
 +		}
 +		return i != 0;
 +	}
 +	else {
 +		bool ok = false;
 +		BLI_assert(!"TODO");
 +		return ok;
 +	}
 +}
 +
 +/**
 + * Creates and returns idname hash table for (visible) manipulators in \a mmap
 + *
 + * \param poll  Polling function for excluding manipulators.
 + * \param data  Custom data passed to \a poll
 + *
 + * TODO(campbell): this uses unreliable order,
 + * best we use an iterator function instead of a hash.
 + */
 +static GHash *WM_manipulatormap_manipulator_hash_new(
 +        const bContext *C, wmManipulatorMap *mmap,
 +        bool (*poll)(const wmManipulator *, void *),
 +        void *data, const bool include_hidden)
 +{
 +	GHash *hash = BLI_ghash_ptr_new(__func__);
 +
 +	/* collect manipulators */
 +	for (wmManipulatorGroup *mgroup = mmap->groups.first; mgroup; mgroup = mgroup->next) {
 +		if (!mgroup->type->poll || mgroup->type->poll(C, mgroup->type)) {
 +			for (wmManipulator *mpr = mgroup->manipulators.first; mpr; mpr = mpr->next) {
 +				if ((include_hidden || (mpr->flag & WM_MANIPULATOR_HIDDEN) == 0) &&
 +				    (!poll || poll(mpr, data)))
 +				{
 +					BLI_ghash_insert(hash, mpr, mpr);
 +				}
 +			}
 +		}
 +	}
 +
 +	return hash;
 +}
 +
 +void WM_manipulatormap_tag_refresh(wmManipulatorMap *mmap)
 +{
 +	if (mmap) {
 +		/* We might want only to refresh some, for tag all steps. */
 +		for (int i = 0; i < WM_MANIPULATORMAP_DRAWSTEP_MAX; i++) {
 +			mmap->update_flag[i] |= (
 +			        MANIPULATORMAP_IS_PREPARE_DRAW |
 +			        MANIPULATORMAP_IS_REFRESH_CALLBACK);
 +		}
 +	}
 +}
 +
 +static bool manipulator_prepare_drawing(
 +        wmManipulatorMap *mmap, wmManipulator *mpr,
 +        const bContext *C, ListBase *draw_manipulators,
 +        const eWM_ManipulatorMapDrawStep drawstep)
 +{
 +	int do_draw = wm_manipulator_is_visible(mpr);
 +	if (do_draw == 0) {
 +		/* skip */
 +	}
 +	else {
 +		/* Ensure we get RNA updates */
 +		if (do_draw & WM_MANIPULATOR_IS_VISIBLE_UPDATE) {
 +			/* hover manipulators need updating, even if we don't draw them */
 +			wm_manipulator_update(mpr, C, (mmap->update_flag[drawstep] & MANIPULATORMAP_IS_PREPARE_DRAW) != 0);
 +		}
 +		if (do_draw & WM_MANIPULATOR_IS_VISIBLE_DRAW) {
 +			BLI_addhead(draw_manipulators, BLI_genericNodeN(mpr));
 +		}
 +		return true;
 +	}
 +
 +	return false;
 +}
 +
 +/**
 + * Update manipulators of \a mmap to prepare for drawing. Adds all manipulators that
 + * should be drawn to list \a draw_manipulators, note that 

@@ Diff output truncated at 10240 characters. @@



More information about the Bf-blender-cvs mailing list