RNA
[blender.git] / source / blender / makesrna / intern / rna_mesh_api.c
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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) 2009 Blender Foundation.
21  * All rights reserved.
22  *
23  * 
24  * Contributor(s): Blender Foundation
25  *
26  * ***** END GPL LICENSE BLOCK *****
27  */
28
29 #include <stdlib.h>
30 #include <stdio.h>
31
32 #include "RNA_define.h"
33 #include "RNA_types.h"
34
35 #ifdef RNA_RUNTIME
36
37 #include "DNA_mesh_types.h"
38 #include "DNA_scene_types.h"
39
40 #include "BKE_customdata.h"
41 #include "BKE_depsgraph.h"
42 #include "BKE_DerivedMesh.h"
43 #include "BKE_main.h"
44 #include "BKE_mesh.h"
45
46 #include "BLI_edgehash.h"
47
48 #include "WM_api.h"
49 #include "WM_types.h"
50
51 static void rna_Mesh_calc_edges(Mesh *mesh)
52 {
53         CustomData edata;
54         EdgeHashIterator *ehi;
55         MFace *mf = mesh->mface;
56         MEdge *med;
57         EdgeHash *eh = BLI_edgehash_new();
58         int i, *index, totedge, totface = mesh->totface;
59
60         for (i = 0; i < totface; i++, mf++) {
61                 if (!BLI_edgehash_haskey(eh, mf->v1, mf->v2))
62                         BLI_edgehash_insert(eh, mf->v1, mf->v2, NULL);
63                 if (!BLI_edgehash_haskey(eh, mf->v2, mf->v3))
64                         BLI_edgehash_insert(eh, mf->v2, mf->v3, NULL);
65                 
66                 if (mf->v4) {
67                         if (!BLI_edgehash_haskey(eh, mf->v3, mf->v4))
68                                 BLI_edgehash_insert(eh, mf->v3, mf->v4, NULL);
69                         if (!BLI_edgehash_haskey(eh, mf->v4, mf->v1))
70                                 BLI_edgehash_insert(eh, mf->v4, mf->v1, NULL);
71                 } else {
72                         if (!BLI_edgehash_haskey(eh, mf->v3, mf->v1))
73                                 BLI_edgehash_insert(eh, mf->v3, mf->v1, NULL);
74                 }
75         }
76
77         totedge = BLI_edgehash_size(eh);
78
79         /* write new edges into a temporary CustomData */
80         memset(&edata, 0, sizeof(edata));
81         CustomData_add_layer(&edata, CD_MEDGE, CD_CALLOC, NULL, totedge);
82
83         ehi = BLI_edgehashIterator_new(eh);
84         med = CustomData_get_layer(&edata, CD_MEDGE);
85         for(i = 0; !BLI_edgehashIterator_isDone(ehi);
86             BLI_edgehashIterator_step(ehi), ++i, ++med, ++index) {
87                 BLI_edgehashIterator_getKey(ehi, (int*)&med->v1, (int*)&med->v2);
88
89                 med->flag = ME_EDGEDRAW|ME_EDGERENDER;
90         }
91         BLI_edgehashIterator_free(ehi);
92
93         /* free old CustomData and assign new one */
94         CustomData_free(&mesh->edata, mesh->totedge);
95         mesh->edata = edata;
96         mesh->totedge = totedge;
97
98         mesh->medge = CustomData_get_layer(&mesh->edata, CD_MEDGE);
99
100         BLI_edgehash_free(eh, NULL);
101 }
102
103 static void rna_Mesh_update(Mesh *mesh, bContext *C)
104 {
105         Main *bmain= CTX_data_main(C);
106         Object *ob;
107
108         if(mesh->totface && mesh->totedge == 0)
109                 rna_Mesh_calc_edges(mesh);
110
111         mesh_calc_normals(mesh->mvert, mesh->totvert, mesh->mface, mesh->totface, NULL);
112
113         for(ob=bmain->object.first; ob; ob=ob->id.next) {
114                 if(ob->data == mesh) {
115                         ob->recalc |= OB_RECALC_DATA;
116                         WM_event_add_notifier(C, NC_OBJECT|ND_GEOM_DATA, ob);
117                 }
118         }
119 }
120
121 static void rna_Mesh_add_verts(Mesh *mesh, int len)
122 {
123         CustomData vdata;
124         MVert *mvert;
125         int i, totvert;
126
127         if(len == 0)
128                 return;
129
130         totvert= mesh->totvert + len;
131         CustomData_copy(&mesh->vdata, &vdata, CD_MASK_MESH, CD_DEFAULT, totvert);
132         CustomData_copy_data(&mesh->vdata, &vdata, 0, 0, mesh->totvert);
133
134         if(!CustomData_has_layer(&vdata, CD_MVERT))
135                 CustomData_add_layer(&vdata, CD_MVERT, CD_CALLOC, NULL, totvert);
136
137         CustomData_free(&mesh->vdata, mesh->totvert);
138         mesh->vdata= vdata;
139         mesh_update_customdata_pointers(mesh);
140
141         /* scan the input list and insert the new vertices */
142
143         mvert= &mesh->mvert[mesh->totvert];
144         for(i=0; i<len; i++, mvert++)
145                 mvert->flag |= SELECT;
146
147         /* set final vertex list size */
148         mesh->totvert= totvert;
149 }
150
151 static void rna_Mesh_add_edges(Mesh *mesh, int len)
152 {
153         CustomData edata;
154         MEdge *medge;
155         int i, totedge;
156
157         if(len == 0)
158                 return;
159
160         totedge= mesh->totedge+len;
161
162         /* update customdata  */
163         CustomData_copy(&mesh->edata, &edata, CD_MASK_MESH, CD_DEFAULT, totedge);
164         CustomData_copy_data(&mesh->edata, &edata, 0, 0, mesh->totedge);
165
166         if(!CustomData_has_layer(&edata, CD_MEDGE))
167                 CustomData_add_layer(&edata, CD_MEDGE, CD_CALLOC, NULL, totedge);
168
169         CustomData_free(&mesh->edata, mesh->totedge);
170         mesh->edata= edata;
171         mesh_update_customdata_pointers(mesh);
172
173         /* set default flags */
174         medge= &mesh->medge[mesh->totedge];
175         for(i=0; i<len; i++, medge++)
176                 medge->flag= ME_EDGEDRAW|ME_EDGERENDER|SELECT;
177
178         mesh->totedge= totedge;
179 }
180
181 static void rna_Mesh_add_faces(Mesh *mesh, int len)
182 {
183         CustomData fdata;
184         MFace *mface;
185         int i, totface;
186
187         if(len == 0)
188                 return;
189
190         totface= mesh->totface + len;   /* new face count */
191
192         /* update customdata */
193         CustomData_copy(&mesh->fdata, &fdata, CD_MASK_MESH, CD_DEFAULT, totface);
194         CustomData_copy_data(&mesh->fdata, &fdata, 0, 0, mesh->totface);
195
196         if(!CustomData_has_layer(&fdata, CD_MFACE))
197                 CustomData_add_layer(&fdata, CD_MFACE, CD_CALLOC, NULL, totface);
198
199         CustomData_free(&mesh->fdata, mesh->totface);
200         mesh->fdata= fdata;
201         mesh_update_customdata_pointers(mesh);
202
203         /* set default flags */
204         mface= &mesh->mface[mesh->totface];
205         for(i=0; i<len; i++, mface++)
206                 mface->flag= SELECT;
207
208         mesh->totface= totface;
209 }
210
211 static void rna_Mesh_add_geometry(Mesh *mesh, int verts, int edges, int faces)
212 {
213         if(verts)
214                 rna_Mesh_add_verts(mesh, verts);
215         if(edges)
216                 rna_Mesh_add_edges(mesh, edges);
217         if(faces)
218                 rna_Mesh_add_faces(mesh, faces);
219 }
220
221 #else
222
223 void RNA_api_mesh(StructRNA *srna)
224 {
225         FunctionRNA *func;
226         PropertyRNA *parm;
227
228         func= RNA_def_function(srna, "add_geometry", "rna_Mesh_add_geometry");
229         parm= RNA_def_int(func, "verts", 0, 0, INT_MAX, "Number", "Number of vertices to add.", 0, INT_MAX);
230         RNA_def_property_flag(parm, PROP_REQUIRED);
231         parm= RNA_def_int(func, "edges", 0, 0, INT_MAX, "Number", "Number of edges to add.", 0, INT_MAX);
232         RNA_def_property_flag(parm, PROP_REQUIRED);
233         parm= RNA_def_int(func, "faces", 0, 0, INT_MAX, "Number", "Number of faces to add.", 0, INT_MAX);
234         RNA_def_property_flag(parm, PROP_REQUIRED);
235
236         func= RNA_def_function(srna, "update", "rna_Mesh_update");
237         RNA_def_function_flag(func, FUNC_USE_CONTEXT);
238 }
239
240 #endif
241