Merge of itasc branch. Project files, scons and cmake should be working. Makefile...
[blender.git] / source / blender / blenkernel / intern / pointcache.c
index b514ac0..e5f8972 100644 (file)
@@ -39,6 +39,7 @@
 #include "DNA_object_force.h"
 #include "DNA_particle_types.h"
 #include "DNA_scene_types.h"
+#include "DNA_smoke_types.h"
 
 #include "BLI_blenlib.h"
 
 #include "BKE_particle.h"
 #include "BKE_pointcache.h"
 #include "BKE_scene.h"
+#include "BKE_smoke.h"
 #include "BKE_softbody.h"
 #include "BKE_utildefines.h"
+#include "BIK_api.h"
 
 #include "BLI_blenlib.h"
 
+/* both in intern */
+#include "smoke_API.h"
+#include "minilzo.h"
+
+#include "LzmaLib.h"
+
+
 /* needed for directory lookup */
+/* untitled blend's need getpid for a unique name */
 #ifndef WIN32
   #include <dirent.h>
+#include <unistd.h>
 #else
+#include <process.h>
   #include "BLI_winstuff.h"
 #endif
 
-/* untitled blend's need getpid for a unique name */
-#ifdef WIN32
-#include <process.h>
-#else
-#include <unistd.h>
-#endif
+static void ptcache_data_to(void **data, int type, int index, void *to);
+static void ptcache_data_from(void **data, int type, void *from);
+
+#define PTCACHE_DATA_FROM(data, type, from)            if(data[type]) { memcpy(data[type], from, ptcache_data_size[type]); }
+#define PTCACHE_DATA_TO(data, type, index, to) if(data[type]) { memcpy(to, (char*)data[type] + (index ? index * ptcache_data_size[type] : 0), ptcache_data_size[type]); }
+
+int ptcache_data_size[] = {    
+               sizeof(int), // BPHYS_DATA_INDEX
+               3 * sizeof(float), // BPHYS_DATA_LOCATION:
+               3 * sizeof(float), // BPHYS_DATA_VELOCITY:
+               4 * sizeof(float), // BPHYS_DATA_ROTATION:
+               3 * sizeof(float), // BPHYS_DATA_AVELOCITY: /* also BPHYS_DATA_XCONST */
+               sizeof(float), // BPHYS_DATA_SIZE:
+               3 * sizeof(float), // BPHYS_DATA_TIMES: 
+               sizeof(BoidData) // case BPHYS_DATA_BOIDS:
+};
+
+/* Common functions */
+static int ptcache_read_basic_header(PTCacheFile *pf)
+{
+       int error=0;
 
-#ifdef _WIN32
-#ifndef snprintf
-#define snprintf _snprintf
-#endif
-#endif
+       /* Custom functions should read these basic elements too! */
+       if(!error && !fread(&pf->totpoint, sizeof(int), 1, pf->fp))
+               error = 1;
+       
+       if(!error && !fread(&pf->data_types, sizeof(int), 1, pf->fp))
+               error = 1;
 
-/* Creating ID's */
+       return !error;
+}
+static int ptcache_write_basic_header(PTCacheFile *pf)
+{
+       /* Custom functions should write these basic elements too! */
+       if(!fwrite(&pf->totpoint, sizeof(int), 1, pf->fp))
+               return 0;
+       
+       if(!fwrite(&pf->data_types, sizeof(int), 1, pf->fp))
+               return 0;
 
-void BKE_ptcache_id_from_softbody(PTCacheID *pid, Object *ob, SoftBody *sb)
+       return 1;
+}
+/* Softbody functions */
+static int ptcache_write_softbody(int index, void *soft_v, void **data)
 {
-       ParticleSystemModifierData *psmd;
-       ModifierData *md;
-       int a;
+       SoftBody *soft= soft_v;
+       BodyPoint *bp = soft->bpoint + index;
+
+       PTCACHE_DATA_FROM(data, BPHYS_DATA_LOCATION, bp->pos);
+       PTCACHE_DATA_FROM(data, BPHYS_DATA_VELOCITY, bp->vec);
+
+       return 1;
+}
+static void ptcache_read_softbody(int index, void *soft_v, void **data, float frs_sec, float cfra, float *old_data)
+{
+       SoftBody *soft= soft_v;
+       BodyPoint *bp = soft->bpoint + index;
+
+       if(old_data) {
+               memcpy(bp->pos, data, 3 * sizeof(float));
+               memcpy(bp->vec, data + 3, 3 * sizeof(float));
+       }
+       else {
+               PTCACHE_DATA_TO(data, BPHYS_DATA_LOCATION, 0, bp->pos);
+               PTCACHE_DATA_TO(data, BPHYS_DATA_VELOCITY, 0, bp->vec);
+       }
+}
+static void ptcache_interpolate_softbody(int index, void *soft_v, void **data, float frs_sec, float cfra, float cfra1, float cfra2, float *old_data)
+{
+       SoftBody *soft= soft_v;
+       BodyPoint *bp = soft->bpoint + index;
+       ParticleKey keys[4];
+       float dfra;
+
+       if(cfra1 == cfra2)
+               return;
+
+       VECCOPY(keys[1].co, bp->pos);
+       VECCOPY(keys[1].vel, bp->vec);
+
+       if(old_data) {
+               memcpy(keys[2].co, old_data, 3 * sizeof(float));
+               memcpy(keys[2].vel, old_data + 3, 3 * sizeof(float));
+       }
+       else
+               BKE_ptcache_make_particle_key(keys+2, 0, data, cfra2);
+
+       dfra = cfra2 - cfra1;
+
+       VecMulf(keys[1].vel, dfra);
+       VecMulf(keys[2].vel, dfra);
+
+       psys_interpolate_particle(-1, keys, (cfra - cfra1) / dfra, keys, 1);
+
+       VecMulf(keys->vel, 1.0f / dfra);
+
+       VECCOPY(bp->pos, keys->co);
+       VECCOPY(bp->vec, keys->vel);
+}
+static int ptcache_totpoint_softbody(void *soft_v)
+{
+       SoftBody *soft= soft_v;
+       return soft->totpoint;
+}
+/* Particle functions */
+static int ptcache_write_particle(int index, void *psys_v, void **data)
+{
+       ParticleSystem *psys= psys_v;
+       ParticleData *pa = psys->particles + index;
+       BoidParticle *boid = (psys->part->phystype == PART_PHYS_BOIDS) ? pa->boid : NULL;
+       float times[3] = {pa->time, pa->dietime, pa->lifetime};
+
+       if(data[BPHYS_DATA_INDEX]) {
+               int step = psys->pointcache->step;
+               /* No need to store unborn or died particles */
+               if(pa->time - step > pa->state.time || pa->dietime + step < pa->state.time)
+                       return 0;
+       }
+       
+       PTCACHE_DATA_FROM(data, BPHYS_DATA_INDEX, &index);
+       PTCACHE_DATA_FROM(data, BPHYS_DATA_LOCATION, pa->state.co);
+       PTCACHE_DATA_FROM(data, BPHYS_DATA_VELOCITY, pa->state.vel);
+       PTCACHE_DATA_FROM(data, BPHYS_DATA_ROTATION, pa->state.rot);
+       PTCACHE_DATA_FROM(data, BPHYS_DATA_AVELOCITY, pa->state.ave);
+       PTCACHE_DATA_FROM(data, BPHYS_DATA_SIZE, &pa->size);
+       PTCACHE_DATA_FROM(data, BPHYS_DATA_TIMES, times);
+
+       if(boid)
+               PTCACHE_DATA_FROM(data, BPHYS_DATA_BOIDS, &boid->data);
+
+       return 1;
+}
+void BKE_ptcache_make_particle_key(ParticleKey *key, int index, void **data, float time)
+{
+       PTCACHE_DATA_TO(data, BPHYS_DATA_LOCATION, index, key->co);
+       PTCACHE_DATA_TO(data, BPHYS_DATA_VELOCITY, index, key->vel);
+       PTCACHE_DATA_TO(data, BPHYS_DATA_ROTATION, index, key->rot);
+       PTCACHE_DATA_TO(data, BPHYS_DATA_AVELOCITY, index, key->ave);
+       key->time = time;
+}
+static void ptcache_read_particle(int index, void *psys_v, void **data, float frs_sec, float cfra, float *old_data)
+{
+       ParticleSystem *psys= psys_v;
+       ParticleData *pa = psys->particles + index;
+       BoidParticle *boid = (psys->part->phystype == PART_PHYS_BOIDS) ? pa->boid : NULL;
+
+       if(cfra > pa->state.time)
+               memcpy(&pa->prev_state, &pa->state, sizeof(ParticleKey));
+
+       if(old_data){
+               /* old format cache */
+               memcpy(&pa->state, old_data, sizeof(ParticleKey));
+               return;
+       }
+
+       BKE_ptcache_make_particle_key(&pa->state, 0, data, cfra);
+
+       if(data[BPHYS_DATA_SIZE])
+               PTCACHE_DATA_TO(data, BPHYS_DATA_SIZE, 0, &pa->size);
+       
+       if(data[BPHYS_DATA_TIMES]) {
+               float times[3];
+               PTCACHE_DATA_TO(data, BPHYS_DATA_TIMES, 0, &times);
+               pa->time = times[0];
+               pa->dietime = times[1];
+               pa->lifetime = times[2];
+       }
+
+       if(boid)
+               PTCACHE_DATA_TO(data, BPHYS_DATA_BOIDS, 0, &boid->data);
+
+       /* determine velocity from previous location */
+       if(data[BPHYS_DATA_LOCATION] && !data[BPHYS_DATA_VELOCITY]) {
+               if(cfra > pa->prev_state.time) {
+                       VecSubf(pa->state.vel, pa->state.co, pa->prev_state.co);
+                       VecMulf(pa->state.vel, (cfra - pa->prev_state.time) / frs_sec);
+               }
+               else {
+                       VecSubf(pa->state.vel, pa->prev_state.co, pa->state.co);
+                       VecMulf(pa->state.vel, (pa->prev_state.time - cfra) / frs_sec);
+               }
+       }
+
+       /* determine rotation from velocity */
+       if(data[BPHYS_DATA_LOCATION] && !data[BPHYS_DATA_ROTATION]) {
+               vectoquat(pa->state.vel, OB_POSX, OB_POSZ, pa->state.rot);
+       }
+}
+static void ptcache_interpolate_particle(int index, void *psys_v, void **data, float frs_sec, float cfra, float cfra1, float cfra2, float *old_data)
+{
+       ParticleSystem *psys= psys_v;
+       ParticleData *pa = psys->particles + index;
+       ParticleKey keys[4];
+       float dfra;
+
+       cfra = MIN2(cfra, pa->dietime);
+       cfra1 = MIN2(cfra1, pa->dietime);
+       cfra2 = MIN2(cfra2, pa->dietime);
+
+       if(cfra1 == cfra2)
+               return;
+
+       memcpy(keys+1, &pa->state, sizeof(ParticleKey));
+       if(old_data)
+               memcpy(keys+2, old_data, sizeof(ParticleKey));
+       else
+               BKE_ptcache_make_particle_key(keys+2, 0, data, cfra2);
+
+       dfra = cfra2 - cfra1;
+
+       VecMulf(keys[1].vel, dfra / frs_sec);
+       VecMulf(keys[2].vel, dfra / frs_sec);
+
+       psys_interpolate_particle(-1, keys, (cfra - cfra1) / dfra, &pa->state, 1);
+       QuatInterpol(pa->state.rot, keys[1].rot,keys[2].rot, (cfra - cfra1) / dfra);
+
+       VecMulf(pa->state.vel, frs_sec / dfra);
+
+       pa->state.time = cfra;
+}
+
+static int ptcache_totpoint_particle(void *psys_v)
+{
+       ParticleSystem *psys = psys_v;
+       return psys->totpart;
+}
+static int ptcache_totwrite_particle(void *psys_v)
+{
+       ParticleSystem *psys = psys_v;
+       int totwrite = 0;
+
+       /* TODO for later */
+       //if((psys->part->flag & (PART_UNBORN|PART_DIED))==0) {
+       //      ParticleData *pa= psys->particles;
+       //      int p, step = psys->pointcache->step;
+
+       //      for(p=0; p<psys->totpart; p++,pa++)
+       //              totwrite += (pa->time - step > pa->state.time || pa->dietime + step > pa->state.time);
+       //}
+       //else
+               totwrite= psys->totpart;
+
+       return totwrite;
+}
+
+//static int ptcache_write_particle_stream(PTCacheFile *pf, PTCacheMem *pm, void *psys_v)
+//{
+//     ParticleSystem *psys= psys_v;
+//     ParticleData *pa = psys->particles;
+//     BoidParticle *boid = NULL;
+//     float times[3];
+//     int i = 0;
+//
+//     if(!pf && !pm)
+//             return 0;
+//
+//     for(i=0; i<psys->totpart; i++, pa++) {
+//
+//             if(data[BPHYS_DATA_INDEX]) {
+//                     int step = psys->pointcache->step;
+//                     /* No need to store unborn or died particles */
+//                     if(pa->time - step > pa->state.time || pa->dietime + step < pa->state.time)
+//                             continue;
+//             }
+//
+//             times[0] = pa->time;
+//             times[1] = pa->dietime;
+//             times[2] = pa->lifetime;
+//             
+//             PTCACHE_DATA_FROM(data, BPHYS_DATA_INDEX, &index);
+//             PTCACHE_DATA_FROM(data, BPHYS_DATA_LOCATION, pa->state.co);
+//             PTCACHE_DATA_FROM(data, BPHYS_DATA_VELOCITY, pa->state.vel);
+//             PTCACHE_DATA_FROM(data, BPHYS_DATA_ROTATION, pa->state.rot);
+//             PTCACHE_DATA_FROM(data, BPHYS_DATA_AVELOCITY, pa->state.ave);
+//             PTCACHE_DATA_FROM(data, BPHYS_DATA_SIZE, &pa->size);
+//             PTCACHE_DATA_FROM(data, BPHYS_DATA_TIMES, times);
+//
+//             boid = (psys->part->phystype == PART_PHYS_BOIDS) ? pa->boid : NULL;
+//             if(boid)
+//                     PTCACHE_DATA_FROM(data, BPHYS_DATA_BOIDS, &boid->data);
+//
+//             if(pf && !ptcache_file_write_data(pf))
+//                     return 0;
+//
+//             if(pm)
+//                     BKE_ptcache_mem_incr_pointers(pm);
+//     }
+//
+//     return 1;
+//}
+//static void ptcache_read_particle_stream(PTCacheFile *pf, PTCacheMem *pm, void *psys_v, void **data, float frs_sec, float cfra, float *old_data)
+//{
+//     ParticleSystem *psys= psys_v;
+//     ParticleData *pa = psys->particles + index;
+//     BoidParticle *boid = (psys->part->phystype == PART_PHYS_BOIDS) ? pa->boid : NULL;
+//
+//     if(cfra > pa->state.time)
+//             memcpy(&pa->prev_state, &pa->state, sizeof(ParticleKey));
+//
+//     if(old_data){
+//             /* old format cache */
+//             memcpy(&pa->state, old_data, sizeof(ParticleKey));
+//             return;
+//     }
+//
+//     BKE_ptcache_make_particle_key(&pa->state, 0, data, cfra);
+//
+//     if(data[BPHYS_DATA_SIZE])
+//             PTCACHE_DATA_TO(data, BPHYS_DATA_SIZE, 0, &pa->size);
+//     
+//     if(data[BPHYS_DATA_TIMES]) {
+//             float times[3];
+//             PTCACHE_DATA_TO(data, BPHYS_DATA_TIMES, 0, &times);
+//             pa->time = times[0];
+//             pa->dietime = times[1];
+//             pa->lifetime = times[2];
+//     }
+//
+//     if(boid)
+//             PTCACHE_DATA_TO(data, BPHYS_DATA_BOIDS, 0, &boid->data);
+//
+//     /* determine velocity from previous location */
+//     if(data[BPHYS_DATA_LOCATION] && !data[BPHYS_DATA_VELOCITY]) {
+//             if(cfra > pa->prev_state.time) {
+//                     VecSubf(pa->state.vel, pa->state.co, pa->prev_state.co);
+//                     VecMulf(pa->state.vel, (cfra - pa->prev_state.time) / frs_sec);
+//             }
+//             else {
+//                     VecSubf(pa->state.vel, pa->prev_state.co, pa->state.co);
+//                     VecMulf(pa->state.vel, (pa->prev_state.time - cfra) / frs_sec);
+//             }
+//     }
+//
+//     /* determine rotation from velocity */
+//     if(data[BPHYS_DATA_LOCATION] && !data[BPHYS_DATA_ROTATION]) {
+//             vectoquat(pa->state.vel, OB_POSX, OB_POSZ, pa->state.rot);
+//     }
+//}
+//static void ptcache_interpolate_particle_stream(int index, void *psys_v, void **data, float frs_sec, float cfra, float cfra1, float cfra2, float *old_data)
+//{
+//     ParticleSystem *psys= psys_v;
+//     ParticleData *pa = psys->particles + index;
+//     ParticleKey keys[4];
+//     float dfra;
+//
+//     cfra = MIN2(cfra, pa->dietime);
+//     cfra1 = MIN2(cfra1, pa->dietime);
+//     cfra2 = MIN2(cfra2, pa->dietime);
+//
+//     if(cfra1 == cfra2)
+//             return;
+//
+//     memcpy(keys+1, &pa->state, sizeof(ParticleKey));
+//     if(old_data)
+//             memcpy(keys+2, old_data, sizeof(ParticleKey));
+//     else
+//             BKE_ptcache_make_particle_key(keys+2, 0, data, cfra2);
+//
+//     dfra = cfra2 - cfra1;
+//
+//     VecMulf(keys[1].vel, dfra / frs_sec);
+//     VecMulf(keys[2].vel, dfra / frs_sec);
+//
+//     psys_interpolate_particle(-1, keys, (cfra - cfra1) / dfra, &pa->state, 1);
+//     QuatInterpol(pa->state.rot, keys[1].rot,keys[2].rot, (cfra - cfra1) / dfra);
+//
+//     VecMulf(pa->state.vel, frs_sec / dfra);
+//
+//     pa->state.time = cfra;
+//}
+//
+/* Cloth functions */
+static int ptcache_write_cloth(int index, void *cloth_v, void **data)
+{
+       ClothModifierData *clmd= cloth_v;
+       Cloth *cloth= clmd->clothObject;
+       ClothVertex *vert = cloth->verts + index;
+
+       PTCACHE_DATA_FROM(data, BPHYS_DATA_LOCATION, vert->x);
+       PTCACHE_DATA_FROM(data, BPHYS_DATA_VELOCITY, vert->v);
+       PTCACHE_DATA_FROM(data, BPHYS_DATA_XCONST, vert->xconst);
+
+       return 1;
+}
+static void ptcache_read_cloth(int index, void *cloth_v, void **data, float frs_sec, float cfra, float *old_data)
+{
+       ClothModifierData *clmd= cloth_v;
+       Cloth *cloth= clmd->clothObject;
+       ClothVertex *vert = cloth->verts + index;
+       
+       if(old_data) {
+               memcpy(vert->x, data, 3 * sizeof(float));
+               memcpy(vert->xconst, data + 3, 3 * sizeof(float));
+               memcpy(vert->v, data + 6, 3 * sizeof(float));
+       }
+       else {
+               PTCACHE_DATA_TO(data, BPHYS_DATA_LOCATION, 0, vert->x);
+               PTCACHE_DATA_TO(data, BPHYS_DATA_VELOCITY, 0, vert->v);
+               PTCACHE_DATA_TO(data, BPHYS_DATA_XCONST, 0, vert->xconst);
+       }
+}
+static void ptcache_interpolate_cloth(int index, void *cloth_v, void **data, float frs_sec, float cfra, float cfra1, float cfra2, float *old_data)
+{
+       ClothModifierData *clmd= cloth_v;
+       Cloth *cloth= clmd->clothObject;
+       ClothVertex *vert = cloth->verts + index;
+       ParticleKey keys[4];
+       float dfra;
+
+       if(cfra1 == cfra2)
+               return;
+
+       VECCOPY(keys[1].co, vert->x);
+       VECCOPY(keys[1].vel, vert->v);
 
+       if(old_data) {
+               memcpy(keys[2].co, old_data, 3 * sizeof(float));
+               memcpy(keys[2].vel, old_data + 6, 3 * sizeof(float));
+       }
+       else
+               BKE_ptcache_make_particle_key(keys+2, 0, data, cfra2);
+
+       dfra = cfra2 - cfra1;
+
+       VecMulf(keys[1].vel, dfra);
+       VecMulf(keys[2].vel, dfra);
+
+       psys_interpolate_particle(-1, keys, (cfra - cfra1) / dfra, keys, 1);
+
+       VecMulf(keys->vel, 1.0f / dfra);
+
+       VECCOPY(vert->x, keys->co);
+       VECCOPY(vert->v, keys->vel);
+
+       /* should vert->xconst be interpolated somehow too? - jahka */
+}
+
+static int ptcache_totpoint_cloth(void *cloth_v)
+{
+       ClothModifierData *clmd= cloth_v;
+       return clmd->clothObject->numverts;
+}
+
+/* Creating ID's */
+void BKE_ptcache_id_from_softbody(PTCacheID *pid, Object *ob, SoftBody *sb)
+{
        memset(pid, 0, sizeof(PTCacheID));
 
        pid->ob= ob;
-       pid->data= sb;
+       pid->calldata= sb;
        pid->type= PTCACHE_TYPE_SOFTBODY;
        pid->cache= sb->pointcache;
+       pid->cache_ptr= &sb->pointcache;
+       pid->ptcaches= &sb->ptcaches;
+       pid->totpoint= pid->totwrite= ptcache_totpoint_softbody;
+
+       pid->write_elem= ptcache_write_softbody;
+       pid->write_stream = NULL;
+       pid->read_stream = NULL;
+       pid->read_elem= ptcache_read_softbody;
+       pid->interpolate_elem= ptcache_interpolate_softbody;
+
+       pid->write_header= ptcache_write_basic_header;
+       pid->read_header= ptcache_read_basic_header;
+
+       pid->data_types= (1<<BPHYS_DATA_LOCATION) | (1<<BPHYS_DATA_VELOCITY);
+       pid->info_types= 0;
+
+       pid->stack_index = pid->cache->index;
+}
+
+void BKE_ptcache_id_from_particles(PTCacheID *pid, Object *ob, ParticleSystem *psys)
+{
+       memset(pid, 0, sizeof(PTCacheID));
+
+       pid->ob= ob;
+       pid->calldata= psys;
+       pid->type= PTCACHE_TYPE_PARTICLES;
+       pid->stack_index= psys->pointcache->index;
+       pid->cache= psys->pointcache;
+       pid->cache_ptr= &psys->pointcache;
+       pid->ptcaches= &psys->ptcaches;
 
-       if(sb->particles) {
-               psmd= psys_get_modifier(ob, sb->particles);
-               pid->stack_index= modifiers_indexInObject(ob, (ModifierData*)psmd);
+       if(psys->part->type != PART_HAIR)
+               pid->flag |= PTCACHE_VEL_PER_SEC;
+
+       pid->write_elem= ptcache_write_particle;
+       pid->write_stream = NULL;
+       pid->read_stream = NULL;
+       pid->read_elem= ptcache_read_particle;
+       pid->interpolate_elem= ptcache_interpolate_particle;
+
+       pid->totpoint= ptcache_totpoint_particle;
+       pid->totwrite= ptcache_totwrite_particle;
+
+       pid->write_header= ptcache_write_basic_header;
+       pid->read_header= ptcache_read_basic_header;
+
+       pid->data_types= (1<<BPHYS_DATA_LOCATION) | (1<<BPHYS_DATA_VELOCITY);
+
+       /* TODO for later */
+       //if((psys->part->flag & (PART_UNBORN|PART_DIED))==0)
+       //      pid->data_types|= (1<<BPHYS_DATA_INDEX);
+
+       if(psys->part->phystype == PART_PHYS_BOIDS)
+               pid->data_types|= (1<<BPHYS_DATA_AVELOCITY) | (1<<BPHYS_DATA_ROTATION) | (1<<BPHYS_DATA_BOIDS);
+
+       if(psys->part->rotmode || psys->part->avemode)
+               pid->data_types|= (1<<BPHYS_DATA_AVELOCITY) | (1<<BPHYS_DATA_ROTATION);
+
+       if(psys->part->flag & PART_ROT_DYN)
+               pid->data_types|= (1<<BPHYS_DATA_ROTATION);
+
+       pid->info_types= (1<<BPHYS_DATA_TIMES);
+}
+
+/* Smoke functions */
+static int ptcache_totpoint_smoke(void *smoke_v)
+{
+       SmokeModifierData *smd= (SmokeModifierData *)smoke_v;
+       SmokeDomainSettings *sds = smd->domain;
+       
+       if(sds->fluid) {
+               return sds->res[0]*sds->res[1]*sds->res[2];
        }
-       else {
-               for(a=0, md=ob->modifiers.first; md; md=md->next, a++) {
-                       if(md->type == eModifierType_Softbody) {
-                               pid->stack_index = a;
-                               break;
-                       }
+       else
+               return 0;
+}
+
+/* Smoke functions */
+static int ptcache_totpoint_smoke_turbulence(void *smoke_v)
+{
+       SmokeModifierData *smd= (SmokeModifierData *)smoke_v;
+       SmokeDomainSettings *sds = smd->domain;
+       
+       if(sds->wt) {
+               return sds->res_wt[0]*sds->res_wt[1]*sds->res_wt[2];
+       }
+       else
+               return 0;
+}
+
+// forward decleration
+static int ptcache_file_write(PTCacheFile *pf, void *f, size_t tot, int size);
+
+static int ptcache_compress_write(PTCacheFile *pf, unsigned char *in, unsigned int in_len, unsigned char *out, int mode)
+{
+       int r = 0;
+       unsigned char compressed;
+       LZO_HEAP_ALLOC(wrkmem, LZO1X_MEM_COMPRESS);
+       unsigned int out_len = LZO_OUT_LEN(in_len);
+       unsigned char *props = MEM_callocN(16*sizeof(char), "tmp");
+       size_t sizeOfIt = 5;
+
+       if(mode == 1) {
+               r = lzo1x_1_compress(in, (lzo_uint)in_len, out, (lzo_uint *)&out_len, wrkmem);  
+               if (!(r == LZO_E_OK) || (out_len >= in_len))
+                       compressed = 0;
+               else
+                       compressed = 1;
+       }
+       else if(mode == 2) {
+               
+               r = LzmaCompress(out, (size_t *)&out_len, in, in_len,//assume sizeof(char)==1....
+                                               props, &sizeOfIt, 5, 1 << 24, 3, 0, 2, 32, 2);
+
+               if(!(r == SZ_OK) || (out_len >= in_len))
+                       compressed = 0;
+               else
+                       compressed = 2;
+       }
+
+       ptcache_file_write(pf, &compressed, 1, sizeof(unsigned char));
+       if(compressed) {
+               ptcache_file_write(pf, &out_len, 1, sizeof(unsigned int));
+               ptcache_file_write(pf, out, out_len, sizeof(unsigned char));
+       }
+       else
+               ptcache_file_write(pf, in, in_len, sizeof(unsigned char));
+
+       if(compressed == 2)
+       {
+               ptcache_file_write(pf, &sizeOfIt, 1, sizeof(unsigned int));
+               ptcache_file_write(pf, props, sizeOfIt, sizeof(unsigned char));
+       }
+
+       MEM_freeN(props);
+
+       return r;
+}
+
+static int ptcache_write_smoke(PTCacheFile *pf, void *smoke_v)
+{      
+       SmokeModifierData *smd= (SmokeModifierData *)smoke_v;
+       SmokeDomainSettings *sds = smd->domain;
+       
+       if(sds->fluid) {
+               size_t res = sds->res[0]*sds->res[1]*sds->res[2];
+               float dt, dx, *dens, *densold, *heat, *heatold, *vx, *vy, *vz, *vxold, *vyold, *vzold;
+               unsigned char *obstacles;
+               unsigned int in_len = sizeof(float)*(unsigned int)res;
+               unsigned char *out = (unsigned char *)MEM_callocN(LZO_OUT_LEN(in_len)*4, "pointcache_lzo_buffer");
+               int mode = res >= 1000000 ? 2 : 1;
+
+               smoke_export(sds->fluid, &dt, &dx, &dens, &densold, &heat, &heatold, &vx, &vy, &vz, &vxold, &vyold, &vzold, &obstacles);
+
+               ptcache_compress_write(pf, (unsigned char *)sds->shadow, in_len, out, mode);
+               ptcache_compress_write(pf, (unsigned char *)dens, in_len, out, mode);
+               ptcache_compress_write(pf, (unsigned char *)densold, in_len, out, mode);        
+               ptcache_compress_write(pf, (unsigned char *)heat, in_len, out, mode);
+               ptcache_compress_write(pf, (unsigned char *)heatold, in_len, out, mode);
+               ptcache_compress_write(pf, (unsigned char *)vx, in_len, out, mode);
+               ptcache_compress_write(pf, (unsigned char *)vy, in_len, out, mode);
+               ptcache_compress_write(pf, (unsigned char *)vz, in_len, out, mode);
+               ptcache_compress_write(pf, (unsigned char *)vxold, in_len, out, mode);
+               ptcache_compress_write(pf, (unsigned char *)vyold, in_len, out, mode);
+               ptcache_compress_write(pf, (unsigned char *)vzold, in_len, out, mode);
+               ptcache_compress_write(pf, (unsigned char *)obstacles, (unsigned int)res, out, mode);
+               ptcache_file_write(pf, &dt, 1, sizeof(float));
+               ptcache_file_write(pf, &dx, 1, sizeof(float));
+
+               MEM_freeN(out);
+               
+               return 1;
+       }
+       return 0;
+}
+
+static int ptcache_write_smoke_turbulence(PTCacheFile *pf, void *smoke_v)
+{
+       SmokeModifierData *smd= (SmokeModifierData *)smoke_v;
+       SmokeDomainSettings *sds = smd->domain;
+       
+       if(sds->wt) {
+               int res_big_array[3];
+               int res_big;
+               int res = sds->res[0]*sds->res[1]*sds->res[2];
+               float *dens, *densold, *tcu, *tcv, *tcw;
+               unsigned int in_len = sizeof(float)*(unsigned int)res;
+               unsigned int in_len_big;
+               unsigned char *out;
+               int mode;
+
+               smoke_turbulence_get_res(sds->wt, res_big_array);
+               res_big = res_big_array[0]*res_big_array[1]*res_big_array[2];
+               mode =  res_big >= 1000000 ? 2 : 1;
+               in_len_big = sizeof(float) * (unsigned int)res_big;
+
+               smoke_turbulence_export(sds->wt, &dens, &densold, &tcu, &tcv, &tcw);
+
+               out = (unsigned char *)MEM_callocN(LZO_OUT_LEN(in_len_big), "pointcache_lzo_buffer");
+               ptcache_compress_write(pf, (unsigned char *)dens, in_len_big, out, mode);
+               ptcache_compress_write(pf, (unsigned char *)densold, in_len_big, out, mode);    
+               MEM_freeN(out);
+
+               out = (unsigned char *)MEM_callocN(LZO_OUT_LEN(in_len), "pointcache_lzo_buffer");
+               ptcache_compress_write(pf, (unsigned char *)tcu, in_len, out, mode);
+               ptcache_compress_write(pf, (unsigned char *)tcv, in_len, out, mode);
+               ptcache_compress_write(pf, (unsigned char *)tcw, in_len, out, mode);
+               MEM_freeN(out);
+               
+               return 1;
+       }
+       return 0;
+}
+
+// forward decleration
+static int ptcache_file_read(PTCacheFile *pf, void *f, size_t tot, int size);
+
+static int ptcache_compress_read(PTCacheFile *pf, unsigned char *result, unsigned int len)
+{
+       int r = 0;
+       unsigned char compressed = 0;
+       unsigned int in_len;
+       unsigned int out_len = len;
+       unsigned char *in;
+       unsigned char *props = MEM_callocN(16*sizeof(char), "tmp");
+       size_t sizeOfIt = 5;
+
+       ptcache_file_read(pf, &compressed, 1, sizeof(unsigned char));
+       if(compressed) {
+               ptcache_file_read(pf, &in_len, 1, sizeof(unsigned int));
+               in = (unsigned char *)MEM_callocN(sizeof(unsigned char)*in_len, "pointcache_compressed_buffer");
+               ptcache_file_read(pf, in, in_len, sizeof(unsigned char));
+
+               if(compressed == 1)
+                               r = lzo1x_decompress(in, (lzo_uint)in_len, result, (lzo_uint *)&out_len, NULL);
+               else if(compressed == 2)
+               {
+                       size_t leni = in_len, leno = out_len;
+                       ptcache_file_read(pf, &sizeOfIt, 1, sizeof(unsigned int));
+                       ptcache_file_read(pf, props, sizeOfIt, sizeof(unsigned char));
+                       r = LzmaUncompress(result, &leno, in, &leni, props, sizeOfIt);
                }
+
+               MEM_freeN(in);
        }
+       else {
+               ptcache_file_read(pf, result, len, sizeof(unsigned char));
+       }
+
+       MEM_freeN(props);
+
+       return r;
 }
 
-void BKE_ptcache_id_from_particles(PTCacheID *pid, Object *ob, ParticleSystem *psys)
+static void ptcache_read_smoke(PTCacheFile *pf, void *smoke_v)
+{
+       SmokeModifierData *smd= (SmokeModifierData *)smoke_v;
+       SmokeDomainSettings *sds = smd->domain;
+       
+       if(sds->fluid) {
+               size_t res = sds->res[0]*sds->res[1]*sds->res[2];
+               float dt, dx, *dens, *densold, *heat, *heatold, *vx, *vy, *vz, *vxold, *vyold, *vzold;
+               unsigned char *obstacles;
+               unsigned int out_len = (unsigned int)res * sizeof(float);
+               
+               smoke_export(sds->fluid, &dt, &dx, &dens, &densold, &heat, &heatold, &vx, &vy, &vz, &vxold, &vyold, &vzold, &obstacles);
+
+               ptcache_compress_read(pf, (unsigned char *)sds->shadow, out_len);
+               ptcache_compress_read(pf, (unsigned char*)dens, out_len);
+               ptcache_compress_read(pf, (unsigned char*)densold, out_len);
+               ptcache_compress_read(pf, (unsigned char*)heat, out_len);
+               ptcache_compress_read(pf, (unsigned char*)heatold, out_len);
+               ptcache_compress_read(pf, (unsigned char*)vx, out_len);
+               ptcache_compress_read(pf, (unsigned char*)vy, out_len);
+               ptcache_compress_read(pf, (unsigned char*)vz, out_len);
+               ptcache_compress_read(pf, (unsigned char*)vxold, out_len);
+               ptcache_compress_read(pf, (unsigned char*)vyold, out_len);
+               ptcache_compress_read(pf, (unsigned char*)vzold, out_len);
+               ptcache_compress_read(pf, (unsigned char*)obstacles, (unsigned int)res);
+               ptcache_file_read(pf, &dt, 1, sizeof(float));
+               ptcache_file_read(pf, &dx, 1, sizeof(float));
+       }
+}
+
+static void ptcache_read_smoke_turbulence(PTCacheFile *pf, void *smoke_v)
+{
+       SmokeModifierData *smd= (SmokeModifierData *)smoke_v;
+       SmokeDomainSettings *sds = smd->domain;
+       
+       if(sds->fluid) {
+               int res = sds->res[0]*sds->res[1]*sds->res[2];
+               int res_big, res_big_array[3];
+               float *dens, *densold, *tcu, *tcv, *tcw;
+               unsigned int out_len = sizeof(float)*(unsigned int)res;
+               unsigned int out_len_big;
+
+               smoke_turbulence_get_res(sds->wt, res_big_array);
+               res_big = res_big_array[0]*res_big_array[1]*res_big_array[2];
+               out_len_big = sizeof(float) * (unsigned int)res_big;
+
+               smoke_turbulence_export(sds->wt, &dens, &densold, &tcu, &tcv, &tcw);
+
+               ptcache_compress_read(pf, (unsigned char*)dens, out_len_big);
+               ptcache_compress_read(pf, (unsigned char*)densold, out_len_big);
+
+               ptcache_compress_read(pf, (unsigned char*)tcu, out_len);
+               ptcache_compress_read(pf, (unsigned char*)tcv, out_len);
+               ptcache_compress_read(pf, (unsigned char*)tcw, out_len);                
+       }
+}
+
+void BKE_ptcache_id_from_smoke(PTCacheID *pid, struct Object *ob, struct SmokeModifierData *smd)
 {
-       ParticleSystemModifierData *psmd= psys_get_modifier(ob, psys);
+       SmokeDomainSettings *sds = smd->domain;
 
        memset(pid, 0, sizeof(PTCacheID));
 
        pid->ob= ob;
-       pid->data= psys;
-       pid->type= PTCACHE_TYPE_PARTICLES;
-       pid->stack_index= modifiers_indexInObject(ob, (ModifierData *)psmd);
-       pid->cache= psys->pointcache;
+       pid->calldata= smd;
+       
+       pid->type= PTCACHE_TYPE_SMOKE_DOMAIN;
+       pid->stack_index= sds->point_cache[0]->index;
+
+       pid->cache= sds->point_cache[0];
+       pid->cache_ptr= &(sds->point_cache[0]);
+       pid->ptcaches= &(sds->ptcaches[0]);
+
+       pid->totpoint= pid->totwrite= ptcache_totpoint_smoke;
+
+       pid->write_elem= NULL;
+       pid->read_elem= NULL;
+
+       pid->read_stream = ptcache_read_smoke;
+       pid->write_stream = ptcache_write_smoke;
+       
+       pid->interpolate_elem= NULL;
+
+       pid->write_header= ptcache_write_basic_header;
+       pid->read_header= ptcache_read_basic_header;
+
+       pid->data_types= (1<<BPHYS_DATA_LOCATION); // bogus values to make pointcache happy
+       pid->info_types= 0;
+}
+
+void BKE_ptcache_id_from_smoke_turbulence(PTCacheID *pid, struct Object *ob, struct SmokeModifierData *smd)
+{
+       SmokeDomainSettings *sds = smd->domain;
+
+       memset(pid, 0, sizeof(PTCacheID));
+
+       pid->ob= ob;
+       pid->calldata= smd;
+       
+       pid->type= PTCACHE_TYPE_SMOKE_HIGHRES;
+       pid->stack_index= sds->point_cache[1]->index;
+
+       pid->cache= sds->point_cache[1];
+       pid->cache_ptr= &sds->point_cache[1];
+       pid->ptcaches= &sds->ptcaches[1];
+
+       pid->totpoint= pid->totwrite= ptcache_totpoint_smoke_turbulence;
+
+       pid->write_elem= NULL;
+       pid->read_elem= NULL;
+
+       pid->read_stream = ptcache_read_smoke_turbulence;
+       pid->write_stream = ptcache_write_smoke_turbulence;
+       
+       pid->interpolate_elem= NULL;
+
+       pid->write_header= ptcache_write_basic_header;
+       pid->read_header= ptcache_read_basic_header;
+
+       pid->data_types= (1<<BPHYS_DATA_LOCATION); // bogus values tot make pointcache happy
+       pid->info_types= 0;
 }
 
 void BKE_ptcache_id_from_cloth(PTCacheID *pid, Object *ob, ClothModifierData *clmd)
@@ -124,10 +911,25 @@ void BKE_ptcache_id_from_cloth(PTCacheID *pid, Object *ob, ClothModifierData *cl
        memset(pid, 0, sizeof(PTCacheID));
 
        pid->ob= ob;
-       pid->data= clmd;
+       pid->calldata= clmd;
        pid->type= PTCACHE_TYPE_CLOTH;
-       pid->stack_index= modifiers_indexInObject(ob, (ModifierData *)clmd);
+       pid->stack_index= clmd->point_cache->index;
        pid->cache= clmd->point_cache;
+       pid->cache_ptr= &clmd->point_cache;
+       pid->ptcaches= &clmd->ptcaches;
+       pid->totpoint= pid->totwrite= ptcache_totpoint_cloth;
+
+       pid->write_elem= ptcache_write_cloth;
+       pid->write_stream = NULL;
+       pid->read_stream = NULL;
+       pid->read_elem= ptcache_read_cloth;
+       pid->interpolate_elem= ptcache_interpolate_cloth;
+
+       pid->write_header= ptcache_write_basic_header;
+       pid->read_header= ptcache_read_basic_header;
+
+       pid->data_types= (1<<BPHYS_DATA_LOCATION) | (1<<BPHYS_DATA_VELOCITY) | (1<<BPHYS_DATA_XCONST);
+       pid->info_types= 0;
 }
 
 void BKE_ptcache_ids_from_object(ListBase *lb, Object *ob)
@@ -145,13 +947,9 @@ void BKE_ptcache_ids_from_object(ListBase *lb, Object *ob)
        }
 
        for(psys=ob->particlesystem.first; psys; psys=psys->next) {
-               pid= MEM_callocN(sizeof(PTCacheID), "PTCacheID");
-               BKE_ptcache_id_from_particles(pid, ob, psys);
-               BLI_addtail(lb, pid);
-
-               if(psys->soft) {
+               if(psys->part) {
                        pid= MEM_callocN(sizeof(PTCacheID), "PTCacheID");
-                       BKE_ptcache_id_from_softbody(pid, ob, psys->soft);
+                       BKE_ptcache_id_from_particles(pid, ob, psys);
                        BLI_addtail(lb, pid);
                }
        }
@@ -162,9 +960,25 @@ void BKE_ptcache_ids_from_object(ListBase *lb, Object *ob)
                        BKE_ptcache_id_from_cloth(pid, ob, (ClothModifierData*)md);
                        BLI_addtail(lb, pid);
                }
+               if(md->type == eModifierType_Smoke) {
+                       SmokeModifierData *smd = (SmokeModifierData *)md;
+                       if(smd->type & MOD_SMOKE_TYPE_DOMAIN)
+                       {
+                               pid= MEM_callocN(sizeof(PTCacheID), "PTCacheID");
+                               BKE_ptcache_id_from_smoke(pid, ob, (SmokeModifierData*)md);
+                               BLI_addtail(lb, pid);
+
+                               pid= MEM_callocN(sizeof(PTCacheID), "PTCacheID");
+                               BKE_ptcache_id_from_smoke_turbulence(pid, ob, (SmokeModifierData*)md);
+                               BLI_addtail(lb, pid);
+                       }
+               }
        }
 }
 
+
+/* File handling */
+
 /*     Takes an Object ID and returns a unique name
        - id: object id
        - cfra: frame for the cache, can be negative
@@ -177,11 +991,15 @@ void BKE_ptcache_ids_from_object(ListBase *lb, Object *ob)
 static int ptcache_path(PTCacheID *pid, char *filename)
 {
        Library *lib;
-       int i;
+       size_t i;
 
        lib= (pid)? pid->ob->id.lib: NULL;
 
-       if (G.relbase_valid || lib) {
+       if(pid->cache->flag & PTCACHE_EXTERNAL) {
+               strcpy(filename, pid->cache->path);
+               return BLI_add_slash(filename); /* new strlen() */
+       }
+       else if (G.relbase_valid || lib) {
                char file[MAX_PTCACHE_PATH]; /* we dont want the dir, only the file */
                char *blendfilename;
 
@@ -196,15 +1014,14 @@ static int ptcache_path(PTCacheID *pid, char *filename)
                
                snprintf(filename, MAX_PTCACHE_PATH, "//"PTCACHE_PATH"%s", file); /* add blend file name to pointcache dir */
                BLI_convertstringcode(filename, blendfilename);
-               BLI_add_slash(filename);
-               return strlen(filename);
+               return BLI_add_slash(filename); /* new strlen() */
        }
        
        /* use the temp path. this is weak but better then not using point cache at all */
        /* btempdir is assumed to exist and ALWAYS has a trailing slash */
        snprintf(filename, MAX_PTCACHE_PATH, "%s"PTCACHE_PATH"%d", btempdir, abs(getpid()));
-       BLI_add_slash(filename);
-       return strlen(filename);
+       
+       return BLI_add_slash(filename); /* new strlen() */
 }
 
 static int BKE_ptcache_id_filename(PTCacheID *pid, char *filename, int cfra, short do_path, short do_ext)
@@ -215,14 +1032,14 @@ static int BKE_ptcache_id_filename(PTCacheID *pid, char *filename, int cfra, sho
        filename[0] = '\0';
        newname = filename;
        
-       if (!G.relbase_valid) return 0; /* save blend file before using disk pointcache */
+       if (!G.relbase_valid && (pid->cache->flag & PTCACHE_EXTERNAL)==0) return 0; /* save blend file before using disk pointcache */
        
        /* start with temp dir */
        if (do_path) {
                len = ptcache_path(pid, filename);
                newname += len;
        }
-       if(strcmp(pid->cache->name, "")==0) {
+       if(strcmp(pid->cache->name, "")==0 && (pid->cache->flag & PTCACHE_EXTERNAL)==0) {
                idname = (pid->ob->id.name+2);
                /* convert chars to hex so they are always a valid filename */
                while('\0' != *idname) {
@@ -232,14 +1049,26 @@ static int BKE_ptcache_id_filename(PTCacheID *pid, char *filename, int cfra, sho
                }
        }
        else {
-               int temp = strlen(pid->cache->name); 
+               int temp = (int)strlen(pid->cache->name); 
                strcpy(newname, pid->cache->name); 
                newname+=temp;
                len += temp;
        }
 
        if (do_ext) {
-               snprintf(newname, MAX_PTCACHE_FILE, "_%06d_%02d"PTCACHE_EXT, cfra, pid->stack_index); /* always 6 chars */
+
+               if(pid->cache->index < 0)
+                       pid->cache->index =  pid->stack_index = object_insert_ptcache(pid->ob);
+
+               if(pid->cache->flag & PTCACHE_EXTERNAL) {
+                       if(pid->cache->index >= 0)
+                               snprintf(newname, MAX_PTCACHE_FILE, "_%06d_%02d"PTCACHE_EXT, cfra, pid->stack_index); /* always 6 chars */
+                       else
+                               snprintf(newname, MAX_PTCACHE_FILE, "_%06d"PTCACHE_EXT, cfra); /* always 6 chars */
+               }
+               else {
+                       snprintf(newname, MAX_PTCACHE_FILE, "_%06d_%02d"PTCACHE_EXT, cfra, pid->stack_index); /* always 6 chars */
+               }
                len += 16;
        }
        
@@ -247,7 +1076,7 @@ static int BKE_ptcache_id_filename(PTCacheID *pid, char *filename, int cfra, sho
 }
 
 /* youll need to close yourself after! */
-PTCacheFile *BKE_ptcache_file_open(PTCacheID *pid, int mode, int cfra)
+static PTCacheFile *ptcache_file_open(PTCacheID *pid, int mode, int cfra)
 {
        PTCacheFile *pf;
        FILE *fp = NULL;
@@ -257,7 +1086,7 @@ PTCacheFile *BKE_ptcache_file_open(PTCacheID *pid, int mode, int cfra)
        if(pid->ob->id.lib && mode == PTCACHE_FILE_WRITE)
                return NULL;
 
-       if (!G.relbase_valid) return NULL; /* save blend file before using disk pointcache */
+       if (!G.relbase_valid && (pid->cache->flag & PTCACHE_EXTERNAL)==0) return NULL; /* save blend file before using disk pointcache */
        
        BKE_ptcache_id_filename(pid, filename, cfra, 1, 1);
 
@@ -280,104 +1109,193 @@ PTCacheFile *BKE_ptcache_file_open(PTCacheID *pid, int mode, int cfra)
        return pf;
 }
 
-void BKE_ptcache_file_close(PTCacheFile *pf)
+static void ptcache_file_close(PTCacheFile *pf)
 {
        fclose(pf->fp);
        MEM_freeN(pf);
 }
 
-int BKE_ptcache_file_read_floats(PTCacheFile *pf, float *f, int tot)
+static int ptcache_file_read(PTCacheFile *pf, void *f, size_t tot, int size)
+{
+       return (fread(f, size, tot, pf->fp) == tot);
+}
+static int ptcache_file_write(PTCacheFile *pf, void *f, size_t tot, int size)
 {
-       return (fread(f, sizeof(float), tot, pf->fp) == tot);
+       return (fwrite(f, size, tot, pf->fp) == tot);
+}
+static int ptcache_file_read_data(PTCacheFile *pf)
+{
+       int i;
+
+       for(i=0; i<BPHYS_TOT_DATA; i++) {
+               if(pf->data_types & (1<<i) && !ptcache_file_read(pf, pf->cur[i], 1, ptcache_data_size[i]))
+                       return 0;
+       }
+       
+       return 1;
 }
+static int ptcache_file_write_data(PTCacheFile *pf)
+{              
+       int i;
 
-int BKE_ptcache_file_write_floats(PTCacheFile *pf, float *f, int tot)
+       for(i=0; i<BPHYS_TOT_DATA; i++) {
+               if(pf->data_types & (1<<i) && !ptcache_file_write(pf, pf->cur[i], 1, ptcache_data_size[i]))
+                       return 0;
+       }
+       
+       return 1;
+}
+static int ptcache_file_read_header_begin(PTCacheFile *pf)
 {
-       return (fwrite(f, sizeof(float), tot, pf->fp) == tot);
+       int error=0;
+       char bphysics[8];
+       
+       pf->data_types = 0;
+       
+       if(fread(bphysics, sizeof(char), 8, pf->fp) != 8)
+               error = 1;
+       
+       if(!error && strncmp(bphysics, "BPHYSICS", 8))
+               error = 1;
+
+       if(!error && !fread(&pf->type, sizeof(int), 1, pf->fp))
+               error = 1;
+       
+       /* if there was an error set file as it was */
+       if(error)
+               fseek(pf->fp, 0, SEEK_SET);
+
+       return !error;
 }
 
-static int ptcache_pid_elemsize(PTCacheID *pid)
+
+static int ptcache_file_write_header_begin(PTCacheFile *pf)
 {
-       if(pid->type==PTCACHE_TYPE_SOFTBODY)
-               return 0; // TODO
-       else if(pid->type==PTCACHE_TYPE_PARTICLES)
-               return sizeof(ParticleKey);
-       else if(pid->type==PTCACHE_TYPE_CLOTH)
-               return 0; // TODO
+       char *bphysics = "BPHYSICS";
+       
+       if(fwrite(bphysics, sizeof(char), 8, pf->fp) != 8)
+               return 0;
 
-       return 0;
+       if(!fwrite(&pf->type, sizeof(int), 1, pf->fp))
+               return 0;
+       
+       return 1;
 }
-static int ptcache_pid_totelem(PTCacheID *pid)
+
+
+/* Data pointer handling */
+int BKE_ptcache_data_size(int data_type)
 {
-       if(pid->type==PTCACHE_TYPE_SOFTBODY)
-               return 0; // TODO
-       else if(pid->type==PTCACHE_TYPE_PARTICLES) {
-               ParticleSystem *psys = pid->data;
-               return psys->totpart;
-       }
-       else if(pid->type==PTCACHE_TYPE_CLOTH)
-               return 0; // TODO
+       return ptcache_data_size[data_type];
+}
 
-       return 0;
+static void ptcache_file_init_pointers(PTCacheFile *pf)
+{
+       int data_types = pf->data_types;
+
+       pf->cur[BPHYS_DATA_INDEX] =             data_types & (1<<BPHYS_DATA_INDEX) ?            &pf->data.index : NULL;
+       pf->cur[BPHYS_DATA_LOCATION] =  data_types & (1<<BPHYS_DATA_LOCATION) ?         &pf->data.loc   : NULL;
+       pf->cur[BPHYS_DATA_VELOCITY] =  data_types & (1<<BPHYS_DATA_VELOCITY) ?         &pf->data.vel   : NULL;
+       pf->cur[BPHYS_DATA_ROTATION] =  data_types & (1<<BPHYS_DATA_ROTATION) ?         &pf->data.rot   : NULL;
+       pf->cur[BPHYS_DATA_AVELOCITY] = data_types & (1<<BPHYS_DATA_AVELOCITY) ?        &pf->data.ave   : NULL;
+       pf->cur[BPHYS_DATA_SIZE] =              data_types & (1<<BPHYS_DATA_SIZE)       ?               &pf->data.size  : NULL;
+       pf->cur[BPHYS_DATA_TIMES] =             data_types & (1<<BPHYS_DATA_TIMES) ?            &pf->data.times : NULL;
+       pf->cur[BPHYS_DATA_BOIDS] =             data_types & (1<<BPHYS_DATA_BOIDS) ?            &pf->data.boids : NULL;
 }
 
-void ptcache_update_info(PTCacheID *pid)
+void BKE_ptcache_mem_init_pointers(PTCacheMem *pm)
 {
-       PointCache *cache = pid->cache;
-       int totframes = 0;
+       int data_types = pm->data_types;
+       int i;
 
-       if(cache->flag & PTCACHE_DISK_CACHE) {
-               int cfra = cache->startframe;
+       for(i=0; i<BPHYS_TOT_DATA; i++)
+               pm->cur[i] = data_types & (1<<i) ? pm->data[i] : NULL;
+}
 
-               for(; cfra<=cache->endframe; cfra++) {
-                       if(BKE_ptcache_id_exist(pid, cfra))
-                               totframes++;
-               }
+void BKE_ptcache_mem_incr_pointers(PTCacheMem *pm)
+{
+       int i;
 
-               sprintf(cache->info, "%i frames on disk.", totframes);
+       for(i=0; i<BPHYS_TOT_DATA; i++) {
+               if(pm->cur[i])
+                       pm->cur[i] = (char*)pm->cur[i] + ptcache_data_size[i];
        }
-       else {
-               PTCacheMem *pm = cache->mem_cache.first;                
-               float framesize = 0.0f, bytes = 0.0f;
-               int mb;
+}
+static void ptcache_alloc_data(PTCacheMem *pm)
+{
+       int data_types = pm->data_types;
+       int totpoint = pm->totpoint;
+       int i;
 
-               if(pm)
-                       framesize = (float)ptcache_pid_elemsize(pid) * (float)pm->totpoint;
-               
-               for(; pm; pm=pm->next)
-                       totframes++;
+       for(i=0; i<BPHYS_TOT_DATA; i++) {
+               if(data_types & (1<<i))
+                       pm->data[i] = MEM_callocN(totpoint * ptcache_data_size[i], "PTCache Data");
+       }
+}
+static void ptcache_free_data(void *data[])
+{
+       int i;
 
-               bytes = totframes * framesize;
+       for(i=0; i<BPHYS_TOT_DATA; i++) {
+               if(data[i])
+                       MEM_freeN(data[i]);
+       }
+}
+static void ptcache_copy_data(void *from[], void *to[])
+{
+       int i;
+       for(i=0; i<BPHYS_TOT_DATA; i++) {
+               if(from[i])
+                       memcpy(to[i], from[i], ptcache_data_size[i]);
+       }
+}
 
-               mb = (bytes > 1024.0f * 1024.0f);
 
-               sprintf(cache->info, "%i frames in memory (%.1f %s).",
-                       totframes,
-                       bytes / (mb ? 1024.0f * 1024.0f : 1024.0f),
-                       mb ? "Mb" : "kb");
-       }
+
+static int ptcache_pid_old_elemsize(PTCacheID *pid)
+{
+       if(pid->type==PTCACHE_TYPE_SOFTBODY)
+               return 6 * sizeof(float);
+       else if(pid->type==PTCACHE_TYPE_PARTICLES)
+               return sizeof(ParticleKey);
+       else if(pid->type==PTCACHE_TYPE_CLOTH)
+               return 9 * sizeof(float);
+
+       return 0;
 }
+
 /* reads cache from disk or memory */
 /* possible to get old or interpolated result */
-int BKE_ptcache_read_cache(PTCacheReader *reader)
+int BKE_ptcache_read_cache(PTCacheID *pid, float cfra, float frs_sec)
 {
-       PTCacheID *pid = reader->pid;
        PTCacheFile *pf=NULL, *pf2=NULL;
        PTCacheMem *pm=NULL, *pm2=NULL;
-       int totelem = reader->totelem;
-       float cfra = reader->cfra;
+       float old_data1[14], old_data2[14];
        int cfrai = (int)cfra;
-       int elemsize = ptcache_pid_elemsize(pid);
-       int i, incr = elemsize / sizeof(float);
-       float frs_sec = reader->scene->r.frs_sec;
+       int old_elemsize = ptcache_pid_old_elemsize(pid);
+       int i;
 
-       if(totelem == 0)
+       int cfra1 = 0, cfra2 = 0;
+       int totpoint = 0, totpoint2 = 0;
+       int *index = &i, *index2 = &i;
+       int use_old = 0, old_frame = 0;
+
+       int ret = 0, error = 0;
+
+       /* nothing to read to */
+       if(pid->totpoint(pid->calldata) == 0)
                return 0;
 
+       if(pid->cache->flag & PTCACHE_READ_INFO) {
+               pid->cache->flag &= ~PTCACHE_READ_INFO;
+               BKE_ptcache_read_cache(pid, 0, frs_sec);
+       }
+
+
        /* first check if we have the actual frame cached */
        if(cfra == (float)cfrai) {
                if(pid->cache->flag & PTCACHE_DISK_CACHE) {
-                       pf= BKE_ptcache_file_open(pid, PTCACHE_FILE_READ, cfrai);
+                       pf= ptcache_file_open(pid, PTCACHE_FILE_READ, cfrai);
                }
                else {
                        pm = pid->cache->mem_cache.first;
@@ -389,58 +1307,29 @@ int BKE_ptcache_read_cache(PTCacheReader *reader)
                }
        }
 
-       /* if found, use exact frame */
-       if(pf || pm) {
-               float *data;
-
-               if(pm)
-                       data = pm->data;
-               else
-                       data = MEM_callocN(elemsize, "pointcache read data");
-
-               for(i=0; i<totelem; i++) {
-                       if(pf) {
-                               if(!BKE_ptcache_file_read_floats(pf, data, incr)) {
-                                       BKE_ptcache_file_close(pf);
-                                       MEM_freeN(data);
-                                       return 0;
-                               }
-
-                               reader->set_elem(i, reader->calldata, data);
-                       }
-                       else {
-                               reader->set_elem(i, reader->calldata, data);
-                               data += incr;
-                       }
-               }
-
-               if(pf) {
-                       BKE_ptcache_file_close(pf);
-                       MEM_freeN(data);
-               }
-
-               return PTCACHE_READ_EXACT;
-       }
        /* no exact cache frame found so try to find cached frames around cfra */
-       if(reader->allow_interpolate || reader->allow_old) {
-               int cfra1, cfra2;
-
+       if(!pm && !pf) {
                if(pid->cache->flag & PTCACHE_DISK_CACHE) {
                        pf=NULL;
                        while(cfrai > pid->cache->startframe && !pf) {
                                cfrai--;
-                               pf= BKE_ptcache_file_open(pid, PTCACHE_FILE_READ, cfrai);
+                               pf= ptcache_file_open(pid, PTCACHE_FILE_READ, cfrai);
                                cfra1 = cfrai;
                        }
 
-                       *(reader->old_frame) = cfrai;
+                       old_frame = cfrai;
 
                        cfrai = (int)cfra;
                        while(cfrai < pid->cache->endframe && !pf2) {
                                cfrai++;
-                               pf2= BKE_ptcache_file_open(pid, PTCACHE_FILE_READ, cfrai);
+                               pf2= ptcache_file_open(pid, PTCACHE_FILE_READ, cfrai);
                                cfra2 = cfrai;
                        }
+
+                       if(pf && !pf2) {
+                               pf2 = pf;
+                               pf = NULL;
+                       }
                }
                else if(pid->cache->mem_cache.first){
                        pm = pid->cache->mem_cache.first;
@@ -449,167 +1338,370 @@ int BKE_ptcache_read_cache(PTCacheReader *reader)
                                pm= pm->next;
 
                        if(pm) {
-                               *(reader->old_frame) = pm->frame;
+                               old_frame = pm->frame;
                                cfra1 = pm->frame;
                        }
 
                        pm2 = pid->cache->mem_cache.last;
 
-                       while(pm2->prev && pm2->frame > cfra)
-                               pm2= pm2->prev;
+                       if(pm2 && pm2->frame < cfra)
+                               pm2 = NULL;
+                       else {
+                               while(pm2->prev && pm2->prev->frame > cfra)
+                                       pm2= pm2->prev;
 
-                       if(pm2)
-                               cfra2 = pm2->frame;
+                               if(pm2)
+                                       cfra2 = pm2->frame;
+                       }
+
+                       if(pm && !pm2) {
+                               pm2 = pm;
+                               pm = NULL;
+                       }
                }
+       }
 
-               if(reader->allow_interpolate && ((pf && pf2) || (pm && pm2))) {
-                       /* interpolate from nearest frames */
-                       float *data1, *data2;
+       if(!pm && !pm2 && !pf && !pf2)
+               return 0;
 
-                       if(pm) {
-                               data1 = pm->data;
-                               data2 = pm2->data;
+       if(pm) {
+               BKE_ptcache_mem_init_pointers(pm);
+               totpoint = pm->totpoint;
+               index = pm->data_types & (1<<BPHYS_DATA_INDEX) ? pm->cur[BPHYS_DATA_INDEX] : &i;
+       }
+       if(pm2) {
+               BKE_ptcache_mem_init_pointers(pm2);
+               totpoint2 = pm2->totpoint;
+               index2 = pm2->data_types & (1<<BPHYS_DATA_INDEX) ? pm2->cur[BPHYS_DATA_INDEX] : &i;
+       }
+       if(pf) {
+               if(ptcache_file_read_header_begin(pf)) {
+                       if(pf->type != pid->type) {
+                               /* todo report error */
+                               ptcache_file_close(pf);
+                               pf = NULL;
                        }
-                       else {
-                               data1 = MEM_callocN(elemsize, "pointcache read data1");
-                               data2 = MEM_callocN(elemsize, "pointcache read data2");
+                       else if(pid->read_header(pf)) {
+                               ptcache_file_init_pointers(pf);
+                               totpoint = pf->totpoint;
+                               index = pf->data_types & BPHYS_DATA_INDEX ? &pf->data.index : &i;
                        }
+               }
+               else {
+                       /* fall back to old cache file format */
+                       use_old = 1;
+                       totpoint = pid->totpoint(pid->calldata);
+               }
+       }
+       if(pf2) {
+               if(ptcache_file_read_header_begin(pf2)) {
+                       if(pf2->type != pid->type) {
+                               /* todo report error */
+                               ptcache_file_close(pf2);
+                               pf2 = NULL;
+                       }
+                       else if(pid->read_header(pf2)) {
+                               ptcache_file_init_pointers(pf2);
+                               totpoint2 = pf2->totpoint;
+                               index2 = pf->data_types & BPHYS_DATA_INDEX ? &pf2->data.index : &i;
+                       }
+               }
+               else {
+                       /* fall back to old cache file format */
+                       use_old = 1;
+                       totpoint2 = pid->totpoint(pid->calldata);
+               }
+       }
 
-                       for(i=0; i<totelem; i++) {
-                               if(pf && pf2) {
-                                       if(!BKE_ptcache_file_read_floats(pf, data1, incr)) {
-                                               BKE_ptcache_file_close(pf);
-                                               BKE_ptcache_file_close(pf2);
-                                               MEM_freeN(data1);
-                                               MEM_freeN(data2);
-                                               return 0;
-                                       }
-                                       if(!BKE_ptcache_file_read_floats(pf2, data2, incr)) {
-                                               BKE_ptcache_file_close(pf);
-                                               BKE_ptcache_file_close(pf2);
-                                               MEM_freeN(data1);
-                                               MEM_freeN(data2);
-                                               return 0;
-                                       }
-                                       reader->interpolate_elem(i, reader->calldata, frs_sec, cfra, cfra1, cfra2, data1, data2);
-                               }
-                               else {
-                                       reader->interpolate_elem(i, reader->calldata, frs_sec, cfra, cfra1, cfra2, data1, data2);
-                                       data1 += incr;
-                                       data2 += incr;
-                               }
+       /* don't read old cache if allready simulated past cached frame */
+       if(!pm && !pf && cfra1 && cfra1 <= pid->cache->simframe)
+               error = 1;
+       if(cfra1 && cfra1==cfra2)
+               error = 1;
+
+       if(!error) 
+       {
+               if(pf && pid->read_stream) {
+                       if(totpoint != pid->totpoint(pid->calldata))
+                               error = 1;
+                       else
+                       {
+                               // we have stream writing here
+                               pid->read_stream(pf, pid->calldata);
                        }
+               }
+       }
 
-                       if(pf) {
-                               BKE_ptcache_file_close(pf);
-                               BKE_ptcache_file_close(pf2);
-                               MEM_freeN(data1);
-                               MEM_freeN(data2);
+       totpoint = MIN2(totpoint, pid->totpoint(pid->calldata));
+
+       if(!error) 
+       {       
+               for(i=0; i<totpoint; i++) {
+                       /* read old cache file format */
+                       if(use_old) {
+                               if(pid->read_elem && ptcache_file_read(pf, (void*)old_data1, 1, old_elemsize))
+                                       pid->read_elem(i, pid->calldata, NULL, frs_sec, cfra, old_data1);
+                               else if(pid->read_elem)
+                                       { error = 1; break; }
+                       }
+                       else {
+                               if(pid->read_elem && (pm || ptcache_file_read_data(pf)))
+                                       pid->read_elem(*index, pid->calldata, pm ? pm->cur : pf->cur, frs_sec, cfra1 ? (float)cfra1 : (float)cfrai, NULL);
+                               else if(pid->read_elem)
+                                       { error = 1; break; }
                        }
 
-                       return PTCACHE_READ_INTERPOLATED;
+                       if(pm) {
+                               BKE_ptcache_mem_incr_pointers(pm);
+                               index = pm->data_types & (1<<BPHYS_DATA_INDEX) ? pm->cur[BPHYS_DATA_INDEX] : &i;
+                       }
                }
-               else if(reader->allow_old && (pf || pm)) {
-                       /* use last valid cache frame */
-                       float *data;
+       }
 
-                       if(pm)
-                               data = pm->data;
+       if(!error) 
+       {
+               if(pf2 && pid->read_stream) {
+                       if(totpoint2 != pid->totpoint(pid->calldata))
+                               error = 1;
                        else
-                               data = MEM_callocN(elemsize, "pointcache read data");
-
-                       for(i=0; i<totelem; i++) {
-                               if(pf) {
-                                       if(!BKE_ptcache_file_read_floats(pf, data, incr)) {
-                                               BKE_ptcache_file_close(pf);
-                                               if(pf2)
-                                                       BKE_ptcache_file_close(pf2);
-                                               return 0;
-                                       }
-                                       reader->set_elem(i, reader->calldata, data);
+                       {
+                               // we have stream writing here
+                               pid->read_stream(pf2, pid->calldata);
+                       }
+               }
+       }
+
+       totpoint2 = MIN2(totpoint2, pid->totpoint(pid->calldata));
+
+       if(!error) 
+       {
+               for(i=0; i<totpoint2; i++) {
+                       /* read old cache file format */
+                       if(use_old) {
+                               if(pid->read_elem && ptcache_file_read(pf2, (void*)old_data2, 1, old_elemsize)) {
+                                       if(!pf && pf2)
+                                               pid->read_elem(i, pid->calldata, NULL, frs_sec, (float)cfra2, old_data2);
+                                       else if(pid->interpolate_elem)
+                                               pid->interpolate_elem(i, pid->calldata, NULL, frs_sec, cfra, (float)cfra1, (float)cfra2, old_data2);
+                                       else
+                                       { error = 1; break; }
                                }
-                               else {
-                                       reader->set_elem(i, reader->calldata, data);
-                                       data += incr;
+                               else if(pid->read_elem)
+                                       { error = 1; break; }
+                       }
+                       else {
+                               if(pid->read_elem && (pm2 || ptcache_file_read_data(pf2))) {
+                                       if((!pf && pf2) || (!pm && pm2))
+                                               pid->read_elem(*index2, pid->calldata, pm2 ? pm2->cur : pf2->cur, frs_sec, (float)cfra2, NULL);
+                                       else if(pid->interpolate_elem)
+                                               pid->interpolate_elem(*index2, pid->calldata, pm2 ? pm2->cur : pf2->cur, frs_sec, cfra, (float)cfra1, (float)cfra2, NULL);
+                                       else
+                                       { error = 1; break; }
                                }
+                               else if(pid->read_elem)
+                                       { error = 1; break; }
                        }
 
-                       if(pf) {
-                               BKE_ptcache_file_close(pf);
-                               MEM_freeN(data);
+                       if(pm2) {
+                               BKE_ptcache_mem_incr_pointers(pm2);
+                               index2 = pm2->data_types & (1<<BPHYS_DATA_INDEX) ? pm2->cur[BPHYS_DATA_INDEX] : &i;
                        }
-                       if(pf2)
-                               BKE_ptcache_file_close(pf2);
-
-                       return PTCACHE_READ_OLD;
                }
        }
 
-       if(pf)
-               BKE_ptcache_file_close(pf);
-       if(pf2)
-               BKE_ptcache_file_close(pf2);
+       if(pm || pf)
+               ret = (pm2 || pf2) ? PTCACHE_READ_INTERPOLATED : PTCACHE_READ_EXACT;
+       else if(pm2 || pf2) {
+               ret = PTCACHE_READ_OLD;
+               pid->cache->simframe = old_frame;
+       }
 
-       return 0;
+       if(pf) {
+               ptcache_file_close(pf);
+               pf = NULL;
+       }
+
+       if(pf2) {
+               ptcache_file_close(pf2);
+               pf = NULL;
+       }
+
+       if((pid->cache->flag & PTCACHE_QUICK_CACHE)==0) {
+               cfrai = (int)cfra;
+               /* clear invalid cache frames so that better stuff can be simulated */
+               if(pid->cache->flag & PTCACHE_OUTDATED) {
+                       BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_AFTER, cfrai);
+               }
+               else if(pid->cache->flag & PTCACHE_FRAMES_SKIPPED) {
+                       if(cfra <= pid->cache->last_exact)
+                               pid->cache->flag &= ~PTCACHE_FRAMES_SKIPPED;
+
+                       BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_AFTER, MAX2(cfrai,pid->cache->last_exact));
+               }
+       }
+
+       return (error ? 0 : ret);
 }
+/* TODO for later */
+//static void ptcache_make_index_array(PTCacheMem *pm, int totpoint)
+//{
+//     int i, *index;
+//
+//     if(pm->index_array) {
+//             MEM_freeN(pm->index_array);
+//             pm->index_array = NULL;
+//     }
+//
+//     if(!pm->data[BPHYS_DATA_INDEX])
+//             return;
+//
+//     pm->index_array = MEM_callocN(totpoint * sizeof(int), "PTCacheMem index_array");
+//     index = pm->data[BPHYS_DATA_INDEX];
+//
+//     for(i=0; i<pm->totpoint; i++, index++)
+//             pm->index_array[*index] = i;
+//}
 /* writes cache to disk or memory */
-int BKE_ptcache_write_cache(PTCacheWriter *writer)
+int BKE_ptcache_write_cache(PTCacheID *pid, int cfra)
 {
-       PointCache *cache = writer->pid->cache;
+       PointCache *cache = pid->cache;
        PTCacheFile *pf= NULL;
-       int elemsize = ptcache_pid_elemsize(writer->pid);
-       int i, incr = elemsize / sizeof(float);
+       int i;
+       int totpoint = pid->totpoint(pid->calldata);
+       int add = 0, overwrite = 0;
 
-       if(writer->totelem == 0 || writer->cfra <= 0)
+       if(totpoint == 0 || cfra < 0
+               || (cfra ? pid->data_types == 0 : pid->info_types == 0))
                return 0;
 
        if(cache->flag & PTCACHE_DISK_CACHE) {
-               pf = BKE_ptcache_file_open(writer->pid, PTCACHE_FILE_WRITE, writer->cfra);
-               if(!pf)
-                       return 0;
+               int efra = cache->endframe;
+
+               if(cfra==0)
+                       add = 1;
+               /* allways start from scratch on the first frame */
+               else if(cfra == cache->startframe) {
+                       BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_ALL, cfra);
+                       cache->flag &= ~PTCACHE_REDO_NEEDED;
+                       add = 1;
+               }
+               else {
+                       int ofra;
+                       /* find last cached frame */
+                       while(efra > cache->startframe && !BKE_ptcache_id_exist(pid, efra))
+                               efra--;
+
+                       /* find second last cached frame */
+                       ofra = efra-1;
+                       while(ofra > cache->startframe && !BKE_ptcache_id_exist(pid, ofra))
+                               ofra--;
+
+                       if(efra >= cache->startframe && cfra > efra) {
+                               if(ofra >= cache->startframe && efra - ofra < cache->step)
+                                       overwrite = 1;
+                               else
+                                       add = 1;
+                       }
+               }
+
+               if(add || overwrite) {
+                       if(overwrite)
+                               BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_FRAME, efra);
 
-               for(i=0; i<writer->totelem; i++)
-                       BKE_ptcache_file_write_floats(pf, writer->elem_ptr(i, writer->calldata), incr);
+                       pf = ptcache_file_open(pid, PTCACHE_FILE_WRITE, cfra);
+                       if(!pf)
+                               return 0;
+
+                       pf->type = pid->type;
+                       pf->totpoint = cfra ? totpoint : pid->totwrite(pid->calldata);
+                       pf->data_types = cfra ? pid->data_types : pid->info_types;
+
+                       if(!ptcache_file_write_header_begin(pf) || !pid->write_header(pf)) {
+                               ptcache_file_close(pf);
+                               return 0;
+                       }
+
+                       ptcache_file_init_pointers(pf);
+
+                       if(pf && pid->write_stream) {
+                               // we have stream writing here
+                               pid->write_stream(pf, pid->calldata);
+                       }
+                       else
+                               for(i=0; i<totpoint; i++) {
+                                       if(pid->write_elem && pid->write_elem(i, pid->calldata, pf->cur))
+                                               if(!ptcache_file_write_data(pf)) {
+                                                       ptcache_file_close(pf);
+                                                       return 0;
+                                               }
+                               }
+               }
        }
        else {
-               PTCacheMem *pm = MEM_callocN(sizeof(PTCacheMem), "Pointcache mem");
+               PTCacheMem *pm;
                PTCacheMem *pm2;
-               float *pmdata;
 
-               pm->data = MEM_callocN(elemsize * writer->totelem, "Pointcache mem data");
-               pmdata = pm->data;
+               pm2 = cache->mem_cache.first;
+               
+               /* don't write info file in memory */
+               if(cfra==0)
+                       return 1;
+               /* allways start from scratch on the first frame */
+               if(cfra == cache->startframe) {
+                       BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_ALL, cfra);
+                       cache->flag &= ~PTCACHE_REDO_NEEDED;
+                       add = 1;
+               }
+               else if (cache->mem_cache.last) {
+                       pm2 = cache->mem_cache.last;
+
+                       if(pm2 && cfra > pm2->frame) {
+                               if(pm2->prev && pm2->frame - pm2->prev->frame < cache->step)
+                                       overwrite = 1;
+                               else
+                                       add = 1;
+                       }
+               }
+               else
+                       add = 1;
+
+               if(add || overwrite) {
+                       if(overwrite)
+                               BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_FRAME, pm2->frame);
 
-               for(i=0; i<writer->totelem; i++, pmdata+=incr)
-                       memcpy(pmdata, writer->elem_ptr(i, writer->calldata), elemsize);
+                       pm = MEM_callocN(sizeof(PTCacheMem), "Pointcache mem");
 
-               pm->frame = writer->cfra;
-               pm->totpoint = writer->totelem;
+                       pm->totpoint = pid->totwrite(pid->calldata);
+                       pm->data_types = cfra ? pid->data_types : pid->info_types;
 
-               /* find add location */
-               pm2 = cache->mem_cache.first;
-               if(!pm2)
+                       ptcache_alloc_data(pm);
+                       BKE_ptcache_mem_init_pointers(pm);
+
+                       for(i=0; i<totpoint; i++) {
+                               if(pid->write_elem && pid->write_elem(i, pid->calldata, pm->cur))
+                                       BKE_ptcache_mem_incr_pointers(pm);
+                       }
+                       //ptcache_make_index_array(pm, pid->totpoint(pid->calldata));
+
+                       pm->frame = cfra;
                        BLI_addtail(&cache->mem_cache, pm);
-               else if(pm2->frame == writer->cfra) {
-                       /* overwrite same frame */
-                       MEM_freeN(pm2->data);
-                       pm2->data = pm->data;
-                       MEM_freeN(pm);
                }
-               else {
-                       while(pm2->next && pm2->next->frame < writer->cfra)
-                               pm2 = pm2->next;
+       }
 
-                       BLI_insertlinkafter(&cache->mem_cache, pm2, pm);
+       if(add || overwrite) {
+               if(cfra - cache->last_exact == 1
+                       || cfra == cache->startframe) {
+                       cache->last_exact = cfra;
+                       cache->flag &= ~PTCACHE_FRAMES_SKIPPED;
                }
+               else
+                       cache->flag |= PTCACHE_FRAMES_SKIPPED;
        }
-
-       if(writer->cfra - cache->last_exact == 1)
-               cache->last_exact = writer->cfra;
        
        if(pf)
-               BKE_ptcache_file_close(pf);
+               ptcache_file_close(pf);
 
-       ptcache_update_info(writer->pid);
+       BKE_ptcache_update_info(pid);
 
        return 1;
 }
@@ -617,7 +1709,7 @@ int BKE_ptcache_write_cache(PTCacheWriter *writer)
  * mode - PTCACHE_CLEAR_ALL, 
 
 */
-
+/* Clears & resets */
 void BKE_ptcache_id_clear(PTCacheID *pid, int mode, int cfra)
 {
        int len; /* store the length of the string */
@@ -630,7 +1722,7 @@ void BKE_ptcache_id_clear(PTCacheID *pid, int mode, int cfra)
        char path_full[MAX_PTCACHE_FILE];
        char ext[MAX_PTCACHE_PATH];
 
-       if(!pid->cache)
+       if(!pid->cache || pid->cache->flag & PTCACHE_BAKED)
                return;
 
        /* don't allow clearing for linked objects */
@@ -664,7 +1756,7 @@ void BKE_ptcache_id_clear(PTCacheID *pid, int mode, int cfra)
                                                        BLI_delete(path_full, 0, 0);
                                                } else {
                                                        /* read the number of the file */
-                                                       int frame, len2 = strlen(de->d_name);
+                                                       int frame, len2 = (int)strlen(de->d_name);
                                                        char num[7];
 
                                                        if (len2 > 15) { /* could crash if trying to copy a string out of this range*/
@@ -688,10 +1780,12 @@ void BKE_ptcache_id_clear(PTCacheID *pid, int mode, int cfra)
                        PTCacheMem *pm= pid->cache->mem_cache.first;
                        PTCacheMem *link= NULL;
 
+                       pm= pid->cache->mem_cache.first;
+
                        if(mode == PTCACHE_CLEAR_ALL) {
                                pid->cache->last_exact = 0;
                                for(; pm; pm=pm->next)
-                                       MEM_freeN(pm->data);
+                                       ptcache_free_data(pm->data);
                                BLI_freelistN(&pid->cache->mem_cache);
                        } else {
                                while(pm) {
@@ -699,7 +1793,7 @@ void BKE_ptcache_id_clear(PTCacheID *pid, int mode, int cfra)
                                        (mode==PTCACHE_CLEAR_AFTER && pm->frame > cfra) ) {
                                                link = pm;
                                                pm = pm->next;
-                                               MEM_freeN(link->data);
+                                               ptcache_free_data(link->data);
                                                BLI_freelinkN(&pid->cache->mem_cache, link);
                                        }
                                        else
@@ -721,7 +1815,7 @@ void BKE_ptcache_id_clear(PTCacheID *pid, int mode, int cfra)
 
                        for(; pm; pm=pm->next) {
                                if(pm->frame == cfra) {
-                                       MEM_freeN(pm->data);
+                                       ptcache_free_data(pm->data);
                                        BLI_freelinkN(&pid->cache->mem_cache, pm);
                                        break;
                                }
@@ -730,7 +1824,7 @@ void BKE_ptcache_id_clear(PTCacheID *pid, int mode, int cfra)
                break;
        }
 
-       ptcache_update_info(pid);
+       BKE_ptcache_update_info(pid);
 }
 
 int BKE_ptcache_id_exist(PTCacheID *pid, int cfra)
@@ -762,6 +1856,9 @@ void BKE_ptcache_id_time(PTCacheID *pid, Scene *scene, float cfra, int *startfra
        PointCache *cache;
        float offset, time, nexttime;
 
+       /* TODO: this has to be sorter out once bsystem_time gets redone, */
+       /*       now caches can handle interpolating etc. too - jahka */
+
        /* time handling for point cache:
         * - simulation time is scaled by result of bsystem_time
         * - for offsetting time only time offset is taken into account, since
@@ -798,7 +1895,7 @@ void BKE_ptcache_id_time(PTCacheID *pid, Scene *scene, float cfra, int *startfra
 int BKE_ptcache_id_reset(Scene *scene, PTCacheID *pid, int mode)
 {
        PointCache *cache;
-       int reset, clear, current, after;
+       int reset, clear, after;
 
        if(!pid->cache)
                return 0;
@@ -806,23 +1903,17 @@ int BKE_ptcache_id_reset(Scene *scene, PTCacheID *pid, int mode)
        cache= pid->cache;
        reset= 0;
        clear= 0;
-       current= 0;
        after= 0;
 
        if(mode == PTCACHE_RESET_DEPSGRAPH) {
                if(!(cache->flag & PTCACHE_BAKED) && !BKE_ptcache_get_continue_physics()) {
-                       if(cache->flag & PTCACHE_AUTOCACHE) {
-                               reset= 1;
+                       if(cache->flag & PTCACHE_QUICK_CACHE)
                                clear= 1;
-                       }
-                       else {
-                               current= 1;
-                               after= 1;
-                               cache->flag |= PTCACHE_OUTDATED;
-                       }
+
+                       after= 1;
                }
-               else
-                       cache->flag |= PTCACHE_OUTDATED;
+
+               cache->flag |= PTCACHE_OUTDATED;
        }
        else if(mode == PTCACHE_RESET_BAKED) {
                if(!BKE_ptcache_get_continue_physics()) {
@@ -835,39 +1926,34 @@ int BKE_ptcache_id_reset(Scene *scene, PTCacheID *pid, int mode)
        else if(mode == PTCACHE_RESET_OUTDATED) {
                reset = 1;
 
-               if(cache->flag & PTCACHE_OUTDATED)
-                       if(!(cache->flag & PTCACHE_BAKED))
-                               clear= 1;
-       }
-       else if(mode == PTCACHE_RESET_FREE) {
-               if(!(cache->flag & PTCACHE_BAKED) && !BKE_ptcache_get_continue_physics()) {
-                       if((cache->flag & PTCACHE_AUTOCACHE)==0) {
-                               current= 1;
-                               after= 1;
-                       }
+               if(cache->flag & PTCACHE_OUTDATED && !(cache->flag & PTCACHE_BAKED)) {
+                       clear= 1;
+                       cache->flag &= ~PTCACHE_OUTDATED;
                }
        }
 
        if(reset) {
-               cache->flag &= ~(PTCACHE_OUTDATED|PTCACHE_SIMULATION_VALID);
+               cache->flag &= ~(PTCACHE_REDO_NEEDED|PTCACHE_SIMULATION_VALID);
                cache->simframe= 0;
                cache->last_exact= 0;
 
                if(pid->type == PTCACHE_TYPE_CLOTH)
-                       cloth_free_modifier(pid->ob, pid->data);
+                       cloth_free_modifier(pid->ob, pid->calldata);
                else if(pid->type == PTCACHE_TYPE_SOFTBODY)
-                       sbFreeSimulation(pid->data);
+                       sbFreeSimulation(pid->calldata);
                else if(pid->type == PTCACHE_TYPE_PARTICLES)
-                       psys_reset(pid->data, PSYS_RESET_DEPSGRAPH);
+                       psys_reset(pid->calldata, PSYS_RESET_DEPSGRAPH);
+               else if(pid->type == PTCACHE_TYPE_SMOKE_DOMAIN)
+                       smokeModifier_reset(pid->calldata);
+               else if(pid->type == PTCACHE_TYPE_SMOKE_HIGHRES)
+                       smokeModifier_reset_turbulence(pid->calldata);
        }
        if(clear)
                BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_ALL, 0);
-       if(after)
+       else if(after)
                BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_AFTER, CFRA);
-       if(current)
-               BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_FRAME, CFRA);
 
-       return (reset || clear || current || after);
+       return (reset || clear || after);
 }
 
 int BKE_ptcache_object_reset(Scene *scene, Object *ob, int mode)
@@ -886,10 +1972,10 @@ int BKE_ptcache_object_reset(Scene *scene, Object *ob, int mode)
        }
 
        for(psys=ob->particlesystem.first; psys; psys=psys->next) {
-               /* Baked softbody hair has to be checked first, because we don't want to reset */
-               /* particles or softbody in that case -jahka */
-               if(psys->soft) {
-                       BKE_ptcache_id_from_softbody(&pid, ob, psys->soft);
+               /* Baked cloth hair has to be checked first, because we don't want to reset */
+               /* particles or cloth in that case -jahka */
+               if(psys->clmd) {
+                       BKE_ptcache_id_from_cloth(&pid, ob, psys->clmd);
                        if(mode == PSYS_RESET_ALL || !(psys->part->type == PART_HAIR && (pid.cache->flag & PTCACHE_BAKED))) 
                                reset |= BKE_ptcache_id_reset(scene, &pid, mode);
                        else
@@ -898,7 +1984,7 @@ int BKE_ptcache_object_reset(Scene *scene, Object *ob, int mode)
                else if(psys->recalc & PSYS_RECALC_REDO || psys->recalc & PSYS_RECALC_CHILD)
                        skip = 1;
 
-               if(skip == 0) {
+               if(skip == 0 && psys->part) {
                        BKE_ptcache_id_from_particles(&pid, ob, psys);
                        reset |= BKE_ptcache_id_reset(scene, &pid, mode);
                }
@@ -909,8 +1995,22 @@ int BKE_ptcache_object_reset(Scene *scene, Object *ob, int mode)
                        BKE_ptcache_id_from_cloth(&pid, ob, (ClothModifierData*)md);
                        reset |= BKE_ptcache_id_reset(scene, &pid, mode);
                }
+               if(md->type == eModifierType_Smoke) {
+                       SmokeModifierData *smd = (SmokeModifierData *)md;
+                       if(smd->type & MOD_SMOKE_TYPE_DOMAIN)
+                       {
+                               BKE_ptcache_id_from_smoke(&pid, ob, (SmokeModifierData*)md);
+                               reset |= BKE_ptcache_id_reset(scene, &pid, mode);
+
+                               BKE_ptcache_id_from_smoke_turbulence(&pid, ob, (SmokeModifierData*)md);
+                               reset |= BKE_ptcache_id_reset(scene, &pid, mode);
+                       }
+               }
        }
 
+       if (ob->type == OB_ARMATURE)
+               BIK_clear_cache(ob->pose);
+
        return reset;
 }
 
@@ -968,7 +2068,7 @@ void BKE_ptcache_set_continue_physics(Scene *scene, int enable)
                if(CONTINUE_PHYSICS == 0) {
                        for(ob=G.main->object.first; ob; ob=ob->id.next)
                                if(BKE_ptcache_object_reset(scene, ob, PTCACHE_RESET_OUTDATED))
-                                       DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
+                                       DAG_id_flush_update(&ob->id, OB_RECALC_DATA);
                }
        }
 }
@@ -978,48 +2078,118 @@ int BKE_ptcache_get_continue_physics()
        return CONTINUE_PHYSICS;
 }
 
-/* Point Cache */
+/* Point Cache handling */
 
-PointCache *BKE_ptcache_add()
+PointCache *BKE_ptcache_add(ListBase *ptcaches)
 {
        PointCache *cache;
 
        cache= MEM_callocN(sizeof(PointCache), "PointCache");
        cache->startframe= 1;
        cache->endframe= 250;
+       cache->step= 10;
+       cache->index = -1;
+
+       BLI_addtail(ptcaches, cache);
 
        return cache;
 }
 
-void BKE_ptcache_free(PointCache *cache)
+void BKE_ptcache_free_mem(ListBase *mem_cache)
 {
-       PTCacheMem *pm = cache->mem_cache.first;
+       PTCacheMem *pm = mem_cache->first;
+
        if(pm) {
-               for(; pm; pm=pm->next)
-                       MEM_freeN(pm->data);
+               for(; pm; pm=pm->next) {
+                       ptcache_free_data(pm->data);
+                       if(pm->index_array)
+                               MEM_freeN(pm->index_array);
+               }
 
-               BLI_freelistN(&cache->mem_cache);
+               BLI_freelistN(mem_cache);
        }
-
+}
+void BKE_ptcache_free(PointCache *cache)
+{
+       BKE_ptcache_free_mem(&cache->mem_cache);
+       if(cache->edit && cache->free_edit)
+               cache->free_edit(cache->edit);
        MEM_freeN(cache);
 }
+void BKE_ptcache_free_list(ListBase *ptcaches)
+{
+       PointCache *cache = ptcaches->first;
+
+       while(cache) {
+               BLI_remlink(ptcaches, cache);
+               BKE_ptcache_free(cache);
+               cache = ptcaches->first;
+       }
+}
 
-PointCache *BKE_ptcache_copy(PointCache *cache)
+static PointCache *ptcache_copy(PointCache *cache)
 {
        PointCache *ncache;
 
        ncache= MEM_dupallocN(cache);
 
+       /* hmm, should these be copied over instead? */
+       ncache->mem_cache.first = NULL;
+       ncache->mem_cache.last = NULL;
+
        ncache->flag= 0;
        ncache->simframe= 0;
 
        return ncache;
 }
+/* returns first point cache */
+PointCache *BKE_ptcache_copy_list(ListBase *ptcaches_new, ListBase *ptcaches_old)
+{
+       PointCache *cache = ptcaches_old->first;
+
+       ptcaches_new->first = ptcaches_new->last = NULL;
 
+       for(; cache; cache=cache->next)
+               BLI_addtail(ptcaches_new, ptcache_copy(cache));
+
+       return ptcaches_new->first;
+}
 
 
 /* Baking */
-void BKE_ptcache_autocache_all(Scene *scene)
+static int count_quick_cache(Scene *scene, int *quick_step)
+{
+       Base *base = scene->base.first;
+       PTCacheID *pid;
+       ListBase pidlist;
+       int autocache_count= 0;
+
+       for(base = scene->base.first; base; base = base->next) {
+               if(base->object) {
+                       BKE_ptcache_ids_from_object(&pidlist, base->object);
+
+                       for(pid=pidlist.first; pid; pid=pid->next) {
+                               if((pid->cache->flag & PTCACHE_BAKED)
+                                       || (pid->cache->flag & PTCACHE_QUICK_CACHE)==0)
+                                       continue;
+
+                               if(pid->cache->flag & PTCACHE_OUTDATED || (pid->cache->flag & PTCACHE_SIMULATION_VALID)==0) {
+                                       if(!autocache_count)
+                                               *quick_step = pid->cache->step;
+                                       else
+                                               *quick_step = MIN2(*quick_step, pid->cache->step);
+
+                                       autocache_count++;
+                               }
+                       }
+
+                       BLI_freelistN(&pidlist);
+               }
+       }
+
+       return autocache_count;
+}
+void BKE_ptcache_quick_cache_all(Scene *scene)
 {
        PTCacheBaker baker;
 
@@ -1030,9 +2200,10 @@ void BKE_ptcache_autocache_all(Scene *scene)
        baker.progressbar=NULL;
        baker.progresscontext=NULL;
        baker.render=0;
+       baker.anim_init = 0;
        baker.scene=scene;
 
-       if(psys_count_autocache(scene, NULL))
+       if(count_quick_cache(scene, &baker.quick_step))
                BKE_ptcache_make_cache(&baker);
 }
 
@@ -1043,27 +2214,45 @@ void BKE_ptcache_make_cache(PTCacheBaker* baker)
        Base *base;
        ListBase pidlist;
        PTCacheID *pid = baker->pid;
-       PointCache *cache;
+       PointCache *cache = NULL;
        float frameleno = scene->r.framelen;
        int cfrao = CFRA;
        int startframe = MAXFRAME;
-       int endframe = CFRA;
+       int endframe = baker->anim_init ? scene->r.sfra : CFRA;
        int bake = baker->bake;
        int render = baker->render;
+       int step = baker->quick_step;
 
        G.afbreek = 0;
 
-       //printf("Caching physics...");
-
        /* set caches to baking mode and figure out start frame */
        if(pid) {
                /* cache/bake a single object */
                cache = pid->cache;
                if((cache->flag & PTCACHE_BAKED)==0) {
                        if(pid->type==PTCACHE_TYPE_PARTICLES)
-                               psys_get_pointcache_start_end(scene, pid->data, &cache->startframe, &cache->endframe);
+                               psys_get_pointcache_start_end(scene, pid->calldata, &cache->startframe, &cache->endframe);
+                       else if(pid->type == PTCACHE_TYPE_SMOKE_HIGHRES) {
+                               /* get all pids from the object and search for smoke low res */
+                               ListBase pidlist2;
+                               PTCacheID *pid2;
+                               BKE_ptcache_ids_from_object(&pidlist2, pid->ob);
+                               for(pid2=pidlist2.first; pid2; pid2=pid2->next) {
+                                       if(pid2->type == PTCACHE_TYPE_SMOKE_DOMAIN) 
+                                       {
+                                               if(pid2->cache && !(pid2->cache->flag & PTCACHE_BAKED)) {
+                                                       if(bake || pid2->cache->flag & PTCACHE_REDO_NEEDED)
+                                                               BKE_ptcache_id_clear(pid2, PTCACHE_CLEAR_ALL, 0);
+                                                       if(bake) {
+                                                               pid2->cache->flag |= PTCACHE_BAKING;
+                                                               pid2->cache->flag &= ~PTCACHE_BAKED;
+                                                       }
+                                               }
+                                       }
+                               }
+                       }
 
-                       if(bake || cache->flag & PTCACHE_OUTDATED)
+                       if(bake || cache->flag & PTCACHE_REDO_NEEDED)
                                BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_ALL, 0);
 
                        startframe = MAX2(cache->last_exact, cache->startframe);
@@ -1072,8 +2261,9 @@ void BKE_ptcache_make_cache(PTCacheBaker* baker)
                                endframe = cache->endframe;
                                cache->flag |= PTCACHE_BAKING;
                        }
-                       else
+                       else {
                                endframe = MIN2(endframe, cache->endframe);
+                       }
 
                        cache->flag &= ~PTCACHE_BAKED;
                }
@@ -1085,38 +2275,43 @@ void BKE_ptcache_make_cache(PTCacheBaker* baker)
                for(pid=pidlist.first; pid; pid=pid->next) {
                        cache = pid->cache;
                        if((cache->flag & PTCACHE_BAKED)==0) {
-                               if(pid->type==PTCACHE_TYPE_PARTICLES)
-                                       psys_get_pointcache_start_end(scene, pid->data, &cache->startframe, &cache->endframe);
+                               if(pid->type==PTCACHE_TYPE_PARTICLES) {
+                                       ParticleSystem *psys = (ParticleSystem*)pid->calldata;
+                                       /* skip hair & keyed particles */
+                                       if(psys->part->type == PART_HAIR || psys->part->phystype == PART_PHYS_KEYED)
+                                               continue;
+
+                                       psys_get_pointcache_start_end(scene, pid->calldata, &cache->startframe, &cache->endframe);
+                               }
 
-                               if(cache->flag & PTCACHE_OUTDATED)
+                               if((cache->flag & PTCACHE_REDO_NEEDED || (cache->flag & PTCACHE_SIMULATION_VALID)==0)
+                                       && ((cache->flag & PTCACHE_QUICK_CACHE)==0 || render || bake))
                                        BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_ALL, 0);
 
                                startframe = MIN2(startframe, cache->startframe);
 
-                               if(bake) {
-                                       endframe = MAX2(endframe, cache->endframe);
+                               if(bake || render) {
                                        cache->flag |= PTCACHE_BAKING;
+
+                                       if(bake)
+                                               endframe = MAX2(endframe, cache->endframe);
                                }
-                               else if(render)
-                                       cache->flag |= PTCACHE_BAKING;
 
                                cache->flag &= ~PTCACHE_BAKED;
 
                        }
                }
-
                BLI_freelistN(&pidlist);
        }
 
        CFRA= startframe;
        scene->r.framelen = 1.0;
-       scene_update_for_newframe(scene, scene->lay);
 
-       for(; CFRA <= endframe; CFRA++) {
-               float prog;
+       for(; CFRA <= endframe; CFRA+=step) {
+               int prog;
 
                if(bake)
-                       prog = (int)(100.0 * (float)(CFRA - startframe)/(float)(endframe-startframe));
+                       prog = (int)(100.0f * (float)(CFRA - startframe)/(float)(endframe-startframe));
                else
                        prog = CFRA;
 
@@ -1133,112 +2328,345 @@ void BKE_ptcache_make_cache(PTCacheBaker* baker)
 
        /* clear baking flag */
        if(pid) {
-               cache->flag &= ~(PTCACHE_BAKING|PTCACHE_OUTDATED);
-               if(bake)
+               cache->flag &= ~(PTCACHE_BAKING|PTCACHE_REDO_NEEDED);
+               cache->flag |= PTCACHE_SIMULATION_VALID;
+               if(bake) {
                        cache->flag |= PTCACHE_BAKED;
+                       /* write info file */
+                       if(cache->flag & PTCACHE_DISK_CACHE)
+                               BKE_ptcache_write_cache(pid, 0);
+               }
        }
        else for(base=scene->base.first; base; base= base->next) {
                BKE_ptcache_ids_from_object(&pidlist, base->object);
 
                for(pid=pidlist.first; pid; pid=pid->next) {
-                       cache->flag &= ~(PTCACHE_BAKING|PTCACHE_OUTDATED);
-                       if(bake)
+                       /* skip hair particles */
+                       if(pid->type==PTCACHE_TYPE_PARTICLES && ((ParticleSystem*)pid->calldata)->part->type == PART_HAIR)
+                               continue;
+               
+                       cache = pid->cache;
+
+                       if(step > 1)
+                               cache->flag &= ~(PTCACHE_BAKING|PTCACHE_OUTDATED);
+                       else
+                               cache->flag &= ~(PTCACHE_BAKING|PTCACHE_REDO_NEEDED);
+
+                       cache->flag |= PTCACHE_SIMULATION_VALID;
+
+                       if(bake) {
                                cache->flag |= PTCACHE_BAKED;
+                               if(cache->flag & PTCACHE_DISK_CACHE)
+                                       BKE_ptcache_write_cache(pid, 0);
+                       }
                }
+               BLI_freelistN(&pidlist);
        }
-       
-       //printf("done!\n");
 
        scene->r.framelen = frameleno;
        CFRA = cfrao;
-       scene_update_for_newframe(scene, scene->lay);
-}
 
-void BKE_ptcache_toggle_disk_cache(PTCacheID *pid) {
+       if(bake) /* already on cfra unless baking */
+               scene_update_for_newframe(scene, scene->lay);
+
+       /* TODO: call redraw all windows somehow */
+}
+/* Helpers */
+void BKE_ptcache_disk_to_mem(PTCacheID *pid)
+{
        PointCache *cache = pid->cache;
        PTCacheFile *pf;
        PTCacheMem *pm;
-       int totelem=0;
-       int float_count=0;
-       int tot;
 
-       if (!G.relbase_valid){
-               cache->flag &= ~PTCACHE_DISK_CACHE;
-               return;
+       int cfra, sfra = cache->startframe, efra = cache->endframe;
+       int i;
+
+       BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_ALL, 0);
+
+       for(cfra=sfra; cfra <= efra; cfra++) {
+               pf = ptcache_file_open(pid, PTCACHE_FILE_READ, cfra);
+
+               if(pf) {
+                       if(!ptcache_file_read_header_begin(pf)) {
+                               printf("Can't yet convert old cache format\n");
+                               cache->flag |= PTCACHE_DISK_CACHE;
+                               ptcache_file_close(pf);
+                               return;
+                       }
+
+                       if(pf->type != pid->type || !pid->read_header(pf)) {
+                               cache->flag |= PTCACHE_DISK_CACHE;
+                               ptcache_file_close(pf);
+                               return;
+                       }
+                       
+                       pm = MEM_callocN(sizeof(PTCacheMem), "Pointcache mem");
+
+                       pm->totpoint = pf->totpoint;
+                       pm->data_types = pf->data_types;
+                       pm->frame = cfra;
+
+                       ptcache_alloc_data(pm);
+                       BKE_ptcache_mem_init_pointers(pm);
+                       ptcache_file_init_pointers(pf);
+
+                       for(i=0; i<pm->totpoint; i++) {
+                               if(!ptcache_file_read_data(pf)) {
+                                       printf("Error reading from disk cache\n");
+                                       
+                                       cache->flag |= PTCACHE_DISK_CACHE;
+                                       
+                                       ptcache_free_data(pm->data);
+                                       MEM_freeN(pm);
+                                       ptcache_file_close(pf);
+
+                                       return;
+                               }
+                               ptcache_copy_data(pf->cur, pm->cur);
+                               BKE_ptcache_mem_incr_pointers(pm);
+                       }
+
+                       //ptcache_make_index_array(pm, pid->totpoint(pid->calldata));
+
+                       BLI_addtail(&pid->cache->mem_cache, pm);
+
+                       ptcache_file_close(pf);
+               }
        }
 
-       totelem = ptcache_pid_totelem(pid);
-       float_count = ptcache_pid_elemsize(pid) / sizeof(float);
+}
+void BKE_ptcache_mem_to_disk(PTCacheID *pid)
+{
+       PointCache *cache = pid->cache;
+       PTCacheFile *pf;
+       PTCacheMem *pm;
+       int i;
 
-       if(totelem==0 || float_count==0)
-               return;
+       pm = cache->mem_cache.first;
 
-       tot = totelem*float_count;
+       BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_ALL, 0);
 
-       /* MEM -> DISK */
-       if(cache->flag & PTCACHE_DISK_CACHE) {
-               pm = cache->mem_cache.first;
+       for(; pm; pm=pm->next) {
+               pf = ptcache_file_open(pid, PTCACHE_FILE_WRITE, pm->frame);
 
-               BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_ALL, 0);
+               if(pf) {
+                       pf->data_types = pm->data_types;
+                       pf->totpoint = pm->totpoint;
+                       pf->type = pid->type;
 
-               for(; pm; pm=pm->next) {
-                       pf = BKE_ptcache_file_open(pid, PTCACHE_FILE_WRITE, pm->frame);
+                       BKE_ptcache_mem_init_pointers(pm);
+                       ptcache_file_init_pointers(pf);
 
-                       if(pf) {
-                               if(fwrite(pm->data, sizeof(float), tot, pf->fp) != tot) {
+                       if(!ptcache_file_write_header_begin(pf) || !pid->write_header(pf)) {
+                               printf("Error writing to disk cache\n");
+                               cache->flag &= ~PTCACHE_DISK_CACHE;
+
+                               ptcache_file_close(pf);
+                               return;
+                       }
+
+                       for(i=0; i<pm->totpoint; i++) {
+                               ptcache_copy_data(pm->cur, pf->cur);
+                               if(!ptcache_file_write_data(pf)) {
                                        printf("Error writing to disk cache\n");
-                                       
                                        cache->flag &= ~PTCACHE_DISK_CACHE;
 
-                                       BKE_ptcache_file_close(pf);
+                                       ptcache_file_close(pf);
                                        return;
                                }
-                               BKE_ptcache_file_close(pf);
+                               BKE_ptcache_mem_incr_pointers(pm);
                        }
-                       else
-                               printf("Error creating disk cache file\n");
+
+                       ptcache_file_close(pf);
+
+                       /* write info file */
+                       if(cache->flag & PTCACHE_BAKED)
+                               BKE_ptcache_write_cache(pid, 0);
                }
+               else
+                       printf("Error creating disk cache file\n");
+       }
+}
+void BKE_ptcache_toggle_disk_cache(PTCacheID *pid)
+{
+       PointCache *cache = pid->cache;
+       int last_exact = cache->last_exact;
 
+       if (!G.relbase_valid){
                cache->flag &= ~PTCACHE_DISK_CACHE;
-               BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_ALL, 0);
-               cache->flag |= PTCACHE_DISK_CACHE;
+               printf("File must be saved before using disk cache!\n");
+               return;
        }
-       /* DISK -> MEM */
-       else {
-               int cfra;
-               int sfra = cache->startframe;
-               int efra = cache->endframe;
 
-               BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_ALL, 0);
+       if(cache->flag & PTCACHE_DISK_CACHE)
+               BKE_ptcache_mem_to_disk(pid);
+       else
+               BKE_ptcache_disk_to_mem(pid);
 
-               for(cfra=sfra; cfra <= efra; cfra++) {
-                       pf = BKE_ptcache_file_open(pid, PTCACHE_FILE_READ, cfra);
+       cache->flag ^= PTCACHE_DISK_CACHE;
+       BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_ALL, 0);
+       cache->flag ^= PTCACHE_DISK_CACHE;
+       
+       cache->last_exact = last_exact;
 
-                       if(pf) {
-                               pm = MEM_callocN(sizeof(PTCacheMem), "Pointcache mem");
-                               pm->data = MEM_callocN(sizeof(float)*tot, "Pointcache mem data");
+       BKE_ptcache_update_info(pid);
+}
 
-                               if(fread(pm->data, sizeof(float), tot, pf->fp)!= tot) {
-                                       printf("Error reading from disk cache\n");
+void BKE_ptcache_load_external(PTCacheID *pid)
+{
+       /*todo*/
+       PointCache *cache = pid->cache;
+       int len; /* store the length of the string */
+       int info = 0;
 
-                                       cache->flag |= PTCACHE_DISK_CACHE;
+       /* mode is same as fopen's modes */
+       DIR *dir; 
+       struct dirent *de;
+       char path[MAX_PTCACHE_PATH];
+       char filename[MAX_PTCACHE_FILE];
+       char ext[MAX_PTCACHE_PATH];
 
-                                       MEM_freeN(pm->data);
-                                       MEM_freeN(pm);
-                                       BKE_ptcache_file_close(pf);
-                                       return;
+       if(!cache)
+               return;
+
+       cache->startframe = MAXFRAME;
+       cache->endframe = -1;
+       cache->totpoint = 0;
+
+       ptcache_path(pid, path);
+       
+       len = BKE_ptcache_id_filename(pid, filename, 1, 0, 0); /* no path */
+       
+       dir = opendir(path);
+       if (dir==NULL)
+               return;
+
+       if(cache->index >= 0)
+               snprintf(ext, sizeof(ext), "_%02d"PTCACHE_EXT, cache->index);
+       else
+               strcpy(ext, PTCACHE_EXT);
+       
+       while ((de = readdir(dir)) != NULL) {
+               if (strstr(de->d_name, ext)) { /* do we have the right extension?*/
+                       if (strncmp(filename, de->d_name, len ) == 0) { /* do we have the right prefix */
+                               /* read the number of the file */
+                               int frame, len2 = (int)strlen(de->d_name);
+                               char num[7];
+
+                               if (len2 > 15) { /* could crash if trying to copy a string out of this range*/
+                                       BLI_strncpy(num, de->d_name + (strlen(de->d_name) - 15), sizeof(num));
+                                       frame = atoi(num);
+
+                                       if(frame) {
+                                               cache->startframe = MIN2(cache->startframe, frame);
+                                               cache->endframe = MAX2(cache->endframe, frame);
+                                       }
+                                       else
+                                               info = 1;
                                }
+                       }
+               }
+       }
+       closedir(dir);
 
-                               pm->frame = cfra;
+       if(cache->startframe != MAXFRAME) {
+               PTCacheFile *pf;
 
-                               BLI_addtail(&pid->cache->mem_cache, pm);
+               /* read totpoint from info file (frame 0) */
+               if(info) {
+                       pf= ptcache_file_open(pid, PTCACHE_FILE_READ, 0);
 
-                               BKE_ptcache_file_close(pf);
+                       if(pf) {
+                               if(ptcache_file_read_header_begin(pf)) {
+                                       if(pf->type == pid->type && pid->read_header(pf)) {
+                                               cache->totpoint = pf->totpoint;
+                                               cache->flag |= PTCACHE_READ_INFO;
+                                       }
+                                       else {
+                                               cache->totpoint = 0;
+                                       }
+                               }
+                               ptcache_file_close(pf);
                        }
                }
+               /* or from any old format cache file */
+               else {
+                       float old_data[14];
+                       int elemsize = ptcache_pid_old_elemsize(pid);
+                       pf= ptcache_file_open(pid, PTCACHE_FILE_READ, cache->startframe);
 
-               cache->flag |= PTCACHE_DISK_CACHE;
-               BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_ALL, 0);
-               cache->flag &= ~PTCACHE_DISK_CACHE;
+                       if(pf) {
+                               while(ptcache_file_read(pf, old_data, 1, elemsize))
+                                       cache->totpoint++;
+                               
+                               ptcache_file_close(pf);
+                       }
+               }
+       }
+
+       cache->flag &= ~(PTCACHE_OUTDATED|PTCACHE_FRAMES_SKIPPED);
+
+       BKE_ptcache_update_info(pid);
+}
+
+void BKE_ptcache_update_info(PTCacheID *pid)
+{
+       PointCache *cache = pid->cache;
+       int totframes = 0;
+       char mem_info[64];
+
+       if(cache->flag & PTCACHE_EXTERNAL) {
+               int cfra = cache->startframe;
+
+               for(; cfra<=cache->endframe; cfra++) {
+                       if(BKE_ptcache_id_exist(pid, cfra))
+                               totframes++;
+               }
+
+               if(totframes && cache->totpoint)
+                       sprintf(cache->info, "%i points found!", cache->totpoint);
+               else
+                       sprintf(cache->info, "No valid data to read!");
+               return;
+       }
+
+       if(cache->flag & PTCACHE_DISK_CACHE) {
+               int cfra = cache->startframe;
+
+               for(; cfra<=cache->endframe; cfra++) {
+                       if(BKE_ptcache_id_exist(pid, cfra))
+                               totframes++;
+               }
+
+               sprintf(mem_info, "%i frames on disk", totframes);
+       }
+       else {
+               PTCacheMem *pm = cache->mem_cache.first;                
+               float framesize = 0.0f, bytes = 0.0f;
+               int mb;
+
+               if(pm)
+                       framesize = (float)ptcache_pid_old_elemsize(pid) * (float)pm->totpoint;
+               
+               for(; pm; pm=pm->next)
+                       totframes++;
+
+               bytes = totframes * framesize;
+
+               mb = (bytes > 1024.0f * 1024.0f);
+
+               sprintf(mem_info, "%i frames in memory (%.1f %s)",
+                       totframes,
+                       bytes / (mb ? 1024.0f * 1024.0f : 1024.0f),
+                       mb ? "Mb" : "kb");
+       }
+
+       if(cache->flag & PTCACHE_OUTDATED) {
+               sprintf(cache->info, "%s, cache is outdated!", mem_info);
+       }
+       else if(cache->flag & PTCACHE_FRAMES_SKIPPED) {
+               sprintf(cache->info, "%s, not exact since frame %i.", mem_info, cache->last_exact);
        }
+       else
+               sprintf(cache->info, "%s.", mem_info);
 }