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