87ed951b48a27392ec3f0ef2e71ab66f941768c4
[scilab.git] / scilab / modules / graphic_objects / src / cpp / TriangleMeshData.cpp
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2010 - DIGITEO - Manuel Juliachs
4  *
5  *  This file must be used under the terms of the CeCILL.
6  *  This source file is licensed as described in the file COPYING, which
7  *  you should have received as part of this distribution.  The terms
8  *  are also available at
9  *  http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
10  *
11  */
12
13 #include "TriangleMeshData.hxx"
14 #include "DataProperties.hxx"
15
16 extern "C" {
17 #include <string.h>
18 #include "BOOL.h"
19
20 #include "graphicObjectProperties.h"
21 }
22
23 TriangleMeshData::TriangleMeshData(void)
24 {
25     vertices = NULL;
26     indices = NULL;
27     values = NULL;
28
29     numberVertices = 0;
30     numberTriangles = 0;
31 }
32
33 /* To be correctly implemented */
34 TriangleMeshData::TriangleMeshData(unsigned int numberVertices, unsigned int numberTriangles)
35 {
36     vertices = new double[3 * numberVertices];
37
38     indices = new unsigned int[3 * numberTriangles];
39
40     this->numberVertices = numberVertices;
41     this->numberTriangles = numberTriangles;
42 }
43
44 /* To be correctly implemented */
45 TriangleMeshData::~TriangleMeshData(void)
46 {
47     if (numberVertices > 0)
48     {
49         delete [] vertices;
50         delete [] values;
51     }
52
53     if (numberTriangles > 0)
54     {
55         delete [] indices;
56     }
57
58 }
59
60 int TriangleMeshData::getPropertyFromName(int propertyName)
61 {
62     switch (propertyName)
63     {
64         case __GO_DATA_MODEL_NUM_VERTICES__ :
65             return NUM_VERTICES;
66         case __GO_DATA_MODEL_NUM_INDICES__ :
67             return NUM_INDICES;
68         case __GO_DATA_MODEL_X__ :
69             return X_COORDINATES;
70         case __GO_DATA_MODEL_Y__ :
71             return Y_COORDINATES;
72         case __GO_DATA_MODEL_Z__ :
73             return Z_COORDINATES;
74         case __GO_DATA_MODEL_COORDINATES__ :
75             return COORDINATES;
76         case __GO_DATA_MODEL_INDICES__ :
77             return INDICES;
78         case __GO_DATA_MODEL_VALUES__ :
79             return VALUES;
80         default :
81             return Data3D::getPropertyFromName(propertyName);
82     }
83
84 }
85
86
87 int TriangleMeshData::setDataProperty(int property, void const* value, int numElements)
88 {
89     if (property == NUM_VERTICES)
90     {
91         return setNumVertices(*((unsigned int const*) value));
92     }
93     else if (property == NUM_INDICES)
94     {
95         return setNumIndices(*((unsigned int const*) value));
96     }
97     else if (property == X_COORDINATES)
98     {
99         setDataX((double const*) value, numElements);
100     }
101     else if (property == Y_COORDINATES)
102     {
103         setDataY((double const*) value, numElements);
104     }
105     else if (property == Z_COORDINATES)
106     {
107         setDataZ((double const*) value, numElements);
108     }
109     else if (property == COORDINATES)
110     {
111         setVertices((double const*) value, numElements);
112     }
113     else if (property == INDICES)
114     {
115         setIndices((unsigned int const*) value, numElements);
116     }
117     else if (property == VALUES)
118     {
119         setValues((double const*) value, numElements);
120     }
121     else
122     {
123         return Data3D::setDataProperty(property, value, numElements);
124     }
125
126     return 1;
127 }
128
129 void TriangleMeshData::getDataProperty(int property, void **_pvData)
130 {
131     if (property == NUM_VERTICES)
132     {
133         ((int *)*_pvData)[0] = getNumVertices();
134     }
135     else if (property == NUM_INDICES)
136     {
137         ((int *)*_pvData)[0] = getNumIndices();
138     }
139     else if (property == COORDINATES)
140     {
141         *_pvData = getVertices();
142     }
143     else if (property == INDICES)
144     {
145         *_pvData = getIndices();
146     }
147     else if (property == VALUES)
148     {
149         *_pvData = getValues();
150     }
151     else
152     {
153         Data3D::getDataProperty(property, _pvData);
154     }
155 }
156
157 unsigned int TriangleMeshData::getNumVertices(void)
158 {
159     return numberVertices;
160 }
161
162 /*
163  * Values are considered as being specified per-vertex for now
164  * To be corrected
165  */
166 int TriangleMeshData::setNumVertices(unsigned int numVertices)
167 {
168     int result = 1;
169
170     if (numVertices == 0 && numberVertices > 0)
171     {
172         numberVertices = 0;
173
174         delete [] vertices;
175         delete [] values;
176
177         return 1;
178     }
179
180     if (numVertices != this->numberVertices)
181     {
182         double* newVertices = NULL;
183         double* newValues = NULL;
184
185         try
186         {
187             newVertices = new double[3 * numVertices];
188         }
189         catch (const std::exception& e)
190         {
191             e.what();
192             result = 0;
193         }
194
195         try
196         {
197             newValues = new double[numVertices];
198         }
199         catch (const std::exception& e)
200         {
201             e.what();
202             result = 0;
203         }
204
205         if (result)
206         {
207             if (this->numberVertices > 0)
208             {
209                 delete [] vertices;
210                 delete [] values;
211             }
212
213             vertices = newVertices;
214             values = newValues;
215
216             this->numberVertices =  numVertices;
217
218             resetCoordinates();
219         }
220         else
221         {
222             /* Failed allocation, nothing is set */
223             if (newVertices != NULL)
224             {
225                 delete [] newVertices;
226             }
227
228             if (newValues != NULL)
229             {
230                 delete [] newValues;
231             }
232         }
233
234     }
235
236     return result;
237 }
238
239 unsigned int TriangleMeshData::getNumIndices(void)
240 {
241     return numberTriangles;
242 }
243
244 int TriangleMeshData::setNumIndices(unsigned int numIndices)
245 {
246     int result = 1;
247
248     if (numIndices != this->numberTriangles)
249     {
250         unsigned int* newIndices = NULL;
251
252         try
253         {
254             newIndices = new unsigned int[3 * numIndices];
255         }
256         catch (const std::exception& e)
257         {
258             e.what();
259             result = 0;
260         }
261
262         if (result)
263         {
264             if (this->numberTriangles > 0)
265             {
266                 delete [] indices;
267             }
268
269             indices = newIndices;
270
271             this->numberTriangles =  numIndices;
272         }
273         else
274         {
275             /* Failed allocation, nothing is set */
276             if (newIndices != NULL)
277             {
278                 delete [] newIndices;
279             }
280         }
281
282     }
283
284     return result;
285 }
286
287 double* TriangleMeshData::getVertices(void)
288 {
289     return vertices;
290 }
291
292 void TriangleMeshData::setVertices(double const* vertices, unsigned int numElements)
293 {
294     if (numElements <= numberVertices)
295     {
296         memcpy(this->vertices, vertices, numElements * 3 * sizeof(double));
297     }
298 }
299
300 unsigned int* TriangleMeshData::getIndices(void)
301 {
302     return indices;
303 }
304
305 void TriangleMeshData::setIndices(unsigned int const* indices, unsigned int numElements)
306 {
307     if (numElements <= numberTriangles)
308     {
309         memcpy(this->indices, indices, numElements * 3 * sizeof(unsigned int));
310     }
311 }
312
313 void TriangleMeshData::setDataX(double const* data, unsigned int numElements)
314 {
315     if (numElements <= numberVertices)
316     {
317         for (unsigned int i = 0 ; i < numElements ; i++)
318         {
319             vertices[3 * i] = data[i];
320         }
321     }
322 }
323
324 void TriangleMeshData::setDataY(double const* data, unsigned int numElements)
325 {
326     if (numElements <= numberVertices)
327     {
328         for (unsigned int i = 0 ; i < numElements ; i++)
329         {
330             vertices[3 * i + 1] = data[i];
331         }
332     }
333 }
334
335 void TriangleMeshData::setDataZ(double const* data, unsigned int numElements)
336 {
337     if (numElements <= numberVertices)
338     {
339         for (unsigned int i = 0; i < numElements; i++)
340         {
341             vertices[3 * i + 2] = data[i];
342         }
343     }
344 }
345
346 void TriangleMeshData::setValues(double const* data, unsigned int numElements)
347 {
348     if (numElements <= numberVertices)
349     {
350         memcpy(this->values, data, numElements * sizeof(double));
351     }
352 }
353
354 double* TriangleMeshData::getValues(void)
355 {
356     return values;
357 }
358
359 unsigned int TriangleMeshData::scilabIndexToIndex(unsigned int scilabIndex)
360 {
361     return (scilabIndex - 1);
362 }
363
364 void TriangleMeshData::resetCoordinates(void)
365 {
366     for (unsigned int i = 0; i < numberVertices; i++)
367     {
368         vertices[3 * i] = 0.0;
369         vertices[3 * i + 1] = 0.0;
370         vertices[3 * i + 2] = 0.0;
371     }
372 }
373