Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

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

Last change on this file since 7422 was 7221, checked in by bensch, 19 years ago

orxonox/trunk: merged the std-branche back, it runs on windows and Linux

svn merge ​https://svn.orxonox.net/orxonox/branches/std . -r7202:HEAD
  • Property svn:executable set to *
File size: 17.8 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 "util/loading/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 std::string& height_map_name = "")
336  : VertexArrayModel()
337{
338   this->setClassID(CL_HEIGHT_MAP, "HeightMap");
339   heightMap =  IMG_Load(height_map_name.c_str());
340   if(heightMap!=NULL) {
341
342     PRINTF(0)("loading Image %s\n", height_map_name.c_str());
343                 PRINTF(0)("width : %i\n", heightMap->w);
344                 PRINTF(0)("height : %i\n", heightMap->h);
345                 PRINTF(0)("%i Byte(s) per Pixel \n", heightMap->format->BytesPerPixel);
346                 PRINTF(0)("Rshift : %i\n", heightMap->format->Rshift);
347                 PRINTF(0)("Bshift: %i\n", heightMap->format->Bshift);
348                 PRINTF(0)("Gshift: %i\n", heightMap->format->Gshift);
349                 PRINTF(0)("Rmask: %i\n", heightMap->format->Rmask);
350                 PRINTF(0)("Gmask: %i\n", heightMap->format->Gmask);
351                }
352
353                else       PRINTF(4)("oops! couldn't load %s for some reason.\n", height_map_name.c_str());
354
355
356  generateNormalVectorField();
357
358  shiftX = 0;
359  shiftY = 0;
360  shiftZ = 0;
361
362}
363
364HeightMap::HeightMap(const std::string& height_map_name = NULL, const std::string& colour_map_name = NULL)
365  : VertexArrayModel()
366{
367this->setClassID(CL_HEIGHT_MAP, "HeightMap");
368
369   heightMap =  IMG_Load(height_map_name.c_str());
370   if(heightMap!=NULL) {
371
372     PRINTF(0)("loading Image %s\n", height_map_name.c_str());
373                 PRINTF(0)("width : %i\n", heightMap->w);
374                 PRINTF(0)("height : %i\n", heightMap->h);
375                 PRINTF(0)("%i Byte(s) per Pixel \n", heightMap->format->BytesPerPixel);
376                 PRINTF(0)("Rshift : %i\n", heightMap->format->Rshift);
377                 PRINTF(0)("Bshift: %i\n", heightMap->format->Bshift);
378                 PRINTF(0)("Gshift: %i\n", heightMap->format->Gshift);
379                 PRINTF(0)("Rmask: %i\n", heightMap->format->Rmask);
380                 PRINTF(0)("Gmask: %i\n", heightMap->format->Gmask);
381                }
382
383                else       PRINTF(4)("oops! couldn't load %s for some reason.\n", height_map_name.c_str());
384
385
386    generateNormalVectorField();
387
388  colourMap=NULL;
389  if(colour_map_name != "")
390  {
391    colourMap = IMG_Load(colour_map_name.c_str());
392  }
393
394  if(colourMap != NULL)
395                {
396                  PRINTF(0)("loading Image %s\n", colour_map_name.c_str());
397                 PRINTF(0)("width : %i\n", colourMap->w);
398                 PRINTF(0)("height : %i\n", colourMap->h);
399                 PRINTF(0)("%i Byte(s) per Pixel \n", colourMap->format->BytesPerPixel);
400                 PRINTF(0)("Rshift : %i\n", colourMap->format->Rshift);
401                 PRINTF(0)("Bshift: %i\n", colourMap->format->Bshift);
402                 PRINTF(0)("Gshift: %i\n", colourMap->format->Gshift);
403                 PRINTF(0)("Rmask: %i\n", colourMap->format->Rmask);
404                 PRINTF(0)("Gmask: %i\n", colourMap->format->Gmask);
405                 }
406                 else       PRINTF(0)("oops! couldn't load colorMap for some reason.\n");
407
408
409
410  if(colourMap != NULL)
411  {
412  colours = (unsigned char *) colourMap->pixels;
413  hasColourMap = true;
414  }
415  else hasColourMap = false;
416
417
418  heights  = (unsigned char*) heightMap->pixels;
419  shiftX = 0;
420  shiftY = 0;
421  shiftZ = 0;
422}
423
424
425HeightMap::~HeightMap()
426{
427        delete heightMap;
428        delete colourMap;
429
430
431        for(int i=0;i <    heightMap->h/tileSize ; i++)
432        {
433        for(int j = 0; j < heightMap->w/ tileSize; j++)
434        {
435         delete tiles [i][j];
436        }
437        }
438        for(int i=0;i <    heightMap->h/tileSize ; i++)
439        delete[] tiles[i];
440        delete[] tiles;
441
442
443
444
445
446for(int i=0;i<heightMap->h;i++)
447delete[] normalVectorField [i];
448delete[] normalVectorField;
449
450
451
452
453
454
455
456}
457
458void HeightMap::load()
459{
460
461//Create a Dynamicly sized 2D-Array for Tiles
462tiles =  new Tile** [heightMap->h/tileSize];
463for(int i=0;i <    heightMap->h/tileSize ; i++)
464tiles [i]= new (Tile* [heightMap->w /tileSize ]);
465
466//SetUp Arrays
467for(int i = 0; i < (heightMap->h  )/ tileSize; i ++)
468{
469        for(int j = 0; j < (heightMap->w )/ tileSize; j ++)
470        {
471
472         tiles[i][j] =    new Tile( i*tileSize ,  j*tileSize , (i+1)*tileSize, (j+1)*tileSize , this ) ;
473        }
474}
475
476}
477
478
479void HeightMap::draw()
480{
481const PNode* camera = State::getCameraNode();
482Vector v = camera->getAbsCoor();
483
484int i_min = 0;
485int i_max = (heightMap->h )/ tileSize;
486int j_min = 0;
487int j_max= (heightMap->w  ) / tileSize;
488
489
490
491for(int i = 0; i <  i_max        ; i ++)
492{
493        for(int j = 0; j < j_max ; j++)
494        {
495         tiles[i][j]->draw();
496        }
497}
498
499}
500void HeightMap::generateNormalVectorField()
501{
502int delta = 1;
503heights  = (unsigned char*) heightMap->pixels;
504
505//Create a Dynamicly sized 2D-Array to store our normals
506normalVectorField =  new Vector* [heightMap->h];
507for(int i=0;i<heightMap->h;i++)
508normalVectorField [i]= new (Vector [heightMap->w]);
509
510
511
512
513// Initialize
514for(int i=0; i< heightMap->h; i++)
515{
516        for(int j = 0; j> heightMap->w; j++)
517        {
518        Vector v = Vector(0.0, 1.0, 0.0);
519         normalVectorField[i][j] = v;
520        }
521}
522
523// !!! Does not yet calculate the normals of some border points!!!!!
524
525if(heightMap != NULL && heightMap->format->BitsPerPixel == 8 )
526        {
527        SDL_LockSurface(heightMap);
528        for(int i = 0 ; i < heightMap->h - 1  ; i ++)
529        {
530            for(int j = 0; j < heightMap->w  - 1  ;  j ++)
531            {
532
533
534                delta = (int)heights[j + (i+1)*(heightMap->w )] -  (int) heights[j + i*(heightMap->w )];
535                Vector a =  Vector(-scaleX,(float)delta*scaleY  ,0.0f);
536
537                delta = (int)heights[j+1 + i*(heightMap->w )] - (int)heights[j + i*(heightMap->w )];
538                Vector b =  Vector(0.0f,(float) delta*scaleY ,scaleZ);
539
540
541                 normalVectorField[i][j] = b.cross(a);
542                 normalVectorField[i][j].normalize();
543
544             }
545        }
546        SDL_UnlockSurface(heightMap);
547
548}
549
550
551
552
553}
554
555
556void HeightMap::scale(Vector v)
557{
558 scaleX = v.x;
559 scaleY = v.y;
560 scaleZ = v.z;
561 generateNormalVectorField();
562}
563
564void HeightMap::setAbsCoor(Vector v)
565{
566 offsetX = v.x;
567 offsetY = v.y;
568 offsetZ  = v.z;
569}
570
571
572float HeightMap::getHeight(float x, float y)
573{
574
575 x -= offsetX;
576 y -= offsetZ;
577
578
579 int xInt = (int)x / scaleX;  x -= (float)((int)x); xInt = heightMap->h - xInt;
580 int yInt = (int)y / scaleZ;    y -= (float) ((int) y); /*yInt = heightMap->w - yInt;*/
581
582 //PRINTF(0)("xInt: %i, yInt: %i, x: %f, y: %f\n", xInt, yInt, x, y);
583
584 if(xInt <= 0 || xInt >= heightMap->h || yInt <= 0 || yInt >= heightMap->w  ) return 0;
585 if( y >= 0.5*x)
586 {
587        // Check for ...
588 }
589
590 float height = heights[yInt + (xInt)*heightMap->w]*scaleY;
591
592
593 float a = normalVectorField[(xInt)][yInt].x;
594 float b = normalVectorField [(xInt)][yInt].z;
595 float c = normalVectorField [(xInt)][yInt].y;
596
597 PRINTF(0)("a: %f \n" ,a);
598  PRINTF(0)("b: %f \n" ,b);
599   PRINTF(0)("c: %f \n" ,c);
600
601 height -= ( (a/c)*(x) + (b/c)*(y));
602
603 PRINTF(0)("height: %f \n" ,height );
604 return (height + offsetZ);
605}
Note: See TracBrowser for help on using the repository browser.