Cleanup: move particle undo into own file
authorCampbell Barton <ideasman42@gmail.com>
Mon, 19 Mar 2018 16:46:49 +0000 (17:46 +0100)
committerCampbell Barton <ideasman42@gmail.com>
Mon, 19 Mar 2018 16:46:49 +0000 (17:46 +0100)
Also avoid extern declarations which can get out of sync.

source/blender/editors/physics/CMakeLists.txt
source/blender/editors/physics/particle_edit.c
source/blender/editors/physics/particle_edit_undo.c [new file with mode: 0644]
source/blender/editors/physics/particle_edit_utildefines.h [new file with mode: 0644]
source/blender/editors/physics/particle_object.c
source/blender/editors/physics/physics_intern.h

index 898422d..a04ebb2 100644 (file)
@@ -40,6 +40,7 @@ set(SRC
        dynamicpaint_ops.c
        particle_boids.c
        particle_edit.c
+       particle_edit_undo.c
        particle_object.c
        physics_fluid.c
        physics_ops.c
@@ -48,6 +49,7 @@ set(SRC
        rigidbody_object.c
        rigidbody_world.c
 
+       particle_edit_utildefines.h
        physics_intern.h
 )
 
index 3c7cb90..93bfd15 100644 (file)
@@ -29,7 +29,6 @@
  *  \ingroup edphys
  */
 
-
 #include <stdlib.h>
 #include <math.h>
 #include <string.h>
@@ -47,7 +46,6 @@
 #include "BLI_math.h"
 #include "BLI_lasso_2d.h"
 #include "BLI_listbase.h"
-#include "BLI_string.h"
 #include "BLI_kdtree.h"
 #include "BLI_rand.h"
 #include "BLI_utildefines.h"
 
 #include "physics_intern.h"
 
-void PE_create_particle_edit(Scene *scene, Object *ob, PointCache *cache, ParticleSystem *psys);
-void PTCacheUndo_clear(PTCacheEdit *edit);
-void recalc_lengths(PTCacheEdit *edit);
-void recalc_emitter_field(Object *ob, ParticleSystem *psys);
-void update_world_cos(Object *ob, PTCacheEdit *edit);
-
-#define KEY_K                                  PTCacheEditKey *key; int k
-#define POINT_P                                        PTCacheEditPoint *point; int p
-#define LOOP_POINTS                            for (p=0, point=edit->points; p<edit->totpoint; p++, point++)
-#define LOOP_VISIBLE_POINTS            for (p=0, point=edit->points; p<edit->totpoint; p++, point++) if (!(point->flag & PEP_HIDE))
-#define LOOP_SELECTED_POINTS   for (p=0, point=edit->points; p<edit->totpoint; p++, point++) if (point_is_selected(point))
-#define LOOP_UNSELECTED_POINTS for (p=0, point=edit->points; p<edit->totpoint; p++, point++) if (!point_is_selected(point))
-#define LOOP_EDITED_POINTS             for (p=0, point=edit->points; p<edit->totpoint; p++, point++) if (point->flag & PEP_EDIT_RECALC)
-#define LOOP_TAGGED_POINTS             for (p=0, point=edit->points; p<edit->totpoint; p++, point++) if (point->flag & PEP_TAG)
-#define LOOP_KEYS                              for (k=0, key=point->keys; k<point->totkey; k++, key++)
-#define LOOP_VISIBLE_KEYS              for (k=0, key=point->keys; k<point->totkey; k++, key++) if (!(key->flag & PEK_HIDE))
-#define LOOP_SELECTED_KEYS             for (k=0, key=point->keys; k<point->totkey; k++, key++) if ((key->flag & PEK_SELECT) && !(key->flag & PEK_HIDE))
-#define LOOP_TAGGED_KEYS               for (k=0, key=point->keys; k<point->totkey; k++, key++) if (key->flag & PEK_TAG)
-
-#define KEY_WCO                                        ((key->flag & PEK_USE_WCO) ? key->world_co : key->co)
+#include "particle_edit_utildefines.h"
 
 /**************************** utilities *******************************/
 
@@ -4256,293 +4235,6 @@ void PARTICLE_OT_shape_cut(wmOperatorType *ot)
        ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 }
 
-/*********************** undo ***************************/
-
-static void free_PTCacheUndo(PTCacheUndo *undo)
-{
-       PTCacheEditPoint *point;
-       int i;
-
-       for (i=0, point=undo->points; i<undo->totpoint; i++, point++) {
-               if (undo->particles && (undo->particles + i)->hair)
-                       MEM_freeN((undo->particles + i)->hair);
-               if (point->keys)
-                       MEM_freeN(point->keys);
-       }
-       if (undo->points)
-               MEM_freeN(undo->points);
-
-       if (undo->particles)
-               MEM_freeN(undo->particles);
-
-       BKE_ptcache_free_mem(&undo->mem_cache);
-}
-
-static void make_PTCacheUndo(PTCacheEdit *edit, PTCacheUndo *undo)
-{
-       PTCacheEditPoint *point;
-       int i;
-
-       undo->totpoint= edit->totpoint;
-
-       if (edit->psys) {
-               ParticleData *pa;
-
-               pa= undo->particles= MEM_dupallocN(edit->psys->particles);
-
-               for (i=0; i<edit->totpoint; i++, pa++)
-                       pa->hair= MEM_dupallocN(pa->hair);
-
-               undo->psys_flag = edit->psys->flag;
-       }
-       else {
-               PTCacheMem *pm;
-
-               BLI_duplicatelist(&undo->mem_cache, &edit->pid.cache->mem_cache);
-               pm = undo->mem_cache.first;
-
-               for (; pm; pm=pm->next) {
-                       for (i=0; i<BPHYS_TOT_DATA; i++)
-                               pm->data[i] = MEM_dupallocN(pm->data[i]);
-               }
-       }
-
-       point= undo->points = MEM_dupallocN(edit->points);
-       undo->totpoint = edit->totpoint;
-
-       for (i=0; i<edit->totpoint; i++, point++) {
-               point->keys= MEM_dupallocN(point->keys);
-               /* no need to update edit key->co & key->time pointers here */
-       }
-}
-
-static void get_PTCacheUndo(PTCacheEdit *edit, PTCacheUndo *undo)
-{
-       ParticleSystem *psys = edit->psys;
-       ParticleData *pa;
-       HairKey *hkey;
-       POINT_P; KEY_K;
-
-       LOOP_POINTS {
-               if (psys && psys->particles[p].hair)
-                       MEM_freeN(psys->particles[p].hair);
-
-               if (point->keys)
-                       MEM_freeN(point->keys);
-       }
-       if (psys && psys->particles)
-               MEM_freeN(psys->particles);
-       if (edit->points)
-               MEM_freeN(edit->points);
-       if (edit->mirror_cache) {
-               MEM_freeN(edit->mirror_cache);
-               edit->mirror_cache= NULL;
-       }
-
-       edit->points= MEM_dupallocN(undo->points);
-       edit->totpoint = undo->totpoint;
-
-       LOOP_POINTS {
-               point->keys= MEM_dupallocN(point->keys);
-       }
-
-       if (psys) {
-               psys->particles= MEM_dupallocN(undo->particles);
-
-               psys->totpart= undo->totpoint;
-
-               LOOP_POINTS {
-                       pa = psys->particles + p;
-                       hkey= pa->hair = MEM_dupallocN(pa->hair);
-
-                       LOOP_KEYS {
-                               key->co= hkey->co;
-                               key->time= &hkey->time;
-                               hkey++;
-                       }
-               }
-
-               psys->flag = undo->psys_flag;
-       }
-       else {
-               PTCacheMem *pm;
-               int i;
-
-               BKE_ptcache_free_mem(&edit->pid.cache->mem_cache);
-
-               BLI_duplicatelist(&edit->pid.cache->mem_cache, &undo->mem_cache);
-
-               pm = edit->pid.cache->mem_cache.first;
-
-               for (; pm; pm=pm->next) {
-                       for (i=0; i<BPHYS_TOT_DATA; i++)
-                               pm->data[i] = MEM_dupallocN(pm->data[i]);
-
-                       BKE_ptcache_mem_pointers_init(pm);
-
-                       LOOP_POINTS {
-                               LOOP_KEYS {
-                                       if ((int)key->ftime == (int)pm->frame) {
-                                               key->co = pm->cur[BPHYS_DATA_LOCATION];
-                                               key->vel = pm->cur[BPHYS_DATA_VELOCITY];
-                                               key->rot = pm->cur[BPHYS_DATA_ROTATION];
-                                               key->time = &key->ftime;
-                                       }
-                               }
-                               BKE_ptcache_mem_pointers_incr(pm);
-                       }
-               }
-       }
-}
-
-void PE_undo_push(Scene *scene, const char *str)
-{
-       PTCacheEdit *edit= PE_get_current(scene, OBACT);
-       PTCacheUndo *undo;
-       int nr;
-
-       if (!edit) return;
-
-       /* remove all undos after (also when curundo==NULL) */
-       while (edit->undo.last != edit->curundo) {
-               undo= edit->undo.last;
-               BLI_remlink(&edit->undo, undo);
-               free_PTCacheUndo(undo);
-               MEM_freeN(undo);
-       }
-
-       /* make new */
-       edit->curundo= undo= MEM_callocN(sizeof(PTCacheUndo), "particle undo file");
-       BLI_strncpy(undo->name, str, sizeof(undo->name));
-       BLI_addtail(&edit->undo, undo);
-       
-       /* and limit amount to the maximum */
-       nr= 0;
-       undo= edit->undo.last;
-       while (undo) {
-               nr++;
-               if (nr==U.undosteps) break;
-               undo= undo->prev;
-       }
-       if (undo) {
-               while (edit->undo.first != undo) {
-                       PTCacheUndo *first= edit->undo.first;
-                       BLI_remlink(&edit->undo, first);
-                       free_PTCacheUndo(first);
-                       MEM_freeN(first);
-               }
-       }
-
-       /* copy  */
-       make_PTCacheUndo(edit, edit->curundo);
-}
-
-void PE_undo_step(Scene *scene, int step)
-{      
-       PTCacheEdit *edit= PE_get_current(scene, OBACT);
-
-       if (!edit) return;
-
-       if (step==0) {
-               get_PTCacheUndo(edit, edit->curundo);
-       }
-       else if (step==1) {
-               
-               if (edit->curundo==NULL || edit->curundo->prev==NULL) {
-                       /* pass */
-               }
-               else {
-                       if (G.debug & G_DEBUG) printf("undo %s\n", edit->curundo->name);
-                       edit->curundo= edit->curundo->prev;
-                       get_PTCacheUndo(edit, edit->curundo);
-               }
-       }
-       else {
-               /* curundo has to remain current situation! */
-               
-               if (edit->curundo==NULL || edit->curundo->next==NULL) {
-                       /* pass */
-               }
-               else {
-                       get_PTCacheUndo(edit, edit->curundo->next);
-                       edit->curundo= edit->curundo->next;
-                       if (G.debug & G_DEBUG) printf("redo %s\n", edit->curundo->name);
-               }
-       }
-
-       DAG_id_tag_update(&OBACT->id, OB_RECALC_DATA);
-}
-
-bool PE_undo_is_valid(Scene *scene)
-{
-       PTCacheEdit *edit= PE_get_current(scene, OBACT);
-       
-       if (edit) {
-               return (edit->undo.last != edit->undo.first);
-       }
-       return 0;
-}
-
-void PTCacheUndo_clear(PTCacheEdit *edit)
-{
-       PTCacheUndo *undo;
-
-       if (edit==NULL) return;
-       
-       undo= edit->undo.first;
-       while (undo) {
-               free_PTCacheUndo(undo);
-               undo= undo->next;
-       }
-       BLI_freelistN(&edit->undo);
-       edit->curundo= NULL;
-}
-
-void PE_undo(Scene *scene)
-{
-       PE_undo_step(scene, 1);
-}
-
-void PE_redo(Scene *scene)
-{
-       PE_undo_step(scene, -1);
-}
-
-void PE_undo_number(Scene *scene, int nr)
-{
-       PTCacheEdit *edit= PE_get_current(scene, OBACT);
-       PTCacheUndo *undo;
-       int a=0;
-       
-       for (undo= edit->undo.first; undo; undo= undo->next, a++) {
-               if (a==nr) break;
-       }
-       edit->curundo= undo;
-       PE_undo_step(scene, 0);
-}
-
-
-/* get name of undo item, return null if no item with this index */
-/* if active pointer, set it to 1 if true */
-const char *PE_undo_get_name(Scene *scene, int nr, bool *r_active)
-{
-       PTCacheEdit *edit= PE_get_current(scene, OBACT);
-       PTCacheUndo *undo;
-       
-       if (r_active) *r_active = false;
-       
-       if (edit) {
-               undo= BLI_findlink(&edit->undo, nr);
-               if (undo) {
-                       if (r_active && (undo == edit->curundo)) {
-                               *r_active = true;
-                       }
-                       return undo->name;
-               }
-       }
-       return NULL;
-}
-
 /************************ utilities ******************************/
 
 int PE_minmax(Scene *scene, float min[3], float max[3])
diff --git a/source/blender/editors/physics/particle_edit_undo.c b/source/blender/editors/physics/particle_edit_undo.c
new file mode 100644 (file)
index 0000000..3899d44
--- /dev/null
@@ -0,0 +1,344 @@
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2007 by Janne Karhu.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/editors/physics/particle_edit_undo.c
+ *  \ingroup edphys
+ */
+
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+#include <assert.h>
+
+#include "MEM_guardedalloc.h"
+
+#include "DNA_scene_types.h"
+#include "DNA_meshdata_types.h"
+
+#include "BLI_listbase.h"
+#include "BLI_string.h"
+#include "BLI_utildefines.h"
+
+#include "BKE_depsgraph.h"
+#include "BKE_global.h"
+#include "BKE_particle.h"
+#include "BKE_pointcache.h"
+
+
+#include "ED_particle.h"
+
+
+
+
+#include "particle_edit_utildefines.h"
+
+#include "physics_intern.h"
+
+static void free_PTCacheUndo(PTCacheUndo *undo)
+{
+       PTCacheEditPoint *point;
+       int i;
+
+       for (i=0, point=undo->points; i<undo->totpoint; i++, point++) {
+               if (undo->particles && (undo->particles + i)->hair)
+                       MEM_freeN((undo->particles + i)->hair);
+               if (point->keys)
+                       MEM_freeN(point->keys);
+       }
+       if (undo->points)
+               MEM_freeN(undo->points);
+
+       if (undo->particles)
+               MEM_freeN(undo->particles);
+
+       BKE_ptcache_free_mem(&undo->mem_cache);
+}
+
+static void make_PTCacheUndo(PTCacheEdit *edit, PTCacheUndo *undo)
+{
+       PTCacheEditPoint *point;
+       int i;
+
+       undo->totpoint= edit->totpoint;
+
+       if (edit->psys) {
+               ParticleData *pa;
+
+               pa= undo->particles= MEM_dupallocN(edit->psys->particles);
+
+               for (i=0; i<edit->totpoint; i++, pa++)
+                       pa->hair= MEM_dupallocN(pa->hair);
+
+               undo->psys_flag = edit->psys->flag;
+       }
+       else {
+               PTCacheMem *pm;
+
+               BLI_duplicatelist(&undo->mem_cache, &edit->pid.cache->mem_cache);
+               pm = undo->mem_cache.first;
+
+               for (; pm; pm=pm->next) {
+                       for (i=0; i<BPHYS_TOT_DATA; i++)
+                               pm->data[i] = MEM_dupallocN(pm->data[i]);
+               }
+       }
+
+       point= undo->points = MEM_dupallocN(edit->points);
+       undo->totpoint = edit->totpoint;
+
+       for (i=0; i<edit->totpoint; i++, point++) {
+               point->keys= MEM_dupallocN(point->keys);
+               /* no need to update edit key->co & key->time pointers here */
+       }
+}
+
+static void get_PTCacheUndo(PTCacheEdit *edit, PTCacheUndo *undo)
+{
+       ParticleSystem *psys = edit->psys;
+       ParticleData *pa;
+       HairKey *hkey;
+       POINT_P; KEY_K;
+
+       LOOP_POINTS {
+               if (psys && psys->particles[p].hair)
+                       MEM_freeN(psys->particles[p].hair);
+
+               if (point->keys)
+                       MEM_freeN(point->keys);
+       }
+       if (psys && psys->particles)
+               MEM_freeN(psys->particles);
+       if (edit->points)
+               MEM_freeN(edit->points);
+       if (edit->mirror_cache) {
+               MEM_freeN(edit->mirror_cache);
+               edit->mirror_cache= NULL;
+       }
+
+       edit->points= MEM_dupallocN(undo->points);
+       edit->totpoint = undo->totpoint;
+
+       LOOP_POINTS {
+               point->keys= MEM_dupallocN(point->keys);
+       }
+
+       if (psys) {
+               psys->particles= MEM_dupallocN(undo->particles);
+
+               psys->totpart= undo->totpoint;
+
+               LOOP_POINTS {
+                       pa = psys->particles + p;
+                       hkey= pa->hair = MEM_dupallocN(pa->hair);
+
+                       LOOP_KEYS {
+                               key->co= hkey->co;
+                               key->time= &hkey->time;
+                               hkey++;
+                       }
+               }
+
+               psys->flag = undo->psys_flag;
+       }
+       else {
+               PTCacheMem *pm;
+               int i;
+
+               BKE_ptcache_free_mem(&edit->pid.cache->mem_cache);
+
+               BLI_duplicatelist(&edit->pid.cache->mem_cache, &undo->mem_cache);
+
+               pm = edit->pid.cache->mem_cache.first;
+
+               for (; pm; pm=pm->next) {
+                       for (i=0; i<BPHYS_TOT_DATA; i++)
+                               pm->data[i] = MEM_dupallocN(pm->data[i]);
+
+                       BKE_ptcache_mem_pointers_init(pm);
+
+                       LOOP_POINTS {
+                               LOOP_KEYS {
+                                       if ((int)key->ftime == (int)pm->frame) {
+                                               key->co = pm->cur[BPHYS_DATA_LOCATION];
+                                               key->vel = pm->cur[BPHYS_DATA_VELOCITY];
+                                               key->rot = pm->cur[BPHYS_DATA_ROTATION];
+                                               key->time = &key->ftime;
+                                       }
+                               }
+                               BKE_ptcache_mem_pointers_incr(pm);
+                       }
+               }
+       }
+}
+
+void PE_undo_push(Scene *scene, const char *str)
+{
+       PTCacheEdit *edit= PE_get_current(scene, OBACT);
+       PTCacheUndo *undo;
+       int nr;
+
+       if (!edit) return;
+
+       /* remove all undos after (also when curundo==NULL) */
+       while (edit->undo.last != edit->curundo) {
+               undo= edit->undo.last;
+               BLI_remlink(&edit->undo, undo);
+               free_PTCacheUndo(undo);
+               MEM_freeN(undo);
+       }
+
+       /* make new */
+       edit->curundo= undo= MEM_callocN(sizeof(PTCacheUndo), "particle undo file");
+       BLI_strncpy(undo->name, str, sizeof(undo->name));
+       BLI_addtail(&edit->undo, undo);
+       
+       /* and limit amount to the maximum */
+       nr= 0;
+       undo= edit->undo.last;
+       while (undo) {
+               nr++;
+               if (nr==U.undosteps) break;
+               undo= undo->prev;
+       }
+       if (undo) {
+               while (edit->undo.first != undo) {
+                       PTCacheUndo *first= edit->undo.first;
+                       BLI_remlink(&edit->undo, first);
+                       free_PTCacheUndo(first);
+                       MEM_freeN(first);
+               }
+       }
+
+       /* copy  */
+       make_PTCacheUndo(edit, edit->curundo);
+}
+
+void PE_undo_step(Scene *scene, int step)
+{      
+       PTCacheEdit *edit= PE_get_current(scene, OBACT);
+
+       if (!edit) return;
+
+       if (step==0) {
+               get_PTCacheUndo(edit, edit->curundo);
+       }
+       else if (step==1) {
+               
+               if (edit->curundo==NULL || edit->curundo->prev==NULL) {
+                       /* pass */
+               }
+               else {
+                       if (G.debug & G_DEBUG) printf("undo %s\n", edit->curundo->name);
+                       edit->curundo= edit->curundo->prev;
+                       get_PTCacheUndo(edit, edit->curundo);
+               }
+       }
+       else {
+               /* curundo has to remain current situation! */
+               
+               if (edit->curundo==NULL || edit->curundo->next==NULL) {
+                       /* pass */
+               }
+               else {
+                       get_PTCacheUndo(edit, edit->curundo->next);
+                       edit->curundo= edit->curundo->next;
+                       if (G.debug & G_DEBUG) printf("redo %s\n", edit->curundo->name);
+               }
+       }
+
+       DAG_id_tag_update(&OBACT->id, OB_RECALC_DATA);
+}
+
+bool PE_undo_is_valid(Scene *scene)
+{
+       PTCacheEdit *edit= PE_get_current(scene, OBACT);
+       
+       if (edit) {
+               return (edit->undo.last != edit->undo.first);
+       }
+       return 0;
+}
+
+void PTCacheUndo_clear(PTCacheEdit *edit)
+{
+       PTCacheUndo *undo;
+
+       if (edit==NULL) return;
+       
+       undo= edit->undo.first;
+       while (undo) {
+               free_PTCacheUndo(undo);
+               undo= undo->next;
+       }
+       BLI_freelistN(&edit->undo);
+       edit->curundo= NULL;
+}
+
+void PE_undo(Scene *scene)
+{
+       PE_undo_step(scene, 1);
+}
+
+void PE_redo(Scene *scene)
+{
+       PE_undo_step(scene, -1);
+}
+
+void PE_undo_number(Scene *scene, int nr)
+{
+       PTCacheEdit *edit= PE_get_current(scene, OBACT);
+       PTCacheUndo *undo;
+       int a=0;
+       
+       for (undo= edit->undo.first; undo; undo= undo->next, a++) {
+               if (a==nr) break;
+       }
+       edit->curundo= undo;
+       PE_undo_step(scene, 0);
+}
+
+
+/* get name of undo item, return null if no item with this index */
+/* if active pointer, set it to 1 if true */
+const char *PE_undo_get_name(Scene *scene, int nr, bool *r_active)
+{
+       PTCacheEdit *edit= PE_get_current(scene, OBACT);
+       PTCacheUndo *undo;
+       
+       if (r_active) *r_active = false;
+       
+       if (edit) {
+               undo= BLI_findlink(&edit->undo, nr);
+               if (undo) {
+                       if (r_active && (undo == edit->curundo)) {
+                               *r_active = true;
+                       }
+                       return undo->name;
+               }
+       }
+       return NULL;
+}
diff --git a/source/blender/editors/physics/particle_edit_utildefines.h b/source/blender/editors/physics/particle_edit_utildefines.h
new file mode 100644 (file)
index 0000000..7608b88
--- /dev/null
@@ -0,0 +1,50 @@
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2007 by Janne Karhu.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/editors/physics/particle_edit_utildefines.h
+ *  \ingroup edphys
+ */
+
+#ifndef __PARTICLE_EDIT_UTILDEFNIES_H__
+#define __PARTICLE_EDIT_UTILDEFNIES_H__
+
+#define KEY_K                                  PTCacheEditKey *key; int k
+#define POINT_P                                        PTCacheEditPoint *point; int p
+#define LOOP_POINTS                            for (p=0, point=edit->points; p<edit->totpoint; p++, point++)
+#define LOOP_VISIBLE_POINTS            for (p=0, point=edit->points; p<edit->totpoint; p++, point++) if (!(point->flag & PEP_HIDE))
+#define LOOP_SELECTED_POINTS   for (p=0, point=edit->points; p<edit->totpoint; p++, point++) if (point_is_selected(point))
+#define LOOP_UNSELECTED_POINTS for (p=0, point=edit->points; p<edit->totpoint; p++, point++) if (!point_is_selected(point))
+#define LOOP_EDITED_POINTS             for (p=0, point=edit->points; p<edit->totpoint; p++, point++) if (point->flag & PEP_EDIT_RECALC)
+#define LOOP_TAGGED_POINTS             for (p=0, point=edit->points; p<edit->totpoint; p++, point++) if (point->flag & PEP_TAG)
+#define LOOP_KEYS                              for (k=0, key=point->keys; k<point->totkey; k++, key++)
+#define LOOP_VISIBLE_KEYS              for (k=0, key=point->keys; k<point->totkey; k++, key++) if (!(key->flag & PEK_HIDE))
+#define LOOP_SELECTED_KEYS             for (k=0, key=point->keys; k<point->totkey; k++, key++) if ((key->flag & PEK_SELECT) && !(key->flag & PEK_HIDE))
+#define LOOP_TAGGED_KEYS               for (k=0, key=point->keys; k<point->totkey; k++, key++) if (key->flag & PEK_TAG)
+
+#define KEY_WCO                                        ((key->flag & PEK_USE_WCO) ? key->world_co : key->co)
+
+#endif  /* __PARTICLE_EDIT_UTILDEFNIES_H__ */
index ce18083..b3e166a 100644 (file)
 
 #include "physics_intern.h"
 
-extern void PE_create_particle_edit(Scene *scene, Object *ob, PointCache *cache, ParticleSystem *psys);
-extern void PTCacheUndo_clear(PTCacheEdit *edit);
-extern void recalc_lengths(PTCacheEdit *edit);
-extern void recalc_emitter_field(Object *ob, ParticleSystem *psys);
-extern void update_world_cos(Object *ob, PTCacheEdit *edit);
-
 #define KEY_K                                  PTCacheEditKey *key; int k
 #define POINT_P                                        PTCacheEditPoint *point; int p
 #define LOOP_POINTS                            for (p=0, point=edit->points; p<edit->totpoint; p++, point++)
index 6b6df15..cb28193 100644 (file)
 #ifndef __PHYSICS_INTERN_H__
 #define __PHYSICS_INTERN_H__
 
+struct Object;
+struct PTCacheEdit;
+struct ParticleSystem;
+struct PointCache;
+struct Scene;
 struct wmOperatorType;
 
 /* particle_edit.c */
@@ -63,6 +68,12 @@ void PARTICLE_OT_edited_clear(struct wmOperatorType *ot);
 
 void PARTICLE_OT_unify_length(struct wmOperatorType *ot);
 
+void PTCacheUndo_clear(struct PTCacheEdit *edit);
+void PE_create_particle_edit(struct Scene *scene, struct Object *ob, struct PointCache *cache, struct ParticleSystem *psys);
+void recalc_lengths(struct PTCacheEdit *edit);
+void recalc_emitter_field(struct Object *ob, struct ParticleSystem *psys);
+void update_world_cos(struct Object *ob, struct PTCacheEdit *edit);
+
 /* particle_object.c */
 void OBJECT_OT_particle_system_add(struct wmOperatorType *ot);
 void OBJECT_OT_particle_system_remove(struct wmOperatorType *ot);