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