]> git.jsancho.org Git - lugaru.git/blob - Source/Environment/Terrain.cpp
Cleaned up Terrain::AddObject
[lugaru.git] / Source / Environment / Terrain.cpp
1 /*
2 Copyright (C) 2003, 2010 - Wolfire Games
3 Copyright (C) 2010-2016 - 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 "Environment/Terrain.hpp"
22
23 #include "Game.hpp"
24 #include "Objects/Object.hpp"
25 #include "Utils/Folders.hpp"
26 #include "Tutorial.hpp"
27
28 extern XYZ viewer;
29 extern float viewdistance;
30 extern float fadestart;
31 extern int environment;
32 extern float texscale;
33 extern Light light;
34 extern float multiplier;
35 extern FRUSTUM frustum;
36 extern float texdetail;
37 extern int detail;
38 extern bool decalstoggle;
39 extern float blurness;
40 extern float targetblurness;
41 extern bool skyboxtexture;
42
43 //Functions
44
45 int Terrain::lineTerrain(XYZ p1, XYZ p2, XYZ *p)
46 {
47     static int i, j, k;
48     static float distance;
49     static float olddistance;
50     static int intersecting;
51     static int firstintersecting;
52     static XYZ point;
53     static int startx, starty;
54     static int endx, endy;
55     static float highest, lowest;
56
57     firstintersecting = -1;
58     olddistance = 10000;
59     distance = 1;
60
61     XYZ triangles[3];
62
63     p1 /= scale;
64     p2 /= scale;
65
66     startx = p1.x;
67     starty = p1.z;
68     endx = p2.x;
69     endy = p2.z;
70
71     if (startx > endx) {
72         i = endx;
73         endx = startx;
74         startx = i;
75     }
76     if (starty > endy) {
77         i = endy;
78         endy = starty;
79         starty = i;
80     }
81
82     if (startx < 0)
83         startx = 0;
84     if (starty < 0)
85         starty = 0;
86     if (endx > size - 1)
87         endx = size - 1;
88     if (endy > size - 1)
89         endy = size - 1;
90
91     for (i = startx; i <= endx; i++) {
92         for (j = starty; j <= endy; j++) {
93             highest = -1000;
94             lowest = 1000;
95             for (k = 0; k < 2; k++) {
96                 if (heightmap[i + k][j] > highest)
97                     highest = heightmap[i + k][j];
98                 if (heightmap[i + k][j] < lowest)
99                     lowest = heightmap[i + k][j];
100                 if (heightmap[i + k][j + 1] > highest)
101                     highest = heightmap[i + k][j + 1];
102                 if (heightmap[i + k][j + 1] < lowest)
103                     lowest = heightmap[i + k][j + 1];
104             }
105             if ((p1.y <= highest || p2.y <= highest) && (p1.y >= lowest || p2.y >= lowest)) {
106                 triangles[0].x = i;
107                 triangles[0].y = heightmap[i][j];
108                 triangles[0].z = j;
109
110                 triangles[1].x = i;
111                 triangles[1].y = heightmap[i][j + 1];
112                 triangles[1].z = j + 1;
113
114                 triangles[2].x = i + 1;
115                 triangles[2].y = heightmap[i + 1][j];
116                 triangles[2].z = j;
117
118                 intersecting = LineFacet(p1, p2, triangles[0], triangles[1], triangles[2], &point);
119                 distance = distsq(&p1, &point);
120                 if ((distance < olddistance || firstintersecting == -1) && intersecting == 1) {
121                     olddistance = distance;
122                     firstintersecting = 1;
123                     *p = point;
124                 }
125
126                 triangles[0].x = i + 1;
127                 triangles[0].y = heightmap[i + 1][j];
128                 triangles[0].z = j;
129
130                 triangles[1].x = i;
131                 triangles[1].y = heightmap[i][j + 1];
132                 triangles[1].z = j + 1;
133
134                 triangles[2].x = i + 1;
135                 triangles[2].y = heightmap[i + 1][j + 1];
136                 triangles[2].z = j + 1;
137
138                 intersecting = LineFacet(p1, p2, triangles[0], triangles[1], triangles[2], &point);
139                 distance = distsq(&p1, &point);
140                 if ((distance < olddistance || firstintersecting == -1) && intersecting == 1) {
141                     olddistance = distance;
142                     firstintersecting = 1;
143                     *p = point;
144                 }
145             }
146         }
147     }
148     return firstintersecting;
149 }
150
151 void Terrain::UpdateTransparency(int whichx, int whichy)
152 {
153     static XYZ vertex;
154     static int i, j, a, b, c, d, patch_size, stepsize;
155     static float distance;
156
157     static float viewdistsquared;
158
159     viewdistsquared = viewdistance * viewdistance;
160     patch_size = size / subdivision;
161
162     stepsize = 1;
163     c = whichx * patch_elements + whichy * patch_elements * subdivision;
164
165     for (i = patch_size * whichx; i < patch_size * (whichx + 1) + 1; i += stepsize) {
166         for (j = patch_size * whichy; j < patch_size * (whichy + 1) + 1; j += stepsize) {
167             if (i < size && j < size) {
168                 vertex.x = i * scale;
169                 vertex.z = j * scale;
170                 vertex.y = heightmap[i][j] * scale;
171                 distance = distsq(&viewer, &vertex);
172                 if (distance > viewdistsquared)
173                     distance = viewdistsquared;
174                 colors[i][j][3] = (viewdistsquared - (distance - (viewdistsquared * fadestart)) * (1 / (1 - fadestart))) / viewdistsquared;
175             }
176         }
177     }
178
179     for (i = patch_size * whichx; i < patch_size * (whichx + 1); i += stepsize) {
180         for (j = patch_size * whichy; j < patch_size * (whichy + 1); j += stepsize) {
181             a = (i - (patch_size * whichx)) / stepsize;
182             b = (j - (patch_size * whichy)) / stepsize;
183             d = (a * 54) + (b * 54 * patch_size / stepsize);
184             vArray[d + c + 6] = colors[i][j][3];
185
186             vArray[d + c + 15] = colors[i][j + stepsize][3];
187
188             vArray[d + c + 24] = colors[i + stepsize][j][3];
189
190             vArray[d + c + 33] = colors[i + stepsize][j][3];
191
192             vArray[d + c + 42] = colors[i][j + stepsize][3];
193
194             vArray[d + c + 51] = colors[i + stepsize][j + stepsize][3];
195         }
196     }
197 }
198
199 void Terrain::UpdateTransparencyother(int whichx, int whichy)
200 {
201     static int i, j, a, b, c, d, patch_size, stepsize;
202
203     patch_size = size / subdivision;
204
205     stepsize = 1;
206     c = whichx * patch_elements + whichy * patch_elements * subdivision;
207
208     for (i = patch_size * whichx; i < patch_size * (whichx + 1); i += stepsize) {
209         for (j = patch_size * whichy; j < patch_size * (whichy + 1); j += stepsize) {
210             a = (i - (patch_size * whichx)) / stepsize;
211             b = (j - (patch_size * whichy)) / stepsize;
212             d = (a * 54) + (b * 54 * patch_size / stepsize);
213             vArray[d + c + 6] = colors[i][j][3] * opacityother[i][j];
214
215             vArray[d + c + 15] = colors[i][j + stepsize][3] * opacityother[i][j + stepsize];
216
217             vArray[d + c + 24] = colors[i + stepsize][j][3] * opacityother[i + stepsize][j];
218
219             vArray[d + c + 33] = colors[i + stepsize][j][3] * opacityother[i + stepsize][j];
220
221             vArray[d + c + 42] = colors[i][j + stepsize][3] * opacityother[i][j + stepsize];
222
223             vArray[d + c + 51] = colors[i + stepsize][j + stepsize][3] * opacityother[i + stepsize][j + stepsize];
224         }
225     }
226 }
227
228 void Terrain::UpdateTransparencyotherother(int whichx, int whichy)
229 {
230     static XYZ vertex;
231     static int i, j, a, b, c, d, patch_size, stepsize;
232     static float distance;
233
234     static float viewdistsquared;
235
236     viewdistsquared = viewdistance * viewdistance;
237     patch_size = size / subdivision;
238
239     stepsize = 1;
240     c = whichx * patch_elements + whichy * patch_elements * subdivision;
241
242     for (i = patch_size * whichx; i < patch_size * (whichx + 1) + 1; i += stepsize) {
243         for (j = patch_size * whichy; j < patch_size * (whichy + 1) + 1; j += stepsize) {
244             if (i < size && j < size) {
245                 vertex.x = i * scale;
246                 vertex.z = j * scale;
247                 vertex.y = heightmap[i][j] * scale;
248                 distance = distsq(&viewer, &vertex);
249                 if (distance > viewdistsquared)
250                     distance = viewdistsquared;
251                 colors[i][j][3] = (viewdistsquared - (distance - (viewdistsquared * fadestart)) * (1 / (1 - fadestart))) / viewdistsquared;
252             }
253         }
254     }
255
256     for (i = patch_size * whichx; i < patch_size * (whichx + 1); i += stepsize) {
257         for (j = patch_size * whichy; j < patch_size * (whichy + 1); j += stepsize) {
258             a = (i - (patch_size * whichx)) / stepsize;
259             b = (j - (patch_size * whichy)) / stepsize;
260             d = (a * 54) + (b * 54 * patch_size / stepsize);
261             vArray[d + c + 6] = colors[i][j][3];
262
263             vArray[d + c + 15] = colors[i][j + stepsize][3];
264
265             vArray[d + c + 24] = colors[i + stepsize][j][3];
266
267             vArray[d + c + 33] = colors[i + stepsize][j][3];
268
269             vArray[d + c + 42] = colors[i][j + stepsize][3];
270
271             vArray[d + c + 51] = colors[i + stepsize][j + stepsize][3];
272         }
273     }
274 }
275
276 void Terrain::UpdateVertexArray(int whichx, int whichy)
277 {
278     static int i, j, a, b, c, patch_size, stepsize;
279
280
281     numtris[whichx][whichy] = 0;
282
283     patch_size = size / subdivision;
284
285     stepsize = 1;
286     c = whichx * patch_elements + whichy * patch_elements * subdivision;
287     for (i = patch_size * whichx; i < patch_size * (whichx + 1); i += stepsize) {
288         for (j = patch_size * whichy; j < patch_size * (whichy + 1); j += stepsize) {
289             a = (i - ((float)size / subdivision * (float)whichx)) / stepsize;
290             b = (j - ((float)size / subdivision * (float)whichy)) / stepsize;
291             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 0] = i * scale;
292             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 1] = heightmap[i][j] * scale;
293             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 2] = j * scale;
294             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 3] = colors[i][j][0];
295             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 4] = colors[i][j][1];
296             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 5] = colors[i][j][2];
297             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 6] = colors[i][j][3];
298             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 7] = i * scale * texscale + texoffsetx[i][j];
299             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 8] = j * scale * texscale + texoffsety[i][j];
300
301             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 9] = i * scale;
302             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 10] = heightmap[i][j + stepsize] * scale;
303             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 11] = j * scale + stepsize * scale;
304             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 12] = colors[i][j + stepsize][0];
305             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 13] = colors[i][j + stepsize][1];
306             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 14] = colors[i][j + stepsize][2];
307             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 15] = colors[i][j + stepsize][3];
308             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 16] = i * scale * texscale + texoffsetx[i][j + stepsize];
309             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 17] = j * scale * texscale + stepsize * scale * texscale + texoffsety[i][j + stepsize];
310
311             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 18] = i * scale + stepsize * scale;
312             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 19] = heightmap[i + stepsize][j] * scale;
313             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 20] = j * scale;
314             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 21] = colors[i + stepsize][j][0];
315             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 22] = colors[i + stepsize][j][1];
316             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 23] = colors[i + stepsize][j][2];
317             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 24] = colors[i + stepsize][j][3];
318             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 25] = i * scale * texscale + stepsize * scale * texscale + texoffsetx[i + stepsize][j];
319             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 26] = j * scale * texscale + texoffsety[i + stepsize][j];
320
321             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 27] = i * scale + stepsize * scale;
322             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 28] = heightmap[i + stepsize][j] * scale;
323             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 29] = j * scale;
324             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 30] = colors[i + stepsize][j][0];
325             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 31] = colors[i + stepsize][j][1];
326             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 32] = colors[i + stepsize][j][2];
327             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 33] = colors[i + stepsize][j][3];
328             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 34] = i * scale * texscale + stepsize * scale * texscale + texoffsetx[i + stepsize][j];
329             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 35] = j * scale * texscale + texoffsety[i + stepsize][j];
330
331             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 36] = i * scale;
332             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 37] = heightmap[i][j + stepsize] * scale;
333             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 38] = j * scale + stepsize * scale;
334             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 39] = colors[i][j + stepsize][0];
335             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 40] = colors[i][j + stepsize][1];
336             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 41] = colors[i][j + stepsize][2];
337             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 42] = colors[i][j + stepsize][3];
338             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 43] = i * scale * texscale + texoffsetx[i][j + stepsize];
339             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 44] = j * scale * texscale + stepsize * scale * texscale + texoffsety[i][j + stepsize];
340
341             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 45] = i * scale + stepsize * scale;
342             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 46] = heightmap[i + stepsize][j + stepsize] * scale;
343             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 47] = j * scale + stepsize * scale;
344             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 48] = colors[i + stepsize][j + stepsize][0];
345             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 49] = colors[i + stepsize][j + stepsize][1];
346             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 50] = colors[i + stepsize][j + stepsize][2];
347             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 51] = colors[i + stepsize][j + stepsize][3];
348             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 52] = i * scale * texscale + stepsize * scale * texscale + texoffsetx[i + stepsize][j + stepsize];
349             vArray[(a * 54) + (b * 54 * patch_size / stepsize) + c + 53] = j * scale * texscale + stepsize * scale * texscale + texoffsety[i + stepsize][j + stepsize];
350             numtris[whichx][whichy] += 2;
351         }
352     }
353
354     maxypatch[whichx][whichy] = -10000;
355     minypatch[whichx][whichy] = 10000;
356     for (a = 0; a < size / subdivision; a++) {
357         for (b = 0; b < size / subdivision; b++) {
358             if (heightmap[(size / subdivision)*whichx + a][(size / subdivision)*whichy + b]*scale > maxypatch[whichx][whichy])
359                 maxypatch[whichx][whichy] = heightmap[(size / subdivision) * whichx + a][(size / subdivision) * whichy + b] * scale;
360             if (heightmap[(size / subdivision)*whichx + a][(size / subdivision)*whichy + b]*scale < minypatch[whichx][whichy])
361                 minypatch[whichx][whichy] = heightmap[(size / subdivision) * whichx + a][(size / subdivision) * whichy + b] * scale;
362         }
363     }
364     heightypatch[whichx][whichy] = (maxypatch[whichx][whichy] - minypatch[whichx][whichy]);
365     if (heightypatch[whichx][whichy] < size / subdivision * scale)
366         heightypatch[whichx][whichy] = size / subdivision * scale;
367     avgypatch[whichx][whichy] = (minypatch[whichx][whichy] + maxypatch[whichx][whichy]) / 2;
368
369     for (i = whichx * size / subdivision; i < (whichx + 1)*size / subdivision - 1; i++) {
370         for (j = whichy * size / subdivision; j < (whichy + 1)*size / subdivision - 1; j++) {
371             triangles[(i * (size - 1) * 2) + (j * 2)][0].x = i * scale;
372             triangles[(i * (size - 1) * 2) + (j * 2)][0].y = heightmap[i][j] * scale;
373             triangles[(i * (size - 1) * 2) + (j * 2)][0].z = j * scale;
374
375             triangles[(i * (size - 1) * 2) + (j * 2)][1].x = i * scale;
376             triangles[(i * (size - 1) * 2) + (j * 2)][1].y = heightmap[i][j + 1] * scale;
377             triangles[(i * (size - 1) * 2) + (j * 2)][1].z = j * scale + scale;
378
379             triangles[(i * (size - 1) * 2) + (j * 2)][2].x = i * scale + 1 * scale;
380             triangles[(i * (size - 1) * 2) + (j * 2)][2].y = heightmap[i + 1][j] * scale;
381             triangles[(i * (size - 1) * 2) + (j * 2)][2].z = j * scale;
382
383             triangles[(i * (size - 1) * 2) + (j * 2) + 1][0].x = i * scale + 1 * scale;
384             triangles[(i * (size - 1) * 2) + (j * 2) + 1][0].y = heightmap[i + 1][j] * scale;
385             triangles[(i * (size - 1) * 2) + (j * 2) + 1][0].z = j * scale;
386
387             triangles[(i * (size - 1) * 2) + (j * 2) + 1][1].x = i * scale;
388             triangles[(i * (size - 1) * 2) + (j * 2) + 1][1].y = heightmap[i][j + 1] * scale;
389             triangles[(i * (size - 1) * 2) + (j * 2) + 1][1].z = j * scale + 1 * scale;
390
391             triangles[(i * (size - 1) * 2) + (j * 2) + 1][2].x = i * scale + 1 * scale;
392             triangles[(i * (size - 1) * 2) + (j * 2) + 1][2].y = heightmap[i + 1][j + 1] * scale;
393             triangles[(i * (size - 1) * 2) + (j * 2) + 1][2].z = j * scale + 1 * scale;
394         }
395     }
396
397 }
398
399
400 bool Terrain::load(const std::string& fileName)
401 {
402     static long i, j;
403     static long x, y;
404     static float patch_size;
405
406     float temptexdetail = texdetail;
407
408     ImageRec texture;
409
410     //Load Image
411     if (!load_image(Folders::getResourcePath(fileName).c_str(), texture)) {
412         return false;
413     }
414
415     //Is it valid?
416     if (texture.bpp > 24) {
417         int bytesPerPixel = texture.bpp / 8;
418
419         int tempnum = 0;
420         for (i = 0; i < (long)(texture.sizeY * texture.sizeX * bytesPerPixel); i++) {
421             if ((i + 1) % 4) {
422                 texture.data[tempnum] = texture.data[i];
423                 tempnum++;
424             }
425         }
426     }
427     texture.bpp = 24;
428     Game::LoadingScreen();
429
430     texdetail = temptexdetail;
431
432     size = texture.sizeX;
433
434     for (i = 0; i < size; i++) {
435         for (j = 0; j < size; j++) {
436             heightmap[size - 1 - i][j] = (float)((texture.data[(i + (j * size)) * texture.bpp / 8])) / 5;
437         }
438     }
439
440     Game::LoadingScreen();
441
442     float slopeness;
443
444     for (i = 0; i < subdivision; i++) {
445         for (j = 0; j < subdivision; j++) {
446             textureness[i][j] = -1;
447         }
448     }
449     Game::LoadingScreen();
450
451
452     for (i = 0; i < size; i++) {
453         for (j = 0; j < size; j++) {
454             heightmap[i][j] *= .5;
455
456             texoffsetx[i][j] = (float)abs(Random() % 100) / 1200 / scale * 3;
457             texoffsety[i][j] = (float)abs(Random() % 100) / 1200 / scale * 3;
458
459             slopeness = 0;
460             if (environment == snowyenvironment) {
461                 if (j != 0 && heightmap[i][j] - heightmap[i][j - 1] > slopeness) {
462                     slopeness = heightmap[i][j] - heightmap[i][j - 1];
463                 }
464                 opacityother[i][j] = slopeness * slopeness * 2;
465                 if (opacityother[i][j] > 1)
466                     opacityother[i][j] = 1;
467                 opacityother[i][j] -= (float)abs(Random() % 100) / 300;
468             }
469             if (environment == desertenvironment) {
470                 if (j != 0 && heightmap[i][j] - heightmap[i][j - 1] > slopeness) {
471                     slopeness = heightmap[i][j] - heightmap[i][j - 1];
472                 }
473                 opacityother[i][j] = slopeness * slopeness * 2;
474                 if (opacityother[i][j] > 1)
475                     opacityother[i][j] = 1;
476                 opacityother[i][j] -= (float)abs(Random() % 100) / 300;
477             }
478             if (environment == grassyenvironment) {
479                 if (i != 0 && heightmap[i][j] - heightmap[i - 1][j] > slopeness) {
480                     slopeness = heightmap[i][j] - heightmap[i - 1][j];
481                 }
482                 if (j != 0 && heightmap[i][j] - heightmap[i][j - 1] > slopeness) {
483                     slopeness = heightmap[i][j] - heightmap[i][j - 1];
484                 }
485                 if (i < size - 1 && heightmap[i][j] - heightmap[i + 1][j] > slopeness) {
486                     slopeness = heightmap[i][j] - heightmap[i + 1][j];
487                 }
488                 if (j < size - 1 && heightmap[i][j] - heightmap[i][j + 1] > slopeness) {
489                     slopeness = heightmap[i][j] - heightmap[i][j + 1];
490                 }
491                 opacityother[i][j] = slopeness * slopeness * 10;
492                 if (opacityother[i][j] > 1)
493                     opacityother[i][j] = 1;
494                 opacityother[i][j] -= (float)abs(Random() % 100) / 100;
495             }
496         }
497     }
498     Game::LoadingScreen();
499
500     for (i = 0; i < size; i++) {
501         for (j = 0; j < size; j++) {
502             if (environment == snowyenvironment) {
503                 heightmap[i][j] -= opacityother[i][j];
504             }
505             if (environment == desertenvironment) {
506                 heightmap[i][j] -= opacityother[i][j];
507             }
508         }
509     }
510     Game::LoadingScreen();
511
512     for (i = 0; i < size; i++) {
513         for (j = 0; j < size; j++) {
514             if (opacityother[i][j] < .1)
515                 opacityother[i][j] = 0;
516             if (textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == -1) {
517                 if (!opacityother[i][j])
518                     textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = allfirst;
519                 if (opacityother[i][j] == 1)
520                     textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = allsecond;
521             }
522             if (opacityother[i][j] && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allfirst)
523                 textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
524             if (opacityother[i][j] != 1 && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allsecond)
525                 textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
526
527             x = i;
528             y = j;
529             if (i > 0) {
530                 i--;
531                 if (opacityother[x][y] && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allfirst)
532                     textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
533                 if (opacityother[x][y] != 1 && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allsecond)
534                     textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
535                 if (opacityother[i][j] && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allfirst)
536                     textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
537                 if (opacityother[i][j] != 1 && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allsecond)
538                     textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
539
540                 if (j > 0) {
541                     j--;
542                     if (opacityother[x][y] && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allfirst)
543                         textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
544                     if (opacityother[x][y] != 1 && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allsecond)
545                         textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
546                     if (opacityother[i][j] && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allfirst)
547                         textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
548                     if (opacityother[i][j] != 1 && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allsecond)
549                         textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
550                     j++;
551                 }
552
553                 if (j < size - 1) {
554                     j++;
555                     if (opacityother[x][y] && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allfirst)
556                         textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
557                     if (opacityother[x][y] != 1 && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allsecond)
558                         textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
559                     if (opacityother[i][j] && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allfirst)
560                         textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
561                     if (opacityother[i][j] != 1 && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allsecond)
562                         textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
563                     j--;
564                 }
565                 i++;
566             }
567
568             if (i < size - 1) {
569                 i++;
570                 if (opacityother[x][y] && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allfirst)
571                     textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
572                 if (opacityother[x][y] != 1 && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allsecond)
573                     textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
574                 if (opacityother[i][j] && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allfirst)
575                     textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
576                 if (opacityother[i][j] != 1 && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allsecond)
577                     textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
578
579                 if (j > 0) {
580                     j--;
581                     if (opacityother[x][y] && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allfirst)
582                         textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
583                     if (opacityother[x][y] != 1 && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allsecond)
584                         textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
585                     if (opacityother[i][j] && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allfirst)
586                         textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
587                     if (opacityother[i][j] != 1 && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allsecond)
588                         textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
589                     j++;
590                 }
591
592                 if (j < size - 1) {
593                     j++;
594                     if (opacityother[x][y] && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allfirst)
595                         textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
596                     if (opacityother[x][y] != 1 && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allsecond)
597                         textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
598                     if (opacityother[i][j] && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allfirst)
599                         textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
600                     if (opacityother[i][j] != 1 && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allsecond)
601                         textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
602                     j--;
603                 }
604                 i--;
605             }
606
607             if (j > 0) {
608                 j--;
609                 if (opacityother[x][y] && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allfirst)
610                     textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
611                 if (opacityother[x][y] != 1 && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allsecond)
612                     textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
613                 if (opacityother[i][j] && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allfirst)
614                     textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
615                 if (opacityother[i][j] != 1 && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allsecond)
616                     textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
617                 j++;
618             }
619
620             if (j < size - 1) {
621                 j++;
622                 if (opacityother[x][y] && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allfirst)
623                     textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
624                 if (opacityother[x][y] != 1 && textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] == allsecond)
625                     textureness[(int)(i * subdivision / size)][(int)(j * subdivision / size)] = mixed;
626                 if (opacityother[i][j] && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allfirst)
627                     textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
628                 if (opacityother[i][j] != 1 && textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] == allsecond)
629                     textureness[(int)(x * subdivision / size)][(int)(y * subdivision / size)] = mixed;
630                 j--;
631
632             }
633         }
634     }
635     Game::LoadingScreen();
636
637     patch_size = size / subdivision;
638     patch_elements = (patch_size) * (patch_size) * 54;
639     CalculateNormals();
640
641     return true;
642 }
643
644 void Terrain::CalculateNormals()
645 {
646     static int i, j;
647     static XYZ facenormal;
648     static XYZ p, q, a, b, c;
649
650     for (i = 0; i < size; i++) {
651         for (j = 0; j < size; j++) {
652             normals[i][j].x = 0;
653             normals[i][j].y = 0;
654             normals[i][j].z = 0;
655         }
656     }
657
658     for (i = 0; i < size - 1; i++) {
659         for (j = 0; j < size - 1; j++) {
660             a.x = i;
661             a.y = heightmap[i][j];
662             a.z = j;
663             b.x = i;
664             b.y = heightmap[i][j + 1];
665             b.z = j + 1;
666             c.x = i + 1;
667             c.y = heightmap[i + 1][j];
668             c.z = j;
669
670             p.x = b.x - a.x;
671             p.y = b.y - a.y;
672             p.z = b.z - a.z;
673             q.x = c.x - a.x;
674             q.y = c.y - a.y;
675             q.z = c.z - a.z;
676
677             CrossProduct(&p, &q, &facenormal);
678
679             facenormals[i][j] = facenormal;
680
681             normals[i][j] = normals[i][j] + facenormal;
682             normals[i][j + 1] = normals[i][j + 1] + facenormal;
683             normals[i + 1][j] = normals[i + 1][j] + facenormal;
684
685
686             a.x = i + 1;
687             a.y = heightmap[i + 1][j];
688             a.z = j;
689             b.x = i;
690             b.y = heightmap[i][j + 1];
691             b.z = j + 1;
692             c.x = i + 1;
693             c.y = heightmap[i + 1][j + 1];
694             c.z = j + 1;
695
696             p.x = b.x - a.x;
697             p.y = b.y - a.y;
698             p.z = b.z - a.z;
699             q.x = c.x - a.x;
700             q.y = c.y - a.y;
701             q.z = c.z - a.z;
702
703             CrossProduct(&p, &q, &facenormal);
704
705             normals[i + 1][j + 1] = normals[i + 1][j + 1] + facenormal;
706             normals[i][j + 1] = normals[i][j + 1] + facenormal;
707             normals[i + 1][j] = normals[i + 1][j] + facenormal;
708
709             Normalise(&facenormals[i][j]);
710         }
711     }
712
713     for (i = 0; i < size; i++) {
714         for (j = 0; j < size; j++) {
715             Normalise(&normals[i][j]);
716         }
717     }
718 }
719
720 void Terrain::drawpatch(int whichx, int whichy, float opacity)
721 {
722     if (opacity >= 1)
723         glDisable(GL_BLEND);
724     if (opacity < 1) {
725         glEnable(GL_BLEND);
726         UpdateTransparency(whichx, whichy);
727     }
728
729     glColor4f(1, 1, 1, 1);
730
731     //Set up vertex array
732     glEnableClientState(GL_VERTEX_ARRAY);
733     glEnableClientState(GL_COLOR_ARRAY);
734     glEnableClientState(GL_TEXTURE_COORD_ARRAY);
735     glVertexPointer(3, GL_FLOAT, 9 * sizeof(GLfloat), &vArray[0 + whichx * patch_elements + whichy * patch_elements * subdivision]);
736     glColorPointer(4, GL_FLOAT, 9 * sizeof(GLfloat), &vArray[3 + whichx * patch_elements + whichy * patch_elements * subdivision]);
737     glTexCoordPointer(2, GL_FLOAT, 9 * sizeof(GLfloat), &vArray[7 + whichx * patch_elements + whichy * patch_elements * subdivision]);
738
739     //Draw
740     glDrawArrays(GL_TRIANGLES, 0, numtris[whichx][whichy] * 3);
741
742     glDisableClientState(GL_VERTEX_ARRAY);
743     glDisableClientState(GL_COLOR_ARRAY);
744     glDisableClientState(GL_TEXTURE_COORD_ARRAY);
745 }
746
747 void Terrain::drawpatchother(int whichx, int whichy, float opacity)
748 {
749     glEnable(GL_BLEND);
750     if (opacity < 1) {
751         UpdateTransparency(whichx, whichy);
752     }
753     UpdateTransparencyother(whichx, whichy);
754
755     glColor4f(1, 1, 1, 1);
756
757     //Set up vertex array
758     glEnableClientState(GL_VERTEX_ARRAY);
759     glEnableClientState(GL_COLOR_ARRAY);
760     glEnableClientState(GL_TEXTURE_COORD_ARRAY);
761     glVertexPointer(3, GL_FLOAT, 9 * sizeof(GLfloat), &vArray[0 + whichx * patch_elements + whichy * patch_elements * subdivision]);
762     glColorPointer(4, GL_FLOAT, 9 * sizeof(GLfloat), &vArray[3 + whichx * patch_elements + whichy * patch_elements * subdivision]);
763     glTexCoordPointer(2, GL_FLOAT, 9 * sizeof(GLfloat), &vArray[7 + whichx * patch_elements + whichy * patch_elements * subdivision]);
764
765     //Draw
766     glDrawArrays(GL_TRIANGLES, 0, numtris[whichx][whichy] * 3);
767
768     glDisableClientState(GL_VERTEX_ARRAY);
769     glDisableClientState(GL_COLOR_ARRAY);
770     glDisableClientState(GL_TEXTURE_COORD_ARRAY);
771 }
772
773 void Terrain::drawpatchotherother(int whichx, int whichy)
774 {
775     glEnable(GL_BLEND);
776     UpdateTransparencyotherother(whichx, whichy);
777
778     glMatrixMode(GL_TEXTURE);
779     glPushMatrix();
780     glScalef(6, 6, 6);
781
782     glColor4f(1, 1, 1, 1);
783
784     //Set up vertex array
785     glEnableClientState(GL_VERTEX_ARRAY);
786     glEnableClientState(GL_COLOR_ARRAY);
787     glEnableClientState(GL_TEXTURE_COORD_ARRAY);
788     glVertexPointer(3, GL_FLOAT, 9 * sizeof(GLfloat), &vArray[0 + whichx * patch_elements + whichy * patch_elements * subdivision]);
789     glColorPointer(4, GL_FLOAT, 9 * sizeof(GLfloat), &vArray[3 + whichx * patch_elements + whichy * patch_elements * subdivision]);
790     glTexCoordPointer(2, GL_FLOAT, 9 * sizeof(GLfloat), &vArray[7 + whichx * patch_elements + whichy * patch_elements * subdivision]);
791
792     //Draw
793     glDrawArrays(GL_TRIANGLES, 0, numtris[whichx][whichy] * 3);
794
795     glDisableClientState(GL_VERTEX_ARRAY);
796     glDisableClientState(GL_COLOR_ARRAY);
797     glDisableClientState(GL_TEXTURE_COORD_ARRAY);
798
799     glPopMatrix();
800     glMatrixMode(GL_MODELVIEW);
801 }
802
803
804 float Terrain::getHeight(float pointx, float pointz)
805 {
806     static int tilex, tiley;
807     static XYZ startpoint, endpoint, intersect, triangle[3];
808
809     pointx /= scale;
810     pointz /= scale;
811
812     if (pointx >= size - 1 || pointz >= size - 1 || pointx <= 0 || pointz <= 0)
813         return 0;
814
815     startpoint.x = pointx;
816     startpoint.y = -1000;
817     startpoint.z = pointz;
818
819     endpoint = startpoint;
820     endpoint.y = 1000;
821
822     tilex = pointx;
823     tiley = pointz;
824
825     triangle[0].x = tilex;
826     triangle[0].z = tiley;
827     triangle[0].y = heightmap[tilex][tiley];
828
829     triangle[1].x = tilex + 1;
830     triangle[1].z = tiley;
831     triangle[1].y = heightmap[tilex + 1][tiley];
832
833     triangle[2].x = tilex;
834     triangle[2].z = tiley + 1;
835     triangle[2].y = heightmap[tilex][tiley + 1];
836
837     if (!LineFacetd(&startpoint, &endpoint, &triangle[0], &triangle[1], &triangle[2], &intersect)) {
838         triangle[0].x = tilex + 1;
839         triangle[0].z = tiley;
840         triangle[0].y = heightmap[tilex + 1][tiley];
841
842         triangle[1].x = tilex + 1;
843         triangle[1].z = tiley + 1;
844         triangle[1].y = heightmap[tilex + 1][tiley + 1];
845
846         triangle[2].x = tilex;
847         triangle[2].z = tiley + 1;
848         triangle[2].y = heightmap[tilex][tiley + 1];
849         LineFacetd(&startpoint, &endpoint, &triangle[0], &triangle[1], &triangle[2], &intersect);
850     }
851     return intersect.y * scale + getOpacity(pointx * scale, pointz * scale) / 8;
852 }
853
854 float Terrain::getOpacity(float pointx, float pointz)
855 {
856     static float height1, height2;
857     static int tilex, tiley;
858
859     pointx /= scale;
860     pointz /= scale;
861
862     if (pointx >= size - 1 || pointz >= size - 1 || pointx <= 0 || pointz <= 0)
863         return 0;
864
865     tilex = pointx;
866     tiley = pointz;
867
868     height1 = opacityother[tilex][tiley] * (1 - (pointx - tilex)) + opacityother[tilex + 1][tiley] * (pointx - tilex);
869     height2 = opacityother[tilex][tiley + 1] * (1 - (pointx - tilex)) + opacityother[tilex + 1][tiley + 1] * (pointx - tilex);
870
871     return height1 * (1 - (pointz - tiley)) + height2 * (pointz - tiley);
872 }
873
874 XYZ Terrain::getNormal(float pointx, float pointz)
875 {
876     static XYZ height1, height2, total;
877     static int tilex, tiley;
878
879     pointx /= scale;
880     pointz /= scale;
881
882     height1 = 0;
883     if (pointx >= size - 1 || pointz >= size - 1 || pointx <= 0 || pointz <= 0)
884         return height1;
885     tilex = pointx;
886     tiley = pointz;
887
888     height1 = normals[tilex][tiley] * (1 - (pointx - tilex)) + normals[tilex + 1][tiley] * (pointx - tilex);
889     height2 = normals[tilex][tiley + 1] * (1 - (pointx - tilex)) + normals[tilex + 1][tiley + 1] * (pointx - tilex);
890     total = height1 * (1 - (pointz - tiley)) + height2 * (pointz - tiley);
891     Normalise(&total);
892     return total;
893 }
894
895 XYZ Terrain::getLighting(float pointx, float pointz)
896 {
897     static XYZ height1, height2;
898     static int tilex, tiley;
899
900     pointx /= scale;
901     pointz /= scale;
902
903     height1 = 0;
904     if (pointx >= size - 1 || pointz >= size - 1 || pointx <= 0 || pointz <= 0)
905         return height1;
906     tilex = pointx;
907     tiley = pointz;
908
909     height1.x = colors[tilex][tiley][0] * (1 - (pointx - tilex)) + colors[tilex + 1][tiley][0] * (pointx - tilex);
910     height1.y = colors[tilex][tiley][1] * (1 - (pointx - tilex)) + colors[tilex + 1][tiley][1] * (pointx - tilex);
911     height1.z = colors[tilex][tiley][2] * (1 - (pointx - tilex)) + colors[tilex + 1][tiley][2] * (pointx - tilex);
912     height2.x = colors[tilex][tiley + 1][0] * (1 - (pointx - tilex)) + colors[tilex + 1][tiley + 1][0] * (pointx - tilex);
913     height2.y = colors[tilex][tiley + 1][1] * (1 - (pointx - tilex)) + colors[tilex + 1][tiley + 1][1] * (pointx - tilex);
914     height2.z = colors[tilex][tiley + 1][2] * (1 - (pointx - tilex)) + colors[tilex + 1][tiley + 1][2] * (pointx - tilex);
915
916     return height1 * (1 - (pointz - tiley)) + height2 * (pointz - tiley);
917 }
918
919 void Terrain::draw(int layer)
920 {
921     static int i, j;
922     static float opacity;
923     static XYZ terrainpoint;
924     static float distance[subdivision][subdivision];
925
926     static int beginx, endx;
927     static int beginz, endz;
928
929     static float patch_size = size / subdivision * scale;
930     static float viewdistsquared;
931
932     viewdistsquared = viewdistance * viewdistance;
933
934     //Only nearby blocks
935     beginx = (viewer.x - viewdistance) / (patch_size) - 1;
936     if (beginx < 0)
937         beginx = 0;
938     beginz = (viewer.z - viewdistance) / (patch_size) - 1;
939     if (beginz < 0)
940         beginz = 0;
941
942     endx = (viewer.x + viewdistance) / (patch_size) + 1;
943     if (endx > subdivision)
944         endx = subdivision;
945     endz = (viewer.z + viewdistance) / (patch_size) + 1;
946     if (endz > subdivision)
947         endz = subdivision;
948
949     if (!layer) {
950         for (i = beginx; i < endx; i++) {
951             for (j = beginz; j < endz; j++) {
952                 terrainpoint.x = i * patch_size + (patch_size) / 2;
953                 terrainpoint.y = viewer.y; //heightmap[i][j]*scale;
954                 terrainpoint.z = j * patch_size + (patch_size) / 2;
955                 distance[i][j] = distsq(&viewer, &terrainpoint);
956             }
957         }
958     }
959     for (i = beginx; i < endx; i++) {
960         for (j = beginz; j < endz; j++) {
961             if (distance[i][j] < (viewdistance + patch_size) * (viewdistance + patch_size)) {
962                 opacity = 1;
963                 if (distance[i][j] > viewdistsquared * fadestart - viewdistsquared)
964                     opacity = 0;
965                 if (opacity == 1 && i != subdivision)
966                     if (distance[i + 1][j] > viewdistsquared * fadestart - viewdistsquared)
967                         opacity = 0;
968                 if (opacity == 1 && j != subdivision)
969                     if (distance[i][j + 1] > viewdistsquared * fadestart - viewdistsquared)
970                         opacity = 0;
971                 if (opacity == 1 && j != subdivision && i != subdivision)
972                     if (distance[i + 1][j + 1] > viewdistsquared * fadestart - viewdistsquared)
973                         opacity = 0;
974                 glMatrixMode(GL_MODELVIEW);
975                 glPushMatrix();
976                 if (frustum.CubeInFrustum(i * patch_size + patch_size * .5, avgypatch[i][j], j * patch_size + patch_size * .5, heightypatch[i][j] / 2)) {
977                     if (environment == desertenvironment && distance[i][j] > viewdistsquared / 4)
978                         glTexEnvf( GL_TEXTURE_FILTER_CONTROL_EXT, GL_TEXTURE_LOD_BIAS_EXT, blurness);
979                     else if (environment == desertenvironment)
980                         glTexEnvf( GL_TEXTURE_FILTER_CONTROL_EXT, GL_TEXTURE_LOD_BIAS_EXT, 0 );
981                     if (!layer && textureness[i][j] != allsecond)
982                         drawpatch(i, j, opacity);
983                     if (layer == 1 && textureness[i][j] != allfirst)
984                         drawpatchother(i, j, opacity);
985                     if (layer == 2 && textureness[i][j] != allfirst)
986                         drawpatchotherother(i, j);
987                 }
988                 glPopMatrix();
989             }
990         }
991     }
992     if (environment == desertenvironment)
993         glTexEnvf( GL_TEXTURE_FILTER_CONTROL_EXT, GL_TEXTURE_LOD_BIAS_EXT, 0 );
994 }
995
996 void Terrain::drawdecals()
997 {
998     if (decalstoggle) {
999         static float distancemult;
1000         static int lasttype;
1001
1002         static float viewdistsquared;
1003         static bool blend;
1004
1005         viewdistsquared = viewdistance * viewdistance;
1006         blend = 1;
1007
1008         lasttype = -1;
1009         glEnable(GL_BLEND);
1010         glDisable(GL_LIGHTING);
1011         glDisable(GL_CULL_FACE);
1012         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1013         glDepthMask(0);
1014         for (unsigned int i = 0; i < decals.size(); i++) {
1015             if (decals[i].type == blooddecalfast && decals[i].alivetime < 2)
1016                 decals[i].alivetime = 2;
1017             if (decals[i].type != lasttype) {
1018                 if (decals[i].type == shadowdecal || decals[i].type == shadowdecalpermanent) {
1019                     shadowtexture.bind();
1020                     if (!blend) {
1021                         blend = 1;
1022                         glAlphaFunc(GL_GREATER, 0.0001);
1023                         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1024                     }
1025                 }
1026                 if (decals[i].type == footprintdecal) {
1027                     footprinttexture.bind();
1028                     if (!blend) {
1029                         blend = 1;
1030                         glAlphaFunc(GL_GREATER, 0.0001);
1031                         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1032                     }
1033                 }
1034                 if (decals[i].type == bodyprintdecal) {
1035                     bodyprinttexture.bind();
1036                     if (!blend) {
1037                         blend = 1;
1038                         glAlphaFunc(GL_GREATER, 0.0001);
1039                         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1040                     }
1041                 }
1042                 if (decals[i].type == blooddecal || decals[i].type == blooddecalslow) {
1043                     bloodtexture.bind();
1044                     if (blend) {
1045                         blend = 0;
1046                         glAlphaFunc(GL_GREATER, 0.15);
1047                         glBlendFunc(GL_ONE, GL_ZERO);
1048                     }
1049                 }
1050                 if (decals[i].type == blooddecalfast) {
1051                     bloodtexture2.bind();
1052                     if (blend) {
1053                         blend = 0;
1054                         glAlphaFunc(GL_GREATER, 0.15);
1055                         glBlendFunc(GL_ONE, GL_ZERO);
1056                     }
1057                 }
1058             }
1059             if (decals[i].type == shadowdecal || decals[i].type == shadowdecalpermanent) {
1060                 distancemult = (viewdistsquared - (distsq(&viewer, &decals[i].position) - (viewdistsquared * fadestart)) * (1 / (1 - fadestart))) / viewdistsquared;
1061                 if (distancemult >= 1)
1062                     glColor4f(1, 1, 1, decals[i].opacity);
1063                 if (distancemult < 1)
1064                     glColor4f(1, 1, 1, decals[i].opacity*distancemult);
1065             }
1066             if (decals[i].type == footprintdecal || decals[i].type == bodyprintdecal) {
1067                 distancemult = (viewdistsquared - (distsq(&viewer, &decals[i].position) - (viewdistsquared * fadestart)) * (1 / (1 - fadestart))) / viewdistsquared;
1068                 if (distancemult >= 1) {
1069                     glColor4f(1, 1, 1, decals[i].opacity);
1070                     if (decals[i].alivetime > 3)
1071                         glColor4f(1, 1, 1, decals[i].opacity * (5 - decals[i].alivetime) / 2);
1072                 }
1073                 if (distancemult < 1) {
1074                     glColor4f(1, 1, 1, decals[i].opacity*distancemult);
1075                     if (decals[i].alivetime > 3)
1076                         glColor4f(1, 1, 1, decals[i].opacity * (5 - decals[i].alivetime) / 2 * distancemult);
1077                 }
1078             }
1079             if ((decals[i].type == blooddecal || decals[i].type == blooddecalfast || decals[i].type == blooddecalslow)) {
1080                 distancemult = (viewdistsquared - (distsq(&viewer, &decals[i].position) - (viewdistsquared * fadestart)) * (1 / (1 - fadestart))) / viewdistsquared;
1081                 if (distancemult >= 1) {
1082                     glColor4f(decals[i].brightness, decals[i].brightness, decals[i].brightness, decals[i].opacity);
1083                     if (decals[i].alivetime < 4)
1084                         glColor4f(decals[i].brightness, decals[i].brightness, decals[i].brightness, decals[i].opacity*decals[i].alivetime*.25);
1085                     if (decals[i].alivetime > 58)
1086                         glColor4f(decals[i].brightness, decals[i].brightness, decals[i].brightness, decals[i].opacity * (60 - decals[i].alivetime) / 2);
1087                 }
1088                 if (distancemult < 1) {
1089                     glColor4f(decals[i].brightness, decals[i].brightness, decals[i].brightness, decals[i].opacity*distancemult);
1090                     if (decals[i].alivetime < 4)
1091                         glColor4f(decals[i].brightness, decals[i].brightness, decals[i].brightness, decals[i].opacity*decals[i].alivetime*distancemult * .25);
1092                     if (decals[i].alivetime > 58)
1093                         glColor4f(decals[i].brightness, decals[i].brightness, decals[i].brightness, decals[i].opacity * (60 - decals[i].alivetime) / 2 * distancemult);
1094                 }
1095             }
1096             lasttype = decals[i].type;
1097             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
1098             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
1099
1100             glMatrixMode(GL_MODELVIEW);
1101             glPushMatrix();
1102             glBegin(GL_TRIANGLES);
1103             for (int j = 0; j < 3; j++) {
1104                 glTexCoord2f(decals[i].texcoords[j][0], decals[i].texcoords[j][1]);
1105                 glVertex3f(decals[i].vertex[j].x, decals[i].vertex[j].y, decals[i].vertex[j].z);
1106             }
1107             glEnd();
1108             glPopMatrix();
1109         }
1110         for (int i = decals.size() - 1; i >= 0; i--) {
1111             decals[i].alivetime += multiplier;
1112             if (decals[i].type == blooddecalslow)
1113                 decals[i].alivetime -= multiplier * 2 / 3;
1114             if (decals[i].type == blooddecalfast)
1115                 decals[i].alivetime += multiplier * 4;
1116             if (decals[i].type == shadowdecal)
1117                 DeleteDecal(i);
1118             if (decals[i].type == footprintdecal && decals[i].alivetime >= 5)
1119                 DeleteDecal(i);
1120             if (decals[i].type == bodyprintdecal && decals[i].alivetime >= 5)
1121                 DeleteDecal(i);
1122             if ((decals[i].type == blooddecal || decals[i].type == blooddecalfast || decals[i].type == blooddecalslow) && decals[i].alivetime >= 60)
1123                 DeleteDecal(i);
1124         }
1125         glAlphaFunc(GL_GREATER, 0.0001);
1126     }
1127 }
1128
1129 void Terrain::deleteDeadDecals()
1130 {
1131     for (int i = decals.size() - 1; i >= 0; i--) {
1132         if ((decals[i].type == blooddecal || decals[i].type == blooddecalslow) && decals[i].alivetime < 2) {
1133             DeleteDecal(i);
1134         }
1135     }
1136 }
1137
1138 void Terrain::AddObject(XYZ where, float radius, int id)
1139 {
1140     XYZ points[2];
1141     if (id >= 0 && id < 10000) {
1142         for (int i = 0; i < subdivision; i++) {
1143             for (int j = 0; j < subdivision; j++) {
1144                 if (patchobjectnum[i][j] < 300 - 1) {
1145                     points[0].x = (size / subdivision) * i;
1146                     points[0].z = (size / subdivision) * j;
1147                     points[0].y = heightmap[(int)points[0].x][(int)points[0].z];
1148                     points[1].x = (size / subdivision) * (i + 1);
1149                     points[1].z = (size / subdivision) * (j + 1);
1150                     points[1].y = heightmap[(int)points[1].x][(int)points[1].z];
1151                     points[0] *= scale;
1152                     points[1] *= scale;
1153                     if (where.x + radius > points[0].x && where.x - radius < points[1].x && where.z + radius > points[0].z && where.z - radius < points[1].z) {
1154                         patchobjects[i][j][patchobjectnum[i][j]] = id;
1155                         patchobjectnum[i][j]++;
1156                     }
1157                 }
1158             }
1159         }
1160     }
1161 }
1162
1163 void Terrain::DeleteDecal(int which)
1164 {
1165     if (decalstoggle) {
1166         decals.erase(decals.begin() + which);
1167     }
1168 }
1169
1170 void Terrain::MakeDecal(decal_type type, XYZ where, float size, float opacity, float rotation)
1171 {
1172     if (decalstoggle) {
1173         if (opacity > 0 && size > 0) {
1174             static int patchx[4];
1175             static int patchy[4];
1176
1177             patchx[0] = (where.x + size) / scale;
1178             patchx[1] = (where.x - size) / scale;
1179             patchx[2] = (where.x - size) / scale;
1180             patchx[3] = (where.x + size) / scale;
1181
1182             patchy[0] = (where.z - size) / scale;
1183             patchy[1] = (where.z - size) / scale;
1184             patchy[2] = (where.z + size) / scale;
1185             patchy[3] = (where.z + size) / scale;
1186
1187             if ((patchx[0] != patchx[1] || patchy[0] != patchy[1]) && (patchx[0] != patchx[2] || patchy[0] != patchy[2]) && (patchx[0] != patchx[3] || patchy[0] != patchy[3])) {
1188                 MakeDecalLock(type, where, patchx[0], patchy[0], size, opacity, rotation);
1189             }
1190
1191             if ((patchx[1] != patchx[2] || patchy[1] != patchy[2]) && (patchx[1] != patchx[3] || patchy[1] != patchy[3])) {
1192                 MakeDecalLock(type, where, patchx[1], patchy[1], size, opacity, rotation);
1193             }
1194
1195             if ((patchx[2] != patchx[3] || patchy[2] != patchy[3])) {
1196                 MakeDecalLock(type, where, patchx[2], patchy[2], size, opacity, rotation);
1197             }
1198
1199             MakeDecalLock(type, where, patchx[3], patchy[3], size, opacity, rotation);
1200         }
1201     }
1202 }
1203
1204 void Terrain::MakeDecalLock(decal_type type, XYZ where, int whichx, int whichy, float size, float opacity, float rotation)
1205 {
1206     if (decalstoggle) {
1207         XYZ rot = getLighting(where.x, where.z);
1208         float decalbright = (rot.x + rot.y + rot.z) / 3;
1209
1210         if (decalbright < .4)
1211             decalbright = .4;
1212
1213         if (environment == grassyenvironment) {
1214             decalbright *= .6;
1215         }
1216
1217         if (decalbright > 1) {
1218             decalbright = 1;
1219         }
1220
1221         Decal decal(where, type, opacity, rotation, decalbright, whichx, whichy, size, *this, true);
1222
1223         if (!(decal.texcoords[0][0] < 0 && decal.texcoords[1][0] < 0 && decal.texcoords[2][0] < 0))
1224             if (!(decal.texcoords[0][1] < 0 && decal.texcoords[1][1] < 0 && decal.texcoords[2][1] < 0))
1225                 if (!(decal.texcoords[0][0] > 1 && decal.texcoords[1][0] > 1 && decal.texcoords[2][0] > 1))
1226                     if (!(decal.texcoords[0][1] > 1 && decal.texcoords[1][1] > 1 && decal.texcoords[2][1] > 1))
1227                         if (decals.size() < max_decals - 1)
1228                             decals.push_back(decal);
1229
1230         Decal decal2(where, type, opacity, rotation, decalbright, whichx, whichy, size, *this, false);
1231
1232         if (!(decal2.texcoords[0][0] < 0 && decal2.texcoords[1][0] < 0 && decal2.texcoords[2][0] < 0))
1233             if (!(decal2.texcoords[0][1] < 0 && decal2.texcoords[1][1] < 0 && decal2.texcoords[2][1] < 0))
1234                 if (!(decal2.texcoords[0][0] > 1 && decal2.texcoords[1][0] > 1 && decal2.texcoords[2][0] > 1))
1235                     if (!(decal2.texcoords[0][1] > 1 && decal2.texcoords[1][1] > 1 && decal2.texcoords[2][1] > 1))
1236                         if (decals.size() < max_decals - 1)
1237                             decals.push_back(decal2);
1238     }
1239 }
1240
1241 void Terrain::DoShadows()
1242 {
1243     static int i, j, k, l, todivide;
1244     static float brightness, total;
1245     static XYZ testpoint, testpoint2, terrainpoint, lightloc, col;
1246     lightloc = light.location;
1247     if (!skyboxtexture) {
1248         lightloc.x = 0;
1249         lightloc.z = 0;
1250     }
1251     if (skyboxtexture && Tutorial::active) {
1252         lightloc.x *= .4;
1253         lightloc.z *= .4;
1254     }
1255     int patchx, patchz;
1256     float shadowed;
1257     Normalise(&lightloc);
1258     //Calculate shadows
1259     for (i = 0; i < size; i++) {
1260         for (j = 0; j < size; j++) {
1261             terrainpoint.x = (float)(i) * scale;
1262             terrainpoint.z = (float)(j) * scale;
1263             terrainpoint.y = heightmap[i][j] * scale;
1264
1265             shadowed = 0;
1266             patchx = (float)(i) * subdivision / size;
1267             patchz = (float)(j) * subdivision / size;
1268             if (patchobjectnum[patchx][patchz]) {
1269                 for (k = 0; k < patchobjectnum[patchx][patchz]; k++) {
1270                     l = patchobjects[patchx][patchz][k];
1271                     if (Object::objects[l]->type != treetrunktype) {
1272                         testpoint = terrainpoint;
1273                         testpoint2 = terrainpoint + lightloc * 50 * (1 - shadowed);
1274                         if (Object::objects[l]->model.LineCheck(&testpoint, &testpoint2, &col, &Object::objects[l]->position, &Object::objects[l]->yaw) != -1) {
1275                             shadowed = 1 - (findDistance(&terrainpoint, &col) / 50);
1276                         }
1277                     }
1278                 }
1279                 Game::LoadingScreen();
1280             }
1281             brightness = dotproduct(&lightloc, &normals[i][j]);
1282             if (shadowed)
1283                 brightness *= 1 - shadowed;
1284
1285             if (brightness > 1)
1286                 brightness = 1;
1287             if (brightness < 0)
1288                 brightness = 0;
1289
1290             colors[i][j][0] = light.color[0] * brightness + light.ambient[0];
1291             colors[i][j][1] = light.color[1] * brightness + light.ambient[1];
1292             colors[i][j][2] = light.color[2] * brightness + light.ambient[2];
1293
1294             if (colors[i][j][0] > 1) colors[i][j][0] = 1;
1295             if (colors[i][j][1] > 1) colors[i][j][1] = 1;
1296             if (colors[i][j][2] > 1) colors[i][j][2] = 1;
1297             if (colors[i][j][0] < 0) colors[i][j][0] = 0;
1298             if (colors[i][j][1] < 0) colors[i][j][1] = 0;
1299             if (colors[i][j][2] < 0) colors[i][j][2] = 0;
1300         }
1301     }
1302
1303     Game::LoadingScreen();
1304
1305     //Smooth shadows
1306     for (i = 0; i < size; i++) {
1307         for (j = 0; j < size; j++) {
1308             for (k = 0; k < 3; k++) {
1309                 total = 0;
1310                 todivide = 0;
1311                 if (i != 0) {
1312                     total += colors[j][i - 1][k];
1313                     todivide++;
1314                 }
1315                 if (i != size - 1) {
1316                     total += colors[j][i + 1][k];
1317                     todivide++;
1318                 }
1319                 if (j != 0) {
1320                     total += colors[j - 1][i][k];
1321                     todivide++;
1322                 }
1323                 if (j != size - 1) {
1324                     total += colors[j + 1][i][k];
1325                     todivide++;
1326                 }
1327                 if (i != 0 && j != 0) {
1328                     total += colors[j - 1][i - 1][k];
1329                     todivide++;
1330                 }
1331                 if (i != size - 1 && j != 0) {
1332                     total += colors[j - 1][i + 1][k];
1333                     todivide++;
1334                 }
1335                 if (j != size - 1 && i != size - 1) {
1336                     total += colors[j + 1][i + 1][k];
1337                     todivide++;
1338                 }
1339                 if (j != size - 1 && i != 0) {
1340                     total += colors[j + 1][i - 1][k];
1341                     todivide++;
1342                 }
1343                 total += colors[j][i][k];
1344                 todivide++;
1345
1346                 colors[j][i][k] = total / todivide;
1347             }
1348         }
1349     }
1350
1351     for (i = 0; i < subdivision; i++) {
1352         for (j = 0; j < subdivision; j++) {
1353             UpdateVertexArray(i, j);
1354         }
1355     }
1356 }
1357
1358 Terrain::Terrain()
1359 {
1360     size = 0;
1361
1362     memset(patchobjectnum, 0, sizeof(patchobjectnum));
1363     memset(patchobjects, 0, sizeof(patchobjects));
1364
1365     scale = 1.0f;
1366     type = 0;
1367     memset(heightmap, 0, sizeof(heightmap));
1368     memset(normals, 0, sizeof(normals));
1369     memset(facenormals, 0, sizeof(facenormals));
1370     memset(triangles, 0, sizeof(triangles));
1371     memset(colors, 0, sizeof(colors));
1372     memset(opacityother, 0, sizeof(opacityother));
1373     memset(texoffsetx, 0, sizeof(texoffsetx));
1374     memset(texoffsety, 0, sizeof(texoffsety));
1375     memset(numtris, 0, sizeof(numtris));
1376     memset(textureness, 0, sizeof(textureness));
1377
1378     memset(vArray, 0, sizeof(vArray));
1379
1380     memset(visible, 0, sizeof(visible));
1381     memset(avgypatch, 0, sizeof(avgypatch));
1382     memset(maxypatch, 0, sizeof(maxypatch));
1383     memset(minypatch, 0, sizeof(minypatch));
1384     memset(heightypatch, 0, sizeof(heightypatch));
1385
1386     patch_elements = 0;
1387 }