[Glestae-svn] SF.net SVN: glestae:[1036] trunk/source/game

[<si...@us...>]

Revision: 1036
          http://glestae.svn.sourceforge.net/glestae/?rev=1036&view=rev
Author:   silnarm
Date:     2010-12-19 12:42:05 +0000 (Sun, 19 Dec 2010)

Log Message:
-----------
 * TerrainRenderer2, to use start program with '-test tr2'
   * Map vertex data is in a VBO, vertices are duplicated, is (video) memory hungry
   * splatted textures are all copied onto one big texture
   * can leave ugly artefacts on tile borders when zoomed out (fp precision)
   * significantly faster than TerrainRendererGlest (~3X at starting zoom, even better zoomed out more)
   * no dynamic map updates yet, and generally in need of much clean-up
 * fix -loadmap for shroud-of-darkness (turn off)
 * fix fog on border tiles when shroud-of-darkness is off

Modified Paths:
--------------
    trunk/source/game/game/game.cpp
    trunk/source/game/graphics/renderer.cpp
    trunk/source/game/graphics/surface_atlas.cpp
    trunk/source/game/graphics/surface_atlas.h
    trunk/source/game/graphics/terrain_renderer.cpp
    trunk/source/game/graphics/terrain_renderer.h
    trunk/source/game/main/program.cpp
    trunk/source/game/world/map.cpp
    trunk/source/game/world/map.h
    trunk/source/game/world/minimap.cpp

Modified: trunk/source/game/game/game.cpp
===================================================================
--- trunk/source/game/game/game.cpp	2010-12-16 10:48:28 UTC (rev 1035)
+++ trunk/source/game/game/game.cpp	2010-12-19 12:42:05 UTC (rev 1036)
@@ -909,11 +909,11 @@
 }
 
 void ShowMap::render2d(){
-	//init
-	g_renderer.reset2d();
+	////init
+	//g_renderer.reset2d();
 
-	//2d mouse
-	g_renderer.renderMouse2d(mouseX, mouseY, mouse2d, gui.isSelectingPos() ? 1.f : 0.f);
+	////2d mouse
+	//g_renderer.renderMouse2d(mouseX, mouseY, mouse2d, gui.isSelectingPos() ? 1.f : 0.f);
 }
 
 void ShowMap::keyDown(const Key &key) {

Modified: trunk/source/game/graphics/renderer.cpp
===================================================================
--- trunk/source/game/graphics/renderer.cpp	2010-12-16 10:48:28 UTC (rev 1035)
+++ trunk/source/game/graphics/renderer.cpp	2010-12-19 12:42:05 UTC (rev 1036)
@@ -29,6 +29,7 @@
 #include "factory_repository.h"
 #include "sim_interface.h"
 #include "debug_stats.h"
+#include "program.h"
 
 #include "leak_dumper.h"
 
@@ -264,7 +265,12 @@
 	shadowMapFrame= 0;
 	waterAnim= 0;
 
-	m_terrainRenderer = new TerrainRendererGlest();
+	// terrain renderer
+	if (g_program.getCmdArgs().isTest("tr2")) {
+		m_terrainRenderer = new TerrainRenderer2();
+	} else {
+		m_terrainRenderer = new TerrainRendererGlest();
+	}
 	m_terrainRenderer->init(g_world.getMap(), g_world.getTileset());
 
 	// shadows
@@ -936,7 +942,7 @@
 				glMaterialfv(
 					GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE,
 					computeWaterColor(waterLevel, map->getTileHeight(tilePos1)).ptr());
-				glMultiTexCoord2fv(GL_TEXTURE1, mapData.get(tilePos1).texCoord().ptr());
+				glMultiTexCoord2fv(GL_TEXTURE1, mapData.get(tilePos1).fowTexCoord().ptr());
 				glTexCoord3f( (float)i, 1.f, waterAnim );
 				glVertex3f(
 					float(i) * GameConstants::mapScale,
@@ -947,7 +953,7 @@
 				glMaterialfv(
 					GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE,
 					computeWaterColor(waterLevel, map->getTileHeight(tilePos0)).ptr());
-				glMultiTexCoord2fv(GL_TEXTURE1, mapData.get(tilePos0).texCoord().ptr());
+				glMultiTexCoord2fv(GL_TEXTURE1, mapData.get(tilePos0).fowTexCoord().ptr());
 				glTexCoord3f( (float)i, 0.f, waterAnim );
 				glVertex3f(
 					float(i) * GameConstants::mapScale,
@@ -961,7 +967,7 @@
 					glMaterialfv(
 						GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE,
 						computeWaterColor(waterLevel, map->getTileHeight(tilePos1)).ptr());
-					glMultiTexCoord2fv(GL_TEXTURE1, mapData.get(tilePos1).texCoord().ptr());
+					glMultiTexCoord2fv(GL_TEXTURE1, mapData.get(tilePos1).fowTexCoord().ptr());
 					glTexCoord3f( (float)i, 1.f, waterAnim );
 					glVertex3f(
 						float(i) * GameConstants::mapScale,
@@ -972,7 +978,7 @@
 					glMaterialfv(
 						GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE,
 						computeWaterColor(waterLevel, map->getTileHeight(tilePos0)).ptr());
-					glMultiTexCoord2fv(GL_TEXTURE1, mapData.get(tilePos0).texCoord().ptr());
+					glMultiTexCoord2fv(GL_TEXTURE1, mapData.get(tilePos0).fowTexCoord().ptr());
 					glTexCoord3f( (float)i, 0.f, waterAnim );
 					glVertex3f(
 						float(i) * GameConstants::mapScale,

Modified: trunk/source/game/graphics/surface_atlas.cpp
===================================================================
--- trunk/source/game/graphics/surface_atlas.cpp	2010-12-16 10:48:28 UTC (rev 1035)
+++ trunk/source/game/graphics/surface_atlas.cpp	2010-12-19 12:42:05 UTC (rev 1036)
@@ -30,59 +30,57 @@
 //	class SurfaceInfo
 // =====================================================
 
-SurfaceInfo::SurfaceInfo(const Pixmap2D *lu, const Pixmap2D *ru, const Pixmap2D *ld, const Pixmap2D *rd){
-	this->leftDown= ld;
-	this->leftUp= lu;
-	this->rightDown= rd;
-	this->rightUp= ru;
-	center= NULL;
+SurfaceInfo::SurfaceInfo(const Pixmap2D *lu, const Pixmap2D *ru, const Pixmap2D *ld, const Pixmap2D *rd) {
+	this->leftDown = ld;
+	this->leftUp = lu;
+	this->rightDown = rd;
+	this->rightUp = ru;
+	this->center = NULL;
 	this->coord = Vec2f(0.f);
 }
 
-SurfaceInfo::SurfaceInfo(const Pixmap2D *center){
-	this->leftDown= NULL;
-	this->leftUp= NULL;
-	this->rightDown= NULL;
-	this->rightUp= NULL;
-	this->center= center;
+SurfaceInfo::SurfaceInfo(const Pixmap2D *center) {
+	this->leftDown = NULL;
+	this->leftUp = NULL;
+	this->rightDown = NULL;
+	this->rightUp = NULL;
+	this->center = center;
 	this->coord = Vec2f(0.f);
 }
 
-bool SurfaceInfo::operator==(const SurfaceInfo &si) const{
-	return
-		this->center == si.getCenter() &&
-		this->leftDown == si.getLeftDown() &&
-		this->leftUp == si.getLeftUp() &&
-		this->rightDown == si.getRightDown() &&
-		this->rightUp == si.getRightUp();
+bool SurfaceInfo::operator==(const SurfaceInfo &si) const {
+	return this->center == si.getCenter()
+		&& this->leftDown == si.getLeftDown()
+		&& this->leftUp == si.getLeftUp()
+		&& this->rightDown == si.getRightDown()
+		&& this->rightUp == si.getRightUp();
 }
 
 // ===============================
 // 	class SurfaceAtlas
 // ===============================
 
-SurfaceAtlas::SurfaceAtlas(){
-	surfaceSize= -1;
+SurfaceAtlas::SurfaceAtlas() : m_coordStep(1.f) {
+	surfaceSize = -1;
 }
 
-void SurfaceAtlas::addSurface(SurfaceInfo *si){
+void SurfaceAtlas::addSurface(SurfaceInfo *si) {
 
-	//check dimensions
-	if(si->getCenter()!=NULL){
+	// check dimensions
+	if (si->getCenter() != NULL) {
 		checkDimensions(si->getCenter());
-	}
-	else{
+	} else {
 		checkDimensions(si->getLeftUp());
 		checkDimensions(si->getLeftDown());
 		checkDimensions(si->getRightUp());
 		checkDimensions(si->getRightDown());
 	}
 
-	//add info
-	SurfaceInfos::iterator it= find(surfaceInfos.begin(), surfaceInfos.end(), *si);
-	if(it==surfaceInfos.end()){
-		//add new texture
-		Texture2D *t= Renderer::getInstance().newTexture2D(ResourceScope::GAME);
+	// add info
+	SurfaceInfos::iterator it = find(surfaceInfos.begin(), surfaceInfos.end(), *si);
+	if (it == surfaceInfos.end()) {
+		// add new texture
+		Texture2D *t = Renderer::getInstance().newTexture2D(ResourceScope::GAME);
 		t->setWrapMode(Texture::wmClampToEdge);
 		t->getPixmap()->init(surfaceSize, surfaceSize, 3);
 
@@ -90,28 +88,73 @@
 		si->setTexture(t);
 		surfaceInfos.push_back(*si);
 
-		//copy texture to pixmap
-		if(si->getCenter()!=NULL){
+		// copy texture to pixmap
+		if (si->getCenter() != NULL) {
 			t->getPixmap()->copy(si->getCenter());
 			//t->getPixmap()->splat(si->getCenter(), si->getCenter(), si->getCenter(), si->getCenter());
-		}
-		else{
+		} else {
 			t->getPixmap()->splat(si->getLeftUp(), si->getRightUp(), si->getLeftDown(), si->getRightDown());
 		}
-	}
-	else{
+	} else {
 		si->setCoord(it->getCoord());
 		si->setTexture(it->getTexture());
 	}
 }
 
-void SurfaceAtlas::checkDimensions(const Pixmap2D *p){
-	if(surfaceSize==-1){
-		surfaceSize= p->getW();
+void SurfaceAtlas::checkDimensions(const Pixmap2D *p) {
+	if (surfaceSize == -1) {
+		surfaceSize = p->getW();
+		if (!isPowerOfTwo(surfaceSize)) {
+			throw runtime_error("Bad surface texture dimensions (not power of two)");
+		}
 	}
-	else if(p->getW()!=surfaceSize || p->getH()!=surfaceSize){
-		throw runtime_error("Bad surface texture dimensions");
+	if (p->getW() != surfaceSize || p->getH() != surfaceSize) {
+		throw runtime_error("Bad surface texture dimensions (all tileset textures are not same size)");
 	}
 }
 
-}}//end namespace
+void SurfaceAtlas2::buildTexture() {
+	int numTex = surfaceInfos.size();
+	int sideLength = int(sqrtf(float(numTex))) + 1;
+	///@todo fix, no need to be square, this is wasting lots of tex mem
+	m_width = m_height = nextPowerOf2(sideLength * surfaceSize);
+	sideLength = m_width / surfaceSize;
+	RUNTIME_CHECK(m_width % surfaceSize == 0);
+	Texture2D *tex = g_renderer.newTexture2D(ResourceScope::GAME);
+	tex->setWrapMode(Texture::wmClampToEdge);
+	m_texture = tex;
+	
+	Pixmap2D *pixmap = tex->getPixmap();
+	pixmap->init(m_width, m_height, 3);
+
+	//Vec3f debugColour(1.f, 0.f, 0.f);
+	//for (int y=0; y < m_height; ++y) {
+	//	for (int x=0; x < m_width; ++x) {
+	//		pixmap->setPixel(x, y, debugColour.ptr());
+	//	}
+	//}
+
+	int x = 0, y = 0;
+	int tx = 0, ty = 0;
+	float stepSize = 1.f / float(sideLength);
+	float pixelSize = 1.f / float(m_width);
+	m_coordStep = stepSize - 2.f * pixelSize;
+
+	foreach (SurfaceInfos, it, surfaceInfos) {
+		pixmap->subCopy(x, y, it->getTexture()->getPixmap());
+		float s = tx * stepSize + pixelSize;
+		float t = ty * stepSize + pixelSize;
+		it->setCoord(Vec2f(s, t));
+		x += surfaceSize;
+		++tx;
+		if (x + surfaceSize > m_width) {
+			x = 0;
+			y += surfaceSize;
+			++ty;
+			tx = 0;
+		}
+	}
+	//pixmap->savePng("terrain_tex.png");
+}
+
+}} // end namespace

Modified: trunk/source/game/graphics/surface_atlas.h
===================================================================
--- trunk/source/game/graphics/surface_atlas.h	2010-12-16 10:48:28 UTC (rev 1035)
+++ trunk/source/game/graphics/surface_atlas.h	2010-12-19 12:42:05 UTC (rev 1036)
@@ -31,7 +31,7 @@
 //	class SurfaceInfo
 // =====================================================
 
-class SurfaceInfo{
+class SurfaceInfo {
 private:
 	const Pixmap2D *center;
 	const Pixmap2D *leftUp;
@@ -65,23 +65,45 @@
 // =====================================================
 
 class SurfaceAtlas{
-private:
+protected:
 	typedef vector<SurfaceInfo> SurfaceInfos;
 
-private:
+protected:
 	SurfaceInfos surfaceInfos;
 	int surfaceSize;
+	float m_coordStep;
 
 public:
 	SurfaceAtlas();
 
 	void addSurface(SurfaceInfo *si);
-	float getCoordStep() const { return 1.f; }
+	float getCoordStep() const { return m_coordStep; }
 
 private:
 	void checkDimensions(const Pixmap2D *p);
 };
 
+class SurfaceAtlas2 : public SurfaceAtlas {
+private:
+	const Texture2D *m_texture;
+	int		m_width, m_height;
+
+public:
+	SurfaceAtlas2() : m_texture(0), m_width(0), m_height(0) { }
+
+	void buildTexture();
+	Vec2f getTexCoords(const Texture2D *tex) {
+		foreach (SurfaceInfos, it, surfaceInfos) {
+			if (it->getTexture() == tex) {
+				return it->getCoord();
+			}
+		}
+		throw runtime_error("Texture not in atlas!");
+	}
+
+	const Texture2D* getMasterTexture() const { return m_texture; }
+};
+
 }}//end namespace
 
 #endif

Modified: trunk/source/game/graphics/terrain_renderer.cpp
===================================================================
--- trunk/source/game/graphics/terrain_renderer.cpp	2010-12-16 10:48:28 UTC (rev 1035)
+++ trunk/source/game/graphics/terrain_renderer.cpp	2010-12-19 12:42:05 UTC (rev 1036)
@@ -39,7 +39,6 @@
 // ===========================================================
 
 TerrainRenderer::~TerrainRenderer() {
-	delete m_mapData;
 }
 
 void TerrainRenderer::initMapData(const Vec2i &size, MapVertexData *data) {
@@ -51,7 +50,7 @@
 	float yStep = 1.f / (m_size.h - 1.f);
 	for (int i=0; i < m_size.w; ++i) {
 		for (int j=0; j < m_size.h; ++j) {
-			m_mapData->get(i, j).texCoord() = Vec2f(i * xStep, j * yStep);
+			m_mapData->get(i, j).fowTexCoord() = Vec2f(i * xStep, j * yStep);
 		}
 	}
 }
@@ -90,15 +89,7 @@
 	return si.getTexture();
 }
 
-
-void TerrainRendererGlest::init(Map *map, Tileset *tileset) {
-	m_map = map;
-	Vec2i size(map->getTileW(), map->getTileH());
-	TerrainRenderer::initMapData(size, map->getVertexData());
-
-	m_tileset = tileset;
-	m_surfaceAtlas = new SurfaceAtlas();
-
+void TerrainRendererGlest::splatTextures() {
 	for (int i = 0; i < m_map->getTileW() - 1; ++i) {
 		for (int j = 0; j < m_map->getTileH() - 1; ++j) {
 			Vec2f coord;
@@ -115,6 +106,17 @@
 	}
 }
 
+void TerrainRendererGlest::init(Map *map, Tileset *tileset) {
+	m_map = map;
+	Vec2i size(map->getTileW(), map->getTileH());
+	TerrainRenderer::initMapData(size, map->getVertexData());
+
+	m_tileset = tileset;
+	m_surfaceAtlas = new SurfaceAtlas();
+
+	splatTextures();
+}
+
 void TerrainRendererGlest::render(SceneCuller &culler) {
 	SECTION_TIMER(RENDER_SURFACE);
 	IF_DEBUG_EDITION(
@@ -125,7 +127,6 @@
 
 	Renderer &renderer = g_renderer;
 	int lastTex=-1;
-
 	int currTex;
 	const Rect2i mapBounds(0, 0, m_map->getTileW() - 1, m_map->getTileH() - 1);
 
@@ -184,22 +185,22 @@
 			glBegin(GL_TRIANGLE_STRIP);
 
 			// draw quad using immediate mode
-			glMultiTexCoord2fv(Renderer::fowTexUnit, vert01.texCoord().ptr());
+			glMultiTexCoord2fv(Renderer::fowTexUnit, vert01.fowTexCoord().ptr());
 			glMultiTexCoord2f(Renderer::baseTexUnit, surfCoord.x, surfCoord.y + coordStep);
 			glNormal3fv(vert01.norm().ptr());
 			glVertex3fv(vert01.vert().ptr());
 
-			glMultiTexCoord2fv(Renderer::fowTexUnit, vert00.texCoord().ptr());
+			glMultiTexCoord2fv(Renderer::fowTexUnit, vert00.fowTexCoord().ptr());
 			glMultiTexCoord2f(Renderer::baseTexUnit, surfCoord.x, surfCoord.y);
 			glNormal3fv(vert00.norm().ptr());
 			glVertex3fv(vert00.vert().ptr());
 
-			glMultiTexCoord2fv(Renderer::fowTexUnit, vert11.texCoord().ptr());
+			glMultiTexCoord2fv(Renderer::fowTexUnit, vert11.fowTexCoord().ptr());
 			glMultiTexCoord2f(Renderer::baseTexUnit, surfCoord.x + coordStep, surfCoord.y + coordStep);
 			glNormal3fv(vert11.norm().ptr());
 			glVertex3fv(vert11.vert().ptr());
 
-			glMultiTexCoord2fv(Renderer::fowTexUnit, vert10.texCoord().ptr());
+			glMultiTexCoord2fv(Renderer::fowTexUnit, vert10.fowTexCoord().ptr());
 			glMultiTexCoord2f(Renderer::baseTexUnit, surfCoord.x + coordStep, surfCoord.y);
 			glNormal3fv(vert10.norm().ptr());
 			glVertex3fv(vert10.vert().ptr());
@@ -220,5 +221,169 @@
 	)
 }
 
+// ===========================================================
+// 	class TerrainRenderer2
+// ===========================================================
 
+TerrainRenderer2::TerrainRenderer2()
+		: m_vertexBuffer(0) {
+}
+
+TerrainRenderer2::~TerrainRenderer2() {
+	if (m_vertexBuffer) {
+		glDeleteBuffers(1, &m_vertexBuffer);
+	}
+}
+
+bool TerrainRenderer2::checkCaps() {
+	return isGlVersionSupported(1, 5, 0);
+}
+
+void TerrainRenderer2::updateVertexData(Rect2i &area) {
+	if (area.p[0] == Vec2i(-1)) {
+		area = Rect2i(Vec2i(0), Vec2i(m_size.w - 2, m_size.h - 2));
+	}
+	const Vec2i right(1, 0);
+	const Vec2i down(0, 1);
+	const Vec2i diag(1, 1);
+	const float step = m_surfaceAtlas->getCoordStep();
+
+	///@todo fix (does not do partial updates at all right)
+	TileVertex *myData = new TileVertex[(m_size.w - 1) * (m_size.h - 1) * 4];
+	RectIterator iter(area.p[0], area.p[1]);
+	while (iter.more()) {
+		Vec2i pos = iter.next();
+		const int ndx = 4 * pos.y * (m_size.w - 1) + 4 * pos.x;
+		TileVertex &tl = m_mapData->get(pos);
+		TileVertex &tr = m_mapData->get(pos + right);
+		TileVertex &br = m_mapData->get(pos + diag);
+		TileVertex &bl = m_mapData->get(pos + down);
+
+		const Texture2D *tileTex = m_map->getTile(pos)->getTileTexture();
+		Vec2f ttCoord = static_cast<SurfaceAtlas2*>(m_surfaceAtlas)->getTexCoords(tileTex);
+
+		myData[ndx + 0] = tl;
+		myData[ndx + 0].tileTexCoord() = ttCoord + Vec2f(0.f, 0.f);
+		myData[ndx + 1] = tr;
+		myData[ndx + 1].tileTexCoord() = ttCoord + Vec2f(step, 0.f);
+		myData[ndx + 2] = br;
+		myData[ndx + 2].tileTexCoord() = ttCoord + Vec2f(step, step);
+		myData[ndx + 3] = bl;
+		myData[ndx + 3].tileTexCoord() = ttCoord + Vec2f(0.f, step);
+	}
+
+	size_t size = sizeof(TileVertex) * (m_size.w - 1) * (m_size.h - 1) * 4;
+	glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer);
+	void *vbo = glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
+	memcpy(vbo, myData, size);
+	glUnmapBuffer(GL_ARRAY_BUFFER);
+	glBindBuffer(GL_ARRAY_BUFFER, 0);
+	delete [] myData;
+}
+
+void TerrainRenderer2::init(Map *map, Tileset *tileset) {
+	m_map = map;
+	Vec2i size(map->getTileW(), map->getTileH());
+	TerrainRenderer::initMapData(size, map->getVertexData());
+
+	m_tileset = tileset;
+	m_surfaceAtlas = new SurfaceAtlas2();
+	splatTextures();
+	static_cast<SurfaceAtlas2*>(m_surfaceAtlas)->buildTexture();
+
+	glGenBuffers(1, &m_vertexBuffer);
+	glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer);
+
+	int buffSize = sizeof(TileVertex) * (m_size.w - 1) * (m_size.h - 1) * 4;
+	glBufferData(GL_ARRAY_BUFFER, buffSize, 0, GL_STATIC_DRAW);
+	glBindBufferARB(GL_ARRAY_BUFFER, 0);
+
+	updateVertexData();
+}
+
+void TerrainRenderer2::render(SceneCuller &culler) {
+	SECTION_TIMER(RENDER_SURFACE);
+
+	Renderer &renderer = g_renderer;
+	const Rect2i mapBounds(0, 0, m_map->getTileW() - 1, m_map->getTileH() - 1);
+
+	assertGl();
+
+	// build index array
+	m_indexArray.clear();
+	int tileCount = 0;
+	SceneCuller::iterator it = culler.tile_begin();
+	for ( ; it != culler.tile_end(); ++it) {
+		Vec2i pos = *it;
+		if (!mapBounds.isInside(pos)) {
+			continue;
+		}
+		int ndx = 4 * pos.y * (m_size.w - 1) + 4 * pos.x;
+		m_indexArray.push_back(ndx + 0);
+		m_indexArray.push_back(ndx + 1);
+		m_indexArray.push_back(ndx + 2);
+		m_indexArray.push_back(ndx + 3);
+		++tileCount;
+	}
+
+	// set up gl state
+	glPushAttrib(GL_LIGHTING_BIT | GL_ENABLE_BIT | GL_FOG_BIT | GL_TEXTURE_BIT);
+	glEnable(GL_BLEND);
+	glEnable(GL_COLOR_MATERIAL);
+	glDisable(GL_ALPHA_TEST);
+
+	int stride = sizeof(TileVertex);
+
+	// bind vbo, enable arrays & set vert and normal offsets
+	glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer);
+	glEnableClientState(GL_VERTEX_ARRAY);
+	glVertexPointer(3, GL_FLOAT, stride, 0);
+	glEnableClientState(GL_NORMAL_ARRAY);
+	glNormalPointer(GL_FLOAT, stride, (void*)(3 * sizeof(float)));
+
+	// fog of war texture
+	glActiveTexture(Renderer::fowTexUnit);
+	glClientActiveTexture(Renderer::fowTexUnit);
+	const Texture2D *fowTex = g_userInterface.getMinimap()->getFowTexture();
+	glEnable(GL_TEXTURE_2D);
+	glBindTexture(GL_TEXTURE_2D, static_cast<const Texture2DGl*>(fowTex)->getHandle());
+	glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, fowTex->getPixmap()->getW(), fowTex->getPixmap()->getH(),
+		GL_ALPHA, GL_UNSIGNED_BYTE, fowTex->getPixmap()->getPixels());
+	glTexCoordPointer(2, GL_FLOAT, stride, (void*)(8 * sizeof(float)));
+	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+
+	// shadow texture
+	ShadowMode shadows = renderer.getShadowMode();
+	if (shadows == ShadowMode::PROJECTED || shadows == ShadowMode::MAPPED) {
+		glActiveTexture(Renderer::shadowTexUnit);
+		glEnable(GL_TEXTURE_2D);
+		glBindTexture(GL_TEXTURE_2D, renderer.getShadowMapHandle());
+		renderer.enableProjectiveTexturing();
+	}
+
+	// base texture
+	glActiveTexture(Renderer::baseTexUnit);
+	glClientActiveTexture(Renderer::baseTexUnit);
+	const Texture2D *baseTex = static_cast<SurfaceAtlas2*>(m_surfaceAtlas)->getMasterTexture();
+	GLuint texHandle = static_cast<const Texture2DGl*>(baseTex)->getHandle();
+	glBindTexture(GL_TEXTURE_2D, texHandle);
+	glTexCoordPointer(2, GL_FLOAT, stride, (void*)(6 * sizeof(float)));
+	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+
+	// zap
+	glDrawElements(GL_QUADS, tileCount * 4, GL_UNSIGNED_INT, &m_indexArray[0]);
+
+	// disable arrays/buffers & restore state
+	glDisableClientState(GL_VERTEX_ARRAY);
+	glDisableClientState(GL_NORMAL_ARRAY);
+	glActiveTexture(Renderer::fowTexUnit);
+	glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+	glActiveTexture(Renderer::baseTexUnit);
+	glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+	glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+	glPopAttrib();
+	assertGl();
+}
+
 }} // end namespace Glest::Graphics

Modified: trunk/source/game/graphics/terrain_renderer.h
===================================================================
--- trunk/source/game/graphics/terrain_renderer.h	2010-12-16 10:48:28 UTC (rev 1035)
+++ trunk/source/game/graphics/terrain_renderer.h	2010-12-19 12:42:05 UTC (rev 1036)
@@ -70,25 +70,45 @@
 // ===========================================================
 
 class TerrainRendererGlest : public TerrainRenderer {
-private:
+protected:
 	Map				*m_map;
 	Tileset			*m_tileset;
 	SurfaceAtlas	*m_surfaceAtlas;
 
 	const Texture2D* addSurfTex(int tl, int tr, int bl, int br);
+	void splatTextures();
 
 public:
 	TerrainRendererGlest();
 	~TerrainRendererGlest();
 
 	virtual bool checkCaps() override; /**< Check GL caps, can this renderer be used? */
-
 	virtual void init(Map *map, Tileset *tileset) override;
-
 	virtual void render(SceneCuller &culler) override; /**< render visible terrain */
 };
 
+// ===========================================================
+// 	class TerrainRenderer2
+//
+///	experimental
+// ===========================================================
 
+class TerrainRenderer2 : public TerrainRendererGlest {
+protected:
+	GLuint			m_vertexBuffer;
+	vector<uint32>	m_indexArray;
+
+	void updateVertexData(Rect2i &area = Rect2i(-1, -1, -1, -1));
+
+public:
+	TerrainRenderer2();
+	~TerrainRenderer2();
+
+	virtual bool checkCaps() override;
+	virtual void init(Map *map, Tileset *tileset) override;
+	virtual void render(SceneCuller &culler) override;
+};
+
 }} // end namespace Glest::Graphics
 
 #endif // ndef _GLEST_GRAPHICS_TARRAIN_RENDERER_H_

Modified: trunk/source/game/main/program.cpp
===================================================================
--- trunk/source/game/main/program.cpp	2010-12-16 10:48:28 UTC (rev 1035)
+++ trunk/source/game/main/program.cpp	2010-12-19 12:42:05 UTC (rev 1036)
@@ -203,6 +203,7 @@
 		gs.setTilesetPath(string("tilesets/") + cmdArgs.getLoadTileset());
 		gs.setTechPath(string("techs/magitech"));
 		gs.setFogOfWar(false);
+		gs.setShroudOfDarkness(false);
 		gs.setFactionCount(0);
 
 		try{

Modified: trunk/source/game/world/map.cpp
===================================================================
--- trunk/source/game/world/map.cpp	2010-12-16 10:48:28 UTC (rev 1035)
+++ trunk/source/game/world/map.cpp	2010-12-19 12:42:05 UTC (rev 1036)
@@ -72,10 +72,10 @@
 Map::~Map() {
 	Logger::getInstance().add("~Cells", !Program::getInstance()->isTerminating());
 
-	if(cells)			{delete[] cells;}
-	if(tiles)			{delete[] tiles;}
-	if(startLocations)	{delete[] startLocations;}
-//	if (surfaceHeights)	{delete[] surfaceHeights;}
+	delete [] cells;
+	delete [] tiles;
+	delete [] startLocations;
+	delete m_vertexData;
 }
 
 char encodeExplorationState(Tile *tile) {
@@ -289,6 +289,7 @@
 	Logger::getInstance().add("Heightmap computations", true);
 	m_vertexData = new MapVertexData(m_tileSize);
 	smoothSurface();
+	computeNormals();
 	computeInterpolatedHeights();
 	computeNearSubmerged();
 	computeTileColors();
@@ -845,8 +846,14 @@
 }
 
 //compute normals
-void Map::computeNormals(){  
-	//compute center normals
+void Map::computeNormals() {
+	// set perimeter normals
+	PerimeterIterator pIter(Vec2i(0), m_tileSize - Vec2i(1));
+	while (pIter.more()) {
+		Vec2i pos = pIter.next();
+		m_vertexData->get(pos).norm() = Vec3f(0.f, 1.f, 0.f);
+	}
+	// compute center normals
 	for (int i=1; i < m_tileSize.w - 1; ++i) {
 		for (int j=1; j < m_tileSize.h - 1; ++j) {
 			m_vertexData->get(i, j).norm() = m_vertexData->get(i, j).vert().normal(
@@ -961,24 +968,25 @@
 	Util::RectIterator rectIter(Vec2i(1), m_tileSize - Vec2i(2));
 	while (rectIter.more()) {
 		Vec2i pos = rectIter.next();
-		float hieght = 0.f;
+		float height = 0.f;
 		perimIter = Util::PerimeterIterator(pos - Vec2i(1), pos + Vec2i(1));
 		while (perimIter.more()) {
 			Vec2i pos2 = perimIter.next();
-			hieght += m_heightMap[pos2.y * m_tileSize.w + pos2.x];
+			height += m_heightMap[pos2.y * m_tileSize.w + pos2.x];
 		}
-		hieght /= 9.f;
-		setTileHeight(pos, hieght);
+		height /= 9.f;
+		setTileHeight(pos, height);
 
 		Tile *tile = getTile(pos);
 		Object *obj = tile->getObject();
 		if (obj) {
 			Vec3f pos = obj->getPos();
-			pos.y = hieght;
+			pos.y = height;
 			obj->setPos(pos);
 		}
 	}
 	delete [] m_heightMap;
+	m_heightMap = 0;
 }
 
 void Map::computeNearSubmerged() {

Modified: trunk/source/game/world/map.h
===================================================================
--- trunk/source/game/world/map.h	2010-12-16 10:48:28 UTC (rev 1035)
+++ trunk/source/game/world/map.h	2010-12-19 12:42:05 UTC (rev 1036)
@@ -172,7 +172,7 @@
 	void deleteResource()					{ delete object; object= NULL;				}
 	//void resetVertex()						{ vertex = originalVertex;					}
 	//void alterVertex(const Vec3f &offset)	{ vertex += offset;							}
-	void updateObjectVertex();/*				{
+	/*void updateObjectVertex();				{
 		if (object) {
 			float xzOffset = GameConstants::cellScale / 2.f;
 			object->setPos(vertex + Vec3f(xzOffset, 0.f, xzOffset));
@@ -183,14 +183,27 @@
 /** Tile Vertex structure */
 struct TileVertex {
 private:
-	Vec3f m_position;
-	Vec3f m_normal;
-	Vec2f m_fowTexCoord;
+	Vec3f m_position;		// 12
+	Vec3f m_normal;			// 12
+	Vec2f m_tileTLTexCoord;	//  8
+	Vec2f m_fowTexCoord;	//  8 => 40 != good
 
+	//Vec2f m_tileTRTexCoord;	//  8
+	//Vec2f m_tileBRTexCoord;	//  8
+	//Vec2f m_tileBLTexCoord;	//  8 => 64 == good.
+
 public:
+	TileVertex() : m_tileTLTexCoord(0.f) {}
+
+	TileVertex& operator=(const TileVertex &that) {
+		memcpy(this, &that, sizeof(TileVertex));
+		return *this;
+	}
+
 	Vec3f& vert() { return m_position; }
 	Vec3f& norm() { return m_normal; }
-	Vec2f& texCoord() { return m_fowTexCoord; }
+	Vec2f& tileTexCoord() { return m_tileTLTexCoord; }
+	Vec2f& fowTexCoord() { return m_fowTexCoord; }
 };
 
 /** vertex data for the map, in video card friendly format */
@@ -218,6 +231,8 @@
 	TileVertex& get(int x, int y) {
 		return m_data[y * m_size.w + x];
 	}
+
+	TileVertex* data() {return m_data;}
 };
 
 // =====================================================
@@ -311,10 +326,7 @@
 	bool isInside(int x, int y) const		{return x >= 0 && y >= 0 && x < m_cellSize.w && y < m_cellSize.h;}
 	bool isInside(const Vec2i &pos) const	{return isInside(pos.x, pos.y);}
 	bool isInsideTile(int sx, int sy) const	{return sx >= 0 && sy >= 0 && sx < m_tileSize.w && sy < m_tileSize.h;}
-	
-	bool isInsideTile(const Vec2i &sPos) const	{
-		return isInsideTile(sPos.x, sPos.y);
-	}
+	bool isInsideTile(const Vec2i &sPos) const	{ return isInsideTile(sPos.x, sPos.y); }
 
 	bool isResourceNear(const Vec2i &pos, int size, const ResourceType *rt, Vec2i &resourcePos) const;
 

Modified: trunk/source/game/world/minimap.cpp
===================================================================
--- trunk/source/game/world/minimap.cpp	2010-12-16 10:48:28 UTC (rev 1035)
+++ trunk/source/game/world/minimap.cpp	2010-12-19 12:42:05 UTC (rev 1036)
@@ -108,6 +108,8 @@
 		setExploredState(world);
 	}
 
+	f = 0.f;
+
 	// fow texture
 	m_fowTex = g_renderer.newTexture2D(ResourceScope::GAME);
 	m_fowTex->setMipmap(false);


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.