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