]> git.jsancho.org Git - lugaru.git/blob - Source/Graphic/Models.cpp
Put some sounds and animations information in creature types
[lugaru.git] / Source / Graphic / Models.cpp
1 /*
2 Copyright (C) 2003, 2010 - Wolfire Games
3 Copyright (C) 2010-2017 - Lugaru contributors (see AUTHORS file)
4
5 This file is part of Lugaru.
6
7 Lugaru is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 Lugaru is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with Lugaru.  If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "Graphic/Models.hpp"
22
23 #include "Game.hpp"
24 #include "Utils/Folders.hpp"
25
26 extern float multiplier;
27 extern float viewdistance;
28 extern XYZ viewer;
29 extern float fadestart;
30 extern float texdetail;
31 extern bool decalstoggle;
32
33 int Model::LineCheck(XYZ* p1, XYZ* p2, XYZ* p, XYZ* move, float* rotate)
34 {
35     static float distance;
36     static float olddistance;
37     static int intersecting;
38     static int firstintersecting;
39     static XYZ point;
40
41     *p1 = *p1 - *move;
42     *p2 = *p2 - *move;
43     if (*rotate) {
44         *p1 = DoRotation(*p1, 0, -*rotate, 0);
45     }
46     if (*rotate) {
47         *p2 = DoRotation(*p2, 0, -*rotate, 0);
48     }
49     if (!sphere_line_intersection(p1, p2, &boundingspherecenter, &boundingsphereradius)) {
50         return -1;
51     }
52     firstintersecting = -1;
53
54     for (unsigned int j = 0; j < Triangles.size(); j++) {
55         intersecting = LineFacetd(p1, p2, &vertex[Triangles[j].vertex[0]], &vertex[Triangles[j].vertex[1]], &vertex[Triangles[j].vertex[2]], &Triangles[j].facenormal, &point);
56         distance = (point.x - p1->x) * (point.x - p1->x) + (point.y - p1->y) * (point.y - p1->y) + (point.z - p1->z) * (point.z - p1->z);
57         if ((distance < olddistance || firstintersecting == -1) && intersecting) {
58             olddistance = distance;
59             firstintersecting = j;
60             *p = point;
61         }
62     }
63
64     if (*rotate) {
65         *p = DoRotation(*p, 0, *rotate, 0);
66     }
67     *p = *p + *move;
68     return firstintersecting;
69 }
70
71 int Model::LineCheckPossible(XYZ* p1, XYZ* p2, XYZ* p, XYZ* move, float* rotate)
72 {
73     static float distance;
74     static float olddistance;
75     static int intersecting;
76     static int firstintersecting;
77     static XYZ point;
78
79     *p1 = *p1 - *move;
80     *p2 = *p2 - *move;
81     if (!sphere_line_intersection(p1, p2, &boundingspherecenter, &boundingsphereradius)) {
82         return -1;
83     }
84     firstintersecting = -1;
85     if (*rotate) {
86         *p1 = DoRotation(*p1, 0, -*rotate, 0);
87     }
88     if (*rotate) {
89         *p2 = DoRotation(*p2, 0, -*rotate, 0);
90     }
91
92     for (unsigned int j = 0; j < possible.size(); j++) {
93         if (possible[j] < Triangles.size()) {
94             intersecting = LineFacetd(p1, p2, &vertex[Triangles[possible[j]].vertex[0]], &vertex[Triangles[possible[j]].vertex[1]], &vertex[Triangles[possible[j]].vertex[2]], &Triangles[possible[j]].facenormal, &point);
95             distance = (point.x - p1->x) * (point.x - p1->x) + (point.y - p1->y) * (point.y - p1->y) + (point.z - p1->z) * (point.z - p1->z);
96             if ((distance < olddistance || firstintersecting == -1) && intersecting) {
97                 olddistance = distance;
98                 firstintersecting = possible[j];
99                 *p = point;
100             }
101         }
102     }
103
104     if (*rotate) {
105         *p = DoRotation(*p, 0, *rotate, 0);
106     }
107     *p = *p + *move;
108     return firstintersecting;
109 }
110
111 int Model::LineCheckSlidePossible(XYZ* p1, XYZ* p2, XYZ* move, float* rotate)
112 {
113     static float distance;
114     static float olddistance;
115     static int intersecting;
116     static int firstintersecting;
117     static XYZ point;
118
119     *p1 = *p1 - *move;
120     *p2 = *p2 - *move;
121     if (!sphere_line_intersection(p1, p2, &boundingspherecenter, &boundingsphereradius)) {
122         return -1;
123     }
124     firstintersecting = -1;
125     if (*rotate) {
126         *p1 = DoRotation(*p1, 0, -*rotate, 0);
127     }
128     if (*rotate) {
129         *p2 = DoRotation(*p2, 0, -*rotate, 0);
130     }
131
132     for (unsigned int j = 0; j < possible.size(); j++) {
133         if (possible[j] < Triangles.size()) {
134             intersecting = LineFacetd(p1, p2, &vertex[Triangles[possible[j]].vertex[0]], &vertex[Triangles[possible[j]].vertex[1]], &vertex[Triangles[possible[j]].vertex[2]], &Triangles[possible[j]].facenormal, &point);
135             distance = (point.x - p1->x) * (point.x - p1->x) + (point.y - p1->y) * (point.y - p1->y) + (point.z - p1->z) * (point.z - p1->z);
136             if ((distance < olddistance || firstintersecting == -1) && intersecting) {
137                 olddistance = distance;
138                 firstintersecting = possible[j];
139             }
140         }
141     }
142
143     if (firstintersecting > 0) {
144         distance = abs((Triangles[firstintersecting].facenormal.x * p2->x) + (Triangles[firstintersecting].facenormal.y * p2->y) + (Triangles[firstintersecting].facenormal.z * p2->z) - ((Triangles[firstintersecting].facenormal.x * vertex[Triangles[firstintersecting].vertex[0]].x) + (Triangles[firstintersecting].facenormal.y * vertex[Triangles[firstintersecting].vertex[0]].y) + (Triangles[firstintersecting].facenormal.z * vertex[Triangles[firstintersecting].vertex[0]].z)));
145         *p2 -= Triangles[firstintersecting].facenormal * distance;
146     }
147
148     if (*rotate) {
149         *p2 = DoRotation(*p2, 0, *rotate, 0);
150     }
151     *p2 = *p2 + *move;
152     return firstintersecting;
153 }
154
155 int Model::SphereCheck(XYZ* p1, float radius, XYZ* p, XYZ* move, float* rotate)
156 {
157     static int i;
158     static float distance;
159     static float olddistance;
160     static int intersecting;
161     static int firstintersecting;
162     static XYZ point;
163     static XYZ oldp1;
164
165     firstintersecting = -1;
166
167     oldp1 = *p1;
168     *p1 = *p1 - *move;
169     if (*rotate) {
170         *p1 = DoRotation(*p1, 0, -*rotate, 0);
171     }
172     if (distsq(p1, &boundingspherecenter) > radius * radius + boundingsphereradius * boundingsphereradius) {
173         return -1;
174     }
175
176     for (i = 0; i < 4; i++) {
177         for (unsigned int j = 0; j < Triangles.size(); j++) {
178             intersecting = 0;
179             distance = abs((Triangles[j].facenormal.x * p1->x) + (Triangles[j].facenormal.y * p1->y) + (Triangles[j].facenormal.z * p1->z) - ((Triangles[j].facenormal.x * vertex[Triangles[j].vertex[0]].x) + (Triangles[j].facenormal.y * vertex[Triangles[j].vertex[0]].y) + (Triangles[j].facenormal.z * vertex[Triangles[j].vertex[0]].z)));
180             if (distance < radius) {
181                 point = *p1 - Triangles[j].facenormal * distance;
182                 if (PointInTriangle(&point, Triangles[j].facenormal, &vertex[Triangles[j].vertex[0]], &vertex[Triangles[j].vertex[1]], &vertex[Triangles[j].vertex[2]])) {
183                     intersecting = 1;
184                 }
185                 if (!intersecting) {
186                     intersecting = sphere_line_intersection(&vertex[Triangles[j].vertex[0]], &vertex[Triangles[j].vertex[1]], p1, &radius);
187                 }
188                 if (!intersecting) {
189                     intersecting = sphere_line_intersection(&vertex[Triangles[j].vertex[1]], &vertex[Triangles[j].vertex[2]], p1, &radius);
190                 }
191                 if (!intersecting) {
192                     intersecting = sphere_line_intersection(&vertex[Triangles[j].vertex[0]], &vertex[Triangles[j].vertex[2]], p1, &radius);
193                 }
194                 if (intersecting) {
195                     *p1 += Triangles[j].facenormal * (distance - radius);
196                 }
197             }
198             if ((distance < olddistance || firstintersecting == -1) && intersecting) {
199                 olddistance = distance;
200                 firstintersecting = j;
201                 *p = point;
202             }
203         }
204     }
205     if (*rotate) {
206         *p = DoRotation(*p, 0, *rotate, 0);
207     }
208     *p = *p + *move;
209     if (*rotate) {
210         *p1 = DoRotation(*p1, 0, *rotate, 0);
211     }
212     *p1 += *move;
213     return firstintersecting;
214 }
215
216 int Model::SphereCheckPossible(XYZ* p1, float radius, XYZ* move, float* rotate)
217 {
218     static float distance;
219     static float olddistance;
220     static int intersecting;
221     static int firstintersecting;
222     static XYZ point;
223     static XYZ oldp1;
224
225     firstintersecting = -1;
226
227     oldp1 = *p1;
228     *p1 = *p1 - *move;
229
230     possible.clear();
231
232     if (*rotate) {
233         *p1 = DoRotation(*p1, 0, -*rotate, 0);
234     }
235     if (distsq(p1, &boundingspherecenter) > radius * radius + boundingsphereradius * boundingsphereradius) {
236         *p1 = oldp1;
237         return -1;
238     }
239
240     for (unsigned int j = 0; j < Triangles.size(); j++) {
241         intersecting = 0;
242         distance = abs((Triangles[j].facenormal.x * p1->x) + (Triangles[j].facenormal.y * p1->y) + (Triangles[j].facenormal.z * p1->z) - ((Triangles[j].facenormal.x * vertex[Triangles[j].vertex[0]].x) + (Triangles[j].facenormal.y * vertex[Triangles[j].vertex[0]].y) + (Triangles[j].facenormal.z * vertex[Triangles[j].vertex[0]].z)));
243         if (distance < radius) {
244             point = *p1 - Triangles[j].facenormal * distance;
245             if (PointInTriangle(&point, Triangles[j].facenormal, &vertex[Triangles[j].vertex[0]], &vertex[Triangles[j].vertex[1]], &vertex[Triangles[j].vertex[2]])) {
246                 intersecting = 1;
247             }
248             if (!intersecting) {
249                 intersecting = sphere_line_intersection(&vertex[Triangles[j].vertex[0]], &vertex[Triangles[j].vertex[1]], p1, &radius);
250             }
251             if (!intersecting) {
252                 intersecting = sphere_line_intersection(&vertex[Triangles[j].vertex[1]], &vertex[Triangles[j].vertex[2]], p1, &radius);
253             }
254             if (!intersecting) {
255                 intersecting = sphere_line_intersection(&vertex[Triangles[j].vertex[0]], &vertex[Triangles[j].vertex[2]], p1, &radius);
256             }
257             if (intersecting) {
258                 possible.push_back(j);
259             }
260         }
261         if ((distance < olddistance || firstintersecting == -1) && intersecting) {
262             olddistance = distance;
263             firstintersecting = j;
264         }
265     }
266     if (*rotate) {
267         *p1 = DoRotation(*p1, 0, *rotate, 0);
268     }
269     *p1 += *move;
270
271     return firstintersecting;
272 }
273
274 void Model::UpdateVertexArray()
275 {
276     if (type != normaltype && type != decalstype) {
277         return;
278     }
279
280     if (flat) {
281         for (unsigned int i = 0; i < Triangles.size(); i++) {
282             unsigned int j = i * 24;
283             vArray[j + 0] = Triangles[i].gx[0];
284             vArray[j + 1] = Triangles[i].gy[0];
285             vArray[j + 2] = Triangles[i].facenormal.x * -1;
286             vArray[j + 3] = Triangles[i].facenormal.y * -1;
287             vArray[j + 4] = Triangles[i].facenormal.z * -1;
288             vArray[j + 5] = vertex[Triangles[i].vertex[0]].x;
289             vArray[j + 6] = vertex[Triangles[i].vertex[0]].y;
290             vArray[j + 7] = vertex[Triangles[i].vertex[0]].z;
291
292             vArray[j + 8] = Triangles[i].gx[1];
293             vArray[j + 9] = Triangles[i].gy[1];
294             vArray[j + 10] = Triangles[i].facenormal.x * -1;
295             vArray[j + 11] = Triangles[i].facenormal.y * -1;
296             vArray[j + 12] = Triangles[i].facenormal.z * -1;
297             vArray[j + 13] = vertex[Triangles[i].vertex[1]].x;
298             vArray[j + 14] = vertex[Triangles[i].vertex[1]].y;
299             vArray[j + 15] = vertex[Triangles[i].vertex[1]].z;
300
301             vArray[j + 16] = Triangles[i].gx[2];
302             vArray[j + 17] = Triangles[i].gy[2];
303             vArray[j + 18] = Triangles[i].facenormal.x * -1;
304             vArray[j + 19] = Triangles[i].facenormal.y * -1;
305             vArray[j + 20] = Triangles[i].facenormal.z * -1;
306             vArray[j + 21] = vertex[Triangles[i].vertex[2]].x;
307             vArray[j + 22] = vertex[Triangles[i].vertex[2]].y;
308             vArray[j + 23] = vertex[Triangles[i].vertex[2]].z;
309         }
310     } else {
311         for (unsigned int i = 0; i < Triangles.size(); i++) {
312             unsigned int j = i * 24;
313             vArray[j + 0] = Triangles[i].gx[0];
314             vArray[j + 1] = Triangles[i].gy[0];
315             vArray[j + 2] = normals[Triangles[i].vertex[0]].x;
316             vArray[j + 3] = normals[Triangles[i].vertex[0]].y;
317             vArray[j + 4] = normals[Triangles[i].vertex[0]].z;
318             vArray[j + 5] = vertex[Triangles[i].vertex[0]].x;
319             vArray[j + 6] = vertex[Triangles[i].vertex[0]].y;
320             vArray[j + 7] = vertex[Triangles[i].vertex[0]].z;
321
322             vArray[j + 8] = Triangles[i].gx[1];
323             vArray[j + 9] = Triangles[i].gy[1];
324             vArray[j + 10] = normals[Triangles[i].vertex[1]].x;
325             vArray[j + 11] = normals[Triangles[i].vertex[1]].y;
326             vArray[j + 12] = normals[Triangles[i].vertex[1]].z;
327             vArray[j + 13] = vertex[Triangles[i].vertex[1]].x;
328             vArray[j + 14] = vertex[Triangles[i].vertex[1]].y;
329             vArray[j + 15] = vertex[Triangles[i].vertex[1]].z;
330
331             vArray[j + 16] = Triangles[i].gx[2];
332             vArray[j + 17] = Triangles[i].gy[2];
333             vArray[j + 18] = normals[Triangles[i].vertex[2]].x;
334             vArray[j + 19] = normals[Triangles[i].vertex[2]].y;
335             vArray[j + 20] = normals[Triangles[i].vertex[2]].z;
336             vArray[j + 21] = vertex[Triangles[i].vertex[2]].x;
337             vArray[j + 22] = vertex[Triangles[i].vertex[2]].y;
338             vArray[j + 23] = vertex[Triangles[i].vertex[2]].z;
339         }
340     }
341 }
342
343 void Model::UpdateVertexArrayNoTex()
344 {
345     if (type != normaltype && type != decalstype) {
346         return;
347     }
348
349     if (flat) {
350         for (unsigned int i = 0; i < Triangles.size(); i++) {
351             unsigned int j = i * 24;
352             vArray[j + 2] = Triangles[i].facenormal.x * -1;
353             vArray[j + 3] = Triangles[i].facenormal.y * -1;
354             vArray[j + 4] = Triangles[i].facenormal.z * -1;
355             vArray[j + 5] = vertex[Triangles[i].vertex[0]].x;
356             vArray[j + 6] = vertex[Triangles[i].vertex[0]].y;
357             vArray[j + 7] = vertex[Triangles[i].vertex[0]].z;
358
359             vArray[j + 10] = Triangles[i].facenormal.x * -1;
360             vArray[j + 11] = Triangles[i].facenormal.y * -1;
361             vArray[j + 12] = Triangles[i].facenormal.z * -1;
362             vArray[j + 13] = vertex[Triangles[i].vertex[1]].x;
363             vArray[j + 14] = vertex[Triangles[i].vertex[1]].y;
364             vArray[j + 15] = vertex[Triangles[i].vertex[1]].z;
365
366             vArray[j + 18] = Triangles[i].facenormal.x * -1;
367             vArray[j + 19] = Triangles[i].facenormal.y * -1;
368             vArray[j + 20] = Triangles[i].facenormal.z * -1;
369             vArray[j + 21] = vertex[Triangles[i].vertex[2]].x;
370             vArray[j + 22] = vertex[Triangles[i].vertex[2]].y;
371             vArray[j + 23] = vertex[Triangles[i].vertex[2]].z;
372         }
373     } else {
374         for (unsigned int i = 0; i < Triangles.size(); i++) {
375             unsigned int j = i * 24;
376             vArray[j + 2] = normals[Triangles[i].vertex[0]].x;
377             vArray[j + 3] = normals[Triangles[i].vertex[0]].y;
378             vArray[j + 4] = normals[Triangles[i].vertex[0]].z;
379             vArray[j + 5] = vertex[Triangles[i].vertex[0]].x;
380             vArray[j + 6] = vertex[Triangles[i].vertex[0]].y;
381             vArray[j + 7] = vertex[Triangles[i].vertex[0]].z;
382
383             vArray[j + 10] = normals[Triangles[i].vertex[1]].x;
384             vArray[j + 11] = normals[Triangles[i].vertex[1]].y;
385             vArray[j + 12] = normals[Triangles[i].vertex[1]].z;
386             vArray[j + 13] = vertex[Triangles[i].vertex[1]].x;
387             vArray[j + 14] = vertex[Triangles[i].vertex[1]].y;
388             vArray[j + 15] = vertex[Triangles[i].vertex[1]].z;
389
390             vArray[j + 18] = normals[Triangles[i].vertex[2]].x;
391             vArray[j + 19] = normals[Triangles[i].vertex[2]].y;
392             vArray[j + 20] = normals[Triangles[i].vertex[2]].z;
393             vArray[j + 21] = vertex[Triangles[i].vertex[2]].x;
394             vArray[j + 22] = vertex[Triangles[i].vertex[2]].y;
395             vArray[j + 23] = vertex[Triangles[i].vertex[2]].z;
396         }
397     }
398 }
399
400 void Model::UpdateVertexArrayNoTexNoNorm()
401 {
402     if (type != normaltype && type != decalstype) {
403         return;
404     }
405
406     for (unsigned int i = 0; i < Triangles.size(); i++) {
407         unsigned int j = i * 24;
408         vArray[j + 5] = vertex[Triangles[i].vertex[0]].x;
409         vArray[j + 6] = vertex[Triangles[i].vertex[0]].y;
410         vArray[j + 7] = vertex[Triangles[i].vertex[0]].z;
411
412         vArray[j + 13] = vertex[Triangles[i].vertex[1]].x;
413         vArray[j + 14] = vertex[Triangles[i].vertex[1]].y;
414         vArray[j + 15] = vertex[Triangles[i].vertex[1]].z;
415
416         vArray[j + 21] = vertex[Triangles[i].vertex[2]].x;
417         vArray[j + 22] = vertex[Triangles[i].vertex[2]].y;
418         vArray[j + 23] = vertex[Triangles[i].vertex[2]].z;
419     }
420 }
421
422 bool Model::loadnotex(const std::string& filename)
423 {
424     FILE* tfile;
425     long i;
426     short triangleNum;
427
428     type = notextype;
429     color = 0;
430
431     tfile = Folders::openMandatoryFile(Folders::getResourcePath(filename), "rb");
432
433     // read model settings
434
435     fseek(tfile, 0, SEEK_SET);
436     funpackf(tfile, "Bs Bs", &vertexNum, &triangleNum);
437
438     // read the model data
439     deallocate();
440
441     possible.clear();
442
443     owner = (int*)malloc(sizeof(int) * vertexNum);
444     vertex = (XYZ*)malloc(sizeof(XYZ) * vertexNum);
445     Triangles.resize(triangleNum);
446     vArray = (GLfloat*)malloc(sizeof(GLfloat) * triangleNum * 24);
447
448     for (i = 0; i < vertexNum; i++) {
449         funpackf(tfile, "Bf Bf Bf", &vertex[i].x, &vertex[i].y, &vertex[i].z);
450     }
451
452     for (i = 0; i < triangleNum; i++) {
453         short vertex[6];
454         funpackf(tfile, "Bs Bs Bs Bs Bs Bs", &vertex[0], &vertex[1], &vertex[2], &vertex[3], &vertex[4], &vertex[5]);
455         Triangles[i].vertex[0] = vertex[0];
456         Triangles[i].vertex[1] = vertex[2];
457         Triangles[i].vertex[2] = vertex[4];
458         funpackf(tfile, "Bf Bf Bf", &Triangles[i].gx[0], &Triangles[i].gx[1], &Triangles[i].gx[2]);
459         funpackf(tfile, "Bf Bf Bf", &Triangles[i].gy[0], &Triangles[i].gy[1], &Triangles[i].gy[2]);
460     }
461
462     fclose(tfile);
463
464     UpdateVertexArray();
465
466     for (i = 0; i < vertexNum; i++) {
467         owner[i] = -1;
468     }
469
470     boundingsphereradius = 0;
471     for (i = 0; i < vertexNum; i++) {
472         for (int j = 0; j < vertexNum; j++) {
473             if (j != i && distsq(&vertex[j], &vertex[i]) / 2 > boundingsphereradius) {
474                 boundingsphereradius = distsq(&vertex[j], &vertex[i]) / 2;
475                 boundingspherecenter = (vertex[i] + vertex[j]) / 2;
476             }
477         }
478     }
479     boundingsphereradius = fast_sqrt(boundingsphereradius);
480
481     return true;
482 }
483
484 bool Model::load(const std::string& filename)
485 {
486     FILE* tfile;
487     long i;
488     short triangleNum;
489
490     LOGFUNC;
491
492     LOG(std::string("Loading model...") + filename);
493
494     Game::LoadingScreen();
495
496     type = normaltype;
497     color = 0;
498
499     tfile = Folders::openMandatoryFile(Folders::getResourcePath(filename), "rb");
500
501     // read model settings
502
503     fseek(tfile, 0, SEEK_SET);
504     funpackf(tfile, "Bs Bs", &vertexNum, &triangleNum);
505
506     // read the model data
507     deallocate();
508
509     possible.clear();
510
511     owner = (int*)malloc(sizeof(int) * vertexNum);
512     vertex = (XYZ*)malloc(sizeof(XYZ) * vertexNum);
513     normals = (XYZ*)malloc(sizeof(XYZ) * vertexNum);
514     Triangles.resize(triangleNum);
515     vArray = (GLfloat*)malloc(sizeof(GLfloat) * triangleNum * 24);
516
517     for (i = 0; i < vertexNum; i++) {
518         funpackf(tfile, "Bf Bf Bf", &vertex[i].x, &vertex[i].y, &vertex[i].z);
519     }
520
521     for (i = 0; i < triangleNum; i++) {
522         short vertex[6];
523         funpackf(tfile, "Bs Bs Bs Bs Bs Bs", &vertex[0], &vertex[1], &vertex[2], &vertex[3], &vertex[4], &vertex[5]);
524         Triangles[i].vertex[0] = vertex[0];
525         Triangles[i].vertex[1] = vertex[2];
526         Triangles[i].vertex[2] = vertex[4];
527         funpackf(tfile, "Bf Bf Bf", &Triangles[i].gx[0], &Triangles[i].gx[1], &Triangles[i].gx[2]);
528         funpackf(tfile, "Bf Bf Bf", &Triangles[i].gy[0], &Triangles[i].gy[1], &Triangles[i].gy[2]);
529     }
530
531     modelTexture.xsz = 0;
532
533     fclose(tfile);
534
535     UpdateVertexArray();
536
537     for (i = 0; i < vertexNum; i++) {
538         owner[i] = -1;
539     }
540
541     static int j;
542     boundingsphereradius = 0;
543     for (i = 0; i < vertexNum; i++) {
544         for (j = 0; j < vertexNum; j++) {
545             if (j != i && distsq(&vertex[j], &vertex[i]) / 2 > boundingsphereradius) {
546                 boundingsphereradius = distsq(&vertex[j], &vertex[i]) / 2;
547                 boundingspherecenter = (vertex[i] + vertex[j]) / 2;
548             }
549         }
550     }
551     boundingsphereradius = fast_sqrt(boundingsphereradius);
552
553     return true;
554 }
555
556 bool Model::loaddecal(const std::string& filename)
557 {
558     FILE* tfile;
559     long i, j;
560     short triangleNum;
561
562     LOGFUNC;
563
564     LOG(std::string("Loading decal...") + Folders::getResourcePath(filename));
565
566     type = decalstype;
567     color = 0;
568
569     tfile = Folders::openMandatoryFile(Folders::getResourcePath(filename), "rb");
570
571     // read model settings
572
573     fseek(tfile, 0, SEEK_SET);
574     funpackf(tfile, "Bs Bs", &vertexNum, &triangleNum);
575
576     // read the model data
577
578     deallocate();
579
580     possible.clear();
581
582     owner = (int*)malloc(sizeof(int) * vertexNum);
583     vertex = (XYZ*)malloc(sizeof(XYZ) * vertexNum);
584     normals = (XYZ*)malloc(sizeof(XYZ) * vertexNum);
585     Triangles.resize(triangleNum);
586     vArray = (GLfloat*)malloc(sizeof(GLfloat) * triangleNum * 24);
587
588     for (i = 0; i < vertexNum; i++) {
589         funpackf(tfile, "Bf Bf Bf", &vertex[i].x, &vertex[i].y, &vertex[i].z);
590     }
591
592     for (i = 0; i < triangleNum; i++) {
593         short vertex[6];
594         funpackf(tfile, "Bs Bs Bs Bs Bs Bs", &vertex[0], &vertex[1], &vertex[2], &vertex[3], &vertex[4], &vertex[5]);
595         Triangles[i].vertex[0] = vertex[0];
596         Triangles[i].vertex[1] = vertex[2];
597         Triangles[i].vertex[2] = vertex[4];
598         funpackf(tfile, "Bf Bf Bf", &Triangles[i].gx[0], &Triangles[i].gx[1], &Triangles[i].gx[2]);
599         funpackf(tfile, "Bf Bf Bf", &Triangles[i].gy[0], &Triangles[i].gy[1], &Triangles[i].gy[2]);
600     }
601
602     modelTexture.xsz = 0;
603
604     fclose(tfile);
605
606     UpdateVertexArray();
607
608     for (i = 0; i < vertexNum; i++) {
609         owner[i] = -1;
610     }
611
612     boundingsphereradius = 0;
613     for (i = 0; i < vertexNum; i++) {
614         for (j = 0; j < vertexNum; j++) {
615             if (j != i && distsq(&vertex[j], &vertex[i]) / 2 > boundingsphereradius) {
616                 boundingsphereradius = distsq(&vertex[j], &vertex[i]) / 2;
617                 boundingspherecenter = (vertex[i] + vertex[j]) / 2;
618             }
619         }
620     }
621     boundingsphereradius = fast_sqrt(boundingsphereradius);
622
623     return true;
624 }
625
626 bool Model::loadraw(const std::string& filename)
627 {
628     FILE* tfile;
629     long i;
630     short triangleNum;
631
632     LOGFUNC;
633
634     LOG(std::string("Loading raw...") + filename);
635
636     type = rawtype;
637     color = 0;
638
639     tfile = Folders::openMandatoryFile(Folders::getResourcePath(filename), "rb");
640
641     // read model settings
642
643     fseek(tfile, 0, SEEK_SET);
644     funpackf(tfile, "Bs Bs", &vertexNum, &triangleNum);
645
646     // read the model data
647     deallocate();
648
649     possible.clear();
650
651     owner = (int*)malloc(sizeof(int) * vertexNum);
652     vertex = (XYZ*)malloc(sizeof(XYZ) * vertexNum);
653     Triangles.resize(triangleNum);
654     vArray = (GLfloat*)malloc(sizeof(GLfloat) * triangleNum * 24);
655
656     for (i = 0; i < vertexNum; i++) {
657         funpackf(tfile, "Bf Bf Bf", &vertex[i].x, &vertex[i].y, &vertex[i].z);
658     }
659
660     for (i = 0; i < triangleNum; i++) {
661         short vertex[6];
662         funpackf(tfile, "Bs Bs Bs Bs Bs Bs", &vertex[0], &vertex[1], &vertex[2], &vertex[3], &vertex[4], &vertex[5]);
663         Triangles[i].vertex[0] = vertex[0];
664         Triangles[i].vertex[1] = vertex[2];
665         Triangles[i].vertex[2] = vertex[4];
666         funpackf(tfile, "Bf Bf Bf", &Triangles[i].gx[0], &Triangles[i].gx[1], &Triangles[i].gx[2]);
667         funpackf(tfile, "Bf Bf Bf", &Triangles[i].gy[0], &Triangles[i].gy[1], &Triangles[i].gy[2]);
668     }
669
670     fclose(tfile);
671
672     for (i = 0; i < vertexNum; i++) {
673         owner[i] = -1;
674     }
675
676     return true;
677 }
678
679 void Model::UniformTexCoords()
680 {
681     for (unsigned int i = 0; i < Triangles.size(); i++) {
682         Triangles[i].gy[0] = vertex[Triangles[i].vertex[0]].y;
683         Triangles[i].gy[1] = vertex[Triangles[i].vertex[1]].y;
684         Triangles[i].gy[2] = vertex[Triangles[i].vertex[2]].y;
685         Triangles[i].gx[0] = vertex[Triangles[i].vertex[0]].x;
686         Triangles[i].gx[1] = vertex[Triangles[i].vertex[1]].x;
687         Triangles[i].gx[2] = vertex[Triangles[i].vertex[2]].x;
688     }
689     UpdateVertexArray();
690 }
691
692 void Model::FlipTexCoords()
693 {
694     for (unsigned int i = 0; i < Triangles.size(); i++) {
695         Triangles[i].gy[0] = -Triangles[i].gy[0];
696         Triangles[i].gy[1] = -Triangles[i].gy[1];
697         Triangles[i].gy[2] = -Triangles[i].gy[2];
698     }
699     UpdateVertexArray();
700 }
701
702 void Model::ScaleTexCoords(float howmuch)
703 {
704     for (unsigned int i = 0; i < Triangles.size(); i++) {
705         Triangles[i].gx[0] *= howmuch;
706         Triangles[i].gx[1] *= howmuch;
707         Triangles[i].gx[2] *= howmuch;
708         Triangles[i].gy[0] *= howmuch;
709         Triangles[i].gy[1] *= howmuch;
710         Triangles[i].gy[2] *= howmuch;
711     }
712     UpdateVertexArray();
713 }
714
715 void Model::Scale(float xscale, float yscale, float zscale)
716 {
717     static int i;
718     for (i = 0; i < vertexNum; i++) {
719         vertex[i].x *= xscale;
720         vertex[i].y *= yscale;
721         vertex[i].z *= zscale;
722     }
723     UpdateVertexArray();
724
725     static int j;
726
727     boundingsphereradius = 0;
728     for (i = 0; i < vertexNum; i++) {
729         for (j = 0; j < vertexNum; j++) {
730             if (j != i && distsq(&vertex[j], &vertex[i]) / 2 > boundingsphereradius) {
731                 boundingsphereradius = distsq(&vertex[j], &vertex[i]) / 2;
732                 boundingspherecenter = (vertex[i] + vertex[j]) / 2;
733             }
734         }
735     }
736     boundingsphereradius = fast_sqrt(boundingsphereradius);
737 }
738
739 void Model::ScaleNormals(float xscale, float yscale, float zscale)
740 {
741     if (type != normaltype && type != decalstype) {
742         return;
743     }
744
745     for (int i = 0; i < vertexNum; i++) {
746         normals[i].x *= xscale;
747         normals[i].y *= yscale;
748         normals[i].z *= zscale;
749     }
750     for (unsigned int i = 0; i < Triangles.size(); i++) {
751         Triangles[i].facenormal.x *= xscale;
752         Triangles[i].facenormal.y *= yscale;
753         Triangles[i].facenormal.z *= zscale;
754     }
755     UpdateVertexArray();
756 }
757
758 void Model::Translate(float xtrans, float ytrans, float ztrans)
759 {
760     static int i;
761     for (i = 0; i < vertexNum; i++) {
762         vertex[i].x += xtrans;
763         vertex[i].y += ytrans;
764         vertex[i].z += ztrans;
765     }
766     UpdateVertexArray();
767
768     static int j;
769     boundingsphereradius = 0;
770     for (i = 0; i < vertexNum; i++) {
771         for (j = 0; j < vertexNum; j++) {
772             if (j != i && distsq(&vertex[j], &vertex[i]) / 2 > boundingsphereradius) {
773                 boundingsphereradius = distsq(&vertex[j], &vertex[i]) / 2;
774                 boundingspherecenter = (vertex[i] + vertex[j]) / 2;
775             }
776         }
777     }
778     boundingsphereradius = fast_sqrt(boundingsphereradius);
779 }
780
781 void Model::Rotate(float xang, float yang, float zang)
782 {
783     static int i;
784     for (i = 0; i < vertexNum; i++) {
785         vertex[i] = DoRotation(vertex[i], xang, yang, zang);
786     }
787     UpdateVertexArray();
788
789     static int j;
790     boundingsphereradius = 0;
791     for (i = 0; i < vertexNum; i++) {
792         for (j = 0; j < vertexNum; j++) {
793             if (j != i && distsq(&vertex[j], &vertex[i]) / 2 > boundingsphereradius) {
794                 boundingsphereradius = distsq(&vertex[j], &vertex[i]) / 2;
795                 boundingspherecenter = (vertex[i] + vertex[j]) / 2;
796             }
797         }
798     }
799     boundingsphereradius = fast_sqrt(boundingsphereradius);
800 }
801
802 void Model::CalculateNormals(bool facenormalise)
803 {
804     Game::LoadingScreen();
805
806     if (type != normaltype && type != decalstype) {
807         return;
808     }
809
810     for (int i = 0; i < vertexNum; i++) {
811         normals[i].x = 0;
812         normals[i].y = 0;
813         normals[i].z = 0;
814     }
815
816     for (unsigned int i = 0; i < Triangles.size(); i++) {
817         CrossProduct(vertex[Triangles[i].vertex[1]] - vertex[Triangles[i].vertex[0]], vertex[Triangles[i].vertex[2]] - vertex[Triangles[i].vertex[0]], &Triangles[i].facenormal);
818
819         normals[Triangles[i].vertex[0]].x += Triangles[i].facenormal.x;
820         normals[Triangles[i].vertex[0]].y += Triangles[i].facenormal.y;
821         normals[Triangles[i].vertex[0]].z += Triangles[i].facenormal.z;
822
823         normals[Triangles[i].vertex[1]].x += Triangles[i].facenormal.x;
824         normals[Triangles[i].vertex[1]].y += Triangles[i].facenormal.y;
825         normals[Triangles[i].vertex[1]].z += Triangles[i].facenormal.z;
826
827         normals[Triangles[i].vertex[2]].x += Triangles[i].facenormal.x;
828         normals[Triangles[i].vertex[2]].y += Triangles[i].facenormal.y;
829         normals[Triangles[i].vertex[2]].z += Triangles[i].facenormal.z;
830         if (facenormalise) {
831             Normalise(&Triangles[i].facenormal);
832         }
833     }
834     for (int i = 0; i < vertexNum; i++) {
835         Normalise(&normals[i]);
836         normals[i] *= -1;
837     }
838     UpdateVertexArrayNoTex();
839 }
840
841 void Model::drawimmediate()
842 {
843     textureptr.bind();
844     glBegin(GL_TRIANGLES);
845     for (unsigned int i = 0; i < Triangles.size(); i++) {
846         glTexCoord2f(Triangles[i].gx[0], Triangles[i].gy[0]);
847         if (color) {
848             glColor3f(normals[Triangles[i].vertex[0]].x, normals[Triangles[i].vertex[0]].y, normals[Triangles[i].vertex[0]].z);
849         } else if (flat) {
850             glNormal3f(Triangles[i].facenormal.x, Triangles[i].facenormal.y, Triangles[i].facenormal.y);
851         } else {
852             glNormal3f(normals[Triangles[i].vertex[0]].x, normals[Triangles[i].vertex[0]].y, normals[Triangles[i].vertex[0]].z);
853         }
854         glVertex3f(vertex[Triangles[i].vertex[0]].x, vertex[Triangles[i].vertex[0]].y, vertex[Triangles[i].vertex[0]].z);
855
856         glTexCoord2f(Triangles[i].gx[1], Triangles[i].gy[1]);
857         if (color) {
858             glColor3f(normals[Triangles[i].vertex[1]].x, normals[Triangles[i].vertex[1]].y, normals[Triangles[i].vertex[1]].z);
859         } else if (flat) {
860             glNormal3f(Triangles[i].facenormal.x, Triangles[i].facenormal.y, Triangles[i].facenormal.y);
861         } else {
862             glNormal3f(normals[Triangles[i].vertex[1]].x, normals[Triangles[i].vertex[1]].y, normals[Triangles[i].vertex[1]].z);
863         }
864         glVertex3f(vertex[Triangles[i].vertex[1]].x, vertex[Triangles[i].vertex[1]].y, vertex[Triangles[i].vertex[1]].z);
865
866         glTexCoord2f(Triangles[i].gx[2], Triangles[i].gy[2]);
867         if (color) {
868             glColor3f(normals[Triangles[i].vertex[2]].x, normals[Triangles[i].vertex[2]].y, normals[Triangles[i].vertex[2]].z);
869         } else if (flat) {
870             glNormal3f(Triangles[i].facenormal.x, Triangles[i].facenormal.y, Triangles[i].facenormal.y);
871         } else {
872             glNormal3f(normals[Triangles[i].vertex[2]].x, normals[Triangles[i].vertex[2]].y, normals[Triangles[i].vertex[2]].z);
873         }
874         glVertex3f(vertex[Triangles[i].vertex[2]].x, vertex[Triangles[i].vertex[2]].y, vertex[Triangles[i].vertex[2]].z);
875     }
876     glEnd();
877 }
878
879 void Model::draw()
880 {
881     if (type != normaltype && type != decalstype) {
882         return;
883     }
884
885     glEnableClientState(GL_NORMAL_ARRAY);
886     glEnableClientState(GL_VERTEX_ARRAY);
887     glEnableClientState(GL_TEXTURE_COORD_ARRAY);
888
889     if (color) {
890         glInterleavedArrays(GL_T2F_C3F_V3F, 8 * sizeof(GLfloat), &vArray[0]);
891     } else {
892         glInterleavedArrays(GL_T2F_N3F_V3F, 8 * sizeof(GLfloat), &vArray[0]);
893     }
894     textureptr.bind();
895
896     glDrawArrays(GL_TRIANGLES, 0, Triangles.size() * 3);
897
898     if (color) {
899         glDisableClientState(GL_COLOR_ARRAY);
900     } else {
901         glDisableClientState(GL_NORMAL_ARRAY);
902     }
903     glDisableClientState(GL_VERTEX_ARRAY);
904     glDisableClientState(GL_TEXTURE_COORD_ARRAY);
905 }
906
907 void Model::drawdifftex(Texture texture)
908 {
909     glEnableClientState(GL_NORMAL_ARRAY);
910     glEnableClientState(GL_VERTEX_ARRAY);
911     glEnableClientState(GL_TEXTURE_COORD_ARRAY);
912     if (color) {
913         glInterleavedArrays(GL_T2F_C3F_V3F, 8 * sizeof(GLfloat), &vArray[0]);
914     } else {
915         glInterleavedArrays(GL_T2F_N3F_V3F, 8 * sizeof(GLfloat), &vArray[0]);
916     }
917
918     texture.bind();
919     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
920     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
921
922     glDrawArrays(GL_TRIANGLES, 0, Triangles.size() * 3);
923
924     if (color) {
925         glDisableClientState(GL_COLOR_ARRAY);
926     } else {
927         glDisableClientState(GL_NORMAL_ARRAY);
928     }
929     glDisableClientState(GL_VERTEX_ARRAY);
930     glDisableClientState(GL_TEXTURE_COORD_ARRAY);
931 }
932
933 void Model::drawdecals(Texture shadowtexture, Texture bloodtexture, Texture bloodtexture2, Texture breaktexture)
934 {
935     if (decalstoggle) {
936         if (type != decalstype) {
937             return;
938         }
939
940         bool blend = true;
941         int lasttype = -1;
942
943         glEnable(GL_BLEND);
944         glDisable(GL_LIGHTING);
945         glDisable(GL_CULL_FACE);
946         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
947         glDepthMask(0);
948         for (unsigned int i = 0; i < decals.size(); i++) {
949             if (decals[i].type == blooddecalfast && decals[i].alivetime < 2) {
950                 decals[i].alivetime = 2;
951             }
952
953             if (decals[i].type != lasttype) {
954                 if (decals[i].type == shadowdecal) {
955                     shadowtexture.bind();
956                     if (!blend) {
957                         blend = 1;
958                         glAlphaFunc(GL_GREATER, 0.0001);
959                         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
960                     }
961                 }
962                 if (decals[i].type == breakdecal) {
963                     breaktexture.bind();
964                     if (!blend) {
965                         blend = 1;
966                         glAlphaFunc(GL_GREATER, 0.0001);
967                         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
968                     }
969                 }
970                 if (decals[i].type == blooddecal || decals[i].type == blooddecalslow) {
971                     bloodtexture.bind();
972                     if (blend) {
973                         blend = 0;
974                         glAlphaFunc(GL_GREATER, 0.15);
975                         glBlendFunc(GL_ONE, GL_ZERO);
976                     }
977                 }
978                 if (decals[i].type == blooddecalfast) {
979                     bloodtexture2.bind();
980                     if (blend) {
981                         blend = 0;
982                         glAlphaFunc(GL_GREATER, 0.15);
983                         glBlendFunc(GL_ONE, GL_ZERO);
984                     }
985                 }
986             }
987             if (decals[i].type == shadowdecal) {
988                 glColor4f(1, 1, 1, decals[i].opacity);
989             }
990             if (decals[i].type == breakdecal) {
991                 glColor4f(1, 1, 1, decals[i].opacity);
992                 if (decals[i].alivetime > 58) {
993                     glColor4f(1, 1, 1, decals[i].opacity * (60 - decals[i].alivetime) / 2);
994                 }
995             }
996             if ((decals[i].type == blooddecal || decals[i].type == blooddecalfast || decals[i].type == blooddecalslow)) {
997                 glColor4f(1, 1, 1, decals[i].opacity);
998                 if (decals[i].alivetime < 4) {
999                     glColor4f(1, 1, 1, decals[i].opacity * decals[i].alivetime * .25);
1000                 }
1001                 if (decals[i].alivetime > 58) {
1002                     glColor4f(1, 1, 1, decals[i].opacity * (60 - decals[i].alivetime) / 2);
1003                 }
1004             }
1005             lasttype = decals[i].type;
1006             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
1007             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
1008
1009             glMatrixMode(GL_MODELVIEW);
1010             glPushMatrix();
1011             glBegin(GL_TRIANGLES);
1012             for (int j = 0; j < 3; j++) {
1013                 glTexCoord2f(decals[i].texcoords[j][0], decals[i].texcoords[j][1]);
1014                 glVertex3f(decals[i].vertex[j].x, decals[i].vertex[j].y, decals[i].vertex[j].z);
1015             }
1016             glEnd();
1017             glPopMatrix();
1018         }
1019         for (int i = decals.size() - 1; i >= 0; i--) {
1020             decals[i].alivetime += multiplier;
1021             if (decals[i].type == blooddecalslow) {
1022                 decals[i].alivetime -= multiplier * 2 / 3;
1023             }
1024             if (decals[i].type == blooddecalfast) {
1025                 decals[i].alivetime += multiplier * 4;
1026             }
1027             if (decals[i].type == shadowdecal) {
1028                 DeleteDecal(i);
1029             }
1030             if ((decals[i].type == blooddecal || decals[i].type == blooddecalfast || decals[i].type == blooddecalslow) && decals[i].alivetime >= 60) {
1031                 DeleteDecal(i);
1032             }
1033         }
1034         glAlphaFunc(GL_GREATER, 0.0001);
1035         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1036     }
1037 }
1038
1039 void Model::DeleteDecal(int which)
1040 {
1041     if (decalstoggle) {
1042         if (type != decalstype) {
1043             return;
1044         }
1045         decals.erase(decals.begin() + which);
1046     }
1047 }
1048
1049 void Model::MakeDecal(decal_type atype, XYZ* where, float* size, float* opacity, float* rotation)
1050 {
1051     if (decalstoggle) {
1052         if (type != decalstype) {
1053             return;
1054         }
1055
1056         static XYZ rot;
1057         static float distance;
1058
1059         if (*opacity > 0) {
1060             if (distsq(where, &boundingspherecenter) < (boundingsphereradius + *size) * (boundingsphereradius + *size)) {
1061                 for (unsigned int i = 0; i < Triangles.size(); i++) {
1062                     if (Triangles[i].facenormal.y < -.1 && (vertex[Triangles[i].vertex[0]].y < where->y || vertex[Triangles[i].vertex[1]].y < where->y || vertex[Triangles[i].vertex[2]].y < where->y)) {
1063                         distance = abs(((Triangles[i].facenormal.x * where->x) + (Triangles[i].facenormal.y * where->y) + (Triangles[i].facenormal.z * where->z) - ((Triangles[i].facenormal.x * vertex[Triangles[i].vertex[0]].x) + (Triangles[i].facenormal.y * vertex[Triangles[i].vertex[0]].y) + (Triangles[i].facenormal.z * vertex[Triangles[i].vertex[0]].z))) / Triangles[i].facenormal.y);
1064
1065                         if ((*opacity - distance / 10) > 0) {
1066                             Decal decal(*where, atype, *opacity - distance / 10, *rotation, *size, *this, i, 0);
1067
1068                             if (!(decal.texcoords[0][0] < 0 && decal.texcoords[1][0] < 0 && decal.texcoords[2][0] < 0)) {
1069                                 if (!(decal.texcoords[0][1] < 0 && decal.texcoords[1][1] < 0 && decal.texcoords[2][1] < 0)) {
1070                                     if (!(decal.texcoords[0][0] > 1 && decal.texcoords[1][0] > 1 && decal.texcoords[2][0] > 1)) {
1071                                         if (!(decal.texcoords[0][1] > 1 && decal.texcoords[1][1] > 1 && decal.texcoords[2][1] > 1)) {
1072                                             if (decal.rotation) {
1073                                                 for (int j = 0; j < 3; j++) {
1074                                                     rot.y = 0;
1075                                                     rot.x = decal.texcoords[j][0] - .5;
1076                                                     rot.z = decal.texcoords[j][1] - .5;
1077                                                     rot = DoRotation(rot, 0, -decal.rotation, 0);
1078                                                     decal.texcoords[j][0] = rot.x + .5;
1079                                                     decal.texcoords[j][1] = rot.z + .5;
1080                                                 }
1081                                             }
1082                                             if (decals.size() < max_model_decals - 1) {
1083                                                 decals.push_back(decal);
1084                                             }
1085                                         }
1086                                     }
1087                                 }
1088                             }
1089                         }
1090                     }
1091                 }
1092             }
1093         }
1094     }
1095 }
1096
1097 void Model::MakeDecal(decal_type atype, XYZ where, float size, float opacity, float rotation)
1098 {
1099     if (decalstoggle) {
1100         if (type != decalstype) {
1101             return;
1102         }
1103
1104         static XYZ rot;
1105         static float distance;
1106
1107         if (opacity > 0) {
1108             if (distsq(&where, &boundingspherecenter) < (boundingsphereradius + size) * (boundingsphereradius + size)) {
1109                 for (unsigned int i = 0; i < Triangles.size(); i++) {
1110                     distance = abs(((Triangles[i].facenormal.x * where.x) + (Triangles[i].facenormal.y * where.y) + (Triangles[i].facenormal.z * where.z) - ((Triangles[i].facenormal.x * vertex[Triangles[i].vertex[0]].x) + (Triangles[i].facenormal.y * vertex[Triangles[i].vertex[0]].y) + (Triangles[i].facenormal.z * vertex[Triangles[i].vertex[0]].z))));
1111                     if (distance < .02 && abs(Triangles[i].facenormal.y) > abs(Triangles[i].facenormal.x) && abs(Triangles[i].facenormal.y) > abs(Triangles[i].facenormal.z)) {
1112                         if ((opacity - distance / 10) > 0) {
1113                             Decal decal(where, atype, opacity - distance / 10, rotation, size, *this, i, 0);
1114
1115                             if (!(decal.texcoords[0][0] < 0 && decal.texcoords[1][0] < 0 && decal.texcoords[2][0] < 0)) {
1116                                 if (!(decal.texcoords[0][1] < 0 && decal.texcoords[1][1] < 0 && decal.texcoords[2][1] < 0)) {
1117                                     if (!(decal.texcoords[0][0] > 1 && decal.texcoords[1][0] > 1 && decal.texcoords[2][0] > 1)) {
1118                                         if (!(decal.texcoords[0][1] > 1 && decal.texcoords[1][1] > 1 && decal.texcoords[2][1] > 1)) {
1119                                             if (decal.rotation) {
1120                                                 for (int j = 0; j < 3; j++) {
1121                                                     rot.y = 0;
1122                                                     rot.x = decal.texcoords[j][0] - .5;
1123                                                     rot.z = decal.texcoords[j][1] - .5;
1124                                                     rot = DoRotation(rot, 0, -decal.rotation, 0);
1125                                                     decal.texcoords[j][0] = rot.x + .5;
1126                                                     decal.texcoords[j][1] = rot.z + .5;
1127                                                 }
1128                                             }
1129                                             if (decals.size() < max_model_decals - 1) {
1130                                                 decals.push_back(decal);
1131                                             }
1132                                         }
1133                                     }
1134                                 }
1135                             }
1136                         }
1137                     } else if (distance < .02 && abs(Triangles[i].facenormal.x) > abs(Triangles[i].facenormal.y) && abs(Triangles[i].facenormal.x) > abs(Triangles[i].facenormal.z)) {
1138                         if ((opacity - distance / 10) > 0) {
1139                             Decal decal(where, atype, opacity - distance / 10, rotation, size, *this, i, 1);
1140
1141                             if (!(decal.texcoords[0][0] < 0 && decal.texcoords[1][0] < 0 && decal.texcoords[2][0] < 0)) {
1142                                 if (!(decal.texcoords[0][1] < 0 && decal.texcoords[1][1] < 0 && decal.texcoords[2][1] < 0)) {
1143                                     if (!(decal.texcoords[0][0] > 1 && decal.texcoords[1][0] > 1 && decal.texcoords[2][0] > 1)) {
1144                                         if (!(decal.texcoords[0][1] > 1 && decal.texcoords[1][1] > 1 && decal.texcoords[2][1] > 1)) {
1145                                             if (decal.rotation) {
1146                                                 for (int j = 0; j < 3; j++) {
1147                                                     rot.y = 0;
1148                                                     rot.x = decal.texcoords[j][0] - .5;
1149                                                     rot.z = decal.texcoords[j][1] - .5;
1150                                                     rot = DoRotation(rot, 0, -decal.rotation, 0);
1151                                                     decal.texcoords[j][0] = rot.x + .5;
1152                                                     decal.texcoords[j][1] = rot.z + .5;
1153                                                 }
1154                                             }
1155                                             if (decals.size() < max_model_decals - 1) {
1156                                                 decals.push_back(decal);
1157                                             }
1158                                         }
1159                                     }
1160                                 }
1161                             }
1162                         }
1163                     } else if (distance < .02 && abs(Triangles[i].facenormal.z) > abs(Triangles[i].facenormal.y) && abs(Triangles[i].facenormal.z) > abs(Triangles[i].facenormal.x)) {
1164                         if ((opacity - distance / 10) > 0) {
1165                             Decal decal(where, atype, opacity - distance / 10, rotation, size, *this, i, 2);
1166
1167                             if (!(decal.texcoords[0][0] < 0 && decal.texcoords[1][0] < 0 && decal.texcoords[2][0] < 0)) {
1168                                 if (!(decal.texcoords[0][1] < 0 && decal.texcoords[1][1] < 0 && decal.texcoords[2][1] < 0)) {
1169                                     if (!(decal.texcoords[0][0] > 1 && decal.texcoords[1][0] > 1 && decal.texcoords[2][0] > 1)) {
1170                                         if (!(decal.texcoords[0][1] > 1 && decal.texcoords[1][1] > 1 && decal.texcoords[2][1] > 1)) {
1171                                             if (decal.rotation) {
1172                                                 for (int j = 0; j < 3; j++) {
1173                                                     rot.y = 0;
1174                                                     rot.x = decal.texcoords[j][0] - .5;
1175                                                     rot.z = decal.texcoords[j][1] - .5;
1176                                                     rot = DoRotation(rot, 0, -decal.rotation, 0);
1177                                                     decal.texcoords[j][0] = rot.x + .5;
1178                                                     decal.texcoords[j][1] = rot.z + .5;
1179                                                 }
1180                                             }
1181                                             if (decals.size() < max_model_decals - 1) {
1182                                                 decals.push_back(decal);
1183                                             }
1184                                         }
1185                                     }
1186                                 }
1187                             }
1188                         }
1189                     }
1190                 }
1191             }
1192         }
1193     }
1194 }
1195
1196 const XYZ& Model::getTriangleVertex(unsigned triangleId, unsigned vertexId) const
1197 {
1198     return vertex[Triangles[triangleId].vertex[vertexId]];
1199 }
1200
1201 void Model::deleteDeadDecals()
1202 {
1203     for (int i = decals.size() - 1; i >= 0; i--) {
1204         if ((decals[i].type == blooddecal || decals[i].type == blooddecalslow) && decals[i].alivetime < 2) {
1205             DeleteDecal(i);
1206         }
1207     }
1208 }
1209
1210 Model::~Model()
1211 {
1212     deallocate();
1213 }
1214
1215 void Model::deallocate()
1216 {
1217     if (owner) {
1218         free(owner);
1219     }
1220     owner = 0;
1221
1222     if (vertex) {
1223         free(vertex);
1224     }
1225     vertex = 0;
1226
1227     if (normals) {
1228         free(normals);
1229     }
1230     normals = 0;
1231
1232     if (vArray) {
1233         free(vArray);
1234     }
1235     vArray = 0;
1236
1237     decals.clear();
1238 }
1239
1240 Model::Model()
1241     : vertexNum(0)
1242     , type(nothing)
1243     , owner(0)
1244     , vertex(0)
1245     , normals(0)
1246     , vArray(0)
1247     , color(0)
1248     , boundingspherecenter()
1249     , boundingsphereradius(0)
1250     , flat(false)
1251 {
1252     memset(&modelTexture, 0, sizeof(modelTexture));
1253 }