Merging r58330 through r58361 from trunk into soc-2013-depsgraph_mt
authorSergey Sharybin <sergey.vfx@gmail.com>
Thu, 18 Jul 2013 09:29:12 +0000 (09:29 +0000)
committerSergey Sharybin <sergey.vfx@gmail.com>
Thu, 18 Jul 2013 09:29:12 +0000 (09:29 +0000)
1  2 
source/blender/blenkernel/intern/curve.c
source/blender/makesdna/DNA_curve_types.h

index b7926e5302f87c422e7fd08bb59163e59d2e07c9,00a479b8b880364073059cd53774ce9df3eea771..fb4d8395777afde309d5eaef2ea0439d94ab07dc
@@@ -145,6 -145,8 +145,6 @@@ void BKE_curve_editNurb_free(Curve *cu
  void BKE_curve_free(Curve *cu)
  {
        BKE_nurbList_free(&cu->nurb);
 -      BLI_freelistN(&cu->bev);
 -      BKE_displist_free(&cu->disp);
        BKE_curve_editfont_free(cu);
  
        BKE_curve_editNurb_free(cu);
                MEM_freeN(cu->strinfo);
        if (cu->bb)
                MEM_freeN(cu->bb);
 -      if (cu->path)
 -              free_path(cu->path);
        if (cu->tb)
                MEM_freeN(cu->tb);
  }
@@@ -224,6 -228,10 +224,6 @@@ Curve *BKE_curve_copy(Curve *cu
        cun->key = BKE_key_copy(cu->key);
        if (cun->key) cun->key->from = (ID *)cun;
  
 -      cun->disp.first = cun->disp.last = NULL;
 -      cun->bev.first = cun->bev.last = NULL;
 -      cun->path = NULL;
 -
        cun->editnurb = NULL;
        cun->editfont = NULL;
        cun->selboxes = NULL;
@@@ -364,79 -372,60 +364,79 @@@ void BKE_curve_type_test(Object *ob
                BKE_curve_curve_dimension_update((Curve *)ob->data);
  }
  
 -void BKE_curve_texspace_calc(Curve *cu)
 +void BKE_curve_boundbox_calc(Curve *cu, float r_loc[3], float r_size[3])
  {
 -      DispList *dl;
        BoundBox *bb;
 -      float *fp, min[3], max[3];
 -      int tot, do_it = FALSE;
 +      float min[3], max[3];
 +      float mloc[3], msize[3];
  
 -      if (cu->bb == NULL)
 -              cu->bb = MEM_callocN(sizeof(BoundBox), "boundbox");
 +      if (cu->bb == NULL) cu->bb = MEM_callocN(sizeof(BoundBox), "boundbox");
        bb = cu->bb;
  
 -      INIT_MINMAX(min, max);
 -
 -      dl = cu->disp.first;
 -      while (dl) {
 -              tot = ELEM(dl->type, DL_INDEX3, DL_INDEX4) ? dl->nr : dl->nr * dl->parts;
 +      if (!r_loc) r_loc = mloc;
 +      if (!r_size) r_size = msize;
  
 -              if (tot) do_it = TRUE;
 -              fp = dl->verts;
 -              while (tot--) {
 -                      minmax_v3v3_v3(min, max, fp);
 -                      fp += 3;
 -              }
 -              dl = dl->next;
 -      }
 -
 -      if (do_it == FALSE) {
 +      INIT_MINMAX(min, max);
 +      /* TODO(sergey): makecode aware of radius and bevel somehow.. */
 +      if (!BKE_curve_minmax(cu, true, min, max)) {
                min[0] = min[1] = min[2] = -1.0f;
                max[0] = max[1] = max[2] = 1.0f;
        }
  
 +      mid_v3_v3v3(r_loc, min, max);
 +
 +      r_size[0] = (max[0] - min[0]) / 2.0f;
 +      r_size[1] = (max[1] - min[1]) / 2.0f;
 +      r_size[2] = (max[2] - min[2]) / 2.0f;
 +
        BKE_boundbox_init_from_minmax(bb, min, max);
  
 -      if (cu->texflag & CU_AUTOSPACE) {
 -              mid_v3_v3v3(cu->loc, min, max);
 -              cu->size[0] = (max[0] - min[0]) / 2.0f;
 -              cu->size[1] = (max[1] - min[1]) / 2.0f;
 -              cu->size[2] = (max[2] - min[2]) / 2.0f;
 +      bb->flag &= ~BOUNDBOX_INVALID;
 +}
  
 -              zero_v3(cu->rot);
 +BoundBox *BKE_curve_boundbox_get(Object *ob)
 +{
 +      Curve *cu = ob->data;
  
 -              if (cu->size[0] == 0.0f) cu->size[0] = 1.0f;
 -              else if (cu->size[0] > 0.0f && cu->size[0] < 0.00001f) cu->size[0] = 0.00001f;
 -              else if (cu->size[0] < 0.0f && cu->size[0] > -0.00001f) cu->size[0] = -0.00001f;
 +      if (ob->bb)
 +              return ob->bb;
  
 -              if (cu->size[1] == 0.0f) cu->size[1] = 1.0f;
 -              else if (cu->size[1] > 0.0f && cu->size[1] < 0.00001f) cu->size[1] = 0.00001f;
 -              else if (cu->size[1] < 0.0f && cu->size[1] > -0.00001f) cu->size[1] = -0.00001f;
 +      if (cu->bb == NULL || (cu->bb->flag & BOUNDBOX_INVALID)) {
 +              BKE_curve_texspace_calc(cu);
 +      }
 +
 +      return cu->bb;
 +}
  
 -              if (cu->size[2] == 0.0f) cu->size[2] = 1.0f;
 -              else if (cu->size[2] > 0.0f && cu->size[2] < 0.00001f) cu->size[2] = 0.00001f;
 -              else if (cu->size[2] < 0.0f && cu->size[2] > -0.00001f) cu->size[2] = -0.00001f;
 +void BKE_curve_texspace_calc(Curve *cu)
 +{
 +      float loc[3], size[3];
 +      int a;
  
 +      BKE_curve_boundbox_calc(cu, loc, size);
 +
 +      if (cu->texflag & CU_AUTOSPACE) {
 +              for (a = 0; a < 3; a++) {
 +                      if (size[a] == 0.0f) size[a] = 1.0f;
 +                      else if (size[a] > 0.0f && size[a] < 0.00001f) size[a] = 0.00001f;
 +                      else if (size[a] < 0.0f && size[a] > -0.00001f) size[a] = -0.00001f;
 +              }
 +
 +              copy_v3_v3(cu->loc, loc);
 +              copy_v3_v3(cu->size, size);
 +              zero_v3(cu->rot);
 +      }
 +}
 +
 +void BKE_curve_texspace_get(Curve *cu, float r_loc[3], float r_rot[3], float r_size[3])
 +{
 +      if (cu->bb == NULL || (cu->bb->flag & BOUNDBOX_INVALID)) {
 +              BKE_curve_texspace_calc(cu);
        }
 +
 +      if (r_loc) copy_v3_v3(r_loc,  cu->loc);
 +      if (r_rot) copy_v3_v3(r_rot,  cu->rot);
 +      if (r_size) copy_v3_v3(r_size, cu->size);
  }
  
  int BKE_nurbList_index_get_co(ListBase *nurb, const int index, float r_co[3])
@@@ -625,34 -614,18 +625,34 @@@ void BKE_nurb_test2D(Nurb *nu
        }
  }
  
 -void BKE_nurb_minmax(Nurb *nu, float min[3], float max[3])
 +/* if use_radius is truth, minmax will take points' radius into account,
 + * which will make boundbox closer to bevelled curve.
 + */
 +void BKE_nurb_minmax(Nurb *nu, bool use_radius, float min[3], float max[3])
  {
        BezTriple *bezt;
        BPoint *bp;
        int a;
 +      float point[3];
  
        if (nu->type == CU_BEZIER) {
                a = nu->pntsu;
                bezt = nu->bezt;
                while (a--) {
 +                      if (use_radius) {
 +                              float radius_vector[3];
 +                              radius_vector[0] = radius_vector[1] = radius_vector[2] = bezt->radius;
 +
 +                              add_v3_v3v3(point, bezt->vec[1], radius_vector);
 +                              minmax_v3v3_v3(min, max, point);
 +
 +                              sub_v3_v3v3(point, bezt->vec[1], radius_vector);
 +                              minmax_v3v3_v3(min, max, point);
 +                      }
 +                      else {
 +                              minmax_v3v3_v3(min, max, bezt->vec[1]);
 +                      }
                        minmax_v3v3_v3(min, max, bezt->vec[0]);
 -                      minmax_v3v3_v3(min, max, bezt->vec[1]);
                        minmax_v3v3_v3(min, max, bezt->vec[2]);
                        bezt++;
                }
                a = nu->pntsu * nu->pntsv;
                bp = nu->bp;
                while (a--) {
 -                      minmax_v3v3_v3(min, max, bp->vec);
 +                      if (nu->pntsv == 1 && use_radius) {
 +                              float radius_vector[3];
 +                              radius_vector[0] = radius_vector[1] = radius_vector[2] = bp->radius;
 +
 +                              add_v3_v3v3(point, bp->vec, radius_vector);
 +                              minmax_v3v3_v3(min, max, point);
 +
 +                              sub_v3_v3v3(point, bp->vec, radius_vector);
 +                              minmax_v3v3_v3(min, max, point);
 +                      }
 +                      else {
 +                              /* Surfaces doesn't use bevel, so no need to take radius into account. */
 +                              minmax_v3v3_v3(min, max, bp->vec);
 +                      }
                        bp++;
                }
        }
@@@ -1489,10 -1449,10 +1489,10 @@@ void BKE_curve_bevel_make(Scene *scene
                                dl = bevdisp.first;
                        }
                        else {
 -                              dl = cu->bevobj->disp.first;
 +                              dl = cu->bevobj->curve_cache ? cu->bevobj->curve_cache->disp.first : NULL;
                                if (dl == NULL) {
                                        BKE_displist_make_curveTypes(scene, cu->bevobj, 0);
 -                                      dl = cu->bevobj->disp.first;
 +                                      dl = cu->bevobj->curve_cache->disp.first;
                                }
                        }
  
@@@ -2309,7 -2269,7 +2309,7 @@@ static void make_bevel_list_2D(BevList 
        }
  }
  
 -void BKE_curve_bevelList_make(Object *ob)
 +void BKE_curve_bevelList_make(Object *ob, ListBase *nurbs, bool for_render)
  {
        /*
         * - convert all curves to polys, with indication of resol and flags for double-vertices
        int a, b, nr, poly, resolu = 0, len = 0;
        int do_tilt, do_radius, do_weight;
        int is_editmode = 0;
 +      ListBase *bev;
  
        /* this function needs an object, because of tflag and upflag */
        cu = ob->data;
  
 +      bev = &ob->curve_cache->bev;
 +
        /* do we need to calculate the radius for each point? */
        /* do_radius = (cu->bevobj || cu->taperobj || (cu->flag & CU_FRONT) || (cu->flag & CU_BACK)) ? 0 : 1; */
  
        /* STEP 1: MAKE POLYS  */
  
 -      BLI_freelistN(&(cu->bev));
 +      BLI_freelistN(&(ob->curve_cache->bev));
 +      nu = nurbs->first;
        if (cu->editnurb && ob->type != OB_FONT) {
 -              ListBase *nurbs = BKE_curve_editNurbs_get(cu);
 -              nu = nurbs->first;
                is_editmode = 1;
        }
 -      else {
 -              nu = cu->nurb.first;
 -      }
  
        for (; nu; nu = nu->next) {
                
                 * enforced in the UI but can go wrong possibly */
                if (!BKE_nurb_check_valid_u(nu)) {
                        bl = MEM_callocN(sizeof(BevList) + 1 * sizeof(BevPoint), "makeBevelList1");
 -                      BLI_addtail(&(cu->bev), bl);
 +                      BLI_addtail(bev, bl);
                        bl->nr = 0;
+                       bl->charidx = nu->charidx;
                }
                else {
 -                      if (G.is_rendering && cu->resolu_ren != 0)
 +                      if (for_render && cu->resolu_ren != 0)
                                resolu = cu->resolu_ren;
                        else
                                resolu = nu->resolu;
                        if (nu->type == CU_POLY) {
                                len = nu->pntsu;
                                bl = MEM_callocN(sizeof(BevList) + len * sizeof(BevPoint), "makeBevelList2");
 -                              BLI_addtail(&(cu->bev), bl);
 +                              BLI_addtail(bev, bl);
  
-                               if (nu->flagu & CU_NURB_CYCLIC) bl->poly = 0;
-                               else bl->poly = -1;
+                               bl->poly = (nu->flagu & CU_NURB_CYCLIC) ? 0 : -1;
                                bl->nr = len;
                                bl->dupe_nr = 0;
+                               bl->charidx = nu->charidx;
                                bevp = (BevPoint *)(bl + 1);
                                bp = nu->bp;
  
                                /* in case last point is not cyclic */
                                len = resolu * (nu->pntsu + (nu->flagu & CU_NURB_CYCLIC) - 1) + 1;
                                bl = MEM_callocN(sizeof(BevList) + len * sizeof(BevPoint), "makeBevelBPoints");
 -                              BLI_addtail(&(cu->bev), bl);
 +                              BLI_addtail(bev, bl);
  
-                               if (nu->flagu & CU_NURB_CYCLIC) bl->poly = 0;
-                               else bl->poly = -1;
+                               bl->poly = (nu->flagu & CU_NURB_CYCLIC) ? 0 : -1;
+                               bl->charidx = nu->charidx;
                                bevp = (BevPoint *)(bl + 1);
  
                                a = nu->pntsu - 1;
                                        len = (resolu * SEGMENTSU(nu));
  
                                        bl = MEM_callocN(sizeof(BevList) + len * sizeof(BevPoint), "makeBevelList3");
 -                                      BLI_addtail(&(cu->bev), bl);
 +                                      BLI_addtail(bev, bl);
                                        bl->nr = len;
                                        bl->dupe_nr = 0;
-                                       if (nu->flagu & CU_NURB_CYCLIC) bl->poly = 0;
-                                       else bl->poly = -1;
+                                       bl->poly = (nu->flagu & CU_NURB_CYCLIC) ? 0 : -1;
+                                       bl->charidx = nu->charidx;
                                        bevp = (BevPoint *)(bl + 1);
  
                                        BKE_nurb_makeCurve(nu, &bevp->vec[0],
        }
  
        /* STEP 2: DOUBLE POINTS AND AUTOMATIC RESOLUTION, REDUCE DATABLOCKS */
 -      bl = cu->bev.first;
 +      bl = bev->first;
        while (bl) {
                if (bl->nr) { /* null bevel items come from single points */
                        nr = bl->nr;
                }
                bl = bl->next;
        }
 -      bl = cu->bev.first;
 +      bl = bev->first;
        while (bl) {
                blnext = bl->next;
                if (bl->nr && bl->dupe_nr) {
                        blnew = MEM_mallocN(sizeof(BevList) + nr * sizeof(BevPoint), "makeBevelList4");
                        memcpy(blnew, bl, sizeof(BevList));
                        blnew->nr = 0;
 -                      BLI_remlink(&(cu->bev), bl);
 -                      BLI_insertlinkbefore(&(cu->bev), blnext, blnew);    /* to make sure bevlijst is tuned with nurblist */
 +                      BLI_remlink(bev, bl);
 +                      BLI_insertlinkbefore(bev, blnext, blnew);    /* to make sure bevlijst is tuned with nurblist */
                        bevp0 = (BevPoint *)(bl + 1);
                        bevp1 = (BevPoint *)(blnew + 1);
                        nr = bl->nr;
        }
  
        /* STEP 3: POLYS COUNT AND AUTOHOLE */
 -      bl = cu->bev.first;
 +      bl = bev->first;
        poly = 0;
        while (bl) {
                if (bl->nr && bl->poly >= 0) {
        /* find extreme left points, also test (turning) direction */
        if (poly > 0) {
                sd = sortdata = MEM_mallocN(sizeof(struct bevelsort) * poly, "makeBevelList5");
 -              bl = cu->bev.first;
 +              bl = bev->first;
                while (bl) {
                        if (bl->poly > 0) {
  
                        bl = sd->bl;     /* is bl a hole? */
                        sd1 = sortdata + (a - 1);
                        for (b = a - 1; b >= 0; b--, sd1--) { /* all polys to the left */
-                               if (bevelinside(sd1->bl, bl)) {
-                                       bl->hole = 1 - sd1->bl->hole;
-                                       break;
+                               if (sd1->bl->charidx == bl->charidx) { /* for text, only check matching char */
+                                       if (bevelinside(sd1->bl, bl)) {
+                                               bl->hole = 1 - sd1->bl->hole;
+                                               break;
+                                       }
                                }
                        }
                }
        /* STEP 4: 2D-COSINES or 3D ORIENTATION */
        if ((cu->flag & CU_3D) == 0) {
                /* 2D Curves */
 -              for (bl = cu->bev.first; bl; bl = bl->next) {
 +              for (bl = bev->first; bl; bl = bl->next) {
                        if (bl->nr < 2) {
                                /* do nothing */
                        }
        }
        else {
                /* 3D Curves */
 -              for (bl = cu->bev.first; bl; bl = bl->next) {
 +              for (bl = bev->first; bl; bl = bl->next) {
                        if (bl->nr < 2) {
                                /* do nothing */
                        }
@@@ -3244,7 -3208,7 +3247,7 @@@ void BKE_nurb_direction_switch(Nurb *nu
  }
  
  
 -float (*BKE_curve_vertexCos_get(Curve *UNUSED(cu), ListBase *lb, int *numVerts_r))[3]
 +float (*BKE_curve_nurbs_vertexCos_get(ListBase *lb, int *numVerts_r))[3]
  {
        int i, numVerts = *numVerts_r = BKE_nurbList_verts_count(lb);
        float *co, (*cos)[3] = MEM_mallocN(sizeof(*cos) * numVerts, "cu_vcos");
        return cos;
  }
  
 -void BK_curve_vertexCos_apply(Curve *UNUSED(cu), ListBase *lb, float (*vertexCos)[3])
 +void BK_curve_nurbs_vertexCos_apply(ListBase *lb, float (*vertexCos)[3])
  {
        float *co = vertexCos[0];
        Nurb *nu;
        }
  }
  
 -float (*BKE_curve_keyVertexCos_get(Curve *UNUSED(cu), ListBase *lb, float *key))[3]
 +float (*BKE_curve_nurbs_keyVertexCos_get(ListBase *lb, float *key))[3]
  {
        int i, numVerts = BKE_nurbList_verts_count(lb);
        float *co, (*cos)[3] = MEM_mallocN(sizeof(*cos) * numVerts, "cu_vcos");
        return cos;
  }
  
 -void BKE_curve_keyVertexTilts_apply(Curve *UNUSED(cu), ListBase *lb, float *key)
 +void BKE_curve_nurbs_keyVertexTilts_apply(ListBase *lb, float *key)
  {
        Nurb *nu;
        int i;
@@@ -3583,13 -3547,13 +3586,13 @@@ ListBase *BKE_curve_nurbs_get(Curve *cu
  
  
  /* basic vertex data functions */
 -bool BKE_curve_minmax(Curve *cu, float min[3], float max[3])
 +bool BKE_curve_minmax(Curve *cu, bool use_radius, float min[3], float max[3])
  {
        ListBase *nurb_lb = BKE_curve_nurbs_get(cu);
        Nurb *nu;
  
        for (nu = nurb_lb->first; nu; nu = nu->next)
 -              BKE_nurb_minmax(nu, min, max);
 +              BKE_nurb_minmax(nu, use_radius, min, max);
  
        return (nurb_lb->first != NULL);
  }
@@@ -3636,7 -3600,7 +3639,7 @@@ bool BKE_curve_center_bounds(Curve *cu
  {
        float min[3], max[3];
        INIT_MINMAX(min, max);
 -      if (BKE_curve_minmax(cu, min, max)) {
 +      if (BKE_curve_minmax(cu, false, min, max)) {
                mid_v3_v3v3(cent, min, max);
                return true;
        }
index 38cbd95b61fba138cf0bf6baf9530757b10241cb,7ff8667f90eb5b58caa7a972decbc841a6d01cd5..1c99f9ac827bb5c9de742dc988ce5aa476a22a6c
@@@ -75,6 -75,7 +75,7 @@@ typedef struct BevList 
        struct BevList *next, *prev;
        int nr, dupe_nr;
        int poly, hole;
+       int charidx;
  } BevList;
  
  /* These two Lines with # tell makesdna this struct can be excluded. */
@@@ -177,14 -178,18 +178,14 @@@ typedef struct Curve 
        struct BoundBox *bb;
        
        ListBase nurb;          /* actual data, called splines in rna */
 -      ListBase disp;          /* undeformed display list, used mostly for texture space calculation */
        
        EditNurb *editnurb;     /* edited data, not in file, use pointer so we can check for it */
        
        struct Object *bevobj, *taperobj, *textoncurve;
        struct Ipo *ipo    DNA_DEPRECATED;  /* old animation system, deprecated for 2.5 */
 -      Path *path;
        struct Key *key;
        struct Material **mat;
        
 -      ListBase bev;
 -      
        /* texture space, copied as one block in editobject.c */
        float loc[3];
        float size[3];