Object.cpp 16.1 KB
Newer Older
1
#include "Object.h"
Anakin's avatar
Anakin committed
2
#include <iostream>
3
4
5
6
7


/////////////////////////////////////////////////////////////////////////
// public constructor/destructor

Anakin's avatar
Anakin committed
8
Object::Object(const char* path)
9
{
Anakin's avatar
Anakin committed
10
	// open file
11
	fsMesh.open(path, std::ios::in | std::ios::binary);
12

Anakin's avatar
Anakin committed
13
14
	if (!fsMesh.is_open())
		throw std::invalid_argument(std::string("file not found: ") += path);
15

16
17
	// jump to file size information
	fsMesh.seekg(4);
18

19
20
	std::uint32_t tempFileSize;
	std::list<ChunkHeader*> tempMainChunks;
21

22
23
24
	// get all chunks under HEDR
	fsMesh.read(reinterpret_cast<char*>(&tempFileSize), sizeof(tempFileSize));
	loadChunks(tempMainChunks, fsMesh.tellg(), tempFileSize);
25

Anakin's avatar
Anakin committed
26
	// evaluate HEDR subchunks (= find MSH2)
27
	for (std::list<ChunkHeader*>::iterator it = tempMainChunks.begin(); it != tempMainChunks.end(); it++)
28
	{
29
		if (!strcmp("MSH2", (*it)->name))
30
		{
Anakin's avatar
Anakin committed
31
			// get all subchunks
32
33
			std::list<ChunkHeader*> tempMsh2Chunks;
			loadChunks(tempMsh2Chunks, (*it)->position, (*it)->size);
Anakin's avatar
Anakin committed
34

35
36
37
38
39
			// evaluate MSH2 subchunks
			analyseMsh2Chunks(tempMsh2Chunks);

			// clean up
			while (!tempMsh2Chunks.empty())
Anakin's avatar
Anakin committed
40
			{
41
42
				ChunkHeader* tempCursor = tempMsh2Chunks.front();
				tempMsh2Chunks.pop_front();
Anakin's avatar
Anakin committed
43
44
				delete tempCursor;
			}
45
			continue;
46
47
		}
	}
48

49
50
51
52
53
54
55
56
	// clean up
	while (!tempMainChunks.empty())
	{
		ChunkHeader* tempCursor = tempMainChunks.front();
		tempMainChunks.pop_front();
		delete tempCursor;
	}

57
58
59
60
61
62
63
64
	// close file
	fsMesh.close();
}

Object::~Object()
{
	//delete Chunk list;	
}
65
66


67
68
/////////////////////////////////////////////////////////////////////////
// private functions
69

70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
void Object::setModlDefault(Modl * model)
{
	model->name = "";
	model->parent = "";
	model->type = null;
	model->renderFlags = -1;
	model->tran.scale[0] = 0;
	model->tran.scale[1] = 0;
	model->tran.scale[2] = 0;
	model->tran.rotation[0] = 0;
	model->tran.rotation[1] = 0;
	model->tran.rotation[2] = 0;
	model->tran.rotation[3] = 0;
	model->tran.translation[0] = 0;
	model->tran.translation[1] = 0;
	model->tran.translation[2] = 0;
	model->swci.type = -1;
	model->swci.data1 = -1;
	model->swci.data2 = -1;
	model->swci.data3 = -1;
	model->texture = "";
	model->vertex = NULL;
	model->uv = NULL;
	model->mesh = NULL;
Anakin's avatar
Anakin committed
94
	model->meshSize = 0;
95
96
}

Anakin's avatar
Anakin committed
97
void Object::loadChunks(std::list<ChunkHeader*>& destination, std::streampos start, const std::uint32_t end)
98
{
99
	// jump to first chunk
100
	fsMesh.seekg(start);
101

Anakin's avatar
Anakin committed
102
103
	do
	{
Anakin's avatar
Anakin committed
104
		ChunkHeader* tempHeader = new ChunkHeader();
105

106
107
108
		fsMesh.read(reinterpret_cast<char*>(&tempHeader->name[0]), sizeof(tempHeader->name) - 1);
		fsMesh.read(reinterpret_cast<char*>(&tempHeader->size), sizeof(tempHeader->size));
		tempHeader->position = fsMesh.tellg();
109

110
		destination.push_back(tempHeader);
111

112
		fsMesh.seekg(tempHeader->size, std::ios_base::cur);
113

114
115
		// reached end
		if (fsMesh.tellg() - start == end)
Anakin's avatar
Anakin committed
116
			break;
117
118
119
120
121
122
123
124
125
126

		// error. Maybe the size information is corrupted
		if (!fsMesh.good())
		{
			std::cout << "WARNING: corrupted file. Trying to continue" << std::endl;
			fsMesh.clear();
			break;
		}

	} while (true);
127
128
}

129
130
131
132
133
134
void Object::analyseMsh2Chunks(std::list<ChunkHeader*>& chunkList)
{
	for (std::list<ChunkHeader*>::iterator it = chunkList.begin(); it != chunkList.end(); it++)
	{
		if (!strcmp("MATL", (*it)->name))
		{
135
136
137
138
139
			// "useless" information how many MATD follow
			fsMesh.seekg((*it)->position);
			std::uint32_t tempMatdCount;
			fsMesh.read(reinterpret_cast<char*>(&tempMatdCount), sizeof(std::uint32_t));

Anakin's avatar
Anakin committed
140
141
			// get all MATD from MATL list
			std::list<ChunkHeader*> tempMatlChunks;
142
			loadChunks(tempMatlChunks, fsMesh.tellg(), (*it)->size - 4);
Anakin's avatar
Anakin committed
143
144
145
146
147
148
149
150
151
152
153
154

			// evaluate MATL subchunks
			for (std::list<ChunkHeader*>::iterator it = tempMatlChunks.begin(); it != tempMatlChunks.end(); it++)
			{
				// This shouldn't be anything else than MATD
				if (!strcmp("MATD", (*it)->name))
				{
					// get all subchunks from MATD
					std::list<ChunkHeader*> tempMatdChunks;
					loadChunks(tempMatdChunks, (*it)->position, (*it)->size);

					// analyse MATD subchunks
Anakin's avatar
Anakin committed
155
					analyseMatdChunks(tempMatdChunks);
Anakin's avatar
Anakin committed
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173

					// clean up
					while (!tempMatdChunks.empty())
					{
						ChunkHeader* tempCursor = tempMatdChunks.front();
						tempMatdChunks.pop_front();
						delete tempCursor;
					}
				}
			}

			// clean up
			while (!tempMatlChunks.empty())
			{
				ChunkHeader* tempCursor = tempMatlChunks.front();
				tempMatlChunks.pop_front();
				delete tempCursor;
			}
174
175
176
177
178
179

			continue;
		}

		if (!strcmp("MODL", (*it)->name))
		{
Anakin's avatar
Anakin committed
180
181
182
			Modl* tempModl = new Modl;
			setModlDefault(tempModl);

183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
			// get all subchunks
			std::list<ChunkHeader*> tempChunks;
			loadChunks(tempChunks, (*it)->position, (*it)->size);

			// evaluate MODL subchunks
			analyseModlChunks(tempModl, tempChunks);

			//clean up
			while (!tempChunks.empty())
			{
				ChunkHeader* tempCursor = tempChunks.front();
				tempChunks.pop_front();
				delete tempCursor;
			}

Anakin's avatar
Anakin committed
198
199
200
			// save Model data
			lModls.push_back(tempModl);

Anakin's avatar
Anakin committed
201
202
203
204
			continue;
		}
	}
}
205

Anakin's avatar
Anakin committed
206
void Object::analyseMatdChunks(std::list<ChunkHeader*>& chunkList)
Anakin's avatar
Anakin committed
207
208
209
210
211
212
213
214
215
216
217
218
{
	for (std::list<ChunkHeader*>::iterator it = chunkList.begin(); it != chunkList.end(); it++)
	{
		//TX1D, TX2D, TX3D
		if (!strcmp("TX0D", (*it)->name))
		{
			fsMesh.seekg((*it)->position);
			char* buffer = new char[(*it)->size + 1];
			*buffer = { 0 };
			fsMesh.read(buffer, (*it)->size);
			vTextures.push_back(buffer);
			delete buffer;
219
220
221
222
223
			continue;
		}
	}
}

Anakin's avatar
Anakin committed
224
225
226
227
228
229
230
231
232
233
void Object::analyseModlChunks(Modl* dataDestination, std::list<ChunkHeader*>& chunkList)
{
	for (std::list<ChunkHeader*>::iterator it = chunkList.begin(); it != chunkList.end(); it++)
	{
		if (!strcmp("MTYP", (*it)->name))
		{
			fsMesh.seekg((*it)->position);
			std::uint32_t tempType;
			fsMesh.read(reinterpret_cast<char*>(&tempType), sizeof(tempType));
			dataDestination->type = (Mtyp)tempType;
Anakin's avatar
Anakin committed
234
			continue;
Anakin's avatar
Anakin committed
235
236
237
238
239
		}

		if (!strcmp("PRNT", (*it)->name))
		{
			fsMesh.seekg((*it)->position);
240
			char* buffer = new char[(*it)->size];
Anakin's avatar
Anakin committed
241
			*buffer = { 0 };
242
243
244
			fsMesh.read(buffer, (*it)->size); 
			dataDestination->parent = buffer;
			delete buffer;
Anakin's avatar
Anakin committed
245
			continue;
Anakin's avatar
Anakin committed
246
247
248
249
250
		}

		if (!strcmp("NAME", (*it)->name))
		{
			fsMesh.seekg((*it)->position);
251
			char* buffer = new char[(*it)->size];
Anakin's avatar
Anakin committed
252
			*buffer = { 0 };
253
254
			fsMesh.read(buffer, (*it)->size);
			dataDestination->name = buffer;
255
			delete buffer;
Anakin's avatar
Anakin committed
256
			continue;
Anakin's avatar
Anakin committed
257
258
259
260
261
262
		}

		if (!strcmp("FLGS", (*it)->name))
		{
			fsMesh.seekg((*it)->position);
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->renderFlags), sizeof(dataDestination->renderFlags));
Anakin's avatar
Anakin committed
263
			continue;
Anakin's avatar
Anakin committed
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
		}

		if (!strcmp("TRAN", (*it)->name))
		{
			fsMesh.seekg((*it)->position);
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->tran.scale[0]), sizeof(float));
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->tran.scale[1]), sizeof(float));
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->tran.scale[2]), sizeof(float));
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->tran.rotation[0]), sizeof(float));
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->tran.rotation[1]), sizeof(float));
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->tran.rotation[2]), sizeof(float));
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->tran.rotation[3]), sizeof(float));
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->tran.translation[0]), sizeof(float));
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->tran.translation[1]), sizeof(float));
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->tran.translation[2]), sizeof(float));
Anakin's avatar
Anakin committed
279
			continue;
Anakin's avatar
Anakin committed
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
		}

		if (!strcmp("GEOM", (*it)->name))
		{
			// get all subchunks
			std::list<ChunkHeader*> tempGeomChunks;
			loadChunks(tempGeomChunks, (*it)->position, (*it)->size);

			// evaluate GEOM subchunks
			analyseGeomChunks(dataDestination, tempGeomChunks);

			// clean up
			while (!tempGeomChunks.empty())
			{
				ChunkHeader* tempCursor = tempGeomChunks.front();
				tempGeomChunks.pop_front();
				delete tempCursor;
			}
Anakin's avatar
Anakin committed
298
299

			continue;
Anakin's avatar
Anakin committed
300
301
302
303
304
305
306
307
308
		}

		if (!strcmp("SWCI", (*it)->name))
		{
			fsMesh.seekg((*it)->position);
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->swci.type), sizeof(dataDestination->swci.type));
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->swci.data1), sizeof(dataDestination->swci.data1));
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->swci.data2), sizeof(dataDestination->swci.data2));
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->swci.data3), sizeof(dataDestination->swci.data3));
Anakin's avatar
Anakin committed
309
			continue;
Anakin's avatar
Anakin committed
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
		}
	}
}

void Object::analyseGeomChunks(Modl * dataDestination, std::list<ChunkHeader*>& chunkList)
{
	for (std::list<ChunkHeader*>::iterator it = chunkList.begin(); it != chunkList.end(); it++)
	{
		if (!strcmp("SEGM", (*it)->name))
		{
			// get all subchunks
			std::list<ChunkHeader*> tempSegmChunks;
			loadChunks(tempSegmChunks, (*it)->position, (*it)->size);

			// evaluate SEGM subchunks
			analyseSegmChunks(dataDestination, tempSegmChunks);

			// clean up
			while (!tempSegmChunks.empty())
			{
				ChunkHeader* tempCursor = tempSegmChunks.front();
				tempSegmChunks.pop_front();
				delete tempCursor;
			}
Anakin's avatar
Anakin committed
334
			continue;
Anakin's avatar
Anakin committed
335
		}
Anakin's avatar
Anakin committed
336
337
		
		if (!strcmp("CLTH", (*it)->name))
Anakin's avatar
Anakin committed
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
		{
			// get all subchunks
			std::list<ChunkHeader*> tempClthChunks;
			loadChunks(tempClthChunks, (*it)->position, (*it)->size);

			// evaluate CLTH subchunks
			analyseClthChunks(dataDestination, tempClthChunks);

			// clean up
			while (!tempClthChunks.empty())
			{
				ChunkHeader* tempCursor = tempClthChunks.front();
				tempClthChunks.pop_front();
				delete tempCursor;
			}
Anakin's avatar
Anakin committed
353
			continue;
Anakin's avatar
Anakin committed
354
355
356
357
358
359
360
361
		}
	}
}

void Object::analyseSegmChunks(Modl * dataDestination, std::list<ChunkHeader*>& chunkList)
{
	for (std::list<ChunkHeader*>::iterator it = chunkList.begin(); it != chunkList.end(); it++)
	{
362
		/*if (!strcmp("SHDW", (*it)->name))
Anakin's avatar
Anakin committed
363
364
365
366
367
368
369
370
371
372
373
374
		{
			fsMesh.seekg((*it)->position);
			/* shadow mesh geometry

			long int - 4 - number of vertex positions
			float[3][] - 12 each - vertex positions (XYZ)
			long int - 4 - number of edges
			short int[4][] - 8 each - edge the following 4 entries from one edge
			> short int - 2 - vertex index of this edge, referes to the vertex list
			> short int - 2 - Reference into an edge. Defines the target vertex (the local edge vertex of the referenced edge) to which the edge should be dran from the local vertex
			> short int - 2 - Second reference into an edge. In all example .msh files I've seen this always refers to the same vertex as the first edge reference
			> short int - 2 - MAX_VALUE of short integers (65535). Indicates the end of this edge
375
			* /
Anakin's avatar
Anakin committed
376
			continue;
377
		}*/
Anakin's avatar
Anakin committed
378
379
380
381

		if (!strcmp("MATI", (*it)->name))
		{
			fsMesh.seekg((*it)->position);
Anakin's avatar
Anakin committed
382
383
			std::uint32_t tempIndex;
			fsMesh.read(reinterpret_cast<char*>(&tempIndex), sizeof(tempIndex));
384
			if (vTextures.size() <= tempIndex)
Anakin's avatar
Anakin committed
385
386
387
388
389
			{
				std::cout << "warning texture index <" << tempIndex << "> unknown" << std::endl;
				dataDestination->texture = "";
				continue;
			}
390
			dataDestination->texture = vTextures[tempIndex];
Anakin's avatar
Anakin committed
391
			continue;
Anakin's avatar
Anakin committed
392
393
394
395
		}

		if (!strcmp("POSL", (*it)->name))
		{
396
			readVertex(dataDestination, (*it)->position);
Anakin's avatar
Anakin committed
397
			continue;
Anakin's avatar
Anakin committed
398
399
		}

400
		/*if (!strcmp("NRML", (*it)->name))
Anakin's avatar
Anakin committed
401
402
403
404
405
		{
			fsMesh.seekg((*it)->position);
			// List of normals
			// long int - 4 - number of normal vectores stored in this list
			// float[3][] - 12 each - UVW vector for each vertex
Anakin's avatar
Anakin committed
406
			continue;
407
		}*/
Anakin's avatar
Anakin committed
408
409
410

		if (!strcmp("UV0L", (*it)->name))
		{
411
			readUV(dataDestination, (*it)->position);
Anakin's avatar
Anakin committed
412
			continue;
Anakin's avatar
Anakin committed
413
414
415
416
417
		}

		if (!strcmp("STRP", (*it)->name))
		{
			fsMesh.seekg((*it)->position);
Anakin's avatar
Anakin committed
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442

			fsMesh.seekg((*it)->position);
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->meshSize), sizeof(dataDestination->meshSize));

			dataDestination->mesh = new std::uint32_t[dataDestination->meshSize * 3];

			for (unsigned int i = 0; i < dataDestination->meshSize; i += 3)
			{
				std::uint16_t tempValue[3];
				fsMesh.read(reinterpret_cast<char*>(&tempValue[0]), sizeof(std::uint16_t));
				fsMesh.read(reinterpret_cast<char*>(&tempValue[1]), sizeof(std::uint16_t));
				fsMesh.read(reinterpret_cast<char*>(&tempValue[2]), sizeof(std::uint16_t));

				if (!(tempValue[0] >> 15 && tempValue[1] >> 15 && !(tempValue[2] >> 15)))
					throw std::invalid_argument("invalid file. go and triangulate!");

				tempValue[0] = (std::uint16_t(tempValue[0] << 1) >> 1);
				tempValue[1] = (std::uint16_t(tempValue[1] << 1) >> 1);

				dataDestination->mesh[i] = (std::uint32_t)tempValue[0];
				dataDestination->mesh[i + 1] = (std::uint32_t)tempValue[1];
				dataDestination->mesh[i + 2] = (std::uint32_t)tempValue[2];
			}

			continue;
Anakin's avatar
Anakin committed
443
444
445
446
447
448
449
450
451
452
453
		}
	}
}

void Object::analyseClthChunks(Modl * dataDestination, std::list<ChunkHeader*>& chunkList)
{
	for (std::list<ChunkHeader*>::iterator it = chunkList.begin(); it != chunkList.end(); it++)
	{
		if (!strcmp("CTEX", (*it)->name))
		{
			fsMesh.seekg((*it)->position);
454
			char* buffer = new char[(*it)->size];
Anakin's avatar
Anakin committed
455
			*buffer = { 0 };
456
457
			fsMesh.read(buffer, (*it)->size);
			dataDestination->texture = buffer;
458
			delete buffer;
Anakin's avatar
Anakin committed
459
			continue;
Anakin's avatar
Anakin committed
460
461
462
		}

		if (!strcmp("CPOS", (*it)->name))
Anakin's avatar
Anakin committed
463
		{
464
			readVertex(dataDestination, (*it)->position);
Anakin's avatar
Anakin committed
465
466
			continue;
		}
Anakin's avatar
Anakin committed
467
468

		if (!strcmp("CUV0", (*it)->name))
Anakin's avatar
Anakin committed
469
		{
470
			readUV(dataDestination, (*it)->position);
Anakin's avatar
Anakin committed
471
472
			continue;
		}
Anakin's avatar
Anakin committed
473
474

		if (!strcmp("CMSH", (*it)->name))
Anakin's avatar
Anakin committed
475
476
477
478
479
480
481
482
483
484
485
486
487
488
		{
			fsMesh.seekg((*it)->position);
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->meshSize), sizeof(dataDestination->meshSize));

			dataDestination->mesh = new std::uint32_t[dataDestination->meshSize * 3];

			for (unsigned int i = 0; i < dataDestination->meshSize; i += 3)
			{
				fsMesh.read(reinterpret_cast<char*>(&dataDestination->mesh[i]), sizeof(std::uint32_t));
				fsMesh.read(reinterpret_cast<char*>(&dataDestination->mesh[i + 1]), sizeof(std::uint32_t));
				fsMesh.read(reinterpret_cast<char*>(&dataDestination->mesh[i + 2]), sizeof(std::uint32_t));
			}
			continue;
		}
489
490
491
492
493
494
495
496
497
498
499
	}
}

void Object::readVertex(Modl* dataDestination, std::streampos position)
{
	std::uint32_t tempSize;
	fsMesh.seekg(position);
	fsMesh.read(reinterpret_cast<char*>(&tempSize), sizeof(tempSize));

	dataDestination->vertex = new float[tempSize * 3];

Anakin's avatar
Anakin committed
500
	for (unsigned int i = 0; i < tempSize * 3; i += 3)
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
	{
		fsMesh.read(reinterpret_cast<char*>(&dataDestination->vertex[i]), sizeof(float));
		fsMesh.read(reinterpret_cast<char*>(&dataDestination->vertex[i + 1]), sizeof(float));
		fsMesh.read(reinterpret_cast<char*>(&dataDestination->vertex[i + 2]), sizeof(float));
	}
}

void Object::readUV(Modl* dataDestination, std::streampos position)
{
	std::uint32_t tempSize;
	fsMesh.seekg(position);
	fsMesh.read(reinterpret_cast<char*>(&tempSize), sizeof(tempSize));

	dataDestination->uv = new float[tempSize * 2];

Anakin's avatar
Anakin committed
516
	for (unsigned int i = 0; i < tempSize * 2; i += 2)
517
518
519
520
	{
		fsMesh.read(reinterpret_cast<char*>(&dataDestination->uv[i]), sizeof(float));
		fsMesh.read(reinterpret_cast<char*>(&dataDestination->uv[i + 1]), sizeof(float));
	}
Anakin's avatar
Anakin committed
521
522
}

523

Anakin's avatar
Anakin committed
524
525
/////////////////////////////////////////////////////////////////////////
// public getter
526

527
528
529
530
531
532
std::vector<GLfloat> Object::getVertex() const
{
	std::vector<GLfloat> tempData;

	for (std::list<Modl*>::const_iterator it = lModls.begin(); it != lModls.end(); it++)
	{
Anakin's avatar
Anakin committed
533
		for (unsigned int i = 0; i < (*it)->meshSize; i++)
534
		{
Anakin's avatar
Anakin committed
535
536
537
			tempData.push_back((GLfloat)(*it)->vertex[(*it)->mesh[i] * 3]);
			tempData.push_back((GLfloat)(*it)->vertex[(*it)->mesh[i] * 3 + 1]);
			tempData.push_back((GLfloat)(*it)->vertex[(*it)->mesh[i] * 3 + 2]);
538
539
540
541
542
543
544
545
546
547
548
		}
	}

	return tempData;
}

std::vector<GLfloat> Object::getUV() const
{
	std::vector<GLfloat> tempData;

	for (std::list<Modl*>::const_iterator it = lModls.begin(); it != lModls.end(); it++)
Anakin's avatar
Anakin committed
549
550
	{
		if ((*it)->uv == NULL)
Anakin's avatar
Anakin committed
551
552
553
		{
			for (unsigned int i = 0; i < (*it)->meshSize; i++)
				tempData.push_back(1.0);
Anakin's avatar
Anakin committed
554
			continue;
Anakin's avatar
Anakin committed
555
556
		}
		for (unsigned int i = 0; i < (*it)->meshSize; i++)
Anakin's avatar
Anakin committed
557
		{
Anakin's avatar
Anakin committed
558
559
			tempData.push_back((GLfloat)(*it)->uv[(*it)->mesh[i] * 2]);
			tempData.push_back((GLfloat)(*it)->uv[(*it)->mesh[i] * 2 + 1]);
Anakin's avatar
Anakin committed
560
561
		}
	}
562
563
564

	return tempData;
}
565

566
567
568
569
570
571
572
573
574
575
std::list<std::uint32_t> Object::getSize() const
{
	std::list<std::uint32_t> tempData;

	for (std::list<Modl*>::const_iterator it = lModls.begin(); it != lModls.end(); it++)
		tempData.push_back((*it)->meshSize);

	return tempData;
}

576
577
578
579
580
581
582
583
584
585
std::list<std::string> Object::getTexture() const
{
	std::list<std::string> tempData;

	for (std::list<Modl*>::const_iterator it = lModls.begin(); it != lModls.end(); it++)
		tempData.push_back((*it)->texture);

	return tempData;
}

586
587
588
589

/////////////////////////////////////////////////////////////////////////
// public functions