copy animdata and id-props when copying material node tree's to avoid double memory...
[blender.git] / source / blender / blenkernel / BKE_mball.h
1 /**
2  * blenlib/BKE_mball.h (mar-2001 nzc)
3  *      
4  * $Id$ 
5  *
6  * ***** BEGIN GPL LICENSE BLOCK *****
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * as published by the Free Software Foundation; either version 2
11  * of the License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software Foundation,
20  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
21  *
22  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
23  * All rights reserved.
24  *
25  * The Original Code is: all of this file.
26  *
27  * Contributor(s): none yet.
28  *
29  * ***** END GPL LICENSE BLOCK *****
30  */
31 #ifndef BKE_MBALL_H
32 #define BKE_MBALL_H
33
34 struct MetaBall;
35 struct Object;
36 struct Scene;
37 struct MetaElem;
38
39 typedef struct point {                  /* a three-dimensional point */
40         float x, y, z;                          /* its coordinates */
41 } MB_POINT;
42
43 typedef struct vertex {                 /* surface vertex */
44         MB_POINT position, normal;              /* position and surface normal */
45 } VERTEX;
46
47 typedef struct vertices {               /* list of vertices in polygonization */
48         int count, max;                         /* # vertices, max # allowed */
49         VERTEX *ptr;                            /* dynamically allocated */
50 } VERTICES;
51
52 typedef struct corner {                 /* corner of a cube */
53         int i, j, k;                            /* (i, j, k) is index within lattice */
54         float x, y, z, value;           /* location and function value */
55         struct corner *next;
56 } CORNER;
57
58 typedef struct cube {                   /* partitioning cell (cube) */
59         int i, j, k;                            /* lattice location of cube */
60         CORNER *corners[8];                     /* eight corners */
61 } CUBE;
62
63 typedef struct cubes {                  /* linked list of cubes acting as stack */
64         CUBE cube;                                      /* a single cube */
65         struct cubes *next;                     /* remaining elements */
66 } CUBES;
67
68 typedef struct centerlist {             /* list of cube locations */
69         int i, j, k;                            /* cube location */
70         struct centerlist *next;        /* remaining elements */
71 } CENTERLIST;
72
73 typedef struct edgelist {               /* list of edges */
74         int i1, j1, k1, i2, j2, k2;     /* edge corner ids */
75         int vid;                                        /* vertex id */
76         struct edgelist *next;          /* remaining elements */
77 } EDGELIST;
78
79 typedef struct intlist {                /* list of integers */
80         int i;                                          /* an integer */
81         struct intlist *next;           /* remaining elements */
82 } INTLIST;
83
84 typedef struct intlists {               /* list of list of integers */
85         INTLIST *list;                          /* a list of integers */
86         struct intlists *next;          /* remaining elements */
87 } INTLISTS;
88
89 typedef struct process {                /* parameters, function, storage */
90         /* what happens here? floats, I think. */
91         /*  float (*function)(void);     */     /* implicit surface function */
92         float (*function)(float, float, float);
93         float size, delta;                      /* cube size, normal delta */
94         int bounds;                                     /* cube range within lattice */
95         CUBES *cubes;                           /* active cubes */
96         VERTICES vertices;                      /* surface vertices */
97         CENTERLIST **centers;           /* cube center hash table */
98         CORNER **corners;                       /* corner value hash table */
99         EDGELIST **edges;                       /* edge and vertex id hash table */
100 } PROCESS;
101
102 /* dividing scene using octal tree makes polygonisation faster */
103 typedef struct ml_pointer {
104         struct ml_pointer *next, *prev;
105         struct MetaElem *ml;
106 } ml_pointer;
107
108 typedef struct octal_node {
109         struct octal_node *nodes[8];    /* children of current node */
110         struct octal_node *parent;      /* parent of current node */
111         struct ListBase elems;          /* ListBase of MetaElem pointers (ml_pointer) */
112         float x_min, y_min, z_min;      /* 1st border point */
113         float x_max, y_max, z_max;      /* 7th border point */
114         float x,y,z;                    /* center of node */
115         int pos, neg;                   /* number of positive and negative MetaElements in the node */
116         int count;                      /* number of MetaElems, which belongs to the node */
117 } octal_node;
118
119 typedef struct octal_tree {
120         struct octal_node *first;       /* first node */
121         int pos, neg;                   /* number of positive and negative MetaElements in the scene */
122         short depth;                    /* number of scene subdivision */
123 } octal_tree;
124
125 struct pgn_elements {
126         struct pgn_elements *next, *prev;
127         char *data;
128 };
129
130 void calc_mballco(struct MetaElem *ml, float *vec);
131 float densfunc(struct MetaElem *ball, float x, float y, float z);
132 octal_node* find_metaball_octal_node(octal_node *node, float x, float y, float z, short depth);
133 float metaball(float x, float y, float z);
134 void accum_mballfaces(int i1, int i2, int i3, int i4);
135 void *new_pgn_element(int size);
136
137 void freepolygonize(PROCESS *p);
138 void docube(CUBE *cube, PROCESS *p, struct MetaBall *mb);
139 void testface(int i, int j, int k, CUBE* old, int bit, int c1, int c2, int c3, int c4, PROCESS *p);
140 CORNER *setcorner (PROCESS* p, int i, int j, int k);
141 int vertid (CORNER *c1, CORNER *c2, PROCESS *p, struct MetaBall *mb);
142 int setcenter(CENTERLIST *table[], int i, int j, int k);
143 int otherface (int edge, int face);
144 void makecubetable (void);
145 void setedge (EDGELIST *table[], int i1, int j1, int k1, int i2, int j2, int k2, int vid);
146 int getedge (EDGELIST *table[], int i1, int j1, int k1, int i2, int j2, int k2);
147 void addtovertices (VERTICES *vertices, VERTEX v);
148 void vnormal (MB_POINT *point, PROCESS *p, MB_POINT *v);
149 void converge (MB_POINT *p1, MB_POINT *p2, float v1, float v2, float (*function)(float, float, float), MB_POINT *p, struct MetaBall *mb, int f);
150 void add_cube(PROCESS *mbproc, int i, int j, int k, int count);
151 void find_first_points(PROCESS *mbproc, struct MetaBall *mb, int a);
152
153 void fill_metaball_octal_node(octal_node *node, struct MetaElem *ml, short i);
154 void subdivide_metaball_octal_node(octal_node *node, float size_x, float size_y, float size_z, short depth);
155 void free_metaball_octal_node(octal_node *node);
156 void init_metaball_octal_tree(int depth);
157 void polygonize(PROCESS *mbproc, struct MetaBall *mb);
158 float init_meta(struct Scene *scene, struct Object *ob);
159
160 void unlink_mball(struct MetaBall *mb);
161 void free_mball(struct MetaBall *mb);
162 struct MetaBall *add_mball(char *name);
163 struct MetaBall *copy_mball(struct MetaBall *mb);
164 void make_local_mball(struct MetaBall *mb);
165 void tex_space_mball(struct Object *ob);
166 float *make_orco_mball(struct Object *ob);
167 void copy_mball_properties(struct Scene *scene, struct Object *active_object);
168 struct Object *find_basis_mball(struct Scene *scene, struct Object *ob);
169 int is_basis_mball(struct Object *ob);
170 void metaball_polygonize(struct Scene *scene, struct Object *ob);
171 void calc_mballco(struct MetaElem *ml, float *vec);
172 float densfunc(struct MetaElem *ball, float x, float y, float z);
173 float metaball(float x, float y, float z);
174 void accum_mballfaces(int i1, int i2, int i3, int i4);
175 void *new_pgn_element(int size);
176 int nextcwedge (int edge, int face);
177 void BKE_freecubetable(void);
178
179 #endif
180