Merge branch 'master' into blender2.8
authorBastien Montagne <montagne29@wanadoo.fr>
Wed, 14 Mar 2018 17:07:01 +0000 (18:07 +0100)
committerBastien Montagne <montagne29@wanadoo.fr>
Wed, 14 Mar 2018 17:10:31 +0000 (18:10 +0100)
1  2 
source/blender/blenkernel/intern/idprop.c
source/blender/editors/animation/anim_channels_edit.c
source/blender/editors/mesh/editmesh_knife.c
source/blender/editors/mesh/editmesh_select.c
source/blender/editors/object/object_transform.c
source/blender/editors/object/object_vgroup.c
source/blender/editors/space_node/node_templates.c
source/blender/editors/uvedit/uvedit_ops.c
source/blender/modifiers/intern/MOD_skin.c

index 033f9d190b7f6b2365db5042d297fb3e2b71f12a,9fea7bf5b8938f5c9a5da363d16b8c40db83c908..7ea1a04f31f271e33668ad40c6de5379194872ce
@@@ -1152,389 -1131,3 +1152,389 @@@ void OBJECT_OT_origin_set(wmOperatorTyp
        ot->prop = RNA_def_enum(ot->srna, "type", prop_set_center_types, 0, "Type", "");
        RNA_def_enum(ot->srna, "center", prop_set_bounds_types, V3D_AROUND_CENTER_MEAN, "Center", "");
  }
-               xfd->object_data_len = BLI_array_count(object_data);
 +
 +/* -------------------------------------------------------------------- */
 +
 +/** \name Transform Axis Target
 + *
 + * Note this is an experemental operator to point lamps/cameras at objects.
 + * We may re-work how this behaves based on user feedback.
 + * - campbell.
 + * \{ */
 +
 +/* When using multiple objects, apply their relative rotational offset to the active object. */
 +#define USE_RELATIVE_ROTATION
 +
 +struct XFormAxisItem {
 +      Object *ob;
 +      float rot_mat[3][3];
 +      void *obtfm;
 +      float xform_dist;
 +
 +#ifdef USE_RELATIVE_ROTATION
 +      /* use when translating multiple */
 +      float xform_rot_offset[3][3];
 +#endif
 +};
 +
 +struct XFormAxisData {
 +      ViewContext vc;
 +      struct {
 +              float depth;
 +              float normal[3];
 +              bool is_depth_valid;
 +              bool is_normal_valid;
 +      } prev;
 +
 +      struct XFormAxisItem *object_data;
 +      uint object_data_len;
 +      bool is_translate;
 +
 +      int init_event;
 +};
 +
 +static bool object_is_target_compat(const Object *ob)
 +{
 +      if (ob->type == OB_LAMP) {
 +              const Lamp *la = ob->data;
 +              if (ELEM(la->type, LA_SUN, LA_SPOT, LA_HEMI, LA_AREA)) {
 +                      return true;
 +              }
 +      }
 +      /* We might want to enable this later, for now just lamps */
 +#if 0
 +      else if (ob->type == OB_CAMERA) {
 +              return true;
 +      }
 +#endif
 +      return false;
 +}
 +
 +static void object_transform_axis_target_free_data(wmOperator *op)
 +{
 +      struct XFormAxisData *xfd = op->customdata;
 +      struct XFormAxisItem *item = xfd->object_data;
 +      for (int i = 0; i < xfd->object_data_len; i++, item++) {
 +              MEM_freeN(item->obtfm);
 +      }
 +      MEM_freeN(xfd->object_data);
 +      MEM_freeN(xfd);
 +      op->customdata = NULL;
 +}
 +
 +/* We may want to expose as alternative to: BKE_object_apply_rotation */
 +static void object_apply_rotation(Object *ob, const float rmat[3][3])
 +{
 +      float size[3];
 +      float loc[3];
 +      float rmat4[4][4];
 +      copy_m4_m3(rmat4, rmat);
 +
 +      copy_v3_v3(size, ob->size);
 +      copy_v3_v3(loc, ob->loc);
 +      BKE_object_apply_mat4(ob, rmat4, true, true);
 +      copy_v3_v3(ob->size, size);
 +      copy_v3_v3(ob->loc, loc);
 +}
 +/* We may want to extract this to: BKE_object_apply_location */
 +static void object_apply_location(Object *ob, const float loc[3])
 +{
 +      /* quick but weak */
 +      Object ob_prev = *ob;
 +      float mat[4][4];
 +      copy_m4_m4(mat, ob->obmat);
 +      copy_v3_v3(mat[3], loc);
 +      BKE_object_apply_mat4(ob, mat, true, true);
 +      copy_v3_v3(mat[3], ob->loc);
 +      *ob = ob_prev;
 +      copy_v3_v3(ob->loc, mat[3]);
 +}
 +
 +static void object_orient_to_location(
 +        Object *ob, float rot_orig[3][3], const float axis[3], const float location[3])
 +{
 +      float delta[3];
 +      sub_v3_v3v3(delta, ob->obmat[3], location);
 +      if (normalize_v3(delta) != 0.0f) {
 +              if (len_squared_v3v3(delta, axis) > FLT_EPSILON) {
 +                      float delta_rot[3][3];
 +                      float final_rot[3][3];
 +                      rotation_between_vecs_to_mat3(delta_rot, axis, delta);
 +
 +                      mul_m3_m3m3(final_rot, delta_rot, rot_orig);
 +
 +                      object_apply_rotation(ob, final_rot);
 +
 +                      DEG_id_tag_update(&ob->id, OB_RECALC_OB);
 +              }
 +      }
 +}
 +
 +static void object_transform_axis_target_cancel(bContext *C, wmOperator *op)
 +{
 +      struct XFormAxisData *xfd = op->customdata;
 +      struct XFormAxisItem *item = xfd->object_data;
 +      for (int i = 0; i < xfd->object_data_len; i++, item++) {
 +              BKE_object_tfm_restore(item->ob, item->obtfm);
 +              DEG_id_tag_update(&item->ob->id, OB_RECALC_OB);
 +              WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, item->ob);
 +      }
 +
 +      object_transform_axis_target_free_data(op);
 +}
 +
 +static int object_transform_axis_target_invoke(bContext *C, wmOperator *op, const wmEvent *event)
 +{
 +      ViewContext vc;
 +      ED_view3d_viewcontext_init(C, &vc);
 +
 +      if (!object_is_target_compat(vc.obact)) {
 +              /* Falls back to texture space transform. */
 +              return OPERATOR_PASS_THROUGH;
 +      }
 +
 +      EvaluationContext eval_ctx;
 +
 +      CTX_data_eval_ctx(C, &eval_ctx);
 +
 +      ED_view3d_autodist_init(&eval_ctx, vc.depsgraph, vc.ar, vc.v3d, 0);
 +
 +      if (vc.rv3d->depths != NULL) {
 +              vc.rv3d->depths->damaged = true;
 +      }
 +      ED_view3d_depth_update(vc.ar);
 +
 +      if (vc.rv3d->depths == NULL) {
 +              BKE_report(op->reports, RPT_WARNING, "Unable to access depth buffer, using view plane");
 +              return OPERATOR_CANCELLED;
 +      }
 +
 +      ED_region_tag_redraw(vc.ar);
 +
 +      struct XFormAxisData *xfd;
 +      xfd = op->customdata = MEM_callocN(sizeof(struct XFormAxisData), __func__);
 +
 +      /* Don't change this at runtime. */
 +      xfd->vc = vc;
 +      xfd->vc.mval[0] = event->mval[0];
 +      xfd->vc.mval[1] = event->mval[1];
 +
 +      xfd->prev.depth = 1.0f;
 +      xfd->prev.is_depth_valid = false;
 +      xfd->prev.is_normal_valid = false;
 +      xfd->is_translate = false;
 +
 +      xfd->init_event = WM_userdef_event_type_from_keymap_type(event->type);
 +
 +      {
 +              struct XFormAxisItem *object_data = NULL;
 +              BLI_array_declare(object_data);
 +
 +              struct XFormAxisItem *item = BLI_array_append_ret(object_data);
 +              item->ob = xfd->vc.obact;
 +
 +              CTX_DATA_BEGIN (C, Object *, ob, selected_editable_objects)
 +              {
 +                      if ((ob != xfd->vc.obact) && object_is_target_compat(ob)) {
 +                              item = BLI_array_append_ret(object_data);
 +                              item->ob = ob;
 +                      }
 +              }
 +              CTX_DATA_END;
 +
 +              xfd->object_data = object_data;
-               if (xfd->object_data_len != BLI_array_count(object_data)) {
++              xfd->object_data_len = BLI_array_len(object_data);
 +
++              if (xfd->object_data_len != BLI_array_len(object_data)) {
 +                      xfd->object_data = MEM_reallocN(xfd->object_data, xfd->object_data_len * sizeof(*xfd->object_data));
 +              }
 +      }
 +
 +      {
 +              struct XFormAxisItem *item = xfd->object_data;
 +              for (int i = 0; i < xfd->object_data_len; i++, item++) {
 +                      item->obtfm = BKE_object_tfm_backup(item->ob);
 +                      BKE_object_rot_to_mat3(item->ob, item->rot_mat, true);
 +              }
 +      }
 +
 +      WM_event_add_modal_handler(C, op);
 +
 +      return OPERATOR_RUNNING_MODAL;
 +}
 +
 +static int object_transform_axis_target_modal(bContext *C, wmOperator *op, const wmEvent *event)
 +{
 +      struct XFormAxisData *xfd = op->customdata;
 +      ARegion *ar = xfd->vc.ar;
 +
 +      view3d_operator_needs_opengl(C);
 +
 +      const bool is_translate = (event->ctrl != 0);
 +      const bool is_translate_init = is_translate && (xfd->is_translate != is_translate);
 +
 +      if (event->type == MOUSEMOVE || is_translate_init) {
 +              const ViewDepths *depths = xfd->vc.rv3d->depths;
 +              if (depths &&
 +                  ((unsigned int)event->mval[0] < depths->w) &&
 +                  ((unsigned int)event->mval[1] < depths->h))
 +              {
 +                      double depth = (double)ED_view3d_depth_read_cached(&xfd->vc, event->mval);
 +                      float location_world[3];
 +                      if (depth == 1.0f) {
 +                              if (xfd->prev.is_depth_valid) {
 +                                      depth = (double)xfd->prev.depth;
 +                              }
 +                      }
 +                      if ((depth > depths->depth_range[0]) && (depth < depths->depth_range[1])) {
 +                              xfd->prev.depth = depth;
 +                              xfd->prev.is_depth_valid = true;
 +                              if (ED_view3d_depth_unproject(ar, event->mval, depth, location_world)) {
 +                                      if (is_translate) {
 +
 +                                              float normal[3];
 +                                              bool normal_found = false;
 +                                              if (ED_view3d_depth_read_cached_normal(&xfd->vc, event->mval, normal)) {
 +                                                      normal_found = true;
 +
 +                                                      /* cheap attempt to smooth normals out a bit! */
 +                                                      const uint ofs = 2;
 +                                                      for (uint x = -ofs; x <= ofs; x += ofs / 2) {
 +                                                              for (uint y = -ofs; y <= ofs; y += ofs / 2) {
 +                                                                      if (x != 0 && y != 0) {
 +                                                                              int mval_ofs[2] = {event->mval[0] + x, event->mval[1] + y};
 +                                                                              float n[3];
 +                                                                              if (ED_view3d_depth_read_cached_normal(
 +                                                                                      &xfd->vc, mval_ofs, n))
 +                                                                              {
 +                                                                                      add_v3_v3(normal, n);
 +                                                                              }
 +                                                                      }
 +                                                              }
 +                                                      }
 +                                                      normalize_v3(normal);
 +                                              }
 +                                              else if (xfd->prev.is_normal_valid) {
 +                                                      copy_v3_v3(normal, xfd->prev.normal);
 +                                                      normal_found = true;
 +                                              }
 +
 +                                              if (normal_found) {
 +#ifdef USE_RELATIVE_ROTATION
 +                                                      if (is_translate_init && xfd->object_data_len > 1) {
 +                                                              float xform_rot_offset_inv_first[3][3];
 +                                                              struct XFormAxisItem *item = xfd->object_data;
 +                                                              for (int i = 0; i < xfd->object_data_len; i++, item++) {
 +                                                                      copy_m3_m4(item->xform_rot_offset, item->ob->obmat);
 +                                                                      normalize_m3(item->xform_rot_offset);
 +
 +                                                                      if (i == 0) {
 +                                                                              invert_m3_m3(xform_rot_offset_inv_first, xfd->object_data[0].xform_rot_offset);
 +                                                                      }
 +                                                                      else {
 +                                                                              mul_m3_m3m3(item->xform_rot_offset,
 +                                                                                          item->xform_rot_offset,
 +                                                                                          xform_rot_offset_inv_first);
 +                                                                      }
 +                                                              }
 +                                                      }
 +
 +#endif
 +
 +                                                      struct XFormAxisItem *item = xfd->object_data;
 +                                                      for (int i = 0; i < xfd->object_data_len; i++, item++) {
 +                                                              if (is_translate_init) {
 +                                                                      float ob_axis[3];
 +                                                                      item->xform_dist = len_v3v3(item->ob->obmat[3], location_world);
 +                                                                      normalize_v3_v3(ob_axis, item->ob->obmat[2]);
 +                                                                      /* Scale to avoid adding distance when moving between surfaces. */
 +                                                                      float scale = fabsf(dot_v3v3(ob_axis, normal));
 +                                                                      item->xform_dist *= scale;
 +                                                              }
 +
 +                                                              float target_normal[3];
 +                                                              copy_v3_v3(target_normal, normal);
 +
 +#ifdef USE_RELATIVE_ROTATION
 +                                                              if (i != 0) {
 +                                                                      mul_m3_v3(item->xform_rot_offset, target_normal);
 +                                                              }
 +#endif
 +                                                              {
 +                                                                      float loc[3];
 +
 +                                                                      copy_v3_v3(loc, location_world);
 +                                                                      madd_v3_v3fl(loc, target_normal, item->xform_dist);
 +                                                                      object_apply_location(item->ob, loc);
 +                                                                      copy_v3_v3(item->ob->obmat[3], loc);  /* so orient behaves as expected */
 +                                                              }
 +
 +                                                              object_orient_to_location(item->ob, item->rot_mat, item->rot_mat[2], location_world);
 +                                                              WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, item->ob);
 +                                                      }
 +                                                      copy_v3_v3(xfd->prev.normal, normal);
 +                                                      xfd->prev.is_normal_valid = true;
 +                                              }
 +                                      }
 +                                      else {
 +                                              struct XFormAxisItem *item = xfd->object_data;
 +                                              for (int i = 0; i < xfd->object_data_len; i++, item++) {
 +                                                      object_orient_to_location(item->ob, item->rot_mat, item->rot_mat[2], location_world);
 +                                                      WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, item->ob);
 +                                              }
 +                                              xfd->prev.is_normal_valid = false;
 +                                      }
 +                              }
 +                      }
 +              }
 +              xfd->is_translate = is_translate;
 +
 +              ED_region_tag_redraw(xfd->vc.ar);
 +      }
 +
 +      bool is_finished = false;
 +
 +      if (ISMOUSE(xfd->init_event)) {
 +              if ((event->type == xfd->init_event) && (event->val == KM_RELEASE)) {
 +                      is_finished = true;
 +              }
 +      }
 +      else {
 +              if (ELEM(event->type, LEFTMOUSE, RETKEY, PADENTER)) {
 +                      is_finished = true;
 +              }
 +      }
 +
 +      if (is_finished) {
 +              object_transform_axis_target_free_data(op);
 +              return OPERATOR_FINISHED;
 +      }
 +      else if (ELEM(event->type, ESCKEY, RIGHTMOUSE)) {
 +              object_transform_axis_target_cancel(C, op);
 +              return OPERATOR_CANCELLED;
 +      }
 +
 +
 +      return OPERATOR_RUNNING_MODAL;
 +}
 +
 +void OBJECT_OT_transform_axis_target(wmOperatorType *ot)
 +{
 +      /* identifiers */
 +      ot->name = "Interactive Lamp Track to Cursor";
 +      ot->description = "Interactively point cameras and lamps to a location (Ctrl translates)";
 +      ot->idname = "OBJECT_OT_transform_axis_target";
 +
 +      /* api callbacks */
 +      ot->invoke = object_transform_axis_target_invoke;
 +      ot->cancel = object_transform_axis_target_cancel;
 +      ot->modal = object_transform_axis_target_modal;
 +      ot->poll = ED_operator_region_view3d_active;
 +
 +      /* flags */
 +      ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_BLOCKING;
 +}
 +
 +#undef USE_RELATIVE_ROTATION
 +
 +/** \} */
index 1acd6a1152dab8085bfe348b51863614702cd9bc,852c4ae5958bee407bfb5c627577ac8ad87fa13c..9df0c7c89ed0178f572d321cc8ce0cb88156b694
@@@ -1663,13 -1746,11 +1663,13 @@@ static void uv_weld_align(bContext *C, 
                        }
  
                        /* now we have all verts, make into a line */
-                       if (BLI_array_count(eve_line) > 2) {
+                       if (BLI_array_len(eve_line) > 2) {
  
                                /* we know the returns from these must be valid */
 -                              const float *uv_start = uv_sel_co_from_eve(scene, ima, em, eve_line[0]);
 -                              const float *uv_end   = uv_sel_co_from_eve(scene, ima, em, eve_line[BLI_array_len(eve_line) - 1]);
 +                              const float *uv_start = uv_sel_co_from_eve(
 +                                      scene, obedit, ima, em, eve_line[0]);
 +                              const float *uv_end   = uv_sel_co_from_eve(
-                                       scene, obedit, ima, em, eve_line[BLI_array_count(eve_line) - 1]);
++                                      scene, obedit, ima, em, eve_line[BLI_array_len(eve_line) - 1]);
                                /* For t & u modes */
                                float a = 0.0f;
  
                                }
  
                                /* go over all verts except for endpoints */
-                               for (i = 0; i < BLI_array_count(eve_line); i++) {
+                               for (i = 0; i < BLI_array_len(eve_line); i++) {
                                        BM_ITER_ELEM (l, &liter, eve_line[i], BM_LOOPS_OF_VERT) {
 -                                              tf = BM_ELEM_CD_GET_VOID_P(l->f, cd_poly_tex_offset);
 -
 -                                              if (!uvedit_face_visible_test(scene, ima, l->f, tf))
 +                                              if (!uvedit_face_visible_test(scene, obedit, ima, l->f))
                                                        continue;
  
                                                if (uvedit_uv_select_test(scene, l, cd_loop_uv_offset)) {