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