Bugfix [#27157] keyframing a constrained bone does not work as before
[blender.git] / source / blender / blenkernel / intern / booleanops_mesh.c
1 #if 0
2
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
32 /** \file blender/blenkernel/intern/booleanops_mesh.c
33  *  \ingroup bke
34  */
35
36 #include "CSG_BooleanOps.h"
37
38
39
40
41
42 /**
43  * Implementation of boolean ops mesh interface.
44  */
45
46         void
47 CSG_DestroyMeshDescriptor(
48         CSG_MeshDescriptor *mesh
49 ){
50         // Call mesh descriptors destroy function....
51         mesh->m_destroy_func(mesh);
52 }
53         
54 // Destroy function for blender mesh internals.
55
56 static
57         void
58 CSG_DestroyBlenderMeshInternals(
59         CSG_MeshDescriptor *mesh
60 ) {
61         // Free face and vertex iterators.
62         FreeMeshDescriptors(&(mesh->m_face_iterator),&(mesh->m_vertex_iterator));               
63 }
64
65
66 static
67         void
68 CSG_DestroyCSGMeshInternals(
69         CSG_MeshDescriptor *mesh
70 ){
71         CSG_FreeVertexDescriptor(&(mesh->m_vertex_iterator));
72         CSG_FreeFaceDescriptor(&(mesh->m_face_iterator));
73 }
74
75 static
76         int
77 MakeCSGMeshFromBlenderBase(
78         Base * base,
79         CSG_MeshDescriptor * output
80 ) {
81         Mesh *me;
82         if (output == NULL || base == NULL) return 0;
83
84         me = get_mesh(base->object);
85                 
86         output->m_descriptor.user_face_vertex_data_size = 0;
87         output->m_descriptor.user_data_size = sizeof(FaceData);
88
89         output->base = base;
90         
91         BuildMeshDescriptors(
92                 base->object,
93                 &(output->m_face_iterator),
94                 &(output->m_vertex_iterator)
95         );
96
97         output->m_destroy_func = CSG_DestroyBlenderMeshInternals;
98
99         return 1;
100 }       
101
102         int
103 CSG_LoadBlenderMesh(
104         Object * obj,
105         CSG_MeshDescriptor *output
106 ){
107
108         Mesh *me;
109         if (output == NULL || obj == NULL) return 0;
110
111         me = get_mesh(obj);
112                 
113         output->m_descriptor.user_face_vertex_data_size = 0;
114         output->m_descriptor.user_data_size = sizeof(FaceData);
115
116         output->base = NULL;
117         
118         BuildMeshDescriptors(
119                 obj,
120                 &(output->m_face_iterator),
121                 &(output->m_vertex_iterator)
122         );
123
124         output->m_destroy_func = CSG_DestroyBlenderMeshInternals;
125         output->base = NULL;
126
127         return 1;
128 }
129         
130
131
132
133         int
134 CSG_AddMeshToBlender(
135         CSG_MeshDescriptor *mesh
136 ){
137         Mesh *me_new = NULL;
138         Object *ob_new = NULL;
139         float inv_mat[4][4];
140
141         if (mesh == NULL) return 0;
142         if (mesh->base == NULL) return 0;
143
144         invert_m4_m4(inv_mat,mesh->base->object->obmat);
145
146         // Create a new blender mesh object - using 'base' as 
147         // a template for the new object.
148         ob_new=  AddNewBlenderMesh(mesh->base);
149
150         me_new = ob_new->data;
151
152         // make sure the iterators are reset.
153         mesh->m_face_iterator.Reset(mesh->m_face_iterator.it);
154         mesh->m_vertex_iterator.Reset(mesh->m_vertex_iterator.it);
155
156         // iterate through results of operation and insert into new object
157         // see subsurf.c 
158
159         ConvertCSGDescriptorsToMeshObject(
160                 ob_new,
161                 &(mesh->m_descriptor),
162                 &(mesh->m_face_iterator),
163                 &(mesh->m_vertex_iterator),
164                 inv_mat
165         );
166
167         return 1;
168 }
169
170         int 
171 CSG_PerformOp(
172         CSG_MeshDescriptor *mesh1,
173         CSG_MeshDescriptor *mesh2,
174         int int_op_type,
175         CSG_MeshDescriptor *output
176 ){
177
178         CSG_OperationType op_type;
179         CSG_BooleanOperation * bool_op = CSG_NewBooleanFunction();
180         int success = 0;
181
182         if (bool_op == NULL) return 0;
183
184         if ((mesh1 == NULL) || (mesh2 == NULL) || (output == NULL)) {
185                 return 0;
186         }       
187         if ((int_op_type < 1) || (int_op_type > 3)) return 0;
188
189         switch (int_op_type) {
190                 case 1 : op_type = e_csg_intersection; break;
191                 case 2 : op_type = e_csg_union; break;
192                 case 3 : op_type = e_csg_difference; break;
193                 case 4 : op_type = e_csg_classify; break;
194                 default : op_type = e_csg_intersection;
195         }
196         
197         output->m_descriptor = CSG_DescibeOperands(bool_op,mesh1->m_descriptor,mesh2->m_descriptor);
198         output->base = mesh1->base;
199
200         if (output->m_descriptor.user_face_vertex_data_size) {
201                 // Then use the only interp function supported 
202                 success = 
203                 CSG_PerformBooleanOperation(
204                         bool_op,
205                         op_type,
206                         mesh1->m_face_iterator,
207                         mesh1->m_vertex_iterator,
208                         mesh2->m_face_iterator,
209                         mesh2->m_vertex_iterator,               
210                         InterpFaceVertexData    
211                 );
212         } else {
213                 success = 
214                 CSG_PerformBooleanOperation(
215                         bool_op,
216                         op_type,
217                         mesh1->m_face_iterator,
218                         mesh1->m_vertex_iterator,
219                         mesh2->m_face_iterator,
220                         mesh2->m_vertex_iterator,               
221                         InterpNoUserData        
222                 );
223         }
224
225         if (!success) {
226                 CSG_FreeBooleanOperation(bool_op);
227                 bool_op = NULL;
228                 return 0;
229         }
230                 
231         // get the ouput mesh descriptors.
232
233         CSG_OutputFaceDescriptor(bool_op,&(output->m_face_iterator));
234         CSG_OutputVertexDescriptor(bool_op,&(output->m_vertex_iterator));
235         output->m_destroy_func = CSG_DestroyCSGMeshInternals;
236
237         return 1;
238 }
239
240         int
241 NewBooleanMeshTest(
242         struct Base * base,
243         struct Base * base_select,
244         int op_type
245 ){
246
247         CSG_MeshDescriptor m1,m2,output;
248         CSG_MeshDescriptor output2,output3;
249         
250         if (!MakeCSGMeshFromBlenderBase(base,&m1)) {
251                 return 0;
252         }
253         
254         if (!MakeCSGMeshFromBlenderBase(base_select,&m2)) {
255                 return 0;
256         }
257         
258         CSG_PerformOp(&m1,&m2,1,&output);
259         CSG_PerformOp(&m1,&m2,2,&output2);
260         CSG_PerformOp(&m1,&m2,3,&output3);
261
262         if (!CSG_AddMeshToBlender(&output)) {
263                 return 0;
264         }
265         if (!CSG_AddMeshToBlender(&output2)) {
266                 return 0;
267         }
268         if (!CSG_AddMeshToBlender(&output3)) {
269                 return 0;
270         }
271
272         
273         CSG_DestroyMeshDescriptor(&m1);
274         CSG_DestroyMeshDescriptor(&m2);
275         CSG_DestroyMeshDescriptor(&output);
276         CSG_DestroyMeshDescriptor(&output2);
277         CSG_DestroyMeshDescriptor(&output3);
278
279         return 1;
280 }
281
282 #endif
283