~ubuntu-branches/debian/sid/gnome-chess/sid

« back to all changes in this revision

Viewing changes to src/3ds.c

  • Committer: Package Import Robot
  • Author(s): Luca Falavigna, Jeremy Bicha, Jackson Doak, Luca Falavigna
  • Date: 2014-07-15 21:50:20 UTC
  • mfrom: (1.1.5)
  • Revision ID: package-import@ubuntu.com-20140715215020-rhk7hmpjf5xlntb9
Tags: 1:3.12.3-1
* Team upload.

[ Jeremy Bicha ]
* debian/control.in:
  - Depend on hoichess and demote other chess engines to Suggests
    per upstream recommendation (LP: #138570)
  - Bump minimum intoltool and vala
  - Drop sqlite dependency
* debian/gnome-chess.install:
  - AI configuration file moved to /etc/chess-engines.conf

[ Jackson Doak ]
* New upstream release (3.12.3)

[ Luca Falavigna ]
* debian/control.in:
  - Bump Standards-Version to 3.9.5.
  - Refresh build-dependencies required minimum versions.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/* 3ds.c generated by valac 0.18.1, the Vala compiler
 
1
/* 3ds.c generated by valac 0.24.0.112-bbf5, the Vala compiler
2
2
 * generated from 3ds.vala, do not modify */
3
3
 
 
4
/* -*- Mode: vala; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 
5
 *
 
6
 * Copyright (C) 2010-2013 Robert Ancell
 
7
 *
 
8
 * This program is free software: you can redistribute it and/or modify it under
 
9
 * the terms of the GNU General Public License as published by the Free Software
 
10
 * Foundation, either version 2 of the License, or (at your option) any later
 
11
 * version. See http://www.gnu.org/copyleft/gpl.html the full text of the
 
12
 * license.
 
13
 */
4
14
 
5
15
#include <glib.h>
6
16
#include <glib-object.h>
91
101
 
92
102
TDSModel* tds_model_construct (GType object_type, GFile* file, GError** error) {
93
103
        TDSModel* self = NULL;
94
 
        GFile* _tmp0_;
 
104
        GFileInputStream* stream = NULL;
 
105
        GFile* _tmp0_ = NULL;
95
106
        GFileInputStream* _tmp1_ = NULL;
96
 
        GFileInputStream* stream;
97
 
        GFileInputStream* _tmp2_;
98
 
        GFileInfo* _tmp3_ = NULL;
99
 
        GFileInfo* _tmp4_;
100
 
        GFileInputStream* _tmp5_;
101
 
        GFileInfo* _tmp6_;
102
 
        gint64 _tmp7_ = 0LL;
103
 
        GLfloat* _tmp8_;
104
 
        gint _tmp8__length1;
 
107
        GFileInfo* _tmp2_ = NULL;
 
108
        GFileInputStream* _tmp3_ = NULL;
 
109
        GFileInfo* _tmp4_ = NULL;
 
110
        GFileInputStream* _tmp5_ = NULL;
 
111
        GFileInfo* _tmp6_ = NULL;
 
112
        GFileInfo* _tmp7_ = NULL;
 
113
        gint64 _tmp8_ = 0LL;
105
114
        GLfloat* _tmp9_ = NULL;
106
 
        GLfloat* _tmp161_;
107
 
        gint _tmp161__length1;
108
 
        GLfloat* _tmp162_ = NULL;
 
115
        gint _tmp9__length1 = 0;
 
116
        GLfloat* _tmp10_ = NULL;
 
117
        GLfloat* _tmp159_ = NULL;
 
118
        gint _tmp159__length1 = 0;
 
119
        GLfloat* _tmp160_ = NULL;
109
120
        GError * _inner_error_ = NULL;
110
121
        g_return_val_if_fail (file != NULL, NULL);
111
122
        self = (TDSModel*) g_type_create_instance (object_type);
112
123
        _tmp0_ = file;
113
124
        _tmp1_ = g_file_read (_tmp0_, NULL, &_inner_error_);
114
125
        stream = _tmp1_;
115
 
        if (_inner_error_ != NULL) {
 
126
        if (G_UNLIKELY (_inner_error_ != NULL)) {
116
127
                g_propagate_error (error, _inner_error_);
117
128
                _tds_model_unref0 (self);
118
129
                return NULL;
119
130
        }
120
 
        _tmp2_ = stream;
121
 
        _tmp3_ = g_file_input_stream_query_info (_tmp2_, G_FILE_ATTRIBUTE_STANDARD_SIZE, NULL, &_inner_error_);
122
 
        _tmp4_ = _tmp3_;
123
 
        if (_inner_error_ != NULL) {
 
131
        _tmp3_ = stream;
 
132
        _tmp4_ = g_file_input_stream_query_info (_tmp3_, G_FILE_ATTRIBUTE_STANDARD_SIZE, NULL, &_inner_error_);
 
133
        _tmp2_ = _tmp4_;
 
134
        if (G_UNLIKELY (_inner_error_ != NULL)) {
124
135
                g_propagate_error (error, _inner_error_);
125
136
                _g_object_unref0 (stream);
126
137
                _tds_model_unref0 (self);
127
138
                return NULL;
128
139
        }
129
140
        _tmp5_ = stream;
130
 
        _tmp6_ = _tmp4_;
131
 
        _tmp7_ = g_file_info_get_size (_tmp6_);
132
 
        tds_model_parse_block (self, _tmp5_, _tmp7_, &_inner_error_);
133
 
        _g_object_unref0 (_tmp6_);
134
 
        if (_inner_error_ != NULL) {
 
141
        _tmp6_ = _tmp2_;
 
142
        _tmp2_ = NULL;
 
143
        _tmp7_ = _tmp6_;
 
144
        _tmp8_ = g_file_info_get_size (_tmp7_);
 
145
        tds_model_parse_block (self, _tmp5_, _tmp8_, &_inner_error_);
 
146
        _g_object_unref0 (_tmp7_);
 
147
        if (G_UNLIKELY (_inner_error_ != NULL)) {
135
148
                g_propagate_error (error, _inner_error_);
 
149
                _g_object_unref0 (_tmp2_);
136
150
                _g_object_unref0 (stream);
137
151
                _tds_model_unref0 (self);
138
152
                return NULL;
139
153
        }
140
 
        _tmp8_ = self->priv->vertices;
141
 
        _tmp8__length1 = self->priv->vertices_length1;
142
 
        _tmp9_ = g_new0 (GLfloat, _tmp8__length1);
 
154
        _tmp9_ = self->priv->vertices;
 
155
        _tmp9__length1 = self->priv->vertices_length1;
 
156
        _tmp10_ = g_new0 (GLfloat, _tmp9__length1);
143
157
        self->priv->normals = (g_free (self->priv->normals), NULL);
144
 
        self->priv->normals = _tmp9_;
145
 
        self->priv->normals_length1 = _tmp8__length1;
 
158
        self->priv->normals = _tmp10_;
 
159
        self->priv->normals_length1 = _tmp9__length1;
146
160
        self->priv->_normals_size_ = self->priv->normals_length1;
147
161
        {
148
 
                gint i;
 
162
                gint i = 0;
149
163
                i = 0;
150
164
                {
151
 
                        gboolean _tmp10_;
152
 
                        _tmp10_ = TRUE;
 
165
                        gboolean _tmp11_ = FALSE;
 
166
                        _tmp11_ = TRUE;
153
167
                        while (TRUE) {
154
 
                                gboolean _tmp11_;
155
 
                                gint _tmp13_;
156
 
                                GLfloat* _tmp14_;
157
 
                                gint _tmp14__length1;
158
 
                                GLfloat* _tmp15_;
159
 
                                gint _tmp15__length1;
160
 
                                gint _tmp16_;
161
 
                                GLfloat _tmp17_;
162
 
                                _tmp11_ = _tmp10_;
 
168
                                gint _tmp13_ = 0;
 
169
                                GLfloat* _tmp14_ = NULL;
 
170
                                gint _tmp14__length1 = 0;
 
171
                                GLfloat* _tmp15_ = NULL;
 
172
                                gint _tmp15__length1 = 0;
 
173
                                gint _tmp16_ = 0;
 
174
                                GLfloat _tmp17_ = 0.0F;
163
175
                                if (!_tmp11_) {
164
 
                                        gint _tmp12_;
 
176
                                        gint _tmp12_ = 0;
165
177
                                        _tmp12_ = i;
166
178
                                        i = _tmp12_ + 1;
167
179
                                }
168
 
                                _tmp10_ = FALSE;
 
180
                                _tmp11_ = FALSE;
169
181
                                _tmp13_ = i;
170
182
                                _tmp14_ = self->priv->normals;
171
183
                                _tmp14__length1 = self->priv->normals_length1;
181
193
                }
182
194
        }
183
195
        {
184
 
                gint i;
 
196
                gint i = 0;
185
197
                i = 0;
186
198
                {
187
 
                        gboolean _tmp18_;
 
199
                        gboolean _tmp18_ = FALSE;
188
200
                        _tmp18_ = TRUE;
189
201
                        while (TRUE) {
190
 
                                gboolean _tmp19_;
191
 
                                gint _tmp21_;
192
 
                                GLushort* _tmp22_;
193
 
                                gint _tmp22__length1;
194
 
                                GLushort* _tmp23_;
195
 
                                gint _tmp23__length1;
196
 
                                gint _tmp24_;
197
 
                                GLushort _tmp25_;
198
 
                                gint v0;
199
 
                                GLushort* _tmp26_;
200
 
                                gint _tmp26__length1;
201
 
                                gint _tmp27_;
202
 
                                GLushort _tmp28_;
203
 
                                gint v1;
204
 
                                GLushort* _tmp29_;
205
 
                                gint _tmp29__length1;
206
 
                                gint _tmp30_;
207
 
                                GLushort _tmp31_;
208
 
                                gint v2;
 
202
                                gint _tmp20_ = 0;
 
203
                                GLushort* _tmp21_ = NULL;
 
204
                                gint _tmp21__length1 = 0;
 
205
                                gint v0 = 0;
 
206
                                GLushort* _tmp22_ = NULL;
 
207
                                gint _tmp22__length1 = 0;
 
208
                                gint _tmp23_ = 0;
 
209
                                GLushort _tmp24_ = 0U;
 
210
                                gint v1 = 0;
 
211
                                GLushort* _tmp25_ = NULL;
 
212
                                gint _tmp25__length1 = 0;
 
213
                                gint _tmp26_ = 0;
 
214
                                GLushort _tmp27_ = 0U;
 
215
                                gint v2 = 0;
 
216
                                GLushort* _tmp28_ = NULL;
 
217
                                gint _tmp28__length1 = 0;
 
218
                                gint _tmp29_ = 0;
 
219
                                GLushort _tmp30_ = 0U;
209
220
                                GLfloat a[3] = {0};
210
221
                                GLfloat b[3] = {0};
211
222
                                GLfloat normal[3] = {0};
212
 
                                GLfloat* _tmp32_;
213
 
                                gint _tmp32__length1;
214
 
                                gint _tmp33_;
215
 
                                GLfloat _tmp34_;
216
 
                                GLfloat* _tmp35_;
217
 
                                gint _tmp35__length1;
218
 
                                gint _tmp36_;
219
 
                                GLfloat _tmp37_;
220
 
                                GLfloat _tmp38_;
221
 
                                GLfloat* _tmp39_;
222
 
                                gint _tmp39__length1;
223
 
                                gint _tmp40_;
224
 
                                GLfloat _tmp41_;
225
 
                                GLfloat* _tmp42_;
226
 
                                gint _tmp42__length1;
227
 
                                gint _tmp43_;
228
 
                                GLfloat _tmp44_;
229
 
                                GLfloat _tmp45_;
230
 
                                GLfloat* _tmp46_;
231
 
                                gint _tmp46__length1;
232
 
                                gint _tmp47_;
233
 
                                GLfloat _tmp48_;
234
 
                                GLfloat* _tmp49_;
235
 
                                gint _tmp49__length1;
236
 
                                gint _tmp50_;
237
 
                                GLfloat _tmp51_;
238
 
                                GLfloat _tmp52_;
239
 
                                GLfloat* _tmp53_;
240
 
                                gint _tmp53__length1;
241
 
                                gint _tmp54_;
242
 
                                GLfloat _tmp55_;
243
 
                                GLfloat* _tmp56_;
244
 
                                gint _tmp56__length1;
245
 
                                gint _tmp57_;
246
 
                                GLfloat _tmp58_;
247
 
                                GLfloat _tmp59_;
248
 
                                GLfloat* _tmp60_;
249
 
                                gint _tmp60__length1;
250
 
                                gint _tmp61_;
251
 
                                GLfloat _tmp62_;
252
 
                                GLfloat* _tmp63_;
253
 
                                gint _tmp63__length1;
254
 
                                gint _tmp64_;
255
 
                                GLfloat _tmp65_;
256
 
                                GLfloat _tmp66_;
257
 
                                GLfloat* _tmp67_;
258
 
                                gint _tmp67__length1;
259
 
                                gint _tmp68_;
260
 
                                GLfloat _tmp69_;
261
 
                                GLfloat* _tmp70_;
262
 
                                gint _tmp70__length1;
263
 
                                gint _tmp71_;
264
 
                                GLfloat _tmp72_;
265
 
                                GLfloat _tmp73_;
266
 
                                GLfloat _tmp74_;
267
 
                                GLfloat _tmp75_;
268
 
                                GLfloat _tmp76_;
269
 
                                GLfloat _tmp77_;
270
 
                                GLfloat _tmp78_;
271
 
                                GLfloat _tmp79_;
272
 
                                GLfloat _tmp80_;
273
 
                                GLfloat _tmp81_;
274
 
                                GLfloat _tmp82_;
275
 
                                GLfloat _tmp83_;
276
 
                                GLfloat _tmp84_;
277
 
                                GLfloat _tmp85_;
278
 
                                GLfloat _tmp86_;
279
 
                                GLfloat _tmp87_;
280
 
                                GLfloat _tmp88_;
281
 
                                GLfloat* _tmp89_;
282
 
                                gint _tmp89__length1;
283
 
                                gint _tmp90_;
284
 
                                GLfloat _tmp91_;
285
 
                                GLfloat _tmp92_;
286
 
                                GLfloat* _tmp93_;
287
 
                                gint _tmp93__length1;
288
 
                                gint _tmp94_;
289
 
                                GLfloat _tmp95_;
290
 
                                GLfloat _tmp96_;
291
 
                                GLfloat* _tmp97_;
292
 
                                gint _tmp97__length1;
293
 
                                gint _tmp98_;
294
 
                                GLfloat _tmp99_;
295
 
                                GLfloat _tmp100_;
296
 
                                GLfloat* _tmp101_;
297
 
                                gint _tmp101__length1;
298
 
                                gint _tmp102_;
299
 
                                GLfloat _tmp103_;
300
 
                                GLfloat _tmp104_;
301
 
                                GLfloat* _tmp105_;
302
 
                                gint _tmp105__length1;
303
 
                                gint _tmp106_;
304
 
                                GLfloat _tmp107_;
305
 
                                GLfloat _tmp108_;
306
 
                                GLfloat* _tmp109_;
307
 
                                gint _tmp109__length1;
308
 
                                gint _tmp110_;
309
 
                                GLfloat _tmp111_;
310
 
                                GLfloat _tmp112_;
311
 
                                GLfloat* _tmp113_;
312
 
                                gint _tmp113__length1;
313
 
                                gint _tmp114_;
314
 
                                GLfloat _tmp115_;
315
 
                                GLfloat _tmp116_;
316
 
                                GLfloat* _tmp117_;
317
 
                                gint _tmp117__length1;
318
 
                                gint _tmp118_;
319
 
                                GLfloat _tmp119_;
320
 
                                GLfloat _tmp120_;
321
 
                                GLfloat* _tmp121_;
322
 
                                gint _tmp121__length1;
323
 
                                gint _tmp122_;
324
 
                                GLfloat _tmp123_;
325
 
                                GLfloat _tmp124_;
326
 
                                _tmp19_ = _tmp18_;
327
 
                                if (!_tmp19_) {
328
 
                                        gint _tmp20_;
329
 
                                        _tmp20_ = i;
330
 
                                        i = _tmp20_ + 3;
 
223
                                GLfloat* _tmp31_ = NULL;
 
224
                                gint _tmp31__length1 = 0;
 
225
                                gint _tmp32_ = 0;
 
226
                                GLfloat _tmp33_ = 0.0F;
 
227
                                GLfloat* _tmp34_ = NULL;
 
228
                                gint _tmp34__length1 = 0;
 
229
                                gint _tmp35_ = 0;
 
230
                                GLfloat _tmp36_ = 0.0F;
 
231
                                GLfloat _tmp37_ = 0.0F;
 
232
                                GLfloat* _tmp38_ = NULL;
 
233
                                gint _tmp38__length1 = 0;
 
234
                                gint _tmp39_ = 0;
 
235
                                GLfloat _tmp40_ = 0.0F;
 
236
                                GLfloat* _tmp41_ = NULL;
 
237
                                gint _tmp41__length1 = 0;
 
238
                                gint _tmp42_ = 0;
 
239
                                GLfloat _tmp43_ = 0.0F;
 
240
                                GLfloat _tmp44_ = 0.0F;
 
241
                                GLfloat* _tmp45_ = NULL;
 
242
                                gint _tmp45__length1 = 0;
 
243
                                gint _tmp46_ = 0;
 
244
                                GLfloat _tmp47_ = 0.0F;
 
245
                                GLfloat* _tmp48_ = NULL;
 
246
                                gint _tmp48__length1 = 0;
 
247
                                gint _tmp49_ = 0;
 
248
                                GLfloat _tmp50_ = 0.0F;
 
249
                                GLfloat _tmp51_ = 0.0F;
 
250
                                GLfloat* _tmp52_ = NULL;
 
251
                                gint _tmp52__length1 = 0;
 
252
                                gint _tmp53_ = 0;
 
253
                                GLfloat _tmp54_ = 0.0F;
 
254
                                GLfloat* _tmp55_ = NULL;
 
255
                                gint _tmp55__length1 = 0;
 
256
                                gint _tmp56_ = 0;
 
257
                                GLfloat _tmp57_ = 0.0F;
 
258
                                GLfloat _tmp58_ = 0.0F;
 
259
                                GLfloat* _tmp59_ = NULL;
 
260
                                gint _tmp59__length1 = 0;
 
261
                                gint _tmp60_ = 0;
 
262
                                GLfloat _tmp61_ = 0.0F;
 
263
                                GLfloat* _tmp62_ = NULL;
 
264
                                gint _tmp62__length1 = 0;
 
265
                                gint _tmp63_ = 0;
 
266
                                GLfloat _tmp64_ = 0.0F;
 
267
                                GLfloat _tmp65_ = 0.0F;
 
268
                                GLfloat* _tmp66_ = NULL;
 
269
                                gint _tmp66__length1 = 0;
 
270
                                gint _tmp67_ = 0;
 
271
                                GLfloat _tmp68_ = 0.0F;
 
272
                                GLfloat* _tmp69_ = NULL;
 
273
                                gint _tmp69__length1 = 0;
 
274
                                gint _tmp70_ = 0;
 
275
                                GLfloat _tmp71_ = 0.0F;
 
276
                                GLfloat _tmp72_ = 0.0F;
 
277
                                GLfloat _tmp73_ = 0.0F;
 
278
                                GLfloat _tmp74_ = 0.0F;
 
279
                                GLfloat _tmp75_ = 0.0F;
 
280
                                GLfloat _tmp76_ = 0.0F;
 
281
                                GLfloat _tmp77_ = 0.0F;
 
282
                                GLfloat _tmp78_ = 0.0F;
 
283
                                GLfloat _tmp79_ = 0.0F;
 
284
                                GLfloat _tmp80_ = 0.0F;
 
285
                                GLfloat _tmp81_ = 0.0F;
 
286
                                GLfloat _tmp82_ = 0.0F;
 
287
                                GLfloat _tmp83_ = 0.0F;
 
288
                                GLfloat _tmp84_ = 0.0F;
 
289
                                GLfloat _tmp85_ = 0.0F;
 
290
                                GLfloat _tmp86_ = 0.0F;
 
291
                                GLfloat _tmp87_ = 0.0F;
 
292
                                GLfloat* _tmp88_ = NULL;
 
293
                                gint _tmp88__length1 = 0;
 
294
                                gint _tmp89_ = 0;
 
295
                                GLfloat _tmp90_ = 0.0F;
 
296
                                GLfloat _tmp91_ = 0.0F;
 
297
                                GLfloat* _tmp92_ = NULL;
 
298
                                gint _tmp92__length1 = 0;
 
299
                                gint _tmp93_ = 0;
 
300
                                GLfloat _tmp94_ = 0.0F;
 
301
                                GLfloat _tmp95_ = 0.0F;
 
302
                                GLfloat* _tmp96_ = NULL;
 
303
                                gint _tmp96__length1 = 0;
 
304
                                gint _tmp97_ = 0;
 
305
                                GLfloat _tmp98_ = 0.0F;
 
306
                                GLfloat _tmp99_ = 0.0F;
 
307
                                GLfloat* _tmp100_ = NULL;
 
308
                                gint _tmp100__length1 = 0;
 
309
                                gint _tmp101_ = 0;
 
310
                                GLfloat _tmp102_ = 0.0F;
 
311
                                GLfloat _tmp103_ = 0.0F;
 
312
                                GLfloat* _tmp104_ = NULL;
 
313
                                gint _tmp104__length1 = 0;
 
314
                                gint _tmp105_ = 0;
 
315
                                GLfloat _tmp106_ = 0.0F;
 
316
                                GLfloat _tmp107_ = 0.0F;
 
317
                                GLfloat* _tmp108_ = NULL;
 
318
                                gint _tmp108__length1 = 0;
 
319
                                gint _tmp109_ = 0;
 
320
                                GLfloat _tmp110_ = 0.0F;
 
321
                                GLfloat _tmp111_ = 0.0F;
 
322
                                GLfloat* _tmp112_ = NULL;
 
323
                                gint _tmp112__length1 = 0;
 
324
                                gint _tmp113_ = 0;
 
325
                                GLfloat _tmp114_ = 0.0F;
 
326
                                GLfloat _tmp115_ = 0.0F;
 
327
                                GLfloat* _tmp116_ = NULL;
 
328
                                gint _tmp116__length1 = 0;
 
329
                                gint _tmp117_ = 0;
 
330
                                GLfloat _tmp118_ = 0.0F;
 
331
                                GLfloat _tmp119_ = 0.0F;
 
332
                                GLfloat* _tmp120_ = NULL;
 
333
                                gint _tmp120__length1 = 0;
 
334
                                gint _tmp121_ = 0;
 
335
                                GLfloat _tmp122_ = 0.0F;
 
336
                                GLfloat _tmp123_ = 0.0F;
 
337
                                if (!_tmp18_) {
 
338
                                        gint _tmp19_ = 0;
 
339
                                        _tmp19_ = i;
 
340
                                        i = _tmp19_ + 3;
331
341
                                }
332
342
                                _tmp18_ = FALSE;
333
 
                                _tmp21_ = i;
 
343
                                _tmp20_ = i;
 
344
                                _tmp21_ = self->priv->triangles;
 
345
                                _tmp21__length1 = self->priv->triangles_length1;
 
346
                                if (!(_tmp20_ < _tmp21__length1)) {
 
347
                                        break;
 
348
                                }
334
349
                                _tmp22_ = self->priv->triangles;
335
350
                                _tmp22__length1 = self->priv->triangles_length1;
336
 
                                if (!(_tmp21_ < _tmp22__length1)) {
337
 
                                        break;
338
 
                                }
339
 
                                _tmp23_ = self->priv->triangles;
340
 
                                _tmp23__length1 = self->priv->triangles_length1;
341
 
                                _tmp24_ = i;
342
 
                                _tmp25_ = _tmp23_[_tmp24_];
343
 
                                v0 = _tmp25_ * 3;
344
 
                                _tmp26_ = self->priv->triangles;
345
 
                                _tmp26__length1 = self->priv->triangles_length1;
346
 
                                _tmp27_ = i;
347
 
                                _tmp28_ = _tmp26_[_tmp27_ + 1];
348
 
                                v1 = _tmp28_ * 3;
349
 
                                _tmp29_ = self->priv->triangles;
350
 
                                _tmp29__length1 = self->priv->triangles_length1;
351
 
                                _tmp30_ = i;
352
 
                                _tmp31_ = _tmp29_[_tmp30_ + 2];
353
 
                                v2 = _tmp31_ * 3;
354
 
                                _tmp32_ = self->priv->vertices;
355
 
                                _tmp32__length1 = self->priv->vertices_length1;
356
 
                                _tmp33_ = v1;
357
 
                                _tmp34_ = _tmp32_[_tmp33_];
358
 
                                _tmp35_ = self->priv->vertices;
359
 
                                _tmp35__length1 = self->priv->vertices_length1;
360
 
                                _tmp36_ = v0;
361
 
                                _tmp37_ = _tmp35_[_tmp36_];
362
 
                                a[0] = _tmp34_ - _tmp37_;
363
 
                                _tmp38_ = a[0];
364
 
                                _tmp39_ = self->priv->vertices;
365
 
                                _tmp39__length1 = self->priv->vertices_length1;
366
 
                                _tmp40_ = v1;
367
 
                                _tmp41_ = _tmp39_[_tmp40_ + 1];
368
 
                                _tmp42_ = self->priv->vertices;
369
 
                                _tmp42__length1 = self->priv->vertices_length1;
370
 
                                _tmp43_ = v0;
371
 
                                _tmp44_ = _tmp42_[_tmp43_ + 1];
372
 
                                a[1] = _tmp41_ - _tmp44_;
373
 
                                _tmp45_ = a[1];
374
 
                                _tmp46_ = self->priv->vertices;
375
 
                                _tmp46__length1 = self->priv->vertices_length1;
376
 
                                _tmp47_ = v1;
377
 
                                _tmp48_ = _tmp46_[_tmp47_ + 2];
378
 
                                _tmp49_ = self->priv->vertices;
379
 
                                _tmp49__length1 = self->priv->vertices_length1;
380
 
                                _tmp50_ = v0;
381
 
                                _tmp51_ = _tmp49_[_tmp50_ + 2];
382
 
                                a[2] = _tmp48_ - _tmp51_;
383
 
                                _tmp52_ = a[2];
384
 
                                _tmp53_ = self->priv->vertices;
385
 
                                _tmp53__length1 = self->priv->vertices_length1;
386
 
                                _tmp54_ = v2;
387
 
                                _tmp55_ = _tmp53_[_tmp54_];
388
 
                                _tmp56_ = self->priv->vertices;
389
 
                                _tmp56__length1 = self->priv->vertices_length1;
390
 
                                _tmp57_ = v0;
391
 
                                _tmp58_ = _tmp56_[_tmp57_];
392
 
                                b[0] = _tmp55_ - _tmp58_;
393
 
                                _tmp59_ = b[0];
394
 
                                _tmp60_ = self->priv->vertices;
395
 
                                _tmp60__length1 = self->priv->vertices_length1;
396
 
                                _tmp61_ = v2;
397
 
                                _tmp62_ = _tmp60_[_tmp61_ + 1];
398
 
                                _tmp63_ = self->priv->vertices;
399
 
                                _tmp63__length1 = self->priv->vertices_length1;
400
 
                                _tmp64_ = v0;
401
 
                                _tmp65_ = _tmp63_[_tmp64_ + 1];
402
 
                                b[1] = _tmp62_ - _tmp65_;
403
 
                                _tmp66_ = b[1];
404
 
                                _tmp67_ = self->priv->vertices;
405
 
                                _tmp67__length1 = self->priv->vertices_length1;
406
 
                                _tmp68_ = v2;
407
 
                                _tmp69_ = _tmp67_[_tmp68_ + 2];
408
 
                                _tmp70_ = self->priv->vertices;
409
 
                                _tmp70__length1 = self->priv->vertices_length1;
410
 
                                _tmp71_ = v0;
411
 
                                _tmp72_ = _tmp70_[_tmp71_ + 2];
412
 
                                b[2] = _tmp69_ - _tmp72_;
413
 
                                _tmp73_ = b[2];
414
 
                                _tmp74_ = a[1];
415
 
                                _tmp75_ = b[2];
416
 
                                _tmp76_ = a[2];
417
 
                                _tmp77_ = b[1];
418
 
                                normal[0] = (_tmp74_ * _tmp75_) - (_tmp76_ * _tmp77_);
419
 
                                _tmp78_ = normal[0];
420
 
                                _tmp79_ = a[2];
421
 
                                _tmp80_ = b[0];
422
 
                                _tmp81_ = a[0];
423
 
                                _tmp82_ = b[2];
424
 
                                normal[1] = (_tmp79_ * _tmp80_) - (_tmp81_ * _tmp82_);
425
 
                                _tmp83_ = normal[1];
426
 
                                _tmp84_ = a[0];
427
 
                                _tmp85_ = b[1];
428
 
                                _tmp86_ = a[1];
429
 
                                _tmp87_ = b[0];
430
 
                                normal[2] = (_tmp84_ * _tmp85_) - (_tmp86_ * _tmp87_);
431
 
                                _tmp88_ = normal[2];
432
 
                                _tmp89_ = self->priv->normals;
433
 
                                _tmp89__length1 = self->priv->normals_length1;
434
 
                                _tmp90_ = v0;
435
 
                                _tmp91_ = normal[0];
436
 
                                _tmp89_[_tmp90_] += _tmp91_;
437
 
                                _tmp92_ = _tmp89_[_tmp90_];
438
 
                                _tmp93_ = self->priv->normals;
439
 
                                _tmp93__length1 = self->priv->normals_length1;
440
 
                                _tmp94_ = v0;
441
 
                                _tmp95_ = normal[1];
442
 
                                _tmp93_[_tmp94_ + 1] += _tmp95_;
443
 
                                _tmp96_ = _tmp93_[_tmp94_ + 1];
444
 
                                _tmp97_ = self->priv->normals;
445
 
                                _tmp97__length1 = self->priv->normals_length1;
446
 
                                _tmp98_ = v0;
447
 
                                _tmp99_ = normal[2];
448
 
                                _tmp97_[_tmp98_ + 2] += _tmp99_;
449
 
                                _tmp100_ = _tmp97_[_tmp98_ + 2];
450
 
                                _tmp101_ = self->priv->normals;
451
 
                                _tmp101__length1 = self->priv->normals_length1;
452
 
                                _tmp102_ = v1;
453
 
                                _tmp103_ = normal[0];
454
 
                                _tmp101_[_tmp102_] += _tmp103_;
455
 
                                _tmp104_ = _tmp101_[_tmp102_];
456
 
                                _tmp105_ = self->priv->normals;
457
 
                                _tmp105__length1 = self->priv->normals_length1;
458
 
                                _tmp106_ = v1;
459
 
                                _tmp107_ = normal[1];
460
 
                                _tmp105_[_tmp106_ + 1] += _tmp107_;
461
 
                                _tmp108_ = _tmp105_[_tmp106_ + 1];
462
 
                                _tmp109_ = self->priv->normals;
463
 
                                _tmp109__length1 = self->priv->normals_length1;
464
 
                                _tmp110_ = v1;
465
 
                                _tmp111_ = normal[2];
466
 
                                _tmp109_[_tmp110_ + 2] += _tmp111_;
467
 
                                _tmp112_ = _tmp109_[_tmp110_ + 2];
468
 
                                _tmp113_ = self->priv->normals;
469
 
                                _tmp113__length1 = self->priv->normals_length1;
470
 
                                _tmp114_ = v2;
471
 
                                _tmp115_ = normal[0];
472
 
                                _tmp113_[_tmp114_] += _tmp115_;
473
 
                                _tmp116_ = _tmp113_[_tmp114_];
474
 
                                _tmp117_ = self->priv->normals;
475
 
                                _tmp117__length1 = self->priv->normals_length1;
476
 
                                _tmp118_ = v2;
477
 
                                _tmp119_ = normal[1];
478
 
                                _tmp117_[_tmp118_ + 1] += _tmp119_;
479
 
                                _tmp120_ = _tmp117_[_tmp118_ + 1];
480
 
                                _tmp121_ = self->priv->normals;
481
 
                                _tmp121__length1 = self->priv->normals_length1;
482
 
                                _tmp122_ = v2;
483
 
                                _tmp123_ = normal[2];
484
 
                                _tmp121_[_tmp122_ + 2] += _tmp123_;
485
 
                                _tmp124_ = _tmp121_[_tmp122_ + 2];
 
351
                                _tmp23_ = i;
 
352
                                _tmp24_ = _tmp22_[_tmp23_];
 
353
                                v0 = _tmp24_ * 3;
 
354
                                _tmp25_ = self->priv->triangles;
 
355
                                _tmp25__length1 = self->priv->triangles_length1;
 
356
                                _tmp26_ = i;
 
357
                                _tmp27_ = _tmp25_[_tmp26_ + 1];
 
358
                                v1 = _tmp27_ * 3;
 
359
                                _tmp28_ = self->priv->triangles;
 
360
                                _tmp28__length1 = self->priv->triangles_length1;
 
361
                                _tmp29_ = i;
 
362
                                _tmp30_ = _tmp28_[_tmp29_ + 2];
 
363
                                v2 = _tmp30_ * 3;
 
364
                                _tmp31_ = self->priv->vertices;
 
365
                                _tmp31__length1 = self->priv->vertices_length1;
 
366
                                _tmp32_ = v1;
 
367
                                _tmp33_ = _tmp31_[_tmp32_];
 
368
                                _tmp34_ = self->priv->vertices;
 
369
                                _tmp34__length1 = self->priv->vertices_length1;
 
370
                                _tmp35_ = v0;
 
371
                                _tmp36_ = _tmp34_[_tmp35_];
 
372
                                a[0] = _tmp33_ - _tmp36_;
 
373
                                _tmp37_ = a[0];
 
374
                                _tmp38_ = self->priv->vertices;
 
375
                                _tmp38__length1 = self->priv->vertices_length1;
 
376
                                _tmp39_ = v1;
 
377
                                _tmp40_ = _tmp38_[_tmp39_ + 1];
 
378
                                _tmp41_ = self->priv->vertices;
 
379
                                _tmp41__length1 = self->priv->vertices_length1;
 
380
                                _tmp42_ = v0;
 
381
                                _tmp43_ = _tmp41_[_tmp42_ + 1];
 
382
                                a[1] = _tmp40_ - _tmp43_;
 
383
                                _tmp44_ = a[1];
 
384
                                _tmp45_ = self->priv->vertices;
 
385
                                _tmp45__length1 = self->priv->vertices_length1;
 
386
                                _tmp46_ = v1;
 
387
                                _tmp47_ = _tmp45_[_tmp46_ + 2];
 
388
                                _tmp48_ = self->priv->vertices;
 
389
                                _tmp48__length1 = self->priv->vertices_length1;
 
390
                                _tmp49_ = v0;
 
391
                                _tmp50_ = _tmp48_[_tmp49_ + 2];
 
392
                                a[2] = _tmp47_ - _tmp50_;
 
393
                                _tmp51_ = a[2];
 
394
                                _tmp52_ = self->priv->vertices;
 
395
                                _tmp52__length1 = self->priv->vertices_length1;
 
396
                                _tmp53_ = v2;
 
397
                                _tmp54_ = _tmp52_[_tmp53_];
 
398
                                _tmp55_ = self->priv->vertices;
 
399
                                _tmp55__length1 = self->priv->vertices_length1;
 
400
                                _tmp56_ = v0;
 
401
                                _tmp57_ = _tmp55_[_tmp56_];
 
402
                                b[0] = _tmp54_ - _tmp57_;
 
403
                                _tmp58_ = b[0];
 
404
                                _tmp59_ = self->priv->vertices;
 
405
                                _tmp59__length1 = self->priv->vertices_length1;
 
406
                                _tmp60_ = v2;
 
407
                                _tmp61_ = _tmp59_[_tmp60_ + 1];
 
408
                                _tmp62_ = self->priv->vertices;
 
409
                                _tmp62__length1 = self->priv->vertices_length1;
 
410
                                _tmp63_ = v0;
 
411
                                _tmp64_ = _tmp62_[_tmp63_ + 1];
 
412
                                b[1] = _tmp61_ - _tmp64_;
 
413
                                _tmp65_ = b[1];
 
414
                                _tmp66_ = self->priv->vertices;
 
415
                                _tmp66__length1 = self->priv->vertices_length1;
 
416
                                _tmp67_ = v2;
 
417
                                _tmp68_ = _tmp66_[_tmp67_ + 2];
 
418
                                _tmp69_ = self->priv->vertices;
 
419
                                _tmp69__length1 = self->priv->vertices_length1;
 
420
                                _tmp70_ = v0;
 
421
                                _tmp71_ = _tmp69_[_tmp70_ + 2];
 
422
                                b[2] = _tmp68_ - _tmp71_;
 
423
                                _tmp72_ = b[2];
 
424
                                _tmp73_ = a[1];
 
425
                                _tmp74_ = b[2];
 
426
                                _tmp75_ = a[2];
 
427
                                _tmp76_ = b[1];
 
428
                                normal[0] = (_tmp73_ * _tmp74_) - (_tmp75_ * _tmp76_);
 
429
                                _tmp77_ = normal[0];
 
430
                                _tmp78_ = a[2];
 
431
                                _tmp79_ = b[0];
 
432
                                _tmp80_ = a[0];
 
433
                                _tmp81_ = b[2];
 
434
                                normal[1] = (_tmp78_ * _tmp79_) - (_tmp80_ * _tmp81_);
 
435
                                _tmp82_ = normal[1];
 
436
                                _tmp83_ = a[0];
 
437
                                _tmp84_ = b[1];
 
438
                                _tmp85_ = a[1];
 
439
                                _tmp86_ = b[0];
 
440
                                normal[2] = (_tmp83_ * _tmp84_) - (_tmp85_ * _tmp86_);
 
441
                                _tmp87_ = normal[2];
 
442
                                _tmp88_ = self->priv->normals;
 
443
                                _tmp88__length1 = self->priv->normals_length1;
 
444
                                _tmp89_ = v0;
 
445
                                _tmp90_ = normal[0];
 
446
                                _tmp88_[_tmp89_] += _tmp90_;
 
447
                                _tmp91_ = _tmp88_[_tmp89_];
 
448
                                _tmp92_ = self->priv->normals;
 
449
                                _tmp92__length1 = self->priv->normals_length1;
 
450
                                _tmp93_ = v0;
 
451
                                _tmp94_ = normal[1];
 
452
                                _tmp92_[_tmp93_ + 1] += _tmp94_;
 
453
                                _tmp95_ = _tmp92_[_tmp93_ + 1];
 
454
                                _tmp96_ = self->priv->normals;
 
455
                                _tmp96__length1 = self->priv->normals_length1;
 
456
                                _tmp97_ = v0;
 
457
                                _tmp98_ = normal[2];
 
458
                                _tmp96_[_tmp97_ + 2] += _tmp98_;
 
459
                                _tmp99_ = _tmp96_[_tmp97_ + 2];
 
460
                                _tmp100_ = self->priv->normals;
 
461
                                _tmp100__length1 = self->priv->normals_length1;
 
462
                                _tmp101_ = v1;
 
463
                                _tmp102_ = normal[0];
 
464
                                _tmp100_[_tmp101_] += _tmp102_;
 
465
                                _tmp103_ = _tmp100_[_tmp101_];
 
466
                                _tmp104_ = self->priv->normals;
 
467
                                _tmp104__length1 = self->priv->normals_length1;
 
468
                                _tmp105_ = v1;
 
469
                                _tmp106_ = normal[1];
 
470
                                _tmp104_[_tmp105_ + 1] += _tmp106_;
 
471
                                _tmp107_ = _tmp104_[_tmp105_ + 1];
 
472
                                _tmp108_ = self->priv->normals;
 
473
                                _tmp108__length1 = self->priv->normals_length1;
 
474
                                _tmp109_ = v1;
 
475
                                _tmp110_ = normal[2];
 
476
                                _tmp108_[_tmp109_ + 2] += _tmp110_;
 
477
                                _tmp111_ = _tmp108_[_tmp109_ + 2];
 
478
                                _tmp112_ = self->priv->normals;
 
479
                                _tmp112__length1 = self->priv->normals_length1;
 
480
                                _tmp113_ = v2;
 
481
                                _tmp114_ = normal[0];
 
482
                                _tmp112_[_tmp113_] += _tmp114_;
 
483
                                _tmp115_ = _tmp112_[_tmp113_];
 
484
                                _tmp116_ = self->priv->normals;
 
485
                                _tmp116__length1 = self->priv->normals_length1;
 
486
                                _tmp117_ = v2;
 
487
                                _tmp118_ = normal[1];
 
488
                                _tmp116_[_tmp117_ + 1] += _tmp118_;
 
489
                                _tmp119_ = _tmp116_[_tmp117_ + 1];
 
490
                                _tmp120_ = self->priv->normals;
 
491
                                _tmp120__length1 = self->priv->normals_length1;
 
492
                                _tmp121_ = v2;
 
493
                                _tmp122_ = normal[2];
 
494
                                _tmp120_[_tmp121_ + 2] += _tmp122_;
 
495
                                _tmp123_ = _tmp120_[_tmp121_ + 2];
486
496
                        }
487
497
                }
488
498
        }
489
499
        {
490
 
                gint i;
 
500
                gint i = 0;
491
501
                i = 0;
492
502
                {
493
 
                        gboolean _tmp125_;
494
 
                        _tmp125_ = TRUE;
 
503
                        gboolean _tmp124_ = FALSE;
 
504
                        _tmp124_ = TRUE;
495
505
                        while (TRUE) {
496
 
                                gboolean _tmp126_;
497
 
                                gint _tmp128_;
498
 
                                GLfloat* _tmp129_;
499
 
                                gint _tmp129__length1;
500
 
                                GLfloat* _tmp130_;
501
 
                                gint _tmp130__length1;
502
 
                                gint _tmp131_;
503
 
                                GLfloat _tmp132_;
504
 
                                GLfloat* _tmp133_;
505
 
                                gint _tmp133__length1;
506
 
                                gint _tmp134_;
507
 
                                GLfloat _tmp135_;
508
 
                                GLfloat* _tmp136_;
509
 
                                gint _tmp136__length1;
510
 
                                gint _tmp137_;
511
 
                                GLfloat _tmp138_;
512
 
                                GLfloat* _tmp139_;
513
 
                                gint _tmp139__length1;
514
 
                                gint _tmp140_;
515
 
                                GLfloat _tmp141_;
516
 
                                GLfloat* _tmp142_;
517
 
                                gint _tmp142__length1;
518
 
                                gint _tmp143_;
519
 
                                GLfloat _tmp144_;
520
 
                                GLfloat* _tmp145_;
521
 
                                gint _tmp145__length1;
522
 
                                gint _tmp146_;
523
 
                                GLfloat _tmp147_;
524
 
                                gdouble _tmp148_ = 0.0;
525
 
                                GLfloat length;
526
 
                                GLfloat* _tmp149_;
527
 
                                gint _tmp149__length1;
528
 
                                gint _tmp150_;
529
 
                                GLfloat _tmp151_;
530
 
                                GLfloat _tmp152_;
531
 
                                GLfloat* _tmp153_;
532
 
                                gint _tmp153__length1;
533
 
                                gint _tmp154_;
534
 
                                GLfloat _tmp155_;
535
 
                                GLfloat _tmp156_;
536
 
                                GLfloat* _tmp157_;
537
 
                                gint _tmp157__length1;
538
 
                                gint _tmp158_;
539
 
                                GLfloat _tmp159_;
540
 
                                GLfloat _tmp160_;
541
 
                                _tmp126_ = _tmp125_;
542
 
                                if (!_tmp126_) {
543
 
                                        gint _tmp127_;
544
 
                                        _tmp127_ = i;
545
 
                                        i = _tmp127_ + 3;
 
506
                                gint _tmp126_ = 0;
 
507
                                GLfloat* _tmp127_ = NULL;
 
508
                                gint _tmp127__length1 = 0;
 
509
                                GLfloat length = 0.0F;
 
510
                                GLfloat* _tmp128_ = NULL;
 
511
                                gint _tmp128__length1 = 0;
 
512
                                gint _tmp129_ = 0;
 
513
                                GLfloat _tmp130_ = 0.0F;
 
514
                                GLfloat* _tmp131_ = NULL;
 
515
                                gint _tmp131__length1 = 0;
 
516
                                gint _tmp132_ = 0;
 
517
                                GLfloat _tmp133_ = 0.0F;
 
518
                                GLfloat* _tmp134_ = NULL;
 
519
                                gint _tmp134__length1 = 0;
 
520
                                gint _tmp135_ = 0;
 
521
                                GLfloat _tmp136_ = 0.0F;
 
522
                                GLfloat* _tmp137_ = NULL;
 
523
                                gint _tmp137__length1 = 0;
 
524
                                gint _tmp138_ = 0;
 
525
                                GLfloat _tmp139_ = 0.0F;
 
526
                                GLfloat* _tmp140_ = NULL;
 
527
                                gint _tmp140__length1 = 0;
 
528
                                gint _tmp141_ = 0;
 
529
                                GLfloat _tmp142_ = 0.0F;
 
530
                                GLfloat* _tmp143_ = NULL;
 
531
                                gint _tmp143__length1 = 0;
 
532
                                gint _tmp144_ = 0;
 
533
                                GLfloat _tmp145_ = 0.0F;
 
534
                                gdouble _tmp146_ = 0.0;
 
535
                                GLfloat* _tmp147_ = NULL;
 
536
                                gint _tmp147__length1 = 0;
 
537
                                gint _tmp148_ = 0;
 
538
                                GLfloat _tmp149_ = 0.0F;
 
539
                                GLfloat _tmp150_ = 0.0F;
 
540
                                GLfloat* _tmp151_ = NULL;
 
541
                                gint _tmp151__length1 = 0;
 
542
                                gint _tmp152_ = 0;
 
543
                                GLfloat _tmp153_ = 0.0F;
 
544
                                GLfloat _tmp154_ = 0.0F;
 
545
                                GLfloat* _tmp155_ = NULL;
 
546
                                gint _tmp155__length1 = 0;
 
547
                                gint _tmp156_ = 0;
 
548
                                GLfloat _tmp157_ = 0.0F;
 
549
                                GLfloat _tmp158_ = 0.0F;
 
550
                                if (!_tmp124_) {
 
551
                                        gint _tmp125_ = 0;
 
552
                                        _tmp125_ = i;
 
553
                                        i = _tmp125_ + 3;
546
554
                                }
547
 
                                _tmp125_ = FALSE;
548
 
                                _tmp128_ = i;
549
 
                                _tmp129_ = self->priv->normals;
550
 
                                _tmp129__length1 = self->priv->normals_length1;
551
 
                                if (!(_tmp128_ < _tmp129__length1)) {
 
555
                                _tmp124_ = FALSE;
 
556
                                _tmp126_ = i;
 
557
                                _tmp127_ = self->priv->normals;
 
558
                                _tmp127__length1 = self->priv->normals_length1;
 
559
                                if (!(_tmp126_ < _tmp127__length1)) {
552
560
                                        break;
553
561
                                }
554
 
                                _tmp130_ = self->priv->normals;
555
 
                                _tmp130__length1 = self->priv->normals_length1;
556
 
                                _tmp131_ = i;
557
 
                                _tmp132_ = _tmp130_[_tmp131_];
558
 
                                _tmp133_ = self->priv->normals;
559
 
                                _tmp133__length1 = self->priv->normals_length1;
560
 
                                _tmp134_ = i;
561
 
                                _tmp135_ = _tmp133_[_tmp134_];
562
 
                                _tmp136_ = self->priv->normals;
563
 
                                _tmp136__length1 = self->priv->normals_length1;
564
 
                                _tmp137_ = i;
565
 
                                _tmp138_ = _tmp136_[_tmp137_ + 1];
566
 
                                _tmp139_ = self->priv->normals;
567
 
                                _tmp139__length1 = self->priv->normals_length1;
568
 
                                _tmp140_ = i;
569
 
                                _tmp141_ = _tmp139_[_tmp140_ + 1];
570
 
                                _tmp142_ = self->priv->normals;
571
 
                                _tmp142__length1 = self->priv->normals_length1;
572
 
                                _tmp143_ = i;
573
 
                                _tmp144_ = _tmp142_[_tmp143_ + 2];
574
 
                                _tmp145_ = self->priv->normals;
575
 
                                _tmp145__length1 = self->priv->normals_length1;
576
 
                                _tmp146_ = i;
577
 
                                _tmp147_ = _tmp145_[_tmp146_ + 2];
578
 
                                _tmp148_ = sqrt ((gdouble) (((_tmp132_ * _tmp135_) + (_tmp138_ * _tmp141_)) + (_tmp144_ * _tmp147_)));
579
 
                                length = (GLfloat) _tmp148_;
580
 
                                _tmp149_ = self->priv->normals;
581
 
                                _tmp149__length1 = self->priv->normals_length1;
582
 
                                _tmp150_ = i;
583
 
                                _tmp151_ = length;
584
 
                                _tmp149_[_tmp150_] /= _tmp151_;
585
 
                                _tmp152_ = _tmp149_[_tmp150_];
586
 
                                _tmp153_ = self->priv->normals;
587
 
                                _tmp153__length1 = self->priv->normals_length1;
588
 
                                _tmp154_ = i;
589
 
                                _tmp155_ = length;
590
 
                                _tmp153_[_tmp154_ + 1] /= _tmp155_;
591
 
                                _tmp156_ = _tmp153_[_tmp154_ + 1];
592
 
                                _tmp157_ = self->priv->normals;
593
 
                                _tmp157__length1 = self->priv->normals_length1;
594
 
                                _tmp158_ = i;
595
 
                                _tmp159_ = length;
596
 
                                _tmp157_[_tmp158_ + 2] /= _tmp159_;
597
 
                                _tmp160_ = _tmp157_[_tmp158_ + 2];
 
562
                                _tmp128_ = self->priv->normals;
 
563
                                _tmp128__length1 = self->priv->normals_length1;
 
564
                                _tmp129_ = i;
 
565
                                _tmp130_ = _tmp128_[_tmp129_];
 
566
                                _tmp131_ = self->priv->normals;
 
567
                                _tmp131__length1 = self->priv->normals_length1;
 
568
                                _tmp132_ = i;
 
569
                                _tmp133_ = _tmp131_[_tmp132_];
 
570
                                _tmp134_ = self->priv->normals;
 
571
                                _tmp134__length1 = self->priv->normals_length1;
 
572
                                _tmp135_ = i;
 
573
                                _tmp136_ = _tmp134_[_tmp135_ + 1];
 
574
                                _tmp137_ = self->priv->normals;
 
575
                                _tmp137__length1 = self->priv->normals_length1;
 
576
                                _tmp138_ = i;
 
577
                                _tmp139_ = _tmp137_[_tmp138_ + 1];
 
578
                                _tmp140_ = self->priv->normals;
 
579
                                _tmp140__length1 = self->priv->normals_length1;
 
580
                                _tmp141_ = i;
 
581
                                _tmp142_ = _tmp140_[_tmp141_ + 2];
 
582
                                _tmp143_ = self->priv->normals;
 
583
                                _tmp143__length1 = self->priv->normals_length1;
 
584
                                _tmp144_ = i;
 
585
                                _tmp145_ = _tmp143_[_tmp144_ + 2];
 
586
                                _tmp146_ = sqrt ((gdouble) (((_tmp130_ * _tmp133_) + (_tmp136_ * _tmp139_)) + (_tmp142_ * _tmp145_)));
 
587
                                length = (GLfloat) _tmp146_;
 
588
                                _tmp147_ = self->priv->normals;
 
589
                                _tmp147__length1 = self->priv->normals_length1;
 
590
                                _tmp148_ = i;
 
591
                                _tmp149_ = length;
 
592
                                _tmp147_[_tmp148_] /= _tmp149_;
 
593
                                _tmp150_ = _tmp147_[_tmp148_];
 
594
                                _tmp151_ = self->priv->normals;
 
595
                                _tmp151__length1 = self->priv->normals_length1;
 
596
                                _tmp152_ = i;
 
597
                                _tmp153_ = length;
 
598
                                _tmp151_[_tmp152_ + 1] /= _tmp153_;
 
599
                                _tmp154_ = _tmp151_[_tmp152_ + 1];
 
600
                                _tmp155_ = self->priv->normals;
 
601
                                _tmp155__length1 = self->priv->normals_length1;
 
602
                                _tmp156_ = i;
 
603
                                _tmp157_ = length;
 
604
                                _tmp155_[_tmp156_ + 2] /= _tmp157_;
 
605
                                _tmp158_ = _tmp155_[_tmp156_ + 2];
598
606
                        }
599
607
                }
600
608
        }
601
 
        _tmp161_ = self->priv->vertices;
602
 
        _tmp161__length1 = self->priv->vertices_length1;
603
 
        _tmp162_ = g_new0 (GLfloat, (_tmp161__length1 / 3) * 2);
 
609
        _tmp159_ = self->priv->vertices;
 
610
        _tmp159__length1 = self->priv->vertices_length1;
 
611
        _tmp160_ = g_new0 (GLfloat, (_tmp159__length1 / 3) * 2);
604
612
        self->priv->texture_coords = (g_free (self->priv->texture_coords), NULL);
605
 
        self->priv->texture_coords = _tmp162_;
606
 
        self->priv->texture_coords_length1 = (_tmp161__length1 / 3) * 2;
 
613
        self->priv->texture_coords = _tmp160_;
 
614
        self->priv->texture_coords_length1 = (_tmp159__length1 / 3) * 2;
607
615
        self->priv->_texture_coords_size_ = self->priv->texture_coords_length1;
608
616
        {
609
 
                gint i;
610
 
                gint j;
 
617
                gint i = 0;
 
618
                gint j = 0;
611
619
                i = 0;
612
620
                j = 0;
613
621
                {
614
 
                        gboolean _tmp163_;
615
 
                        _tmp163_ = TRUE;
 
622
                        gboolean _tmp161_ = FALSE;
 
623
                        _tmp161_ = TRUE;
616
624
                        while (TRUE) {
617
 
                                gboolean _tmp164_;
618
 
                                gint _tmp167_;
619
 
                                GLfloat* _tmp168_;
620
 
                                gint _tmp168__length1;
621
 
                                GLfloat* _tmp169_;
622
 
                                gint _tmp169__length1;
623
 
                                gint _tmp170_;
624
 
                                GLfloat _tmp171_;
625
 
                                GLfloat u;
626
 
                                GLfloat* _tmp172_;
627
 
                                gint _tmp172__length1;
628
 
                                gint _tmp173_;
629
 
                                GLfloat _tmp174_;
630
 
                                GLfloat v;
631
 
                                GLfloat _tmp175_;
632
 
                                GLfloat _tmp176_;
633
 
                                GLfloat _tmp177_;
634
 
                                GLfloat _tmp178_;
635
 
                                gdouble _tmp179_ = 0.0;
636
 
                                GLfloat r;
637
 
                                GLfloat _tmp180_;
638
 
                                GLfloat* _tmp185_;
639
 
                                gint _tmp185__length1;
640
 
                                gint _tmp186_;
641
 
                                GLfloat _tmp187_;
642
 
                                GLfloat _tmp188_;
643
 
                                gfloat h;
644
 
                                GLfloat* _tmp189_;
645
 
                                gint _tmp189__length1;
646
 
                                gint _tmp190_;
647
 
                                gfloat _tmp191_;
648
 
                                GLfloat _tmp192_;
649
 
                                GLfloat _tmp193_;
650
 
                                GLfloat* _tmp194_;
651
 
                                gint _tmp194__length1;
652
 
                                gint _tmp195_;
653
 
                                gfloat _tmp196_;
654
 
                                GLfloat _tmp197_;
655
 
                                GLfloat _tmp198_;
656
 
                                _tmp164_ = _tmp163_;
657
 
                                if (!_tmp164_) {
658
 
                                        gint _tmp165_;
659
 
                                        gint _tmp166_;
660
 
                                        _tmp165_ = i;
661
 
                                        i = _tmp165_ + 3;
662
 
                                        _tmp166_ = j;
663
 
                                        j = _tmp166_ + 2;
664
 
                                }
665
 
                                _tmp163_ = FALSE;
 
625
                                gint _tmp164_ = 0;
 
626
                                GLfloat* _tmp165_ = NULL;
 
627
                                gint _tmp165__length1 = 0;
 
628
                                GLfloat u = 0.0F;
 
629
                                GLfloat* _tmp166_ = NULL;
 
630
                                gint _tmp166__length1 = 0;
 
631
                                gint _tmp167_ = 0;
 
632
                                GLfloat _tmp168_ = 0.0F;
 
633
                                GLfloat v = 0.0F;
 
634
                                GLfloat* _tmp169_ = NULL;
 
635
                                gint _tmp169__length1 = 0;
 
636
                                gint _tmp170_ = 0;
 
637
                                GLfloat _tmp171_ = 0.0F;
 
638
                                GLfloat r = 0.0F;
 
639
                                GLfloat _tmp172_ = 0.0F;
 
640
                                GLfloat _tmp173_ = 0.0F;
 
641
                                GLfloat _tmp174_ = 0.0F;
 
642
                                GLfloat _tmp175_ = 0.0F;
 
643
                                gdouble _tmp176_ = 0.0;
 
644
                                GLfloat _tmp177_ = 0.0F;
 
645
                                gfloat h = 0.0F;
 
646
                                GLfloat* _tmp182_ = NULL;
 
647
                                gint _tmp182__length1 = 0;
 
648
                                gint _tmp183_ = 0;
 
649
                                GLfloat _tmp184_ = 0.0F;
 
650
                                GLfloat _tmp185_ = 0.0F;
 
651
                                GLfloat* _tmp186_ = NULL;
 
652
                                gint _tmp186__length1 = 0;
 
653
                                gint _tmp187_ = 0;
 
654
                                gfloat _tmp188_ = 0.0F;
 
655
                                GLfloat _tmp189_ = 0.0F;
 
656
                                GLfloat _tmp190_ = 0.0F;
 
657
                                GLfloat* _tmp191_ = NULL;
 
658
                                gint _tmp191__length1 = 0;
 
659
                                gint _tmp192_ = 0;
 
660
                                gfloat _tmp193_ = 0.0F;
 
661
                                GLfloat _tmp194_ = 0.0F;
 
662
                                GLfloat _tmp195_ = 0.0F;
 
663
                                if (!_tmp161_) {
 
664
                                        gint _tmp162_ = 0;
 
665
                                        gint _tmp163_ = 0;
 
666
                                        _tmp162_ = i;
 
667
                                        i = _tmp162_ + 3;
 
668
                                        _tmp163_ = j;
 
669
                                        j = _tmp163_ + 2;
 
670
                                }
 
671
                                _tmp161_ = FALSE;
 
672
                                _tmp164_ = i;
 
673
                                _tmp165_ = self->priv->vertices;
 
674
                                _tmp165__length1 = self->priv->vertices_length1;
 
675
                                if (!(_tmp164_ < _tmp165__length1)) {
 
676
                                        break;
 
677
                                }
 
678
                                _tmp166_ = self->priv->vertices;
 
679
                                _tmp166__length1 = self->priv->vertices_length1;
666
680
                                _tmp167_ = i;
667
 
                                _tmp168_ = self->priv->vertices;
668
 
                                _tmp168__length1 = self->priv->vertices_length1;
669
 
                                if (!(_tmp167_ < _tmp168__length1)) {
670
 
                                        break;
671
 
                                }
 
681
                                _tmp168_ = _tmp166_[_tmp167_];
 
682
                                u = _tmp168_;
672
683
                                _tmp169_ = self->priv->vertices;
673
684
                                _tmp169__length1 = self->priv->vertices_length1;
674
685
                                _tmp170_ = i;
675
 
                                _tmp171_ = _tmp169_[_tmp170_];
676
 
                                u = _tmp171_;
677
 
                                _tmp172_ = self->priv->vertices;
678
 
                                _tmp172__length1 = self->priv->vertices_length1;
679
 
                                _tmp173_ = i;
680
 
                                _tmp174_ = _tmp172_[_tmp173_ + 2];
681
 
                                v = _tmp174_;
682
 
                                _tmp175_ = u;
683
 
                                _tmp176_ = u;
684
 
                                _tmp177_ = v;
685
 
                                _tmp178_ = v;
686
 
                                _tmp179_ = sqrt ((gdouble) ((_tmp175_ * _tmp176_) + (_tmp177_ * _tmp178_)));
687
 
                                r = (GLfloat) _tmp179_;
688
 
                                _tmp180_ = r;
689
 
                                if (_tmp180_ != ((GLfloat) 0)) {
690
 
                                        GLfloat _tmp181_;
691
 
                                        GLfloat _tmp182_;
692
 
                                        GLfloat _tmp183_;
693
 
                                        GLfloat _tmp184_;
694
 
                                        _tmp181_ = u;
695
 
                                        _tmp182_ = r;
696
 
                                        u = _tmp181_ / _tmp182_;
697
 
                                        _tmp183_ = v;
698
 
                                        _tmp184_ = r;
699
 
                                        v = _tmp183_ / _tmp184_;
 
686
                                _tmp171_ = _tmp169_[_tmp170_ + 2];
 
687
                                v = _tmp171_;
 
688
                                _tmp172_ = u;
 
689
                                _tmp173_ = u;
 
690
                                _tmp174_ = v;
 
691
                                _tmp175_ = v;
 
692
                                _tmp176_ = sqrt ((gdouble) ((_tmp172_ * _tmp173_) + (_tmp174_ * _tmp175_)));
 
693
                                r = (GLfloat) _tmp176_;
 
694
                                _tmp177_ = r;
 
695
                                if (_tmp177_ != ((GLfloat) 0)) {
 
696
                                        GLfloat _tmp178_ = 0.0F;
 
697
                                        GLfloat _tmp179_ = 0.0F;
 
698
                                        GLfloat _tmp180_ = 0.0F;
 
699
                                        GLfloat _tmp181_ = 0.0F;
 
700
                                        _tmp178_ = u;
 
701
                                        _tmp179_ = r;
 
702
                                        u = _tmp178_ / _tmp179_;
 
703
                                        _tmp180_ = v;
 
704
                                        _tmp181_ = r;
 
705
                                        v = _tmp180_ / _tmp181_;
700
706
                                }
701
 
                                _tmp185_ = self->priv->vertices;
702
 
                                _tmp185__length1 = self->priv->vertices_length1;
703
 
                                _tmp186_ = i;
704
 
                                _tmp187_ = _tmp185_[_tmp186_ + 1];
705
 
                                _tmp188_ = self->priv->max_height;
706
 
                                h = 1.0f - (_tmp187_ / _tmp188_);
707
 
                                _tmp189_ = self->priv->texture_coords;
708
 
                                _tmp189__length1 = self->priv->texture_coords_length1;
709
 
                                _tmp190_ = j;
710
 
                                _tmp191_ = h;
711
 
                                _tmp192_ = u;
712
 
                                _tmp189_[_tmp190_] = (GLfloat) (0.5f + ((0.5f * _tmp191_) * _tmp192_));
713
 
                                _tmp193_ = _tmp189_[_tmp190_];
714
 
                                _tmp194_ = self->priv->texture_coords;
715
 
                                _tmp194__length1 = self->priv->texture_coords_length1;
716
 
                                _tmp195_ = j;
717
 
                                _tmp196_ = h;
718
 
                                _tmp197_ = v;
719
 
                                _tmp194_[_tmp195_ + 1] = (GLfloat) (0.5f + ((0.5f * _tmp196_) * _tmp197_));
720
 
                                _tmp198_ = _tmp194_[_tmp195_ + 1];
 
707
                                _tmp182_ = self->priv->vertices;
 
708
                                _tmp182__length1 = self->priv->vertices_length1;
 
709
                                _tmp183_ = i;
 
710
                                _tmp184_ = _tmp182_[_tmp183_ + 1];
 
711
                                _tmp185_ = self->priv->max_height;
 
712
                                h = 1.0f - (_tmp184_ / _tmp185_);
 
713
                                _tmp186_ = self->priv->texture_coords;
 
714
                                _tmp186__length1 = self->priv->texture_coords_length1;
 
715
                                _tmp187_ = j;
 
716
                                _tmp188_ = h;
 
717
                                _tmp189_ = u;
 
718
                                _tmp186_[_tmp187_] = (GLfloat) (0.5f + ((0.5f * _tmp188_) * _tmp189_));
 
719
                                _tmp190_ = _tmp186_[_tmp187_];
 
720
                                _tmp191_ = self->priv->texture_coords;
 
721
                                _tmp191__length1 = self->priv->texture_coords_length1;
 
722
                                _tmp192_ = j;
 
723
                                _tmp193_ = h;
 
724
                                _tmp194_ = v;
 
725
                                _tmp191_[_tmp192_ + 1] = (GLfloat) (0.5f + ((0.5f * _tmp193_) * _tmp194_));
 
726
                                _tmp195_ = _tmp191_[_tmp192_ + 1];
721
727
                        }
722
728
                }
723
729
        }
 
730
        _g_object_unref0 (_tmp2_);
724
731
        _g_object_unref0 (stream);
725
732
        return self;
726
733
}
732
739
 
733
740
 
734
741
static void tds_model_parse_block (TDSModel* self, GFileInputStream* stream, gint64 length, GError** error) {
735
 
        gint64 _tmp109_;
 
742
        gint64 _tmp106_ = 0LL;
736
743
        GError * _inner_error_ = NULL;
737
744
        g_return_if_fail (self != NULL);
738
745
        g_return_if_fail (stream != NULL);
739
746
        while (TRUE) {
740
 
                gint64 _tmp0_;
741
 
                GFileInputStream* _tmp1_;
 
747
                gint64 _tmp0_ = 0LL;
 
748
                guint16 id = 0U;
 
749
                GFileInputStream* _tmp1_ = NULL;
742
750
                guint16 _tmp2_ = 0U;
743
 
                guint16 id;
744
 
                GFileInputStream* _tmp3_;
 
751
                gint64 block_length = 0LL;
 
752
                GFileInputStream* _tmp3_ = NULL;
745
753
                guint32 _tmp4_ = 0U;
746
 
                gint64 block_length;
747
 
                gint64 _tmp5_;
748
 
                gint64 _tmp6_;
749
 
                gint64 _tmp7_;
750
 
                guint16 _tmp12_;
751
 
                gint64 _tmp107_;
752
 
                gint64 _tmp108_;
 
754
                gint64 _tmp5_ = 0LL;
 
755
                gint64 _tmp6_ = 0LL;
 
756
                gint64 _tmp7_ = 0LL;
 
757
                guint16 _tmp12_ = 0U;
 
758
                gint64 _tmp104_ = 0LL;
 
759
                gint64 _tmp105_ = 0LL;
753
760
                _tmp0_ = length;
754
761
                if (!(_tmp0_ > ((gint64) 6))) {
755
762
                        break;
757
764
                _tmp1_ = stream;
758
765
                _tmp2_ = tds_model_read_uint16 (self, (GInputStream*) _tmp1_, &_inner_error_);
759
766
                id = _tmp2_;
760
 
                if (_inner_error_ != NULL) {
 
767
                if (G_UNLIKELY (_inner_error_ != NULL)) {
761
768
                        g_propagate_error (error, _inner_error_);
762
769
                        return;
763
770
                }
764
771
                _tmp3_ = stream;
765
772
                _tmp4_ = tds_model_read_uint32 (self, (GInputStream*) _tmp3_, &_inner_error_);
766
773
                block_length = (gint64) _tmp4_;
767
 
                if (_inner_error_ != NULL) {
 
774
                if (G_UNLIKELY (_inner_error_ != NULL)) {
768
775
                        g_propagate_error (error, _inner_error_);
769
776
                        return;
770
777
                }
775
782
                _tmp6_ = block_length;
776
783
                _tmp7_ = length;
777
784
                if (_tmp6_ > _tmp7_) {
778
 
                        FILE* _tmp8_;
779
 
                        gint64 _tmp9_;
780
 
                        guint16 _tmp10_;
781
 
                        gint64 _tmp11_;
 
785
                        FILE* _tmp8_ = NULL;
 
786
                        gint64 _tmp9_ = 0LL;
 
787
                        guint16 _tmp10_ = 0U;
 
788
                        gint64 _tmp11_ = 0LL;
782
789
                        _tmp8_ = stderr;
783
790
                        _tmp9_ = block_length;
784
791
                        _tmp10_ = id;
790
797
                switch (_tmp12_) {
791
798
                        case 0x4D4D:
792
799
                        {
793
 
                                GFileInputStream* _tmp13_;
794
 
                                gint64 _tmp14_;
 
800
                                GFileInputStream* _tmp13_ = NULL;
 
801
                                gint64 _tmp14_ = 0LL;
795
802
                                _tmp13_ = stream;
796
803
                                _tmp14_ = block_length;
797
804
                                tds_model_parse_block (self, _tmp13_, _tmp14_ - 6, &_inner_error_);
798
 
                                if (_inner_error_ != NULL) {
 
805
                                if (G_UNLIKELY (_inner_error_ != NULL)) {
799
806
                                        g_propagate_error (error, _inner_error_);
800
807
                                        return;
801
808
                                }
803
810
                        }
804
811
                        case 0x3D3D:
805
812
                        {
806
 
                                GFileInputStream* _tmp15_;
807
 
                                gint64 _tmp16_;
 
813
                                GFileInputStream* _tmp15_ = NULL;
 
814
                                gint64 _tmp16_ = 0LL;
808
815
                                _tmp15_ = stream;
809
816
                                _tmp16_ = block_length;
810
817
                                tds_model_parse_block (self, _tmp15_, _tmp16_ - 6, &_inner_error_);
811
 
                                if (_inner_error_ != NULL) {
 
818
                                if (G_UNLIKELY (_inner_error_ != NULL)) {
812
819
                                        g_propagate_error (error, _inner_error_);
813
820
                                        return;
814
821
                                }
816
823
                        }
817
824
                        case 0x4000:
818
825
                        {
819
 
                                GFileInputStream* _tmp17_;
 
826
                                gchar* name = NULL;
 
827
                                GFileInputStream* _tmp17_ = NULL;
820
828
                                gchar* _tmp18_ = NULL;
821
 
                                gchar* name;
822
 
                                GFileInputStream* _tmp19_;
823
 
                                gint64 _tmp20_;
824
 
                                const gchar* _tmp21_;
825
 
                                gint _tmp22_;
826
 
                                gint _tmp23_;
 
829
                                GFileInputStream* _tmp19_ = NULL;
 
830
                                gint64 _tmp20_ = 0LL;
 
831
                                const gchar* _tmp21_ = NULL;
 
832
                                gint _tmp22_ = 0;
 
833
                                gint _tmp23_ = 0;
827
834
                                _tmp17_ = stream;
828
835
                                _tmp18_ = tds_model_read_string (self, (GInputStream*) _tmp17_, &_inner_error_);
829
836
                                name = _tmp18_;
830
 
                                if (_inner_error_ != NULL) {
 
837
                                if (G_UNLIKELY (_inner_error_ != NULL)) {
831
838
                                        g_propagate_error (error, _inner_error_);
832
839
                                        return;
833
840
                                }
837
844
                                _tmp22_ = strlen (_tmp21_);
838
845
                                _tmp23_ = _tmp22_;
839
846
                                tds_model_parse_block (self, _tmp19_, (_tmp20_ - 6) - (_tmp23_ + 1), &_inner_error_);
840
 
                                if (_inner_error_ != NULL) {
 
847
                                if (G_UNLIKELY (_inner_error_ != NULL)) {
841
848
                                        g_propagate_error (error, _inner_error_);
842
849
                                        _g_free0 (name);
843
850
                                        return;
847
854
                        }
848
855
                        case 0x4100:
849
856
                        {
850
 
                                GFileInputStream* _tmp24_;
851
 
                                gint64 _tmp25_;
 
857
                                GFileInputStream* _tmp24_ = NULL;
 
858
                                gint64 _tmp25_ = 0LL;
852
859
                                _tmp24_ = stream;
853
860
                                _tmp25_ = block_length;
854
861
                                tds_model_parse_block (self, _tmp24_, _tmp25_ - 6, &_inner_error_);
855
 
                                if (_inner_error_ != NULL) {
 
862
                                if (G_UNLIKELY (_inner_error_ != NULL)) {
856
863
                                        g_propagate_error (error, _inner_error_);
857
864
                                        return;
858
865
                                }
860
867
                        }
861
868
                        case 0x4110:
862
869
                        {
863
 
                                GFileInputStream* _tmp26_;
 
870
                                guint16 n = 0U;
 
871
                                GFileInputStream* _tmp26_ = NULL;
864
872
                                guint16 _tmp27_ = 0U;
865
 
                                guint16 n;
866
 
                                guint16 _tmp28_;
 
873
                                guint16 _tmp28_ = 0U;
867
874
                                GLfloat* _tmp29_ = NULL;
868
875
                                _tmp26_ = stream;
869
876
                                _tmp27_ = tds_model_read_uint16 (self, (GInputStream*) _tmp26_, &_inner_error_);
870
877
                                n = _tmp27_;
871
 
                                if (_inner_error_ != NULL) {
 
878
                                if (G_UNLIKELY (_inner_error_ != NULL)) {
872
879
                                        g_propagate_error (error, _inner_error_);
873
880
                                        return;
874
881
                                }
879
886
                                self->priv->vertices_length1 = _tmp28_ * 3;
880
887
                                self->priv->_vertices_size_ = self->priv->vertices_length1;
881
888
                                {
882
 
                                        gint i;
 
889
                                        gint i = 0;
883
890
                                        i = 0;
884
891
                                        {
885
 
                                                gboolean _tmp30_;
 
892
                                                gboolean _tmp30_ = FALSE;
886
893
                                                _tmp30_ = TRUE;
887
894
                                                while (TRUE) {
888
 
                                                        gboolean _tmp31_;
889
 
                                                        gint _tmp33_;
890
 
                                                        guint16 _tmp34_;
891
 
                                                        GFileInputStream* _tmp35_;
892
 
                                                        gfloat _tmp36_ = 0.0F;
893
 
                                                        gfloat x;
894
 
                                                        GFileInputStream* _tmp37_;
895
 
                                                        gfloat _tmp38_ = 0.0F;
896
 
                                                        gfloat y;
897
 
                                                        GFileInputStream* _tmp39_;
898
 
                                                        gfloat _tmp40_ = 0.0F;
899
 
                                                        gfloat z;
900
 
                                                        gfloat scale;
901
 
                                                        GLfloat* _tmp41_;
902
 
                                                        gint _tmp41__length1;
903
 
                                                        gint _tmp42_;
904
 
                                                        gfloat _tmp43_;
905
 
                                                        gfloat _tmp44_;
906
 
                                                        GLfloat _tmp45_;
907
 
                                                        GLfloat* _tmp46_;
908
 
                                                        gint _tmp46__length1;
909
 
                                                        gint _tmp47_;
910
 
                                                        gfloat _tmp48_;
911
 
                                                        gfloat _tmp49_;
912
 
                                                        GLfloat _tmp50_;
913
 
                                                        GLfloat* _tmp51_;
914
 
                                                        gint _tmp51__length1;
915
 
                                                        gint _tmp52_;
916
 
                                                        gfloat _tmp53_;
917
 
                                                        gfloat _tmp54_;
918
 
                                                        GLfloat _tmp55_;
919
 
                                                        gfloat _tmp56_;
920
 
                                                        gfloat _tmp57_;
921
 
                                                        gfloat h;
922
 
                                                        gfloat _tmp58_;
923
 
                                                        GLfloat _tmp59_;
924
 
                                                        gfloat _tmp61_;
925
 
                                                        GLfloat _tmp62_;
926
 
                                                        _tmp31_ = _tmp30_;
927
 
                                                        if (!_tmp31_) {
928
 
                                                                gint _tmp32_;
929
 
                                                                _tmp32_ = i;
930
 
                                                                i = _tmp32_ + 1;
 
895
                                                        gint _tmp32_ = 0;
 
896
                                                        guint16 _tmp33_ = 0U;
 
897
                                                        gfloat x = 0.0F;
 
898
                                                        GFileInputStream* _tmp34_ = NULL;
 
899
                                                        gfloat _tmp35_ = 0.0F;
 
900
                                                        gfloat y = 0.0F;
 
901
                                                        GFileInputStream* _tmp36_ = NULL;
 
902
                                                        gfloat _tmp37_ = 0.0F;
 
903
                                                        gfloat z = 0.0F;
 
904
                                                        GFileInputStream* _tmp38_ = NULL;
 
905
                                                        gfloat _tmp39_ = 0.0F;
 
906
                                                        gfloat scale = 0.0F;
 
907
                                                        GLfloat* _tmp40_ = NULL;
 
908
                                                        gint _tmp40__length1 = 0;
 
909
                                                        gint _tmp41_ = 0;
 
910
                                                        gfloat _tmp42_ = 0.0F;
 
911
                                                        gfloat _tmp43_ = 0.0F;
 
912
                                                        GLfloat _tmp44_ = 0.0F;
 
913
                                                        GLfloat* _tmp45_ = NULL;
 
914
                                                        gint _tmp45__length1 = 0;
 
915
                                                        gint _tmp46_ = 0;
 
916
                                                        gfloat _tmp47_ = 0.0F;
 
917
                                                        gfloat _tmp48_ = 0.0F;
 
918
                                                        GLfloat _tmp49_ = 0.0F;
 
919
                                                        GLfloat* _tmp50_ = NULL;
 
920
                                                        gint _tmp50__length1 = 0;
 
921
                                                        gint _tmp51_ = 0;
 
922
                                                        gfloat _tmp52_ = 0.0F;
 
923
                                                        gfloat _tmp53_ = 0.0F;
 
924
                                                        GLfloat _tmp54_ = 0.0F;
 
925
                                                        gfloat h = 0.0F;
 
926
                                                        gfloat _tmp55_ = 0.0F;
 
927
                                                        gfloat _tmp56_ = 0.0F;
 
928
                                                        gfloat _tmp57_ = 0.0F;
 
929
                                                        GLfloat _tmp58_ = 0.0F;
 
930
                                                        gfloat _tmp60_ = 0.0F;
 
931
                                                        GLfloat _tmp61_ = 0.0F;
 
932
                                                        if (!_tmp30_) {
 
933
                                                                gint _tmp31_ = 0;
 
934
                                                                _tmp31_ = i;
 
935
                                                                i = _tmp31_ + 1;
931
936
                                                        }
932
937
                                                        _tmp30_ = FALSE;
933
 
                                                        _tmp33_ = i;
934
 
                                                        _tmp34_ = n;
935
 
                                                        if (!(_tmp33_ < ((gint) _tmp34_))) {
 
938
                                                        _tmp32_ = i;
 
939
                                                        _tmp33_ = n;
 
940
                                                        if (!(_tmp32_ < ((gint) _tmp33_))) {
936
941
                                                                break;
937
942
                                                        }
938
 
                                                        _tmp35_ = stream;
939
 
                                                        _tmp36_ = tds_model_read_float (self, (GInputStream*) _tmp35_, &_inner_error_);
940
 
                                                        x = _tmp36_;
941
 
                                                        if (_inner_error_ != NULL) {
942
 
                                                                g_propagate_error (error, _inner_error_);
943
 
                                                                return;
944
 
                                                        }
945
 
                                                        _tmp37_ = stream;
946
 
                                                        _tmp38_ = tds_model_read_float (self, (GInputStream*) _tmp37_, &_inner_error_);
947
 
                                                        y = _tmp38_;
948
 
                                                        if (_inner_error_ != NULL) {
949
 
                                                                g_propagate_error (error, _inner_error_);
950
 
                                                                return;
951
 
                                                        }
952
 
                                                        _tmp39_ = stream;
953
 
                                                        _tmp40_ = tds_model_read_float (self, (GInputStream*) _tmp39_, &_inner_error_);
954
 
                                                        z = _tmp40_;
955
 
                                                        if (_inner_error_ != NULL) {
 
943
                                                        _tmp34_ = stream;
 
944
                                                        _tmp35_ = tds_model_read_float (self, (GInputStream*) _tmp34_, &_inner_error_);
 
945
                                                        x = _tmp35_;
 
946
                                                        if (G_UNLIKELY (_inner_error_ != NULL)) {
 
947
                                                                g_propagate_error (error, _inner_error_);
 
948
                                                                return;
 
949
                                                        }
 
950
                                                        _tmp36_ = stream;
 
951
                                                        _tmp37_ = tds_model_read_float (self, (GInputStream*) _tmp36_, &_inner_error_);
 
952
                                                        y = _tmp37_;
 
953
                                                        if (G_UNLIKELY (_inner_error_ != NULL)) {
 
954
                                                                g_propagate_error (error, _inner_error_);
 
955
                                                                return;
 
956
                                                        }
 
957
                                                        _tmp38_ = stream;
 
958
                                                        _tmp39_ = tds_model_read_float (self, (GInputStream*) _tmp38_, &_inner_error_);
 
959
                                                        z = _tmp39_;
 
960
                                                        if (G_UNLIKELY (_inner_error_ != NULL)) {
956
961
                                                                g_propagate_error (error, _inner_error_);
957
962
                                                                return;
958
963
                                                        }
959
964
                                                        scale = 3.5f;
960
 
                                                        _tmp41_ = self->priv->vertices;
961
 
                                                        _tmp41__length1 = self->priv->vertices_length1;
962
 
                                                        _tmp42_ = i;
963
 
                                                        _tmp43_ = scale;
964
 
                                                        _tmp44_ = x;
965
 
                                                        _tmp41_[_tmp42_ * 3] = (GLfloat) (_tmp43_ * _tmp44_);
966
 
                                                        _tmp45_ = _tmp41_[_tmp42_ * 3];
967
 
                                                        _tmp46_ = self->priv->vertices;
968
 
                                                        _tmp46__length1 = self->priv->vertices_length1;
969
 
                                                        _tmp47_ = i;
970
 
                                                        _tmp48_ = scale;
971
 
                                                        _tmp49_ = z;
972
 
                                                        _tmp46_[(_tmp47_ * 3) + 1] = (GLfloat) (_tmp48_ * _tmp49_);
973
 
                                                        _tmp50_ = _tmp46_[(_tmp47_ * 3) + 1];
974
 
                                                        _tmp51_ = self->priv->vertices;
975
 
                                                        _tmp51__length1 = self->priv->vertices_length1;
976
 
                                                        _tmp52_ = i;
977
 
                                                        _tmp53_ = scale;
978
 
                                                        _tmp54_ = y;
979
 
                                                        _tmp51_[(_tmp52_ * 3) + 2] = (GLfloat) (_tmp53_ * _tmp54_);
980
 
                                                        _tmp55_ = _tmp51_[(_tmp52_ * 3) + 2];
981
 
                                                        _tmp56_ = scale;
982
 
                                                        _tmp57_ = z;
983
 
                                                        h = _tmp56_ * _tmp57_;
984
 
                                                        _tmp58_ = h;
985
 
                                                        _tmp59_ = self->priv->min_height;
986
 
                                                        if (_tmp58_ < ((gfloat) _tmp59_)) {
987
 
                                                                gfloat _tmp60_;
988
 
                                                                _tmp60_ = h;
989
 
                                                                self->priv->min_height = (GLfloat) _tmp60_;
 
965
                                                        _tmp40_ = self->priv->vertices;
 
966
                                                        _tmp40__length1 = self->priv->vertices_length1;
 
967
                                                        _tmp41_ = i;
 
968
                                                        _tmp42_ = scale;
 
969
                                                        _tmp43_ = x;
 
970
                                                        _tmp40_[_tmp41_ * 3] = (GLfloat) (_tmp42_ * _tmp43_);
 
971
                                                        _tmp44_ = _tmp40_[_tmp41_ * 3];
 
972
                                                        _tmp45_ = self->priv->vertices;
 
973
                                                        _tmp45__length1 = self->priv->vertices_length1;
 
974
                                                        _tmp46_ = i;
 
975
                                                        _tmp47_ = scale;
 
976
                                                        _tmp48_ = z;
 
977
                                                        _tmp45_[(_tmp46_ * 3) + 1] = (GLfloat) (_tmp47_ * _tmp48_);
 
978
                                                        _tmp49_ = _tmp45_[(_tmp46_ * 3) + 1];
 
979
                                                        _tmp50_ = self->priv->vertices;
 
980
                                                        _tmp50__length1 = self->priv->vertices_length1;
 
981
                                                        _tmp51_ = i;
 
982
                                                        _tmp52_ = scale;
 
983
                                                        _tmp53_ = y;
 
984
                                                        _tmp50_[(_tmp51_ * 3) + 2] = (GLfloat) (_tmp52_ * _tmp53_);
 
985
                                                        _tmp54_ = _tmp50_[(_tmp51_ * 3) + 2];
 
986
                                                        _tmp55_ = scale;
 
987
                                                        _tmp56_ = z;
 
988
                                                        h = _tmp55_ * _tmp56_;
 
989
                                                        _tmp57_ = h;
 
990
                                                        _tmp58_ = self->priv->min_height;
 
991
                                                        if (_tmp57_ < ((gfloat) _tmp58_)) {
 
992
                                                                gfloat _tmp59_ = 0.0F;
 
993
                                                                _tmp59_ = h;
 
994
                                                                self->priv->min_height = (GLfloat) _tmp59_;
990
995
                                                        }
991
 
                                                        _tmp61_ = h;
992
 
                                                        _tmp62_ = self->priv->max_height;
993
 
                                                        if (_tmp61_ > ((gfloat) _tmp62_)) {
994
 
                                                                gfloat _tmp63_;
995
 
                                                                _tmp63_ = h;
996
 
                                                                self->priv->max_height = (GLfloat) _tmp63_;
 
996
                                                        _tmp60_ = h;
 
997
                                                        _tmp61_ = self->priv->max_height;
 
998
                                                        if (_tmp60_ > ((gfloat) _tmp61_)) {
 
999
                                                                gfloat _tmp62_ = 0.0F;
 
1000
                                                                _tmp62_ = h;
 
1001
                                                                self->priv->max_height = (GLfloat) _tmp62_;
997
1002
                                                        }
998
1003
                                                }
999
1004
                                        }
1002
1007
                        }
1003
1008
                        case 0x4120:
1004
1009
                        {
1005
 
                                gint64 _tmp64_;
1006
 
                                GFileInputStream* _tmp65_;
 
1010
                                gint64 _tmp63_ = 0LL;
 
1011
                                guint16 n = 0U;
 
1012
                                GFileInputStream* _tmp64_ = NULL;
 
1013
                                guint16 _tmp65_ = 0U;
1007
1014
                                guint16 _tmp66_ = 0U;
1008
 
                                guint16 n;
1009
 
                                guint16 _tmp67_;
1010
 
                                GLushort* _tmp68_ = NULL;
1011
 
                                gint64 _tmp69_;
1012
 
                                guint16 _tmp70_;
1013
 
                                GFileInputStream* _tmp98_;
1014
 
                                gint64 _tmp99_;
1015
 
                                guint16 _tmp100_;
1016
 
                                _tmp64_ = block_length;
1017
 
                                if (_tmp64_ < ((gint64) 2)) {
 
1015
                                GLushort* _tmp67_ = NULL;
 
1016
                                gint64 _tmp68_ = 0LL;
 
1017
                                guint16 _tmp69_ = 0U;
 
1018
                                GFileInputStream* _tmp96_ = NULL;
 
1019
                                gint64 _tmp97_ = 0LL;
 
1020
                                guint16 _tmp98_ = 0U;
 
1021
                                _tmp63_ = block_length;
 
1022
                                if (_tmp63_ < ((gint64) 2)) {
1018
1023
                                        return;
1019
1024
                                }
1020
 
                                _tmp65_ = stream;
1021
 
                                _tmp66_ = tds_model_read_uint16 (self, (GInputStream*) _tmp65_, &_inner_error_);
1022
 
                                n = _tmp66_;
1023
 
                                if (_inner_error_ != NULL) {
 
1025
                                _tmp64_ = stream;
 
1026
                                _tmp65_ = tds_model_read_uint16 (self, (GInputStream*) _tmp64_, &_inner_error_);
 
1027
                                n = _tmp65_;
 
1028
                                if (G_UNLIKELY (_inner_error_ != NULL)) {
1024
1029
                                        g_propagate_error (error, _inner_error_);
1025
1030
                                        return;
1026
1031
                                }
1027
 
                                _tmp67_ = n;
1028
 
                                _tmp68_ = g_new0 (GLushort, _tmp67_ * 3);
 
1032
                                _tmp66_ = n;
 
1033
                                _tmp67_ = g_new0 (GLushort, _tmp66_ * 3);
1029
1034
                                self->priv->triangles = (g_free (self->priv->triangles), NULL);
1030
 
                                self->priv->triangles = _tmp68_;
1031
 
                                self->priv->triangles_length1 = _tmp67_ * 3;
 
1035
                                self->priv->triangles = _tmp67_;
 
1036
                                self->priv->triangles_length1 = _tmp66_ * 3;
1032
1037
                                self->priv->_triangles_size_ = self->priv->triangles_length1;
1033
 
                                _tmp69_ = block_length;
1034
 
                                _tmp70_ = n;
1035
 
                                if (_tmp69_ < ((gint64) (2 + (_tmp70_ * 8)))) {
1036
 
                                        FILE* _tmp71_;
1037
 
                                        guint16 _tmp72_;
1038
 
                                        gint64 _tmp73_;
1039
 
                                        _tmp71_ = stderr;
1040
 
                                        _tmp72_ = n;
1041
 
                                        _tmp73_ = block_length;
1042
 
                                        fprintf (_tmp71_, "Invalid face data, need %u, have %lli\n", (guint) (2 + (_tmp72_ * 8)), _tmp73_);
 
1038
                                _tmp68_ = block_length;
 
1039
                                _tmp69_ = n;
 
1040
                                if (_tmp68_ < ((gint64) (2 + (_tmp69_ * 8)))) {
 
1041
                                        FILE* _tmp70_ = NULL;
 
1042
                                        guint16 _tmp71_ = 0U;
 
1043
                                        gint64 _tmp72_ = 0LL;
 
1044
                                        _tmp70_ = stderr;
 
1045
                                        _tmp71_ = n;
 
1046
                                        _tmp72_ = block_length;
 
1047
                                        fprintf (_tmp70_, "Invalid face data, need %u, have %lli\n", (guint) (2 + (_tmp71_ * 8)), _tmp72_);
1043
1048
                                        return;
1044
1049
                                }
1045
1050
                                {
1046
 
                                        gint i;
 
1051
                                        gint i = 0;
1047
1052
                                        i = 0;
1048
1053
                                        {
1049
 
                                                gboolean _tmp74_;
1050
 
                                                _tmp74_ = TRUE;
 
1054
                                                gboolean _tmp73_ = FALSE;
 
1055
                                                _tmp73_ = TRUE;
1051
1056
                                                while (TRUE) {
1052
 
                                                        gboolean _tmp75_;
1053
 
                                                        gint _tmp77_;
1054
 
                                                        guint16 _tmp78_;
1055
 
                                                        GFileInputStream* _tmp79_;
 
1057
                                                        gint _tmp75_ = 0;
 
1058
                                                        guint16 _tmp76_ = 0U;
 
1059
                                                        guint16 a = 0U;
 
1060
                                                        GFileInputStream* _tmp77_ = NULL;
 
1061
                                                        guint16 _tmp78_ = 0U;
 
1062
                                                        guint16 b = 0U;
 
1063
                                                        GFileInputStream* _tmp79_ = NULL;
1056
1064
                                                        guint16 _tmp80_ = 0U;
1057
 
                                                        guint16 a;
1058
 
                                                        GFileInputStream* _tmp81_;
 
1065
                                                        guint16 c = 0U;
 
1066
                                                        GFileInputStream* _tmp81_ = NULL;
1059
1067
                                                        guint16 _tmp82_ = 0U;
1060
 
                                                        guint16 b;
1061
 
                                                        GFileInputStream* _tmp83_;
1062
 
                                                        guint16 _tmp84_ = 0U;
1063
 
                                                        guint16 c;
1064
 
                                                        GFileInputStream* _tmp85_;
1065
 
                                                        GLushort* _tmp86_;
1066
 
                                                        gint _tmp86__length1;
1067
 
                                                        gint _tmp87_;
1068
 
                                                        guint16 _tmp88_;
1069
 
                                                        GLushort _tmp89_;
1070
 
                                                        GLushort* _tmp90_;
1071
 
                                                        gint _tmp90__length1;
1072
 
                                                        gint _tmp91_;
1073
 
                                                        guint16 _tmp92_;
1074
 
                                                        GLushort _tmp93_;
1075
 
                                                        GLushort* _tmp94_;
1076
 
                                                        gint _tmp94__length1;
1077
 
                                                        gint _tmp95_;
1078
 
                                                        guint16 _tmp96_;
1079
 
                                                        GLushort _tmp97_;
1080
 
                                                        _tmp75_ = _tmp74_;
1081
 
                                                        if (!_tmp75_) {
1082
 
                                                                gint _tmp76_;
1083
 
                                                                _tmp76_ = i;
1084
 
                                                                i = _tmp76_ + 1;
 
1068
                                                        GFileInputStream* _tmp83_ = NULL;
 
1069
                                                        GLushort* _tmp84_ = NULL;
 
1070
                                                        gint _tmp84__length1 = 0;
 
1071
                                                        gint _tmp85_ = 0;
 
1072
                                                        guint16 _tmp86_ = 0U;
 
1073
                                                        GLushort _tmp87_ = 0U;
 
1074
                                                        GLushort* _tmp88_ = NULL;
 
1075
                                                        gint _tmp88__length1 = 0;
 
1076
                                                        gint _tmp89_ = 0;
 
1077
                                                        guint16 _tmp90_ = 0U;
 
1078
                                                        GLushort _tmp91_ = 0U;
 
1079
                                                        GLushort* _tmp92_ = NULL;
 
1080
                                                        gint _tmp92__length1 = 0;
 
1081
                                                        gint _tmp93_ = 0;
 
1082
                                                        guint16 _tmp94_ = 0U;
 
1083
                                                        GLushort _tmp95_ = 0U;
 
1084
                                                        if (!_tmp73_) {
 
1085
                                                                gint _tmp74_ = 0;
 
1086
                                                                _tmp74_ = i;
 
1087
                                                                i = _tmp74_ + 1;
1085
1088
                                                        }
1086
 
                                                        _tmp74_ = FALSE;
1087
 
                                                        _tmp77_ = i;
1088
 
                                                        _tmp78_ = n;
1089
 
                                                        if (!(_tmp77_ < ((gint) _tmp78_))) {
 
1089
                                                        _tmp73_ = FALSE;
 
1090
                                                        _tmp75_ = i;
 
1091
                                                        _tmp76_ = n;
 
1092
                                                        if (!(_tmp75_ < ((gint) _tmp76_))) {
1090
1093
                                                                break;
1091
1094
                                                        }
 
1095
                                                        _tmp77_ = stream;
 
1096
                                                        _tmp78_ = tds_model_read_uint16 (self, (GInputStream*) _tmp77_, &_inner_error_);
 
1097
                                                        a = _tmp78_;
 
1098
                                                        if (G_UNLIKELY (_inner_error_ != NULL)) {
 
1099
                                                                g_propagate_error (error, _inner_error_);
 
1100
                                                                return;
 
1101
                                                        }
1092
1102
                                                        _tmp79_ = stream;
1093
1103
                                                        _tmp80_ = tds_model_read_uint16 (self, (GInputStream*) _tmp79_, &_inner_error_);
1094
 
                                                        a = _tmp80_;
1095
 
                                                        if (_inner_error_ != NULL) {
 
1104
                                                        b = _tmp80_;
 
1105
                                                        if (G_UNLIKELY (_inner_error_ != NULL)) {
1096
1106
                                                                g_propagate_error (error, _inner_error_);
1097
1107
                                                                return;
1098
1108
                                                        }
1099
1109
                                                        _tmp81_ = stream;
1100
1110
                                                        _tmp82_ = tds_model_read_uint16 (self, (GInputStream*) _tmp81_, &_inner_error_);
1101
 
                                                        b = _tmp82_;
1102
 
                                                        if (_inner_error_ != NULL) {
 
1111
                                                        c = _tmp82_;
 
1112
                                                        if (G_UNLIKELY (_inner_error_ != NULL)) {
1103
1113
                                                                g_propagate_error (error, _inner_error_);
1104
1114
                                                                return;
1105
1115
                                                        }
1106
1116
                                                        _tmp83_ = stream;
1107
 
                                                        _tmp84_ = tds_model_read_uint16 (self, (GInputStream*) _tmp83_, &_inner_error_);
1108
 
                                                        c = _tmp84_;
1109
 
                                                        if (_inner_error_ != NULL) {
1110
 
                                                                g_propagate_error (error, _inner_error_);
1111
 
                                                                return;
1112
 
                                                        }
1113
 
                                                        _tmp85_ = stream;
1114
 
                                                        tds_model_read_uint16 (self, (GInputStream*) _tmp85_, &_inner_error_);
1115
 
                                                        if (_inner_error_ != NULL) {
1116
 
                                                                g_propagate_error (error, _inner_error_);
1117
 
                                                                return;
1118
 
                                                        }
1119
 
                                                        _tmp86_ = self->priv->triangles;
1120
 
                                                        _tmp86__length1 = self->priv->triangles_length1;
1121
 
                                                        _tmp87_ = i;
1122
 
                                                        _tmp88_ = a;
1123
 
                                                        _tmp86_[_tmp87_ * 3] = (GLushort) _tmp88_;
1124
 
                                                        _tmp89_ = _tmp86_[_tmp87_ * 3];
1125
 
                                                        _tmp90_ = self->priv->triangles;
1126
 
                                                        _tmp90__length1 = self->priv->triangles_length1;
1127
 
                                                        _tmp91_ = i;
1128
 
                                                        _tmp92_ = c;
1129
 
                                                        _tmp90_[(_tmp91_ * 3) + 1] = (GLushort) _tmp92_;
1130
 
                                                        _tmp93_ = _tmp90_[(_tmp91_ * 3) + 1];
1131
 
                                                        _tmp94_ = self->priv->triangles;
1132
 
                                                        _tmp94__length1 = self->priv->triangles_length1;
1133
 
                                                        _tmp95_ = i;
1134
 
                                                        _tmp96_ = b;
1135
 
                                                        _tmp94_[(_tmp95_ * 3) + 2] = (GLushort) _tmp96_;
1136
 
                                                        _tmp97_ = _tmp94_[(_tmp95_ * 3) + 2];
 
1117
                                                        tds_model_read_uint16 (self, (GInputStream*) _tmp83_, &_inner_error_);
 
1118
                                                        if (G_UNLIKELY (_inner_error_ != NULL)) {
 
1119
                                                                g_propagate_error (error, _inner_error_);
 
1120
                                                                return;
 
1121
                                                        }
 
1122
                                                        _tmp84_ = self->priv->triangles;
 
1123
                                                        _tmp84__length1 = self->priv->triangles_length1;
 
1124
                                                        _tmp85_ = i;
 
1125
                                                        _tmp86_ = a;
 
1126
                                                        _tmp84_[_tmp85_ * 3] = (GLushort) _tmp86_;
 
1127
                                                        _tmp87_ = _tmp84_[_tmp85_ * 3];
 
1128
                                                        _tmp88_ = self->priv->triangles;
 
1129
                                                        _tmp88__length1 = self->priv->triangles_length1;
 
1130
                                                        _tmp89_ = i;
 
1131
                                                        _tmp90_ = c;
 
1132
                                                        _tmp88_[(_tmp89_ * 3) + 1] = (GLushort) _tmp90_;
 
1133
                                                        _tmp91_ = _tmp88_[(_tmp89_ * 3) + 1];
 
1134
                                                        _tmp92_ = self->priv->triangles;
 
1135
                                                        _tmp92__length1 = self->priv->triangles_length1;
 
1136
                                                        _tmp93_ = i;
 
1137
                                                        _tmp94_ = b;
 
1138
                                                        _tmp92_[(_tmp93_ * 3) + 2] = (GLushort) _tmp94_;
 
1139
                                                        _tmp95_ = _tmp92_[(_tmp93_ * 3) + 2];
1137
1140
                                                }
1138
1141
                                        }
1139
1142
                                }
1140
 
                                _tmp98_ = stream;
1141
 
                                _tmp99_ = block_length;
1142
 
                                _tmp100_ = n;
1143
 
                                tds_model_parse_block (self, _tmp98_, _tmp99_ - (2 + (_tmp100_ * 8)), &_inner_error_);
1144
 
                                if (_inner_error_ != NULL) {
 
1143
                                _tmp96_ = stream;
 
1144
                                _tmp97_ = block_length;
 
1145
                                _tmp98_ = n;
 
1146
                                tds_model_parse_block (self, _tmp96_, _tmp97_ - (2 + (_tmp98_ * 8)), &_inner_error_);
 
1147
                                if (G_UNLIKELY (_inner_error_ != NULL)) {
1145
1148
                                        g_propagate_error (error, _inner_error_);
1146
1149
                                        return;
1147
1150
                                }
1150
1153
                        default:
1151
1154
                        {
1152
1155
                                {
1153
 
                                        gint i;
 
1156
                                        gint i = 0;
1154
1157
                                        i = 0;
1155
1158
                                        {
1156
 
                                                gboolean _tmp101_;
1157
 
                                                _tmp101_ = TRUE;
 
1159
                                                gboolean _tmp99_ = FALSE;
 
1160
                                                _tmp99_ = TRUE;
1158
1161
                                                while (TRUE) {
1159
 
                                                        gboolean _tmp102_;
1160
 
                                                        gint _tmp104_;
1161
 
                                                        gint64 _tmp105_;
1162
 
                                                        GFileInputStream* _tmp106_;
1163
 
                                                        _tmp102_ = _tmp101_;
1164
 
                                                        if (!_tmp102_) {
1165
 
                                                                gint _tmp103_;
1166
 
                                                                _tmp103_ = i;
1167
 
                                                                i = _tmp103_ + 1;
 
1162
                                                        gint _tmp101_ = 0;
 
1163
                                                        gint64 _tmp102_ = 0LL;
 
1164
                                                        GFileInputStream* _tmp103_ = NULL;
 
1165
                                                        if (!_tmp99_) {
 
1166
                                                                gint _tmp100_ = 0;
 
1167
                                                                _tmp100_ = i;
 
1168
                                                                i = _tmp100_ + 1;
1168
1169
                                                        }
1169
 
                                                        _tmp101_ = FALSE;
1170
 
                                                        _tmp104_ = i;
1171
 
                                                        _tmp105_ = block_length;
1172
 
                                                        if (!(((gint64) _tmp104_) < (_tmp105_ - 6))) {
 
1170
                                                        _tmp99_ = FALSE;
 
1171
                                                        _tmp101_ = i;
 
1172
                                                        _tmp102_ = block_length;
 
1173
                                                        if (!(((gint64) _tmp101_) < (_tmp102_ - 6))) {
1173
1174
                                                                break;
1174
1175
                                                        }
1175
 
                                                        _tmp106_ = stream;
1176
 
                                                        tds_model_read_uint8 (self, (GInputStream*) _tmp106_, &_inner_error_);
1177
 
                                                        if (_inner_error_ != NULL) {
 
1176
                                                        _tmp103_ = stream;
 
1177
                                                        tds_model_read_uint8 (self, (GInputStream*) _tmp103_, &_inner_error_);
 
1178
                                                        if (G_UNLIKELY (_inner_error_ != NULL)) {
1178
1179
                                                                g_propagate_error (error, _inner_error_);
1179
1180
                                                                return;
1180
1181
                                                        }
1184
1185
                                break;
1185
1186
                        }
1186
1187
                }
1187
 
                _tmp107_ = length;
1188
 
                _tmp108_ = block_length;
1189
 
                length = _tmp107_ - _tmp108_;
 
1188
                _tmp104_ = length;
 
1189
                _tmp105_ = block_length;
 
1190
                length = _tmp104_ - _tmp105_;
1190
1191
        }
1191
 
        _tmp109_ = length;
1192
 
        if (_tmp109_ != ((gint64) 0)) {
 
1192
        _tmp106_ = length;
 
1193
        if (_tmp106_ != ((gint64) 0)) {
1193
1194
                return;
1194
1195
        }
1195
1196
}
1196
1197
 
1197
1198
 
1198
1199
void tds_model_render (TDSModel* self) {
1199
 
        GLfloat* _tmp0_;
1200
 
        gint _tmp0__length1;
1201
 
        GLfloat* _tmp1_;
1202
 
        gint _tmp1__length1;
1203
 
        GLfloat* _tmp2_;
1204
 
        gint _tmp2__length1;
1205
 
        GLushort* _tmp3_;
1206
 
        gint _tmp3__length1;
1207
 
        GLushort* _tmp4_;
1208
 
        gint _tmp4__length1;
 
1200
        GLfloat* _tmp0_ = NULL;
 
1201
        gint _tmp0__length1 = 0;
 
1202
        GLfloat* _tmp1_ = NULL;
 
1203
        gint _tmp1__length1 = 0;
 
1204
        GLfloat* _tmp2_ = NULL;
 
1205
        gint _tmp2__length1 = 0;
 
1206
        GLushort* _tmp3_ = NULL;
 
1207
        gint _tmp3__length1 = 0;
 
1208
        GLushort* _tmp4_ = NULL;
 
1209
        gint _tmp4__length1 = 0;
1209
1210
        g_return_if_fail (self != NULL);
1210
1211
        glEnable (GL_CULL_FACE);
1211
1212
        glEnableClientState (GL_VERTEX_ARRAY);
1234
1235
static guint8 tds_model_read_uint8 (TDSModel* self, GInputStream* stream, GError** error) {
1235
1236
        guint8 result = 0U;
1236
1237
        guchar buffer[1] = {0};
1237
 
        GInputStream* _tmp0_;
1238
 
        guchar _tmp1_;
 
1238
        GInputStream* _tmp0_ = NULL;
 
1239
        guchar _tmp1_ = '\0';
1239
1240
        GError * _inner_error_ = NULL;
1240
1241
        g_return_val_if_fail (self != NULL, 0U);
1241
1242
        g_return_val_if_fail (stream != NULL, 0U);
1242
1243
        _tmp0_ = stream;
1243
 
        g_input_stream_read_all (_tmp0_, (void*) buffer, (gsize) 1, NULL, NULL, &_inner_error_);
1244
 
        if (_inner_error_ != NULL) {
 
1244
        g_input_stream_read_all (_tmp0_, buffer, (gsize) 1, NULL, NULL, &_inner_error_);
 
1245
        if (G_UNLIKELY (_inner_error_ != NULL)) {
1245
1246
                g_propagate_error (error, _inner_error_);
1246
1247
                return 0U;
1247
1248
        }
1254
1255
static guint16 tds_model_read_uint16 (TDSModel* self, GInputStream* stream, GError** error) {
1255
1256
        guint16 result = 0U;
1256
1257
        guchar buffer[2] = {0};
1257
 
        GInputStream* _tmp0_;
1258
 
        guchar _tmp1_;
1259
 
        guchar _tmp2_;
 
1258
        GInputStream* _tmp0_ = NULL;
 
1259
        guchar _tmp1_ = '\0';
 
1260
        guchar _tmp2_ = '\0';
1260
1261
        GError * _inner_error_ = NULL;
1261
1262
        g_return_val_if_fail (self != NULL, 0U);
1262
1263
        g_return_val_if_fail (stream != NULL, 0U);
1263
1264
        _tmp0_ = stream;
1264
 
        g_input_stream_read_all (_tmp0_, (void*) buffer, (gsize) 2, NULL, NULL, &_inner_error_);
1265
 
        if (_inner_error_ != NULL) {
 
1265
        g_input_stream_read_all (_tmp0_, buffer, (gsize) 2, NULL, NULL, &_inner_error_);
 
1266
        if (G_UNLIKELY (_inner_error_ != NULL)) {
1266
1267
                g_propagate_error (error, _inner_error_);
1267
1268
                return 0U;
1268
1269
        }
1276
1277
static guint32 tds_model_read_uint32 (TDSModel* self, GInputStream* stream, GError** error) {
1277
1278
        guint32 result = 0U;
1278
1279
        guchar buffer[4] = {0};
1279
 
        GInputStream* _tmp0_;
1280
 
        guchar _tmp1_;
1281
 
        guchar _tmp2_;
1282
 
        guchar _tmp3_;
1283
 
        guchar _tmp4_;
 
1280
        GInputStream* _tmp0_ = NULL;
 
1281
        guchar _tmp1_ = '\0';
 
1282
        guchar _tmp2_ = '\0';
 
1283
        guchar _tmp3_ = '\0';
 
1284
        guchar _tmp4_ = '\0';
1284
1285
        GError * _inner_error_ = NULL;
1285
1286
        g_return_val_if_fail (self != NULL, 0U);
1286
1287
        g_return_val_if_fail (stream != NULL, 0U);
1287
1288
        _tmp0_ = stream;
1288
 
        g_input_stream_read_all (_tmp0_, (void*) buffer, (gsize) 4, NULL, NULL, &_inner_error_);
1289
 
        if (_inner_error_ != NULL) {
 
1289
        g_input_stream_read_all (_tmp0_, buffer, (gsize) 4, NULL, NULL, &_inner_error_);
 
1290
        if (G_UNLIKELY (_inner_error_ != NULL)) {
1290
1291
                g_propagate_error (error, _inner_error_);
1291
1292
                return 0U;
1292
1293
        }
1307
1308
static gfloat tds_model_read_float (TDSModel* self, GInputStream* stream, GError** error) {
1308
1309
        gfloat result = 0.0F;
1309
1310
        guint8 buffer[4] = {0};
1310
 
        GInputStream* _tmp0_;
1311
 
        gfloat* _tmp1_;
1312
 
        gint _tmp1__length1;
1313
 
        gfloat* fbuffer;
1314
 
        gint fbuffer_length1;
1315
 
        gint _fbuffer_size_;
1316
 
        gfloat* _tmp2_;
1317
 
        gint _tmp2__length1;
1318
 
        gfloat _tmp3_;
 
1311
        GInputStream* _tmp0_ = NULL;
 
1312
        gfloat* fbuffer = NULL;
 
1313
        gfloat* _tmp1_ = NULL;
 
1314
        gint _tmp1__length1 = 0;
 
1315
        gint fbuffer_length1 = 0;
 
1316
        gint _fbuffer_size_ = 0;
 
1317
        gfloat* _tmp2_ = NULL;
 
1318
        gint _tmp2__length1 = 0;
 
1319
        gfloat _tmp3_ = 0.0F;
1319
1320
        GError * _inner_error_ = NULL;
1320
1321
        g_return_val_if_fail (self != NULL, 0.0F);
1321
1322
        g_return_val_if_fail (stream != NULL, 0.0F);
1322
1323
        _tmp0_ = stream;
1323
 
        g_input_stream_read_all (_tmp0_, (void*) buffer, (gsize) 4, NULL, NULL, &_inner_error_);
1324
 
        if (_inner_error_ != NULL) {
 
1324
        g_input_stream_read_all (_tmp0_, buffer, (gsize) 4, NULL, NULL, &_inner_error_);
 
1325
        if (G_UNLIKELY (_inner_error_ != NULL)) {
1325
1326
                g_propagate_error (error, _inner_error_);
1326
1327
                return 0.0F;
1327
1328
        }
1341
1342
 
1342
1343
static gchar* tds_model_read_string (TDSModel* self, GInputStream* stream, GError** error) {
1343
1344
        gchar* result = NULL;
1344
 
        GString* _tmp0_;
1345
 
        GString* value;
 
1345
        GString* value = NULL;
 
1346
        GString* _tmp0_ = NULL;
1346
1347
        GError * _inner_error_ = NULL;
1347
1348
        g_return_val_if_fail (self != NULL, NULL);
1348
1349
        g_return_val_if_fail (stream != NULL, NULL);
1349
1350
        _tmp0_ = g_string_new ("");
1350
1351
        value = _tmp0_;
1351
1352
        while (TRUE) {
1352
 
                GInputStream* _tmp1_;
 
1353
                guint8 c = 0U;
 
1354
                GInputStream* _tmp1_ = NULL;
1353
1355
                guint8 _tmp2_ = 0U;
1354
 
                guint8 c;
1355
 
                guint8 _tmp3_;
1356
 
                GString* _tmp7_;
1357
 
                guint8 _tmp8_;
 
1356
                guint8 _tmp3_ = 0U;
 
1357
                GString* _tmp7_ = NULL;
 
1358
                guint8 _tmp8_ = 0U;
1358
1359
                _tmp1_ = stream;
1359
1360
                _tmp2_ = tds_model_read_uint8 (self, _tmp1_, &_inner_error_);
1360
1361
                c = _tmp2_;
1361
 
                if (_inner_error_ != NULL) {
 
1362
                if (G_UNLIKELY (_inner_error_ != NULL)) {
1362
1363
                        g_propagate_error (error, _inner_error_);
1363
1364
                        _g_string_free0 (value);
1364
1365
                        return NULL;
1365
1366
                }
1366
1367
                _tmp3_ = c;
1367
1368
                if (((gint) _tmp3_) == 0) {
1368
 
                        GString* _tmp4_;
1369
 
                        const gchar* _tmp5_;
1370
 
                        gchar* _tmp6_;
 
1369
                        GString* _tmp4_ = NULL;
 
1370
                        const gchar* _tmp5_ = NULL;
 
1371
                        gchar* _tmp6_ = NULL;
1371
1372
                        _tmp4_ = value;
1372
1373
                        _tmp5_ = _tmp4_->str;
1373
1374
                        _tmp6_ = g_strdup (_tmp5_);
1501
1502
 
1502
1503
 
1503
1504
static void tds_model_instance_init (TDSModel * self) {
1504
 
        gfloat _tmp0_;
1505
 
        gfloat _tmp1_;
1506
1505
        self->priv = TDS_MODEL_GET_PRIVATE (self);
1507
 
        _tmp0_ = FLT_MAX;
1508
 
        self->priv->min_height = (GLfloat) _tmp0_;
1509
 
        _tmp1_ = FLT_MIN;
1510
 
        self->priv->max_height = (GLfloat) _tmp1_;
 
1506
        self->priv->min_height = (GLfloat) FLT_MAX;
 
1507
        self->priv->max_height = (GLfloat) FLT_MIN;
1511
1508
        self->ref_count = 1;
1512
1509
}
1513
1510