svn merge ^/trunk/blender -r43160:43183
authorCampbell Barton <ideasman42@gmail.com>
Thu, 5 Jan 2012 22:30:08 +0000 (22:30 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Thu, 5 Jan 2012 22:30:08 +0000 (22:30 +0000)
1  2 
source/blender/blenkernel/intern/mesh.c

@@@ -1661,125 -1248,9 +1661,122 @@@ void mesh_set_smooth_flag(Object *meshO
                        mf->flag &= ~ME_SMOOTH;
                }
        }
-       mesh_calc_normals(me->mvert, me->totvert, me->mloop, me->mpoly, me->totloop, 
-                                         me->totpoly, NULL, NULL, 0, NULL, NULL);
  }
  
 -void mesh_calc_normals(MVert *mverts, int numVerts, MFace *mfaces, int numFaces, float (*faceNors_r)[3]) 
 +void mesh_calc_normals(MVert *mverts, int numVerts, MLoop *mloop, MPoly *mpolys,
 +              int numLoops, int numPolys, float (*polyNors_r)[3], MFace *mfaces, int numFaces,
 +              int *origIndexFace, float (*faceNors_r)[3])
 +{
 +      mesh_calc_normals_ex(mverts, numVerts, mloop, mpolys,
 +                        numLoops, numPolys, polyNors_r, mfaces, numFaces,
 +                        origIndexFace, faceNors_r, TRUE);
 +}
 +void mesh_calc_normals_ex(MVert *mverts, int numVerts, MLoop *mloop, MPoly *mpolys,
 +              int UNUSED(numLoops), int numPolys, float (*polyNors_r)[3], MFace *mfaces, int numFaces,
 +              int *origIndexFace, float (*faceNors_r)[3],
 +              const short only_face_normals)
 +{
 +      float (*pnors)[3] = polyNors_r, (*fnors)[3] = faceNors_r;
 +      int i, j;
 +      MFace *mf;
 +      MPoly *mp;
 +      MLoop *ml;
 +
 +      if (numPolys == 0) {
 +              return;
 +      }
 +
 +      /* if we are not calculating verts and no verts were passes thene we have nothign to do */
 +      if ((only_face_normals == TRUE) && (polyNors_r == NULL) && (faceNors_r == NULL)) {
 +              printf("%s: called with nothing to do\n", __func__);
 +              return;
 +      }
 +
 +      if (!pnors) pnors = MEM_callocN(sizeof(float) * 3 * numPolys, "poly_nors mesh.c");
 +      /* if (!fnors) fnors = MEM_callocN(sizeof(float) * 3 * numFaces, "face nors mesh.c"); */ /* NO NEED TO ALLOC YET */
 +
 +
 +      if (only_face_normals == FALSE) {
 +              /* vertex normals are optional, they require some extra calculations,
 +               * so make them optional */
 +
 +              float (*tnorms)[3], (*edgevecbuf)[3]= NULL;
 +              float **vertcos = NULL, **vertnos = NULL;
 +              BLI_array_declare(vertcos);
 +              BLI_array_declare(vertnos);
 +              BLI_array_declare(edgevecbuf);
 +
 +              /*first go through and calculate normals for all the polys*/
 +              tnorms = MEM_callocN(sizeof(float)*3*numVerts, "tnorms mesh.c");
 +
 +              mp = mpolys;
 +              for (i=0; i<numPolys; i++, mp++) {
 +                      mesh_calc_poly_normal(mp, mloop+mp->loopstart, mverts, pnors[i]);
 +                      ml = mloop + mp->loopstart;
 +
 +                      BLI_array_empty(vertcos);
 +                      BLI_array_empty(vertnos);
 +                      for (j=0; j<mp->totloop; j++) {
 +                              int vindex = ml[j].v;
 +                              BLI_array_append(vertcos, mverts[vindex].co);
 +                              BLI_array_append(vertnos, tnorms[vindex]);
 +                      }
 +
 +                      BLI_array_empty(edgevecbuf);
 +                      BLI_array_growitems(edgevecbuf, mp->totloop);
 +
 +                      accumulate_vertex_normals_poly(vertnos, pnors[i], vertcos, edgevecbuf, mp->totloop);
 +              }
 +
 +              BLI_array_free(vertcos);
 +              BLI_array_free(vertnos);
 +              BLI_array_free(edgevecbuf);
 +
 +              /* following Mesh convention; we use vertex coordinate itself for normal in this case */
 +              for(i=0; i<numVerts; i++) {
 +                      MVert *mv= &mverts[i];
 +                      float *no= tnorms[i];
 +
 +                      if(normalize_v3(no) == 0.0f)
 +                              normalize_v3_v3(no, mv->co);
 +
 +                      normal_float_to_short_v3(mv->no, no);
 +              }
 +
 +              MEM_freeN(tnorms);
 +      }
 +      else {
 +              /* only calc poly normals */
 +              mp = mpolys;
 +              for (i=0; i<numPolys; i++, mp++) {
 +                      mesh_calc_poly_normal(mp, mloop+mp->loopstart, mverts, pnors[i]);
 +              }
 +      }
 +
 +      if ( origIndexFace &&
 +           /* fnors==faceNors_r */ /* NO NEED TO ALLOC YET */
 +           fnors != NULL &&
 +           numFaces)
 +      {
 +              mf = mfaces;
 +              for (i=0; i<numFaces; i++, mf++, origIndexFace++) {
 +                      if (*origIndexFace < numPolys) {
 +                              copy_v3_v3(fnors[i], pnors[*origIndexFace]);
 +                      } else {
 +                              /*eek, we're not corrusponding to polys*/
 +                              printf("error in mesh_calc_normals; tesselation face indices are incorrect.  normals may look bad.\n");
 +                      }
 +              }
 +      }
 +
 +      if (pnors != polyNors_r) MEM_freeN(pnors);
 +      /* if (fnors != faceNors_r) MEM_freeN(fnors); */ /* NO NEED TO ALLOC YET */
 +
 +      fnors = pnors = NULL;
 +      
 +}
 +
 +void mesh_calc_tessface_normals(MVert *mverts, int numVerts, MFace *mfaces, int numFaces, float (*faceNors_r)[3]) 
  {
        float (*tnorms)[3]= MEM_callocN(numVerts*sizeof(*tnorms), "tnorms");
        float (*fnors)[3]= (faceNors_r)? faceNors_r: MEM_callocN(sizeof(*fnors)*numFaces, "meshnormals");