Point cache editing:

- Baked point caches for particles, cloth and softbody can now be edited in particle mode.
	* This overwrites the old cloth/sb cache editmode editing.
	* The type of editable system is chosen from a menu.
	* For particles the current particle system and it's current cache are used.
- Currently this only works for caches that are in memory, but some automatic conversion from disk to memory and back can be implemented later.
- All tools from hair editing can't be applied to point caches and are hidden in the tool panel and specials menu. Some functionality like subdividing paths can be later implemented in a slightly different way from how it works for hair.
- Code is not yet optimized for speed, so editing might be slow sometimes.

Known issues:
- Cloth doesn't update properly while in particle mode, due to the way cloth modifier currently works. Daniel can you check on this?
- As "particle mode" is not only for particles any more some other name would be in place?
- Better icons are needed for the path, point, and tip-modes as the current icons from mesh edit mode are quite misleading.
- Direct editing of point velocities is not yet implemented, but will be in the future.

Other changes:
- Hair editing doesn't require a "make editable" button press any more.
- Multiple caches in single particle system disables changing emission properties.
- Unified ui code for all point cache panels.
	* Defined in buttons_particle.py and imported for cloth, smoke & softbody.
- Proper disabling of properties in ui after baking point caches. (Daniel could you please make needed disable code for smoke panels as their functionality is not familiar to me.)
- Hair weight brush has been removed. Once hair dynamics is re-implemented I'll code a more useable alternative to the functionality.

Bug fixes:
- Unlinking particle settings crashed.
- Deleting the active object with particles in the scene crashed.
- Softbody didn't write point caches correctly on save.

7 files changed, 401 insertions, 271 deletions

diff --git a/source/blender/blenkernel/BKE_particle.h b/source/blender/blenkernel/BKE_particle.h
index cf02efc34ac..e24114cd219 100644
--- a/source/blender/blenkernel/BKE_particle.h
+++ b/source/blender/blenkernel/BKE_particle.h
@@ -109,46 +109,10 @@ typedef struct ParticleCacheKey{
 	float vel[3];
 	float rot[4];
 	float col[3];
+	float time;
 	int steps;
 } ParticleCacheKey;
 
-typedef struct ParticleEditKey{
-	float *co;
-	float *vel;
-	float *rot;
-	float *time;
-
-	float world_co[3];
-	float length;
-	short flag;
-} ParticleEditKey;
-
-typedef struct ParticleUndo {
-	struct ParticleUndo *next, *prev;
-	struct ParticleEditKey **keys;
-	struct KDTree *emitter_field;
-	struct ParticleData *particles;
-	float *emitter_cosnos;
-	int totpart, totkeys;
-	char name[64];
-} ParticleUndo;
-
-typedef struct ParticleEdit {
-	ListBase undo;
-	struct ParticleUndo *curundo;
-
-	ParticleEditKey **keys;
-	int totkeys;
-
-	int *mirror_cache;
-
-	struct KDTree *emitter_field;
-	float *emitter_cosnos;
-
-	char sel_col[3];
-	char nosel_col[3];
-} ParticleEdit;
-
 typedef struct ParticleThreadContext {
 	/* shared */
 	struct Scene *scene;
@@ -240,7 +204,7 @@ int psys_check_enabled(struct Object *ob, struct ParticleSystem *psys);
 void psys_free_boid_rules(struct ListBase *list);
 void psys_free_settings(struct ParticleSettings *part);
 void free_child_path_cache(struct ParticleSystem *psys);
-void psys_free_path_cache(struct ParticleSystem *psys);
+void psys_free_path_cache(struct ParticleSystem *psys, struct PTCacheEdit *edit);
 void free_hair(struct ParticleSystem *psys, int softbody);
 void free_keyed_keys(struct ParticleSystem *psys);
 void psys_free(struct Object * ob, struct ParticleSystem * psys);
@@ -271,9 +235,9 @@ void psys_reset(struct ParticleSystem *psys, int mode);
 
 void psys_find_parents(struct Object *ob, struct ParticleSystemModifierData *psmd, struct ParticleSystem *psys);
 
-void psys_cache_paths(struct Scene *scene, struct Object *ob, struct ParticleSystem *psys, float cfra, int editupdate);
+void psys_cache_paths(struct Scene *scene, struct Object *ob, struct ParticleSystem *psys, float cfra);
+void psys_cache_edit_paths(struct Scene *scene, struct Object *ob, struct PTCacheEdit *edit, float cfra);
 void psys_cache_child_paths(struct Scene *scene, struct Object *ob, struct ParticleSystem *psys, float cfra, int editupdate);
-void psys_update_world_cos(struct Object *ob, struct ParticleSystem *psys);
 int do_guide(struct Scene *scene, struct ParticleKey *state, int pa_num, float time, struct ListBase *lb);
 float psys_get_size(struct Object *ob, struct Material *ma, struct ParticleSystemModifierData *psmd, struct IpoCurve *icu_size, struct ParticleSystem *psys, struct ParticleSettings *part, struct ParticleData *pa, float *vg_size);
 float psys_get_timestep(struct ParticleSettings *part);
@@ -359,12 +323,6 @@ void reset_particle(struct Scene *scene, struct ParticleData *pa, struct Particl
 #define PSYS_EC_PARTICLE	4
 #define PSYS_EC_REACTOR		8
 
-/* ParticleEditKey->flag */
-#define PEK_SELECT		1
-#define PEK_TO_SELECT	2
-#define PEK_TAG			4
-#define PEK_HIDE		8
-
 /* index_dmcache */
 #define DMCACHE_NOTFOUND	-1
 #define DMCACHE_ISCHILD		-2
diff --git a/source/blender/blenkernel/BKE_pointcache.h b/source/blender/blenkernel/BKE_pointcache.h
index 531487549da..9ba34091064 100644
--- a/source/blender/blenkernel/BKE_pointcache.h
+++ b/source/blender/blenkernel/BKE_pointcache.h
@@ -101,6 +101,8 @@ typedef struct PTCacheFile {
 	void *cur[BPHYS_TOT_DATA];
 } PTCacheFile;
 
+#define PTCACHE_VEL_PER_SEC		1
+
 typedef struct PTCacheID {
 	struct PTCacheID *next, *prev;
 
@@ -109,6 +111,7 @@ typedef struct PTCacheID {
 	void *calldata;
 	int type;
 	int stack_index;
+	int flag;
 
 	/* flags defined in DNA_object_force.h */
 	unsigned int data_types, info_types;
@@ -151,6 +154,75 @@ typedef struct PTCacheBaker {
 	void *progresscontext;
 } PTCacheBaker;
 
+/* PTCacheEditKey->flag */
+#define PEK_SELECT		1
+#define PEK_TAG			2
+#define PEK_HIDE		4
+#define PEK_USE_WCO		8
+
+typedef struct PTCacheEditKey{
+	float *co;
+	float *vel;
+	float *rot;
+	float *time;
+
+	float world_co[3];
+	float ftime;
+	float length;
+	short flag;
+} PTCacheEditKey;
+
+/* PTCacheEditPoint->flag */
+#define PEP_TAG				1
+#define PEP_EDIT_RECALC		2
+#define PEP_TRANSFORM		4
+#define PEP_HIDE			8
+
+typedef struct PTCacheEditPoint {
+	struct PTCacheEditKey *keys;
+	int totkey;
+	short flag;
+} PTCacheEditPoint;
+
+typedef struct PTCacheUndo {
+	struct PTCacheUndo *next, *prev;
+	struct PTCacheEditPoint *points;
+
+	/* particles stuff */
+	struct ParticleData *particles;
+	struct KDTree *emitter_field;
+	float *emitter_cosnos;
+
+	/* cache stuff */
+	struct ListBase mem_cache;
+
+	int totpoint;
+	char name[64];
+} PTCacheUndo;
+
+typedef struct PTCacheEdit {
+	ListBase undo;
+	struct PTCacheUndo *curundo;
+	PTCacheEditPoint *points;
+
+	struct PTCacheID pid;
+
+	/* particles stuff */
+	struct ParticleSystem *psys;
+	struct ParticleData *particles;
+	struct KDTree *emitter_field;
+	float *emitter_cosnos;
+	int *mirror_cache;
+
+	struct ParticleCacheKey **pathcache;	/* path cache (runtime) */
+	ListBase pathcachebufs;
+
+	int totpoint, totframes, totcached, edited;
+
+	char sel_col[3];
+	char nosel_col[3];
+} PTCacheEdit;
+
 /* Particle functions */
 void BKE_ptcache_make_particle_key(struct ParticleKey *key, int index, void **data, float time);
 
@@ -179,6 +251,10 @@ void BKE_ptcache_update_info(PTCacheID *pid);
 /* Size of cache data type. */
 int		BKE_ptcache_data_size(int data_type);
 
+/* Memory cache read/write helpers. */
+void BKE_ptcache_mem_init_pointers(struct PTCacheMem *pm);
+void BKE_ptcache_mem_incr_pointers(struct PTCacheMem *pm);
+
 /* Copy a specific data type from cache data to point data. */
 void	BKE_ptcache_data_get(void **data, int type, int index, void *to);
 
@@ -197,7 +273,7 @@ int BKE_ptcache_get_continue_physics(void);
 
 /******************* Allocate & free ***************/
 struct PointCache *BKE_ptcache_add(struct ListBase *ptcaches);
-void BKE_ptache_free_mem(struct PointCache *cache);
+void BKE_ptcache_free_mem(struct ListBase *mem_cache);
 void BKE_ptcache_free(struct PointCache *cache);
 void BKE_ptcache_free_list(struct ListBase *ptcaches);
 struct PointCache *BKE_ptcache_copy_list(struct ListBase *ptcaches_new, struct ListBase *ptcaches_old);
diff --git a/source/blender/blenkernel/intern/cloth.c b/source/blender/blenkernel/intern/cloth.c
index 3acaaecb1e8..eafd9eb01fe 100644
--- a/source/blender/blenkernel/intern/cloth.c
+++ b/source/blender/blenkernel/intern/cloth.c
@@ -347,7 +347,7 @@ void cloth_clear_cache(Object *ob, ClothModifierData *clmd, float framenr)
 	BKE_ptcache_id_from_cloth(&pid, ob, clmd);
 
 	// don't do anything as long as we're in editmode!
-	if(pid.cache->flag & PTCACHE_BAKE_EDIT_ACTIVE)
+	if(pid.cache->edit && ob->mode & OB_MODE_PARTICLE_EDIT)
 		return;
 	
 	BKE_ptcache_id_clear(&pid, PTCACHE_CLEAR_AFTER, framenr);
diff --git a/source/blender/blenkernel/intern/particle.c b/source/blender/blenkernel/intern/particle.c
index e1987d34a6c..18e3512967a 100644
--- a/source/blender/blenkernel/intern/particle.c
+++ b/source/blender/blenkernel/intern/particle.c
@@ -321,7 +321,7 @@ int psys_ob_has_hair(Object *ob)
 }
 int psys_in_edit_mode(Scene *scene, ParticleSystem *psys)
 {
-	return ((scene->basact->object->mode & OB_MODE_PARTICLE_EDIT) && psys==psys_get_current((scene->basact)->object) && psys->edit);
+	return (scene->basact && (scene->basact->object->mode & OB_MODE_PARTICLE_EDIT) && psys==psys_get_current((scene->basact)->object) && (psys->edit || psys->pointcache->edit));
 }
 int psys_check_enabled(Object *ob, ParticleSystem *psys)
 {
@@ -406,13 +406,20 @@ void free_child_path_cache(ParticleSystem *psys)
 	psys->childcache = NULL;
 	psys->totchildcache = 0;
 }
-void psys_free_path_cache(ParticleSystem *psys)
+void psys_free_path_cache(ParticleSystem *psys, PTCacheEdit *edit)
 {
-	psys_free_path_cache_buffers(psys->pathcache, &psys->pathcachebufs);
-	psys->pathcache= NULL;
-	psys->totcached= 0;
+	if(edit) {
+		psys_free_path_cache_buffers(edit->pathcache, &edit->pathcachebufs);
+		edit->pathcache= NULL;
+		edit->totcached= 0;
+	}
+	else {
+		psys_free_path_cache_buffers(psys->pathcache, &psys->pathcachebufs);
+		psys->pathcache= NULL;
+		psys->totcached= 0;
 
-	free_child_path_cache(psys);
+		free_child_path_cache(psys);
+	}
 }
 void psys_free_children(ParticleSystem *psys)
 {
@@ -431,14 +438,14 @@ void psys_free(Object *ob, ParticleSystem * psys)
 		int nr = 0;
 		ParticleSystem * tpsys;
 		
-		psys_free_path_cache(psys);
+		psys_free_path_cache(psys, NULL);
 
 		free_hair(psys, 1);
 
 		free_keyed_keys(psys);
 
 		if(psys->edit && psys->free_edit)
-			psys->free_edit(psys);
+			psys->free_edit(psys->edit);
 
 		if(psys->particles){
 			if(psys->particles->boid)
@@ -645,7 +652,7 @@ void psys_render_restore(Object *ob, ParticleSystem *psys)
 		psmd->dm->release(psmd->dm);
 	}
 
-	psys_free_path_cache(psys);
+	psys_free_path_cache(psys, NULL);
 
 	if(psys->child){
 		MEM_freeN(psys->child);
@@ -953,17 +960,25 @@ void psys_interpolate_particle(short type, ParticleKey keys[4], float dt, Partic
 
 
 typedef struct ParticleInterpolationData {
-	ParticleKey *kkey[2];
 	HairKey *hkey[2];
-	BodyPoint *bp[2];
+
+	int keyed;
+	ParticleKey *kkey[2];
+	
 	SoftBody *soft;
-	int keyed, cached;
+	BodyPoint *bp[2];
+
+	PointCache *cache;
+
+	PTCacheEditPoint *epoint;
+	PTCacheEditKey *ekey[2];
+
 	float birthtime, dietime;
+	int bspline;
 } ParticleInterpolationData;
 /* Assumes pointcache->mem_cache exists, so for disk cached particles call psys_make_temp_pointcache() before use */
-static void get_pointcache_keys_for_time(Object *ob, ParticleSystem *psys, int index, float t, ParticleKey *key1, ParticleKey *key2)
+static void get_pointcache_keys_for_time(Object *ob, PointCache *cache, int index, float t, ParticleKey *key1, ParticleKey *key2)
 {
-	PointCache *cache = psys->pointcache;
 	static PTCacheMem *pm = NULL; /* not thread safe */
 
 	if(index < 0) { /* initialize */
@@ -990,22 +1005,27 @@ static void get_pointcache_keys_for_time(Object *ob, ParticleSystem *psys, int i
 static void init_particle_interpolation(Object *ob, ParticleSystem *psys, ParticleData *pa, ParticleInterpolationData *pind)
 {
 
-	if(pind->keyed) {
-		pind->kkey[0] = pa->keys;
+	if(pind->epoint) {
+		PTCacheEditPoint *point = pind->epoint;
 
-		if(pa->totkey > 1)
-			pind->kkey[1] = pa->keys + 1;
-		else
-			pind->kkey[1] = NULL;
+		pind->ekey[0] = point->keys;
+		pind->ekey[1] = point->totkey > 1 ? point->keys + 1 : NULL;
+
+		pind->birthtime = *(point->keys->time);
+		pind->dietime = *((point->keys + point->totkey - 1)->time);
+	}
+	else if(pind->keyed) {
+		pind->kkey[0] = pa->keys;
+		pind->kkey[1] = pa->totkey > 1 ? pa->keys + 1 : NULL;
 
 		pind->birthtime = pa->keys->time;
 		pind->dietime = (pa->keys + pa->totkey - 1)->time;
 	}
-	else if(pind->cached) {
-		get_pointcache_keys_for_time(ob, psys, -1, 0.0f, NULL, NULL);
+	else if(pind->cache) {
+		get_pointcache_keys_for_time(ob, pind->cache, -1, 0.0f, NULL, NULL);
 
-		pind->birthtime = pa->time;
-		pind->dietime = pa->dietime;
+		pind->birthtime = pa ? pa->time : pind->cache->startframe;
+		pind->dietime = pa ? pa->dietime : pind->cache->endframe;
 	}
 	else {
 		pind->hkey[0] = pa->hair;
@@ -1020,6 +1040,14 @@ static void init_particle_interpolation(Object *ob, ParticleSystem *psys, Partic
 		pind->bp[1] = pind->soft->bpoint + pa->bpi + 1;
 	}
 }
+static void edit_to_particle(ParticleKey *key, PTCacheEditKey *ekey)
+{
+	VECCOPY(key->co, ekey->co);
+	if(ekey->vel) {
+		VECCOPY(key->vel, ekey->vel);
+	}
+	key->time = *(ekey->time);
+}
 static void hair_to_particle(ParticleKey *key, HairKey *hkey)
 {
 	VECCOPY(key->co, hkey->co);
@@ -1033,11 +1061,24 @@ static void bp_to_particle(ParticleKey *key, BodyPoint *bp, HairKey *hkey)
 
 static void do_particle_interpolation(ParticleSystem *psys, int p, ParticleData *pa, float t, float frs_sec, ParticleInterpolationData *pind, ParticleKey *result)
 {
+	PTCacheEditPoint *point = pind->epoint;
 	ParticleKey keys[4];
+	int point_vel = (point && point->keys->vel);
 	float real_t, dfra, keytime;
 
 	/* interpret timing and find keys */
-	if(pind->keyed) {
+	if(point) {
+		if(result->time < 0.0f)
+			real_t = -result->time;
+		else
+			real_t = *(pind->ekey[0]->time) + t * (*(pind->ekey[0][point->totkey-1].time) - *(pind->ekey[0]->time));
+
+		while(*(pind->ekey[1]->time) < real_t)
+			pind->ekey[1]++;
+
+		pind->ekey[0] = pind->ekey[1] - 1;
+	}
+	else if(pind->keyed) {
 		/* we have only one key, so let's use that */
 		if(pind->kkey[1]==NULL) {
 			copy_particle_key(result, pind->kkey[0], 1);
@@ -1074,7 +1115,7 @@ static void do_particle_interpolation(ParticleSystem *psys, int p, ParticleData
 		
 		pind->kkey[0] = pind->kkey[1] - 1;
 	}
-	else if(pind->cached) {
+	else if(pind->cache) {
 		if(result->time < 0.0f) /* flag for time in frames */
 			real_t = -result->time;
 		else
@@ -1095,7 +1136,11 @@ static void do_particle_interpolation(ParticleSystem *psys, int p, ParticleData
 	}
 
 	/* set actual interpolation keys */
-	if(pind->soft) {
+	if(point) {
+		edit_to_particle(keys + 1, pind->ekey[0]);
+		edit_to_particle(keys + 2, pind->ekey[1]);
+	}
+	else if(pind->soft) {
 		pind->bp[0] = pind->bp[1] - 1;
 		bp_to_particle(keys + 1, pind->bp[0], pind->hkey[0]);
 		bp_to_particle(keys + 2, pind->bp[1], pind->hkey[1]);
@@ -1104,8 +1149,8 @@ static void do_particle_interpolation(ParticleSystem *psys, int p, ParticleData
 		memcpy(keys + 1, pind->kkey[0], sizeof(ParticleKey));
 		memcpy(keys + 2, pind->kkey[1], sizeof(ParticleKey));
 	}
-	else if(pind->cached) {
-		get_pointcache_keys_for_time(NULL, psys, p, real_t, keys+1, keys+2);
+	else if(pind->cache) {
+		get_pointcache_keys_for_time(NULL, pind->cache, p, real_t, keys+1, keys+2);
 	}
 	else {
 		hair_to_particle(keys + 1, pind->hkey[0]);
@@ -1113,8 +1158,14 @@ static void do_particle_interpolation(ParticleSystem *psys, int p, ParticleData
 	}
 
 	/* set secondary interpolation keys for hair */
-	if(!pind->keyed && !pind->cached) {
-		if(pind->soft) {
+	if(!pind->keyed && !pind->cache && !point_vel) {
+		if(point) {
+			if(pind->ekey[0] != point->keys)
+				edit_to_particle(keys, pind->ekey[0] - 1);
+			else
+				edit_to_particle(keys, pind->ekey[0]);
+		}
+		else if(pind->soft) {
 			if(pind->hkey[0] != pa->hair)
 				bp_to_particle(keys, pind->bp[0] - 1, pind->hkey[0] - 1);
 			else
@@ -1127,7 +1178,13 @@ static void do_particle_interpolation(ParticleSystem *psys, int p, ParticleData
 				hair_to_particle(keys, pind->hkey[0]);
 		}
 
-		if(pind->soft) {
+		if(point) {
+			if(pind->ekey[1] != point->keys + point->totkey - 1)
+				edit_to_particle(keys + 3, pind->ekey[1] + 1);
+			else
+				edit_to_particle(keys + 3, pind->ekey[1]);
+		}
+		else if(pind->soft) {
 			if(pind->hkey[1] != pa->hair + pa->totkey - 1)
 				bp_to_particle(keys + 3, pind->bp[1] + 1, pind->hkey[1] + 1);
 			else
@@ -1145,19 +1202,19 @@ static void do_particle_interpolation(ParticleSystem *psys, int p, ParticleData
 	keytime = (real_t - keys[1].time) / dfra;
 
 	/* convert velocity to timestep size */
-	if(pind->keyed || pind->cached){
+	if(pind->keyed || pind->cache || point_vel){
 		VecMulf(keys[1].vel, dfra / frs_sec);
 		VecMulf(keys[2].vel, dfra / frs_sec);
 		QuatInterpol(result->rot,keys[1].rot,keys[2].rot,keytime);
 	}
 
 	/* now we should have in chronologiacl order k1<=k2<=t<=k3<=k4 with keytime between [0,1]->[k2,k3] (k1 & k4 used for cardinal & bspline interpolation)*/
-	psys_interpolate_particle((pind->keyed || pind->cached) ? -1 /* signal for cubic interpolation */
-		: ((psys->part->flag & PART_HAIR_BSPLINE) ? KEY_BSPLINE : KEY_CARDINAL)
+	psys_interpolate_particle((pind->keyed || pind->cache || point_vel) ? -1 /* signal for cubic interpolation */
+		: (pind->bspline ? KEY_BSPLINE : KEY_CARDINAL)
 		,keys, keytime, result, 1);
 
 	/* the velocity needs to be converted back from cubic interpolation */
-	if(pind->keyed || pind->cached)
+	if(pind->keyed || pind->cache || point_vel)
 		VecMulf(result->vel, frs_sec / dfra);
 }
 /************************************************/
@@ -1610,7 +1667,7 @@ ParticleSystemModifierData *psys_get_modifier(Object *ob, ParticleSystem *psys)
 			}
 		}
 	}
-	return 0;
+	return NULL;
 }
 /************************************************/
 /*			Particles on a shape				*/
@@ -2129,7 +2186,7 @@ int psys_threads_init_path(ParticleThread *threads, Scene *scene, float cfra, in
 
 	/*---start figuring out what is actually wanted---*/
 	if(psys_in_edit_mode(scene, psys))
-		if(psys->renderdata==0 && (psys->edit==NULL || pset->flag & PE_SHOW_CHILD)==0)
+		if(psys->renderdata==0 && (psys->edit==NULL || pset->flag & PE_DRAW_PART)==0)
 			totchild=0;
 
 	if(totchild && part->from!=PART_FROM_PARTICLE && part->childtype==PART_CHILD_FACES){
@@ -2245,7 +2302,7 @@ void psys_thread_create_path(ParticleThread *thread, struct ChildParticle *cpa,
 			needupdate= 0;
 			w= 0;
 			while(w<4 && cpa->pa[w]>=0) {
-				if(psys->particles[cpa->pa[w]].flag & PARS_EDIT_RECALC) {
+				if(psys->edit->points[cpa->pa[w]].flag & PEP_EDIT_RECALC) {
 					needupdate= 1;
 					break;
 				}
@@ -2288,7 +2345,7 @@ void psys_thread_create_path(ParticleThread *thread, struct ChildParticle *cpa,
 	}
 	else{
 		if(ctx->editupdate && !(part->flag & PART_BRANCHING)) {
-			if(!(psys->particles[cpa->parent].flag & PARS_EDIT_RECALC))
+			if(!(psys->edit->points[cpa->parent].flag & PEP_EDIT_RECALC))
 				return;
 
 			memset(keys, 0, sizeof(*keys)*(ctx->steps+1));
@@ -2557,24 +2614,20 @@ void psys_cache_child_paths(Scene *scene, Object *ob, ParticleSystem *psys, floa
 /* -Usefull for making use of opengl vertex arrays for super fast strand drawing.	*/
 /* -Makes child strands possible and creates them too into the cache.				*/
 /* -Cached path data is also used to determine cut position for the editmode tool.	*/
-void psys_cache_paths(Scene *scene, Object *ob, ParticleSystem *psys, float cfra, int editupdate)
+void psys_cache_paths(Scene *scene, Object *ob, ParticleSystem *psys, float cfra)
 {
-	ParticleCacheKey *ca, **cache=psys->pathcache;
+	ParticleCacheKey *ca, **cache= psys->pathcache;
 	ParticleSystemModifierData *psmd = psys_get_modifier(ob, psys);
-	ParticleEditSettings *pset = &scene->toolsettings->particle;
 	ParticleSettings *part = psys->part;
+	ParticleEditSettings *pset = &scene->toolsettings->particle;
 	
-	ParticleData *pa;
+	ParticleData *pa = psys->particles;
 	ParticleKey result;
 
-	ParticleEdit *edit = 0;
-	ParticleEditKey *ekey = 0;
-
-	SoftBody *soft = 0;
+	SoftBody *soft = NULL;
 	BodyPoint *bp[2] = {NULL, NULL};
 	
 	Material *ma;
-
 	ParticleInterpolationData pind;
 	
 	float birthtime = 0.0, dietime = 0.0;
@@ -2583,132 +2636,98 @@ void psys_cache_paths(Scene *scene, Object *ob, ParticleSystem *psys, float cfra
 	float prev_tangent[3], hairmat[4][4];
 	float rotmat[3][3];
 	int k,i;
-	int steps = (int)pow(2.0, (double)psys->part->draw_step);
+	int steps = (int)pow(2.0, (double)(psys->renderdata ? part->ren_step : part->draw_step));
 	int totpart = psys->totpart;
-	float sel_col[3];
-	float nosel_col[3];
 	float length, vec[3];
 	float *vg_effector= NULL, effector=0.0f;
 	float *vg_length= NULL, pa_length=1.0f;
 	int keyed, baked;
 
 	/* we don't have anything valid to create paths from so let's quit here */
-	if((psys->flag & PSYS_HAIR_DONE)==0 && (psys->flag & PSYS_KEYED)==0 && (psys->pointcache->flag & PTCACHE_BAKED)==0)
+	if(!(psys->flag & PSYS_HAIR_DONE) && !(psys->flag & PSYS_KEYED) && !(psys->pointcache->flag & PTCACHE_BAKED))
 		return;
 
+	if(psys_in_edit_mode(scene, psys))
+		if(psys->renderdata==0 && (psys->edit==NULL || pset->flag & PE_DRAW_PART)==0)
+			return;
+	
 	BLI_srandom(psys->seed);
 
 	keyed = psys->flag & PSYS_KEYED;
 	baked = psys->pointcache->flag & PTCACHE_BAKED;
 
-	if(psys->renderdata) {
-		steps = (int)pow(2.0, (double)psys->part->ren_step);
-	}
-	else if(psys_in_edit_mode(scene, psys)) {
-		edit=psys->edit;
-		
-		//timed = edit->draw_timed;
-
-		if(pset->brushtype == PE_BRUSH_WEIGHT) {
-			sel_col[0] = sel_col[1] = sel_col[2] = 1.0f;
-			nosel_col[0] = nosel_col[1] = nosel_col[2] = 0.0f;
-		}
-		else{
-			sel_col[0] = (float)edit->sel_col[0] / 255.0f;
-			sel_col[1] = (float)edit->sel_col[1] / 255.0f;
-			sel_col[2] = (float)edit->sel_col[2] / 255.0f;
-			nosel_col[0] = (float)edit->nosel_col[0] / 255.0f;
-			nosel_col[1] = (float)edit->nosel_col[1] / 255.0f;
-			nosel_col[2] = (float)edit->nosel_col[2] / 255.0f;
-		}
-	}
-
-	if(editupdate && psys->pathcache && totpart == psys->totcached) {
-		cache = psys->pathcache;
-	}
-	else {
-		/* clear out old and create new empty path cache */
-		psys_free_path_cache(psys);
-		cache= psys_alloc_path_cache_buffers(&psys->pathcachebufs, totpart, steps+1);
-		psys->pathcache= cache;
-	}
+	/* clear out old and create new empty path cache */
+	psys_free_path_cache(psys, NULL);
+	cache= psys->pathcache= psys_alloc_path_cache_buffers(&psys->pathcachebufs, totpart, steps+1);
 
-	if(edit==NULL && psys->soft && psys->softflag & OB_SB_ENABLE) {
+	if(psys->soft && psys->softflag & OB_SB_ENABLE) {
 		soft = psys->soft;
 		if(!soft->bpoint)
 			soft= NULL;
 	}
-	
+
 	psys->lattice = psys_get_lattice(scene, ob, psys);
 	ma= give_current_material(ob, psys->part->omat);
 	if(ma && (psys->part->draw & PART_DRAW_MAT_COL))
 		VECCOPY(col, &ma->r)
-	
+
 	if(psys->part->from!=PART_FROM_PARTICLE) {
 		if(!(psys->part->flag & PART_CHILD_EFFECT))
 			vg_effector = psys_cache_vgroup(psmd->dm, psys, PSYS_VG_EFFECTOR);
 		
-		if(!edit && !psys->totchild)
+		if(!psys->totchild)
 			vg_length = psys_cache_vgroup(psmd->dm, psys, PSYS_VG_LENGTH);
 	}
 
 	/*---first main loop: create all actual particles' paths---*/
-	for(i=0,pa=psys->particles; i<totpart; i++, pa++){
-		if(psys && edit==NULL && (pa->flag & PARS_NO_DISP || pa->flag & PARS_UNEXIST)) {
+	for(i=0; i<totpart; i++, pa++){
+		if(pa->flag & PARS_NO_DISP || pa->flag & PARS_UNEXIST) {
 			if(soft)
 				bp[0] += pa->totkey; /* TODO use of initialized value? */
 			continue;
 		}
 
-		if(editupdate && !(pa->flag & PARS_EDIT_RECALC)) continue;
-		else memset(cache[i], 0, sizeof(*cache[i])*(steps+1));
-
-		if(!edit && !psys->totchild) {
+		if(!psys->totchild) {
 			pa_length = 1.0f - part->randlength * 0.5 * (1.0f + pa->r_ave[0]);
 			if(vg_length)
 				pa_length *= psys_particle_value_from_verts(psmd->dm,part->from,pa,vg_length);
 		}
 
-		cache[i]->steps = steps;
+		pind.keyed = keyed;
+		pind.cache = baked ? psys->pointcache : NULL;
+		pind.soft = soft;
+		pind.epoint = NULL;
+		pind.bspline = (psys->part->flag & PART_HAIR_BSPLINE);
+
+		memset(cache[i], 0, sizeof(*cache[i])*(steps+1));
 
-		if(edit)
-			ekey = edit->keys[i];
+		cache[i]->steps = steps;
 
 		/*--get the first data points--*/
-		pind.keyed = keyed;
-		pind.cached = baked;
-		pind.soft = soft;
 		init_particle_interpolation(ob, psys, pa, &pind);
 
-
 		/* hairmat is needed for for non-hair particle too so we get proper rotations */
 		psys_mat_hair_to_global(ob, psmd->dm, psys->part->from, pa, hairmat);
 		VECCOPY(rotmat[0], hairmat[2]);
 		VECCOPY(rotmat[1], hairmat[1]);
 		VECCOPY(rotmat[2], hairmat[0]);
 
-		if(!edit) {
-			if(part->draw & PART_ABS_PATH_TIME) {
-				birthtime = MAX2(pind.birthtime, part->path_start);
-				dietime = MIN2(pind.dietime, part->path_end);
-			}
-			else {
-				float tb = pind.birthtime;
-				birthtime = tb + part->path_start * (pind.dietime - tb);
-				dietime = tb + part->path_end * (pind.dietime - tb);
-			}
-
-			if(birthtime >= dietime) {
-				cache[i]->steps = -1;
-				continue;
-			}
+		if(part->draw & PART_ABS_PATH_TIME) {
+			birthtime = MAX2(pind.birthtime, part->path_start);
+			dietime = MIN2(pind.dietime, part->path_end);
+		}
+		else {
+			float tb = pind.birthtime;
+			birthtime = tb + part->path_start * (pind.dietime - tb);
+			dietime = tb + part->path_end * (pind.dietime - tb);
+		}
 
-			dietime = birthtime + pa_length * (dietime - birthtime);
+		if(birthtime >= dietime) {
+			cache[i]->steps = -1;
+			continue;
 		}
-		else
-			/* XXX brecht: don't know if this code from 2.4 is correct
-			 * still, but makes hair appear again in particle mode */
-			dietime= pind.hkey[0][pa->totkey-1].time;
+
+		dietime = birthtime + pa_length * (dietime - birthtime);
 
 		/*--interpolate actual path from data points--*/
 		for(k=0, ca=cache[i]; k<=steps; k++, ca++){
@@ -2726,40 +2745,8 @@ void psys_cache_paths(Scene *scene, Object *ob, ParticleSystem *psys, float cfra
 			}
 
 			VECCOPY(ca->co, result.co);
-
-			/* selection coloring in edit mode */
-			if(edit){
-				if(pset->brushtype==PE_BRUSH_WEIGHT){
-					if(k==steps)
-						VecLerpf(ca->col, nosel_col, sel_col, pind.hkey[0]->weight);
-					else
-						VecLerpf(ca->col, nosel_col, sel_col,
-						(1.0f - keytime) * pind.hkey[0]->weight + keytime * pind.hkey[1]->weight);
-				}
-				else{
-					if((ekey + (pind.hkey[0] - pa->hair))->flag & PEK_SELECT){
-						if((ekey + (pind.hkey[1] - pa->hair))->flag & PEK_SELECT){
-							VECCOPY(ca->col, sel_col);
-						}
-						else{
-							VecLerpf(ca->col, sel_col, nosel_col, keytime);
-						}
-					}
-					else{
-						if((ekey + (pind.hkey[1] - pa->hair))->flag & PEK_SELECT){
-							VecLerpf(ca->col, nosel_col, sel_col, keytime);
-						}
-						else{
-							VECCOPY(ca->col, nosel_col);
-						}
-					}
-				}
-			}
-			else{
-				VECCOPY(ca->col, col);
-			}
+			VECCOPY(ca->col, col);
 		}
-
 		
 		/*--modify paths and calculate rotation & velocity--*/
 
@@ -2772,16 +2759,16 @@ void psys_cache_paths(Scene *scene, Object *ob, ParticleSystem *psys, float cfra
 
 		for(k=0, ca=cache[i]; k<=steps; k++, ca++) {
 			/* apply effectors */
-			if(!(psys->part->flag & PART_CHILD_EFFECT) && edit==0 && k)
+			if(!(psys->part->flag & PART_CHILD_EFFECT) && k)
 				do_path_effectors(scene, ob, psys, i, ca, k, steps, cache[i]->co, effector, dfra, cfra, &length, vec);
 
 			/* apply guide curves to path data */
-			if(edit==0 && psys->effectors.first && (psys->part->flag & PART_CHILD_EFFECT)==0)
+			if(psys->effectors.first && (psys->part->flag & PART_CHILD_EFFECT)==0)
 				/* ca is safe to cast, since only co and vel are used */
 				do_guide(scene, (ParticleKey*)ca, i, (float)k/(float)steps, &psys->effectors);
 
 			/* apply lattice */
-			if(psys->lattice && edit==0)
+			if(psys->lattice)
 				calc_latt_deform(psys->lattice, ca->co, 1.0f);
 
 			/* figure out rotation */
@@ -2810,8 +2797,8 @@ void psys_cache_paths(Scene *scene, Object *ob, ParticleSystem *psys, float cfra
 					cosangle= Inpf(tangent, prev_tangent);
 
 					/* note we do the comparison on cosangle instead of
-					 * angle, since floating point accuracy makes it give
-					 * different results across platforms */
+					* angle, since floating point accuracy makes it give
+					* different results across platforms */
 					if(cosangle > 0.999999f) {
 						QUATCOPY((ca - 1)->rot, (ca - 2)->rot);
 					}
@@ -2856,6 +2843,124 @@ void psys_cache_paths(Scene *scene, Object *ob, ParticleSystem *psys, float cfra
 	if(vg_length)
 		MEM_freeN(vg_length);
 }
+void psys_cache_edit_paths(Scene *scene, Object *ob, PTCacheEdit *edit, float cfra)
+{
+	ParticleCacheKey *ca, **cache= edit->pathcache;
+	ParticleEditSettings *pset = &scene->toolsettings->particle;
+	
+	PTCacheEditPoint *point = edit->points;
+	PTCacheEditKey *ekey = NULL;
+
+	ParticleSystem *psys = edit->psys;
+	ParticleSystemModifierData *psmd = psys_get_modifier(ob, psys);
+	ParticleSettings *part = psys ? psys->part : NULL;
+	ParticleData *pa = psys ? psys->particles : NULL;
+
+	ParticleInterpolationData pind;
+	ParticleKey result;
+	
+	float birthtime = 0.0, dietime = 0.0;
+	float t, time = 0.0, keytime = 0.0, dfra = 1.0, frs_sec;
+	float hairmat[4][4];
+	int k,i;
+	int steps = (int)pow(2.0, (double)pset->draw_step);
+	int totpart = edit->totpoint;
+	float sel_col[3];
+	float nosel_col[3];
+
+	steps = MAX2(steps, 4);
+
+	if(!cache || edit->totpoint != edit->totcached) {
+		/* clear out old and create new empty path cache */
+		psys_free_path_cache(NULL, edit);
+		cache= edit->pathcache= psys_alloc_path_cache_buffers(&edit->pathcachebufs, totpart, steps+1);
+	}
+
+	frs_sec = (psys || edit->pid.flag & PTCACHE_VEL_PER_SEC) ? 25.0f : 1.0f;
+
+	sel_col[0] = (float)edit->sel_col[0] / 255.0f;
+	sel_col[1] = (float)edit->sel_col[1] / 255.0f;
+	sel_col[2] = (float)edit->sel_col[2] / 255.0f;
+	nosel_col[0] = (float)edit->nosel_col[0] / 255.0f;
+	nosel_col[1] = (float)edit->nosel_col[1] / 255.0f;
+	nosel_col[2] = (float)edit->nosel_col[2] / 255.0f;
+
+	/*---first main loop: create all actual particles' paths---*/
+	for(i=0; i<totpart; i++, pa+=pa?1:0, point++){
+		if(edit->totcached && !(point->flag & PEP_EDIT_RECALC))
+			continue;
+
+		ekey = point->keys;
+
+		pind.keyed = 0;
+		pind.cache = NULL;
+		pind.soft = NULL;
+		pind.epoint = point;
+		pind.bspline = psys ? (psys->part->flag & PART_HAIR_BSPLINE) : 0;
+
+		memset(cache[i], 0, sizeof(*cache[i])*(steps+1));
+
+		cache[i]->steps = steps;
+
+		/*--get the first data points--*/
+		init_particle_interpolation(ob, psys, pa, &pind);
+
+		if(psys)
+			psys_mat_hair_to_global(ob, psmd->dm, psys->part->from, pa, hairmat);
+
+		birthtime = pind.birthtime;
+		dietime = pind.dietime;
+
+		if(birthtime >= dietime) {
+			cache[i]->steps = -1;
+			continue;
+		}
+
+		/*--interpolate actual path from data points--*/
+		for(k=0, ca=cache[i]; k<=steps; k++, ca++){
+			time = (float)k / (float)steps;
+
+			t = birthtime + time * (dietime - birthtime);
+
+			result.time = -t;
+
+			do_particle_interpolation(psys, i, pa, t, frs_sec, &pind, &result);
+
+			 /* non-hair points are allready in global space */
+			if(psys)
+				Mat4MulVecfl(hairmat, result.co);
+
+			VECCOPY(ca->co, result.co);
+
+			ca->vel[0] = ca->vel[1] = 0.0f;
+			ca->vel[1] = 1.0f;
+
+			/* selection coloring in edit mode */
+			if((ekey + (pind.ekey[0] - point->keys))->flag & PEK_SELECT){
+				if((ekey + (pind.ekey[1] - point->keys))->flag & PEK_SELECT){
+					VECCOPY(ca->col, sel_col);
+				}
+				else{
+					keytime = (t - (*pind.ekey[0]->time))/((*pind.ekey[1]->time) - (*pind.ekey[0]->time));
+					VecLerpf(ca->col, sel_col, nosel_col, keytime);
+				}
+			}
+			else{
+				if((ekey + (pind.ekey[1] - point->keys))->flag & PEK_SELECT){
+					keytime = (t - (*pind.ekey[0]->time))/((*pind.ekey[1]->time) - (*pind.ekey[0]->time));
+					VecLerpf(ca->col, nosel_col, sel_col, keytime);
+				}
+				else{
+					VECCOPY(ca->col, nosel_col);
+				}
+			}
+
+			ca->time = t;
+		}
+	}
+
+	edit->totcached = totpart;
+}
 /************************************************/
 /*			Particle Key handling				*/
 /************************************************/
@@ -3663,8 +3768,9 @@ void psys_get_particle_on_path(Scene *scene, Object *ob, ParticleSystem *psys, i
 		}
 
 		pind.keyed = keyed;
-		pind.cached = cached;
+		pind.cache = cached ? psys->pointcache : NULL;
 		pind.soft = NULL;
+		pind.epoint = NULL;
 		init_particle_interpolation(ob, psys, pa, &pind);
 		do_particle_interpolation(psys, p, pa, t, frs_sec, &pind, state);
 
diff --git a/source/blender/blenkernel/intern/particle_system.c b/source/blender/blenkernel/intern/particle_system.c
index bf642a14a49..0f72c1c5866 100644
--- a/source/blender/blenkernel/intern/particle_system.c
+++ b/source/blender/blenkernel/intern/particle_system.c
@@ -127,7 +127,7 @@ void psys_reset(ParticleSystem *psys, int mode)
 	int i;
 
 	if(ELEM(mode, PSYS_RESET_ALL, PSYS_RESET_DEPSGRAPH)) {
-		if(mode == PSYS_RESET_ALL || !(part->type == PART_HAIR && (psys->flag & PSYS_EDITED))) {
+		if(mode == PSYS_RESET_ALL || !(part->type == PART_HAIR && (psys->edit && psys->edit->edited))) {
 			if(psys->particles) {
 				if(psys->particles->keys)
 					MEM_freeN(psys->particles->keys);
@@ -145,6 +145,12 @@ void psys_reset(ParticleSystem *psys, int mode)
 
 			if(psys->reactevents.first)
 				BLI_freelistN(&psys->reactevents);
+
+			if(psys->edit && psys->free_edit) {
+				psys->free_edit(psys->edit);
+				psys->edit = NULL;
+				psys->free_edit = NULL;
+			}
 		}
 	}
 	else if(mode == PSYS_RESET_CACHE_MISS) {
@@ -165,7 +171,7 @@ void psys_reset(ParticleSystem *psys, int mode)
 	psys->totchild= 0;
 
 	/* reset path cache */
-	psys_free_path_cache(psys);
+	psys_free_path_cache(psys, NULL);
 
 	/* reset point cache */
 	psys->pointcache->flag &= ~PTCACHE_SIMULATION_VALID;
@@ -2274,7 +2280,7 @@ void psys_clear_temp_pointcache(ParticleSystem *psys)
 	if((psys->pointcache->flag & PTCACHE_DISK_CACHE)==0)
 		return;
 
-	BKE_ptache_free_mem(psys->pointcache);
+	BKE_ptcache_free_mem(&psys->pointcache->mem_cache);
 }
 void psys_get_pointcache_start_end(Scene *scene, ParticleSystem *psys, int *sfra, int *efra)
 {
@@ -3747,41 +3753,17 @@ static void psys_update_path_cache(Scene *scene, Object *ob, ParticleSystemModif
 	if((part->type==PART_HAIR || psys->flag&PSYS_KEYED || psys->pointcache->flag & PTCACHE_BAKED) && ( psys_in_edit_mode(scene, psys) || (part->type==PART_HAIR 
 		|| (part->ren_as == PART_DRAW_PATH && (part->draw_as == PART_DRAW_REND || psys->renderdata))))){
 
-		psys_cache_paths(scene, ob, psys, cfra, 0);
+		psys_cache_paths(scene, ob, psys, cfra);
 
 		/* for render, child particle paths are computed on the fly */
 		if(part->childtype) {
-			if(((psys->totchild!=0)) || (psys_in_edit_mode(scene, psys) && (pset->flag&PE_SHOW_CHILD)))
+			if(((psys->totchild!=0)) || (psys_in_edit_mode(scene, psys) && (pset->flag&PE_DRAW_PART)))
 				if(!(psys->part->type == PART_HAIR) || (psys->flag & PSYS_HAIR_DONE))
 					psys_cache_child_paths(scene, ob, psys, cfra, 0);
 		}
 	}
 	else if(psys->pathcache)
-		psys_free_path_cache(psys);
-}
-
-/* calculate and store key locations in world coordinates */
-void psys_update_world_cos(Object *ob, ParticleSystem *psys)
-{
-	ParticleSystemModifierData *psmd= psys_get_modifier(ob, psys);
-	ParticleData *pa;
-	ParticleEditKey *key;
-	int i, k, totpart;
-	float hairmat[4][4];
-
-	if(psys==0 || psys->edit==0)
-		return;
-
-	totpart= psys->totpart;
-
-	for(i=0, pa=psys->particles; i<totpart; i++, pa++) {
-		psys_mat_hair_to_global(ob, psmd->dm, psys->part->from, pa, hairmat);
-
-		for(k=0, key=psys->edit->keys[i]; k<pa->totkey; k++, key++) {
-			VECCOPY(key->world_co,key->co);
-			Mat4MulVecfl(hairmat, key->world_co);
-		}
-	}
+		psys_free_path_cache(psys, NULL);
 }
 
 static void hair_step(Scene *scene, Object *ob, ParticleSystemModifierData *psmd, ParticleSystem *psys, float cfra)
@@ -3808,9 +3790,6 @@ static void hair_step(Scene *scene, Object *ob, ParticleSystemModifierData *psmd
 	psys_init_effectors(scene, ob, part->eff_group, psys);
 	if(psys->effectors.first)
 		precalc_effectors(scene, ob,psys,psmd,cfra);
-		
-	if(psys_in_edit_mode(scene, psys))
-		psys_update_world_cos(ob, psys);
 
 	psys_update_path_cache(scene, ob,psmd,psys,cfra);
 }
@@ -4339,7 +4318,7 @@ static void system_step(Scene *scene, Object *ob, ParticleSystem *psys, Particle
 		psys_update_path_cache(scene, ob, psmd, psys,(int)cfra);
 	}
 	else if(psys->pathcache)
-		psys_free_path_cache(psys);
+		psys_free_path_cache(psys, NULL);
 
 	/* cleanup */
 	if(vg_vel) MEM_freeN(vg_vel);
@@ -4385,7 +4364,7 @@ static void psys_to_softbody(Scene *scene, Object *ob, ParticleSystem *psys)
 
 static int hair_needs_recalc(ParticleSystem *psys)
 {
-	if((psys->flag & PSYS_EDITED)==0 &&
+	if((!psys->edit || !psys->edit->edited) &&
 		((psys->flag & PSYS_HAIR_DONE)==0 || psys->recalc & PSYS_RECALC_RESET)) {
 		return 1;
 	}
diff --git a/source/blender/blenkernel/intern/pointcache.c b/source/blender/blenkernel/intern/pointcache.c
index 69da8f19d8c..c0223d1690c 100644
--- a/source/blender/blenkernel/intern/pointcache.c
+++ b/source/blender/blenkernel/intern/pointcache.c
@@ -434,6 +434,8 @@ void BKE_ptcache_id_from_particles(PTCacheID *pid, Object *ob, ParticleSystem *p
 	pid->cache_ptr= &psys->pointcache;
 	pid->ptcaches= &psys->ptcaches;
 
+	pid->flag |= PTCACHE_VEL_PER_SEC;
+
 	pid->write_elem= ptcache_write_particle;
 	pid->write_stream = NULL;
 	pid->read_stream = NULL;
@@ -800,14 +802,16 @@ 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);
+
+			if(psys->soft) {
+				pid= MEM_callocN(sizeof(PTCacheID), "PTCacheID");
+				BKE_ptcache_id_from_softbody(pid, ob, psys->soft);
+				BLI_addtail(lb, pid);
+			}
 		}
 	}
 
@@ -1087,7 +1091,7 @@ static void ptcache_file_init_pointers(PTCacheFile *pf)
 	pf->cur[BPHYS_DATA_BOIDS] =		data_types & (1<<BPHYS_DATA_BOIDS) ?		&pf->data.boids	: NULL;
 }
 
-static void ptcache_mem_init_pointers(PTCacheMem *pm)
+void BKE_ptcache_mem_init_pointers(PTCacheMem *pm)
 {
 	int data_types = pm->data_types;
 	int i;
@@ -1096,7 +1100,7 @@ static void ptcache_mem_init_pointers(PTCacheMem *pm)
 		pm->cur[i] = data_types & (1<<i) ? pm->data[i] : NULL;
 }
 
-static void ptcache_mem_incr_pointers(PTCacheMem *pm)
+void BKE_ptcache_mem_incr_pointers(PTCacheMem *pm)
 {
 	int i;
 
@@ -1249,12 +1253,12 @@ int BKE_ptcache_read_cache(PTCacheID *pid, float cfra, float frs_sec)
 		return 0;
 
 	if(pm) {
-		ptcache_mem_init_pointers(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) {
-		ptcache_mem_init_pointers(pm2);
+		BKE_ptcache_mem_init_pointers(pm2);
 		totpoint2 = pm2->totpoint;
 		index2 = pm2->data_types & (1<<BPHYS_DATA_INDEX) ? pm2->cur[BPHYS_DATA_INDEX] : &i;
 	}
@@ -1336,7 +1340,7 @@ int BKE_ptcache_read_cache(PTCacheID *pid, float cfra, float frs_sec)
 			}
 
 			if(pm) {
-				ptcache_mem_incr_pointers(pm);
+				BKE_ptcache_mem_incr_pointers(pm);
 				index = pm->data_types & (1<<BPHYS_DATA_INDEX) ? pm->cur[BPHYS_DATA_INDEX] : &i;
 			}
 		}
@@ -1387,7 +1391,7 @@ int BKE_ptcache_read_cache(PTCacheID *pid, float cfra, float frs_sec)
 			}
 
 			if(pm2) {
-				ptcache_mem_incr_pointers(pm2);
+				BKE_ptcache_mem_incr_pointers(pm2);
 				index2 = pm2->data_types & (1<<BPHYS_DATA_INDEX) ? pm2->cur[BPHYS_DATA_INDEX] : &i;
 			}
 		}
@@ -1559,11 +1563,11 @@ int BKE_ptcache_write_cache(PTCacheID *pid, int cfra)
 			pm->data_types = cfra ? pid->data_types : pid->info_types;
 
 			ptcache_alloc_data(pm);
-			ptcache_mem_init_pointers(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))
-					ptcache_mem_incr_pointers(pm);
+					BKE_ptcache_mem_incr_pointers(pm);
 			}
 			//ptcache_make_index_array(pm, pid->totpoint(pid->calldata));
 
@@ -1664,6 +1668,8 @@ 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)
@@ -1863,7 +1869,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);
 		}
@@ -1968,9 +1974,9 @@ PointCache *BKE_ptcache_add(ListBase *ptcaches)
 	return cache;
 }
 
-void BKE_ptache_free_mem(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) {
@@ -1979,22 +1985,25 @@ void BKE_ptache_free_mem(PointCache *cache)
 				MEM_freeN(pm->index_array);
 		}
 
-		BLI_freelistN(&cache->mem_cache);
+		BLI_freelistN(mem_cache);
 	}
 }
 void BKE_ptcache_free(PointCache *cache)
 {
-	BKE_ptache_free_mem(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;
 
-	for(; cache; cache=cache->next)
-		BKE_ptache_free_mem(cache);
-
-	BLI_freelistN(ptcaches);
+	while(cache) {
+		BLI_remlink(ptcaches, cache);
+		BKE_ptcache_free(cache);
+		cache = ptcaches->first;
+	}
 }
 
 static PointCache *ptcache_copy(PointCache *cache)
@@ -2258,7 +2267,7 @@ void BKE_ptcache_disk_to_mem(PTCacheID *pid)
 			pm->frame = cfra;
 
 			ptcache_alloc_data(pm);
-			ptcache_mem_init_pointers(pm);
+			BKE_ptcache_mem_init_pointers(pm);
 			ptcache_file_init_pointers(pf);
 
 			for(i=0; i<pm->totpoint; i++) {
@@ -2274,7 +2283,7 @@ void BKE_ptcache_disk_to_mem(PTCacheID *pid)
 					return;
 				}
 				ptcache_copy_data(pf->cur, pm->cur);
-				ptcache_mem_incr_pointers(pm);
+				BKE_ptcache_mem_incr_pointers(pm);
 			}
 
 			//ptcache_make_index_array(pm, pid->totpoint(pid->calldata));
@@ -2305,7 +2314,7 @@ void BKE_ptcache_mem_to_disk(PTCacheID *pid)
 			pf->totpoint = pm->totpoint;
 			pf->type = pid->type;
 
-			ptcache_mem_init_pointers(pm);
+			BKE_ptcache_mem_init_pointers(pm);
 			ptcache_file_init_pointers(pf);
 
 			if(!ptcache_file_write_header_begin(pf) || !pid->write_header(pf)) {
@@ -2325,7 +2334,7 @@ void BKE_ptcache_mem_to_disk(PTCacheID *pid)
 					ptcache_file_close(pf);
 					return;
 				}
-				ptcache_mem_incr_pointers(pm);
+				BKE_ptcache_mem_incr_pointers(pm);
 			}
 
 			ptcache_file_close(pf);
diff --git a/source/blender/blenkernel/intern/scene.c b/source/blender/blenkernel/intern/scene.c
index 63dabf18faa..10f6a8cf47c 100644
--- a/source/blender/blenkernel/intern/scene.c
+++ b/source/blender/blenkernel/intern/scene.c
@@ -404,11 +404,13 @@ Scene *add_scene(char *name)
 	sce->unit.scale_length = 1.0f;
 
 	pset= &sce->toolsettings->particle;
-	pset->flag= PE_KEEP_LENGTHS|PE_LOCK_FIRST|PE_DEFLECT_EMITTER;
+	pset->flag= PE_KEEP_LENGTHS|PE_LOCK_FIRST|PE_DEFLECT_EMITTER|PE_AUTO_VELOCITY;
 	pset->emitterdist= 0.25f;
 	pset->totrekey= 5;
 	pset->totaddkey= 5;
 	pset->brushtype= PE_BRUSH_NONE;
+	pset->draw_step= 2;
+	pset->fade_frames= 2;
 	for(a=0; a<PE_TOT_BRUSH; a++) {
 		pset->brush[a].strength= 50;
 		pset->brush[a].size= 50;