Fix #20362: multires conversion from 2.5alpha0 not working. It's still not
[blender.git] / source / blender / blenkernel / intern / multires.c
1 /*
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software  Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) 2007 by Nicholas Bishop
21  * All rights reserved.
22  *
23  * The Original Code is: all of this file.
24  *
25  * Contributor(s): none yet.
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  */
29
30 #include "MEM_guardedalloc.h"
31
32 #include "DNA_key_types.h"
33 #include "DNA_mesh_types.h"
34 #include "DNA_meshdata_types.h"
35 #include "DNA_modifier_types.h"
36 #include "DNA_object_types.h"
37 #include "DNA_scene_types.h"
38 #include "DNA_view3d_types.h"
39
40 #include "BLI_math.h"
41 #include "BLI_blenlib.h"
42 #include "BLI_pbvh.h"
43
44 #include "BKE_cdderivedmesh.h"
45 #include "BKE_customdata.h"
46 #include "BKE_depsgraph.h"
47 #include "BKE_DerivedMesh.h"
48 #include "BKE_global.h"
49 #include "BKE_mesh.h"
50 #include "BKE_modifier.h"
51 #include "BKE_multires.h"
52 #include "BKE_object.h"
53 #include "BKE_subsurf.h"
54 #include "BKE_utildefines.h"
55
56 #include "CCGSubSurf.h"
57
58 #include <math.h>
59 #include <string.h>
60
61 /* MULTIRES MODIFIER */
62 static const int multires_max_levels = 13;
63 static const int multires_grid_tot[] = {0, 4, 9, 25, 81, 289, 1089, 4225, 16641, 66049, 263169, 1050625, 4198401, 16785409};
64 static const int multires_side_tot[] = {0, 2, 3, 5,  9,  17,  33,   65,   129,   257,   513,    1025,    2049,    4097};
65
66 static void multiresModifier_disp_run(DerivedMesh *dm, Mesh *me, int invert, int add, DMGridData **oldGridData, int totlvl);
67
68 MultiresModifierData *find_multires_modifier(Object *ob)
69 {
70         ModifierData *md;
71         MultiresModifierData *mmd = NULL;
72
73         for(md = ob->modifiers.first; md; md = md->next) {
74                 if(md->type == eModifierType_Multires) {
75                         mmd = (MultiresModifierData*)md;
76                         break;
77                 }
78         }
79
80         return mmd;
81 }
82
83 static int multires_get_level(Object *ob, MultiresModifierData *mmd, int render)
84 {
85         if(render)
86                 return mmd->renderlvl;
87         else if(ob->mode == OB_MODE_SCULPT)
88                 return mmd->sculptlvl;
89         else
90                 return mmd->lvl;
91 }
92
93 static void multires_set_tot_level(Object *ob, MultiresModifierData *mmd, int lvl)
94 {
95         mmd->totlvl = lvl;
96
97         if(ob->mode != OB_MODE_SCULPT) {
98                 mmd->lvl = MAX2(mmd->lvl, lvl);
99                 CLAMP(mmd->lvl, 0, mmd->totlvl);
100         }
101
102         mmd->sculptlvl = MAX2(mmd->sculptlvl, lvl);
103         CLAMP(mmd->sculptlvl, 0, mmd->totlvl);
104
105         mmd->renderlvl = MAX2(mmd->renderlvl, lvl);
106         CLAMP(mmd->renderlvl, 0, mmd->totlvl);
107 }
108
109 /* XXX */
110 #if 0
111 void multiresModifier_join(Object *ob)
112 {
113         Base *base = NULL;
114         int highest_lvl = 0;
115
116         /* First find the highest level of subdivision */
117         base = FIRSTBASE;
118         while(base) {
119                 if(TESTBASELIB_BGMODE(v3d, scene, base) && base->object->type==OB_MESH) {
120                         ModifierData *md;
121                         for(md = base->object->modifiers.first; md; md = md->next) {
122                                 if(md->type == eModifierType_Multires) {
123                                         int totlvl = ((MultiresModifierData*)md)->totlvl;
124                                         if(totlvl > highest_lvl)
125                                                 highest_lvl = totlvl;
126
127                                         /* Ensure that all updates are processed */
128                                         multires_force_update(base->object);
129                                 }
130                         }
131                 }
132                 base = base->next;
133         }
134
135         /* No multires meshes selected */
136         if(highest_lvl == 0)
137                 return;
138
139         /* Subdivide all the displacements to the highest level */
140         base = FIRSTBASE;
141         while(base) {
142                 if(TESTBASELIB_BGMODE(v3d, scene, base) && base->object->type==OB_MESH) {
143                         ModifierData *md = NULL;
144                         MultiresModifierData *mmd = NULL;
145
146                         for(md = base->object->modifiers.first; md; md = md->next) {
147                                 if(md->type == eModifierType_Multires)
148                                         mmd = (MultiresModifierData*)md;
149                         }
150
151                         /* If the object didn't have multires enabled, give it a new modifier */
152                         if(!mmd) {
153                                 md = base->object->modifiers.first;
154                                 
155                                 while(md && modifierType_getInfo(md->type)->type == eModifierTypeType_OnlyDeform)
156                                         md = md->next;
157                                 
158                                 mmd = (MultiresModifierData*)modifier_new(eModifierType_Multires);
159                                 BLI_insertlinkbefore(&base->object->modifiers, md, mmd);
160                                 modifier_unique_name(&base->object->modifiers, mmd);
161                         }
162
163                         if(mmd)
164                                 multiresModifier_subdivide(mmd, base->object, highest_lvl - mmd->totlvl, 0, 0);
165                 }
166                 base = base->next;
167         }
168 }
169 #endif
170
171 /* Returns 0 on success, 1 if the src's totvert doesn't match */
172 int multiresModifier_reshape(MultiresModifierData *mmd, Object *dst, Object *src)
173 {
174         /* XXX */
175 #if 0
176         Mesh *src_me = get_mesh(src);
177         DerivedMesh *mrdm = dst->derivedFinal;
178
179         if(mrdm && mrdm->getNumVerts(mrdm) == src_me->totvert) {
180                 MVert *mvert = CDDM_get_verts(mrdm);
181                 int i;
182
183                 for(i = 0; i < src_me->totvert; ++i)
184                         copy_v3_v3(mvert[i].co, src_me->mvert[i].co);
185                 mrdm->needsFree = 1;
186                 MultiresDM_mark_as_modified(mrdm);
187                 mrdm->release(mrdm);
188                 dst->derivedFinal = NULL;
189
190                 return 0;
191         }
192 #endif
193
194         return 1;
195 }
196
197 static void column_vectors_to_mat3(float mat[][3], float v1[3], float v2[3], float v3[3])
198 {
199         copy_v3_v3(mat[0], v1);
200         copy_v3_v3(mat[1], v2);
201         copy_v3_v3(mat[2], v3);
202 }
203
204 static void multires_copy_grid(float (*gridA)[3], float (*gridB)[3], int sizeA, int sizeB)
205 {
206         int x, y, j, skip;
207
208         if(sizeA > sizeB) {
209                 skip = (sizeA-1)/(sizeB-1);
210
211                 for(j = 0, y = 0; y < sizeB; y++)
212                         for(x = 0; x < sizeB; x++, j++)
213                                 copy_v3_v3(gridA[y*skip*sizeA + x*skip], gridB[j]);
214         }
215         else {
216                 skip = (sizeB-1)/(sizeA-1);
217
218                 for(j = 0, y = 0; y < sizeA; y++)
219                         for(x = 0; x < sizeA; x++, j++)
220                                 copy_v3_v3(gridA[j], gridB[y*skip*sizeB + x*skip]);
221         }
222 }
223
224 static void multires_copy_dm_grid(DMGridData *gridA, DMGridData *gridB, int sizeA, int sizeB)
225 {
226         int x, y, j, skip;
227
228         if(sizeA > sizeB) {
229                 skip = (sizeA-1)/(sizeB-1);
230
231                 for(j = 0, y = 0; y < sizeB; y++)
232                         for(x = 0; x < sizeB; x++, j++)
233                                 copy_v3_v3(gridA[y*skip*sizeA + x*skip].co, gridB[j].co);
234         }
235         else {
236                 skip = (sizeB-1)/(sizeA-1);
237
238                 for(j = 0, y = 0; y < sizeA; y++)
239                         for(x = 0; x < sizeA; x++, j++)
240                                 copy_v3_v3(gridA[j].co, gridB[y*skip*sizeB + x*skip].co);
241         }
242 }
243
244 /* direction=1 for delete higher, direction=0 for lower (not implemented yet) */
245 void multiresModifier_del_levels(struct MultiresModifierData *mmd, struct Object *ob, int direction)
246 {
247         Mesh *me = get_mesh(ob);
248         int lvl = multires_get_level(ob, mmd, 0);
249         int levels = mmd->totlvl - lvl;
250         MDisps *mdisps;
251
252         CustomData_external_read(&me->fdata, &me->id, CD_MASK_MDISPS, me->totface);
253         mdisps= CustomData_get_layer(&me->fdata, CD_MDISPS);
254
255         multires_force_update(ob);
256
257         if(mdisps && levels > 0 && direction == 1) {
258                 if(lvl > 0) {
259                         int nsize = multires_side_tot[lvl];
260                         int hsize = multires_side_tot[mmd->totlvl];
261                         int i;
262
263                         for(i = 0; i < me->totface; ++i) {
264                                 MDisps *mdisp= &mdisps[i];
265                                 float (*disps)[3], (*ndisps)[3], (*hdisps)[3];
266                                 int nvert = (me->mface[i].v4)? 4: 3;
267                                 int totdisp = multires_grid_tot[lvl]*nvert;
268                                 int S;
269
270                                 disps = MEM_callocN(sizeof(float) * 3 * totdisp, "multires disps");
271
272                                 ndisps = disps;
273                                 hdisps = mdisp->disps;
274
275                                 for(S = 0; S < nvert; S++) {
276                                         multires_copy_grid(ndisps, hdisps, nsize, hsize);
277
278                                         ndisps += nsize*nsize;
279                                         hdisps += hsize*hsize;
280                                 }
281
282                                 MEM_freeN(mdisp->disps);
283                                 mdisp->disps = disps;
284                                 mdisp->totdisp = totdisp;
285                         }
286                 }
287                 else {
288                         CustomData_external_remove(&me->fdata, &me->id, CD_MDISPS, me->totface);
289                         CustomData_free_layer_active(&me->fdata, CD_MDISPS, me->totface);
290                 }
291         }
292
293         multires_set_tot_level(ob, mmd, lvl);
294 }
295
296 static DerivedMesh *multires_dm_create_local(Object *ob, DerivedMesh *dm, int lvl, int totlvl, int simple)
297 {
298         MultiresModifierData mmd;
299
300         memset(&mmd, 0, sizeof(MultiresModifierData));
301         mmd.lvl = lvl;
302         mmd.sculptlvl = lvl;
303         mmd.renderlvl = lvl;
304         mmd.totlvl = totlvl;
305         mmd.simple = simple;
306
307         return multires_dm_create_from_derived(&mmd, 1, dm, ob, 0, 0);
308 }
309
310 static DerivedMesh *subsurf_dm_create_local(Object *ob, DerivedMesh *dm, int lvl, int simple, int optimal)
311 {
312         SubsurfModifierData smd;
313
314         memset(&smd, 0, sizeof(SubsurfModifierData));
315         smd.levels = smd.renderLevels = lvl;
316         smd.flags |= eSubsurfModifierFlag_SubsurfUv;
317         if(simple)
318                 smd.subdivType = ME_SIMPLE_SUBSURF;
319         if(optimal)
320                 smd.flags |= eSubsurfModifierFlag_ControlEdges;
321
322         return subsurf_make_derived_from_derived(dm, &smd, 0, NULL, 0, 0);
323 }
324
325 static void multires_reallocate_mdisps(Mesh *me, MDisps *mdisps, int lvl)
326 {
327         int i;
328
329         /* reallocate displacements to be filled in */
330         for(i = 0; i < me->totface; ++i) {
331                 int nvert = (me->mface[i].v4)? 4: 3;
332                 int totdisp = multires_grid_tot[lvl]*nvert;
333                 float (*disps)[3] = MEM_callocN(sizeof(float) * 3 * totdisp, "multires disps");
334
335                 if(mdisps[i].disps)
336                         MEM_freeN(mdisps[i].disps);
337
338                 mdisps[i].disps = disps;
339                 mdisps[i].totdisp = totdisp;
340         }
341 }
342
343 void multiresModifier_subdivide(MultiresModifierData *mmd, Object *ob, int updateblock, int simple)
344 {
345         Mesh *me = ob->data;
346         MDisps *mdisps;
347         int lvl= mmd->totlvl;
348         int totlvl= mmd->totlvl+1;
349
350         if(totlvl > multires_max_levels)
351                 return;
352
353         multires_force_update(ob);
354
355         mdisps = CustomData_get_layer(&me->fdata, CD_MDISPS);
356         if(!mdisps)
357                 mdisps = CustomData_add_layer(&me->fdata, CD_MDISPS, CD_DEFAULT, NULL, me->totface);
358
359         if(mdisps->disps && !updateblock && totlvl > 1) {
360                 /* upsample */
361                 DerivedMesh *lowdm, *cddm, *highdm;
362                 DMGridData **highGridData, **lowGridData, **subGridData;
363                 CCGSubSurf *ss;
364                 int i, numGrids, highGridSize, lowGridSize;
365
366                 /* create subsurf DM from original mesh at high level */
367                 cddm = CDDM_from_mesh(me, NULL);
368                 highdm = subsurf_dm_create_local(ob, cddm, totlvl, simple, 0);
369
370                 /* create multires DM from original mesh at low level */
371                 lowdm = multires_dm_create_local(ob, cddm, lvl, lvl, simple);
372                 cddm->release(cddm);
373
374                 /* copy subsurf grids and replace them with low displaced grids */
375                 numGrids = highdm->getNumGrids(highdm);
376                 highGridSize = highdm->getGridSize(highdm);
377                 highGridData = highdm->getGridData(highdm);
378                 lowGridSize = lowdm->getGridSize(lowdm);
379                 lowGridData = lowdm->getGridData(lowdm);
380
381                 subGridData = MEM_callocN(sizeof(float*)*numGrids, "subGridData*");
382
383                 for(i = 0; i < numGrids; ++i) {
384                         /* backup subsurf grids */
385                         subGridData[i] = MEM_callocN(sizeof(DMGridData)*highGridSize*highGridSize, "subGridData");
386                         memcpy(subGridData[i], highGridData[i], sizeof(DMGridData)*highGridSize*highGridSize);
387
388                         /* overwrite with current displaced grids */
389                         multires_copy_dm_grid(highGridData[i], lowGridData[i], highGridSize, lowGridSize);
390                 }
391
392                 /* low lower level dm no longer needed at this point */
393                 lowdm->release(lowdm);
394
395                 /* subsurf higher levels again with displaced data */
396                 ss= ((CCGDerivedMesh*)highdm)->ss;
397                 ccgSubSurf_updateFromFaces(ss, lvl, NULL, 0);
398                 ccgSubSurf_updateLevels(ss, lvl, NULL, 0);
399
400                 /* reallocate displacements */
401                 multires_reallocate_mdisps(me, mdisps, totlvl); 
402
403                 /* compute displacements */
404                 multiresModifier_disp_run(highdm, me, 1, 0, subGridData, totlvl);
405
406                 /* free */
407                 highdm->release(highdm);
408                 for(i = 0; i < numGrids; ++i)
409                         MEM_freeN(subGridData[i]);
410                 MEM_freeN(subGridData);
411         }
412         else {
413                 /* only reallocate, nothing to upsample */
414                 multires_reallocate_mdisps(me, mdisps, totlvl); 
415         }
416
417         multires_set_tot_level(ob, mmd, totlvl);
418 }
419
420 static void grid_tangent(int gridSize, int index, int x, int y, int axis, DMGridData **gridData, float t[3])
421 {
422         if(axis == 0) {
423                 if(x == gridSize - 1) {
424                         if(y == gridSize - 1)
425                                 sub_v3_v3v3(t, gridData[index][x + gridSize*(y - 1)].co, gridData[index][x - 1 + gridSize*(y - 1)].co);
426                         else
427                                 sub_v3_v3v3(t, gridData[index][x + gridSize*y].co, gridData[index][x - 1 + gridSize*y].co);
428                 }
429                 else
430                         sub_v3_v3v3(t, gridData[index][x + 1 + gridSize*y].co, gridData[index][x + gridSize*y].co);
431         }
432         else if(axis == 1) {
433                 if(y == gridSize - 1) {
434                         if(x == gridSize - 1)
435                                 sub_v3_v3v3(t, gridData[index][x - 1 + gridSize*y].co, gridData[index][x - 1 + gridSize*(y - 1)].co);
436                         else
437                                 sub_v3_v3v3(t, gridData[index][x + gridSize*y].co, gridData[index][x + gridSize*(y - 1)].co);
438                 }
439                 else
440                         sub_v3_v3v3(t, gridData[index][x + gridSize*(y + 1)].co, gridData[index][x + gridSize*y].co);
441         }
442 }
443
444 static void multiresModifier_disp_run(DerivedMesh *dm, Mesh *me, int invert, int add, DMGridData **oldGridData, int totlvl)
445 {
446         CCGDerivedMesh *ccgdm = (CCGDerivedMesh*)dm;
447         DMGridData **gridData, **subGridData;
448         MFace *mface = me->mface;
449         MDisps *mdisps = CustomData_get_layer(&me->fdata, CD_MDISPS);
450         int *gridOffset;
451         int i, numGrids, gridSize, dGridSize, dSkip;
452
453         if(!mdisps) {
454                 if(invert)
455                         mdisps = CustomData_add_layer(&me->fdata, CD_MDISPS, CD_DEFAULT, NULL, me->totface);
456                 else
457                         return;
458         }
459
460         numGrids = dm->getNumGrids(dm);
461         gridSize = dm->getGridSize(dm);
462         gridData = dm->getGridData(dm);
463         gridOffset = dm->getGridOffset(dm);
464         subGridData = (oldGridData)? oldGridData: gridData;
465
466         dGridSize = multires_side_tot[totlvl];
467         dSkip = (dGridSize-1)/(gridSize-1);
468
469         #pragma omp parallel for private(i) schedule(static)
470         for(i = 0; i < me->totface; ++i) {
471                 const int numVerts = mface[i].v4 ? 4 : 3;
472                 MDisps *mdisp = &mdisps[i];
473                 int S, x, y, gIndex = gridOffset[i];
474
475                 /* when adding new faces in edit mode, need to allocate disps */
476                 if(!mdisp->disps)
477                 #pragma omp critical
478                 {
479                         multires_reallocate_mdisps(me, mdisps, totlvl);
480                 }
481
482                 for(S = 0; S < numVerts; ++S, ++gIndex) {
483                         DMGridData *grid = gridData[gIndex];
484                         DMGridData *subgrid = subGridData[gIndex];
485                         float (*dispgrid)[3] = &mdisp->disps[S*dGridSize*dGridSize];
486
487                         for(y = 0; y < gridSize; y++) {
488                                 for(x = 0; x < gridSize; x++) {
489                                         float *co = grid[x + y*gridSize].co;
490                                         float *sco = subgrid[x + y*gridSize].co;
491                                         float *no = subgrid[x + y*gridSize].no;
492                                         float *data = dispgrid[dGridSize*y*dSkip + x*dSkip];
493                                         float mat[3][3], tx[3], ty[3], disp[3], d[3];
494
495                                         /* construct tangent space matrix */
496                                         grid_tangent(gridSize, gIndex, x, y, 0, subGridData, tx);
497                                         normalize_v3(tx);
498
499                                         grid_tangent(gridSize, gIndex, x, y, 1, subGridData, ty);
500                                         normalize_v3(ty);
501
502                                         //mul_v3_fl(tx, 1.0f/(gridSize-1));
503                                         //mul_v3_fl(ty, 1.0f/(gridSize-1));
504                                         //cross_v3_v3v3(no, tx, ty);
505
506                                         column_vectors_to_mat3(mat, tx, ty, no);
507
508                                         if(!invert) {
509                                                 /* convert to object space and add */
510                                                 mul_v3_m3v3(disp, mat, data);
511                                                 add_v3_v3v3(co, sco, disp);
512                                         }
513                                         else if(!add) {
514                                                 /* convert difference to tangent space */
515                                                 sub_v3_v3v3(disp, co, sco);
516                                                 invert_m3(mat);
517                                                 mul_v3_m3v3(data, mat, disp);
518                                         }
519                                         else {
520                                                 /* convert difference to tangent space */
521                                                 invert_m3(mat);
522                                                 mul_v3_m3v3(d, mat, co);
523                                                 add_v3_v3(data, d);
524                                         }
525                                 }
526                         }
527                 }
528         }
529
530         if(!invert) {
531                 ccgSubSurf_stitchFaces(ccgdm->ss, 0, NULL, 0);
532                 ccgSubSurf_updateNormals(ccgdm->ss, NULL, 0);
533         }
534 }
535
536 static void multiresModifier_update(DerivedMesh *dm)
537 {
538         CCGDerivedMesh *ccgdm= (CCGDerivedMesh*)dm;
539         Object *ob;
540         Mesh *me;
541         MDisps *mdisps;
542         MultiresModifierData *mmd;
543
544         ob = ccgdm->multires.ob;
545         me = ccgdm->multires.ob->data;
546         mmd = ccgdm->multires.mmd;
547         CustomData_external_read(&me->fdata, &me->id, CD_MASK_MDISPS, me->totface);
548         mdisps = CustomData_get_layer(&me->fdata, CD_MDISPS);
549
550         if(mdisps) {
551                 int lvl = ccgdm->multires.lvl;
552                 int totlvl = ccgdm->multires.totlvl;
553                 
554                 if(lvl < totlvl) {
555                         Mesh *me = ob->data;
556                         DerivedMesh *lowdm, *cddm, *highdm;
557                         DMGridData **highGridData, **lowGridData, **subGridData, **gridData, *diffGrid;
558                         CCGSubSurf *ss;
559                         int i, j, numGrids, highGridSize, lowGridSize;
560
561                         /* create subsurf DM from original mesh at high level */
562                         cddm = CDDM_from_mesh(me, NULL);
563                         highdm = subsurf_dm_create_local(ob, cddm, totlvl, mmd->simple, 0);
564
565                         /* create multires DM from original mesh and displacements */
566                         lowdm = multires_dm_create_local(ob, cddm, lvl, totlvl, mmd->simple);
567                         cddm->release(cddm);
568
569                         /* gather grid data */
570                         numGrids = highdm->getNumGrids(highdm);
571                         highGridSize = highdm->getGridSize(highdm);
572                         highGridData = highdm->getGridData(highdm);
573                         lowGridSize = lowdm->getGridSize(lowdm);
574                         lowGridData = lowdm->getGridData(lowdm);
575                         gridData = dm->getGridData(dm);
576
577                         subGridData = MEM_callocN(sizeof(DMGridData*)*numGrids, "subGridData*");
578                         diffGrid = MEM_callocN(sizeof(DMGridData)*lowGridSize*lowGridSize, "diff");
579
580                         for(i = 0; i < numGrids; ++i) {
581                                 /* backup subsurf grids */
582                                 subGridData[i] = MEM_callocN(sizeof(DMGridData)*highGridSize*highGridSize, "subGridData");
583                                 memcpy(subGridData[i], highGridData[i], sizeof(DMGridData)*highGridSize*highGridSize);
584
585                                 /* write difference of subsurf and displaced low level into high subsurf */
586                                 for(j = 0; j < lowGridSize*lowGridSize; ++j)
587                                         sub_v3_v3v3(diffGrid[j].co, gridData[i][j].co, lowGridData[i][j].co);
588
589                                 multires_copy_dm_grid(highGridData[i], diffGrid, highGridSize, lowGridSize);
590                         }
591
592                         /* lower level dm no longer needed at this point */
593                         MEM_freeN(diffGrid);
594                         lowdm->release(lowdm);
595
596                         /* subsurf higher levels again with difference of coordinates */
597                         ss= ((CCGDerivedMesh*)highdm)->ss;
598                         ccgSubSurf_updateFromFaces(ss, lvl, NULL, 0);
599                         ccgSubSurf_updateLevels(ss, lvl, NULL, 0);
600
601                         /* add to displacements */
602                         multiresModifier_disp_run(highdm, me, 1, 1, subGridData, mmd->totlvl);
603
604                         /* free */
605                         highdm->release(highdm);
606                         for(i = 0; i < numGrids; ++i)
607                                 MEM_freeN(subGridData[i]);
608                         MEM_freeN(subGridData);
609                 }
610                 else {
611                         DerivedMesh *cddm, *subdm;
612
613                         cddm = CDDM_from_mesh(me, NULL);
614                         subdm = subsurf_dm_create_local(ob, cddm, mmd->totlvl, mmd->simple, 0);
615                         cddm->release(cddm);
616
617                         multiresModifier_disp_run(dm, me, 1, 0, subdm->getGridData(subdm), mmd->totlvl);
618
619                         subdm->release(subdm);
620                 }
621         }
622 }
623
624 static void multires_dm_mark_as_modified(struct DerivedMesh *dm)
625 {
626         CCGDerivedMesh *ccgdm = (CCGDerivedMesh*)dm;
627         ccgdm->multires.modified = 1;
628 }
629
630 void multires_mark_as_modified(struct Object *ob)
631 {
632         if(ob && ob->derivedFinal)
633                 multires_dm_mark_as_modified(ob->derivedFinal);
634 }
635
636 void multires_force_update(Object *ob)
637 {
638         if(ob && ob->derivedFinal) {
639                 ob->derivedFinal->needsFree =1;
640                 ob->derivedFinal->release(ob->derivedFinal);
641                 ob->derivedFinal = NULL;
642         }
643 }
644
645 void multires_stitch_grids(Object *ob)
646 {
647         /* utility for smooth brush */
648         if(ob && ob->derivedFinal) {
649                 CCGDerivedMesh *ccgdm = (CCGDerivedMesh*)ob->derivedFinal;
650                 CCGFace **faces;
651                 int totface;
652
653                 if(ccgdm->pbvh) {
654                         BLI_pbvh_get_grid_updates(ccgdm->pbvh, 0, (void***)&faces, &totface);
655
656                         if(totface) {
657                                 ccgSubSurf_stitchFaces(ccgdm->ss, 0, faces, totface);
658                                 MEM_freeN(faces);
659                         }
660                 }
661         }
662 }
663
664 struct DerivedMesh *multires_dm_create_from_derived(MultiresModifierData *mmd, int local_mmd, DerivedMesh *dm, Object *ob,
665                                                     int useRenderParams, int isFinalCalc)
666 {
667         Mesh *me= ob->data;
668         DerivedMesh *result;
669         CCGDerivedMesh *ccgdm;
670         DMGridData **gridData, **subGridData;
671         int lvl= multires_get_level(ob, mmd, useRenderParams);
672         int i, gridSize, numGrids;
673
674         if(lvl == 0)
675                 return dm;
676
677         result = subsurf_dm_create_local(ob, dm, lvl,
678                 mmd->simple, mmd->flags & eMultiresModifierFlag_ControlEdges);
679
680         if(!local_mmd) {
681                 ccgdm = (CCGDerivedMesh*)result;
682
683                 ccgdm->multires.ob = ob;
684                 ccgdm->multires.mmd = mmd;
685                 ccgdm->multires.local_mmd = local_mmd;
686                 ccgdm->multires.lvl = lvl;
687                 ccgdm->multires.totlvl = mmd->totlvl;
688                 ccgdm->multires.modified = 0;
689                 ccgdm->multires.update = multiresModifier_update;
690         }
691
692         numGrids = result->getNumGrids(result);
693         gridSize = result->getGridSize(result);
694         gridData = result->getGridData(result);
695
696         subGridData = MEM_callocN(sizeof(DMGridData*)*numGrids, "subGridData*");
697
698         for(i = 0; i < numGrids; i++) {
699                 subGridData[i] = MEM_callocN(sizeof(DMGridData)*gridSize*gridSize, "subGridData");
700                 memcpy(subGridData[i], gridData[i], sizeof(DMGridData)*gridSize*gridSize);
701         }
702
703         CustomData_external_read(&me->fdata, &me->id, CD_MASK_MDISPS, me->totface);
704         multiresModifier_disp_run(result, ob->data, 0, 0, subGridData, mmd->totlvl);
705
706         for(i = 0; i < numGrids; i++)
707                 MEM_freeN(subGridData[i]);
708         MEM_freeN(subGridData);
709
710         return result;
711 }
712
713 /**** Old Multires code ****
714 ***************************/
715
716 /* Adapted from sculptmode.c */
717 static void old_mdisps_bilinear(float out[3], float (*disps)[3], int st, float u, float v)
718 {
719         int x, y, x2, y2;
720         const int st_max = st - 1;
721         float urat, vrat, uopp;
722         float d[4][3], d2[2][3];
723
724         if(u < 0)
725                 u = 0;
726         else if(u >= st)
727                 u = st_max;
728         if(v < 0)
729                 v = 0;
730         else if(v >= st)
731                 v = st_max;
732
733         x = floor(u);
734         y = floor(v);
735         x2 = x + 1;
736         y2 = y + 1;
737
738         if(x2 >= st) x2 = st_max;
739         if(y2 >= st) y2 = st_max;
740         
741         urat = u - x;
742         vrat = v - y;
743         uopp = 1 - urat;
744
745         mul_v3_v3fl(d[0], disps[y * st + x], uopp);
746         mul_v3_v3fl(d[1], disps[y * st + x2], urat);
747         mul_v3_v3fl(d[2], disps[y2 * st + x], uopp);
748         mul_v3_v3fl(d[3], disps[y2 * st + x2], urat);
749
750         add_v3_v3v3(d2[0], d[0], d[1]);
751         add_v3_v3v3(d2[1], d[2], d[3]);
752         mul_v3_fl(d2[0], 1 - vrat);
753         mul_v3_fl(d2[1], vrat);
754
755         add_v3_v3v3(out, d2[0], d2[1]);
756 }
757
758 static void old_mdisps_rotate(int S, int newside, int oldside, int x, int y, float *u, float *v)
759 {
760         float offset = oldside*0.5f - 0.5f;
761
762         if(S == 1) { *u= offset + x; *v = offset - y; }
763         if(S == 2) { *u= offset + y; *v = offset + x; }
764         if(S == 3) { *u= offset - x; *v = offset + y; }
765         if(S == 0) { *u= offset - y; *v = offset - x; }
766 }
767
768 static void old_mdisps_convert(MFace *mface, MDisps *mdisp)
769 {
770         int newlvl = log(sqrt(mdisp->totdisp)-1)/log(2);
771         int oldlvl = newlvl+1;
772         int oldside = multires_side_tot[oldlvl];
773         int newside = multires_side_tot[newlvl];
774         int nvert = (mface->v4)? 4: 3;
775         int newtotdisp = multires_grid_tot[newlvl]*nvert;
776         int x, y, S;
777         float (*disps)[3], (*out)[3], u, v;
778
779         disps = MEM_callocN(sizeof(float) * 3 * newtotdisp, "multires disps");
780
781         out = disps;
782         for(S = 0; S < nvert; S++) {
783                 for(y = 0; y < newside; ++y) {
784                         for(x = 0; x < newside; ++x, ++out) {
785                                 old_mdisps_rotate(S, newside, oldside, x, y, &u, &v);
786                                 old_mdisps_bilinear(*out, mdisp->disps, oldside, u, v);
787
788                                 if(S == 1) { (*out)[1]= -(*out)[1]; }
789                                 else if(S == 2) { SWAP(float, (*out)[0], (*out)[1]); }
790                                 else if(S == 3) { (*out)[0]= -(*out)[0]; }
791                                 else if(S == 0) { SWAP(float, (*out)[0], (*out)[1]); (*out)[0]= -(*out)[0]; (*out)[1]= -(*out)[1]; };
792                         }
793                 }
794         }
795
796         MEM_freeN(mdisp->disps);
797
798         mdisp->totdisp= newtotdisp;
799         mdisp->disps= disps;
800 }
801
802 void multires_load_old_250(Mesh *me)
803 {
804         MDisps *mdisps;
805         int a;
806
807         mdisps= CustomData_get_layer(&me->fdata, CD_MDISPS);
808
809         if(mdisps) {
810                 for(a=0; a<me->totface; a++)
811                         if(mdisps[a].totdisp)
812                                 old_mdisps_convert(&me->mface[a], &mdisps[a]);
813         }
814 }
815
816 /* Does not actually free lvl itself */
817 static void multires_free_level(MultiresLevel *lvl)
818 {
819         if(lvl) {
820                 if(lvl->faces) MEM_freeN(lvl->faces);
821                 if(lvl->edges) MEM_freeN(lvl->edges);
822                 if(lvl->colfaces) MEM_freeN(lvl->colfaces);
823         }
824 }
825
826 void multires_free(Multires *mr)
827 {
828         if(mr) {
829                 MultiresLevel* lvl= mr->levels.first;
830
831                 /* Free the first-level data */
832                 if(lvl) {
833                         CustomData_free(&mr->vdata, lvl->totvert);
834                         CustomData_free(&mr->fdata, lvl->totface);
835                         if(mr->edge_flags)
836                                 MEM_freeN(mr->edge_flags);
837                         if(mr->edge_creases)
838                                 MEM_freeN(mr->edge_creases);
839                 }
840
841                 while(lvl) {
842                         multires_free_level(lvl);                       
843                         lvl= lvl->next;
844                 }
845
846                 MEM_freeN(mr->verts);
847
848                 BLI_freelistN(&mr->levels);
849
850                 MEM_freeN(mr);
851         }
852 }
853
854 static void create_old_vert_face_map(ListBase **map, IndexNode **mem, const MultiresFace *mface,
855                                      const int totvert, const int totface)
856 {
857         int i,j;
858         IndexNode *node = NULL;
859         
860         (*map) = MEM_callocN(sizeof(ListBase) * totvert, "vert face map");
861         (*mem) = MEM_callocN(sizeof(IndexNode) * totface*4, "vert face map mem");
862         node = *mem;
863         
864         /* Find the users */
865         for(i = 0; i < totface; ++i){
866                 for(j = 0; j < (mface[i].v[3]?4:3); ++j, ++node) {
867                         node->index = i;
868                         BLI_addtail(&(*map)[mface[i].v[j]], node);
869                 }
870         }
871 }
872
873 static void create_old_vert_edge_map(ListBase **map, IndexNode **mem, const MultiresEdge *medge,
874                                      const int totvert, const int totedge)
875 {
876         int i,j;
877         IndexNode *node = NULL;
878         
879         (*map) = MEM_callocN(sizeof(ListBase) * totvert, "vert edge map");
880         (*mem) = MEM_callocN(sizeof(IndexNode) * totedge*2, "vert edge map mem");
881         node = *mem;
882         
883         /* Find the users */
884         for(i = 0; i < totedge; ++i){
885                 for(j = 0; j < 2; ++j, ++node) {
886                         node->index = i;
887                         BLI_addtail(&(*map)[medge[i].v[j]], node);
888                 }
889         }
890 }
891
892 static MultiresFace *find_old_face(ListBase *map, MultiresFace *faces, int v1, int v2, int v3, int v4)
893 {
894         IndexNode *n1;
895         int v[4] = {v1, v2, v3, v4}, i, j;
896
897         for(n1 = map[v1].first; n1; n1 = n1->next) {
898                 int fnd[4] = {0, 0, 0, 0};
899
900                 for(i = 0; i < 4; ++i) {
901                         for(j = 0; j < 4; ++j) {
902                                 if(v[i] == faces[n1->index].v[j])
903                                         fnd[i] = 1;
904                         }
905                 }
906
907                 if(fnd[0] && fnd[1] && fnd[2] && fnd[3])
908                         return &faces[n1->index];
909         }
910
911         return NULL;
912 }
913
914 static MultiresEdge *find_old_edge(ListBase *map, MultiresEdge *edges, int v1, int v2)
915 {
916         IndexNode *n1, *n2;
917
918         for(n1 = map[v1].first; n1; n1 = n1->next) {
919                 for(n2 = map[v2].first; n2; n2 = n2->next) {
920                         if(n1->index == n2->index)
921                                 return &edges[n1->index];
922                 }
923         }
924
925         return NULL;
926 }
927
928 static void multires_load_old_edges(ListBase **emap, MultiresLevel *lvl, int *vvmap, int dst, int v1, int v2, int mov)
929 {
930         int emid = find_old_edge(emap[2], lvl->edges, v1, v2)->mid;
931         vvmap[dst + mov] = emid;
932
933         if(lvl->next->next) {
934                 multires_load_old_edges(emap + 1, lvl->next, vvmap, dst + mov, v1, emid, mov / 2);
935                 multires_load_old_edges(emap + 1, lvl->next, vvmap, dst + mov, v2, emid, -mov / 2);
936         }
937 }
938
939 static void multires_load_old_faces(ListBase **fmap, ListBase **emap, MultiresLevel *lvl, int *vvmap, int dst,
940                                     int v1, int v2, int v3, int v4, int st2, int st3)
941 {
942         int fmid;
943         int emid13, emid14, emid23, emid24;
944
945         if(lvl && lvl->next) {
946                 fmid = find_old_face(fmap[1], lvl->faces, v1, v2, v3, v4)->mid;
947                 vvmap[dst] = fmid;
948
949                 emid13 = find_old_edge(emap[1], lvl->edges, v1, v3)->mid;
950                 emid14 = find_old_edge(emap[1], lvl->edges, v1, v4)->mid;
951                 emid23 = find_old_edge(emap[1], lvl->edges, v2, v3)->mid;
952                 emid24 = find_old_edge(emap[1], lvl->edges, v2, v4)->mid;
953
954
955                 multires_load_old_faces(fmap + 1, emap + 1, lvl->next, vvmap, dst + st2 * st3 + st3,
956                                         fmid, v2, emid23, emid24, st2, st3 / 2);
957
958                 multires_load_old_faces(fmap + 1, emap + 1, lvl->next, vvmap, dst - st2 * st3 + st3,
959                                         emid14, emid24, fmid, v4, st2, st3 / 2);
960
961                 multires_load_old_faces(fmap + 1, emap + 1, lvl->next, vvmap, dst + st2 * st3 - st3,
962                                         emid13, emid23, v3, fmid, st2, st3 / 2);
963
964                 multires_load_old_faces(fmap + 1, emap + 1, lvl->next, vvmap, dst - st2 * st3 - st3,
965                                         v1, fmid, emid13, emid14, st2, st3 / 2);
966
967                 if(lvl->next->next) {
968                         multires_load_old_edges(emap, lvl->next, vvmap, dst, emid24, fmid, st3);
969                         multires_load_old_edges(emap, lvl->next, vvmap, dst, emid13, fmid, -st3);
970                         multires_load_old_edges(emap, lvl->next, vvmap, dst, emid14, fmid, -st2 * st3);
971                         multires_load_old_edges(emap, lvl->next, vvmap, dst, emid23, fmid, st2 * st3);
972                 }
973         }
974 }
975
976 static void multires_old_mvert_to_ss(DerivedMesh *dm, MVert *mvert)
977 {
978         CCGDerivedMesh *ccgdm = (CCGDerivedMesh*) dm;
979         CCGSubSurf *ss = ccgdm->ss;
980         DMGridData *vd;
981         int index;
982         int totvert, totedge, totface;
983         int gridSize = ccgSubSurf_getGridSize(ss);
984         int edgeSize = ccgSubSurf_getEdgeSize(ss);
985         int i = 0;
986
987         totface = ccgSubSurf_getNumFaces(ss);
988         for(index = 0; index < totface; index++) {
989                 CCGFace *f = ccgdm->faceMap[index].face;
990                 int x, y, S, numVerts = ccgSubSurf_getFaceNumVerts(f);
991
992                 vd= ccgSubSurf_getFaceCenterData(f);
993                 copy_v3_v3(vd->co, mvert[i].co);
994                 i++;
995                 
996                 for(S = 0; S < numVerts; S++) {
997                         for(x = 1; x < gridSize - 1; x++, i++) {
998                                 vd= ccgSubSurf_getFaceGridEdgeData(ss, f, S, x);
999                                 copy_v3_v3(vd->co, mvert[i].co);
1000                         }
1001                 }
1002
1003                 for(S = 0; S < numVerts; S++) {
1004                         for(y = 1; y < gridSize - 1; y++) {
1005                                 for(x = 1; x < gridSize - 1; x++, i++) {
1006                                         vd= ccgSubSurf_getFaceGridData(ss, f, S, x, y);
1007                                         copy_v3_v3(vd->co, mvert[i].co);
1008                                 }
1009                         }
1010                 }
1011         }
1012
1013         totedge = ccgSubSurf_getNumEdges(ss);
1014         for(index = 0; index < totedge; index++) {
1015                 CCGEdge *e = ccgdm->edgeMap[index].edge;
1016                 int x;
1017
1018                 for(x = 1; x < edgeSize - 1; x++, i++) {
1019                         vd= ccgSubSurf_getEdgeData(ss, e, x);
1020                         copy_v3_v3(vd->co, mvert[i].co);
1021                 }
1022         }
1023
1024         totvert = ccgSubSurf_getNumVerts(ss);
1025         for(index = 0; index < totvert; index++) {
1026                 CCGVert *v = ccgdm->vertMap[index].vert;
1027
1028                 vd= ccgSubSurf_getVertData(ss, v);
1029                 copy_v3_v3(vd->co, mvert[i].co);
1030                 i++;
1031         }
1032
1033         ccgSubSurf_updateToFaces(ss, 0, NULL, 0);
1034 }
1035
1036 /* Loads a multires object stored in the old Multires struct into the new format */
1037 static void multires_load_old_dm(DerivedMesh *dm, Mesh *me, int totlvl)
1038 {
1039         MultiresLevel *lvl, *lvl1;
1040         Multires *mr= me->mr;
1041         MVert *vsrc, *vdst;
1042         int src, dst;
1043         int st = multires_side_tot[totlvl - 1] - 1;
1044         int extedgelen = multires_side_tot[totlvl] - 2;
1045         int *vvmap; // inorder for dst, map to src
1046         int crossedgelen;
1047         int i, j, s, x, totvert, tottri, totquad;
1048
1049         src = 0;
1050         dst = 0;
1051         vsrc = mr->verts;
1052         vdst = dm->getVertArray(dm);
1053         totvert = dm->getNumVerts(dm);
1054         vvmap = MEM_callocN(sizeof(int) * totvert, "multires vvmap");
1055
1056         lvl1 = mr->levels.first;
1057         /* Load base verts */
1058         for(i = 0; i < lvl1->totvert; ++i) {
1059                 vvmap[totvert - lvl1->totvert + i] = src;
1060                 ++src;
1061         }
1062
1063         /* Original edges */
1064         dst = totvert - lvl1->totvert - extedgelen * lvl1->totedge;
1065         for(i = 0; i < lvl1->totedge; ++i) {
1066                 int ldst = dst + extedgelen * i;
1067                 int lsrc = src;
1068                 lvl = lvl1->next;
1069
1070                 for(j = 2; j <= mr->level_count; ++j) {
1071                         int base = multires_side_tot[totlvl - j + 1] - 2;
1072                         int skip = multires_side_tot[totlvl - j + 2] - 1;
1073                         int st = multires_side_tot[j - 1] - 1;
1074
1075                         for(x = 0; x < st; ++x)
1076                                 vvmap[ldst + base + x * skip] = lsrc + st * i + x;
1077
1078                         lsrc += lvl->totvert - lvl->prev->totvert;
1079                         lvl = lvl->next;
1080                 }
1081         }
1082
1083         /* Center points */
1084         dst = 0;
1085         for(i = 0; i < lvl1->totface; ++i) {
1086                 int sides = lvl1->faces[i].v[3] ? 4 : 3;
1087
1088                 vvmap[dst] = src + lvl1->totedge + i;
1089                 dst += 1 + sides * (st - 1) * st;
1090         }
1091
1092
1093         /* The rest is only for level 3 and up */
1094         if(lvl1->next && lvl1->next->next) {
1095                 ListBase **fmap, **emap;
1096                 IndexNode **fmem, **emem;
1097
1098                 /* Face edge cross */
1099                 tottri = totquad = 0;
1100                 crossedgelen = multires_side_tot[totlvl - 1] - 2;
1101                 dst = 0;
1102                 for(i = 0; i < lvl1->totface; ++i) {
1103                         int sides = lvl1->faces[i].v[3] ? 4 : 3;
1104
1105                         lvl = lvl1->next->next;
1106                         ++dst;
1107
1108                         for(j = 3; j <= mr->level_count; ++j) {
1109                                 int base = multires_side_tot[totlvl - j + 1] - 2;
1110                                 int skip = multires_side_tot[totlvl - j + 2] - 1;
1111                                 int st = pow(2, j - 2);
1112                                 int st2 = pow(2, j - 3);
1113                                 int lsrc = lvl->prev->totvert;
1114
1115                                 /* Skip exterior edge verts */
1116                                 lsrc += lvl1->totedge * st;
1117
1118                                 /* Skip earlier face edge crosses */
1119                                 lsrc += st2 * (tottri * 3 + totquad * 4);
1120
1121                                 for(s = 0; s < sides; ++s) {
1122                                         for(x = 0; x < st2; ++x) {
1123                                                 vvmap[dst + crossedgelen * (s + 1) - base - x * skip - 1] = lsrc;
1124                                                 ++lsrc;
1125                                         }
1126                                 }
1127
1128                                 lvl = lvl->next;
1129                         }
1130
1131                         dst += sides * (st - 1) * st;
1132
1133                         if(sides == 4) ++totquad;
1134                         else ++tottri;
1135
1136                 }
1137
1138                 /* calculate vert to edge/face maps for each level (except the last) */
1139                 fmap = MEM_callocN(sizeof(ListBase*) * (mr->level_count-1), "multires fmap");
1140                 emap = MEM_callocN(sizeof(ListBase*) * (mr->level_count-1), "multires emap");
1141                 fmem = MEM_callocN(sizeof(IndexNode*) * (mr->level_count-1), "multires fmem");
1142                 emem = MEM_callocN(sizeof(IndexNode*) * (mr->level_count-1), "multires emem");
1143                 lvl = lvl1;
1144                 for(i = 0; i < mr->level_count - 1; ++i) {
1145                         create_old_vert_face_map(fmap + i, fmem + i, lvl->faces, lvl->totvert, lvl->totface);
1146                         create_old_vert_edge_map(emap + i, emem + i, lvl->edges, lvl->totvert, lvl->totedge);
1147                         lvl = lvl->next;
1148                 }
1149
1150                 /* Interior face verts */
1151                 lvl = lvl1->next->next;
1152                 dst = 0;
1153                 for(j = 0; j < lvl1->totface; ++j) {
1154                         int sides = lvl1->faces[j].v[3] ? 4 : 3;
1155                         int ldst = dst + 1 + sides * (st - 1);
1156
1157                         for(s = 0; s < sides; ++s) {
1158                                 int st2 = multires_side_tot[totlvl - 1] - 2;
1159                                 int st3 = multires_side_tot[totlvl - 2] - 2;
1160                                 int st4 = st3 == 0 ? 1 : (st3 + 1) / 2;
1161                                 int mid = ldst + st2 * st3 + st3;
1162                                 int cv = lvl1->faces[j].v[s];
1163                                 int nv = lvl1->faces[j].v[s == sides - 1 ? 0 : s + 1];
1164                                 int pv = lvl1->faces[j].v[s == 0 ? sides - 1 : s - 1];
1165
1166                                 multires_load_old_faces(fmap, emap, lvl1->next, vvmap, mid,
1167                                                         vvmap[dst], cv,
1168                                                         find_old_edge(emap[0], lvl1->edges, pv, cv)->mid,
1169                                                         find_old_edge(emap[0], lvl1->edges, cv, nv)->mid,
1170                                                         st2, st4);
1171
1172                                 ldst += (st - 1) * (st - 1);
1173                         }
1174
1175
1176                         dst = ldst;
1177                 }
1178
1179                 lvl = lvl->next;
1180
1181                 for(i = 0; i < mr->level_count - 1; ++i) {
1182                         MEM_freeN(fmap[i]);
1183                         MEM_freeN(fmem[i]);
1184                         MEM_freeN(emap[i]);
1185                         MEM_freeN(emem[i]);
1186                 }
1187
1188                 MEM_freeN(fmap);
1189                 MEM_freeN(emap);
1190                 MEM_freeN(fmem);
1191                 MEM_freeN(emem);
1192         }
1193
1194         /* Transfer verts */
1195         for(i = 0; i < totvert; ++i)
1196                 copy_v3_v3(vdst[i].co, vsrc[vvmap[i]].co);
1197
1198         MEM_freeN(vvmap);
1199
1200         multires_old_mvert_to_ss(dm, vdst);
1201 }
1202
1203
1204 void multires_load_old(Object *ob, Mesh *me)
1205 {
1206         MultiresLevel *lvl;
1207         ModifierData *md;
1208         MultiresModifierData *mmd;
1209         DerivedMesh *dm, *orig;
1210         int i;
1211
1212         /* Load original level into the mesh */
1213         lvl = me->mr->levels.first;
1214         CustomData_free_layers(&me->vdata, CD_MVERT, lvl->totvert);
1215         CustomData_free_layers(&me->edata, CD_MEDGE, lvl->totedge);
1216         CustomData_free_layers(&me->fdata, CD_MFACE, lvl->totface);
1217         me->totvert = lvl->totvert;
1218         me->totedge = lvl->totedge;
1219         me->totface = lvl->totface;
1220         me->mvert = CustomData_add_layer(&me->vdata, CD_MVERT, CD_CALLOC, NULL, me->totvert);
1221         me->medge = CustomData_add_layer(&me->edata, CD_MEDGE, CD_CALLOC, NULL, me->totedge);
1222         me->mface = CustomData_add_layer(&me->fdata, CD_MFACE, CD_CALLOC, NULL, me->totface);
1223         memcpy(me->mvert, me->mr->verts, sizeof(MVert) * me->totvert);
1224         for(i = 0; i < me->totedge; ++i) {
1225                 me->medge[i].v1 = lvl->edges[i].v[0];
1226                 me->medge[i].v2 = lvl->edges[i].v[1];
1227         }
1228         for(i = 0; i < me->totface; ++i) {
1229                 me->mface[i].v1 = lvl->faces[i].v[0];
1230                 me->mface[i].v2 = lvl->faces[i].v[1];
1231                 me->mface[i].v3 = lvl->faces[i].v[2];
1232                 me->mface[i].v4 = lvl->faces[i].v[3];
1233         }
1234
1235         /* Add a multires modifier to the object */
1236         md = ob->modifiers.first;
1237         while(md && modifierType_getInfo(md->type)->type == eModifierTypeType_OnlyDeform)
1238                 md = md->next;                          
1239         mmd = (MultiresModifierData*)modifier_new(eModifierType_Multires);
1240         BLI_insertlinkbefore(&ob->modifiers, md, mmd);
1241
1242         for(i = 0; i < me->mr->level_count - 1; ++i)
1243                 multiresModifier_subdivide(mmd, ob, 1, 0);
1244
1245         mmd->lvl = mmd->totlvl;
1246         orig = CDDM_from_mesh(me, NULL);
1247         dm = multires_dm_create_from_derived(mmd, 0, orig, ob, 0, 0);
1248                                            
1249         multires_load_old_dm(dm, me, mmd->totlvl+1);
1250
1251         multires_dm_mark_as_modified(dm);
1252         dm->release(dm);
1253         orig->release(orig);
1254
1255         /* Remove the old multires */
1256         multires_free(me->mr);
1257         me->mr= NULL;
1258 }
1259