Bug fix of #10999. mbproc->start was useless.
[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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, 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 MetaElem;
37
38 typedef struct point {                  /* a three-dimensional point */
39         float x, y, z;                          /* its coordinates */
40 } MB_POINT;
41
42 typedef struct vertex {                 /* surface vertex */
43         MB_POINT position, normal;              /* position and surface normal */
44 } VERTEX;
45
46 typedef struct vertices {               /* list of vertices in polygonization */
47         int count, max;                         /* # vertices, max # allowed */
48         VERTEX *ptr;                            /* dynamically allocated */
49 } VERTICES;
50
51 typedef struct corner {                 /* corner of a cube */
52         int i, j, k;                            /* (i, j, k) is index within lattice */
53         float x, y, z, value;           /* location and function value */
54         struct corner *next;
55 } CORNER;
56
57 typedef struct cube {                   /* partitioning cell (cube) */
58         int i, j, k;                            /* lattice location of cube */
59         CORNER *corners[8];                     /* eight corners */
60 } CUBE;
61
62 typedef struct cubes {                  /* linked list of cubes acting as stack */
63         CUBE cube;                                      /* a single cube */
64         struct cubes *next;                     /* remaining elements */
65 } CUBES;
66
67 typedef struct centerlist {             /* list of cube locations */
68         int i, j, k;                            /* cube location */
69         struct centerlist *next;        /* remaining elements */
70 } CENTERLIST;
71
72 typedef struct edgelist {               /* list of edges */
73         int i1, j1, k1, i2, j2, k2;     /* edge corner ids */
74         int vid;                                        /* vertex id */
75         struct edgelist *next;          /* remaining elements */
76 } EDGELIST;
77
78 typedef struct intlist {                /* list of integers */
79         int i;                                          /* an integer */
80         struct intlist *next;           /* remaining elements */
81 } INTLIST;
82
83 typedef struct intlists {               /* list of list of integers */
84         INTLIST *list;                          /* a list of integers */
85         struct intlists *next;          /* remaining elements */
86 } INTLISTS;
87
88 typedef struct process {                /* parameters, function, storage */
89         /* what happens here? floats, I think. */
90         /*  float (*function)(void);     */     /* implicit surface function */
91         float (*function)(float, float, float);
92         float size, delta;                      /* cube size, normal delta */
93         int bounds;                                     /* cube range within lattice */
94         CUBES *cubes;                           /* active cubes */
95         VERTICES vertices;                      /* surface vertices */
96         CENTERLIST **centers;           /* cube center hash table */
97         CORNER **corners;                       /* corner value hash table */
98         EDGELIST **edges;                       /* edge and vertex id hash table */
99 } PROCESS;
100
101 /* dividing scene using octal tree makes polygonisation faster */
102 typedef struct ml_pointer {
103         struct ml_pointer *next, *prev;
104         struct MetaElem *ml;
105 } ml_pointer;
106
107 typedef struct octal_node {
108         struct octal_node *nodes[8];    /* children of current node */
109         struct octal_node *parent;      /* parent of current node */
110         struct ListBase elems;          /* ListBase of MetaElem pointers (ml_pointer) */
111         float x_min, y_min, z_min;      /* 1st border point */
112         float x_max, y_max, z_max;      /* 7th border point */
113         float x,y,z;                    /* center of node */
114         int pos, neg;                   /* number of positive and negative MetaElements in the node */
115         int count;                      /* number of MetaElems, which belongs to the node */
116 } octal_node;
117
118 typedef struct octal_tree {
119         struct octal_node *first;       /* first node */
120         int pos, neg;                   /* number of positive and negative MetaElements in the scene */
121         short depth;                    /* number of scene subdivision */
122 } octal_tree;
123
124 struct pgn_elements {
125         struct pgn_elements *next, *prev;
126         char *data;
127 };
128
129 void calc_mballco(struct MetaElem *ml, float *vec);
130 float densfunc(struct MetaElem *ball, float x, float y, float z);
131 octal_node* find_metaball_octal_node(octal_node *node, float x, float y, float z, short depth);
132 float metaball(float x, float y, float z);
133 void accum_mballfaces(int i1, int i2, int i3, int i4);
134 void *new_pgn_element(int size);
135
136 void freepolygonize(PROCESS *p);
137 void docube(CUBE *cube, PROCESS *p, struct MetaBall *mb);
138 void testface(int i, int j, int k, CUBE* old, int bit, int c1, int c2, int c3, int c4, PROCESS *p);
139 CORNER *setcorner (PROCESS* p, int i, int j, int k);
140 int vertid (CORNER *c1, CORNER *c2, PROCESS *p, struct MetaBall *mb);
141 int setcenter(CENTERLIST *table[], int i, int j, int k);
142 int otherface (int edge, int face);
143 void makecubetable (void);
144 void setedge (EDGELIST *table[], int i1, int j1, int k1, int i2, int j2, int k2, int vid);
145 int getedge (EDGELIST *table[], int i1, int j1, int k1, int i2, int j2, int k2);
146 void addtovertices (VERTICES *vertices, VERTEX v);
147 void vnormal (MB_POINT *point, PROCESS *p, MB_POINT *v);
148 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);
149 void add_cube(PROCESS *mbproc, int i, int j, int k, int count);
150 void find_first_points(PROCESS *mbproc, struct MetaBall *mb, int a);
151
152 void fill_metaball_octal_node(octal_node *node, struct MetaElem *ml, short i);
153 void subdivide_metaball_octal_node(octal_node *node, float *size, short depth);
154 void free_metaball_octal_node(octal_node *node);
155 void init_metaball_octal_tree(int depth);
156 void polygonize(PROCESS *mbproc, struct MetaBall *mb);
157 float init_meta(struct Object *ob);
158
159 void unlink_mball(struct MetaBall *mb);
160 void free_mball(struct MetaBall *mb);
161 struct MetaBall *add_mball(char *name);
162 struct MetaBall *copy_mball(struct MetaBall *mb);
163 void make_local_mball(struct MetaBall *mb);
164 void tex_space_mball(struct Object *ob);
165 float *make_orco_mball(struct Object *ob);
166 struct Object *find_basis_mball( struct Object *ob);
167 int is_basis_mball(struct Object *ob);
168 void metaball_polygonize(struct Object *ob);
169 void calc_mballco(struct MetaElem *ml, float *vec);
170 float densfunc(struct MetaElem *ball, float x, float y, float z);
171 float metaball(float x, float y, float z);
172 void accum_mballfaces(int i1, int i2, int i3, int i4);
173 void *new_pgn_element(int size);
174 int nextcwedge (int edge, int face);
175 void BKE_freecubetable(void);
176
177 #endif
178