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


Anakin's avatar
Anakin committed
5
#define PI (4.0*atan(1.0))
6
7
8
9
10


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

Anakin's avatar
Anakin committed
11
Object::Object(const char* path)
12
{
13
14
	vModls = new std::vector<Modl*>;

Anakin's avatar
Anakin committed
15
	// open file
16
	fsMesh.open(path, std::ios::in | std::ios::binary);
17

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

21
22
	// jump to file size information
	fsMesh.seekg(4);
23

24
25
	std::uint32_t tempFileSize;
	std::list<ChunkHeader*> tempMainChunks;
26

27
28
29
	// get all chunks under HEDR
	fsMesh.read(reinterpret_cast<char*>(&tempFileSize), sizeof(tempFileSize));
	loadChunks(tempMainChunks, fsMesh.tellg(), tempFileSize);
30

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

40
41
42
43
44
			// evaluate MSH2 subchunks
			analyseMsh2Chunks(tempMsh2Chunks);

			// clean up
			while (!tempMsh2Chunks.empty())
Anakin's avatar
Anakin committed
45
			{
46
47
				ChunkHeader* tempCursor = tempMsh2Chunks.front();
				tempMsh2Chunks.pop_front();
Anakin's avatar
Anakin committed
48
49
				delete tempCursor;
			}
50
			continue;
51
52
		}
	}
53

54
55
56
57
58
59
60
61
	// clean up
	while (!tempMainChunks.empty())
	{
		ChunkHeader* tempCursor = tempMainChunks.front();
		tempMainChunks.pop_front();
		delete tempCursor;
	}

62
63
64
65
66
67
	// close file
	fsMesh.close();
}

Object::~Object()
{
Anakin's avatar
Anakin committed
68
69
	// clear texture list
	vTextures.clear();
70
}
71
72


73
74
/////////////////////////////////////////////////////////////////////////
// private functions
75

Anakin's avatar
Anakin committed
76
void Object::loadChunks(std::list<ChunkHeader*>& destination, std::streampos start, const std::uint32_t end)
77
{
78
	// jump to first chunk
79
	fsMesh.seekg(start);
80

Anakin's avatar
Anakin committed
81
82
	do
	{
Anakin's avatar
Anakin committed
83
		ChunkHeader* tempHeader = new ChunkHeader();
84

85
86
87
		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();
88

89
		destination.push_back(tempHeader);
90

91
		fsMesh.seekg(tempHeader->size, std::ios_base::cur);
92

93
94
		// reached end
		if (fsMesh.tellg() - start == end)
Anakin's avatar
Anakin committed
95
			break;
96
97
98
99
100
101
102
103
104
105

		// 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);
106
107
}

108
109
void Object::analyseMsh2Chunks(std::list<ChunkHeader*>& chunkList)
{
Anakin's avatar
Anakin committed
110
	for (auto& it : chunkList)
111
	{
Anakin's avatar
Anakin committed
112
		if (!strcmp("MATL", it->name))
113
		{
114
			// "useless" information how many MATD follow
Anakin's avatar
Anakin committed
115
			fsMesh.seekg(it->position);
116
117
118
			std::uint32_t tempMatdCount;
			fsMesh.read(reinterpret_cast<char*>(&tempMatdCount), sizeof(std::uint32_t));

Anakin's avatar
Anakin committed
119
120
			// get all MATD from MATL list
			std::list<ChunkHeader*> tempMatlChunks;
Anakin's avatar
Anakin committed
121
			loadChunks(tempMatlChunks, fsMesh.tellg(), it->size - 4);
Anakin's avatar
Anakin committed
122
123

			// evaluate MATL subchunks
Anakin's avatar
Anakin committed
124
			for (auto& it : tempMatlChunks)
Anakin's avatar
Anakin committed
125
126
			{
				// This shouldn't be anything else than MATD
Anakin's avatar
Anakin committed
127
				if (!strcmp("MATD", it->name))
Anakin's avatar
Anakin committed
128
129
130
				{
					// get all subchunks from MATD
					std::list<ChunkHeader*> tempMatdChunks;
Anakin's avatar
Anakin committed
131
					loadChunks(tempMatdChunks, it->position, it->size);
Anakin's avatar
Anakin committed
132

133
134
					vTextures.push_back("");

Anakin's avatar
Anakin committed
135
					// analyse MATD subchunks
Anakin's avatar
Anakin committed
136
					analyseMatdChunks(tempMatdChunks);
Anakin's avatar
Anakin committed
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

					// 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;
			}
155
156
157
158

			continue;
		}

Anakin's avatar
Anakin committed
159
		if (!strcmp("MODL", it->name))
160
		{
Anakin's avatar
Anakin committed
161
162
			Modl* tempModl = new Modl;

163
164
			// get all subchunks
			std::list<ChunkHeader*> tempChunks;
Anakin's avatar
Anakin committed
165
			loadChunks(tempChunks, it->position, it->size);
166
167
168
169
170
171
172
173
174
175
176
177

			// 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
178
			// save Model data
179
			vModls->push_back(tempModl);
Anakin's avatar
Anakin committed
180

Anakin's avatar
Anakin committed
181
182
183
184
			continue;
		}
	}
}
185

Anakin's avatar
Anakin committed
186
void Object::analyseMatdChunks(std::list<ChunkHeader*>& chunkList)
Anakin's avatar
Anakin committed
187
{
Anakin's avatar
Anakin committed
188
	for (auto& it : chunkList)
Anakin's avatar
Anakin committed
189
190
	{
		//TX1D, TX2D, TX3D
Anakin's avatar
Anakin committed
191
		if (!strcmp("TX0D", it->name))
Anakin's avatar
Anakin committed
192
		{
Anakin's avatar
Anakin committed
193
194
			fsMesh.seekg(it->position);
			char* buffer = new char[it->size + 1];
Anakin's avatar
Anakin committed
195
			*buffer = { 0 };
Anakin's avatar
Anakin committed
196
			fsMesh.read(buffer, it->size);
197
			vTextures.back() = buffer;
Anakin's avatar
Anakin committed
198
			delete buffer;
199
200
201
202
203
			continue;
		}
	}
}

Anakin's avatar
Anakin committed
204
205
void Object::analyseModlChunks(Modl* dataDestination, std::list<ChunkHeader*>& chunkList)
{
Anakin's avatar
Anakin committed
206
	for (auto& it : chunkList)
Anakin's avatar
Anakin committed
207
	{
Anakin's avatar
Anakin committed
208
		if (!strcmp("MTYP", it->name))
Anakin's avatar
Anakin committed
209
		{
Anakin's avatar
Anakin committed
210
			fsMesh.seekg(it->position);
Anakin's avatar
Anakin committed
211
212
213
			std::uint32_t tempType;
			fsMesh.read(reinterpret_cast<char*>(&tempType), sizeof(tempType));
			dataDestination->type = (Mtyp)tempType;
Anakin's avatar
Anakin committed
214
			continue;
Anakin's avatar
Anakin committed
215
216
		}

Anakin's avatar
Anakin committed
217
		if (!strcmp("PRNT", it->name))
Anakin's avatar
Anakin committed
218
		{
Anakin's avatar
Anakin committed
219
220
			fsMesh.seekg(it->position);
			char* buffer = new char[it->size];
Anakin's avatar
Anakin committed
221
			*buffer = { 0 };
Anakin's avatar
Anakin committed
222
			fsMesh.read(buffer, it->size); 
223
224
			dataDestination->parent = buffer;
			delete buffer;
Anakin's avatar
Anakin committed
225
			continue;
Anakin's avatar
Anakin committed
226
227
		}

Anakin's avatar
Anakin committed
228
		if (!strcmp("NAME", it->name))
Anakin's avatar
Anakin committed
229
		{
Anakin's avatar
Anakin committed
230
231
			fsMesh.seekg(it->position);
			char* buffer = new char[it->size];
Anakin's avatar
Anakin committed
232
			*buffer = { 0 };
Anakin's avatar
Anakin committed
233
			fsMesh.read(buffer, it->size);
234
			dataDestination->name = buffer;
235
			delete buffer;
Anakin's avatar
Anakin committed
236
			continue;
Anakin's avatar
Anakin committed
237
238
		}

Anakin's avatar
Anakin committed
239
		if (!strcmp("FLGS", it->name))
Anakin's avatar
Anakin committed
240
		{
Anakin's avatar
Anakin committed
241
			fsMesh.seekg(it->position);
Anakin's avatar
Anakin committed
242
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->renderFlags), sizeof(dataDestination->renderFlags));
Anakin's avatar
Anakin committed
243
			continue;
Anakin's avatar
Anakin committed
244
245
		}

Anakin's avatar
Anakin committed
246
		if (!strcmp("TRAN", it->name))
Anakin's avatar
Anakin committed
247
		{
Anakin's avatar
Anakin committed
248
249
250
251
			float tempScale[3];
			float tempRotation[4];
			float tempTrans[3];

Anakin's avatar
Anakin committed
252
			fsMesh.seekg(it->position);
Anakin's avatar
Anakin committed
253
254
255
256
257
258
259
260
261
262

			fsMesh.read(reinterpret_cast<char*>(&tempScale[0]), sizeof(float));
			fsMesh.read(reinterpret_cast<char*>(&tempScale[1]), sizeof(float));
			fsMesh.read(reinterpret_cast<char*>(&tempScale[2]), sizeof(float));

			fsMesh.read(reinterpret_cast<char*>(&tempRotation[0]), sizeof(float));
			fsMesh.read(reinterpret_cast<char*>(&tempRotation[1]), sizeof(float));
			fsMesh.read(reinterpret_cast<char*>(&tempRotation[2]), sizeof(float));
			fsMesh.read(reinterpret_cast<char*>(&tempRotation[3]), sizeof(float));

Anakin's avatar
Anakin committed
263
			//TODO: make a function for this
Anakin's avatar
Anakin committed
264
265
266
267
268
269
270
			//calculate x,y,z rotation
			tempRotation[0] = atan2(2 * (tempRotation[0] * tempRotation[1] + tempRotation[2] * tempRotation[3]),
									1 - 2 * (pow(tempRotation[1], 2) + pow(tempRotation[2], 2)));
			tempRotation[1] = asin(2 * (tempRotation[0] * tempRotation[2] - tempRotation[3] * tempRotation[1]));
			tempRotation[2] = atan2(2 * (tempRotation[0] * tempRotation[3] + tempRotation[1] * tempRotation[2]),
									1 - 2 * (pow(tempRotation[2], 2) + pow(tempRotation[3], 2))) - PI;

Anakin's avatar
Anakin committed
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
			fsMesh.read(reinterpret_cast<char*>(&tempTrans[0]), sizeof(float));
			fsMesh.read(reinterpret_cast<char*>(&tempTrans[1]), sizeof(float));
			fsMesh.read(reinterpret_cast<char*>(&tempTrans[2]), sizeof(float));

			dataDestination->m4x4Translation = glm::scale(
				dataDestination->m4x4Translation,
				glm::vec3(tempScale[0], tempScale[1], tempScale[2])
			);

			dataDestination->m4x4Translation = glm::translate(
				dataDestination->m4x4Translation,
				glm::vec3(tempTrans[0], tempTrans[1], tempTrans[2])
			);

			dataDestination->m4x4Translation = glm::rotate(
				dataDestination->m4x4Translation,
				tempRotation[0],
				glm::vec3(1, 0, 0)
			);

			dataDestination->m4x4Translation = glm::rotate(
				dataDestination->m4x4Translation,
				tempRotation[1],
				glm::vec3(0, 1, 0)
			);

			dataDestination->m4x4Translation = glm::rotate(
				dataDestination->m4x4Translation,
				tempRotation[2],
				glm::vec3(0, 0, 1)
			);

Anakin's avatar
Anakin committed
303
			continue;
Anakin's avatar
Anakin committed
304
305
		}

Anakin's avatar
Anakin committed
306
		if (!strcmp("GEOM", it->name))
Anakin's avatar
Anakin committed
307
308
309
		{
			// get all subchunks
			std::list<ChunkHeader*> tempGeomChunks;
Anakin's avatar
Anakin committed
310
			loadChunks(tempGeomChunks, it->position, it->size);
Anakin's avatar
Anakin committed
311
312
313
314
315
316
317
318
319
320
321

			// 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
322
323

			continue;
Anakin's avatar
Anakin committed
324
325
326
327
328
329
		}
	}
}

void Object::analyseGeomChunks(Modl * dataDestination, std::list<ChunkHeader*>& chunkList)
{
Anakin's avatar
Anakin committed
330
	for (auto& it : chunkList)
Anakin's avatar
Anakin committed
331
	{
Anakin's avatar
Anakin committed
332
		if (!strcmp("BBOX", it->name))
333
		{
Anakin's avatar
Anakin committed
334
			fsMesh.seekg(it->position);
335

Anakin's avatar
Anakin committed
336
337
338
339
340
341
342
343
344
345
346
			// read in the quaternion
			for (int i = 0; i < 4; i++)
				fsMesh.read(reinterpret_cast<char*>(&dataDestination->boundingBox.quaternion[i]), sizeof(float));

			//read in the center
			for (int i = 0; i < 3; i++)
				fsMesh.read(reinterpret_cast<char*>(&dataDestination->boundingBox.center[i]), sizeof(float));

			//read in the extents
			for (int i = 0; i < 3; i++)
				fsMesh.read(reinterpret_cast<char*>(&dataDestination->boundingBox.extents[i]), sizeof(float));
347
348
349
350

			continue;
		}

Anakin's avatar
Anakin committed
351
		if (!strcmp("SEGM", it->name))
Anakin's avatar
Anakin committed
352
353
354
		{
			// get all subchunks
			std::list<ChunkHeader*> tempSegmChunks;
Anakin's avatar
Anakin committed
355
			loadChunks(tempSegmChunks, it->position, it->size);
Anakin's avatar
Anakin committed
356
357
358
359
360
361
362
363
364
365
366

			// 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
367
			continue;
Anakin's avatar
Anakin committed
368
		}
Anakin's avatar
Anakin committed
369
		
Anakin's avatar
Anakin committed
370
		if (!strcmp("CLTH", it->name))
Anakin's avatar
Anakin committed
371
372
373
		{
			// get all subchunks
			std::list<ChunkHeader*> tempClthChunks;
Anakin's avatar
Anakin committed
374
			loadChunks(tempClthChunks, it->position, it->size);
Anakin's avatar
Anakin committed
375
376
377
378
379
380
381
382
383
384
385

			// 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
386
			continue;
Anakin's avatar
Anakin committed
387
388
389
390
391
392
		}
	}
}

void Object::analyseSegmChunks(Modl * dataDestination, std::list<ChunkHeader*>& chunkList)
{
Anakin's avatar
Anakin committed
393
394
	Segment* tempData = new Segment;

Anakin's avatar
Anakin committed
395
	for (auto& it : chunkList)
Anakin's avatar
Anakin committed
396
	{
Anakin's avatar
Anakin committed
397
		if (!strcmp("MATI", it->name))
Anakin's avatar
Anakin committed
398
		{
Anakin's avatar
Anakin committed
399
			fsMesh.seekg(it->position);
Anakin's avatar
Anakin committed
400
			fsMesh.read(reinterpret_cast<char*>(&tempData->textureIndex), sizeof(tempData->textureIndex));
Anakin's avatar
Anakin committed
401
			continue;
Anakin's avatar
Anakin committed
402
403
		}

Anakin's avatar
Anakin committed
404
		if (!strcmp("POSL", it->name))
Anakin's avatar
Anakin committed
405
		{
Anakin's avatar
Anakin committed
406
			readVertex(tempData, it->position);
Anakin's avatar
Anakin committed
407
			continue;
Anakin's avatar
Anakin committed
408
409
		}

Anakin's avatar
Anakin committed
410
		/*if (!strcmp("NRML", it->name))
Anakin's avatar
Anakin committed
411
		{
Anakin's avatar
Anakin committed
412
			fsMesh.seekg(it->position);
413
414
			std::uint32_t tempSize;
			fsMesh.read(reinterpret_cast<char*>(&tempSize), sizeof(tempSize));
Anakin's avatar
Anakin committed
415
416
417
			// 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
418
			continue;
419
		}*/
Anakin's avatar
Anakin committed
420

Anakin's avatar
Anakin committed
421
		if (!strcmp("UV0L", it->name))
Anakin's avatar
Anakin committed
422
		{
Anakin's avatar
Anakin committed
423
			readUV(tempData, it->position);
Anakin's avatar
Anakin committed
424
			continue;
Anakin's avatar
Anakin committed
425
426
		}

Anakin's avatar
Anakin committed
427
		if (!strcmp("STRP", it->name))
428
		{
429
430
431
432
433
434
			// don't get null, bone, shadowMesh and hidden mesh indices
			if (dataDestination->type == null ||
				dataDestination->type == bone ||
				dataDestination->type == shadowMesh ||
				dataDestination->renderFlags == 1)
				continue;
435
436

			// jump to the data section and read the size;
437
			std::uint32_t tempSize;
Anakin's avatar
Anakin committed
438
			fsMesh.seekg(it->position);
439
			fsMesh.read(reinterpret_cast<char*>(&tempSize), sizeof(tempSize));
440
441

			int highBitCount(0);
Anakin's avatar
Anakin committed
442
			std::vector<uint32_t> tempPoly; // = new std::vector<uint32_t>;
443
			
444
			for (unsigned int i = 0; i < tempSize; i++)
445
446
447
448
449
450
451
452
453
454
455
456
			{
				// ReadData
				std::uint16_t tempValue;
				fsMesh.read(reinterpret_cast<char*>(&tempValue), sizeof(std::uint16_t));

				// Check for highbit
				if (tempValue >> 15)
				{
					highBitCount++;
					tempValue = (std::uint16_t(tempValue << 1) >> 1);
				}

Anakin's avatar
Anakin committed
457
				tempPoly.push_back((std::uint32_t)tempValue);
458

459
				// new Polygon found
460
461
462
				if (highBitCount == 2)
				{
					// reset highBitCount
Anakin's avatar
Anakin committed
463
					highBitCount = 0;
464
465
466
467
468

					// remove the last two values..
					std::uint32_t saveData[2];
					for (int i = 0; i < 2; i++)
					{
Anakin's avatar
Anakin committed
469
470
						saveData[i] = tempPoly.back();
						tempPoly.pop_back();
471
472
473
					}

					// ..and save them in the new vector
Anakin's avatar
Anakin committed
474
475
476
					tempData->meshIndices.push_back(tempPoly);

					tempPoly.clear();
477
					for (int i = 1; i >= 0; i--)
Anakin's avatar
Anakin committed
478
						tempPoly.push_back(saveData[i]);
479
480
481
482

				}	// if high bit set
				
			}	// for all values
483

484
			// save the last values (where no 2 high bits follow);
485
486
487
488
			tempData->meshIndices.push_back(tempPoly);

			// kick the first element, it's empty as a reason of the algo above;
			tempData->meshIndices.erase(tempData->meshIndices.begin());
489
490
			continue;
		}
Anakin's avatar
Anakin committed
491
	}
Anakin's avatar
Anakin committed
492
	dataDestination->segmLst.push_back(tempData);
Anakin's avatar
Anakin committed
493
494
495
496
}

void Object::analyseClthChunks(Modl * dataDestination, std::list<ChunkHeader*>& chunkList)
{
Anakin's avatar
Anakin committed
497
498
	Segment* tempData = new Segment;

Anakin's avatar
Anakin committed
499
	for (auto& it : chunkList)
Anakin's avatar
Anakin committed
500
	{
Anakin's avatar
Anakin committed
501
		if (!strcmp("CTEX", it->name))
Anakin's avatar
Anakin committed
502
		{
Anakin's avatar
Anakin committed
503
504
			fsMesh.seekg(it->position);
			char* buffer = new char[it->size];
Anakin's avatar
Anakin committed
505
			*buffer = { 0 };
Anakin's avatar
Anakin committed
506
			fsMesh.read(buffer, it->size);
Anakin's avatar
Anakin committed
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525

			bool tempFound(false);

			for (unsigned int index = 0; index < vTextures.size(); index++)
			{
				if (!strcmp(buffer, vTextures[index].c_str()))
				{
					tempData->textureIndex = index;
					tempFound = true;
					break;
				}
			}

			if (!tempFound)
			{
				vTextures.push_back(std::string(buffer));
				tempData->textureIndex = vTextures.size() - 1;
			}

526
			delete buffer;
Anakin's avatar
Anakin committed
527
			continue;
Anakin's avatar
Anakin committed
528
529
		}

Anakin's avatar
Anakin committed
530
		if (!strcmp("CPOS", it->name))
Anakin's avatar
Anakin committed
531
		{
Anakin's avatar
Anakin committed
532
			readVertex(tempData, it->position);
Anakin's avatar
Anakin committed
533
534
			continue;
		}
Anakin's avatar
Anakin committed
535

Anakin's avatar
Anakin committed
536
		if (!strcmp("CUV0", it->name))
Anakin's avatar
Anakin committed
537
		{
Anakin's avatar
Anakin committed
538
			readUV(tempData, it->position);
Anakin's avatar
Anakin committed
539
540
			continue;
		}
Anakin's avatar
Anakin committed
541

Anakin's avatar
Anakin committed
542
		if (!strcmp("CMSH", it->name))
Anakin's avatar
Anakin committed
543
		{
544
545
			// jump to the data section and read the size;
			std::uint32_t tempSize;
Anakin's avatar
Anakin committed
546
			fsMesh.seekg(it->position);
547
			fsMesh.read(reinterpret_cast<char*>(&tempSize), sizeof(tempSize));
Anakin's avatar
Anakin committed
548

Anakin's avatar
Anakin committed
549
			std::vector<uint32_t> tempPoly;
Anakin's avatar
Anakin committed
550

551
552
			// for every triangle..
			for (unsigned int i = 0; i < tempSize; i += 3)
Anakin's avatar
Anakin committed
553
			{
Anakin's avatar
Anakin committed
554
				tempPoly.clear();
555
556
557
558
559
560

				// ..get the 3 indices and save them
				for (int j = 0; j < 3; j++)
				{
					std::uint32_t tempValue;
					fsMesh.read(reinterpret_cast<char*>(&tempValue), sizeof(std::uint32_t));
Anakin's avatar
Anakin committed
561
					tempPoly.push_back(tempValue);
562
563
				}
				tempData->meshIndices.push_back(tempPoly);
Anakin's avatar
Anakin committed
564
565
566
			}
			continue;
		}
567
	}
Anakin's avatar
Anakin committed
568
	dataDestination->segmLst.push_back(tempData);
569
570
}

Anakin's avatar
Anakin committed
571
void Object::readVertex(Segment* dataDestination, std::streampos position)
572
573
574
575
576
577
578
{
	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
579
	for (unsigned int i = 0; i < tempSize * 3; i++)
580
581
582
		fsMesh.read(reinterpret_cast<char*>(&dataDestination->vertex[i]), sizeof(float));
}

Anakin's avatar
Anakin committed
583
void Object::readUV(Segment* dataDestination, std::streampos position)
584
585
586
587
588
589
590
{
	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
591
	for (unsigned int i = 0; i < tempSize * 2; i++)
592
		fsMesh.read(reinterpret_cast<char*>(&dataDestination->uv[i]), sizeof(float));
Anakin's avatar
Anakin committed
593
594
}

595

Anakin's avatar
Anakin committed
596
597
/////////////////////////////////////////////////////////////////////////
// public getter
598

599
std::vector<Modl*>* Object::getModels() const
Anakin's avatar
Anakin committed
600
601
602
603
{
	return vModls;
}

Anakin's avatar
Anakin committed
604
605
606
607
608
std::vector<std::string> Object::getTextureList() const
{
	return vTextures;
}

609
610
611
612

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