Cleanup: comments (long lines) in blenkernel
[blender.git] / source / blender / blenkernel / intern / pointcache.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  */
23
24 #include <stdlib.h>
25 #include <stdio.h>
26 #include <string.h>
27 #include <sys/stat.h>
28 #include <sys/types.h>
29
30 #include "CLG_log.h"
31
32 #include "MEM_guardedalloc.h"
33
34 #include "DNA_ID.h"
35 #include "DNA_collection_types.h"
36 #include "DNA_dynamicpaint_types.h"
37 #include "DNA_modifier_types.h"
38 #include "DNA_object_types.h"
39 #include "DNA_object_force_types.h"
40 #include "DNA_particle_types.h"
41 #include "DNA_rigidbody_types.h"
42 #include "DNA_scene_types.h"
43 #include "DNA_smoke_types.h"
44
45 #include "BLI_blenlib.h"
46 #include "BLI_math.h"
47 #include "BLI_string.h"
48 #include "BLI_utildefines.h"
49
50 #include "BLT_translation.h"
51
52 #include "PIL_time.h"
53
54 #include "BKE_appdir.h"
55 #include "BKE_anim.h"
56 #include "BKE_cloth.h"
57 #include "BKE_collection.h"
58 #include "BKE_dynamicpaint.h"
59 #include "BKE_global.h"
60 #include "BKE_library.h"
61 #include "BKE_main.h"
62 #include "BKE_modifier.h"
63 #include "BKE_object.h"
64 #include "BKE_particle.h"
65 #include "BKE_pointcache.h"
66 #include "BKE_scene.h"
67 #include "BKE_smoke.h"
68 #include "BKE_softbody.h"
69
70 #include "BIK_api.h"
71
72 #ifdef WITH_BULLET
73 #  include "RBI_api.h"
74 #endif
75
76 /* both in intern */
77 #ifdef WITH_SMOKE
78 #  include "smoke_API.h"
79 #endif
80
81 #ifdef WITH_OPENVDB
82 #  include "openvdb_capi.h"
83 #endif
84
85 #ifdef WITH_LZO
86 #  ifdef WITH_SYSTEM_LZO
87 #    include <lzo/lzo1x.h>
88 #  else
89 #    include "minilzo.h"
90 #  endif
91 #  define LZO_HEAP_ALLOC(var, size) \
92     lzo_align_t __LZO_MMODEL var[((size) + (sizeof(lzo_align_t) - 1)) / sizeof(lzo_align_t)]
93 #endif
94
95 #define LZO_OUT_LEN(size) ((size) + (size) / 16 + 64 + 3)
96
97 #ifdef WITH_LZMA
98 #  include "LzmaLib.h"
99 #endif
100
101 /* needed for directory lookup */
102 #ifndef WIN32
103 #  include <dirent.h>
104 #else
105 #  include "BLI_winstuff.h"
106 #endif
107
108 #define PTCACHE_DATA_FROM(data, type, from) \
109   if (data[type]) { \
110     memcpy(data[type], from, ptcache_data_size[type]); \
111   } \
112   (void)0
113
114 #define PTCACHE_DATA_TO(data, type, index, to) \
115   if (data[type]) { \
116     memcpy(to, \
117            (char *)(data)[type] + ((index) ? (index)*ptcache_data_size[type] : 0), \
118            ptcache_data_size[type]); \
119   } \
120   (void)0
121
122 /* could be made into a pointcache option */
123 #define DURIAN_POINTCACHE_LIB_OK 1
124
125 static CLG_LogRef LOG = {"bke.pointcache"};
126
127 static int ptcache_data_size[] = {
128     sizeof(unsigned int),  // BPHYS_DATA_INDEX
129     3 * sizeof(float),     // BPHYS_DATA_LOCATION
130     3 * sizeof(float),     // BPHYS_DATA_VELOCITY
131     4 * sizeof(float),     // BPHYS_DATA_ROTATION
132     3 * sizeof(float),     // BPHYS_DATA_AVELOCITY / BPHYS_DATA_XCONST
133     sizeof(float),         // BPHYS_DATA_SIZE
134     3 * sizeof(float),     // BPHYS_DATA_TIMES
135     sizeof(BoidData),      // case BPHYS_DATA_BOIDS
136 };
137
138 static int ptcache_extra_datasize[] = {
139     0,
140     sizeof(ParticleSpring),
141 };
142
143 /* forward declarations */
144 static int ptcache_file_compressed_read(PTCacheFile *pf, unsigned char *result, unsigned int len);
145 static int ptcache_file_compressed_write(
146     PTCacheFile *pf, unsigned char *in, unsigned int in_len, unsigned char *out, int mode);
147 static int ptcache_file_write(PTCacheFile *pf, const void *f, unsigned int tot, unsigned int size);
148 static int ptcache_file_read(PTCacheFile *pf, void *f, unsigned int tot, unsigned int size);
149
150 /* Common functions */
151 static int ptcache_basic_header_read(PTCacheFile *pf)
152 {
153   int error = 0;
154
155   /* Custom functions should read these basic elements too! */
156   if (!error && !fread(&pf->totpoint, sizeof(unsigned int), 1, pf->fp)) {
157     error = 1;
158   }
159
160   if (!error && !fread(&pf->data_types, sizeof(unsigned int), 1, pf->fp)) {
161     error = 1;
162   }
163
164   return !error;
165 }
166 static int ptcache_basic_header_write(PTCacheFile *pf)
167 {
168   /* Custom functions should write these basic elements too! */
169   if (!fwrite(&pf->totpoint, sizeof(unsigned int), 1, pf->fp)) {
170     return 0;
171   }
172
173   if (!fwrite(&pf->data_types, sizeof(unsigned int), 1, pf->fp)) {
174     return 0;
175   }
176
177   return 1;
178 }
179 /* Softbody functions */
180 static int ptcache_softbody_write(int index, void *soft_v, void **data, int UNUSED(cfra))
181 {
182   SoftBody *soft = soft_v;
183   BodyPoint *bp = soft->bpoint + index;
184
185   PTCACHE_DATA_FROM(data, BPHYS_DATA_LOCATION, bp->pos);
186   PTCACHE_DATA_FROM(data, BPHYS_DATA_VELOCITY, bp->vec);
187
188   return 1;
189 }
190 static void ptcache_softbody_read(
191     int index, void *soft_v, void **data, float UNUSED(cfra), float *old_data)
192 {
193   SoftBody *soft = soft_v;
194   BodyPoint *bp = soft->bpoint + index;
195
196   if (old_data) {
197     memcpy(bp->pos, data, 3 * sizeof(float));
198     memcpy(bp->vec, data + 3, 3 * sizeof(float));
199   }
200   else {
201     PTCACHE_DATA_TO(data, BPHYS_DATA_LOCATION, 0, bp->pos);
202     PTCACHE_DATA_TO(data, BPHYS_DATA_VELOCITY, 0, bp->vec);
203   }
204 }
205 static void ptcache_softbody_interpolate(
206     int index, void *soft_v, void **data, float cfra, float cfra1, float cfra2, float *old_data)
207 {
208   SoftBody *soft = soft_v;
209   BodyPoint *bp = soft->bpoint + index;
210   ParticleKey keys[4];
211   float dfra;
212
213   if (cfra1 == cfra2) {
214     return;
215   }
216
217   copy_v3_v3(keys[1].co, bp->pos);
218   copy_v3_v3(keys[1].vel, bp->vec);
219
220   if (old_data) {
221     memcpy(keys[2].co, old_data, 3 * sizeof(float));
222     memcpy(keys[2].vel, old_data + 3, 3 * sizeof(float));
223   }
224   else {
225     BKE_ptcache_make_particle_key(keys + 2, 0, data, cfra2);
226   }
227
228   dfra = cfra2 - cfra1;
229
230   mul_v3_fl(keys[1].vel, dfra);
231   mul_v3_fl(keys[2].vel, dfra);
232
233   psys_interpolate_particle(-1, keys, (cfra - cfra1) / dfra, keys, 1);
234
235   mul_v3_fl(keys->vel, 1.0f / dfra);
236
237   copy_v3_v3(bp->pos, keys->co);
238   copy_v3_v3(bp->vec, keys->vel);
239 }
240 static int ptcache_softbody_totpoint(void *soft_v, int UNUSED(cfra))
241 {
242   SoftBody *soft = soft_v;
243   return soft->totpoint;
244 }
245 static void ptcache_softbody_error(void *UNUSED(soft_v), const char *UNUSED(message))
246 {
247   /* ignored for now */
248 }
249
250 /* Particle functions */
251 void BKE_ptcache_make_particle_key(ParticleKey *key, int index, void **data, float time)
252 {
253   PTCACHE_DATA_TO(data, BPHYS_DATA_LOCATION, index, key->co);
254   PTCACHE_DATA_TO(data, BPHYS_DATA_VELOCITY, index, key->vel);
255
256   /* no rotation info, so make something nice up */
257   if (data[BPHYS_DATA_ROTATION] == NULL) {
258     vec_to_quat(key->rot, key->vel, OB_NEGX, OB_POSZ);
259   }
260   else {
261     PTCACHE_DATA_TO(data, BPHYS_DATA_ROTATION, index, key->rot);
262   }
263
264   PTCACHE_DATA_TO(data, BPHYS_DATA_AVELOCITY, index, key->ave);
265   key->time = time;
266 }
267 static int ptcache_particle_write(int index, void *psys_v, void **data, int cfra)
268 {
269   ParticleSystem *psys = psys_v;
270   ParticleData *pa = psys->particles + index;
271   BoidParticle *boid = (psys->part->phystype == PART_PHYS_BOIDS) ? pa->boid : NULL;
272   float times[3];
273   int step = psys->pointcache->step;
274
275   /* No need to store unborn or died particles outside cache step bounds */
276   if (data[BPHYS_DATA_INDEX] && (cfra < pa->time - step || cfra > pa->dietime + step)) {
277     return 0;
278   }
279
280   times[0] = pa->time;
281   times[1] = pa->dietime;
282   times[2] = pa->lifetime;
283
284   PTCACHE_DATA_FROM(data, BPHYS_DATA_INDEX, &index);
285   PTCACHE_DATA_FROM(data, BPHYS_DATA_LOCATION, pa->state.co);
286   PTCACHE_DATA_FROM(data, BPHYS_DATA_VELOCITY, pa->state.vel);
287   PTCACHE_DATA_FROM(data, BPHYS_DATA_ROTATION, pa->state.rot);
288   PTCACHE_DATA_FROM(data, BPHYS_DATA_AVELOCITY, pa->state.ave);
289   PTCACHE_DATA_FROM(data, BPHYS_DATA_SIZE, &pa->size);
290   PTCACHE_DATA_FROM(data, BPHYS_DATA_TIMES, times);
291
292   if (boid) {
293     PTCACHE_DATA_FROM(data, BPHYS_DATA_BOIDS, &boid->data);
294   }
295
296   /* Return flag 1+1=2 for newly born particles
297    * to copy exact birth location to previously cached frame. */
298   return 1 + (pa->state.time >= pa->time && pa->prev_state.time <= pa->time);
299 }
300 static void ptcache_particle_read(
301     int index, void *psys_v, void **data, float cfra, float *old_data)
302 {
303   ParticleSystem *psys = psys_v;
304   ParticleData *pa;
305   BoidParticle *boid;
306   float timestep = 0.04f * psys->part->timetweak;
307
308   if (index >= psys->totpart) {
309     return;
310   }
311
312   pa = psys->particles + index;
313   boid = (psys->part->phystype == PART_PHYS_BOIDS) ? pa->boid : NULL;
314
315   if (cfra > pa->state.time) {
316     memcpy(&pa->prev_state, &pa->state, sizeof(ParticleKey));
317   }
318
319   if (old_data) {
320     /* old format cache */
321     memcpy(&pa->state, old_data, sizeof(ParticleKey));
322     return;
323   }
324
325   BKE_ptcache_make_particle_key(&pa->state, 0, data, cfra);
326
327   /* set frames cached before birth to birth time */
328   if (cfra < pa->time) {
329     pa->state.time = pa->time;
330   }
331   else if (cfra > pa->dietime) {
332     pa->state.time = pa->dietime;
333   }
334
335   if (data[BPHYS_DATA_SIZE]) {
336     PTCACHE_DATA_TO(data, BPHYS_DATA_SIZE, 0, &pa->size);
337   }
338
339   if (data[BPHYS_DATA_TIMES]) {
340     float times[3];
341     PTCACHE_DATA_TO(data, BPHYS_DATA_TIMES, 0, &times);
342     pa->time = times[0];
343     pa->dietime = times[1];
344     pa->lifetime = times[2];
345   }
346
347   if (boid) {
348     PTCACHE_DATA_TO(data, BPHYS_DATA_BOIDS, 0, &boid->data);
349   }
350
351   /* determine velocity from previous location */
352   if (data[BPHYS_DATA_LOCATION] && !data[BPHYS_DATA_VELOCITY]) {
353     if (cfra > pa->prev_state.time) {
354       sub_v3_v3v3(pa->state.vel, pa->state.co, pa->prev_state.co);
355       mul_v3_fl(pa->state.vel, (cfra - pa->prev_state.time) * timestep);
356     }
357     else {
358       sub_v3_v3v3(pa->state.vel, pa->prev_state.co, pa->state.co);
359       mul_v3_fl(pa->state.vel, (pa->prev_state.time - cfra) * timestep);
360     }
361   }
362
363   /* default to no rotation */
364   if (data[BPHYS_DATA_LOCATION] && !data[BPHYS_DATA_ROTATION]) {
365     unit_qt(pa->state.rot);
366   }
367 }
368 static void ptcache_particle_interpolate(
369     int index, void *psys_v, void **data, float cfra, float cfra1, float cfra2, float *old_data)
370 {
371   ParticleSystem *psys = psys_v;
372   ParticleData *pa;
373   ParticleKey keys[4];
374   float dfra, timestep = 0.04f * psys->part->timetweak;
375
376   if (index >= psys->totpart) {
377     return;
378   }
379
380   pa = psys->particles + index;
381
382   /* particle wasn't read from first cache so can't interpolate */
383   if ((int)cfra1 < pa->time - psys->pointcache->step ||
384       (int)cfra1 > pa->dietime + psys->pointcache->step) {
385     return;
386   }
387
388   cfra = MIN2(cfra, pa->dietime);
389   cfra1 = MIN2(cfra1, pa->dietime);
390   cfra2 = MIN2(cfra2, pa->dietime);
391
392   if (cfra1 == cfra2) {
393     return;
394   }
395
396   memcpy(keys + 1, &pa->state, sizeof(ParticleKey));
397   if (old_data) {
398     memcpy(keys + 2, old_data, sizeof(ParticleKey));
399   }
400   else {
401     BKE_ptcache_make_particle_key(keys + 2, 0, data, cfra2);
402   }
403
404   /* determine velocity from previous location */
405   if (data[BPHYS_DATA_LOCATION] && !data[BPHYS_DATA_VELOCITY]) {
406     if (keys[1].time > keys[2].time) {
407       sub_v3_v3v3(keys[2].vel, keys[1].co, keys[2].co);
408       mul_v3_fl(keys[2].vel, (keys[1].time - keys[2].time) * timestep);
409     }
410     else {
411       sub_v3_v3v3(keys[2].vel, keys[2].co, keys[1].co);
412       mul_v3_fl(keys[2].vel, (keys[2].time - keys[1].time) * timestep);
413     }
414   }
415
416   /* default to no rotation */
417   if (data[BPHYS_DATA_LOCATION] && !data[BPHYS_DATA_ROTATION]) {
418     unit_qt(keys[2].rot);
419   }
420
421   if (cfra > pa->time) {
422     cfra1 = MAX2(cfra1, pa->time);
423   }
424
425   dfra = cfra2 - cfra1;
426
427   mul_v3_fl(keys[1].vel, dfra * timestep);
428   mul_v3_fl(keys[2].vel, dfra * timestep);
429
430   psys_interpolate_particle(-1, keys, (cfra - cfra1) / dfra, &pa->state, 1);
431   interp_qt_qtqt(pa->state.rot, keys[1].rot, keys[2].rot, (cfra - cfra1) / dfra);
432
433   mul_v3_fl(pa->state.vel, 1.f / (dfra * timestep));
434
435   pa->state.time = cfra;
436 }
437
438 static int ptcache_particle_totpoint(void *psys_v, int UNUSED(cfra))
439 {
440   ParticleSystem *psys = psys_v;
441   return psys->totpart;
442 }
443
444 static void ptcache_particle_error(void *UNUSED(psys_v), const char *UNUSED(message))
445 {
446   /* ignored for now */
447 }
448
449 static int ptcache_particle_totwrite(void *psys_v, int cfra)
450 {
451   ParticleSystem *psys = psys_v;
452   ParticleData *pa = psys->particles;
453   int p, step = psys->pointcache->step;
454   int totwrite = 0;
455
456   if (cfra == 0) {
457     return psys->totpart;
458   }
459
460   for (p = 0; p < psys->totpart; p++, pa++) {
461     totwrite += (cfra >= pa->time - step && cfra <= pa->dietime + step);
462   }
463
464   return totwrite;
465 }
466
467 static void ptcache_particle_extra_write(void *psys_v, PTCacheMem *pm, int UNUSED(cfra))
468 {
469   ParticleSystem *psys = psys_v;
470   PTCacheExtra *extra = NULL;
471
472   if (psys->part->phystype == PART_PHYS_FLUID && psys->part->fluid &&
473       psys->part->fluid->flag & SPH_VISCOELASTIC_SPRINGS && psys->tot_fluidsprings &&
474       psys->fluid_springs) {
475     extra = MEM_callocN(sizeof(PTCacheExtra), "Point cache: fluid extra data");
476
477     extra->type = BPHYS_EXTRA_FLUID_SPRINGS;
478     extra->totdata = psys->tot_fluidsprings;
479
480     extra->data = MEM_callocN(extra->totdata * ptcache_extra_datasize[extra->type],
481                               "Point cache: extra data");
482     memcpy(extra->data, psys->fluid_springs, extra->totdata * ptcache_extra_datasize[extra->type]);
483
484     BLI_addtail(&pm->extradata, extra);
485   }
486 }
487
488 static void ptcache_particle_extra_read(void *psys_v, PTCacheMem *pm, float UNUSED(cfra))
489 {
490   ParticleSystem *psys = psys_v;
491   PTCacheExtra *extra = pm->extradata.first;
492
493   for (; extra; extra = extra->next) {
494     switch (extra->type) {
495       case BPHYS_EXTRA_FLUID_SPRINGS: {
496         if (psys->fluid_springs) {
497           MEM_freeN(psys->fluid_springs);
498         }
499
500         psys->fluid_springs = MEM_dupallocN(extra->data);
501         psys->tot_fluidsprings = psys->alloc_fluidsprings = extra->totdata;
502         break;
503       }
504     }
505   }
506 }
507
508 /* Cloth functions */
509 static int ptcache_cloth_write(int index, void *cloth_v, void **data, int UNUSED(cfra))
510 {
511   ClothModifierData *clmd = cloth_v;
512   Cloth *cloth = clmd->clothObject;
513   ClothVertex *vert = cloth->verts + index;
514
515   PTCACHE_DATA_FROM(data, BPHYS_DATA_LOCATION, vert->x);
516   PTCACHE_DATA_FROM(data, BPHYS_DATA_VELOCITY, vert->v);
517   PTCACHE_DATA_FROM(data, BPHYS_DATA_XCONST, vert->xconst);
518
519   return 1;
520 }
521 static void ptcache_cloth_read(
522     int index, void *cloth_v, void **data, float UNUSED(cfra), float *old_data)
523 {
524   ClothModifierData *clmd = cloth_v;
525   Cloth *cloth = clmd->clothObject;
526   ClothVertex *vert = cloth->verts + index;
527
528   if (old_data) {
529     memcpy(vert->x, data, 3 * sizeof(float));
530     memcpy(vert->xconst, data + 3, 3 * sizeof(float));
531     memcpy(vert->v, data + 6, 3 * sizeof(float));
532   }
533   else {
534     PTCACHE_DATA_TO(data, BPHYS_DATA_LOCATION, 0, vert->x);
535     PTCACHE_DATA_TO(data, BPHYS_DATA_VELOCITY, 0, vert->v);
536     PTCACHE_DATA_TO(data, BPHYS_DATA_XCONST, 0, vert->xconst);
537   }
538 }
539 static void ptcache_cloth_interpolate(
540     int index, void *cloth_v, void **data, float cfra, float cfra1, float cfra2, float *old_data)
541 {
542   ClothModifierData *clmd = cloth_v;
543   Cloth *cloth = clmd->clothObject;
544   ClothVertex *vert = cloth->verts + index;
545   ParticleKey keys[4];
546   float dfra;
547
548   if (cfra1 == cfra2) {
549     return;
550   }
551
552   copy_v3_v3(keys[1].co, vert->x);
553   copy_v3_v3(keys[1].vel, vert->v);
554
555   if (old_data) {
556     memcpy(keys[2].co, old_data, 3 * sizeof(float));
557     memcpy(keys[2].vel, old_data + 6, 3 * sizeof(float));
558   }
559   else {
560     BKE_ptcache_make_particle_key(keys + 2, 0, data, cfra2);
561   }
562
563   dfra = cfra2 - cfra1;
564
565   mul_v3_fl(keys[1].vel, dfra);
566   mul_v3_fl(keys[2].vel, dfra);
567
568   psys_interpolate_particle(-1, keys, (cfra - cfra1) / dfra, keys, 1);
569
570   mul_v3_fl(keys->vel, 1.0f / dfra);
571
572   copy_v3_v3(vert->x, keys->co);
573   copy_v3_v3(vert->v, keys->vel);
574
575   /* should vert->xconst be interpolated somehow too? - jahka */
576 }
577
578 static int ptcache_cloth_totpoint(void *cloth_v, int UNUSED(cfra))
579 {
580   ClothModifierData *clmd = cloth_v;
581   return clmd->clothObject ? clmd->clothObject->mvert_num : 0;
582 }
583
584 static void ptcache_cloth_error(void *cloth_v, const char *message)
585 {
586   ClothModifierData *clmd = cloth_v;
587   modifier_setError(&clmd->modifier, "%s", message);
588 }
589
590 #ifdef WITH_SMOKE
591 /* Smoke functions */
592 static int ptcache_smoke_totpoint(void *smoke_v, int UNUSED(cfra))
593 {
594   SmokeModifierData *smd = (SmokeModifierData *)smoke_v;
595   SmokeDomainSettings *sds = smd->domain;
596
597   if (sds->fluid) {
598     return sds->base_res[0] * sds->base_res[1] * sds->base_res[2];
599   }
600   else {
601     return 0;
602   }
603 }
604
605 static void ptcache_smoke_error(void *smoke_v, const char *message)
606 {
607   SmokeModifierData *smd = (SmokeModifierData *)smoke_v;
608   modifier_setError(&smd->modifier, "%s", message);
609 }
610
611 #  define SMOKE_CACHE_VERSION "1.04"
612
613 static int ptcache_smoke_write(PTCacheFile *pf, void *smoke_v)
614 {
615   SmokeModifierData *smd = (SmokeModifierData *)smoke_v;
616   SmokeDomainSettings *sds = smd->domain;
617   int ret = 0;
618   int fluid_fields = BKE_smoke_get_data_flags(sds);
619
620   /* version header */
621   ptcache_file_write(pf, SMOKE_CACHE_VERSION, 4, sizeof(char));
622   ptcache_file_write(pf, &fluid_fields, 1, sizeof(int));
623   ptcache_file_write(pf, &sds->active_fields, 1, sizeof(int));
624   ptcache_file_write(pf, &sds->res, 3, sizeof(int));
625   ptcache_file_write(pf, &sds->dx, 1, sizeof(float));
626
627   if (sds->fluid) {
628     size_t res = sds->res[0] * sds->res[1] * sds->res[2];
629     float dt, dx, *dens, *react, *fuel, *flame, *heat, *heatold, *vx, *vy, *vz, *r, *g, *b;
630     unsigned char *obstacles;
631     unsigned int in_len = sizeof(float) * (unsigned int)res;
632     unsigned char *out = (unsigned char *)MEM_callocN(LZO_OUT_LEN(in_len) * 4,
633                                                       "pointcache_lzo_buffer");
634     //int mode = res >= 1000000 ? 2 : 1;
635     int mode = 1;  // light
636     if (sds->cache_comp == SM_CACHE_HEAVY) {
637       mode = 2;  // heavy
638     }
639
640     smoke_export(sds->fluid,
641                  &dt,
642                  &dx,
643                  &dens,
644                  &react,
645                  &flame,
646                  &fuel,
647                  &heat,
648                  &heatold,
649                  &vx,
650                  &vy,
651                  &vz,
652                  &r,
653                  &g,
654                  &b,
655                  &obstacles);
656
657     ptcache_file_compressed_write(pf, (unsigned char *)sds->shadow, in_len, out, mode);
658     ptcache_file_compressed_write(pf, (unsigned char *)dens, in_len, out, mode);
659     if (fluid_fields & SM_ACTIVE_HEAT) {
660       ptcache_file_compressed_write(pf, (unsigned char *)heat, in_len, out, mode);
661       ptcache_file_compressed_write(pf, (unsigned char *)heatold, in_len, out, mode);
662     }
663     if (fluid_fields & SM_ACTIVE_FIRE) {
664       ptcache_file_compressed_write(pf, (unsigned char *)flame, in_len, out, mode);
665       ptcache_file_compressed_write(pf, (unsigned char *)fuel, in_len, out, mode);
666       ptcache_file_compressed_write(pf, (unsigned char *)react, in_len, out, mode);
667     }
668     if (fluid_fields & SM_ACTIVE_COLORS) {
669       ptcache_file_compressed_write(pf, (unsigned char *)r, in_len, out, mode);
670       ptcache_file_compressed_write(pf, (unsigned char *)g, in_len, out, mode);
671       ptcache_file_compressed_write(pf, (unsigned char *)b, in_len, out, mode);
672     }
673     ptcache_file_compressed_write(pf, (unsigned char *)vx, in_len, out, mode);
674     ptcache_file_compressed_write(pf, (unsigned char *)vy, in_len, out, mode);
675     ptcache_file_compressed_write(pf, (unsigned char *)vz, in_len, out, mode);
676     ptcache_file_compressed_write(pf, (unsigned char *)obstacles, (unsigned int)res, out, mode);
677     ptcache_file_write(pf, &dt, 1, sizeof(float));
678     ptcache_file_write(pf, &dx, 1, sizeof(float));
679     ptcache_file_write(pf, &sds->p0, 3, sizeof(float));
680     ptcache_file_write(pf, &sds->p1, 3, sizeof(float));
681     ptcache_file_write(pf, &sds->dp0, 3, sizeof(float));
682     ptcache_file_write(pf, &sds->shift, 3, sizeof(int));
683     ptcache_file_write(pf, &sds->obj_shift_f, 3, sizeof(float));
684     ptcache_file_write(pf, &sds->obmat, 16, sizeof(float));
685     ptcache_file_write(pf, &sds->base_res, 3, sizeof(int));
686     ptcache_file_write(pf, &sds->res_min, 3, sizeof(int));
687     ptcache_file_write(pf, &sds->res_max, 3, sizeof(int));
688     ptcache_file_write(pf, &sds->active_color, 3, sizeof(float));
689
690     MEM_freeN(out);
691
692     ret = 1;
693   }
694
695   if (sds->wt) {
696     int res_big_array[3];
697     int res_big;
698     int res = sds->res[0] * sds->res[1] * sds->res[2];
699     float *dens, *react, *fuel, *flame, *tcu, *tcv, *tcw, *r, *g, *b;
700     unsigned int in_len = sizeof(float) * (unsigned int)res;
701     unsigned int in_len_big;
702     unsigned char *out;
703     int mode;
704
705     smoke_turbulence_get_res(sds->wt, res_big_array);
706     res_big = res_big_array[0] * res_big_array[1] * res_big_array[2];
707     //mode =  res_big >= 1000000 ? 2 : 1;
708     mode = 1;  // light
709     if (sds->cache_high_comp == SM_CACHE_HEAVY) {
710       mode = 2;  // heavy
711     }
712
713     in_len_big = sizeof(float) * (unsigned int)res_big;
714
715     smoke_turbulence_export(sds->wt, &dens, &react, &flame, &fuel, &r, &g, &b, &tcu, &tcv, &tcw);
716
717     out = (unsigned char *)MEM_callocN(LZO_OUT_LEN(in_len_big), "pointcache_lzo_buffer");
718     ptcache_file_compressed_write(pf, (unsigned char *)dens, in_len_big, out, mode);
719     if (fluid_fields & SM_ACTIVE_FIRE) {
720       ptcache_file_compressed_write(pf, (unsigned char *)flame, in_len_big, out, mode);
721       ptcache_file_compressed_write(pf, (unsigned char *)fuel, in_len_big, out, mode);
722       ptcache_file_compressed_write(pf, (unsigned char *)react, in_len_big, out, mode);
723     }
724     if (fluid_fields & SM_ACTIVE_COLORS) {
725       ptcache_file_compressed_write(pf, (unsigned char *)r, in_len_big, out, mode);
726       ptcache_file_compressed_write(pf, (unsigned char *)g, in_len_big, out, mode);
727       ptcache_file_compressed_write(pf, (unsigned char *)b, in_len_big, out, mode);
728     }
729     MEM_freeN(out);
730
731     out = (unsigned char *)MEM_callocN(LZO_OUT_LEN(in_len), "pointcache_lzo_buffer");
732     ptcache_file_compressed_write(pf, (unsigned char *)tcu, in_len, out, mode);
733     ptcache_file_compressed_write(pf, (unsigned char *)tcv, in_len, out, mode);
734     ptcache_file_compressed_write(pf, (unsigned char *)tcw, in_len, out, mode);
735     MEM_freeN(out);
736
737     ret = 1;
738   }
739
740   return ret;
741 }
742
743 /* read old smoke cache from 2.64 */
744 static int ptcache_smoke_read_old(PTCacheFile *pf, void *smoke_v)
745 {
746   SmokeModifierData *smd = (SmokeModifierData *)smoke_v;
747   SmokeDomainSettings *sds = smd->domain;
748
749   if (sds->fluid) {
750     const size_t res = sds->res[0] * sds->res[1] * sds->res[2];
751     const unsigned int out_len = (unsigned int)res * sizeof(float);
752     float dt, dx, *dens, *heat, *heatold, *vx, *vy, *vz;
753     unsigned char *obstacles;
754     float *tmp_array = MEM_callocN(out_len, "Smoke old cache tmp");
755
756     int fluid_fields = BKE_smoke_get_data_flags(sds);
757
758     /* Part part of the new cache header */
759     sds->active_color[0] = 0.7f;
760     sds->active_color[1] = 0.7f;
761     sds->active_color[2] = 0.7f;
762
763     smoke_export(sds->fluid,
764                  &dt,
765                  &dx,
766                  &dens,
767                  NULL,
768                  NULL,
769                  NULL,
770                  &heat,
771                  &heatold,
772                  &vx,
773                  &vy,
774                  &vz,
775                  NULL,
776                  NULL,
777                  NULL,
778                  &obstacles);
779
780     ptcache_file_compressed_read(pf, (unsigned char *)sds->shadow, out_len);
781     ptcache_file_compressed_read(pf, (unsigned char *)dens, out_len);
782     ptcache_file_compressed_read(pf, (unsigned char *)tmp_array, out_len);
783
784     if (fluid_fields & SM_ACTIVE_HEAT) {
785       ptcache_file_compressed_read(pf, (unsigned char *)heat, out_len);
786       ptcache_file_compressed_read(pf, (unsigned char *)heatold, out_len);
787     }
788     else {
789       ptcache_file_compressed_read(pf, (unsigned char *)tmp_array, out_len);
790       ptcache_file_compressed_read(pf, (unsigned char *)tmp_array, out_len);
791     }
792     ptcache_file_compressed_read(pf, (unsigned char *)vx, out_len);
793     ptcache_file_compressed_read(pf, (unsigned char *)vy, out_len);
794     ptcache_file_compressed_read(pf, (unsigned char *)vz, out_len);
795     ptcache_file_compressed_read(pf, (unsigned char *)tmp_array, out_len);
796     ptcache_file_compressed_read(pf, (unsigned char *)tmp_array, out_len);
797     ptcache_file_compressed_read(pf, (unsigned char *)tmp_array, out_len);
798     ptcache_file_compressed_read(pf, (unsigned char *)obstacles, (unsigned int)res);
799     ptcache_file_read(pf, &dt, 1, sizeof(float));
800     ptcache_file_read(pf, &dx, 1, sizeof(float));
801
802     MEM_freeN(tmp_array);
803
804     if (pf->data_types & (1 << BPHYS_DATA_SMOKE_HIGH) && sds->wt) {
805       int res_big, res_big_array[3];
806       float *tcu, *tcv, *tcw;
807       unsigned int out_len_big;
808       unsigned char *tmp_array_big;
809       smoke_turbulence_get_res(sds->wt, res_big_array);
810       res_big = res_big_array[0] * res_big_array[1] * res_big_array[2];
811       out_len_big = sizeof(float) * (unsigned int)res_big;
812
813       tmp_array_big = MEM_callocN(out_len_big, "Smoke old cache tmp");
814
815       smoke_turbulence_export(
816           sds->wt, &dens, NULL, NULL, NULL, NULL, NULL, NULL, &tcu, &tcv, &tcw);
817
818       ptcache_file_compressed_read(pf, (unsigned char *)dens, out_len_big);
819       ptcache_file_compressed_read(pf, (unsigned char *)tmp_array_big, out_len_big);
820
821       ptcache_file_compressed_read(pf, (unsigned char *)tcu, out_len);
822       ptcache_file_compressed_read(pf, (unsigned char *)tcv, out_len);
823       ptcache_file_compressed_read(pf, (unsigned char *)tcw, out_len);
824
825       MEM_freeN(tmp_array_big);
826     }
827   }
828
829   return 1;
830 }
831
832 static int ptcache_smoke_read(PTCacheFile *pf, void *smoke_v)
833 {
834   SmokeModifierData *smd = (SmokeModifierData *)smoke_v;
835   SmokeDomainSettings *sds = smd->domain;
836   char version[4];
837   int ch_res[3];
838   float ch_dx;
839   int fluid_fields = BKE_smoke_get_data_flags(sds);
840   int cache_fields = 0;
841   int active_fields = 0;
842   int reallocate = 0;
843
844   /* version header */
845   ptcache_file_read(pf, version, 4, sizeof(char));
846   if (!STREQLEN(version, SMOKE_CACHE_VERSION, 4)) {
847     /* reset file pointer */
848     fseek(pf->fp, -4, SEEK_CUR);
849     return ptcache_smoke_read_old(pf, smoke_v);
850   }
851
852   /* fluid info */
853   ptcache_file_read(pf, &cache_fields, 1, sizeof(int));
854   ptcache_file_read(pf, &active_fields, 1, sizeof(int));
855   ptcache_file_read(pf, &ch_res, 3, sizeof(int));
856   ptcache_file_read(pf, &ch_dx, 1, sizeof(float));
857
858   /* check if resolution has changed */
859   if (sds->res[0] != ch_res[0] || sds->res[1] != ch_res[1] || sds->res[2] != ch_res[2]) {
860     if (sds->flags & MOD_SMOKE_ADAPTIVE_DOMAIN) {
861       reallocate = 1;
862     }
863     else {
864       return 0;
865     }
866   }
867   /* check if active fields have changed */
868   if (fluid_fields != cache_fields || active_fields != sds->active_fields) {
869     reallocate = 1;
870   }
871
872   /* reallocate fluid if needed*/
873   if (reallocate) {
874     sds->active_fields = active_fields | cache_fields;
875     BKE_smoke_reallocate_fluid(sds, ch_dx, ch_res, 1);
876     sds->dx = ch_dx;
877     copy_v3_v3_int(sds->res, ch_res);
878     sds->total_cells = ch_res[0] * ch_res[1] * ch_res[2];
879     if (sds->flags & MOD_SMOKE_HIGHRES) {
880       BKE_smoke_reallocate_highres_fluid(sds, ch_dx, ch_res, 1);
881     }
882   }
883
884   if (sds->fluid) {
885     size_t res = sds->res[0] * sds->res[1] * sds->res[2];
886     float dt, dx, *dens, *react, *fuel, *flame, *heat, *heatold, *vx, *vy, *vz, *r, *g, *b;
887     unsigned char *obstacles;
888     unsigned int out_len = (unsigned int)res * sizeof(float);
889
890     smoke_export(sds->fluid,
891                  &dt,
892                  &dx,
893                  &dens,
894                  &react,
895                  &flame,
896                  &fuel,
897                  &heat,
898                  &heatold,
899                  &vx,
900                  &vy,
901                  &vz,
902                  &r,
903                  &g,
904                  &b,
905                  &obstacles);
906
907     ptcache_file_compressed_read(pf, (unsigned char *)sds->shadow, out_len);
908     ptcache_file_compressed_read(pf, (unsigned char *)dens, out_len);
909     if (cache_fields & SM_ACTIVE_HEAT) {
910       ptcache_file_compressed_read(pf, (unsigned char *)heat, out_len);
911       ptcache_file_compressed_read(pf, (unsigned char *)heatold, out_len);
912     }
913     if (cache_fields & SM_ACTIVE_FIRE) {
914       ptcache_file_compressed_read(pf, (unsigned char *)flame, out_len);
915       ptcache_file_compressed_read(pf, (unsigned char *)fuel, out_len);
916       ptcache_file_compressed_read(pf, (unsigned char *)react, out_len);
917     }
918     if (cache_fields & SM_ACTIVE_COLORS) {
919       ptcache_file_compressed_read(pf, (unsigned char *)r, out_len);
920       ptcache_file_compressed_read(pf, (unsigned char *)g, out_len);
921       ptcache_file_compressed_read(pf, (unsigned char *)b, out_len);
922     }
923     ptcache_file_compressed_read(pf, (unsigned char *)vx, out_len);
924     ptcache_file_compressed_read(pf, (unsigned char *)vy, out_len);
925     ptcache_file_compressed_read(pf, (unsigned char *)vz, out_len);
926     ptcache_file_compressed_read(pf, (unsigned char *)obstacles, (unsigned int)res);
927     ptcache_file_read(pf, &dt, 1, sizeof(float));
928     ptcache_file_read(pf, &dx, 1, sizeof(float));
929     ptcache_file_read(pf, &sds->p0, 3, sizeof(float));
930     ptcache_file_read(pf, &sds->p1, 3, sizeof(float));
931     ptcache_file_read(pf, &sds->dp0, 3, sizeof(float));
932     ptcache_file_read(pf, &sds->shift, 3, sizeof(int));
933     ptcache_file_read(pf, &sds->obj_shift_f, 3, sizeof(float));
934     ptcache_file_read(pf, &sds->obmat, 16, sizeof(float));
935     ptcache_file_read(pf, &sds->base_res, 3, sizeof(int));
936     ptcache_file_read(pf, &sds->res_min, 3, sizeof(int));
937     ptcache_file_read(pf, &sds->res_max, 3, sizeof(int));
938     ptcache_file_read(pf, &sds->active_color, 3, sizeof(float));
939   }
940
941   if (pf->data_types & (1 << BPHYS_DATA_SMOKE_HIGH) && sds->wt) {
942     int res = sds->res[0] * sds->res[1] * sds->res[2];
943     int res_big, res_big_array[3];
944     float *dens, *react, *fuel, *flame, *tcu, *tcv, *tcw, *r, *g, *b;
945     unsigned int out_len = sizeof(float) * (unsigned int)res;
946     unsigned int out_len_big;
947
948     smoke_turbulence_get_res(sds->wt, res_big_array);
949     res_big = res_big_array[0] * res_big_array[1] * res_big_array[2];
950     out_len_big = sizeof(float) * (unsigned int)res_big;
951
952     smoke_turbulence_export(sds->wt, &dens, &react, &flame, &fuel, &r, &g, &b, &tcu, &tcv, &tcw);
953
954     ptcache_file_compressed_read(pf, (unsigned char *)dens, out_len_big);
955     if (cache_fields & SM_ACTIVE_FIRE) {
956       ptcache_file_compressed_read(pf, (unsigned char *)flame, out_len_big);
957       ptcache_file_compressed_read(pf, (unsigned char *)fuel, out_len_big);
958       ptcache_file_compressed_read(pf, (unsigned char *)react, out_len_big);
959     }
960     if (cache_fields & SM_ACTIVE_COLORS) {
961       ptcache_file_compressed_read(pf, (unsigned char *)r, out_len_big);
962       ptcache_file_compressed_read(pf, (unsigned char *)g, out_len_big);
963       ptcache_file_compressed_read(pf, (unsigned char *)b, out_len_big);
964     }
965
966     ptcache_file_compressed_read(pf, (unsigned char *)tcu, out_len);
967     ptcache_file_compressed_read(pf, (unsigned char *)tcv, out_len);
968     ptcache_file_compressed_read(pf, (unsigned char *)tcw, out_len);
969   }
970
971   return 1;
972 }
973
974 #  ifdef WITH_OPENVDB
975 /**
976  * Construct matrices which represent the fluid object, for low and high res:
977  * <pre>
978  * vs 0  0  0
979  * 0  vs 0  0
980  * 0  0  vs 0
981  * px py pz 1
982  * </pre>
983  *
984  * with `vs` = voxel size, and `px, py, pz`,
985  * the min position of the domain's bounding box.
986  */
987 static void compute_fluid_matrices(SmokeDomainSettings *sds)
988 {
989   float bbox_min[3];
990
991   copy_v3_v3(bbox_min, sds->p0);
992
993   if (sds->flags & MOD_SMOKE_ADAPTIVE_DOMAIN) {
994     bbox_min[0] += (sds->cell_size[0] * (float)sds->res_min[0]);
995     bbox_min[1] += (sds->cell_size[1] * (float)sds->res_min[1]);
996     bbox_min[2] += (sds->cell_size[2] * (float)sds->res_min[2]);
997     add_v3_v3(bbox_min, sds->obj_shift_f);
998   }
999
1000   /* construct low res matrix */
1001   size_to_mat4(sds->fluidmat, sds->cell_size);
1002   copy_v3_v3(sds->fluidmat[3], bbox_min);
1003
1004   /* The smoke simulator stores voxels cell-centered, whilst VDB is node
1005    * centered, so we offset the matrix by half a voxel to compensate. */
1006   madd_v3_v3fl(sds->fluidmat[3], sds->cell_size, 0.5f);
1007
1008   mul_m4_m4m4(sds->fluidmat, sds->obmat, sds->fluidmat);
1009
1010   if (sds->wt) {
1011     float voxel_size_high[3];
1012     /* construct high res matrix */
1013     mul_v3_v3fl(voxel_size_high, sds->cell_size, 1.0f / (float)(sds->amplify + 1));
1014     size_to_mat4(sds->fluidmat_wt, voxel_size_high);
1015     copy_v3_v3(sds->fluidmat_wt[3], bbox_min);
1016
1017     /* Same here, add half a voxel to adjust the position of the fluid. */
1018     madd_v3_v3fl(sds->fluidmat_wt[3], voxel_size_high, 0.5f);
1019
1020     mul_m4_m4m4(sds->fluidmat_wt, sds->obmat, sds->fluidmat_wt);
1021   }
1022 }
1023
1024 static int ptcache_smoke_openvdb_write(struct OpenVDBWriter *writer, void *smoke_v)
1025 {
1026   SmokeModifierData *smd = (SmokeModifierData *)smoke_v;
1027   SmokeDomainSettings *sds = smd->domain;
1028
1029   OpenVDBWriter_set_flags(writer, sds->openvdb_comp, (sds->data_depth == 16));
1030
1031   OpenVDBWriter_add_meta_int(writer, "blender/smoke/active_fields", sds->active_fields);
1032   OpenVDBWriter_add_meta_v3_int(writer, "blender/smoke/resolution", sds->res);
1033   OpenVDBWriter_add_meta_v3_int(writer, "blender/smoke/min_resolution", sds->res_min);
1034   OpenVDBWriter_add_meta_v3_int(writer, "blender/smoke/max_resolution", sds->res_max);
1035   OpenVDBWriter_add_meta_v3_int(writer, "blender/smoke/base_resolution", sds->base_res);
1036   OpenVDBWriter_add_meta_v3(writer, "blender/smoke/min_bbox", sds->p0);
1037   OpenVDBWriter_add_meta_v3(writer, "blender/smoke/max_bbox", sds->p1);
1038   OpenVDBWriter_add_meta_v3(writer, "blender/smoke/dp0", sds->dp0);
1039   OpenVDBWriter_add_meta_v3_int(writer, "blender/smoke/shift", sds->shift);
1040   OpenVDBWriter_add_meta_v3(writer, "blender/smoke/obj_shift_f", sds->obj_shift_f);
1041   OpenVDBWriter_add_meta_v3(writer, "blender/smoke/active_color", sds->active_color);
1042   OpenVDBWriter_add_meta_mat4(writer, "blender/smoke/obmat", sds->obmat);
1043
1044   int fluid_fields = BKE_smoke_get_data_flags(sds);
1045
1046   struct OpenVDBFloatGrid *clip_grid = NULL;
1047
1048   compute_fluid_matrices(sds);
1049
1050   OpenVDBWriter_add_meta_int(writer, "blender/smoke/fluid_fields", fluid_fields);
1051
1052   if (sds->wt) {
1053     struct OpenVDBFloatGrid *wt_density_grid;
1054     float *dens, *react, *fuel, *flame, *tcu, *tcv, *tcw, *r, *g, *b;
1055
1056     smoke_turbulence_export(sds->wt, &dens, &react, &flame, &fuel, &r, &g, &b, &tcu, &tcv, &tcw);
1057
1058     wt_density_grid = OpenVDB_export_grid_fl(
1059         writer, "density", dens, sds->res_wt, sds->fluidmat_wt, sds->clipping, NULL);
1060     clip_grid = wt_density_grid;
1061
1062     if (fluid_fields & SM_ACTIVE_FIRE) {
1063       OpenVDB_export_grid_fl(
1064           writer, "flame", flame, sds->res_wt, sds->fluidmat_wt, sds->clipping, wt_density_grid);
1065       OpenVDB_export_grid_fl(
1066           writer, "fuel", fuel, sds->res_wt, sds->fluidmat_wt, sds->clipping, wt_density_grid);
1067       OpenVDB_export_grid_fl(
1068           writer, "react", react, sds->res_wt, sds->fluidmat_wt, sds->clipping, wt_density_grid);
1069     }
1070
1071     if (fluid_fields & SM_ACTIVE_COLORS) {
1072       OpenVDB_export_grid_vec(writer,
1073                               "color",
1074                               r,
1075                               g,
1076                               b,
1077                               sds->res_wt,
1078                               sds->fluidmat_wt,
1079                               VEC_INVARIANT,
1080                               true,
1081                               sds->clipping,
1082                               wt_density_grid);
1083     }
1084
1085     OpenVDB_export_grid_vec(writer,
1086                             "texture coordinates",
1087                             tcu,
1088                             tcv,
1089                             tcw,
1090                             sds->res,
1091                             sds->fluidmat,
1092                             VEC_INVARIANT,
1093                             false,
1094                             sds->clipping,
1095                             wt_density_grid);
1096   }
1097
1098   if (sds->fluid) {
1099     struct OpenVDBFloatGrid *density_grid;
1100     float dt, dx, *dens, *react, *fuel, *flame, *heat, *heatold, *vx, *vy, *vz, *r, *g, *b;
1101     unsigned char *obstacles;
1102
1103     smoke_export(sds->fluid,
1104                  &dt,
1105                  &dx,
1106                  &dens,
1107                  &react,
1108                  &flame,
1109                  &fuel,
1110                  &heat,
1111                  &heatold,
1112                  &vx,
1113                  &vy,
1114                  &vz,
1115                  &r,
1116                  &g,
1117                  &b,
1118                  &obstacles);
1119
1120     OpenVDBWriter_add_meta_fl(writer, "blender/smoke/dx", dx);
1121     OpenVDBWriter_add_meta_fl(writer, "blender/smoke/dt", dt);
1122
1123     const char *name = (!sds->wt) ? "density" : "density_low";
1124     density_grid = OpenVDB_export_grid_fl(
1125         writer, name, dens, sds->res, sds->fluidmat, sds->clipping, NULL);
1126     clip_grid = sds->wt ? clip_grid : density_grid;
1127
1128     OpenVDB_export_grid_fl(
1129         writer, "shadow", sds->shadow, sds->res, sds->fluidmat, sds->clipping, NULL);
1130
1131     if (fluid_fields & SM_ACTIVE_HEAT) {
1132       OpenVDB_export_grid_fl(
1133           writer, "heat", heat, sds->res, sds->fluidmat, sds->clipping, clip_grid);
1134       OpenVDB_export_grid_fl(
1135           writer, "heat_old", heatold, sds->res, sds->fluidmat, sds->clipping, clip_grid);
1136     }
1137
1138     if (fluid_fields & SM_ACTIVE_FIRE) {
1139       name = (!sds->wt) ? "flame" : "flame_low";
1140       OpenVDB_export_grid_fl(
1141           writer, name, flame, sds->res, sds->fluidmat, sds->clipping, density_grid);
1142       name = (!sds->wt) ? "fuel" : "fuel_low";
1143       OpenVDB_export_grid_fl(
1144           writer, name, fuel, sds->res, sds->fluidmat, sds->clipping, density_grid);
1145       name = (!sds->wt) ? "react" : "react_low";
1146       OpenVDB_export_grid_fl(
1147           writer, name, react, sds->res, sds->fluidmat, sds->clipping, density_grid);
1148     }
1149
1150     if (fluid_fields & SM_ACTIVE_COLORS) {
1151       name = (!sds->wt) ? "color" : "color_low";
1152       OpenVDB_export_grid_vec(writer,
1153                               name,
1154                               r,
1155                               g,
1156                               b,
1157                               sds->res,
1158                               sds->fluidmat,
1159                               VEC_INVARIANT,
1160                               true,
1161                               sds->clipping,
1162                               density_grid);
1163     }
1164
1165     OpenVDB_export_grid_vec(writer,
1166                             "velocity",
1167                             vx,
1168                             vy,
1169                             vz,
1170                             sds->res,
1171                             sds->fluidmat,
1172                             VEC_CONTRAVARIANT_RELATIVE,
1173                             false,
1174                             sds->clipping,
1175                             clip_grid);
1176     OpenVDB_export_grid_ch(
1177         writer, "obstacles", obstacles, sds->res, sds->fluidmat, sds->clipping, NULL);
1178   }
1179
1180   return 1;
1181 }
1182
1183 static int ptcache_smoke_openvdb_read(struct OpenVDBReader *reader, void *smoke_v)
1184 {
1185   SmokeModifierData *smd = (SmokeModifierData *)smoke_v;
1186
1187   if (!smd) {
1188     return 0;
1189   }
1190
1191   SmokeDomainSettings *sds = smd->domain;
1192
1193   int fluid_fields = BKE_smoke_get_data_flags(sds);
1194   int active_fields, cache_fields = 0;
1195   int cache_res[3];
1196   float cache_dx;
1197   bool reallocate = false;
1198
1199   OpenVDBReader_get_meta_v3_int(reader, "blender/smoke/min_resolution", sds->res_min);
1200   OpenVDBReader_get_meta_v3_int(reader, "blender/smoke/max_resolution", sds->res_max);
1201   OpenVDBReader_get_meta_v3_int(reader, "blender/smoke/base_resolution", sds->base_res);
1202   OpenVDBReader_get_meta_v3(reader, "blender/smoke/min_bbox", sds->p0);
1203   OpenVDBReader_get_meta_v3(reader, "blender/smoke/max_bbox", sds->p1);
1204   OpenVDBReader_get_meta_v3(reader, "blender/smoke/dp0", sds->dp0);
1205   OpenVDBReader_get_meta_v3_int(reader, "blender/smoke/shift", sds->shift);
1206   OpenVDBReader_get_meta_v3(reader, "blender/smoke/obj_shift_f", sds->obj_shift_f);
1207   OpenVDBReader_get_meta_v3(reader, "blender/smoke/active_color", sds->active_color);
1208   OpenVDBReader_get_meta_mat4(reader, "blender/smoke/obmat", sds->obmat);
1209   OpenVDBReader_get_meta_int(reader, "blender/smoke/fluid_fields", &cache_fields);
1210   OpenVDBReader_get_meta_int(reader, "blender/smoke/active_fields", &active_fields);
1211   OpenVDBReader_get_meta_fl(reader, "blender/smoke/dx", &cache_dx);
1212   OpenVDBReader_get_meta_v3_int(reader, "blender/smoke/resolution", cache_res);
1213
1214   /* check if resolution has changed */
1215   if (sds->res[0] != cache_res[0] || sds->res[1] != cache_res[1] || sds->res[2] != cache_res[2]) {
1216     if (sds->flags & MOD_SMOKE_ADAPTIVE_DOMAIN) {
1217       reallocate = true;
1218     }
1219     else {
1220       return 0;
1221     }
1222   }
1223
1224   /* check if active fields have changed */
1225   if ((fluid_fields != cache_fields) || (active_fields != sds->active_fields)) {
1226     reallocate = true;
1227   }
1228
1229   /* reallocate fluid if needed*/
1230   if (reallocate) {
1231     sds->active_fields = active_fields | cache_fields;
1232     BKE_smoke_reallocate_fluid(sds, cache_dx, cache_res, 1);
1233     sds->dx = cache_dx;
1234     copy_v3_v3_int(sds->res, cache_res);
1235     sds->total_cells = cache_res[0] * cache_res[1] * cache_res[2];
1236
1237     if (sds->flags & MOD_SMOKE_HIGHRES) {
1238       BKE_smoke_reallocate_highres_fluid(sds, cache_dx, cache_res, 1);
1239     }
1240   }
1241
1242   if (sds->fluid) {
1243     float dt, dx, *dens, *react, *fuel, *flame, *heat, *heatold, *vx, *vy, *vz, *r, *g, *b;
1244     unsigned char *obstacles;
1245
1246     smoke_export(sds->fluid,
1247                  &dt,
1248                  &dx,
1249                  &dens,
1250                  &react,
1251                  &flame,
1252                  &fuel,
1253                  &heat,
1254                  &heatold,
1255                  &vx,
1256                  &vy,
1257                  &vz,
1258                  &r,
1259                  &g,
1260                  &b,
1261                  &obstacles);
1262
1263     OpenVDBReader_get_meta_fl(reader, "blender/smoke/dt", &dt);
1264
1265     OpenVDB_import_grid_fl(reader, "shadow", &sds->shadow, sds->res);
1266
1267     const char *name = (!sds->wt) ? "density" : "density_low";
1268     OpenVDB_import_grid_fl(reader, name, &dens, sds->res);
1269
1270     if (cache_fields & SM_ACTIVE_HEAT) {
1271       OpenVDB_import_grid_fl(reader, "heat", &heat, sds->res);
1272       OpenVDB_import_grid_fl(reader, "heat_old", &heatold, sds->res);
1273     }
1274
1275     if (cache_fields & SM_ACTIVE_FIRE) {
1276       name = (!sds->wt) ? "flame" : "flame_low";
1277       OpenVDB_import_grid_fl(reader, name, &flame, sds->res);
1278       name = (!sds->wt) ? "fuel" : "fuel_low";
1279       OpenVDB_import_grid_fl(reader, name, &fuel, sds->res);
1280       name = (!sds->wt) ? "react" : "react_low";
1281       OpenVDB_import_grid_fl(reader, name, &react, sds->res);
1282     }
1283
1284     if (cache_fields & SM_ACTIVE_COLORS) {
1285       name = (!sds->wt) ? "color" : "color_low";
1286       OpenVDB_import_grid_vec(reader, name, &r, &g, &b, sds->res);
1287     }
1288
1289     OpenVDB_import_grid_vec(reader, "velocity", &vx, &vy, &vz, sds->res);
1290     OpenVDB_import_grid_ch(reader, "obstacles", &obstacles, sds->res);
1291   }
1292
1293   if (sds->wt) {
1294     float *dens, *react, *fuel, *flame, *tcu, *tcv, *tcw, *r, *g, *b;
1295
1296     smoke_turbulence_export(sds->wt, &dens, &react, &flame, &fuel, &r, &g, &b, &tcu, &tcv, &tcw);
1297
1298     OpenVDB_import_grid_fl(reader, "density", &dens, sds->res_wt);
1299
1300     if (cache_fields & SM_ACTIVE_FIRE) {
1301       OpenVDB_import_grid_fl(reader, "flame", &flame, sds->res_wt);
1302       OpenVDB_import_grid_fl(reader, "fuel", &fuel, sds->res_wt);
1303       OpenVDB_import_grid_fl(reader, "react", &react, sds->res_wt);
1304     }
1305
1306     if (cache_fields & SM_ACTIVE_COLORS) {
1307       OpenVDB_import_grid_vec(reader, "color", &r, &g, &b, sds->res_wt);
1308     }
1309
1310     OpenVDB_import_grid_vec(reader, "texture coordinates", &tcu, &tcv, &tcw, sds->res);
1311   }
1312
1313   OpenVDBReader_free(reader);
1314
1315   return 1;
1316 }
1317 #  endif
1318
1319 #else   // WITH_SMOKE
1320 static int ptcache_smoke_totpoint(void *UNUSED(smoke_v), int UNUSED(cfra))
1321 {
1322   return 0;
1323 }
1324 static void ptcache_smoke_error(void *UNUSED(smoke_v), const char *UNUSED(message))
1325 {
1326 }
1327 static int ptcache_smoke_read(PTCacheFile *UNUSED(pf), void *UNUSED(smoke_v))
1328 {
1329   return 0;
1330 }
1331 static int ptcache_smoke_write(PTCacheFile *UNUSED(pf), void *UNUSED(smoke_v))
1332 {
1333   return 0;
1334 }
1335 #endif  // WITH_SMOKE
1336
1337 #if !defined(WITH_SMOKE) || !defined(WITH_OPENVDB)
1338 static int ptcache_smoke_openvdb_write(struct OpenVDBWriter *writer, void *smoke_v)
1339 {
1340   UNUSED_VARS(writer, smoke_v);
1341   return 0;
1342 }
1343
1344 static int ptcache_smoke_openvdb_read(struct OpenVDBReader *reader, void *smoke_v)
1345 {
1346   UNUSED_VARS(reader, smoke_v);
1347   return 0;
1348 }
1349 #endif
1350
1351 static int ptcache_dynamicpaint_totpoint(void *sd, int UNUSED(cfra))
1352 {
1353   DynamicPaintSurface *surface = (DynamicPaintSurface *)sd;
1354
1355   if (!surface->data) {
1356     return 0;
1357   }
1358   else {
1359     return surface->data->total_points;
1360   }
1361 }
1362
1363 static void ptcache_dynamicpaint_error(void *UNUSED(sd), const char *UNUSED(message))
1364 {
1365   /* ignored for now */
1366 }
1367
1368 #define DPAINT_CACHE_VERSION "1.01"
1369
1370 static int ptcache_dynamicpaint_write(PTCacheFile *pf, void *dp_v)
1371 {
1372   DynamicPaintSurface *surface = (DynamicPaintSurface *)dp_v;
1373   int cache_compress = 1;
1374
1375   /* version header */
1376   ptcache_file_write(pf, DPAINT_CACHE_VERSION, 1, sizeof(char) * 4);
1377
1378   if (surface->format != MOD_DPAINT_SURFACE_F_IMAGESEQ && surface->data) {
1379     int total_points = surface->data->total_points;
1380     unsigned int in_len;
1381     unsigned char *out;
1382
1383     /* cache type */
1384     ptcache_file_write(pf, &surface->type, 1, sizeof(int));
1385
1386     if (surface->type == MOD_DPAINT_SURFACE_T_PAINT) {
1387       in_len = sizeof(PaintPoint) * total_points;
1388     }
1389     else if (surface->type == MOD_DPAINT_SURFACE_T_DISPLACE ||
1390              surface->type == MOD_DPAINT_SURFACE_T_WEIGHT) {
1391       in_len = sizeof(float) * total_points;
1392     }
1393     else if (surface->type == MOD_DPAINT_SURFACE_T_WAVE) {
1394       in_len = sizeof(PaintWavePoint) * total_points;
1395     }
1396     else {
1397       return 0;
1398     }
1399
1400     out = (unsigned char *)MEM_callocN(LZO_OUT_LEN(in_len), "pointcache_lzo_buffer");
1401
1402     ptcache_file_compressed_write(
1403         pf, (unsigned char *)surface->data->type_data, in_len, out, cache_compress);
1404     MEM_freeN(out);
1405   }
1406   return 1;
1407 }
1408 static int ptcache_dynamicpaint_read(PTCacheFile *pf, void *dp_v)
1409 {
1410   DynamicPaintSurface *surface = (DynamicPaintSurface *)dp_v;
1411   char version[4];
1412
1413   /* version header */
1414   ptcache_file_read(pf, version, 1, sizeof(char) * 4);
1415   if (!STREQLEN(version, DPAINT_CACHE_VERSION, 4)) {
1416     CLOG_ERROR(&LOG, "Dynamic Paint: Invalid cache version: '%c%c%c%c'!", UNPACK4(version));
1417     return 0;
1418   }
1419
1420   if (surface->format != MOD_DPAINT_SURFACE_F_IMAGESEQ && surface->data) {
1421     unsigned int data_len;
1422     int surface_type;
1423
1424     /* cache type */
1425     ptcache_file_read(pf, &surface_type, 1, sizeof(int));
1426
1427     if (surface_type != surface->type) {
1428       return 0;
1429     }
1430
1431     /* read surface data */
1432     if (surface->type == MOD_DPAINT_SURFACE_T_PAINT) {
1433       data_len = sizeof(PaintPoint);
1434     }
1435     else if (surface->type == MOD_DPAINT_SURFACE_T_DISPLACE ||
1436              surface->type == MOD_DPAINT_SURFACE_T_WEIGHT) {
1437       data_len = sizeof(float);
1438     }
1439     else if (surface->type == MOD_DPAINT_SURFACE_T_WAVE) {
1440       data_len = sizeof(PaintWavePoint);
1441     }
1442     else {
1443       return 0;
1444     }
1445
1446     ptcache_file_compressed_read(
1447         pf, (unsigned char *)surface->data->type_data, data_len * surface->data->total_points);
1448   }
1449   return 1;
1450 }
1451
1452 /* Rigid Body functions */
1453 static int ptcache_rigidbody_write(int index, void *rb_v, void **data, int UNUSED(cfra))
1454 {
1455   RigidBodyWorld *rbw = rb_v;
1456   Object *ob = NULL;
1457
1458   if (rbw->objects) {
1459     ob = rbw->objects[index];
1460   }
1461
1462   if (ob && ob->rigidbody_object) {
1463     RigidBodyOb *rbo = ob->rigidbody_object;
1464
1465     if (rbo->type == RBO_TYPE_ACTIVE) {
1466 #ifdef WITH_BULLET
1467       RB_body_get_position(rbo->shared->physics_object, rbo->pos);
1468       RB_body_get_orientation(rbo->shared->physics_object, rbo->orn);
1469 #endif
1470       PTCACHE_DATA_FROM(data, BPHYS_DATA_LOCATION, rbo->pos);
1471       PTCACHE_DATA_FROM(data, BPHYS_DATA_ROTATION, rbo->orn);
1472     }
1473   }
1474
1475   return 1;
1476 }
1477 static void ptcache_rigidbody_read(
1478     int index, void *rb_v, void **data, float UNUSED(cfra), float *old_data)
1479 {
1480   RigidBodyWorld *rbw = rb_v;
1481   Object *ob = NULL;
1482
1483   if (rbw->objects) {
1484     ob = rbw->objects[index];
1485   }
1486
1487   if (ob && ob->rigidbody_object) {
1488     RigidBodyOb *rbo = ob->rigidbody_object;
1489
1490     if (rbo->type == RBO_TYPE_ACTIVE) {
1491
1492       if (old_data) {
1493         memcpy(rbo->pos, data, 3 * sizeof(float));
1494         memcpy(rbo->orn, data + 3, 4 * sizeof(float));
1495       }
1496       else {
1497         PTCACHE_DATA_TO(data, BPHYS_DATA_LOCATION, 0, rbo->pos);
1498         PTCACHE_DATA_TO(data, BPHYS_DATA_ROTATION, 0, rbo->orn);
1499       }
1500     }
1501   }
1502 }
1503 static void ptcache_rigidbody_interpolate(
1504     int index, void *rb_v, void **data, float cfra, float cfra1, float cfra2, float *old_data)
1505 {
1506   RigidBodyWorld *rbw = rb_v;
1507   Object *ob = NULL;
1508
1509   if (rbw->objects) {
1510     ob = rbw->objects[index];
1511   }
1512
1513   if (ob && ob->rigidbody_object) {
1514     RigidBodyOb *rbo = ob->rigidbody_object;
1515
1516     if (rbo->type == RBO_TYPE_ACTIVE) {
1517       ParticleKey keys[4];
1518       ParticleKey result;
1519       float dfra;
1520
1521       memset(keys, 0, sizeof(keys));
1522
1523       copy_v3_v3(keys[1].co, rbo->pos);
1524       copy_qt_qt(keys[1].rot, rbo->orn);
1525
1526       if (old_data) {
1527         memcpy(keys[2].co, data, 3 * sizeof(float));
1528         memcpy(keys[2].rot, data + 3, 4 * sizeof(float));
1529       }
1530       else {
1531         BKE_ptcache_make_particle_key(&keys[2], 0, data, cfra2);
1532       }
1533
1534       dfra = cfra2 - cfra1;
1535
1536       /* note: keys[0] and keys[3] unused for type < 1 (crappy) */
1537       psys_interpolate_particle(-1, keys, (cfra - cfra1) / dfra, &result, true);
1538       interp_qt_qtqt(result.rot, keys[1].rot, keys[2].rot, (cfra - cfra1) / dfra);
1539
1540       copy_v3_v3(rbo->pos, result.co);
1541       copy_qt_qt(rbo->orn, result.rot);
1542     }
1543   }
1544 }
1545 static int ptcache_rigidbody_totpoint(void *rb_v, int UNUSED(cfra))
1546 {
1547   RigidBodyWorld *rbw = rb_v;
1548
1549   return rbw->numbodies;
1550 }
1551
1552 static void ptcache_rigidbody_error(void *UNUSED(rb_v), const char *UNUSED(message))
1553 {
1554   /* ignored for now */
1555 }
1556
1557 /* Creating ID's */
1558 void BKE_ptcache_id_from_softbody(PTCacheID *pid, Object *ob, SoftBody *sb)
1559 {
1560   memset(pid, 0, sizeof(PTCacheID));
1561
1562   pid->ob = ob;
1563   pid->calldata = sb;
1564   pid->type = PTCACHE_TYPE_SOFTBODY;
1565   pid->cache = sb->shared->pointcache;
1566   pid->cache_ptr = &sb->shared->pointcache;
1567   pid->ptcaches = &sb->shared->ptcaches;
1568   pid->totpoint = pid->totwrite = ptcache_softbody_totpoint;
1569   pid->error = ptcache_softbody_error;
1570
1571   pid->write_point = ptcache_softbody_write;
1572   pid->read_point = ptcache_softbody_read;
1573   pid->interpolate_point = ptcache_softbody_interpolate;
1574
1575   pid->write_stream = NULL;
1576   pid->read_stream = NULL;
1577
1578   pid->write_openvdb_stream = NULL;
1579   pid->read_openvdb_stream = NULL;
1580
1581   pid->write_extra_data = NULL;
1582   pid->read_extra_data = NULL;
1583   pid->interpolate_extra_data = NULL;
1584
1585   pid->write_header = ptcache_basic_header_write;
1586   pid->read_header = ptcache_basic_header_read;
1587
1588   pid->data_types = (1 << BPHYS_DATA_LOCATION) | (1 << BPHYS_DATA_VELOCITY);
1589   pid->info_types = 0;
1590
1591   pid->stack_index = pid->cache->index;
1592
1593   pid->default_step = 10;
1594   pid->max_step = 20;
1595   pid->file_type = PTCACHE_FILE_PTCACHE;
1596 }
1597 void BKE_ptcache_id_from_particles(PTCacheID *pid, Object *ob, ParticleSystem *psys)
1598 {
1599   memset(pid, 0, sizeof(PTCacheID));
1600
1601   pid->ob = ob;
1602   pid->calldata = psys;
1603   pid->type = PTCACHE_TYPE_PARTICLES;
1604   pid->stack_index = psys->pointcache->index;
1605   pid->cache = psys->pointcache;
1606   pid->cache_ptr = &psys->pointcache;
1607   pid->ptcaches = &psys->ptcaches;
1608
1609   if (psys->part->type != PART_HAIR) {
1610     pid->flag |= PTCACHE_VEL_PER_SEC;
1611   }
1612
1613   pid->totpoint = ptcache_particle_totpoint;
1614   pid->totwrite = ptcache_particle_totwrite;
1615   pid->error = ptcache_particle_error;
1616
1617   pid->write_point = ptcache_particle_write;
1618   pid->read_point = ptcache_particle_read;
1619   pid->interpolate_point = ptcache_particle_interpolate;
1620
1621   pid->write_stream = NULL;
1622   pid->read_stream = NULL;
1623
1624   pid->write_openvdb_stream = NULL;
1625   pid->read_openvdb_stream = NULL;
1626
1627   pid->write_extra_data = NULL;
1628   pid->read_extra_data = NULL;
1629   pid->interpolate_extra_data = NULL;
1630
1631   pid->write_header = ptcache_basic_header_write;
1632   pid->read_header = ptcache_basic_header_read;
1633
1634   pid->data_types = (1 << BPHYS_DATA_LOCATION) | (1 << BPHYS_DATA_VELOCITY) |
1635                     (1 << BPHYS_DATA_INDEX);
1636
1637   if (psys->part->phystype == PART_PHYS_BOIDS) {
1638     pid->data_types |= (1 << BPHYS_DATA_AVELOCITY) | (1 << BPHYS_DATA_ROTATION) |
1639                        (1 << BPHYS_DATA_BOIDS);
1640   }
1641   else if (psys->part->phystype == PART_PHYS_FLUID && psys->part->fluid &&
1642            psys->part->fluid->flag & SPH_VISCOELASTIC_SPRINGS) {
1643     pid->write_extra_data = ptcache_particle_extra_write;
1644     pid->read_extra_data = ptcache_particle_extra_read;
1645   }
1646
1647   if (psys->part->flag & PART_ROTATIONS) {
1648     pid->data_types |= (1 << BPHYS_DATA_ROTATION);
1649
1650     if (psys->part->rotmode != PART_ROT_VEL || psys->part->avemode == PART_AVE_RAND ||
1651         psys->part->avefac != 0.0f) {
1652       pid->data_types |= (1 << BPHYS_DATA_AVELOCITY);
1653     }
1654   }
1655
1656   pid->info_types = (1 << BPHYS_DATA_TIMES);
1657
1658   pid->default_step = 10;
1659   pid->max_step = 20;
1660   pid->file_type = PTCACHE_FILE_PTCACHE;
1661 }
1662 void BKE_ptcache_id_from_cloth(PTCacheID *pid, Object *ob, ClothModifierData *clmd)
1663 {
1664   memset(pid, 0, sizeof(PTCacheID));
1665
1666   pid->ob = ob;
1667   pid->calldata = clmd;
1668   pid->type = PTCACHE_TYPE_CLOTH;
1669   pid->stack_index = clmd->point_cache->index;
1670   pid->cache = clmd->point_cache;
1671   pid->cache_ptr = &clmd->point_cache;
1672   pid->ptcaches = &clmd->ptcaches;
1673   pid->totpoint = pid->totwrite = ptcache_cloth_totpoint;
1674   pid->error = ptcache_cloth_error;
1675
1676   pid->write_point = ptcache_cloth_write;
1677   pid->read_point = ptcache_cloth_read;
1678   pid->interpolate_point = ptcache_cloth_interpolate;
1679
1680   pid->write_openvdb_stream = NULL;
1681   pid->read_openvdb_stream = NULL;
1682
1683   pid->write_stream = NULL;
1684   pid->read_stream = NULL;
1685
1686   pid->write_extra_data = NULL;
1687   pid->read_extra_data = NULL;
1688   pid->interpolate_extra_data = NULL;
1689
1690   pid->write_header = ptcache_basic_header_write;
1691   pid->read_header = ptcache_basic_header_read;
1692
1693   pid->data_types = (1 << BPHYS_DATA_LOCATION) | (1 << BPHYS_DATA_VELOCITY) |
1694                     (1 << BPHYS_DATA_XCONST);
1695   pid->info_types = 0;
1696
1697   pid->default_step = 1;
1698   pid->max_step = 1;
1699   pid->file_type = PTCACHE_FILE_PTCACHE;
1700 }
1701 void BKE_ptcache_id_from_smoke(PTCacheID *pid, struct Object *ob, struct SmokeModifierData *smd)
1702 {
1703   SmokeDomainSettings *sds = smd->domain;
1704
1705   memset(pid, 0, sizeof(PTCacheID));
1706
1707   pid->ob = ob;
1708   pid->calldata = smd;
1709
1710   pid->type = PTCACHE_TYPE_SMOKE_DOMAIN;
1711   pid->stack_index = sds->point_cache[0]->index;
1712
1713   pid->cache = sds->point_cache[0];
1714   pid->cache_ptr = &(sds->point_cache[0]);
1715   pid->ptcaches = &(sds->ptcaches[0]);
1716
1717   pid->totpoint = pid->totwrite = ptcache_smoke_totpoint;
1718   pid->error = ptcache_smoke_error;
1719
1720   pid->write_point = NULL;
1721   pid->read_point = NULL;
1722   pid->interpolate_point = NULL;
1723
1724   pid->read_stream = ptcache_smoke_read;
1725   pid->write_stream = ptcache_smoke_write;
1726
1727   pid->write_openvdb_stream = ptcache_smoke_openvdb_write;
1728   pid->read_openvdb_stream = ptcache_smoke_openvdb_read;
1729
1730   pid->write_extra_data = NULL;
1731   pid->read_extra_data = NULL;
1732   pid->interpolate_extra_data = NULL;
1733
1734   pid->write_header = ptcache_basic_header_write;
1735   pid->read_header = ptcache_basic_header_read;
1736
1737   pid->data_types = 0;
1738   pid->info_types = 0;
1739
1740   if (sds->fluid) {
1741     pid->data_types |= (1 << BPHYS_DATA_SMOKE_LOW);
1742   }
1743   if (sds->wt) {
1744     pid->data_types |= (1 << BPHYS_DATA_SMOKE_HIGH);
1745   }
1746
1747   pid->default_step = 1;
1748   pid->max_step = 1;
1749   pid->file_type = smd->domain->cache_file_format;
1750 }
1751
1752 void BKE_ptcache_id_from_dynamicpaint(PTCacheID *pid, Object *ob, DynamicPaintSurface *surface)
1753 {
1754
1755   memset(pid, 0, sizeof(PTCacheID));
1756
1757   pid->ob = ob;
1758   pid->calldata = surface;
1759   pid->type = PTCACHE_TYPE_DYNAMICPAINT;
1760   pid->cache = surface->pointcache;
1761   pid->cache_ptr = &surface->pointcache;
1762   pid->ptcaches = &surface->ptcaches;
1763   pid->totpoint = pid->totwrite = ptcache_dynamicpaint_totpoint;
1764   pid->error = ptcache_dynamicpaint_error;
1765
1766   pid->write_point = NULL;
1767   pid->read_point = NULL;
1768   pid->interpolate_point = NULL;
1769
1770   pid->write_stream = ptcache_dynamicpaint_write;
1771   pid->read_stream = ptcache_dynamicpaint_read;
1772
1773   pid->write_openvdb_stream = NULL;
1774   pid->read_openvdb_stream = NULL;
1775
1776   pid->write_extra_data = NULL;
1777   pid->read_extra_data = NULL;
1778   pid->interpolate_extra_data = NULL;
1779
1780   pid->write_header = ptcache_basic_header_write;
1781   pid->read_header = ptcache_basic_header_read;
1782
1783   pid->data_types = BPHYS_DATA_DYNAMICPAINT;
1784   pid->info_types = 0;
1785
1786   pid->stack_index = pid->cache->index;
1787
1788   pid->default_step = 1;
1789   pid->max_step = 1;
1790   pid->file_type = PTCACHE_FILE_PTCACHE;
1791 }
1792
1793 void BKE_ptcache_id_from_rigidbody(PTCacheID *pid, Object *ob, RigidBodyWorld *rbw)
1794 {
1795
1796   memset(pid, 0, sizeof(PTCacheID));
1797
1798   pid->ob = ob;
1799   pid->calldata = rbw;
1800   pid->type = PTCACHE_TYPE_RIGIDBODY;
1801   pid->cache = rbw->shared->pointcache;
1802   pid->cache_ptr = &rbw->shared->pointcache;
1803   pid->ptcaches = &rbw->shared->ptcaches;
1804   pid->totpoint = pid->totwrite = ptcache_rigidbody_totpoint;
1805   pid->error = ptcache_rigidbody_error;
1806
1807   pid->write_point = ptcache_rigidbody_write;
1808   pid->read_point = ptcache_rigidbody_read;
1809   pid->interpolate_point = ptcache_rigidbody_interpolate;
1810
1811   pid->write_stream = NULL;
1812   pid->read_stream = NULL;
1813
1814   pid->write_openvdb_stream = NULL;
1815   pid->read_openvdb_stream = NULL;
1816
1817   pid->write_extra_data = NULL;
1818   pid->read_extra_data = NULL;
1819   pid->interpolate_extra_data = NULL;
1820
1821   pid->write_header = ptcache_basic_header_write;
1822   pid->read_header = ptcache_basic_header_read;
1823
1824   pid->data_types = (1 << BPHYS_DATA_LOCATION) | (1 << BPHYS_DATA_ROTATION);
1825   pid->info_types = 0;
1826
1827   pid->stack_index = pid->cache->index;
1828
1829   pid->default_step = 1;
1830   pid->max_step = 1;
1831   pid->file_type = PTCACHE_FILE_PTCACHE;
1832 }
1833
1834 PTCacheID BKE_ptcache_id_find(Object *ob, Scene *scene, PointCache *cache)
1835 {
1836   PTCacheID result = {0};
1837
1838   ListBase pidlist;
1839   BKE_ptcache_ids_from_object(&pidlist, ob, scene, MAX_DUPLI_RECUR);
1840
1841   for (PTCacheID *pid = pidlist.first; pid; pid = pid->next) {
1842     if (pid->cache == cache) {
1843       result = *pid;
1844       break;
1845     }
1846   }
1847
1848   BLI_freelistN(&pidlist);
1849
1850   return result;
1851 }
1852
1853 /* Callback which is used by point cache foreach() family of functions.
1854  *
1855  * Receives ID of the point cache.
1856  *
1857  * NOTE: This ID is owned by foreach() routines and can not be used outside of
1858  * the foreach loop. This means that if one wants to store them those are to be
1859  * malloced and copied over.
1860  *
1861  * If the function returns false, then foreach() loop aborts.
1862  */
1863 typedef bool (*ForeachPtcacheCb)(PTCacheID *pid, void *userdata);
1864
1865 static bool foreach_object_particle_ptcache(Object *object,
1866                                             ForeachPtcacheCb callback,
1867                                             void *callback_user_data)
1868 {
1869   PTCacheID pid;
1870   for (ParticleSystem *psys = object->particlesystem.first; psys != NULL; psys = psys->next) {
1871     if (psys->part == NULL) {
1872       continue;
1873     }
1874     /* Check to make sure point cache is actually used by the particles. */
1875     if (ELEM(psys->part->phystype, PART_PHYS_NO, PART_PHYS_KEYED)) {
1876       continue;
1877     }
1878     /* Hair needs to be included in id-list for cache edit mode to work. */
1879 #if 0
1880     if ((psys->part->type == PART_HAIR) && (psys->flag & PSYS_HAIR_DYNAMICS) == 0) {
1881       continue;
1882     }
1883 #endif
1884     if (psys->part->type == PART_FLUID) {
1885       continue;
1886     }
1887     BKE_ptcache_id_from_particles(&pid, object, psys);
1888     if (!callback(&pid, callback_user_data)) {
1889       return false;
1890     }
1891   }
1892   return true;
1893 }
1894
1895 static bool foreach_object_modifier_ptcache(Object *object,
1896                                             ForeachPtcacheCb callback,
1897                                             void *callback_user_data)
1898 {
1899   PTCacheID pid;
1900   for (ModifierData *md = object->modifiers.first; md != NULL; md = md->next) {
1901     if (md->type == eModifierType_Cloth) {
1902       BKE_ptcache_id_from_cloth(&pid, object, (ClothModifierData *)md);
1903       if (!callback(&pid, callback_user_data)) {
1904         return false;
1905       }
1906     }
1907     else if (md->type == eModifierType_Smoke) {
1908       SmokeModifierData *smd = (SmokeModifierData *)md;
1909       if (smd->type & MOD_SMOKE_TYPE_DOMAIN) {
1910         BKE_ptcache_id_from_smoke(&pid, object, (SmokeModifierData *)md);
1911         if (!callback(&pid, callback_user_data)) {
1912           return false;
1913         }
1914       }
1915     }
1916     else if (md->type == eModifierType_DynamicPaint) {
1917       DynamicPaintModifierData *pmd = (DynamicPaintModifierData *)md;
1918       if (pmd->canvas) {
1919         DynamicPaintSurface *surface = pmd->canvas->surfaces.first;
1920         for (; surface; surface = surface->next) {
1921           BKE_ptcache_id_from_dynamicpaint(&pid, object, surface);
1922           if (!callback(&pid, callback_user_data)) {
1923             return false;
1924           }
1925         }
1926       }
1927     }
1928   }
1929   return true;
1930 }
1931
1932 /* Return false if any of callbacks returned false. */
1933 static bool foreach_object_ptcache(
1934     Scene *scene, Object *object, int duplis, ForeachPtcacheCb callback, void *callback_user_data)
1935 {
1936   PTCacheID pid;
1937   /* Soft body. */
1938   if (object->soft != NULL) {
1939     BKE_ptcache_id_from_softbody(&pid, object, object->soft);
1940     if (!callback(&pid, callback_user_data)) {
1941       return false;
1942     }
1943   }
1944   /* Particle systems. */
1945   if (!foreach_object_particle_ptcache(object, callback, callback_user_data)) {
1946     return false;
1947   }
1948   /* Modifiers. */
1949   if (!foreach_object_modifier_ptcache(object, callback, callback_user_data)) {
1950     return false;
1951   }
1952   /* Rigid body. */
1953   if (scene != NULL && object->rigidbody_object != NULL && scene->rigidbody_world != NULL) {
1954     BKE_ptcache_id_from_rigidbody(&pid, object, scene->rigidbody_world);
1955     if (!callback(&pid, callback_user_data)) {
1956       return false;
1957     }
1958   }
1959   /* Consider all object in dupli groups to be part of the same object,
1960    * for baking with linking dupligroups. Once we have better overrides
1961    * this can be revisited so users select the local objects directly. */
1962   if (scene != NULL && (duplis-- > 0) && (object->instance_collection != NULL)) {
1963     FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN (object->instance_collection, current_object) {
1964       if (current_object == object) {
1965         continue;
1966       }
1967       foreach_object_ptcache(scene, current_object, duplis, callback, callback_user_data);
1968     }
1969     FOREACH_COLLECTION_OBJECT_RECURSIVE_END;
1970   }
1971   return true;
1972 }
1973
1974 typedef struct PTCacheIDsFromObjectData {
1975   ListBase *list_base;
1976 } PTCacheIDsFromObjectData;
1977
1978 static bool ptcache_ids_from_object_cb(PTCacheID *pid, void *userdata)
1979 {
1980   PTCacheIDsFromObjectData *data = userdata;
1981   PTCacheID *own_pid = MEM_mallocN(sizeof(PTCacheID), "PTCacheID");
1982   *own_pid = *pid;
1983   BLI_addtail(data->list_base, own_pid);
1984   return true;
1985 }
1986
1987 void BKE_ptcache_ids_from_object(ListBase *lb, Object *ob, Scene *scene, int duplis)
1988 {
1989   PTCacheIDsFromObjectData data;
1990   lb->first = lb->last = NULL;
1991   data.list_base = lb;
1992   foreach_object_ptcache(scene, ob, duplis, ptcache_ids_from_object_cb, &data);
1993 }
1994
1995 static bool ptcache_object_has_cb(PTCacheID *UNUSED(pid), void *UNUSED(userdata))
1996 {
1997   return false;
1998 }
1999
2000 bool BKE_ptcache_object_has(struct Scene *scene, struct Object *ob, int duplis)
2001 {
2002   return !foreach_object_ptcache(scene, ob, duplis, ptcache_object_has_cb, NULL);
2003 }
2004
2005 /* File handling */
2006
2007 static const char *ptcache_file_extension(const PTCacheID *pid)
2008 {
2009   switch (pid->file_type) {
2010     default:
2011     case PTCACHE_FILE_PTCACHE:
2012       return PTCACHE_EXT;
2013     case PTCACHE_FILE_OPENVDB:
2014       return ".vdb";
2015   }
2016 }
2017
2018 /**
2019  * Similar to #BLI_path_frame_get, but takes into account the stack-index which is after the frame.
2020  */
2021 static int ptcache_frame_from_filename(const char *filename, const char *ext)
2022 {
2023   const int frame_len = 6;
2024   const int ext_len = frame_len + strlen(ext);
2025   const int len = strlen(filename);
2026
2027   /* could crash if trying to copy a string out of this range */
2028   if (len > ext_len) {
2029     /* using frame_len here gives compile error (vla) */
2030     char num[/* frame_len */ 6 + 1];
2031     BLI_strncpy(num, filename + len - ext_len, sizeof(num));
2032
2033     return atoi(num);
2034   }
2035
2036   return -1;
2037 }
2038
2039 /* Takes an Object ID and returns a unique name
2040  * - id: object id
2041  * - cfra: frame for the cache, can be negative
2042  * - stack_index: index in the modifier stack. we can have cache for more than one stack_index
2043  */
2044
2045 #define MAX_PTCACHE_PATH FILE_MAX
2046 #define MAX_PTCACHE_FILE (FILE_MAX * 2)
2047
2048 static int ptcache_path(PTCacheID *pid, char *filename)
2049 {
2050   Library *lib = (pid->ob) ? pid->ob->id.lib : NULL;
2051   const char *blendfilename = (lib && (pid->cache->flag & PTCACHE_IGNORE_LIBPATH) == 0) ?
2052                                   lib->filepath :
2053                                   BKE_main_blendfile_path_from_global();
2054   size_t i;
2055
2056   if (pid->cache->flag & PTCACHE_EXTERNAL) {
2057     strcpy(filename, pid->cache->path);
2058
2059     if (BLI_path_is_rel(filename)) {
2060       BLI_path_abs(filename, blendfilename);
2061     }
2062
2063     return BLI_add_slash(filename); /* new strlen() */
2064   }
2065   else if (G.relbase_valid || lib) {
2066     char file[MAX_PTCACHE_PATH]; /* we don't want the dir, only the file */
2067
2068     BLI_split_file_part(blendfilename, file, sizeof(file));
2069     i = strlen(file);
2070
2071     /* remove .blend */
2072     if (i > 6) {
2073       file[i - 6] = '\0';
2074     }
2075
2076     BLI_snprintf(filename,
2077                  MAX_PTCACHE_PATH,
2078                  "//" PTCACHE_PATH "%s",
2079                  file); /* add blend file name to pointcache dir */
2080     BLI_path_abs(filename, blendfilename);
2081     return BLI_add_slash(filename); /* new strlen() */
2082   }
2083
2084   /* use the temp path. this is weak but better then not using point cache at all */
2085   /* temporary directory is assumed to exist and ALWAYS has a trailing slash */
2086   BLI_snprintf(filename, MAX_PTCACHE_PATH, "%s" PTCACHE_PATH, BKE_tempdir_session());
2087
2088   return BLI_add_slash(filename); /* new strlen() */
2089 }
2090
2091 static int ptcache_filename(PTCacheID *pid, char *filename, int cfra, short do_path, short do_ext)
2092 {
2093   int len = 0;
2094   char *idname;
2095   char *newname;
2096   filename[0] = '\0';
2097   newname = filename;
2098
2099   if (!G.relbase_valid && (pid->cache->flag & PTCACHE_EXTERNAL) == 0) {
2100     return 0; /* save blend file before using disk pointcache */
2101   }
2102
2103   /* start with temp dir */
2104   if (do_path) {
2105     len = ptcache_path(pid, filename);
2106     newname += len;
2107   }
2108   if (pid->cache->name[0] == '\0' && (pid->cache->flag & PTCACHE_EXTERNAL) == 0) {
2109     idname = (pid->ob->id.name + 2);
2110     /* convert chars to hex so they are always a valid filename */
2111     while ('\0' != *idname) {
2112       BLI_snprintf(newname, MAX_PTCACHE_FILE, "%02X", (unsigned int)(*idname++));
2113       newname += 2;
2114       len += 2;
2115     }
2116   }
2117   else {
2118     int temp = (int)strlen(pid->cache->name);
2119     strcpy(newname, pid->cache->name);
2120     newname += temp;
2121     len += temp;
2122   }
2123
2124   if (do_ext) {
2125     if (pid->cache->index < 0) {
2126       pid->cache->index = pid->stack_index = BKE_object_insert_ptcache(pid->ob);
2127     }
2128
2129     const char *ext = ptcache_file_extension(pid);
2130
2131     if (pid->cache->flag & PTCACHE_EXTERNAL) {
2132       if (pid->cache->index >= 0) {
2133         BLI_snprintf(newname,
2134                      MAX_PTCACHE_FILE,
2135                      "_%06d_%02u%s",
2136                      cfra,
2137                      pid->stack_index,
2138                      ext); /* always 6 chars */
2139       }
2140       else {
2141         BLI_snprintf(newname, MAX_PTCACHE_FILE, "_%06d%s", cfra, ext); /* always 6 chars */
2142       }
2143     }
2144     else {
2145       BLI_snprintf(newname,
2146                    MAX_PTCACHE_FILE,
2147                    "_%06d_%02u%s",
2148                    cfra,
2149                    pid->stack_index,
2150                    ext); /* always 6 chars */
2151     }
2152     len += 16;
2153   }
2154
2155   return len; /* make sure the above string is always 16 chars */
2156 }
2157
2158 /* youll need to close yourself after! */
2159 static PTCacheFile *ptcache_file_open(PTCacheID *pid, int mode, int cfra)
2160 {
2161   PTCacheFile *pf;
2162   FILE *fp = NULL;
2163   char filename[FILE_MAX * 2];
2164
2165 #ifndef DURIAN_POINTCACHE_LIB_OK
2166   /* don't allow writing for linked objects */
2167   if (pid->ob->id.lib && mode == PTCACHE_FILE_WRITE) {
2168     return NULL;
2169   }
2170 #endif
2171   if (!G.relbase_valid && (pid->cache->flag & PTCACHE_EXTERNAL) == 0) {
2172     return NULL; /* save blend file before using disk pointcache */
2173   }
2174
2175   ptcache_filename(pid, filename, cfra, 1, 1);
2176
2177   if (mode == PTCACHE_FILE_READ) {
2178     fp = BLI_fopen(filename, "rb");
2179   }
2180   else if (mode == PTCACHE_FILE_WRITE) {
2181     BLI_make_existing_file(
2182         filename); /* will create the dir if needs be, same as //textures is created */
2183     fp = BLI_fopen(filename, "wb");
2184   }
2185   else if (mode == PTCACHE_FILE_UPDATE) {
2186     BLI_make_existing_file(filename);
2187     fp = BLI_fopen(filename, "rb+");
2188   }
2189
2190   if (!fp) {
2191     return NULL;
2192   }
2193
2194   pf = MEM_mallocN(sizeof(PTCacheFile), "PTCacheFile");
2195   pf->fp = fp;
2196   pf->old_format = 0;
2197   pf->frame = cfra;
2198
2199   return pf;
2200 }
2201 static void ptcache_file_close(PTCacheFile *pf)
2202 {
2203   if (pf) {
2204     fclose(pf->fp);
2205     MEM_freeN(pf);
2206   }
2207 }
2208
2209 static int ptcache_file_compressed_read(PTCacheFile *pf, unsigned char *result, unsigned int len)
2210 {
2211   int r = 0;
2212   unsigned char compressed = 0;
2213   size_t in_len;
2214 #ifdef WITH_LZO
2215   size_t out_len = len;
2216 #endif
2217   unsigned char *in;
2218   unsigned char *props = MEM_callocN(16 * sizeof(char), "tmp");
2219
2220   ptcache_file_read(pf, &compressed, 1, sizeof(unsigned char));
2221   if (compressed) {
2222     unsigned int size;
2223     ptcache_file_read(pf, &size, 1, sizeof(unsigned int));
2224     in_len = (size_t)size;
2225     if (in_len == 0) {
2226       /* do nothing */
2227     }
2228     else {
2229       in = (unsigned char *)MEM_callocN(sizeof(unsigned char) * in_len,
2230                                         "pointcache_compressed_buffer");
2231       ptcache_file_read(pf, in, in_len, sizeof(unsigned char));
2232 #ifdef WITH_LZO
2233       if (compressed == 1) {
2234         r = lzo1x_decompress_safe(in, (lzo_uint)in_len, result, (lzo_uint *)&out_len, NULL);
2235       }
2236 #endif
2237 #ifdef WITH_LZMA
2238       if (compressed == 2) {
2239         size_t sizeOfIt;
2240         size_t leni = in_len, leno = len;
2241         ptcache_file_read(pf, &size, 1, sizeof(unsigned int));
2242         sizeOfIt = (size_t)size;
2243         ptcache_file_read(pf, props, sizeOfIt, sizeof(unsigned char));
2244         r = LzmaUncompress(result, &leno, in, &leni, props, sizeOfIt);
2245       }
2246 #endif
2247       MEM_freeN(in);
2248     }
2249   }
2250   else {
2251     ptcache_file_read(pf, result, len, sizeof(unsigned char));
2252   }
2253
2254   MEM_freeN(props);
2255
2256   return r;
2257 }
2258 static int ptcache_file_compressed_write(
2259     PTCacheFile *pf, unsigned char *in, unsigned int in_len, unsigned char *out, int mode)
2260 {
2261   int r = 0;
2262   unsigned char compressed = 0;
2263   size_t out_len = 0;
2264   unsigned char *props = MEM_callocN(16 * sizeof(char), "tmp");
2265   size_t sizeOfIt = 5;
2266
2267   (void)mode; /* unused when building w/o compression */
2268
2269 #ifdef WITH_LZO
2270   out_len = LZO_OUT_LEN(in_len);
2271   if (mode == 1) {
2272     LZO_HEAP_ALLOC(wrkmem, LZO1X_MEM_COMPRESS);
2273
2274     r = lzo1x_1_compress(in, (lzo_uint)in_len, out, (lzo_uint *)&out_len, wrkmem);
2275     if (!(r == LZO_E_OK) || (out_len >= in_len)) {
2276       compressed = 0;
2277     }
2278     else {
2279       compressed = 1;
2280     }
2281   }
2282 #endif
2283 #ifdef WITH_LZMA
2284   if (mode == 2) {
2285
2286     r = LzmaCompress(out,
2287                      &out_len,
2288                      in,
2289                      in_len,  //assume sizeof(char)==1....
2290                      props,
2291                      &sizeOfIt,
2292                      5,
2293                      1 << 24,
2294                      3,
2295                      0,
2296                      2,
2297                      32,
2298                      2);
2299
2300     if (!(r == SZ_OK) || (out_len >= in_len)) {
2301       compressed = 0;
2302     }
2303     else {
2304       compressed = 2;
2305     }
2306   }
2307 #endif
2308
2309   ptcache_file_write(pf, &compressed, 1, sizeof(unsigned char));
2310   if (compressed) {
2311     unsigned int size = out_len;
2312     ptcache_file_write(pf, &size, 1, sizeof(unsigned int));
2313     ptcache_file_write(pf, out, out_len, sizeof(unsigned char));
2314   }
2315   else {
2316     ptcache_file_write(pf, in, in_len, sizeof(unsigned char));
2317   }
2318
2319   if (compressed == 2) {
2320     unsigned int size = sizeOfIt;
2321     ptcache_file_write(pf, &sizeOfIt, 1, sizeof(unsigned int));
2322     ptcache_file_write(pf, props, size, sizeof(unsigned char));
2323   }
2324
2325   MEM_freeN(props);
2326
2327   return r;
2328 }
2329 static int ptcache_file_read(PTCacheFile *pf, void *f, unsigned int tot, unsigned int size)
2330 {
2331   return (fread(f, size, tot, pf->fp) == tot);
2332 }
2333 static int ptcache_file_write(PTCacheFile *pf, const void *f, unsigned int tot, unsigned int size)
2334 {
2335   return (fwrite(f, size, tot, pf->fp) == tot);
2336 }
2337 static int ptcache_file_data_read(PTCacheFile *pf)
2338 {
2339   int i;
2340
2341   for (i = 0; i < BPHYS_TOT_DATA; i++) {
2342     if ((pf->data_types & (1 << i)) &&
2343         !ptcache_file_read(pf, pf->cur[i], 1, ptcache_data_size[i])) {
2344       return 0;
2345     }
2346   }
2347
2348   return 1;
2349 }
2350 static int ptcache_file_data_write(PTCacheFile *pf)
2351 {
2352   int i;
2353
2354   for (i = 0; i < BPHYS_TOT_DATA; i++) {
2355     if ((pf->data_types & (1 << i)) &&
2356         !ptcache_file_write(pf, pf->cur[i], 1, ptcache_data_size[i])) {
2357       return 0;
2358     }
2359   }
2360
2361   return 1;
2362 }
2363 static int ptcache_file_header_begin_read(PTCacheFile *pf)
2364 {
2365   unsigned int typeflag = 0;
2366   int error = 0;
2367   char bphysics[8];
2368
2369   pf->data_types = 0;
2370
2371   if (fread(bphysics, sizeof(char), 8, pf->fp) != 8) {
2372     error = 1;
2373   }
2374
2375   if (!error && !STREQLEN(bphysics, "BPHYSICS", 8)) {
2376     error = 1;
2377   }
2378
2379   if (!error && !fread(&typeflag, sizeof(unsigned int), 1, pf->fp)) {
2380     error = 1;
2381   }
2382
2383   pf->type = (typeflag & PTCACHE_TYPEFLAG_TYPEMASK);
2384   pf->flag = (typeflag & PTCACHE_TYPEFLAG_FLAGMASK);
2385
2386   /* if there was an error set file as it was */
2387   if (error) {
2388     fseek(pf->fp, 0, SEEK_SET);
2389   }
2390
2391   return !error;
2392 }
2393 static int ptcache_file_header_begin_write(PTCacheFile *pf)
2394 {
2395   const char *bphysics = "BPHYSICS";
2396   unsigned int typeflag = pf->type + pf->flag;
2397
2398   if (fwrite(bphysics, sizeof(char), 8, pf->fp) != 8) {
2399     return 0;
2400   }
2401
2402   if (!fwrite(&typeflag, sizeof(unsigned int), 1, pf->fp)) {
2403     return 0;
2404   }
2405
2406   return 1;
2407 }
2408
2409 /* Data pointer handling */
2410 int BKE_ptcache_data_size(int data_type)
2411 {
2412   return ptcache_data_size[data_type];
2413 }
2414
2415 static void ptcache_file_pointers_init(PTCacheFile *pf)
2416 {
2417   int data_types = pf->data_types;
2418
2419   pf->cur[BPHYS_DATA_INDEX] = (data_types & (1 << BPHYS_DATA_INDEX)) ? &pf->data.index : NULL;
2420   pf->cur[BPHYS_DATA_LOCATION] = (data_types & (1 << BPHYS_DATA_LOCATION)) ? &pf->data.loc : NULL;
2421   pf->cur[BPHYS_DATA_VELOCITY] = (data_types & (1 << BPHYS_DATA_VELOCITY)) ? &pf->data.vel : NULL;
2422   pf->cur[BPHYS_DATA_ROTATION] = (data_types & (1 << BPHYS_DATA_ROTATION)) ? &pf->data.rot : NULL;
2423   pf->cur[BPHYS_DATA_AVELOCITY] = (data_types & (1 << BPHYS_DATA_AVELOCITY)) ? &pf->data.ave :
2424                                                                                NULL;
2425   pf->cur[BPHYS_DATA_SIZE] = (data_types & (1 << BPHYS_DATA_SIZE)) ? &pf->data.size : NULL;
2426   pf->cur[BPHYS_DATA_TIMES] = (data_types & (1 << BPHYS_DATA_TIMES)) ? &pf->data.times : NULL;
2427   pf->cur[BPHYS_DATA_BOIDS] = (data_types & (1 << BPHYS_DATA_BOIDS)) ? &pf->data.boids : NULL;
2428 }
2429
2430 /* Check to see if point number "index" is in pm, uses binary search for index data. */
2431 int BKE_ptcache_mem_index_find(PTCacheMem *pm, unsigned int index)
2432 {
2433   if (pm->totpoint > 0 && pm->data[BPHYS_DATA_INDEX]) {
2434     unsigned int *data = pm->data[BPHYS_DATA_INDEX];
2435     unsigned int mid, low = 0, high = pm->totpoint - 1;
2436
2437     if (index < *data || index > *(data + high)) {
2438       return -1;
2439     }
2440
2441     /* check simple case for continuous indexes first */
2442     if (index - *data < high && data[index - *data] == index) {
2443       return index - *data;
2444     }
2445
2446     while (low <= high) {
2447       mid = (low + high) / 2;
2448
2449       if (data[mid] > index) {
2450         high = mid - 1;
2451       }
2452       else if (data[mid] < index) {
2453         low = mid + 1;
2454       }
2455       else {
2456         return mid;
2457       }
2458     }
2459
2460     return -1;
2461   }
2462   else {
2463     return (index < pm->totpoint ? index : -1);
2464   }
2465 }
2466
2467 void BKE_ptcache_mem_pointers_init(PTCacheMem *pm)
2468 {
2469   int data_types = pm->data_types;
2470   int i;
2471
2472   for (i = 0; i < BPHYS_TOT_DATA; i++) {
2473     pm->cur[i] = ((data_types & (1 << i)) ? pm->data[i] : NULL);
2474   }
2475 }
2476
2477 void BKE_ptcache_mem_pointers_incr(PTCacheMem *pm)
2478 {
2479   int i;
2480
2481   for (i = 0; i < BPHYS_TOT_DATA; i++) {
2482     if (pm->cur[i]) {
2483       pm->cur[i] = (char *)pm->cur[i] + ptcache_data_size[i];
2484     }
2485   }
2486 }
2487 int BKE_ptcache_mem_pointers_seek(int point_index, PTCacheMem *pm)
2488 {
2489   int data_types = pm->data_types;
2490   int i, index = BKE_ptcache_mem_index_find(pm, point_index);
2491
2492   if (index < 0) {
2493     /* Can't give proper location without reallocation, so don't give any location.
2494      * Some points will be cached improperly, but this only happens with simulation
2495      * steps bigger than cache->step, so the cache has to be recalculated anyways
2496      * at some point.
2497      */
2498     return 0;
2499   }
2500
2501   for (i = 0; i < BPHYS_TOT_DATA; i++) {
2502     pm->cur[i] = data_types & (1 << i) ? (char *)pm->data[i] + index * ptcache_data_size[i] : NULL;
2503   }
2504
2505   return 1;
2506 }
2507 static void ptcache_data_alloc(PTCacheMem *pm)
2508 {
2509   int data_types = pm->data_types;
2510   int totpoint = pm->totpoint;
2511   int i;
2512
2513   for (i = 0; i < BPHYS_TOT_DATA; i++) {
2514     if (data_types & (1 << i)) {
2515       pm->data[i] = MEM_callocN(totpoint * ptcache_data_size[i], "PTCache Data");
2516     }
2517   }
2518 }
2519 static void ptcache_data_free(PTCacheMem *pm)
2520 {
2521   void **data = pm->data;
2522   int i;
2523
2524   for (i = 0; i < BPHYS_TOT_DATA; i++) {
2525     if (data[i]) {
2526       MEM_freeN(data[i]);
2527     }
2528   }
2529 }
2530 static void ptcache_data_copy(void *from[], void *to[])
2531 {
2532   int i;
2533   for (i = 0; i < BPHYS_TOT_DATA; i++) {
2534     /* note, durian file 03.4b_comp crashes if to[i] is not tested
2535      * its NULL, not sure if this should be fixed elsewhere but for now its needed */
2536     if (from[i] && to[i]) {
2537       memcpy(to[i], from[i], ptcache_data_size[i]);
2538     }
2539   }
2540 }
2541
2542 static void ptcache_extra_free(PTCacheMem *pm)
2543 {
2544   PTCacheExtra *extra = pm->extradata.first;
2545
2546   if (extra) {
2547     for (; extra; extra = extra->next) {
2548       if (extra->data) {
2549         MEM_freeN(extra->data);
2550       }
2551     }
2552
2553     BLI_freelistN(&pm->extradata);
2554   }
2555 }
2556 static int ptcache_old_elemsize(PTCacheID *pid)
2557 {
2558   if (pid->type == PTCACHE_TYPE_SOFTBODY) {
2559     return 6 * sizeof(float);
2560   }
2561   else if (pid->type == PTCACHE_TYPE_PARTICLES) {
2562     return sizeof(ParticleKey);
2563   }
2564   else if (pid->type == PTCACHE_TYPE_CLOTH) {
2565     return 9 * sizeof(float);
2566   }
2567
2568   return 0;
2569 }
2570
2571 static void ptcache_find_frames_around(PTCacheID *pid, unsigned int frame, int *fra1, int *fra2)
2572 {
2573   if (pid->cache->flag & PTCACHE_DISK_CACHE) {
2574     int cfra1 = frame, cfra2 = frame + 1;
2575
2576     while (cfra1 >= pid->cache->startframe && !BKE_ptcache_id_exist(pid, cfra1)) {
2577       cfra1--;
2578     }
2579
2580     if (cfra1 < pid->cache->startframe) {
2581       cfra1 = 0;
2582     }
2583
2584     while (cfra2 <= pid->cache->endframe && !BKE_ptcache_id_exist(pid, cfra2)) {
2585       cfra2++;
2586     }
2587
2588     if (cfra2 > pid->cache->endframe) {
2589       cfra2 = 0;
2590     }
2591
2592     if (cfra1 && !cfra2) {
2593       *fra1 = 0;
2594       *fra2 = cfra1;
2595     }
2596     else {
2597       *fra1 = cfra1;
2598       *fra2 = cfra2;
2599     }
2600   }
2601   else if (pid->cache->mem_cache.first) {
2602     PTCacheMem *pm = pid->cache->mem_cache.first;
2603     PTCacheMem *pm2 = pid->cache->mem_cache.last;
2604
2605     while (pm->next && pm->next->frame <= frame) {
2606       pm = pm->next;
2607     }
2608
2609     if (pm2->frame < frame) {
2610       pm2 = NULL;
2611     }
2612     else {
2613       while (pm2->prev && pm2->prev->frame > frame) {
2614         pm2 = pm2->prev;
2615       }
2616     }
2617
2618     if (!pm2) {
2619       *fra1 = 0;
2620       *fra2 = pm->frame;
2621     }
2622     else {
2623       *fra1 = pm->frame;
2624       *fra2 = pm2->frame;
2625     }
2626   }
2627 }
2628
2629 static PTCacheMem *ptcache_disk_frame_to_mem(PTCacheID *pid, int cfra)
2630 {
2631   PTCacheFile *pf = ptcache_file_open(pid, PTCACHE_FILE_READ, cfra);
2632   PTCacheMem *pm = NULL;
2633   unsigned int i, error = 0;
2634
2635   if (pf == NULL) {
2636     return NULL;
2637   }
2638
2639   if (!ptcache_file_header_begin_read(pf)) {
2640     error = 1;
2641   }
2642
2643   if (!error && (pf->type != pid->type || !pid->read_header(pf))) {
2644     error = 1;
2645   }
2646
2647   if (!error) {
2648     pm = MEM_callocN(sizeof(PTCacheMem), "Pointcache mem");
2649
2650     pm->totpoint = pf->totpoint;
2651     pm->data_types = pf->data_types;
2652     pm->frame = pf->frame;
2653
2654     ptcache_data_alloc(pm);
2655
2656     if (pf->flag & PTCACHE_TYPEFLAG_COMPRESS) {
2657       for (i = 0; i < BPHYS_TOT_DATA; i++) {
2658         unsigned int out_len = pm->totpoint * ptcache_data_size[i];
2659         if (pf->data_types & (1 << i)) {
2660           ptcache_file_compressed_read(pf, (unsigned char *)(pm->data[i]), out_len);
2661         }
2662       }
2663     }
2664     else {
2665       BKE_ptcache_mem_pointers_init(pm);
2666       ptcache_file_pointers_init(pf);
2667
2668       for (i = 0; i < pm->totpoint; i++) {
2669         if (!ptcache_file_data_read(pf)) {
2670           error = 1;
2671           break;
2672         }
2673         ptcache_data_copy(pf->cur, pm->cur);
2674         BKE_ptcache_mem_pointers_incr(pm);
2675       }
2676     }
2677   }
2678
2679   if (!error && pf->flag & PTCACHE_TYPEFLAG_EXTRADATA) {
2680     unsigned int extratype = 0;
2681
2682     while (ptcache_file_read(pf, &extratype, 1, sizeof(unsigned int))) {
2683       PTCacheExtra *extra = MEM_callocN(sizeof(PTCacheExtra), "Pointcache extradata");
2684
2685       extra->type = extratype;
2686
2687       ptcache_file_read(pf, &extra->totdata, 1, sizeof(unsigned int));
2688
2689       extra->data = MEM_callocN(extra->totdata * ptcache_extra_datasize[extra->type],
2690                                 "Pointcache extradata->data");
2691
2692       if (pf->flag & PTCACHE_TYPEFLAG_COMPRESS) {
2693         ptcache_file_compressed_read(pf,
2694                                      (unsigned char *)(extra->data),
2695                                      extra->totdata * ptcache_extra_datasize[extra->type]);
2696       }
2697       else {
2698         ptcache_file_read(pf, extra->data, extra->totdata, ptcache_extra_datasize[extra->type]);
2699       }
2700
2701       BLI_addtail(&pm->extradata, extra);
2702     }
2703   }
2704
2705   if (error && pm) {
2706     ptcache_data_free(pm);
2707     ptcache_extra_free(pm);
2708     MEM_freeN(pm);
2709     pm = NULL;
2710   }
2711
2712   ptcache_file_close(pf);
2713
2714   if (error && G.debug & G_DEBUG) {
2715     printf("Error reading from disk cache\n");
2716   }
2717
2718   return pm;
2719 }
2720 static int ptcache_mem_frame_to_disk(PTCacheID *pid, PTCacheMem *pm)
2721 {
2722   PTCacheFile *pf = NULL;
2723   unsigned int i, error = 0;
2724
2725   BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_FRAME, pm->frame);
2726
2727   pf = ptcache_file_open(pid, PTCACHE_FILE_WRITE, pm->frame);
2728
2729   if (pf == NULL) {
2730     if (G.debug & G_DEBUG) {
2731       printf("Error opening disk cache file for writing\n");
2732     }
2733     return 0;
2734   }
2735
2736   pf->data_types = pm->data_types;
2737   pf->totpoint = pm->totpoint;
2738   pf->type = pid->type;
2739   pf->flag = 0;
2740
2741   if (pm->extradata.first) {
2742     pf->flag |= PTCACHE_TYPEFLAG_EXTRADATA;
2743   }
2744
2745   if (pid->cache->compression) {
2746     pf->flag |= PTCACHE_TYPEFLAG_COMPRESS;
2747   }
2748
2749   if (!ptcache_file_header_begin_write(pf) || !pid->write_header(pf)) {
2750     error = 1;
2751   }
2752
2753   if (!error) {
2754     if (pid->cache->compression) {
2755       for (i = 0; i < BPHYS_TOT_DATA; i++) {
2756         if (pm->data[i]) {
2757           unsigned int in_len = pm->totpoint * ptcache_data_size[i];
2758           unsigned char *out = (unsigned char *)MEM_callocN(LZO_OUT_LEN(in_len) * 4,
2759                                                             "pointcache_lzo_buffer");
2760           ptcache_file_compressed_write(
2761               pf, (unsigned char *)(pm->data[i]), in_len, out, pid->cache->compression);
2762           MEM_freeN(out);
2763         }
2764       }
2765     }
2766     else {
2767       BKE_ptcache_mem_pointers_init(pm);
2768       ptcache_file_pointers_init(pf);
2769
2770       for (i = 0; i < pm->totpoint; i++) {
2771         ptcache_data_copy(pm->cur, pf->cur);
2772         if (!ptcache_file_data_write(pf)) {
2773           error = 1;
2774           break;
2775         }
2776         BKE_ptcache_mem_pointers_incr(pm);
2777       }
2778     }
2779   }
2780
2781   if (!error && pm->extradata.first) {
2782     PTCacheExtra *extra = pm->extradata.first;
2783
2784     for (; extra; extra = extra->next) {
2785       if (extra->data == NULL || extra->totdata == 0) {
2786         continue;
2787       }
2788
2789       ptcache_file_write(pf, &extra->type, 1, sizeof(unsigned int));
2790       ptcache_file_write(pf, &extra->totdata, 1, sizeof(unsigned int));
2791
2792       if (pid->cache->compression) {
2793         unsigned int in_len = extra->totdata * ptcache_extra_datasize[extra->type];
2794         unsigned char *out = (unsigned char *)MEM_callocN(LZO_OUT_LEN(in_len) * 4,
2795                                                           "pointcache_lzo_buffer");
2796         ptcache_file_compressed_write(
2797             pf, (unsigned char *)(extra->data), in_len, out, pid->cache->compression);
2798         MEM_freeN(out);
2799       }
2800       else {
2801         ptcache_file_write(pf, extra->data, extra->totdata, ptcache_extra_datasize[extra->type]);
2802       }
2803     }
2804   }
2805
2806   ptcache_file_close(pf);
2807
2808   if (error && G.debug & G_DEBUG) {
2809     printf("Error writing to disk cache\n");
2810   }
2811
2812   return error == 0;
2813 }
2814
2815 static int ptcache_read_stream(PTCacheID *pid, int cfra)
2816 {
2817   PTCacheFile *pf = ptcache_file_open(pid, PTCACHE_FILE_READ, cfra);
2818   int error = 0;
2819
2820   if (pid->read_stream == NULL) {
2821     return 0;
2822   }
2823
2824   if (pf == NULL) {
2825     if (G.debug & G_DEBUG) {
2826       printf("Error opening disk cache file for reading\n");
2827     }
2828     return 0;
2829   }
2830
2831   if (!ptcache_file_header_begin_read(pf)) {
2832     pid->error(pid->calldata, "Failed to read point cache file");
2833     error = 1;
2834   }
2835   else if (pf->type != pid->type) {
2836     pid->error(pid->calldata, "Point cache file has wrong type");
2837     error = 1;
2838   }
2839   else if (!pid->read_header(pf)) {
2840     pid->error(pid->calldata, "Failed to read point cache file header");
2841     error = 1;
2842   }
2843   else if (pf->totpoint != pid->totpoint(pid->calldata, cfra)) {
2844     pid->error(pid->calldata, "Number of points in cache does not match mesh");
2845     error = 1;
2846   }
2847
2848   if (!error) {
2849     ptcache_file_pointers_init(pf);
2850
2851     // we have stream reading here
2852     if (!pid->read_stream(pf, pid->calldata)) {
2853       pid->error(pid->calldata, "Failed to read point cache file data");
2854       error = 1;
2855     }
2856   }
2857
2858   ptcache_file_close(pf);
2859
2860   return error == 0;
2861 }
2862
2863 static int ptcache_read_openvdb_stream(PTCacheID *pid, int cfra)
2864 {
2865 #ifdef WITH_OPENVDB
2866   char filename[FILE_MAX * 2];
2867
2868   /* save blend file before using disk pointcache */
2869   if (!G.relbase_valid && (pid->cache->flag & PTCACHE_EXTERNAL) == 0) {
2870     return 0;
2871   }
2872
2873   ptcache_filename(pid, filename, cfra, 1, 1);
2874
2875   if (!BLI_exists(filename)) {
2876     return 0;
2877   }
2878
2879   struct OpenVDBReader *reader = OpenVDBReader_create();
2880   OpenVDBReader_open(reader, filename);
2881
2882   if (!pid->read_openvdb_stream(reader, pid->calldata)) {
2883     return 0;
2884   }
2885
2886   return 1;
2887 #else
2888   UNUSED_VARS(pid, cfra);
2889   return 0;
2890 #endif
2891 }
2892
2893 static int ptcache_read(PTCacheID *pid, int cfra)
2894 {
2895   PTCacheMem *pm = NULL;
2896   int i;
2897   int *index = &i;
2898
2899   /* get a memory cache to read from */
2900   if (pid->cache->flag & PTCACHE_DISK_CACHE) {
2901     pm = ptcache_disk_frame_to_mem(pid, cfra);
2902   }
2903   else {
2904     pm = pid->cache->mem_cache.first;
2905
2906     while (pm && pm->frame != cfra) {
2907       pm = pm->next;
2908     }
2909   }
2910
2911   /* read the cache */
2912   if (pm) {
2913     int totpoint = pm->totpoint;
2914
2915     if ((pid->data_types & (1 << BPHYS_DATA_INDEX)) == 0) {
2916       int pid_totpoint = pid->totpoint(pid->calldata, cfra);
2917
2918       if (totpoint != pid_totpoint) {
2919         pid->error(pid->calldata, "Number of points in cache does not match mesh");
2920         totpoint = MIN2(totpoint, pid_totpoint);
2921       }
2922     }
2923
2924     BKE_ptcache_mem_pointers_init(pm);
2925
2926     for (i = 0; i < totpoint; i++) {
2927       if (pm->data_types & (1 << BPHYS_DATA_INDEX)) {
2928         index = pm->cur[BPHYS_DATA_INDEX];
2929       }
2930
2931       pid->read_point(*index, pid->calldata, pm->cur, (float)pm->frame, NULL);
2932
2933       BKE_ptcache_mem_pointers_incr(pm);
2934     }
2935
2936     if (pid->read_extra_data && pm->extradata.first) {
2937       pid->read_extra_data(pid->calldata, pm, (float)pm->frame);
2938     }
2939
2940     /* clean up temporary memory cache */
2941     if (pid->cache->flag & PTCACHE_DISK_CACHE) {
2942       ptcache_data_free(pm);
2943       ptcache_extra_free(pm);
2944       MEM_freeN(pm);
2945     }
2946   }
2947
2948   return 1;
2949 }
2950 static int ptcache_interpolate(PTCacheID *pid, float cfra, int cfra1, int cfra2)
2951 {
2952   PTCacheMem *pm = NULL;
2953   int i;
2954   int *index = &i;
2955
2956   /* get a memory cache to read from */
2957   if (pid->cache->flag & PTCACHE_DISK_CACHE) {
2958     pm = ptcache_disk_frame_to_mem(pid, cfra2);
2959   }
2960   else {
2961     pm = pid->cache->mem_cache.first;
2962
2963     while (pm && pm->frame != cfra2) {
2964       pm = pm->next;
2965     }
2966   }
2967
2968   /* read the cache */
2969   if (pm) {
2970     int totpoint = pm->totpoint;
2971
2972     if ((pid->data_types & (1 << BPHYS_DATA_INDEX)) == 0) {
2973       int pid_totpoint = pid->totpoint(pid->calldata, (int)cfra);
2974
2975       if (totpoint != pid_totpoint) {
2976         pid->error(pid->calldata, "Number of points in cache does not match mesh");
2977         totpoint = MIN2(totpoint, pid_totpoint);
2978       }
2979     }
2980
2981     BKE_ptcache_mem_pointers_init(pm);
2982
2983     for (i = 0; i < totpoint; i++) {
2984       if (pm->data_types & (1 << BPHYS_DATA_INDEX)) {
2985         index = pm->cur[BPHYS_DATA_INDEX];
2986       }
2987
2988       pid->interpolate_point(
2989           *index, pid->calldata, pm->cur, cfra, (float)cfra1, (float)cfra2, NULL);
2990       BKE_ptcache_mem_pointers_incr(pm);
2991     }
2992
2993     if (pid->interpolate_extra_data && pm->extradata.first) {
2994       pid->interpolate_extra_data(pid->calldata, pm, cfra, (float)cfra1, (float)cfra2);
2995     }
2996
2997     /* clean up temporary memory cache */
2998     if (pid->cache->flag & PTCACHE_DISK_CACHE) {
2999       ptcache_data_free(pm);
3000       ptcache_extra_free(pm);
3001       MEM_freeN(pm);
3002     }
3003   }
3004
3005   return 1;
3006 }
3007 /* reads cache from disk or memory */
3008 /* possible to get old or interpolated result */
3009 int BKE_ptcache_read(PTCacheID *pid, float cfra, bool no_extrapolate_old)
3010 {
3011   int cfrai = (int)floor(cfra), cfra1 = 0, cfra2 = 0;
3012   int ret = 0;
3013
3014   /* nothing to read to */
3015   if (pid->totpoint(pid->calldata, cfrai) == 0) {
3016     return 0;
3017   }
3018
3019   if (pid->cache->flag & PTCACHE_READ_INFO) {
3020     pid->cache->flag &= ~PTCACHE_READ_INFO;
3021     ptcache_read(pid, 0);
3022   }
3023
3024   /* first check if we have the actual frame cached */
3025   if (cfra == (float)cfrai && BKE_ptcache_id_exist(pid, cfrai)) {
3026     cfra1 = cfrai;
3027   }
3028
3029   /* no exact cache frame found so try to find cached frames around cfra */
3030   if (cfra1 == 0) {
3031     ptcache_find_frames_around(pid, cfrai, &cfra1, &cfra2);
3032   }
3033
3034   if (cfra1 == 0 && cfra2 == 0) {
3035     return 0;
3036   }
3037
3038   /* don't read old cache if already simulated past cached frame */
3039   if (no_extrapolate_old) {
3040     if (cfra1 == 0 && cfra2 && cfra2 <= pid->cache->simframe) {
3041       return 0;
3042     }
3043     if (cfra1 && cfra1 == cfra2) {
3044       return 0;
3045     }
3046   }
3047   else {
3048     /* avoid calling interpolate between the same frame values */
3049     if (cfra1 && cfra1 == cfra2) {
3050       cfra1 = 0;
3051     }
3052   }
3053
3054   if (cfra1) {
3055     if (pid->file_type == PTCACHE_FILE_OPENVDB && pid->read_openvdb_stream) {
3056       if (!ptcache_read_openvdb_stream(pid, cfra1)) {
3057         return 0;
3058       }
3059     }
3060     else if (pid->read_stream) {
3061       if (!ptcache_read_stream(pid, cfra1)) {
3062         return 0;
3063       }
3064     }
3065     else if (pid->read_point) {
3066       ptcache_read(pid, cfra1);
3067     }
3068   }
3069
3070   if (cfra2) {
3071     if (pid->file_type == PTCACHE_FILE_OPENVDB && pid->read_openvdb_stream) {
3072       if (!ptcache_read_openvdb_stream(pid, cfra2)) {
3073         return 0;
3074       }
3075     }
3076     else if (pid->read_stream) {
3077       if (!ptcache_read_stream(pid, cfra2)) {
3078         return 0;
3079       }
3080     }
3081     else if (pid->read_point) {
3082       if (cfra1 && cfra2 && pid->interpolate_point) {
3083         ptcache_interpolate(pid, cfra, cfra1, cfra2);
3084       }
3085       else {
3086         ptcache_read(pid, cfra2);
3087       }
3088     }
3089   }
3090
3091   if (cfra1) {
3092     ret = (cfra2 ? PTCACHE_READ_INTERPOLATED : PTCACHE_READ_EXACT);
3093   }
3094   else if (cfra2) {
3095     ret = PTCACHE_READ_OLD;
3096     pid->cache->simframe = cfra2;
3097   }
3098
3099   cfrai = (int)cfra;
3100   /* clear invalid cache frames so that better stuff can be simulated */
3101   if (pid->cache->flag & PTCACHE_OUTDATED) {
3102     BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_AFTER, cfrai);
3103   }
3104   else if (pid->cache->flag & PTCACHE_FRAMES_SKIPPED) {
3105     if (cfra <= pid->cache->last_exact) {
3106       pid->cache->flag &= ~PTCACHE_FRAMES_SKIPPED;
3107     }
3108
3109     BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_AFTER, MAX2(cfrai, pid->cache->last_exact));
3110   }
3111
3112   return ret;
3113 }
3114 static int ptcache_write_stream(PTCacheID *pid, int cfra, int totpoint)
3115 {
3116   PTCacheFile *pf = NULL;
3117   int error = 0;
3118
3119   BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_FRAME, cfra);
3120
3121   pf = ptcache_file_open(pid, PTCACHE_FILE_WRITE, cfra);
3122
3123   if (pf == NULL) {
3124     if (G.debug & G_DEBUG) {
3125       printf("Error opening disk cache file for writing\n");
3126     }
3127     return 0;
3128   }
3129
3130   pf->data_types = pid->data_types;
3131   pf->totpoint = totpoint;
3132   pf->type = pid->type;
3133   pf->flag = 0;
3134
3135   if (!error && (!ptcache_file_header_begin_write(pf) || !pid->write_header(pf))) {
3136     error = 1;
3137   }
3138
3139   if (!error && pid->write_stream) {
3140     pid->write_stream(pf, pid->calldata);
3141   }
3142
3143   ptcache_file_close(pf);
3144
3145   if (error && G.debug & G_DEBUG) {
3146     printf("Error writing to disk cache\n");
3147   }
3148
3149   return error == 0;
3150 }
3151 static int ptcache_write_openvdb_stream(PTCacheID *pid, int cfra)
3152 {
3153 #ifdef WITH_OPENVDB
3154   struct OpenVDBWriter *writer = OpenVDBWriter_create();
3155   char filename[FILE_MAX * 2];
3156
3157   BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_FRAME, cfra);
3158
3159   ptcache_filename(pid, filename, cfra, 1, 1);
3160   BLI_make_existing_file(filename);
3161
3162   int error = pid->write_openvdb_stream(writer, pid->calldata);
3163
3164   OpenVDBWriter_write(writer, filename);
3165   OpenVDBWriter_free(writer);
3166
3167   return error == 0;
3168 #else
3169   UNUSED_VARS(pid, cfra);
3170   return 0;
3171 #endif
3172 }
3173 static int ptcache_write(PTCacheID *pid, int cfra, int overwrite)
3174 {
3175   PointCache *cache = pid->cache;
3176   PTCacheMem *pm = NULL, *pm2 = NULL;
3177   int totpoint = pid->totpoint(pid->calldata, cfra);
3178   int i, error = 0;
3179
3180   pm = MEM_callocN(sizeof(PTCacheMem), "Pointcache mem");
3181
3182   pm->totpoint = pid->totwrite(pid->calldata, cfra);
3183   pm->data_types = cfra ? pid->data_types : pid->info_types;
3184
3185   ptcache_data_alloc(pm);
3186   BKE_ptcache_mem_pointers_init(pm);
3187
3188   if (overwrite) {
3189     if (cache->flag & PTCACHE_DISK_CACHE) {
3190       int fra = cfra - 1;
3191
3192       while (fra >= cache->startframe && !BKE_ptcache_id_exist(pid, fra)) {
3193         fra--;
3194       }
3195
3196       pm2 = ptcache_disk_frame_to_mem(pid, fra);
3197     }
3198     else {
3199       pm2 = cache->mem_cache.last;
3200     }
3201   }
3202
3203   if (pid->write_point) {
3204     for (i = 0; i < totpoint; i++) {
3205       int write = pid->write_point(i, pid->calldata, pm->cur, cfra);
3206       if (write) {
3207         BKE_ptcache_mem_pointers_incr(pm);
3208
3209         /* newly born particles have to be copied to previous cached frame */
3210         if (overwrite && write == 2 && pm2 && BKE_ptcache_mem_pointers_seek(i, pm2)) {
3211           pid->write_point(i, pid->calldata, pm2->cur, cfra);
3212         }
3213       }
3214     }
3215   }
3216
3217   if (pid->write_extra_data) {
3218     pid->write_extra_data(pid->calldata, pm, cfra);
3219   }
3220
3221   pm->frame = cfra;
3222
3223   if (cache->flag & PTCACHE_DISK_CACHE) {
3224     error += !ptcache_mem_frame_to_disk(pid, pm);
3225
3226     // if (pm) /* pm is always set */
3227     {
3228       ptcache_data_free(pm);
3229       ptcache_extra_free(pm);
3230       MEM_freeN(pm);
3231     }
3232
3233     if (pm2) {
3234       error += !ptcache_mem_frame_to_disk(pid, pm2);
3235       ptcache_data_free(pm2);
3236       ptcache_extra_free(pm2);
3237       MEM_freeN(pm2);
3238     }
3239   }
3240   else {
3241     BLI_addtail(&cache->mem_cache, pm);
3242   }
3243
3244   return error;
3245 }
3246 static int ptcache_write_needed(PTCacheID *pid, int cfra, int *overwrite)
3247 {
3248   PointCache *cache = pid->cache;
3249   int ofra = 0, efra = cache->endframe;
3250
3251   /* always start from scratch on the first frame */
3252   if (cfra && cfra == cache->startframe) {
3253     BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_ALL, cfra);
3254     cache->flag &= ~PTCACHE_REDO_NEEDED;
3255     return 1;
3256   }
3257
3258   if (pid->cache->flag & PTCACHE_DISK_CACHE) {
3259     if (cfra == 0 && cache->startframe > 0) {
3260       return 1;
3261     }
3262
3263     /* find last cached frame */
3264     while (efra > cache->startframe && !BKE_ptcache_id_exist(pid, efra)) {
3265       efra--;
3266     }
3267
3268     /* find second last cached frame */
3269     ofra = efra - 1;
3270     while (ofra > cache->startframe && !BKE_ptcache_id_exist(pid, ofra)) {
3271       ofra--;
3272     }
3273   }
3274   else {
3275     PTCacheMem *pm = cache->mem_cache.last;
3276     /* don't write info file in memory */
3277     if (cfra == 0) {
3278       return 0;
3279     }
3280
3281     if (pm == NULL) {
3282       return 1;
3283     }
3284
3285     efra = pm->frame;
3286     ofra = (pm->prev ? pm->prev->frame : efra - cache->step);
3287   }
3288
3289   if (efra >= cache->startframe && cfra > efra) {
3290     if (ofra >= cache->startframe && efra - ofra < cache->step) {
3291       /* overwrite previous frame */
3292       BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_FRAME, efra);
3293       *overwrite = 1;
3294     }
3295     return 1;
3296   }
3297
3298   return 0;
3299 }
3300 /* writes cache to disk or memory */
3301 int BKE_ptcache_write(PTCacheID *pid, unsigned int cfra)
3302 {
3303   PointCache *cache = pid->cache;
3304   int totpoint = pid->totpoint(pid->calldata, cfra);
3305   int overwrite = 0, error = 0;
3306
3307   if (totpoint == 0 || (cfra ? pid->data_types == 0 : pid->info_types == 0)) {
3308     return 0;
3309   }
3310
3311   if (ptcache_write_needed(pid, cfra, &overwrite) == 0) {
3312     return 0;
3313   }
3314
3315   if (pid->file_type == PTCACHE_FILE_OPENVDB && pid->write_openvdb_stream) {
3316     ptcache_write_openvdb_stream(pid, cfra);
3317   }
3318   else if (pid->write_stream) {
3319     ptcache_write_stream(pid, cfra, totpoint);
3320   }
3321   else if (pid->write_point) {
3322     error += ptcache_write(pid, cfra, overwrite);
3323   }
3324
3325   /* Mark frames skipped if more than 1 frame forwards since last non-skipped frame. */
3326   if (cfra - cache->last_exact == 1 || cfra == cache->startframe) {
3327     cache->last_exact = cfra;
3328     cache->flag &= ~PTCACHE_FRAMES_SKIPPED;
3329   }
3330   /* Don't mark skipped when writing info file (frame 0) */
3331   else if (cfra) {
3332     cache->flag |= PTCACHE_FRAMES_SKIPPED;
3333   }
3334
3335   /* Update timeline cache display */
3336   if (cfra && cache->cached_frames) {
3337     cache->cached_frames[cfra - cache->startframe] = 1;
3338   }
3339
3340   BKE_ptcache_update_info(pid);
3341
3342   return !error;
3343 }
3344 /* youll need to close yourself after!
3345  * mode - PTCACHE_CLEAR_ALL,
3346  */
3347
3348 /* Clears & resets */
3349 void BKE_ptcache_id_clear(PTCacheID *pid, int mode, unsigned int cfra)
3350 {
3351   unsigned int len; /* store the length of the string */
3352   unsigned int sta, end;
3353
3354   /* mode is same as fopen's modes */
3355   DIR *dir;
3356   struct dirent *de;
3357   char path[MAX_PTCACHE_PATH];
3358   char filename[MAX_PTCACHE_FILE];
3359   char path_full[MAX_PTCACHE_FILE];
3360   char ext[MAX_PTCACHE_PATH];
3361
3362   if (!pid || !pid->cache || pid->cache->flag & PTCACHE_BAKED) {
3363     return;
3364   }
3365
3366   if (pid->cache->flag & PTCACHE_IGNORE_CLEAR) {
3367     return;
3368   }
3369
3370   sta = pid->cache->startframe;
3371   end = pid->cache->endframe;
3372
3373 #ifndef DURIAN_POINTCACHE_LIB_OK
3374   /* don't allow clearing for linked objects */
3375   if (pid->ob->id.lib) {
3376     return;
3377   }
3378 #endif
3379
3380   /*if (!G.relbase_valid) return; */ /* save blend file before using pointcache */
3381
3382   const char *fext = ptcache_file_extension(pid);
3383
3384   /* clear all files in the temp dir with the prefix of the ID and the ".bphys" suffix */
3385   switch (mode) {
3386     case PTCACHE_CLEAR_ALL:
3387     case PTCACHE_CLEAR_BEFORE:
3388     case PTCACHE_CLEAR_AFTER:
3389       if (pid->cache->flag & PTCACHE_DISK_CACHE) {
3390         ptcache_path(pid, path);
3391
3392         dir = opendir(path);
3393         if (dir == NULL) {
3394           return;
3395         }
3396
3397         len = ptcache_filename(pid, filename, cfra, 0, 0); /* no path */
3398         /* append underscore terminator to ensure we don't match similar names
3399          * from objects whose names start with the same prefix
3400          */
3401         if (len < sizeof(filename) - 2) {
3402           BLI_strncpy(filename + len, "_", sizeof(filename) - 2 - len);
3403           len += 1;
3404         }
3405
3406         BLI_snprintf(ext, sizeof(ext), "_%02u%s", pid->stack_index, fext);
3407
3408         while ((de = readdir(dir)) != NULL) {
3409           if (strstr(de->d_name, ext)) {               /* do we have the right extension?*/
3410             if (STREQLEN(filename, de->d_name, len)) { /* do we have the right prefix */
3411               if (mode == PTCACHE_CLEAR_ALL) {
3412                 pid->cache->last_exact = MIN2(pid->cache->startframe, 0);
3413                 BLI_join_dirfile(path_full, sizeof(path_full), path, de->d_name);
3414                 BLI_delete(path_full, false, false);
3415               }
3416               else {
3417                 /* read the number of the file */
3418                 const int frame = ptcache_frame_from_filename(de->d_name, ext);
3419
3420                 if (frame != -1) {
3421                   if ((mode == PTCACHE_CLEAR_BEFORE && frame < cfra) ||
3422                       (mode == PTCACHE_CLEAR_AFTER && frame > cfra)) {
3423                     BLI_join_dirfile(path_full, sizeof(path_full), path, de->d_name);
3424                     BLI_delete(path_full, false, false);
3425                     if (pid->cache->cached_frames && frame >= sta && frame <= end) {
3426                       pid->cache->cached_frames[frame - sta] = 0;
3427                     }
3428                   }
3429                 }
3430               }
3431             }
3432           }
3433         }
3434         closedir(dir);
3435
3436         if (mode == PTCACHE_CLEAR_ALL && pid->cache->cached_frames) {
3437           memset(pid->cache->cached_frames, 0, MEM_allocN_len(pid->cache->cached_frames));
3438         }
3439       }
3440       else {
3441         PTCacheMem *pm = pid->cache->mem_cache.first;
3442         PTCacheMem *link = NULL;
3443
3444         if (mode == PTCACHE_CLEAR_ALL) {
3445           /*we want startframe if the cache starts before zero*/
3446           pid->cache->last_exact = MIN2(pid->cache->startframe, 0);
3447           for (; pm; pm = pm->next) {
3448             ptcache_data_free(pm);
3449             ptcache_extra_free(pm);
3450           }
3451           BLI_freelistN(&pid->cache->mem_cache);
3452
3453           if (pid->cache->cached_frames) {
3454             memset(pid->cache->cached_frames, 0, MEM_allocN_len(pid->cache->cached_frames));
3455           }
3456         }
3457         else {
3458           while (pm) {
3459             if ((mode == PTCACHE_CLEAR_BEFORE && pm->frame < cfra) ||
3460                 (mode == PTCACHE_CLEAR_AFTER && pm->frame > cfra)) {
3461               link = pm;
3462               if (pid->cache->cached_frames && pm->frame >= sta && pm->frame <= end) {
3463                 pid->cache->cached_frames[pm->frame - sta] = 0;
3464               }
3465               ptcache_data_free(pm);
3466               ptcache_extra_free(pm);
3467               pm = pm->next;
3468               BLI_freelinkN(&pid->cache->mem_cache, link);
3469             }
3470             else {
3471               pm = pm->next;
3472             }
3473           }
3474         }
3475       }
3476       break;
3477
3478     case PTCACHE_CLEAR_FRAME:
3479       if (pid->cache->flag & PTCACHE_DISK_CACHE) {
3480         if (BKE_ptcache_id_exist(pid, cfra)) {
3481           ptcache_filename(pid, filename, cfra, 1, 1); /* no path */
3482           BLI_delete(filename, false, false);
3483         }
3484       }
3485       else {
3486         PTCacheMem *pm = pid->cache->mem_cache.first;
3487
3488         for (; pm; pm = pm->next) {
3489           if (pm->frame == cfra) {
3490             ptcache_data_free(pm);
3491             ptcache_extra_free(pm);
3492             BLI_freelinkN(&pid->cache->mem_cache, pm);
3493             break;
3494           }
3495         }
3496       }
3497       if (pid->cache->cached_frames && cfra >= sta && cfra <= end) {
3498         pid->cache->cached_frames[cfra - sta] = 0;
3499       }
3500       break;
3501   }
3502
3503   BKE_ptcache_update_info(pid);
3504 }
3505 int BKE_ptcache_id_exist(PTCacheID *pid, int cfra)
3506 {
3507   if (!pid->cache) {
3508     return 0;
3509   }
3510
3511   if (cfra < pid->cache->startframe || cfra > pid->cache->endframe) {
3512     return 0;
3513   }
3514
3515   if (pid->cache->cached_frames && pid->cache->cached_frames[cfra - pid->cache->startframe] == 0) {
3516     return 0;
3517   }
3518
3519   if (pid->cache->flag & PTCACHE_DISK_CACHE) {
3520     char filename[MAX_PTCACHE_FILE];
3521
3522     ptcache_filename(pid, filename, cfra, 1, 1);
3523
3524     return BLI_exists(filename);
3525   }
3526   else {
3527     PTCacheMem *pm = pid->cache->mem_cache.first;
3528
3529     for (; pm; pm = pm->next) {
3530       if (pm->frame == cfra) {
3531         return 1;
3532       }
3533     }
3534     return 0;
3535   }
3536 }
3537 void BKE_ptcache_id_time(
3538     PTCacheID *pid, Scene *scene, float cfra, int *startframe, int *endframe, float *timescale)
3539 {
3540   /* Object *ob; */ /* UNUSED */
3541   PointCache *cache;
3542   /* float offset; unused for now */
3543   float time, nexttime;
3544
3545   /* TODO: this has to be sorted out once bsystem_time gets redone, */
3546   /*       now caches can handle interpolating etc. too - jahka */
3547
3548   /* time handling for point cache:
3549    * - simulation time is scaled by result of bsystem_time
3550    * - for offsetting time only time offset is taken into account, since
3551    *   that's always the same and can't be animated. a timeoffset which
3552    *   varies over time is not simple to support.
3553    * - field and motion blur offsets are currently ignored, proper solution
3554    *   is probably to interpolate results from two frames for that ..
3555    */
3556
3557   /* ob= pid->ob; */ /* UNUSED */
3558   cache = pid->cache;
3559
3560   if (timescale) {
3561     time = BKE_scene_frame_get(scene);
3562     nexttime = BKE_scene_frame_get_from_ctime(scene, CFRA + 1.0f);
3563
3564     *timescale = MAX2(nexttime - time, 0.0f);
3565   }
3566
3567   if (startframe && endframe) {
3568     *startframe = cache->startframe;
3569     *endframe = cache->endframe;
3570   }
3571
3572   /* verify cached_frames array is up to date */
3573   if (cache->cached_frames) {
3574     if (cache->cached_frames_len != (cache->endframe - cache->startframe + 1)) {
3575       MEM_freeN(cache->cached_frames);
3576       cache->cached_frames = NULL;
3577       cache->cached_frames_len = 0;
3578     }
3579   }
3580
3581   if (cache->cached_frames == NULL && cache->endframe > cache->startframe) {
3582     unsigned int sta = cache->startframe;
3583     unsigned int end = cache->endframe;
3584
3585     cache->cached_frames_len = cache->endframe - cache->startframe + 1;
3586     cache->cached_frames = MEM_callocN(sizeof(char) * cache->cached_frames_len,
3587                                        "cached frames array");
3588
3589     if (pid->cache->flag & PTCACHE_DISK_CACHE) {
3590       /* mode is same as fopen's modes */
3591       DIR *dir;
3592       struct dirent *de;
3593       char path[MAX_PTCACHE_PATH];
3594       char filename[MAX_PTCACHE_FILE];
3595       char ext[MAX_PTCACHE_PATH];
3596       unsigned int len; /* store the length of the string */
3597
3598       ptcache_path(pid, path);
3599
3600       len = ptcache_filename(pid, filename, (int)cfra, 0, 0); /* no path */
3601
3602       dir = opendir(path);
3603       if (dir == NULL) {
3604         return;
3605       }
3606
3607       const char *fext = ptcache_file_extension(pid);
3608
3609       BLI_snprintf(ext, sizeof(ext), "_%02u%s", pid->stack_index, fext);
3610
3611       while ((de = readdir(dir)) != NULL) {
3612         if (strstr(de->d_name, ext)) {               /* do we have the right extension?*/
3613           if (STREQLEN(filename, de->d_name, len)) { /* do we have the right prefix */
3614             /* read the number of the file */
3615             const int frame = ptcache_frame_from_filename(de->d_name, ext);
3616
3617             if ((frame != -1) && (frame >= sta && frame <= end)) {
3618               cache->cached_frames[frame - sta] = 1;
3619             }
3620           }
3621         }
3622       }
3623       closedir(dir);
3624     }
3625     else {
3626       PTCacheMem *pm = pid->cache->mem_cache.first;
3627
3628       while (pm) {
3629         if (pm->frame >= sta && pm->frame <= end) {
3630           cache->cached_frames[pm->frame - sta] = 1;
3631         }
3632         pm = pm->next;
3633       }
3634     }
3635   }
3636 }
3637 int BKE_ptcache_id_reset(Scene *scene, PTCacheID *pid, int mode)
3638 {
3639   PointCache *cache;
3640   int reset, clear, after;
3641
3642   if (!pid->cache) {
3643     return 0;
3644   }
3645
3646   cache = pid->cache;
3647   reset = 0;
3648   clear = 0;
3649   after = 0;
3650
3651   if (mode == PTCACHE_RESET_DEPSGRAPH) {
3652     if (!(cache->flag & PTCACHE_BAKED)) {
3653
3654       after = 1;
3655     }
3656
3657     cache->flag |= PTCACHE_OUTDATED;
3658   }
3659   else if (mode == PTCACHE_RESET_BAKED) {
3660     cache->flag |= PTCACHE_OUTDATED;
3661   }
3662   else if (mode == PTCACHE_RESET_OUTDATED) {
3663     reset = 1;
3664
3665     if (cache->flag & PTCACHE_OUTDATED && !(cache->flag & PTCACHE_BAKED)) {
3666       clear = 1;
3667       cache->flag &= ~PTCACHE_OUTDATED;
3668     }
3669   }
3670
3671   if (reset) {
3672     BKE_ptcache_invalidate(cache);
3673     cache->flag &= ~PTCACHE_REDO_NEEDED;
3674
3675     if (pid->type == PTCACHE_TYPE_CLOTH) {
3676       cloth_free_modifier(pid->calldata);
3677     }
3678     else if (pid->type == PTCACHE_TYPE_SOFTBODY) {
3679       sbFreeSimulation(pid->calldata);
3680     }
3681     else if (pid->type == PTCACHE_TYPE_PARTICLES) {
3682       psys_reset(pid->calldata, PSYS_RESET_DEPSGRAPH);
3683     }
3684     else if (pid->type == PTCACHE_TYPE_DYNAMICPAINT) {
3685       dynamicPaint_clearSurface(scene, (DynamicPaintSurface *)pid->calldata);
3686     }
3687   }
3688   if (clear) {
3689     BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_ALL, 0);
3690   }
3691   else if (after) {
3692     BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_AFTER, CFRA);
3693   }
3694
3695   return (reset || clear || after);
3696 }
3697 int BKE_ptcache_object_reset(Scene *scene, Object *ob, int mode)
3698 {
3699   PTCacheID pid;
3700   ParticleSystem *psys;
3701   ModifierData *md;
3702   int reset, skip;
3703
3704   reset = 0;
3705   skip = 0;
3706
3707   if (ob->soft) {
3708     BKE_ptcache_id_from_softbody(&pid, ob, ob->soft);
3709     reset |= BKE_ptcache_id_reset(scene, &pid, mode);
3710   }
3711
3712   for (psys = ob->particlesystem.first; psys; psys = psys->next) {
3713     /* children or just redo can be calculated without resetting anything */