archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity
This repository has been archived on 2023-10-09. You can view files and clone it, but cannot push or open issues or pull requests.
Files
2120c5af032831348412a2a8e6c61f82ba1b921c
blender-archive/source/blender/editors/space_view3d/view3d_buttons.c
Campbell Barton f7e35d61f8 Cleanup: add View3D_Runtime struct 
Also remove 'matcap_icon'
2019-04-13 15:24:28 +02:00

1323 lines
41 KiB
C
Raw Blame History

/*
* 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) 2009 Blender Foundation.
* All rights reserved.
*/
/** \file
* \ingroup spview3d
*/
#include <string.h>
#include <stdio.h>
#include <math.h>
#include <float.h>
#include "DNA_armature_types.h"
#include "DNA_curve_types.h"
#include "DNA_lattice_types.h"
#include "DNA_meta_types.h"
#include "DNA_mesh_types.h"
#include "DNA_meshdata_types.h"
#include "DNA_object_types.h"
#include "DNA_scene_types.h"
#include "MEM_guardedalloc.h"
#include "BLT_translation.h"
#include "BLI_math.h"
#include "BLI_blenlib.h"
#include "BLI_utildefines.h"
#include "BKE_action.h"
#include "BKE_context.h"
#include "BKE_curve.h"
#include "BKE_customdata.h"
#include "BKE_screen.h"
#include "BKE_editmesh.h"
#include "BKE_deform.h"
#include "BKE_object.h"
#include "BKE_object_deform.h"
#include "BKE_report.h"
#include "DEG_depsgraph.h"
#include "WM_api.h"
#include "WM_types.h"
#include "RNA_access.h"
#include "ED_armature.h"
#include "ED_object.h"
#include "ED_mesh.h"
#include "ED_screen.h"
#include "UI_interface.h"
#include "UI_resources.h"
#include "view3d_intern.h" /* own include */
/* ******************* view3d space & buttons ************** */
enum {
B_REDR = 2,
B_TRANSFORM_PANEL_MEDIAN = 1008,
B_TRANSFORM_PANEL_DIMS = 1009,
};
/* All must start w/ location */
typedef struct {
float location[3];
} TransformMedian_Generic;
typedef struct {
float location[3], bv_weight, be_weight, skin[2], crease;
} TransformMedian_Mesh;
typedef struct {
float location[3], weight, b_weight, radius, tilt;
} TransformMedian_Curve;
typedef struct {
float location[3], weight;
} TransformMedian_Lattice;
typedef union {
TransformMedian_Generic generic;
TransformMedian_Mesh mesh;
TransformMedian_Curve curve;
TransformMedian_Lattice lattice;
} TransformMedian;
/* temporary struct for storing transform properties */
typedef struct {
float ob_dims_orig[3];
float ob_dims[3];
/* Floats only (treated as an array). */
TransformMedian ve_median, median;
} TransformProperties;
#define TRANSFORM_MEDIAN_ARRAY_LEN (sizeof(TransformMedian) / sizeof(float))
/* Helper function to compute a median changed value,
* when the value should be clamped in [0.0, 1.0].
* Returns either 0.0, 1.0 (both can be applied directly), a positive scale factor
* for scale down, or a negative one for scale up.
*/
static float compute_scale_factor(const float ve_median, const float median)
{
if (ve_median <= 0.0f) {
return 0.0f;
}
else if (ve_median >= 1.0f) {
return 1.0f;
}
else {
/* Scale value to target median. */
float median_new = ve_median;
float median_orig = ve_median - median; /* Previous median value. */
/* In case of floating point error. */
CLAMP(median_orig, 0.0f, 1.0f);
CLAMP(median_new, 0.0f, 1.0f);
if (median_new <= median_orig) {
/* Scale down. */
return median_new / median_orig;
}
else {
/* Scale up, negative to indicate it... */
return -(1.0f - median_new) / (1.0f - median_orig);
}
}
}
/* Apply helpers.
* Note: In case we only have one element, copy directly the value instead of applying the diff or scale factor.
* Avoids some glitches when going e.g. from 3 to 0.0001 (see T37327).
*/
static void apply_raw_diff(float *val, const int tot, const float ve_median, const float median)
{
*val = (tot == 1) ? ve_median : (*val + median);
}
static void apply_raw_diff_v3(float val[3], const int tot, const float ve_median[3], const float median[3])
{
if (tot == 1) {
copy_v3_v3(val, ve_median);
}
else {
add_v3_v3(val, median);
}
}
static void apply_scale_factor(float *val, const int tot, const float ve_median, const float median, const float sca)
{
if (tot == 1 || ve_median == median) {
*val = ve_median;
}
else {
*val *= sca;
}
}
static void apply_scale_factor_clamp(float *val, const int tot, const float ve_median, const float sca)
{
if (tot == 1) {
*val = ve_median;
CLAMP(*val, 0.0f, 1.0f);
}
else if (ELEM(sca, 0.0f, 1.0f)) {
*val = sca;
}
else {
*val = (sca > 0.0f) ? (*val * sca) : (1.0f + ((1.0f - *val) * sca));
CLAMP(*val, 0.0f, 1.0f);
}
}
static TransformProperties *v3d_transform_props_ensure(View3D *v3d)
{
if (v3d->runtime.properties_storage == NULL) {
v3d->runtime.properties_storage = MEM_callocN(sizeof(TransformProperties), "TransformProperties");
}
return v3d->runtime.properties_storage;
}
/* is used for both read and write... */
static void v3d_editvertex_buts(uiLayout *layout, View3D *v3d, Object *ob, float lim)
{
uiBlock *block = (layout) ? uiLayoutAbsoluteBlock(layout) : NULL;
TransformProperties *tfp = v3d_transform_props_ensure(v3d);
TransformMedian median_basis, ve_median_basis;
int tot, totedgedata, totcurvedata, totlattdata, totcurvebweight;
bool has_meshdata = false;
bool has_skinradius = false;
PointerRNA data_ptr;
copy_vn_fl((float *)&median_basis, TRANSFORM_MEDIAN_ARRAY_LEN, 0.0f);
tot = totedgedata = totcurvedata = totlattdata = totcurvebweight = 0;
if (ob->type == OB_MESH) {
TransformMedian_Mesh *median = &median_basis.mesh;
Mesh *me = ob->data;
BMEditMesh *em = me->edit_mesh;
BMesh *bm = em->bm;
BMVert *eve;
BMEdge *eed;
BMIter iter;
const int cd_vert_bweight_offset = CustomData_get_offset(&bm->vdata, CD_BWEIGHT);
const int cd_vert_skin_offset = CustomData_get_offset(&bm->vdata, CD_MVERT_SKIN);
const int cd_edge_bweight_offset = CustomData_get_offset(&bm->edata, CD_BWEIGHT);
const int cd_edge_crease_offset = CustomData_get_offset(&bm->edata, CD_CREASE);
has_skinradius = (cd_vert_skin_offset != -1);
if (bm->totvertsel) {
BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) {
tot++;
add_v3_v3(median->location, eve->co);
if (cd_vert_bweight_offset != -1) {
median->bv_weight += BM_ELEM_CD_GET_FLOAT(eve, cd_vert_bweight_offset);
}
if (has_skinradius) {
MVertSkin *vs = BM_ELEM_CD_GET_VOID_P(eve, cd_vert_skin_offset);
add_v2_v2(median->skin, vs->radius); /* Third val not used currently. */
}
}
}
}
if ((cd_edge_bweight_offset != -1) || (cd_edge_crease_offset != -1)) {
if (bm->totedgesel) {
BM_ITER_MESH (eed, &iter, bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) {
if (cd_edge_bweight_offset != -1) {
median->be_weight += BM_ELEM_CD_GET_FLOAT(eed, cd_edge_bweight_offset);
}
if (cd_edge_crease_offset != -1) {
median->crease += BM_ELEM_CD_GET_FLOAT(eed, cd_edge_crease_offset);
}
totedgedata++;
}
}
}
}
else {
totedgedata = bm->totedgesel;
}
has_meshdata = (tot || totedgedata);
}
else if (ob->type == OB_CURVE || ob->type == OB_SURF) {
TransformMedian_Curve *median = &median_basis.curve;
Curve *cu = ob->data;
Nurb *nu;
BPoint *bp;
BezTriple *bezt;
int a;
ListBase *nurbs = BKE_curve_editNurbs_get(cu);
StructRNA *seltype = NULL;
void *selp = NULL;
nu = nurbs->first;
while (nu) {
if (nu->type == CU_BEZIER) {
bezt = nu->bezt;
a = nu->pntsu;
while (a--) {
if (bezt->f2 & SELECT) {
add_v3_v3(median->location, bezt->vec[1]);
tot++;
median->weight += bezt->weight;
median->radius += bezt->radius;
median->tilt += bezt->tilt;
if (!totcurvedata) { /* I.e. first time... */
selp = bezt;
seltype = &RNA_BezierSplinePoint;
}
totcurvedata++;
}
else {
if (bezt->f1 & SELECT) {
add_v3_v3(median->location, bezt->vec[0]);
tot++;
}
if (bezt->f3 & SELECT) {
add_v3_v3(median->location, bezt->vec[2]);
tot++;
}
}
bezt++;
}
}
else {
bp = nu->bp;
a = nu->pntsu * nu->pntsv;
while (a--) {
if (bp->f1 & SELECT) {
add_v3_v3(median->location, bp->vec);
median->b_weight += bp->vec[3];
totcurvebweight++;
tot++;
median->weight += bp->weight;
median->radius += bp->radius;
median->tilt += bp->tilt;
if (!totcurvedata) { /* I.e. first time... */
selp = bp;
seltype = &RNA_SplinePoint;
}
totcurvedata++;
}
bp++;
}
}
nu = nu->next;
}
if (totcurvedata == 1) {
RNA_pointer_create(&cu->id, seltype, selp, &data_ptr);
}
}
else if (ob->type == OB_LATTICE) {
Lattice *lt = ob->data;
TransformMedian_Lattice *median = &median_basis.lattice;
BPoint *bp;
int a;
StructRNA *seltype = NULL;
void *selp = NULL;
a = lt->editlatt->latt->pntsu * lt->editlatt->latt->pntsv * lt->editlatt->latt->pntsw;
bp = lt->editlatt->latt->def;
while (a--) {
if (bp->f1 & SELECT) {
add_v3_v3(median->location, bp->vec);
tot++;
median->weight += bp->weight;
if (!totlattdata) { /* I.e. first time... */
selp = bp;
seltype = &RNA_LatticePoint;
}
totlattdata++;
}
bp++;
}
if (totlattdata == 1) {
RNA_pointer_create(&lt->id, seltype, selp, &data_ptr);
}
}
if (tot == 0) {
uiDefBut(block, UI_BTYPE_LABEL, 0, IFACE_("Nothing selected"), 0, 130, 200, 20, NULL, 0, 0, 0, 0, "");
return;
}
/* Location, X/Y/Z */
mul_v3_fl(median_basis.generic.location, 1.0f / (float)tot);
if (v3d->flag & V3D_GLOBAL_STATS) {
mul_m4_v3(ob->obmat, median_basis.generic.location);
}
if (has_meshdata) {
TransformMedian_Mesh *median = &median_basis.mesh;
if (totedgedata) {
median->crease /= (float)totedgedata;
median->be_weight /= (float)totedgedata;
}
if (tot) {
median->bv_weight /= (float)tot;
if (has_skinradius) {
median->skin[0] /= (float)tot;
median->skin[1] /= (float)tot;
}
}
}
else if (totcurvedata) {
TransformMedian_Curve *median = &median_basis.curve;
if (totcurvebweight) {
median->b_weight /= (float)totcurvebweight;
}
median->weight /= (float)totcurvedata;
median->radius /= (float)totcurvedata;
median->tilt /= (float)totcurvedata;
}
else if (totlattdata) {
TransformMedian_Lattice *median = &median_basis.lattice;
median->weight /= (float)totlattdata;
}
if (block) { /* buttons */
uiBut *but;
int yi = 200;
const float tilt_limit = DEG2RADF(21600.0f);
const int butw = 200;
const int buth = 20 * UI_DPI_FAC;
const int but_margin = 2;
const char *c;
memcpy(&tfp->ve_median, &median_basis, sizeof(tfp->ve_median));
UI_block_align_begin(block);
if (tot == 1) {
if (totcurvedata) {
/* Curve */
c = IFACE_("Control Point:");
}
else {
/* Mesh or lattice */
c = IFACE_("Vertex:");
}
}
else {
c = IFACE_("Median:");
}
uiDefBut(block, UI_BTYPE_LABEL, 0, c, 0, yi -= buth, butw, buth, NULL, 0, 0, 0, 0, "");
UI_block_align_begin(block);
/* Should be no need to translate these. */
but = uiDefButF(block, UI_BTYPE_NUM, B_TRANSFORM_PANEL_MEDIAN, IFACE_("X:"), 0, yi -= buth, butw, buth,
&tfp->ve_median.generic.location[0], -lim, lim, 10, RNA_TRANSLATION_PREC_DEFAULT, "");
UI_but_unit_type_set(but, PROP_UNIT_LENGTH);
but = uiDefButF(block, UI_BTYPE_NUM, B_TRANSFORM_PANEL_MEDIAN, IFACE_("Y:"), 0, yi -= buth, butw, buth,
&tfp->ve_median.generic.location[1], -lim, lim, 10, RNA_TRANSLATION_PREC_DEFAULT, "");
UI_but_unit_type_set(but, PROP_UNIT_LENGTH);
but = uiDefButF(block, UI_BTYPE_NUM, B_TRANSFORM_PANEL_MEDIAN, IFACE_("Z:"), 0, yi -= buth, butw, buth,
&tfp->ve_median.generic.location[2], -lim, lim, 10, RNA_TRANSLATION_PREC_DEFAULT, "");
UI_but_unit_type_set(but, PROP_UNIT_LENGTH);
if (totcurvebweight == tot) {
uiDefButF(block, UI_BTYPE_NUM, B_TRANSFORM_PANEL_MEDIAN, IFACE_("W:"), 0, yi -= buth, butw, buth,
&(tfp->ve_median.curve.b_weight), 0.01, 100.0, 1, 3, "");
}
UI_block_align_begin(block);
uiDefButBitS(block, UI_BTYPE_TOGGLE, V3D_GLOBAL_STATS, B_REDR, IFACE_("Global"),
0, yi -= buth + but_margin, 100, buth,
&v3d->flag, 0, 0, 0, 0, TIP_("Displays global values"));
uiDefButBitS(block, UI_BTYPE_TOGGLE_N, V3D_GLOBAL_STATS, B_REDR, IFACE_("Local"),
100, yi, 100, buth,
&v3d->flag, 0, 0, 0, 0, TIP_("Displays local values"));
UI_block_align_end(block);
/* Meshes... */
if (has_meshdata) {
TransformMedian_Mesh *ve_median = &tfp->ve_median.mesh;
if (tot) {
uiDefBut(block, UI_BTYPE_LABEL, 0, tot == 1 ? IFACE_("Vertex Data:") : IFACE_("Vertices Data:"),
0, yi -= buth + but_margin, butw, buth, NULL, 0.0, 0.0, 0, 0, "");
/* customdata layer added on demand */
uiDefButF(block, UI_BTYPE_NUM, B_TRANSFORM_PANEL_MEDIAN,
tot == 1 ? IFACE_("Bevel Weight:") : IFACE_("Mean Bevel Weight:"),
0, yi -= buth + but_margin, butw, buth,
&ve_median->bv_weight, 0.0, 1.0, 1, 2, TIP_("Vertex weight used by Bevel modifier"));
}
if (has_skinradius) {
UI_block_align_begin(block);
uiDefButF(block, UI_BTYPE_NUM, B_TRANSFORM_PANEL_MEDIAN,
tot == 1 ? IFACE_("Radius X:") : IFACE_("Mean Radius X:"),
0, yi -= buth + but_margin, butw, buth,
&ve_median->skin[0], 0.0, 100.0, 1, 3, TIP_("X radius used by Skin modifier"));
uiDefButF(block, UI_BTYPE_NUM, B_TRANSFORM_PANEL_MEDIAN,
tot == 1 ? IFACE_("Radius Y:") : IFACE_("Mean Radius Y:"),
0, yi -= buth + but_margin, butw, buth,
&ve_median->skin[1], 0.0, 100.0, 1, 3, TIP_("Y radius used by Skin modifier"));
UI_block_align_end(block);
}
if (totedgedata) {
uiDefBut(block, UI_BTYPE_LABEL, 0, totedgedata == 1 ? IFACE_("Edge Data:") : IFACE_("Edges Data:"),
0, yi -= buth + but_margin, butw, buth, NULL, 0.0, 0.0, 0, 0, "");
/* customdata layer added on demand */
uiDefButF(block, UI_BTYPE_NUM, B_TRANSFORM_PANEL_MEDIAN,
totedgedata == 1 ? IFACE_("Bevel Weight:") : IFACE_("Mean Bevel Weight:"),
0, yi -= buth + but_margin, butw, buth,
&ve_median->be_weight, 0.0, 1.0, 1, 2, TIP_("Edge weight used by Bevel modifier"));
/* customdata layer added on demand */
uiDefButF(block, UI_BTYPE_NUM, B_TRANSFORM_PANEL_MEDIAN,
totedgedata == 1 ? IFACE_("Crease:") : IFACE_("Mean Crease:"),
0, yi -= buth + but_margin, butw, buth,
&ve_median->crease, 0.0, 1.0, 1, 2, TIP_("Weight used by the Subdivision Surface modifier"));
}
}
/* Curve... */
else if (totcurvedata) {
TransformMedian_Curve *ve_median = &tfp->ve_median.curve;
if (totcurvedata == 1) {
uiDefButR(block, UI_BTYPE_NUM, 0, IFACE_("Weight:"), 0, yi -= buth + but_margin, butw, buth,
&data_ptr, "weight_softbody", 0, 0.0, 1.0, 1, 3, NULL);
uiDefButR(block, UI_BTYPE_NUM, 0, IFACE_("Radius:"), 0, yi -= buth + but_margin, butw, buth,
&data_ptr, "radius", 0, 0.0, 100.0, 1, 3, NULL);
uiDefButR(block, UI_BTYPE_NUM, 0, IFACE_("Tilt:"), 0, yi -= buth + but_margin, butw, buth,
&data_ptr, "tilt", 0, -tilt_limit, tilt_limit, 1, 3, NULL);
}
else if (totcurvedata > 1) {
uiDefButF(block, UI_BTYPE_NUM, B_TRANSFORM_PANEL_MEDIAN, IFACE_("Mean Weight:"),
0, yi -= buth + but_margin, butw, buth,
&ve_median->weight, 0.0, 1.0, 1, 3, TIP_("Weight used for Soft Body Goal"));
uiDefButF(block, UI_BTYPE_NUM, B_TRANSFORM_PANEL_MEDIAN, IFACE_("Mean Radius:"),
0, yi -= buth + but_margin, butw, buth,
&ve_median->radius, 0.0, 100.0, 1, 3, TIP_("Radius of curve control points"));
but = uiDefButF(block, UI_BTYPE_NUM, B_TRANSFORM_PANEL_MEDIAN, IFACE_("Mean Tilt:"),
0, yi -= buth + but_margin, butw, buth,
&ve_median->tilt, -tilt_limit, tilt_limit, 1, 3,
TIP_("Tilt of curve control points"));
UI_but_unit_type_set(but, PROP_UNIT_ROTATION);
}
}
/* Lattice... */
else if (totlattdata) {
TransformMedian_Lattice *ve_median = &tfp->ve_median.lattice;
if (totlattdata == 1) {
uiDefButR(block, UI_BTYPE_NUM, 0, IFACE_("Weight:"), 0, yi -= buth + but_margin, butw, buth,
&data_ptr, "weight_softbody", 0, 0.0, 1.0, 1, 3, NULL);
}
else if (totlattdata > 1) {
uiDefButF(block, UI_BTYPE_NUM, B_TRANSFORM_PANEL_MEDIAN, IFACE_("Mean Weight:"),
0, yi -= buth + but_margin, butw, buth,
&ve_median->weight, 0.0, 1.0, 1, 3, TIP_("Weight used for Soft Body Goal"));
}
}
UI_block_align_end(block);
}
else { /* apply */
memcpy(&ve_median_basis, &tfp->ve_median, sizeof(tfp->ve_median));
if (v3d->flag & V3D_GLOBAL_STATS) {
invert_m4_m4(ob->imat, ob->obmat);
mul_m4_v3(ob->imat, median_basis.generic.location);
mul_m4_v3(ob->imat, ve_median_basis.generic.location);
}
sub_vn_vnvn(
(float *)&median_basis,
(float *)&ve_median_basis,
(float *)&median_basis,
TRANSFORM_MEDIAN_ARRAY_LEN);
/* Note with a single element selected, we always do. */
const bool apply_vcos = (tot == 1) || (len_squared_v3(median_basis.generic.location) != 0.0f);
if ((ob->type == OB_MESH) &&
(apply_vcos || median_basis.mesh.bv_weight || median_basis.mesh.skin[0] || median_basis.mesh.skin[1] ||
median_basis.mesh.be_weight || median_basis.mesh.crease))
{
const TransformMedian_Mesh *median = &median_basis.mesh, *ve_median = &ve_median_basis.mesh;
Mesh *me = ob->data;
BMEditMesh *em = me->edit_mesh;
BMesh *bm = em->bm;
BMIter iter;
BMVert *eve;
BMEdge *eed;
int cd_vert_bweight_offset = -1;
int cd_vert_skin_offset = -1;
int cd_edge_bweight_offset = -1;
int cd_edge_crease_offset = -1;
float scale_bv_weight = 1.0f;
float scale_skin[2] = {1.0f, 1.0f};
float scale_be_weight = 1.0f;
float scale_crease = 1.0f;
/* Vertices */
if (apply_vcos || median->bv_weight || median->skin[0] || median->skin[1]) {
if (median->bv_weight) {
BM_mesh_cd_flag_ensure(bm, me, ME_CDFLAG_VERT_BWEIGHT);
cd_vert_bweight_offset = CustomData_get_offset(&bm->vdata, CD_BWEIGHT);
BLI_assert(cd_vert_bweight_offset != -1);
scale_bv_weight = compute_scale_factor(ve_median->bv_weight, median->bv_weight);
}
for (int i = 0; i < 2; i++) {
if (median->skin[i]) {
cd_vert_skin_offset = CustomData_get_offset(&bm->vdata, CD_MVERT_SKIN);
BLI_assert(cd_vert_skin_offset != -1);
if (ve_median->skin[i] != median->skin[i]) {
scale_skin[i] = ve_median->skin[i] / (ve_median->skin[i] - median->skin[i]);
}
}
}
BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) {
if (apply_vcos) {
apply_raw_diff_v3(eve->co, tot, ve_median->location, median->location);
}
if (cd_vert_bweight_offset != -1) {
float *b_weight = BM_ELEM_CD_GET_VOID_P(eve, cd_vert_bweight_offset);
apply_scale_factor_clamp(b_weight, tot, ve_median->bv_weight, scale_bv_weight);
}
if (cd_vert_skin_offset != -1) {
MVertSkin *vs = BM_ELEM_CD_GET_VOID_P(eve, cd_vert_skin_offset);
/* That one is not clamped to [0.0, 1.0]. */
for (int i = 0; i < 2; i++) {
if (median->skin[i] != 0.0f) {
apply_scale_factor(
&vs->radius[i], tot, ve_median->skin[i], median->skin[i],
scale_skin[i]);
}
}
}
}
}
}
if (apply_vcos) {
EDBM_mesh_normals_update(em);
}
/* Edges */
if (median->be_weight || median->crease) {
if (median->be_weight) {
BM_mesh_cd_flag_ensure(bm, me, ME_CDFLAG_EDGE_BWEIGHT);
cd_edge_bweight_offset = CustomData_get_offset(&bm->edata, CD_BWEIGHT);
BLI_assert(cd_edge_bweight_offset != -1);
scale_be_weight = compute_scale_factor(ve_median->be_weight, median->be_weight);
}
if (median->crease) {
BM_mesh_cd_flag_ensure(bm, me, ME_CDFLAG_EDGE_CREASE);
cd_edge_crease_offset = CustomData_get_offset(&bm->edata, CD_CREASE);
BLI_assert(cd_edge_crease_offset != -1);
scale_crease = compute_scale_factor(ve_median->crease, median->crease);
}
BM_ITER_MESH (eed, &iter, bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) {
if (median->be_weight != 0.0f) {
float *b_weight = BM_ELEM_CD_GET_VOID_P(eed, cd_edge_bweight_offset);
apply_scale_factor_clamp(b_weight, tot, ve_median->be_weight, scale_be_weight);
}
if (median->crease != 0.0f) {
float *crease = BM_ELEM_CD_GET_VOID_P(eed, cd_edge_crease_offset);
apply_scale_factor_clamp(crease, tot, ve_median->crease, scale_crease);
}
}
}
}
}
else if (ELEM(ob->type, OB_CURVE, OB_SURF) &&
(apply_vcos ||
median_basis.curve.b_weight ||
median_basis.curve.weight ||
median_basis.curve.radius ||
median_basis.curve.tilt))
{
const TransformMedian_Curve *median = &median_basis.curve, *ve_median = &ve_median_basis.curve;
Curve *cu = ob->data;
Nurb *nu;
BPoint *bp;
BezTriple *bezt;
int a;
ListBase *nurbs = BKE_curve_editNurbs_get(cu);
const float scale_w = compute_scale_factor(ve_median->weight, median->weight);
nu = nurbs->first;
while (nu) {
if (nu->type == CU_BEZIER) {
for (a = nu->pntsu, bezt = nu->bezt; a--; bezt++) {
if (bezt->f2 & SELECT) {
if (apply_vcos) {
/* Here we always have to use the diff... :/
* Cannot avoid some glitches when going e.g. from 3 to 0.0001 (see T37327),
* unless we use doubles.
*/
add_v3_v3(bezt->vec[0], median->location);
add_v3_v3(bezt->vec[1], median->location);
add_v3_v3(bezt->vec[2], median->location);
}
if (median->weight) {
apply_scale_factor_clamp(&bezt->weight, tot, ve_median->weight, scale_w);
}
if (median->radius) {
apply_raw_diff(&bezt->radius, tot, ve_median->radius, median->radius);
}
if (median->tilt) {
apply_raw_diff(&bezt->tilt, tot, ve_median->tilt, median->tilt);
}
}
else if (apply_vcos) {
/* Handles can only have their coordinates changed here. */
if (bezt->f1 & SELECT) {
apply_raw_diff_v3(bezt->vec[0], tot, ve_median->location, median->location);
}
if (bezt->f3 & SELECT) {
apply_raw_diff_v3(bezt->vec[2], tot, ve_median->location, median->location);
}
}
}
}
else {
for (a = nu->pntsu * nu->pntsv, bp = nu->bp; a--; bp++) {
if (bp->f1 & SELECT) {
if (apply_vcos) {
apply_raw_diff_v3(bp->vec, tot, ve_median->location, median->location);
}
if (median->b_weight) {
apply_raw_diff(&bp->vec[3], tot, ve_median->b_weight, median->b_weight);
}
if (median->weight) {
apply_scale_factor_clamp(&bp->weight, tot, ve_median->weight, scale_w);
}
if (median->radius) {
apply_raw_diff(&bp->radius, tot, ve_median->radius, median->radius);
}
if (median->tilt) {
apply_raw_diff(&bp->tilt, tot, ve_median->tilt, median->tilt);
}
}
}
}
BKE_nurb_test_2d(nu);
BKE_nurb_handles_test(nu, true); /* test for bezier too */
nu = nu->next;
}
}
else if ((ob->type == OB_LATTICE) &&
(apply_vcos || median_basis.lattice.weight))
{
const TransformMedian_Lattice *median = &median_basis.lattice, *ve_median = &ve_median_basis.lattice;
Lattice *lt = ob->data;
BPoint *bp;
int a;
const float scale_w = compute_scale_factor(ve_median->weight, median->weight);
a = lt->editlatt->latt->pntsu * lt->editlatt->latt->pntsv * lt->editlatt->latt->pntsw;
bp = lt->editlatt->latt->def;
while (a--) {
if (bp->f1 & SELECT) {
if (apply_vcos) {
apply_raw_diff_v3(bp->vec, tot, ve_median->location, median->location);
}
if (median->weight) {
apply_scale_factor_clamp(&bp->weight, tot, ve_median->weight, scale_w);
}
}
bp++;
}
}
/* ED_undo_push(C, "Transform properties"); */
}
}
#undef TRANSFORM_MEDIAN_ARRAY_LEN
static void v3d_object_dimension_buts(bContext *C, uiLayout *layout, View3D *v3d, Object *ob)
{
uiBlock *block = (layout) ? uiLayoutAbsoluteBlock(layout) : NULL;
TransformProperties *tfp = v3d_transform_props_ensure(v3d);
if (block) {
BLI_assert(C == NULL);
int yi = 200;
const int butw = 200;
const int buth = 20 * UI_DPI_FAC;
BKE_object_dimensions_get(ob, tfp->ob_dims);
copy_v3_v3(tfp->ob_dims_orig, tfp->ob_dims);
uiDefBut(block, UI_BTYPE_LABEL, 0, IFACE_("Dimensions:"), 0, yi -= buth, butw, buth, NULL, 0, 0, 0, 0, "");
UI_block_align_begin(block);
const float lim = 10000;
for (int i = 0; i < 3; i++) {
uiBut *but;
char text[3] = {'X' + i, ':', '\0'};
but = uiDefButF(
block, UI_BTYPE_NUM, B_TRANSFORM_PANEL_DIMS, text, 0, yi -= buth, butw, buth,
&(tfp->ob_dims[i]), 0.0f, lim, 10, 3, "");
UI_but_unit_type_set(but, PROP_UNIT_LENGTH);
}
UI_block_align_end(block);
}
else { /* apply */
int axis_mask = 0;
for (int i = 0; i < 3; i++) {
if (tfp->ob_dims[i] == tfp->ob_dims_orig[i]) {
axis_mask |= (1 << i);
}
}
BKE_object_dimensions_set(ob, tfp->ob_dims, axis_mask);
PointerRNA obptr;
RNA_id_pointer_create(&ob->id, &obptr);
PropertyRNA *prop = RNA_struct_find_property(&obptr, "scale");
RNA_property_update(C, &obptr, prop);
}
}
#define B_VGRP_PNL_EDIT_SINGLE 8 /* or greater */
static void do_view3d_vgroup_buttons(bContext *C, void *UNUSED(arg), int event)
{
if (event < B_VGRP_PNL_EDIT_SINGLE) {
/* not for me */
return;
}
else {
ViewLayer *view_layer = CTX_data_view_layer(C);
Object *ob = view_layer->basact->object;
ED_vgroup_vert_active_mirror(ob, event - B_VGRP_PNL_EDIT_SINGLE);
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
WM_event_add_notifier(C, NC_GEOM | ND_DATA, ob->data);
}
}
static bool view3d_panel_vgroup_poll(const bContext *C, PanelType *UNUSED(pt))
{
ViewLayer *view_layer = CTX_data_view_layer(C);
Object *ob = OBACT(view_layer);
if (ob && (BKE_object_is_in_editmode_vgroup(ob) ||
BKE_object_is_in_wpaint_select_vert(ob)))
{
MDeformVert *dvert_act = ED_mesh_active_dvert_get_only(ob);
if (dvert_act) {
return (dvert_act->totweight != 0);
}
}
return false;
}
static void view3d_panel_vgroup(const bContext *C, Panel *pa)
{
uiBlock *block = uiLayoutAbsoluteBlock(pa->layout);
Scene *scene = CTX_data_scene(C);
ViewLayer *view_layer = CTX_data_view_layer(C);
Object *ob = view_layer->basact->object;
MDeformVert *dv;
dv = ED_mesh_active_dvert_get_only(ob);
if (dv && dv->totweight) {
ToolSettings *ts = scene->toolsettings;
wmOperatorType *ot;
PointerRNA op_ptr, tools_ptr;
PointerRNA *but_ptr;
uiLayout *col, *bcol;
uiLayout *row;
uiBut *but;
bDeformGroup *dg;
uint i;
int subset_count, vgroup_tot;
const bool *vgroup_validmap;
eVGroupSelect subset_type = ts->vgroupsubset;
int yco = 0;
int lock_count = 0;
UI_block_func_handle_set(block, do_view3d_vgroup_buttons, NULL);
bcol = uiLayoutColumn(pa->layout, true);
row = uiLayoutRow(bcol, true); /* The filter button row */
RNA_pointer_create(NULL, &RNA_ToolSettings, ts, &tools_ptr);
uiItemR(row, &tools_ptr, "vertex_group_subset", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
col = uiLayoutColumn(bcol, true);
vgroup_validmap = BKE_object_defgroup_subset_from_select_type(ob, subset_type, &vgroup_tot, &subset_count);
for (i = 0, dg = ob->defbase.first; dg; i++, dg = dg->next) {
bool locked = (dg->flag & DG_LOCK_WEIGHT) != 0;
if (vgroup_validmap[i]) {
MDeformWeight *dw = defvert_find_index(dv, i);
if (dw) {
int x, xco = 0;
int icon;
uiLayout *split = uiLayoutSplit(col, 0.45, true);
row = uiLayoutRow(split, true);
/* The Weight Group Name */
ot = WM_operatortype_find("OBJECT_OT_vertex_weight_set_active", true);
but = uiDefButO_ptr(block, UI_BTYPE_BUT, ot, WM_OP_EXEC_DEFAULT, dg->name,
xco, yco, (x = UI_UNIT_X * 5), UI_UNIT_Y, "");
but_ptr = UI_but_operator_ptr_get(but);
RNA_int_set(but_ptr, "weight_group", i);
UI_but_drawflag_enable(but, UI_BUT_TEXT_RIGHT);
if (ob->actdef != i + 1) {
UI_but_flag_enable(but, UI_BUT_INACTIVE);
}
xco += x;
row = uiLayoutRow(split, true);
uiLayoutSetEnabled(row, !locked);
/* The weight group value */
/* To be reworked still */
but = uiDefButF(block, UI_BTYPE_NUM, B_VGRP_PNL_EDIT_SINGLE + i, "",
xco, yco, (x = UI_UNIT_X * 4), UI_UNIT_Y,
&dw->weight, 0.0, 1.0, 1, 3, "");
UI_but_drawflag_enable(but, UI_BUT_TEXT_LEFT);
if (locked) {
lock_count++;
}
xco += x;
/* The weight group paste function */
icon = (locked) ? ICON_BLANK1 : ICON_PASTEDOWN;
uiItemFullO(row, "OBJECT_OT_vertex_weight_paste", "", icon, NULL, WM_OP_INVOKE_DEFAULT, 0, &op_ptr);
RNA_int_set(&op_ptr, "weight_group", i);
/* The weight entry delete function */
icon = (locked) ? ICON_LOCKED : ICON_X;
uiItemFullO(row, "OBJECT_OT_vertex_weight_delete", "", icon, NULL, WM_OP_INVOKE_DEFAULT, 0, &op_ptr);
RNA_int_set(&op_ptr, "weight_group", i);
yco -= UI_UNIT_Y;
}
}
}
MEM_freeN((void *)vgroup_validmap);
yco -= 2;
col = uiLayoutColumn(pa->layout, true);
row = uiLayoutRow(col, true);
ot = WM_operatortype_find("OBJECT_OT_vertex_weight_normalize_active_vertex", 1);
but = uiDefButO_ptr(block, UI_BTYPE_BUT, ot, WM_OP_EXEC_DEFAULT, "Normalize",
0, yco, UI_UNIT_X * 5, UI_UNIT_Y,
TIP_("Normalize weights of active vertex (if affected groups are unlocked)"));
if (lock_count) {
UI_but_flag_enable(but, UI_BUT_DISABLED);
}
ot = WM_operatortype_find("OBJECT_OT_vertex_weight_copy", 1);
but = uiDefButO_ptr(block, UI_BTYPE_BUT, ot, WM_OP_EXEC_DEFAULT, "Copy",
UI_UNIT_X * 5, yco, UI_UNIT_X * 5, UI_UNIT_Y,
TIP_("Copy active vertex to other selected vertices (if affected groups are unlocked)"));
if (lock_count) {
UI_but_flag_enable(but, UI_BUT_DISABLED);
}
}
}
static void v3d_transform_butsR(uiLayout *layout, PointerRNA *ptr)
{
uiLayout *split, *colsub;
split = uiLayoutSplit(layout, 0.8f, false);
if (ptr->type == &RNA_PoseBone) {
PointerRNA boneptr;
Bone *bone;
boneptr = RNA_pointer_get(ptr, "bone");
bone = boneptr.data;
uiLayoutSetActive(split, !(bone->parent && bone->flag & BONE_CONNECTED));
}
colsub = uiLayoutColumn(split, true);
uiItemR(colsub, ptr, "location", 0, NULL, ICON_NONE);
colsub = uiLayoutColumn(split, true);
uiLayoutSetEmboss(colsub, UI_EMBOSS_NONE);
uiItemL(colsub, "", ICON_NONE);
uiItemR(colsub, ptr, "lock_location", UI_ITEM_R_TOGGLE | UI_ITEM_R_ICON_ONLY, "", ICON_DECORATE_UNLOCKED);
split = uiLayoutSplit(layout, 0.8f, false);
switch (RNA_enum_get(ptr, "rotation_mode")) {
case ROT_MODE_QUAT: /* quaternion */
colsub = uiLayoutColumn(split, true);
uiItemR(colsub, ptr, "rotation_quaternion", 0, IFACE_("Rotation"), ICON_NONE);
colsub = uiLayoutColumn(split, true);
uiLayoutSetEmboss(colsub, UI_EMBOSS_NONE);
uiItemR(colsub, ptr, "lock_rotations_4d", UI_ITEM_R_TOGGLE, IFACE_("4L"), ICON_NONE);
if (RNA_boolean_get(ptr, "lock_rotations_4d")) {
uiItemR(colsub, ptr, "lock_rotation_w", UI_ITEM_R_TOGGLE + UI_ITEM_R_ICON_ONLY, "", ICON_DECORATE_UNLOCKED);
}
else {
uiItemL(colsub, "", ICON_NONE);
}
uiItemR(colsub, ptr, "lock_rotation", UI_ITEM_R_TOGGLE | UI_ITEM_R_ICON_ONLY, "", ICON_DECORATE_UNLOCKED);
break;
case ROT_MODE_AXISANGLE: /* axis angle */
colsub = uiLayoutColumn(split, true);
uiItemR(colsub, ptr, "rotation_axis_angle", 0, IFACE_("Rotation"), ICON_NONE);
colsub = uiLayoutColumn(split, true);
uiLayoutSetEmboss(colsub, UI_EMBOSS_NONE);
uiItemR(colsub, ptr, "lock_rotations_4d", UI_ITEM_R_TOGGLE, IFACE_("4L"), ICON_NONE);
if (RNA_boolean_get(ptr, "lock_rotations_4d")) {
uiItemR(colsub, ptr, "lock_rotation_w", UI_ITEM_R_TOGGLE | UI_ITEM_R_ICON_ONLY, "", ICON_DECORATE_UNLOCKED);
}
else {
uiItemL(colsub, "", ICON_NONE);
}
uiItemR(colsub, ptr, "lock_rotation", UI_ITEM_R_TOGGLE | UI_ITEM_R_ICON_ONLY, "", ICON_DECORATE_UNLOCKED);
break;
default: /* euler rotations */
colsub = uiLayoutColumn(split, true);
uiItemR(colsub, ptr, "rotation_euler", 0, IFACE_("Rotation"), ICON_NONE);
colsub = uiLayoutColumn(split, true);
uiLayoutSetEmboss(colsub, UI_EMBOSS_NONE);
uiItemL(colsub, "", ICON_NONE);
uiItemR(colsub, ptr, "lock_rotation", UI_ITEM_R_TOGGLE | UI_ITEM_R_ICON_ONLY, "", ICON_DECORATE_UNLOCKED);
break;
}
uiItemR(layout, ptr, "rotation_mode", 0, "", ICON_NONE);
split = uiLayoutSplit(layout, 0.8f, false);
colsub = uiLayoutColumn(split, true);
uiItemR(colsub, ptr, "scale", 0, NULL, ICON_NONE);
colsub = uiLayoutColumn(split, true);
uiLayoutSetEmboss(colsub, UI_EMBOSS_NONE);
uiItemL(colsub, "", ICON_NONE);
uiItemR(colsub, ptr, "lock_scale", UI_ITEM_R_TOGGLE | UI_ITEM_R_ICON_ONLY, "", ICON_DECORATE_UNLOCKED);
}
static void v3d_posearmature_buts(uiLayout *layout, Object *ob)
{
bPoseChannel *pchan;
PointerRNA pchanptr;
uiLayout *col;
pchan = BKE_pose_channel_active(ob);
if (!pchan) {
uiItemL(layout, IFACE_("No Bone Active"), ICON_NONE);
return;
}
RNA_pointer_create(&ob->id, &RNA_PoseBone, pchan, &pchanptr);
col = uiLayoutColumn(layout, false);
/* XXX: RNA buts show data in native types (i.e. quats, 4-component axis/angle, etc.)
* but old-school UI shows in eulers always. Do we want to be able to still display in Eulers?
* Maybe needs RNA/ui options to display rotations as different types... */
v3d_transform_butsR(col, &pchanptr);
}
static void v3d_editarmature_buts(uiLayout *layout, Object *ob)
{
bArmature *arm = ob->data;
EditBone *ebone;
uiLayout *col;
PointerRNA eboneptr;
ebone = arm->act_edbone;
if (!ebone || (ebone->layer & arm->layer) == 0) {
uiItemL(layout, IFACE_("Nothing selected"), ICON_NONE);
return;
}
RNA_pointer_create(&arm->id, &RNA_EditBone, ebone, &eboneptr);
col = uiLayoutColumn(layout, false);
uiItemR(col, &eboneptr, "head", 0, NULL, ICON_NONE);
if (ebone->parent && ebone->flag & BONE_CONNECTED) {
PointerRNA parptr = RNA_pointer_get(&eboneptr, "parent");
uiItemR(col, &parptr, "tail_radius", 0, IFACE_("Radius (Parent)"), ICON_NONE);
}
else {
uiItemR(col, &eboneptr, "head_radius", 0, IFACE_("Radius"), ICON_NONE);
}
uiItemR(col, &eboneptr, "tail", 0, NULL, ICON_NONE);
uiItemR(col, &eboneptr, "tail_radius", 0, IFACE_("Radius"), ICON_NONE);
uiItemR(col, &eboneptr, "roll", 0, NULL, ICON_NONE);
uiItemR(col, &eboneptr, "envelope_distance", 0, IFACE_("Envelope"), ICON_NONE);
}
static void v3d_editmetaball_buts(uiLayout *layout, Object *ob)
{
PointerRNA mbptr, ptr;
MetaBall *mball = ob->data;
uiLayout *col;
if (!mball || !(mball->lastelem)) {
return;
}
RNA_pointer_create(&mball->id, &RNA_MetaBall, mball, &mbptr);
RNA_pointer_create(&mball->id, &RNA_MetaElement, mball->lastelem, &ptr);
col = uiLayoutColumn(layout, false);
uiItemR(col, &ptr, "co", 0, NULL, ICON_NONE);
uiItemR(col, &ptr, "radius", 0, NULL, ICON_NONE);
uiItemR(col, &ptr, "stiffness", 0, NULL, ICON_NONE);
uiItemR(col, &ptr, "type", 0, NULL, ICON_NONE);
col = uiLayoutColumn(layout, true);
switch (RNA_enum_get(&ptr, "type")) {
case MB_BALL:
break;
case MB_CUBE:
uiItemL(col, IFACE_("Size:"), ICON_NONE);
uiItemR(col, &ptr, "size_x", 0, "X", ICON_NONE);
uiItemR(col, &ptr, "size_y", 0, "Y", ICON_NONE);
uiItemR(col, &ptr, "size_z", 0, "Z", ICON_NONE);
break;
case MB_TUBE:
uiItemL(col, IFACE_("Size:"), ICON_NONE);
uiItemR(col, &ptr, "size_x", 0, "X", ICON_NONE);
break;
case MB_PLANE:
uiItemL(col, IFACE_("Size:"), ICON_NONE);
uiItemR(col, &ptr, "size_x", 0, "X", ICON_NONE);
uiItemR(col, &ptr, "size_y", 0, "Y", ICON_NONE);
break;
case MB_ELIPSOID:
uiItemL(col, IFACE_("Size:"), ICON_NONE);
uiItemR(col, &ptr, "size_x", 0, "X", ICON_NONE);
uiItemR(col, &ptr, "size_y", 0, "Y", ICON_NONE);
uiItemR(col, &ptr, "size_z", 0, "Z", ICON_NONE);
break;
}
}
static void do_view3d_region_buttons(bContext *C, void *UNUSED(index), int event)
{
ViewLayer *view_layer = CTX_data_view_layer(C);
View3D *v3d = CTX_wm_view3d(C);
Object *ob = OBACT(view_layer);
switch (event) {
case B_REDR:
ED_area_tag_redraw(CTX_wm_area(C));
return; /* no notifier! */
case B_TRANSFORM_PANEL_MEDIAN:
if (ob) {
v3d_editvertex_buts(NULL, v3d, ob, 1.0);
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
}
break;
case B_TRANSFORM_PANEL_DIMS:
if (ob) {
v3d_object_dimension_buts(C, NULL, v3d, ob);
}
break;
}
/* default for now */
WM_event_add_notifier(C, NC_SPACE | ND_SPACE_VIEW3D, v3d);
}
static bool view3d_panel_transform_poll(const bContext *C, PanelType *UNUSED(pt))
{
ViewLayer *view_layer = CTX_data_view_layer(C);
return (view_layer->basact != NULL);
}
static void view3d_panel_transform(const bContext *C, Panel *pa)
{
uiBlock *block;
ViewLayer *view_layer = CTX_data_view_layer(C);
Object *ob = view_layer->basact->object;
Object *obedit = OBEDIT_FROM_OBACT(ob);
uiLayout *col;
block = uiLayoutGetBlock(pa->layout);
UI_block_func_handle_set(block, do_view3d_region_buttons, NULL);
col = uiLayoutColumn(pa->layout, false);
if (ob == obedit) {
if (ob->type == OB_ARMATURE) {
v3d_editarmature_buts(col, ob);
}
else if (ob->type == OB_MBALL) {
v3d_editmetaball_buts(col, ob);
}
else {
View3D *v3d = CTX_wm_view3d(C);
Scene *scene = CTX_data_scene(C);
const float lim = 10000.0f * max_ff(1.0f, ED_view3d_grid_scale(scene, v3d, NULL));
v3d_editvertex_buts(col, v3d, ob, lim);
}
}
else if (ob->mode & OB_MODE_POSE) {
v3d_posearmature_buts(col, ob);
}
else {
PointerRNA obptr;
RNA_id_pointer_create(&ob->id, &obptr);
v3d_transform_butsR(col, &obptr);
/* dimensions and editmode just happen to be the same checks */
if (OB_TYPE_SUPPORT_EDITMODE(ob->type)) {
View3D *v3d = CTX_wm_view3d(C);
v3d_object_dimension_buts(NULL, col, v3d, ob);
}
}
}
static void hide_collections_menu_draw(const bContext *C, Menu *menu)
{
ED_collection_hide_menu_draw(C, menu->layout);
}
void view3d_buttons_register(ARegionType *art)
{
PanelType *pt;
pt = MEM_callocN(sizeof(PanelType), "spacetype view3d panel object");
strcpy(pt->idname, "VIEW3D_PT_transform");
strcpy(pt->label, N_("Transform")); /* XXX C panels unavailable through RNA bpy.types! */
strcpy(pt->category, "View");
strcpy(pt->translation_context, BLT_I18NCONTEXT_DEFAULT_BPYRNA);
pt->draw = view3d_panel_transform;
pt->poll = view3d_panel_transform_poll;
BLI_addtail(&art->paneltypes, pt);
pt = MEM_callocN(sizeof(PanelType), "spacetype view3d panel vgroup");
strcpy(pt->idname, "VIEW3D_PT_vgroup");
strcpy(pt->label, N_("Vertex Weights")); /* XXX C panels unavailable through RNA bpy.types! */
strcpy(pt->category, "View");
strcpy(pt->translation_context, BLT_I18NCONTEXT_DEFAULT_BPYRNA);
pt->draw = view3d_panel_vgroup;
pt->poll = view3d_panel_vgroup_poll;
BLI_addtail(&art->paneltypes, pt);
MenuType *mt;
mt = MEM_callocN(sizeof(MenuType), "spacetype view3d menu collections");
strcpy(mt->idname, "VIEW3D_MT_collection");
strcpy(mt->label, N_("Collection"));
strcpy(mt->translation_context, BLT_I18NCONTEXT_DEFAULT_BPYRNA);
mt->draw = hide_collections_menu_draw;
WM_menutype_add(mt);
}
static int view3d_properties_toggle_exec(bContext *C, wmOperator *UNUSED(op))
{
ScrArea *sa = CTX_wm_area(C);
ARegion *ar = view3d_has_buttons_region(sa);
if (ar) {
ED_region_toggle_hidden(C, ar);
}
return OPERATOR_FINISHED;
}
void VIEW3D_OT_properties(wmOperatorType *ot)
{
ot->name = "Toggle Sidebar";
ot->description = "Toggle the properties region visibility";
ot->idname = "VIEW3D_OT_properties";
ot->exec = view3d_properties_toggle_exec;
ot->poll = ED_operator_view3d_active;
/* flags */
ot->flag = 0;
}
static int view3d_object_mode_menu(bContext *C, wmOperator *op)
{
Object *ob = CTX_data_active_object(C);
if (ob == NULL) {
BKE_report(op->reports, RPT_WARNING, "No active object found");
return OPERATOR_CANCELLED;
}
else if (((ob->mode & OB_MODE_EDIT) == 0) && (ELEM(ob->type, OB_ARMATURE))) {
ED_object_mode_toggle(C, OB_MODE_POSE);
return OPERATOR_CANCELLED;
}
else {
UI_pie_menu_invoke(C, "VIEW3D_MT_object_mode_pie", CTX_wm_window(C)->eventstate);
return OPERATOR_CANCELLED;
}
}
void VIEW3D_OT_object_mode_pie_or_toggle(wmOperatorType *ot)
{
ot->name = "Object Mode Menu";
ot->idname = "VIEW3D_OT_object_mode_pie_or_toggle";
ot->exec = view3d_object_mode_menu;
ot->poll = ED_operator_view3d_active;
/* flags */
ot->flag = 0;
}
View Git Blame Copy Permalink