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