00a53b3f16e5f9909e15404e4aedfc35ecf5218d
[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         MB_POINT start;                         /* start point on surface */
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, 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 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 struct Object *find_basis_mball( struct Object *ob);
168 int is_basis_mball(struct Object *ob);
169 void metaball_polygonize(struct Object *ob);
170 void calc_mballco(struct MetaElem *ml, float *vec);
171 float densfunc(struct MetaElem *ball, float x, float y, float z);
172 float metaball(float x, float y, float z);
173 void accum_mballfaces(int i1, int i2, int i3, int i4);
174 void *new_pgn_element(int size);
175 int nextcwedge (int edge, int face);
176 void BKE_freecubetable(void);
177
178 #endif
179