Differential D7930 Diff 25494 source/blender/editors/transform/transform_data.c

Changeset View

Standalone View

source/blender/editors/transform/transform_data.c

This file was added.

				/*
				* 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) 2001-2002 by NaN Holding BV.
				* All rights reserved.
				*/

				/** \file
				* \ingroup edtransform
				*/

				#include <stdlib.h>

				#include "MEM_guardedalloc.h"

				#include "BLI_math.h"

				#include "BKE_context.h"

				#include "ED_screen.h"

				#include "BLT_translation.h"

				#include "transform.h"
				#include "transform_data.h"

				static const size_t g_size[] = {sizeof(((TransData ){0})->basic),
				sizeof(((TransData ){0})->prop),
				sizeof(((TransData ){0})->space),
				sizeof(((TransData ){0})->special),
				sizeof(((TransData ){0})->object),
				sizeof(((TransData ){0})->ext),
				sizeof(((TransData ){0})->curve),
				sizeof(((TransData ){0})->center)};

				/* -------------------------------------------------------------------- */
				/* Transform Elemet Data */

				TransData *transform_data_alloc(const uint len, const eTransDataDescr descriptor)
				{
				TransData r_td = MEM_callocN(len sizeof(*r_td), __func__);
				if (descriptor & TD_BASIC) {
				r_td->basic = MEM_callocN(len * sizeof(*r_td->basic), __func__);
				}
				if (descriptor & TD_PROP) {
				r_td->prop = MEM_callocN(len * sizeof(*r_td->prop), __func__);
				}
				if (descriptor & TD_SPACE) {
				r_td->space = MEM_callocN(len * sizeof(*r_td->space), __func__);
				}
				if (descriptor & TD_SPECIAL) {
				r_td->special = MEM_callocN(len * sizeof(*r_td->special), __func__);
				}
				if (descriptor & TD_OBJECT) {
				r_td->object = MEM_callocN(len * sizeof(*r_td->object), __func__);
				}
				if (descriptor & TD_EXT) {
				r_td->ext = MEM_callocN(len * sizeof(*r_td->ext), __func__);
				}
				if (descriptor & TD_CURVE) {
				r_td->curve = MEM_callocN(len * sizeof(*r_td->curve), __func__);
				}
				if (descriptor & TD_CENTER) {
				r_td->center = MEM_callocN(len * sizeof(*r_td->center), __func__);
				}

				r_td->elem_len = len;
				return r_td;
				}

				void transform_data_free(TransData *td)
				{
				MEM_SAFE_FREE(td->basic);
				MEM_SAFE_FREE(td->prop);
				MEM_SAFE_FREE(td->space);
				MEM_SAFE_FREE(td->special);
				MEM_SAFE_FREE(td->object);
				MEM_SAFE_FREE(td->curve);
				MEM_SAFE_FREE(td->ext);
				MEM_SAFE_FREE(td->center);
				MEM_freeN(td);
				}

				void transform_data_elem_update_all(const TransData td, const int tdi, TransDataIter td_iter)
				{
				size_t offset = 0;
				for (int arr = 0; arr < ARRAY_SIZE(g_size); arr++) {
				size_t size_arr = g_size[arr];
				char arr_curr = ((char *)td)[arr];
				if (arr_curr) {
				memcpy(arr_curr + (tdi * size_arr), ((char *)td_iter) + offset, size_arr);
				}
				offset += size_arr;
				}
				}

				void transform_data_elem_read_all(const TransData *td,
				const const int tdi,
				TransDataIter *r_td_iter)
				{
				size_t offset = 0;
				for (int arr = 0; arr < ARRAY_SIZE(g_size); arr++) {
				size_t size_arr = g_size[arr];
				char arr_curr = ((char *)td)[arr];
				if (arr_curr) {
				memcpy(((char )r_td_iter) + offset, arr_curr + (tdi size_arr), size_arr);
				}
				offset += size_arr;
				}
				}

				void transform_data_reorder(TransData td, const int indexes)
				{
				TransData td_tmp;
				int arr, i;
				int len = td->elem_len;
				for (arr = 0; arr < ARRAY_SIZE(g_size); arr++) {
				char arr_old = ((char *)td)[arr];
				if (arr_old) {
				size_t size_arr = g_size[arr];
				char arr_new = MEM_mallocN(len size_arr, __func__);
				for (i = 0; i < len; i++) {
				memcpy(arr_new + (indexes[i] * size_arr), arr_old + (i * size_arr), size_arr);
				}
				MEM_freeN(arr_old);
				((char **)td)[arr] = arr_new;
				}
				}
				}
				campbellbartonUnsubmitted Not Done Inline Actions Couldnt `BLI_array_permute_ex` be used here? campbellbarton: Couldnt `BLI_array_permute_ex` be used here?

				/** \} */