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