Terrain.cpp~

#include "Terrain.h"

using namespace std;
using namespace SDL;

Terrain::Terrain()
{
	/*m_param.hautmax = 10.0;
	m_param.filaire = 1;
	m_param.angle = -65.0;
	m_param.angle2 = 0.0;
	m_param.trans = -6.0;
	m_param.water = 0;
	m_param.w_cur = 3.0;
	m_param.light = L_AUCUN;
	m_param.l_veci = -1;
	m_param.l_vecj = 0;
	m_param.l_vecz = -0.02;
	m_param.l_min = 0.2;
	m_param.l_max = 1.0;
	m_param.l_adouc = 0.01;
	m_param.l_ldotnmultiple = 47.0;*/
	
	srand(time(NULL));
	
	m_texture_finale_terrain = 0;
	
	m_textures_terrain = NULL;
}

Terrain::Terrain(SDL::Surface carte_terrain_surf, Dim3 dimensions, float precision_x, float precision_y, bool avec_ombre, Clip *textures_terrain, unsigned char hauteur_tex, ...)
 : m_carte_terrain( vector< vector<unsigned char> >( (int)( precision_y * (float)carte_terrain_surf.height() ), vector<unsigned char>( (int)( precision_x * (float)carte_terrain_surf.width() ) ) ) )
{
	srand(time(NULL));
	
	m_carte_terrain_surf = carte_terrain;
	m_textures_terrain = textures_terrain;
	
	m_dimensions = dimensions;
	m_avec_ombre = avec_ombre;
	
	int x = 0, y = 0;
	
	if(precision_x > 1.0)
		precision_x = 1.0;
	if(precision_y > 1.0)
		precision_y = 1.0;
	
	if(carte_terrain_surf == true)
	{
		for(y = 0; y < m_carte_terrain.height(); y++)
		{
			for(x = 0; x < m_carte_terrain.width(); x++)
			{
				m_carte_terrain[y][x] = carte_terrain_surf.getPixelOneComposant(Rect( (float)x/precision_x, (float)y/precision_y), 0);
			}
		}
	}
	
	va_list param; // Liste de paramètres optionnels fonction

	va_start(param, hauteur_tex); // Initialisation de ap
	
	m_hauteurs_textures.push_back(hauteur_tex);
	
	unsigned char hauteur_texture = 0, i = 0;
	
	for(int i = 0; i < m_textures_terrain->get_nbr_sprites()-1 + (m_textures_terrain->get_nbr_sprites() - 1); i++)
	{
		hauteur_texture = va_arg(param, int);
		
		m_hauteurs_textures.push_back(hauteur_texture);
	}
	
	va_end(param);
}

Terrain::~Terrain()
{
}

void setDimensions(Dim3 nouvelles)
{
	m_dimensions = nouvelles;
	
	if(m_texture_finale_terrain != 0)
	{
		if(m_avec_ombre)
		{
			creerTerrainTex(m_resolution_texture);
		}
	}
}

void Terrain::freeAll()
{
	m_carte_terrain.free();
	
	delete m_textures_terrain;
	
	glDeleteTextures(1, &m_texture_finale_terrain);
}

/*! Changer de carte topographique */
void Terrain::setCarte(bool supprimer_ancienne, Surface carte_terrain)
{
	if(supprimer_ancienne)
		m_carte_terrain.free();
		
	m_carte_terrain = carte_terrain;
}

/*! Changer les textures utilisées dans le terrain */
void Terrain::setTextures(bool supprimer_ancienne, Clip *textures_terrain, unsigned char hauteur_tex, ...)
{
	if(supprimer_ancienne)
		delete m_textures_terrain;
	
	m_textures_terrain = textures_terrain;
	
	va_list param; // Liste de paramètres optionnels fonction

	va_start(param, hauteur_tex); // Initialisation de ap
	
	m_hauteurs_textures.push_back(hauteur_tex);
	
	unsigned char hauteur_texture = 0, i = 0;
	
	for(int i = 0; i < m_textures_terrain->get_nbr_sprites()-1 + (m_textures_terrain->get_nbr_sprites() - 1); i++)
	{
		hauteur_texture = va_arg(param, int);
		
		m_hauteurs_textures.push_back(hauteur_texture);
	}
	
	va_end(param);
}


RGB Terrain::getColor(unsigned char hauteur, Rect position)
{
	int add = hauteur + (rand() % 20) - 10;
	
	if( add < 0)
		add = 0;
	else if(add > 255)
		add = 255;
		
	hauteur = add;
	
	float *perc = new float[ m_textures_terrain->get_nbr_sprites() ];
	int i = 0;
	
	for(i = 0; i < m_textures_terrain->get_nbr_sprites(); i++ )
		perc[i] = 0;
	
	for(i = 0; i < m_hauteurs_textures.size(); i++)
	{
		if( hauteur <= m_hauteurs_textures[i] )
		{
			if(i == 0)
			{
				perc[i] = 1.0f;
				
				break;
			}
			else if( i >= m_hauteurs_textures.size() - 1 )
			{
				perc[ m_textures_terrain->get_nbr_sprites() - 1 ] = 1.0f;
				
				break;	
			}
			else if( hauteur > m_hauteurs_textures[i-1] && hauteur <= m_hauteurs_textures[i] )
			{
				if( (i+1) % 2 == 0)
				{
					// i est pair donc mélange entre la texture précédente et la suivante
					
					int j = (i+1)/2;
					j--;
					
					perc[j] = 1.0f - (float)( hauteur - m_hauteurs_textures[i-1] ) / (float)( m_hauteurs_textures[i] - m_hauteurs_textures[i-1] );
					perc[j+1] = 1.0f - perc[j];
					
					break;
				}
				else
				{
					// i est impair donc cette texture seule
					
					float j = (float)(i+1)/2;
					
					if( (j - (float)( (int)j ) ) >= 0.5)
						j = (int)j + 1;
					else
						j = (int)j;
						
					j -= 1;
					//cout << "JLEL " << j << endl;
					perc[ (int)j ] = 1.f;
					
					break;
				}
			}
		}
	}
		
	RGB adequate_color(0, 0, 0);
	
	Pixel pixel;
	Uint8 r, g, b, a;
	
	Rect pos;
	
	for(i = 0; i < m_textures_terrain->get_nbr_sprites(); i++)
	{
		if(perc[i] != 0)
		{
			pos.x = (int)position.x % m_textures_terrain->get(i).width();
			pos.y = (int)position.y % m_textures_terrain->get(i).height();
		
			pixel = m_textures_terrain->get(i).getPixel(pos);
		
			pixel.getPixelInfo(&r, &g, &b, &a);
			
			adequate_color.r += (int)( (float)perc[i] * (float)r );
			adequate_color.g += (int)( (float)perc[i] * (float)g );
			adequate_color.b += (int)( (float)perc[i] * (float)b );
		}
	}
	
	free(perc);
	
	return adequate_color;
}

int Terrain::creerTerrainTex(Rect resolution_texture)
{
	m_resolution_texture = resolution_texture;
	
	int i = 0, x = 0, y = 0, hauteur = 0;
	Pixel pixel_actuel;
	
	for(int i = 0; i < m_textures_terrain->get_nbr_sprites(); i++)
	{
		if( m_textures_terrain->get(i) == false )
			return -1;
		else
			m_textures_terrain->get(i).lock();
	}
	
	if( m_carte_terrain_surf == false )
		return -2;
	
	SDL_Surface *terrain_texture_surface = SDL_CreateRGBSurface(SDL_HWSURFACE, m_resolution_texture.w, m_resolution_texture.h, 24, 0, 0, 0, 0);
	
	m_carte_terrain.lock();
	
	SDL_LockSurface(terrain_texture_surface);
		
	for(y = 0; y < terrain_texture_surface->h; y++)
	{
		for(x = 0; x < terrain_texture_surface->w; x++)
		{
			//hauteur = m_carte_terrain.getPixelColor( Rect( (int)( (float)x*((float)m_carte_terrain.width()/(float)terrain_texture_surface->w) ), (int)( (float)y*((float)m_carte_terrain.height()/(float)terrain_texture_surface->h) ) ) ).r; // Le niveau de gris est la hauteur dans ce pixel car la carte topographique est en noir et
			hauteur = (int) m_carte_terrain_surf.getPixelOneComposant( Rect( (int)( (float)x*((float)m_carte_terrain.width()/(float)terrain_texture_surface->w) ), (int)( (float)y*((float)m_carte_terrain.height()/(float)terrain_texture_surface->h) ) ), 0);
			// blanc et chaque pixel indique une hauteur allant de 0 jusqu'à 255
			
			//cout << hauteur << endl;
			
			RGB couleur_pixel_actuel = getColor(hauteur, Rect(x, y, terrain_texture_surface->w, terrain_texture_surface->h) );
			
			//pixel_actuel = Pixel( (Uint8)couleur_pixel_actuel.r, (Uint8)couleur_pixel_actuel.g, (Uint8)couleur_pixel_actuel.b, (Uint8)0, *terrain_texture_surface->format);
			
			setPixel(terrain_texture_surface, Rect(x, y), SDL_MapRGB(terrain_texture_surface->format, (Uint8)couleur_pixel_actuel.r, (Uint8)couleur_pixel_actuel.g, (Uint8)couleur_pixel_actuel.b) );
		}
	}
	
	SDL_UnlockSurface(terrain_texture_surface);
	
	m_carte_terrain_surf.unlock();
	
	for(int i = 0; i < m_textures_terrain->get_nbr_sprites(); i++)
	{
		m_textures_terrain->get(i).unlock();
	}
	
	glEnable(GL_TEXTURE_2D);
	
//	m_texture_finale_terrain = loadTexture(terrain_texture_surface);
	
	glGenTextures(1, &(m_texture_finale_terrain) );
	glBindTexture(GL_TEXTURE_2D, m_texture_finale_terrain);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
	gluBuild2DMipmaps(GL_TEXTURE_2D, 3, terrain_texture_surface->w, terrain_texture_surface->h, GL_RGB, GL_UNSIGNED_BYTE, terrain_texture_surface->pixels);
	
	glDisable(GL_TEXTURE_2D);
	
//	SDL_SaveBMP(terrain_texture_surface, "mi.bmp");
	
	SDL_FreeSurface(terrain_texture_surface);
}

bool Terrain::draw(Rect pos, bool avec_texture, float lineWidth, RGB couleur_lignes)
{
	if(m_carte_terrain_surf == false) // Si la carte du terrain est corrompue (c'est une image)
		return false; // On retourne erreur
	if(m_texture_finale_terrain == 0) // Si la texture de terrain est égale à 0 (donc pas de texture :D )
		return false; // On retourner false
	if(m_hauteurs_textures.size() == 0)
		return false;
	
	glPushMatrix(); // On sauvegarde la matrix
	
	glTranslated(pos.x - m_dimensions.w/2, pos.y - m_dimensions.l/2, 0); // On translate pour que le terrain soit dessiné au milieu du point donné (seulement en x et y)
	
	Rect position;
	unsigned int i = 0, j = 0;
	
	if(!avec_texture)
		glLineWidth(lineWidth);

	float ajoutx = m_dimensions.w / (float)m_carte_terrain.front().size(); // L'ajout de position varie
	float ajouty = m_dimensions.l / (float)m_carte_terrain.size();
	float division_hauteur = 255 / m_dimensions.h; // Puisque la carte peut enregistrer des hauteurs plus grandes que l'espérance de l'utilisateur, on divise n'importe quelle hauteur dans la carte par cette variable
	
	if(avec_texture) // Si on dessine le terrain avec texture
	{
		glEnable(GL_TEXTURE_2D);
		glBindTexture(GL_TEXTURE_2D, m_texture_finale_terrain); // On indique à OpenGL qu'on utilisera la texture du terrain précédemment créée
	}
	
	if(!avec_texture)
		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
	
	glBegin(GL_TRIANGLES);
	
	if(!avec_texture)
		glColor3ub(couleur_lignes.r, couleur_lignes.g, couleur_lignes.b);
	
//	float facteur_y = (float)m_carte_terrain.height() / (float)m_carte_terrain.size();
//	float facteur_x = (float)m_carte_terrain.width() / (float)m_carte_terrain.front().size();
	
//	m_carte_terrain.lock();
	
	//for(j = 0, position.y = 0; j < (precision * (float)m_carte_terrain.height() ) - 1; j++, position.y += ajouty)
	for(j = 0, position.y = 0; j < m_carte_terrain.size() - 1; j++, position.y += ajout)
	{
//		for(i = 0, position.x = 0; i < (precision * (float)m_carte_terrain.width() ) - 1; i++, position.x += ajoutx)
		for(i = 0, position.x = 0; i < m_carte_terrain.front().size() - 1; i++, position.y += ajout)
		{
			if(avec_texture)
				glTexCoord2f( (float)i / (float)m_carte_terrain.front().size(), (float)j / (float)m_carte_terrain.size() );
			glVertex3f(position.x, position.y, m_carte_terrain[j][i]/division_hauteur );
			
			if(avec_texture)
				glTexCoord2f( (float)i / (float)m_carte_terrain.front().size(), (float)(j + 1) / (float)m_carte_terrain..size());
			glVertex3f(position.x, position.y + ajouty, m_carte_terrain[j+1][i]/division_hauteur );
			
			if(avec_texture)
				glTexCoord2f( (float)(i + 1) / (float)m_carte_terrain.front().size(), (float)(j + 1) / (float)m_carte_terrain.size());
			glVertex3f(position.x + ajoutx, position.y + ajouty, m_carte_terrain[j+1][i+1]/division_hauteur );
			
			
			if(avec_texture)
				glTexCoord2f( (float)i / (float)m_carte_terrain.front().size(), (float)j / (float)m_carte_terrain.size());
			glVertex3f(position.x, position.y, m_carte_terrain[j][i]/division_hauteur );

			if(avec_texture)
				glTexCoord2f( (float)(i + 1) / (float)m_carte_terrain.front().size(), (float)(j + 1) / (float)m_carte_terrain.size());
			glVertex3f(position.x + ajoutx, position.y + ajouty, m_carte_terrain[j+1][i+1]/division_hauteur );
			
			if(avec_texture)
				glTexCoord2f( (float)(i + 1) / (float)m_carte_terrain.front().size(), (float)j / (float)m_carte_terrain.size());
			glVertex3f(position.x + ajoutx, position.y, m_carte_terrain[j][i+1]/division_hauteur );
		}
	}
	
	glEnd();
	
	glPopMatrix();
}