Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/trunk/src/lib/graphics/importer/height_map.cc @ 7139

Last change on this file since 7139 was 7014, checked in by bensch, 19 years ago

trunk: new algorithm for the Camera-Distance
  • Property svn:executable set to *
File size: 17.7 KB
Line 
1/*
2   orxonox - the future of 3D-vertical-scrollers
3
4   Copyright (C) 2004 orx
5
6   This program is free software; you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation; either version 2, or (at your option)
9   any later version.
10
11   ### File Specific:
12   main-programmer: bottac@ee.ethz.ch
13*/
14
15#include "height_map.h"
16#include "model.h"
17#include "texture.h"
18#include "vector.h"
19#include "material.h"
20#include "p_node.h"
21#include "state.h"
22#include "resource_manager.h"
23#include "debug.h"
24
25// INCLUDING SDL_Image
26#ifdef HAVE_SDL_IMAGE_H
27#include <SDL_image.h>
28#else
29#include <SDL/SDL_image.h>
30#endif
31
32Tile::Tile(int i1, int j1, int i2, int j2, HeightMap* hm )
33{
34
35PRINTF(0)("Tile Constructor\n");
36highResModel = new VertexArrayModel();
37lowResModel  = new VertexArrayModel();
38
39this->load(i1,j1,i2,j2,hm,highResModel,4);
40this->load(i1,j1,i2,j2,hm,lowResModel, 8);
41}
42
43Tile::Tile()
44{
45PRINTF(0)("ooops *********************************************************************************************************************************************************************************************************** \n");
46}
47
48Tile::~Tile()
49{
50 delete highResModel;
51 delete lowResModel;
52}
53
54void Tile::draw()
55{
56         // This Draws the LOD's
57                                                                //FIXME
58    float cameraDistance = (State::getCameraNode()->getAbsCoor() - Vector(this->x, hmref->offsetY , this->z) ).len();
59        if(cameraDistance < 0) cameraDistance = -cameraDistance;
60    if(cameraDistance > 5000 )
61    {
62     return;
63    }
64    else if (cameraDistance >= 1000 )
65    {
66      this->drawLowRes();
67    }
68    else
69    {
70      this->drawHighRes();
71    }
72}
73
74void Tile::drawHighRes()
75{
76 highResModel->draw();
77}
78
79void Tile::drawLowRes()
80{
81 lowResModel->draw();
82}
83
84/*
85*/
86void Tile::load(int i1, int j1, int i2, int j2, HeightMap* hm, VertexArrayModel* model, int Res)
87{
88
89        #define heightMap hm->heightMap
90        #define colours   hm->colours
91        #define scaleX hm->scaleX
92        #define scaleY hm->scaleY
93        #define scaleZ hm->scaleZ
94        #define shiftX hm->shiftX
95        #define shiftY hm->shiftY
96        #define shiftZ hm->shiftZ
97        #define normalVectorField hm->normalVectorField
98
99        hmref = hm; // FIXME
100
101        this->x = hm->offsetX + (heightMap->h - ((i1+i2)/2))*scaleX;
102        this->z = hm->offsetZ + ((j1 + j2 )/2 ) * scaleZ;
103
104        int sampleRate = Res;
105
106        float height = 0;
107        int offset = 0;
108
109        float r = 0.0;
110        float g = 0.0;
111        float b = 0.0;
112
113
114
115
116 if(heightMap != NULL && heightMap->format->BitsPerPixel == 8 )
117
118        SDL_LockSurface(heightMap);
119        SDL_LockSurface(hm->colourMap);
120
121        for(int i = i1 ; i <= i2  ; i +=sampleRate)
122        {
123                int w = 0;
124
125
126
127                 if(hm->hasColourMap)
128                 {
129                 r = colours[(3*w+2 + 3*i*(heightMap->w )) ];
130                 g = colours[(3*w+1 + 3*i*(heightMap->w)) ];
131                 b = colours[(3*w+0 + 3*i*(heightMap->w))];
132                 }
133
134                w = j1;
135                model->addVertex(scaleX*(heightMap->h -i)+ shiftX,shiftY,scaleZ*(w)+ shiftZ); // Top Right
136                model->addNormal(normalVectorField[i % heightMap->h][w % heightMap->w].y,normalVectorField[i % heightMap->h][w % heightMap->w].z,normalVectorField[i % heightMap->h][w % heightMap->w].x);
137                model->addTexCoor((float)(j1-sampleRate) /(texRate), (float)(i %heightMap->h)/(texRate));
138
139                model->addColor(r/255.0,g/255.0,b/255.0);
140
141            for(int j = j1  ; j <= j2    ;  j += sampleRate)
142            {
143
144
145                 // To be fixed
146                 if(hm->hasColourMap)
147                 {
148                 r = colours[(3*j+2 + 3*i*(heightMap->w )) ];
149                 g =  colours[(3*j+1 + 3*i*(heightMap->w)) ];
150                 b =  colours[(3*j+0 + 3*i*(heightMap->w))];
151                 }
152                height = (float)(unsigned char) hm->heights[(j +sampleRate+ i*(heightMap->w )) ];
153                height += (float)(unsigned char) hm->heights[(j+ 1 + sampleRate + (i+1)*(heightMap->w )) ];
154                height +=  (float) (unsigned char) hm->heights[(j -1+ sampleRate   + (i+1)*(heightMap->w ))];
155                height +=  (float)(unsigned char)hm->heights[(j +sampleRate+ (i+2)*(heightMap->w )) ];
156                height +=  (float)(unsigned char)hm->heights[(j+sampleRate + (i)*(heightMap->w )) ];
157                height=height/5.0;
158
159                model->addVertex(scaleX*(heightMap->h -i) + shiftX ,((double)(height)*scaleY) + shiftY ,scaleZ*(j) + shiftZ); // Top Right
160                model->addNormal(normalVectorField[i % heightMap->h][j % heightMap->w].y,normalVectorField[i % heightMap->h][j % heightMap->w].z,normalVectorField[i % heightMap->h][j % heightMap->w].x);
161                model->addTexCoor((float)(j) /(texRate), (float)(i %heightMap->h)/(texRate));
162
163                //PRINTF(0)("TexCoord:  %f %f \n",(float)j / 100.0, (float)(i %heightMap->h)/100.0);
164
165                model->addColor(r/255.0,g/255.0,b/255.0);
166                w = j;
167            }
168
169
170                model->addVertex(scaleX*(heightMap->h -i)+ shiftX,shiftY,scaleZ*(w)+ shiftZ); // Top Right
171                model->addNormal(normalVectorField[i % heightMap->h][w % heightMap->w].y,normalVectorField[i % heightMap->h][w % heightMap->w].z,normalVectorField[i% heightMap->h][w % heightMap->w].x);
172                model->addTexCoor((float)(j2+sampleRate) /(texRate), (float)(i %heightMap->h)/(texRate));
173                model->addColor(r/255.0,g/255.0,b/255.0);
174
175        }
176
177
178
179
180
181        SDL_UnlockSurface(heightMap);
182        int cnt = 0;
183        for(int i = i1   ; i < i2  ; i +=sampleRate)
184        {
185
186            for(int j = j1-sampleRate  ; j < j2  + 2*sampleRate  ;  j += sampleRate)
187            {
188
189                model->addIndice(cnt);
190                model->addIndice(cnt  + (j2 -j1 + 3* sampleRate  )/ sampleRate );
191                cnt++;
192
193            }
194
195
196
197                 model->newStripe();
198
199
200        }
201         cnt += (j2 -j1 + 3* sampleRate)/ sampleRate;
202
203                for(int j = j1 ; j <= j2    ;  j += sampleRate)
204            {
205                int i = i1;
206
207                 // To be fixed
208                 if(hm->hasColourMap)
209                 {
210                 r = (float)colours[(3*j+2 + 3*i*(heightMap->w )) ];
211                 g = (float)colours[(3*j+1 + 3*i*(heightMap->w)) ];
212                 b = (float)colours[(3*j+0 + 3*i*(heightMap->w))];
213                 }
214
215                model->addVertex(scaleX*(heightMap->h -i) + shiftX , shiftY ,scaleZ*(j) + shiftZ); // Top Right
216                model->addNormal(normalVectorField[i % heightMap->h][j % heightMap->w].y,normalVectorField[i % heightMap->h][j % heightMap->w].z,normalVectorField[i % heightMap->h][j % heightMap->w].x);
217                model->addTexCoor((float)j /(texRate), (float)((i - sampleRate) %heightMap->h)/(texRate));
218                model->addColor(r/255.0,g/255.0,b/255.0);
219
220            }
221
222                for(int j = j1  ; j <= j2    ;  j += sampleRate)
223            {
224                int i = i1;
225                height = (float)(unsigned char) hm->heights[(j +sampleRate+ i*(heightMap->w )) ];
226                height += (float)(unsigned char) hm->heights[(j+ 1 + sampleRate + (i+1)*(heightMap->w )) ];
227                height +=  (float) (unsigned char) hm->heights[(j -1+ sampleRate   + (i+1)*(heightMap->w ))];
228                height +=  (float)(unsigned char)hm->heights[(j +sampleRate+ (i+2)*(heightMap->w )) ];
229                height +=  (float)(unsigned char)hm->heights[(j+sampleRate + (i)*(heightMap->w )) ];
230                height=height/5.0;
231
232                model->addVertex(scaleX*(heightMap->h -i) + shiftX , ((double)(height)*scaleY) +shiftY ,scaleZ*(j) + shiftZ); // Top Right
233                model->addNormal(normalVectorField[i % heightMap->h][j % heightMap->w].y,normalVectorField[i % heightMap->h][j% heightMap->w].z,normalVectorField[i%heightMap->h][j%heightMap->w].x);
234                model->addTexCoor((float)j /(texRate), (float)(i %heightMap->h)/(texRate));
235                model->addColor(r/255.0,g/255.0,b/255.0);
236
237            }
238
239
240
241            for(int j = j1  ; j <= j2    ;  j += sampleRate)
242            {
243                int i = i2;
244
245                 // To be fixed
246                 if(hm->hasColourMap)
247                 {
248                 r = (float)colours[3*j+2 + 3*i*(heightMap->w )];
249                 g = (float)colours[3*j+1 + 3*i*(heightMap->w)];
250                 b = (float)colours[3*j+0 + 3*i*(heightMap->w)];
251                 }
252
253                model->addVertex(scaleX*(heightMap->h -i) + shiftX , shiftY ,scaleZ*(j) + shiftZ); // Top Right
254                model->addNormal(normalVectorField[i%heightMap->h][j%heightMap->w].y,normalVectorField[i%heightMap->h][j%heightMap->w].z,normalVectorField[i%heightMap->h][j%heightMap->w].x);
255                model->addTexCoor((float)j /(texRate), (float)((i+ sampleRate) %heightMap->h)/(texRate));
256                model->addColor(r/255.0,g/255.0,b/255.0);
257
258            }
259
260
261            for(int j = j1 ; j <= j2    ;  j += sampleRate)
262            {
263                int i = i2;
264                height = (float)(unsigned char) hm->heights[(j +sampleRate+ i*(heightMap->w )) ];
265                height += (float)(unsigned char) hm->heights[(j+ 1 + sampleRate + (i+1)*(heightMap->w )) ];
266                height +=  (float) (unsigned char) hm->heights[(j -1+ sampleRate   + (i+1)*(heightMap->w ))];
267                height +=  (float)(unsigned char)hm->heights[(j +sampleRate+ (i+2)*(heightMap->w ))];
268                height +=  (float)(unsigned char)hm->heights[(j+sampleRate + (i)*(heightMap->w )) ];
269                height=height/5.0;
270                model->addVertex(scaleX*(heightMap->h -i) + shiftX , ((double)(height)*scaleY) +shiftY ,scaleZ*(j) + shiftZ); // Top Right
271                model->addNormal(normalVectorField[i%heightMap->h][j%heightMap->w].y,normalVectorField[i%heightMap->h][j%heightMap->w].z,normalVectorField[i%heightMap->h][j%heightMap->w].x);
272                model->addTexCoor((float)j /(texRate), (float)(i %heightMap->h)/(texRate));
273                model->addColor(r/255.0,g/255.0,b/255.0);
274
275            }
276
277
278
279
280         // link Boarder Stripe
281            for(int j = j1-sampleRate  ; j < j2    ;  j += sampleRate)
282            {
283
284                model->addIndice(cnt);
285                model->addIndice(cnt  + (j2 -j1 +  sampleRate  )/ sampleRate );
286                cnt++;
287
288            }
289
290                cnt++;
291
292                 model->newStripe();
293
294
295
296
297
298         cnt += (j2-j1)/ sampleRate;
299
300        // link 2nd BoarderStripe
301            for(int j = j1-sampleRate  ; j < j2    ;  j += sampleRate)
302            {
303
304                model->addIndice(cnt);
305                model->addIndice(cnt  + (j2 -j1 +  sampleRate  )/ sampleRate );
306                cnt++;
307
308            }
309
310
311            SDL_UnlockSurface(hm->colourMap);
312
313         model->finalize();
314
315
316
317
318        #undef heightMap
319        #undef colours
320        #undef scaleX
321        #undef scaleY
322        #undef scaleZ
323        #undef shiftX
324        #undef shiftY
325        #undef shiftZ
326        #undef normalVectorField
327
328}
329
330HeightMap::HeightMap()
331{
332
333}
334
335HeightMap::HeightMap(const char* height_map_name = NULL) : VertexArrayModel()
336{
337   this->setClassID(CL_HEIGHT_MAP, "HeightMap");
338   heightMap =  IMG_Load(height_map_name);
339   if(heightMap!=NULL) {
340
341                 PRINTF(0)("loading Image %s\n", height_map_name);
342                 PRINTF(0)("width : %i\n", heightMap->w);
343                 PRINTF(0)("height : %i\n", heightMap->h);
344                 PRINTF(0)("%i Byte(s) per Pixel \n", heightMap->format->BytesPerPixel);
345                 PRINTF(0)("Rshift : %i\n", heightMap->format->Rshift);
346                 PRINTF(0)("Bshift: %i\n", heightMap->format->Bshift);
347                 PRINTF(0)("Gshift: %i\n", heightMap->format->Gshift);
348                 PRINTF(0)("Rmask: %i\n", heightMap->format->Rmask);
349                 PRINTF(0)("Gmask: %i\n", heightMap->format->Gmask);
350                }
351
352     else       PRINTF(4)("oops! couldn't load %s for some reason.\n", height_map_name);
353
354
355  generateNormalVectorField();
356
357  shiftX = 0;
358  shiftY = 0;
359  shiftZ = 0;
360
361}
362
363HeightMap::HeightMap(const char* height_map_name = NULL, const char* colour_map_name = NULL) : VertexArrayModel()
364{
365this->setClassID(CL_HEIGHT_MAP, "HeightMap");
366
367   heightMap =  IMG_Load(height_map_name);
368   if(heightMap!=NULL) {
369
370                 PRINTF(0)("loading Image %s\n", height_map_name);
371                 PRINTF(0)("width : %i\n", heightMap->w);
372                 PRINTF(0)("height : %i\n", heightMap->h);
373                 PRINTF(0)("%i Byte(s) per Pixel \n", heightMap->format->BytesPerPixel);
374                 PRINTF(0)("Rshift : %i\n", heightMap->format->Rshift);
375                 PRINTF(0)("Bshift: %i\n", heightMap->format->Bshift);
376                 PRINTF(0)("Gshift: %i\n", heightMap->format->Gshift);
377                 PRINTF(0)("Rmask: %i\n", heightMap->format->Rmask);
378                 PRINTF(0)("Gmask: %i\n", heightMap->format->Gmask);
379                }
380
381     else       PRINTF(4)("oops! couldn't load %s for some reason.\n", height_map_name);
382
383
384    generateNormalVectorField();
385
386  colourMap=NULL;
387  if(colour_map_name != NULL)
388  {
389  colourMap = IMG_Load(colour_map_name);
390  }
391
392  if(colourMap != NULL)
393                {
394                 PRINTF(0)("loading Image %s\n", colour_map_name);
395                 PRINTF(0)("width : %i\n", colourMap->w);
396                 PRINTF(0)("height : %i\n", colourMap->h);
397                 PRINTF(0)("%i Byte(s) per Pixel \n", colourMap->format->BytesPerPixel);
398                 PRINTF(0)("Rshift : %i\n", colourMap->format->Rshift);
399                 PRINTF(0)("Bshift: %i\n", colourMap->format->Bshift);
400                 PRINTF(0)("Gshift: %i\n", colourMap->format->Gshift);
401                 PRINTF(0)("Rmask: %i\n", colourMap->format->Rmask);
402                 PRINTF(0)("Gmask: %i\n", colourMap->format->Gmask);
403                 }
404                 else       PRINTF(0)("oops! couldn't load colorMap for some reason.\n");
405
406
407
408  if(colourMap != NULL)
409  {
410  colours = (unsigned char *) colourMap->pixels;
411  hasColourMap = true;
412  }
413  else hasColourMap = false;
414
415
416  heights  = (unsigned char*) heightMap->pixels;
417  shiftX = 0;
418  shiftY = 0;
419  shiftZ = 0;
420}
421
422
423HeightMap::~HeightMap()
424{
425        delete heightMap;
426        delete colourMap;
427
428
429        for(int i=0;i <    heightMap->h/tileSize ; i++)
430        {
431        for(int j = 0; j < heightMap->w/ tileSize; j++)
432        {
433         delete tiles [i][j];
434        }
435        }
436        for(int i=0;i <    heightMap->h/tileSize ; i++)
437        delete[] tiles[i];
438        delete[] tiles;
439
440
441
442
443
444for(int i=0;i<heightMap->h;i++)
445delete[] normalVectorField [i];
446delete[] normalVectorField;
447
448
449
450
451
452
453
454}
455
456void HeightMap::load()
457{
458
459//Create a Dynamicly sized 2D-Array for Tiles
460tiles =  new Tile** [heightMap->h/tileSize];
461for(int i=0;i <    heightMap->h/tileSize ; i++)
462tiles [i]= new (Tile* [heightMap->w /tileSize ]);
463
464//SetUp Arrays
465for(int i = 0; i < (heightMap->h  )/ tileSize; i ++)
466{
467        for(int j = 0; j < (heightMap->w )/ tileSize; j ++)
468        {
469
470         tiles[i][j] =    new Tile( i*tileSize ,  j*tileSize , (i+1)*tileSize, (j+1)*tileSize , this ) ;
471        }
472}
473
474}
475
476
477void HeightMap::draw()
478{
479const PNode* camera = State::getCameraNode();
480Vector v = camera->getAbsCoor();
481
482int i_min = 0;
483int i_max = (heightMap->h )/ tileSize;
484int j_min = 0;
485int j_max= (heightMap->w  ) / tileSize;
486
487
488
489for(int i = 0; i <  i_max        ; i ++)
490{
491        for(int j = 0; j < j_max ; j++)
492        {
493         tiles[i][j]->draw();
494        }
495}
496
497}
498void HeightMap::generateNormalVectorField()
499{
500int delta = 1;
501heights  = (unsigned char*) heightMap->pixels;
502
503//Create a Dynamicly sized 2D-Array to store our normals
504normalVectorField =  new Vector* [heightMap->h];
505for(int i=0;i<heightMap->h;i++)
506normalVectorField [i]= new (Vector [heightMap->w]);
507
508
509
510
511// Initialize
512for(int i=0; i< heightMap->h; i++)
513{
514        for(int j = 0; j> heightMap->w; j++)
515        {
516        Vector v = Vector(0.0, 1.0, 0.0);
517         normalVectorField[i][j] = v;
518        }
519}
520
521// !!! Does not yet calculate the normals of some border points!!!!!
522
523if(heightMap != NULL && heightMap->format->BitsPerPixel == 8 )
524        {
525        SDL_LockSurface(heightMap);
526        for(int i = 0 ; i < heightMap->h - 1  ; i ++)
527        {
528            for(int j = 0; j < heightMap->w  - 1  ;  j ++)
529            {
530
531
532                delta = (int)heights[j + (i+1)*(heightMap->w )] -  (int) heights[j + i*(heightMap->w )];
533                Vector a =  Vector(-scaleX,(float)delta*scaleY  ,0.0f);
534
535                delta = (int)heights[j+1 + i*(heightMap->w )] - (int)heights[j + i*(heightMap->w )];
536                Vector b =  Vector(0.0f,(float) delta*scaleY ,scaleZ);
537
538
539                 normalVectorField[i][j] = b.cross(a);
540                 normalVectorField[i][j].normalize();
541
542             }
543        }
544        SDL_UnlockSurface(heightMap);
545
546}
547
548
549
550
551}
552
553
554void HeightMap::scale(Vector v)
555{
556 scaleX = v.x;
557 scaleY = v.y;
558 scaleZ = v.z;
559 generateNormalVectorField();
560}
561
562void HeightMap::setAbsCoor(Vector v)
563{
564 offsetX = v.x;
565 offsetY = v.y;
566 offsetZ  = v.z;
567}
568
569
570float HeightMap::getHeight(float x, float y)
571{
572
573 x -= offsetX;
574 y -= offsetZ;
575
576
577 int xInt = (int)x / scaleX;  x -= (float)((int)x); xInt = heightMap->h - xInt;
578 int yInt = (int)y / scaleZ;    y -= (float) ((int) y); /*yInt = heightMap->w - yInt;*/
579
580 //PRINTF(0)("xInt: %i, yInt: %i, x: %f, y: %f\n", xInt, yInt, x, y);
581
582 if(xInt <= 0 || xInt >= heightMap->h || yInt <= 0 || yInt >= heightMap->w  ) return 0;
583 if( y >= 0.5*x)
584 {
585        // Check for ...
586 }
587
588 float height = heights[yInt + (xInt)*heightMap->w]*scaleY;
589
590
591 float a = normalVectorField[(xInt)][yInt].x;
592 float b = normalVectorField [(xInt)][yInt].z;
593 float c = normalVectorField [(xInt)][yInt].y;
594
595 PRINTF(0)("a: %f \n" ,a);
596  PRINTF(0)("b: %f \n" ,b);
597   PRINTF(0)("c: %f \n" ,c);
598
599 height -= ( (a/c)*(x) + (b/c)*(y));
600
601 PRINTF(0)("height: %f \n" ,height );
602 return (height + offsetZ);
603}
Note: See TracBrowser for help on using the repository browser.