GO: replace if-else-if by switch
[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     switch (property)
90     {
91         case NUM_VERTICES :
92             return setNumVertices(*((unsigned int const*) value));
93         case NUM_INDICES :
94             return setNumIndices(*((unsigned int const*) value));
95         case X_COORDINATES :
96             setDataX((double const*) value, numElements);
97             break;
98         case Y_COORDINATES :
99             setDataY((double const*) value, numElements);
100             break;
101         case Z_COORDINATES :
102             setDataZ((double const*) value, numElements);
103             break;
104         case COORDINATES :
105             setVertices((double const*) value, numElements);
106             break;
107         case INDICES :
108             setIndices((unsigned int const*) value, numElements);
109             break;
110         case VALUES :
111             setValues((double const*) value, numElements);
112             break;
113         default :
114             return Data3D::setDataProperty(property, value, numElements);
115     }
116
117     return 1;
118 }
119
120 void TriangleMeshData::getDataProperty(int property, void **_pvData)
121 {
122     switch (property)
123     {
124         case NUM_VERTICES :
125             ((int *)*_pvData)[0] = getNumVertices();
126             break;
127         case NUM_INDICES :
128             ((int *)*_pvData)[0] = getNumIndices();
129             break;
130         case COORDINATES :
131             *_pvData = getVertices();
132             break;
133         case INDICES :
134             *_pvData = getIndices();
135             break;
136         case VALUES :
137             *_pvData = getValues();
138             break;
139         default :
140             Data3D::getDataProperty(property, _pvData);
141     }
142 }
143
144 unsigned int TriangleMeshData::getNumVertices(void)
145 {
146     return numberVertices;
147 }
148
149 /*
150  * Values are considered as being specified per-vertex for now
151  * To be corrected
152  */
153 int TriangleMeshData::setNumVertices(unsigned int numVertices)
154 {
155     int result = 1;
156
157     if (numVertices == 0 && numberVertices > 0)
158     {
159         numberVertices = 0;
160
161         delete [] vertices;
162         delete [] values;
163
164         return 1;
165     }
166
167     if (numVertices != this->numberVertices)
168     {
169         double* newVertices = NULL;
170         double* newValues = NULL;
171
172         try
173         {
174             newVertices = new double[3 * numVertices];
175         }
176         catch (const std::exception& e)
177         {
178             e.what();
179             result = 0;
180         }
181
182         try
183         {
184             newValues = new double[numVertices];
185         }
186         catch (const std::exception& e)
187         {
188             e.what();
189             result = 0;
190         }
191
192         if (result)
193         {
194             if (this->numberVertices > 0)
195             {
196                 delete [] vertices;
197                 delete [] values;
198             }
199
200             vertices = newVertices;
201             values = newValues;
202
203             this->numberVertices =  numVertices;
204
205             resetCoordinates();
206         }
207         else
208         {
209             /* Failed allocation, nothing is set */
210             if (newVertices != NULL)
211             {
212                 delete [] newVertices;
213             }
214
215             if (newValues != NULL)
216             {
217                 delete [] newValues;
218             }
219         }
220
221     }
222
223     return result;
224 }
225
226 unsigned int TriangleMeshData::getNumIndices(void)
227 {
228     return numberTriangles;
229 }
230
231 int TriangleMeshData::setNumIndices(unsigned int numIndices)
232 {
233     int result = 1;
234
235     if (numIndices != this->numberTriangles)
236     {
237         unsigned int* newIndices = NULL;
238
239         try
240         {
241             newIndices = new unsigned int[3 * numIndices];
242         }
243         catch (const std::exception& e)
244         {
245             e.what();
246             result = 0;
247         }
248
249         if (result)
250         {
251             if (this->numberTriangles > 0)
252             {
253                 delete [] indices;
254             }
255
256             indices = newIndices;
257
258             this->numberTriangles =  numIndices;
259         }
260         else
261         {
262             /* Failed allocation, nothing is set */
263             if (newIndices != NULL)
264             {
265                 delete [] newIndices;
266             }
267         }
268
269     }
270
271     return result;
272 }
273
274 double* TriangleMeshData::getVertices(void)
275 {
276     return vertices;
277 }
278
279 void TriangleMeshData::setVertices(double const* vertices, unsigned int numElements)
280 {
281     if (numElements <= numberVertices)
282     {
283         memcpy(this->vertices, vertices, numElements * 3 * sizeof(double));
284     }
285 }
286
287 unsigned int* TriangleMeshData::getIndices(void)
288 {
289     return indices;
290 }
291
292 void TriangleMeshData::setIndices(unsigned int const* indices, unsigned int numElements)
293 {
294     if (numElements <= numberTriangles)
295     {
296         memcpy(this->indices, indices, numElements * 3 * sizeof(unsigned int));
297     }
298 }
299
300 void TriangleMeshData::setDataX(double const* data, unsigned int numElements)
301 {
302     if (numElements <= numberVertices)
303     {
304         for (unsigned int i = 0 ; i < numElements ; i++)
305         {
306             vertices[3 * i] = data[i];
307         }
308     }
309 }
310
311 void TriangleMeshData::setDataY(double const* data, unsigned int numElements)
312 {
313     if (numElements <= numberVertices)
314     {
315         for (unsigned int i = 0 ; i < numElements ; i++)
316         {
317             vertices[3 * i + 1] = data[i];
318         }
319     }
320 }
321
322 void TriangleMeshData::setDataZ(double const* data, unsigned int numElements)
323 {
324     if (numElements <= numberVertices)
325     {
326         for (unsigned int i = 0; i < numElements; i++)
327         {
328             vertices[3 * i + 2] = data[i];
329         }
330     }
331 }
332
333 void TriangleMeshData::setValues(double const* data, unsigned int numElements)
334 {
335     if (numElements <= numberVertices)
336     {
337         memcpy(this->values, data, numElements * sizeof(double));
338     }
339 }
340
341 double* TriangleMeshData::getValues(void)
342 {
343     return values;
344 }
345
346 unsigned int TriangleMeshData::scilabIndexToIndex(unsigned int scilabIndex)
347 {
348     return (scilabIndex - 1);
349 }
350
351 void TriangleMeshData::resetCoordinates(void)
352 {
353     for (unsigned int i = 0; i < numberVertices; i++)
354     {
355         vertices[3 * i] = 0.0;
356         vertices[3 * i + 1] = 0.0;
357         vertices[3 * i + 2] = 0.0;
358     }
359 }
360