source: orxonox.OLD/orxonox/branches/heightMap/src/lib/graphics/importer/heightmap.cc @ 4095

#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_HEIGHTMAP


#include "heightmap.h"

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include "debug.h"
#include "compiler.h"


Heightmap::Heightmap(const char* fileName, float scaling, int displaylistResolution, int vertexResolution)
{
        this->scaleFactor = scaling;
        this->setName(fileName);
        
        this->import(fileName, displaylistResolution, vertexResolution);
        
        this->finalize();
}

Heightmap::~Heightmap ()
{
}

bool Heightmap::import (const char* fileName, int displaylistResolution, int vertexResolution)
{
        PRINTF(4)("preparing to read in file: %s\n", fileName);
        
        // using SDL-image to load the bitmap
        this->bitmap = IMG_Load(fileName);

        // how many pixels wide is a display list?
        int pixPerDLSide = displaylistResolution * vertexResolution;

        int howManyListsWide = bitmap->w / pixPerDLSide + 1;
        int howManyListsHigh = bitmap->h / pixPerDLSide + 1;
        
        // calculated pixel dimensions of one display list. usually equals pixPerDLSide, but at the end of the picture
        // this needs to be shorter, that we do not make a segfault
        int width = pixPerDLSide;
        int height = pixPerDLSide;
        
        for (int i=0; i<howManyListsWide; i++)
        {
                for (int j=0; j<howManyListsHigh; j++)
                {
                        // catch out of image access in x-direction
                        if ( (j+1)*pixPerDLSide - 1 >= bitmap->w )      width = bitmap->w - j*pixPerDLSide;
                        else                                                                            width = pixPerDLSide;
                        // y-direction
                        if ( (i+1)*pixPerDLSide - 1 >= bitmap->h )      height = bitmap->h - i*pixPerDLSide;
                        else                                                                            height = pixPerDLSide;
                        
                        
                        
                        this->readIntoGroup(j*pixPerDLSide,i*pixPerDLSide,width,height,vertexResolution);
                }
        }
        
        return true;
}

void Heightmap::readIntoGroup(int left, int top,int width, int height, int vertexResolution)
{       
        // add all vertices first
        for (int z=top; z < top+height; z++)
        {
                for (int x=left; x < left+width; x++)
                {
                        this->addVertex(x,this->getHeightAt(x,z),z);
                }
        }

        
        // code readability
        int thisVertex = 0;
        int bottomVertex = width;
        
        // create all faces
        for (int z=top; z < top+height - 1; z++)
        {
                for (int x=left; x < left+width - 1; x++)
                {
                        thisVertex++;
                        bottomVertex++;                 
                        
                        this->addFace(3, VERTEX_ONLY, thisVertex, bottomVertex, thisVertex+1);
                        this->addFace(3, VERTEX_ONLY, thisVertex+1, bottomVertex, bottomVertex+1);

                }
        }
        


}

float Heightmap::getHeightAt(int x, int z)
{
        Uint8 index;
        SDL_Color color;
        
        SDL_LockSurface(bitmap);
        
        index = *((Uint8*)bitmap->pixels + z * bitmap->pitch + x * bitmap->format->BytesPerPixel);
        color = bitmap->format->palette->colors[index];
        
        SDL_UnlockSurface(bitmap);
        
        // return the red component, because in a grayscale pic, r,g and b are all the same value
        return (GLint)color.r;
}