Worklog for impixi

Casual RPG

HeightMap ToolBox V0.4.4 Part 1

(Posted 2010-05-13)

For archiving reasons, here is the latest version of my Heightmap Toolbox. The biggest change is the separation of the LightMap/ShadowMap code into its own class.

Since most of the core algorithms are coded in C, Windows users will require MinGW installed.

HeightMap ToolBox V0.4.4

hmap04.4.h
(required)

/*
Heightmap Toolbox
V0.4.4

August 2009

TODO: **** Duplicate relevant comments/docs from hmap04.4.bmx file. ****

*/

void createHillMap(float [], int, int, int, int, int, int);
void createRandomMap(float [], int, int, int);
void createParticleMap(float [], int, int, int, int, int, int, int [], int);
void createFaultMap(float [], int, int, int, int);
void createPerlinMap(float [], int, int, int, float);
void createMPDMap(float [], int, int, int, float);
void recurseMPD(float [], int, int, int, int, int, int, float, float);
float MPD(float [], int, int, int, int, int, int, int, int, float, float);

void fillMap(float [], int, int, float);
void normaliseMap(float [], int, int);
void smoothenMap(float [], int, int, float);
void flattenMap(float [], int, int, float);
void makeCoast(float [], int, int, float, float);
void invertMap(float [], int, int);
void islandiseMap(float [], int, int, float, float);
void lowerCentreMap(float [], int, int);

int iRandom(int, int);
float fRandom(float, float);
void sRandom(int val);
void initRandom();

void cBlendMapsAdd(float [], int, int, float[], int, int, float [], int, int);
void cBlendMapsSub(float [], int, int, float[], int, int, float [], int, int);
void cBlendMapsHi(float [], int, int, float[], int, int, float [], int, int);
void cBlendMapsLo(float [], int, int, float[], int, int, float [], int, int);

void cBlendBrushRaise(float [], int, int, float [], int, int, int, int, float);
void cBlendBrushLower(float [], int, int, float [], int, int, int, int, float);
void cBlendBrushHi(float [], int, int, float [], int, int, int, int, int);
void cBlendBrushLo(float [], int, int, float [], int, int, int, int, int);

void cMaskHeightRange(float [], int, int, float, float, int, float, float);

float cGetMin(float [], int, int);
float cGetMax(float [], int, int);

hmap04.4.c
(required)

/*
Heightmap Toolbox
V0.4.4

August 2009

Recent changes:
	
	* blendBrushRaise - Blending is now possible if a brush's starting x and z offset is < 0.
	* blendBrushLower - Blending is now possible if a brush's starting x and z offset is < 0.
	* blendBrushHi - Blending is now possible if a brush's starting x and z offset is < 0.
	* blendBrushLo - Blending is now possible if a brush's starting x and z offset is < 0.
		
*/

#include <math.h>
#include <time.h>
#include <stdlib.h>
#include "hmap04.4.h"

void createHillMap(float arr[], int w, int h, int seed, int numhills, int maxhsize, int island)
{

	srand(seed);
	
	fillMap(arr, w, h, 0.0f);

	if (island)
		maxhsize = maxhsize * 0.5f;

	int n;
	
	for (n = 1; n <= numhills; n++)
	
	{
		int radius = iRandom(0, maxhsize);
		int centrex = iRandom(0, w - 1);
		int centrez = iRandom(0, h - 1);
		
		if (island)
		{
				int theta = iRandom(0, 359);
				int distx = iRandom(0, (w * 0.5) - radius);
				int distz = iRandom(0, (w * 0.5) - radius);
		  		centrex = (w * 0.5) + (cos(theta) * distx);
		  		centrez = (w * 0.5) + (sin(theta) * distz);
		}

      	int startx = centrex - radius;
		if (startx < 0) 
			startx = 0;

      	int endx = centrex + radius;
  		if (endx > w)
			endx = w;

    		int startz = centrez - radius;
    		if (startz < 0)
			startz = 0;

   		int endz = centrez + radius;
      	if (endz > h)
			endz = h;
	
		int x, z;
   		for (x = startx; x < endx; x++)
		{
   			for (z = startz; z < endz; z++)
			{
	   	  		float y = (radius * radius) - (((x - centrex) * (x - centrex)) + ((z - centrez) * (z - centrez)));
	      		if (y > 0.0)
					arr[(x * h + z)] = arr[(x * h + z)] + y;
	    		}
	  	}
    
    }
  
   	normaliseMap(arr, w, h);

}

void createParticleMap(float arr[], int w, int h, int seed, int particles, int clusters, int method, int val[], int valsize)
{

    float disp = 1.0f;
  
    srand(seed);

	fillMap(arr, w, h, 0.0f);
  
	int m, n, x, z;

	if (method == 0) 					//Sticky
	{
	
    	for (m = 0; m < clusters; m++)
		{
     	 	x = iRandom(0, (w - 1)); 
      		z = iRandom(0, (h - 1));
	
	    	for (n = 0; n < particles; n++)
			{
        		if (((x < w) && (z < h) && (x >= 0) && (z >= 0)))
					arr[(x * h + z)] = arr[(x * h + z)] + disp;
	
		    	switch (iRandom(0, valsize - 1))
				{
     		    		case 0:
           				x = x + val[0];
						break;
						
	         			case 1:
     	       			x = x + val[1];
						break;
						
					case 2:
						z = z + val[2];
						break;

	          		case 3:
     	       			z = z + val[3];
						break;
        		}
				
			}
	
    	}
	}
	
	else if (method == 1)				//Rolling
	
	{
	
		for (m = 0; m < clusters; m++)
		{
      		x = iRandom(0, (w - 1)); 
	      	z = iRandom(0, (h - 1));
	
   			for (n = 0; n < particles; n++)
			{
	
     	   		if (((x < w) && (z < h) && (x >= 0) && (z >= 0)))
				{
			
	      			float y = arr[(x * h + z)] + disp;
	      			arr[(x * h + z)] = y;
	
		      		int startx = x - 1;
     	     		if (startx < 0)
						startx = 0;

          			int endx = x + 1;
          			if (endx > w)
						endx = w;

	          		int startz = z - 1;
     	     		if (startz < 0)
						startz = 0;

     	    			int endz = z + 1;
          			if (endz > h)
						endz = h;
				
					int x2, z2;

     	     		for (x2 = startx; x2 < endx; x2++)
					{
            				for (z2 = startz; z2 < endz; z2++)
						{
		      				float y2 = arr[(x2 * h + z2)];
              					if (y2 < y) 
								arr[(x2 * h + z2)] = y2 + disp;
	            		}
     	     		}
	
	    		}
	
	    		switch (iRandom(0, valsize - 1))
				{
     		    	case 0:
           				x = x + val[0];
						break;
						
	         		case 1:
     	       			x = x + val[1];
						break;
						
					case 2:
						z = z + val[2];
						break;

	          		case 3:
     	       			z = z + val[3];
						break;
        		}

	     	}

    	}
	
	}
	
    normaliseMap(arr, w, h);

}

void createRandomMap(float arr[], int w, int h, int seed)
{
    	srand(seed);
		
	int x, z;
	
    	for (x = 0; x < w; x++)
     	for (z = 0; z < h; z++)
			arr[x * h + z] = fRandom(0.0f, 1.0f);	
		     		
}

void createFaultMap(float arr[], int w, int h, int seed, int realism)
{

    srand(seed);

	fillMap(arr, w, h, 0.0f);

    float d = sqrt((w * w) + (h * h));
    float disp = 10.0f;

	int n;
    
	for (n = 1; n < realism; n++)
	{
	
     	float v = fRandom(0, 359);
	  	float a = sin((v * (M_PI / 180.0f)));
      	float b = cos((v * (M_PI / 180.0f)));
      	float c = (fRandom(0, 1) * d) - (d / 2);

		int x, z;
    		for (x = 0; x < w; x++)
        		for (z = 0; z < h; z++)
					if (((a * x) + (b * z) - c) > 0.0f) 
						arr[(x * h + z)] = arr[(x * h + z)] + disp;
					else 
						arr[(x * h + z)] = arr[(x * h + z)] - disp;
    }

   	normaliseMap(arr, w, h);

}

void createPerlinMap(float arr[], int w, int h, int seed, float multiplier)
{
	if (h != w) return;

	srand(seed);

	int size = w;
    int NoiseMapSize = floor(size / 2);
	float max_height = 1.0f;
	float NoiseMap[NoiseMapSize + 1][NoiseMapSize + 1];

	int x, z;
	for (x = 0; x < size; x++)
    	for (z = 0; z < size; z++)
			arr[x * h + z] = fRandom(0.0f, 1.0f);

   	max_height = max_height * multiplier;

	do
    {
		
		int Noise_Z, Noise_X;
     	for (Noise_Z = 0; Noise_Z < NoiseMapSize + 1; Noise_Z++)
	    	for (Noise_X = 0; Noise_X < NoiseMapSize + 1; Noise_X++)
				NoiseMap[Noise_X][Noise_Z] = fRandom(0.0f, 1.0f) * max_height;
	 
      	int ScaleDifference = size / NoiseMapSize;
		float StepSize = 1.0f / (float)ScaleDifference;
		 
      	for (Noise_Z = 0; Noise_Z < NoiseMapSize; Noise_Z++)
		{
	    	for (Noise_X = 0; Noise_X < NoiseMapSize; Noise_X++)
			{
			
				float N1, N2, N3, N4;
  	      		N1 = NoiseMap[Noise_X][Noise_Z];
		  		N2 = NoiseMap[(Noise_X + 1)][Noise_Z];
	      		N3 = NoiseMap[Noise_X][(Noise_Z + 1)];
	      		N4 = NoiseMap[(Noise_X + 1)][(Noise_Z + 1)];
					
				int Hx, Hz;
	      		Hx = (float)Noise_X * (float)ScaleDifference;
	      		Hz = (float)Noise_Z * (float)ScaleDifference;
					
				float Iy = 0.0f;
	
				int Height_Z, Height_X;
	      		for (Height_Z = 0; Height_Z < ScaleDifference; Height_Z++)
				{

					float ICy = 1.0f - ((cos(Iy * 3.14159) + 1.0f) / 2.0f);
		    		float Ix = 0.0f;
            
		   			for (Height_X = 0; Height_X < ScaleDifference; Height_X++)
					{
						float ICx, Na, Nb, Nc, Nd;
						ICx = 1.0f - ((cos(Ix * 3.14159) + 1.0f) / 2.0f);
						
  		       			Na = N1 * (1.0f - ICx);
		       			Nb = N2 * ICx;
		       			Nc = N3 * (1.0f - ICx);
	  	       			Nd = N4 * ICx;
							
						int off = (((Hx + Height_X) * h) + Hz + Height_Z);
						float y = arr[off];
						arr[off] = (y + (Na + Nb) * (1.0f - ICy) + (Nc + Nd) * ICy);
		       			Ix = Ix + StepSize;
					}
					
		    		Iy = Iy + StepSize;	

	      		}
	
	    	}  	
     	}
				
		NoiseMapSize = NoiseMapSize / 2;
    	max_height = max_height * multiplier;
		
	}  while (NoiseMapSize >= 1);

	normaliseMap(arr, w, h);

}

void createMPDMap(float arr[], int w, int h, int seed, float grain)
{
    srand(seed);

	fillMap(arr, w, h, -1.0f);

    arr[0] = fRandom(0.0f, 1.0f);
    arr[(w - 1)] = fRandom(0.0f, 1.0f);
    arr[(h - 1) * w]= fRandom(0.0f, 1.0f);
    arr[(w * h) - 1] = fRandom(0.0f, 1.0f);

    recurseMPD(arr, w, h, 0, 0, w - 1, h - 1, grain, 1.0);

    normaliseMap(arr, w, h);
}

void recurseMPD(float arr[], int w, int h, int x0, int z0, int x2, int z2, float grain, float level)
{

	if (!(((x2 - x0) < 2) && ((z2 - z0) < 2)))
	{
     	float v, i;

     	level = 2.0f * level;
     
      	int x1 = ceil((x0 + x2) / 2.0f);
      	int z1 = ceil((z0 + z2) / 2.0f);
    
        int ipos = (x1 * h) + z0;
	    v = arr[ipos];
      
		if (v == -1.0f) 
			v = MPD(arr, w, h, x0, z0, x1, z0, x2, z0, grain, level);
		
		i = v;
     
		ipos = (x2 * h) + z1;
		v = arr[ipos];
		if (v == -1.0f) 
			v = MPD(arr, w, h, x2, z0, x2, z1, x2, z2, grain, level);
		
		i += v;
     
		ipos = (x1 * h) + z2;
		v = arr[ipos];
		if (v == -1.0f) 
			v = MPD(arr, w, h, x0, z2, x1, z2, x2, z2, grain, level);
      
		i += v;

		ipos = (x0 * h) + z1;
		v = arr[ipos];
		if (v == -1.0f)
			v = MPD(arr, w, h, x0, z0, x0, z1, x0, z2, grain, level);
      
		i += v;

		ipos = (x1 * h) + z1;
		if (arr[ipos] == -1.0f) 
			arr[ipos] = (float) i/4.0f;
 
		recurseMPD(arr, w, h, x0, z0, x1, z1, grain, level);
		recurseMPD(arr, w, h, x1, z0, x2, z1, grain, level);
		recurseMPD(arr, w, h, x1, z1, x2, z2, grain, level);
		recurseMPD(arr, w, h, x0, z1, x1, z2, grain, level);
	 
	}
}

float MPD(float arr[], int w, int h, int x0, int z0, int x1, int z1, int x2, int z2, float grain, float level)
{

	int ipos, ipos2;
  
	float r = fRandom(-grain, grain) / level;

	ipos = (x0 * h) + z0;
	ipos2 = (x2 * h) + z2;
	r += (arr[ipos] + arr[ipos2]) / 2.0f;
     
	if (r < 0.0f) 
		r = 0.0f;
	if (r > 1.0f) 
		r = 1.0f;
 
    ipos = (x1 * h) + z1;
    arr[ipos] = r;
     
    return r;   
}

void fillMap(float arr[], int w, int h, float val)
{

	int x, z;
	
   	for (x = 0; x < w; x++)
     	for (z = 0; z < h; z++)
			arr[x * h + z] = val;

}

void normaliseMap(float arr[], int w, int h)
{

   	float minv = 10^38, maxv = 10^-38;
  
	int x, z;
	
	for (x = 0; x < w; x++)
     	for (z = 0; z < h; z++)
 	   		if (arr[(x * h + z)] < minv)
				minv = arr[(x * h + z)];
			else 
				if (arr[(x * h + z)] > maxv)
					maxv = arr[(x * h + z)];

  	for (x = 0; x < w; x++)
     	for (z = 0; z < h; z++)
	   		arr[(x * h + z)] = (arr[(x * h + z)] - minv) / (maxv - minv);

}

void smoothenMap(float arr[], int w, int h, float k)
{
	int x, z;
	
    for (x = 1; x < w; x++)
     	for (z = 0; z < h; z++)
	    	arr[x * h + z] = arr[(x - 1) * h + z] * (1 - k) + arr[x * h + z] * k;

    for (x = (w - 3); x >= 0; x--)
	    for (z = 0; z < h; z++)
	   		arr[x * h + z] = arr[(x + 1) * h + z] * (1 - k) + arr[x * h + z] * k;
     
	for (x = 0; x < w; x++)
     	for (z = 1; z < h; z++)
	    	arr[x * h + z] = arr[x * h + (z - 1)] * (1 - k) + arr[x * h + z] * k;


    for (x = 0; x < w; x++)
     	for (z = (h - 3); z >= 0; z--)
	    	arr[x * h + z] = arr[x * h + (z + 1)] * (1 - k) + arr[x * h + z] * k;   
}

void flattenMap(float arr[], int w, int h, float val)
{

	int x, z;

    for (x = 0; x < w; x++)
     	for (z = 0; z < h; z++)
        	arr[x * h + z] = pow(arr[x * h + z], val);

}

void makeCoast(float arr[], int w, int h, float extent, float depth)
{

	int x, z;
	float e, d, min = 10^38, max = 10^-38;

	for (x = 0; x < w; x++)
		for (z = 0; z < h; z++)
	    	if (arr[x * h + z] < min)
				min = arr[x * h + z]; 
			else if (arr[x * h + z] > max)
				max = arr[x * h + z];
	  		
	e = (max - min) * extent;
	d = (max - min) * depth;
	
	for (x = 0; x < w; x++)
		for (z = 0; z < h; z++)
	    	if (arr[x * h + z] <= (min + e))
				arr[x * h + z] = arr[x * h + z] - d;

	normaliseMap(arr, w, h);
}

void invertMap(float arr[], int w, int h)
{	
	int x, z;
	
	for (x = 0; x < w; x++)
		for (z = 0; z < h; z++)
         	arr[x * h + z] = 1.0 - arr[x * h + z]; 
}

void islandiseMap(float arr[], int w, int h, float amt, float fragmentation)
{

	if ((fragmentation > 1.0) || (fragmentation < 0.0))
		fragmentation = 0.25;

	float mask[w * h];
	createHillMap(mask, w, h, time(0), 1000, (w * fragmentation), 1);
	
	int x, z;	
	for (x = 0; x < w; x++)
	{
		for (z = 0; z < h; z++)
		{
				
			float val = amt + mask[x * h + z];
			if (val > 1.0) 
				val = 1.0f;
				
			float y = arr[x * h + z];
			arr[x * h + z] = y * val;
				
		}
	}

}

void lowerCentreMap(float arr[], int w, int h)
{

	int x, z;
	float mask[w * h];
	
	createHillMap(mask, w, h, time(0), 1000, (w * 0.25f), 1);
		
	for (x = 0; x < w; x++)
		for (z = 0; z < h; z++)
			arr[x * h + z] = arr[x * h + z] * (1.0 - mask[x * h + z]);

}

int iRandom(int min, int max)
{
	return (rand() % (max + 1)) + min;
}

float fRandom(float min, float max)
{
	return (float) (( rand() * (max - min) / RAND_MAX) + min);
}

void sRandom(int val)
{
	srand(val);
}

void initRandom()
{
	srand(time(0));
}

void cBlendMapsAdd(float src1[], int src1w, int src1h, float src2[], int src2w, int src2h, float outp[], int outpw, int outph)
{
	float y1, y2;
	int x, z;
    
    for (x = 0; x < outpw; x++)
	{
		for (z = 0; z < outph; z++)
		{
      		if ((x < src1w) && (z < src1h))
				y1 = src1[x * outph + z];
			else 
				y1 = 0.0;
			
			if ((x < src2w) && (z < src2h)) 
				y2 = src2[x * outph + z];
			else 
				y2 = 0.0;

         		outp[x * outph + z] = y1 + y2;
      	}
	}
    
    normaliseMap(outp, outpw, outph);
}

void cBlendMapsSub(float src1[], int src1w, int src1h, float src2[], int src2w, int src2h, float outp[], int outpw, int outph)
{
	float y1, y2;
	int x, z;
    
    for (x = 0; x < outpw; x++)
	{
		for (z = 0; z < outph; z++)
		{
      		if ((x < src1w) && (z < src1h))
				y1 = src1[x * outph + z];
			else 
				y1 = 0.0;
			
			if ((x < src2w) && (z < src2h)) 
				y2 = src2[x * outph + z];
			else 
				y2 = 0.0;

         		outp[x * outph + z] = y1 - y2;
      	}
	}
    
    normaliseMap(outp, outpw, outph);
}

void cBlendMapsHi(float src1[], int src1w, int src1h, float src2[], int src2w, int src2h, float outp[], int outpw, int outph)
{
	float y1, y2;
	int x, z;
    
    for (x = 0; x < outpw; x++)
	{
		for (z = 0; z < outph; z++)
		{
      		if ((x < src1w) && (z < src1h))
				y1 = src1[x * outph + z];
			else 
				y1 = 0.0;
			
			if ((x < src2w) && (z < src2h)) 
				y2 = src2[x * outph + z];
			else 
				y2 = 0.0;

			if (y1 > y2)
				outp[x * outph + z] = y1;
			else 
				outp[x * outph + z] = y2;
      	}
	}
    
    normaliseMap(outp, outpw, outph);
}

void cBlendMapsLo(float src1[], int src1w, int src1h, float src2[], int src2w, int src2h, float outp[], int outpw, int outph)
{
	float y1, y2;
	int x, z;
    
    for (x = 0; x < outpw; x++)
	{
		for (z = 0; z < outph; z++)
		{
      		if ((x < src1w) && (z < src1h))
				y1 = src1[x * outph + z];
			else 
				y1 = 0.0;
			
			if ((x < src2w) && (z < src2h)) 
				y2 = src2[x * outph + z];
			else 
				y2 = 0.0;

			if (y1 < y2)
				outp[x * outph + z] = y1;
			else 
				outp[x * outph + z] = y2;
      	}
	}
    
    normaliseMap(outp, outpw, outph);
}

void cBlendBrushRaise(float arr[], int w, int h, float brush[], int bw, int bh, int offx, int offz, float p)
{
    		
	if (p < 0.0f) 
		p = 0.0f;
	else if (p > 1.0f) 
		p = 1.0f;

	int x, z, boff;
	float y1, y2;

	for (x = 0; x < bw; x++)
	{
     	for (z = 0; z < bh; z++)
		{
         	y1 = brush[x * bh + z] * p;

         	if ( ((offx + x) < w) && ((offz + z) < h) )
			{
				if ( ((offx + x) >= 0) && ((offz + z) >= 0) )
				{
					boff = ((offx + x) * h) + (offz + z);
					y2 = arr[boff] + y1;
           		
					if (y2 < 0.0f) 
						y2 = 0.0f; 
					else if (y2 > 1.0) 
						y2 = 1.0f;
           		
					arr[boff] = y2;
				}
			}
      	}
    }

}

void cBlendBrushLower(float arr[], int w, int h, float brush[], int bw, int bh, int offx, int offz, float p)
{
    		
	if (p < 0.0f) 
		p = 0.0f;
	else if (p > 1.0f) 
		p = 1.0f;

	int x, z, boff;
	float y1, y2;

	for (x = 0; x < bw; x++)
	{
     	for (z = 0; z < bh; z++)
		{
         	y1 = brush[x * bh + z] * p;

         	if ( ((offx + x) < w) && ((offz + z) < h) )
			{
				if ( ((offx + x) >= 0) && ((offz + z) >= 0) )
				{
					boff = ((offx + x) * h) + (offz + z);
					y2 = arr[boff] - y1;
           		
					if (y2 < 0.0f) 
						y2 = 0.0f; 
					else if (y2 > 1.0) 
						y2 = 1.0f;
           		
					arr[boff] = y2;
				}
			}
      	}
    }

}

void cBlendBrushHi(float arr[], int w, int h, float brush[], int bw, int bh, int offx, int offz, int clear)
{

	int x, z, boff;

	for (x = 0; x < bw; x++)
	{
     	for (z = 0; z < bh; z++)
		{
         	if ( ((offx + x) < w) && ((offz + z) < h) )
			{
				if ( ((offx + x) >= 0) && ((offz + z) >= 0) )
				{
					boff = ((offx + x) * h) + (offz + z);
           		
					if (brush[x * bh + z] > arr[boff])
						arr[boff] = brush[x * bh + z];
					else
						if (clear) 
							brush[x * bh + z] = 0.0f;
				}
			}
      	}
    }

}

void cBlendBrushLo(float arr[], int w, int h, float brush[], int bw, int bh, int offx, int offz, int clear)
{
	
	int x, z, boff;

	for (x = 0; x < bw; x++)
	{
     	for (z = 0; z < bh; z++)
		{
         	if ( ((offx + x) < w) && ((offz + z) < h) )
			{
				if ( ((offx + x) >= 0) && ((offz + z) >= 0) )
				{
				
					boff = ((offx + x) * h) + (offz + z);
           		
					if (brush[x * bh + z] < arr[boff])
						arr[boff] = brush[x * bh + z];
					else
						if (clear) 
							brush[x * bh + z] = 1.0f;
				}
			}
      	}
    }

}

void cMaskHeightRange(float arr[], int w, int h, float low, float high, int tomax, float low_edge, float high_edge)
{
	
	if ((low < 0.0f) || (low >= high))
		low = 0.0f;
		
	if ((high > 1.0f) || (high <= low))
		high = 1.0f;
		
	if ((low_edge < 0.0f) || (low_edge > 1.0f)) 
		low_edge = 0.0f;
		
	if ((high_edge < 0.0f) || (high_edge > 1.0f))
		high_edge = 0.0f;

	int x, z;

	for (x = 0; x < w; x++)
	{
     	for (z = 0; z < h; z++)
		{
			float y = arr[x * h + z];
			if ((y < low) || (y > high))
				arr[x * h + z] = 0.0f;
			else	
				if (tomax)
					if ((y > (low + low_edge)) && (y < (high - high_edge)))
						arr[x * h + z] = 1.0f;
		}
	}			
}

float cGetMin(float arr[], int w, int h)
{
  	float minv = 10^38;
  
	int x, z;
  	
	for (x = 0; x < w; x++)
     	for (z = 0; z < h; z++)
 	   		if (arr[(x * h + z)] < minv)
				minv = arr[(x * h + z)];
	
	return minv;
}	

float cGetMax(float arr[], int w, int h)
{
  	float maxv = 10^-38;
  
	int x, z;
  	
	for (x = 0; x < w; x++)
     	for (z = 0; z < h; z++)
			if (arr[(x * h + z)] > maxv)
				maxv = arr[(x * h + z)];
				
	return maxv;
}

TShadowMap.bmx
(optional - for the generation of shadow maps - see test4.bmx example)

Rem


September 2009


TODO: **** Port to C ****


TShadowMap CLASS

	create
	Calculate


TSimpleVector CLASS

	create
	setXYZ
	normalise
	add
	sub
	crossProduct
	dotProduct


EndRem


SuperStrict

Import "hmap04.4.bmx"


Type TShadowMap

	Rem 
  	PORTED, MODIFIED and OBJECTIFIED code from the blitzbasic.com code archives.
	Render a lightmap/shadowmap onto a pixmap
	End Rem


	Function Create:TShadowMap(hm:THeightMap Var, x:Float, y:Float, z:Float, smooth:Float = 0.5)
	
		Local smap:TShadowMap = New TShadowMap
	
		smap.HeightMap = hm
		smap.Sun = TSimpleVector.Create(x, y, z)
		smap.Pixmap = CreatePixmap(smap.HeightMap.Width, smap.HeightMap.Height, PF_RGB888)
		smap.K = smooth
		smap.Calculate
	
		Return smap
	
	EndFunction


	Field HeightMap:THeightMap				'Reference to a pre-existing THeightMap instance.
	Field Pixmap:TPixmap					'Pixmap representation. Format: PF_RGB888.
	Field Sun:TSimpleVector				'Sun's relative position (as a TSimpleVector object)
	Field K:Float						'Smoothing factor: Minumum 0.0 (extreme). Maxumum 1.0 (no smoothing).
	
	
	Method Calculate()

		Local tmp1:TSimpleVector = New TSimpleVector
		Local tmp2:TSimpleVector = New TSimpleVector

		Local norm:TSimpleVector[HeightMap.Width, HeightMap.Height]
		For Local i:Int = 0 To HeightMap.Width - 1 
			For Local j:Int = 0 To HeightMap.Height - 1
				norm[i, j] = New TSimpleVector
			Next
		Next
	
		Local v:TSimpleVector[9]
		Local f:TSimpleVector[9]
		For Local i:Int = 0 To (v.length - 1)
			v[i] = New TSimpleVector
			f[i] = New TSimpleVector
		Next
	
		For Local i:Int = 1 To (HeightMap.Width - 2)
			For Local j:Int = 1 To (HeightMap.Height - 2)

				v[0].setXYZ( i - HeightMap.Width / 2, ..
					PeekFloat(HeightMap.Map, (i * HeightMap.Height + j) * 4)*255, ..
						j - HeightMap.Height / 2 )
					
				v[1].setXYZ( (i - 1) - HeightMap.Width / 2, ..
					PeekFloat(HeightMap.Map, ((i - 1) * HeightMap.Height + (j - 1)) * 4) * 255, ..
						(j -  1) - HeightMap.Height / 2 )
					
				v[2].setXYZ( i - HeightMap.Width / 2, ..
					PeekFloat(HeightMap.Map, (i * HeightMap.Height + (j - 1)) * 4) * 255, ..
						(j - 1) - HeightMap.Height / 2 )
					
				v[3].setXYZ( (i + 1) - HeightMap.Width / 2, ..
					PeekFloat(HeightMap.Map, ((i + 1) * HeightMap.Height + (j - 1)) * 4) * 255, ..
						(j - 1) - HeightMap.Height / 2 )
						
				v[4].setXYZ( (i + 1) - HeightMap.Width / 2, ..
					PeekFloat(HeightMap.Map, ((i + 1) * HeightMap.Height + j) * 4) * 255, ..
						j - HeightMap.Height / 2 )
						
				v[5].setXYZ( (i + 1) - HeightMap.Width / 2, ..
					PeekFloat(HeightMap.Map, ((i + 1) * HeightMap.Height + (j + 1)) * 4) * 255, ..
						(j + 1) - HeightMap.Height / 2 )
						
				v[6].setXYZ( i - HeightMap.Width / 2, ..
					PeekFloat(HeightMap.Map, (i * HeightMap.Height + (j + 1)) * 4) * 255, ..
						(j + 1) - HeightMap.Height / 2 ) 
						
				v[7].setXYZ( (i - 1) - HeightMap.Width/2, ..
					PeekFloat(HeightMap.Map, ((i - 1) * HeightMap.Height + (j + 1)) * 4) * 255, ..
						(j + 1) - HeightMap.Height / 2 )
						
				v[8].setXYZ( (i - 1) - HeightMap.Width/2, ..
					PeekFloat(HeightMap.Map, ((i - 1) * HeightMap.Height + j) * 4) * 255, ..
						j - HeightMap.Height / 2 )


				tmp1.sub(v[8], v[1])
				tmp2.sub(v[1], v[0])
				tmp1.normalise()
				tmp2.normalise()
				f[0].crossProduct(tmp1, tmp2)
				
				tmp1.sub(v[2], v[1])
				tmp2.sub(v[1], v[0])
				tmp1.normalise()
				tmp2.normalise()
				f[1].crossProduct(tmp1, tmp2)
								
				tmp1.sub(v[3], v[2])
				tmp2.sub(v[2], v[0])
				tmp1.normalise()
				tmp2.normalise()
				f[2].crossProduct(tmp1, tmp2)	

				tmp1.sub(v[4], v[3])
				tmp2.sub(v[3], v[0])
				tmp1.normalise()
				tmp2.normalise()
				f[3].crossProduct(tmp1, tmp2)	

				tmp1.sub(v[6], v[5])
				tmp2.sub(v[5], v[0])
				tmp1.normalise()
				tmp2.normalise()
				f[4].crossProduct(tmp1, tmp2)	

				tmp1.sub(v[0], v[5])
				tmp2.sub(v[5], v[4])
				tmp1.normalise()
				tmp2.normalise()
				f[5].crossProduct(tmp1, tmp2)	

				tmp1.sub(v[6], v[0])
				tmp2.sub(v[0], v[7])
				tmp1.normalise()
				tmp2.normalise()
				f[6].crossProduct(tmp1, tmp2)

				tmp1.sub(v[0], v[8])
				tmp2.sub(v[8], v[7])
				tmp1.normalise()
				tmp2.normalise()
				f[7].crossProduct(tmp1, tmp2)
				
				tmp1.add(f[1], f[2])
				tmp2.add(tmp1, f[3])
				tmp1.add(tmp2, f[4])
				tmp2.add(tmp1, f[6])
				tmp1.add(tmp2, f[7])
				tmp2.add(tmp1, f[0])
				tmp1.add(tmp2, f[5])
				tmp1.normalise()
			
				norm[i - 1, j - 1].X = tmp1.X * 128
				norm[i - 1, j - 1].Y = tmp1.Y * 128
				norm[i - 1, j - 1].Z = tmp1.Z * 128
			
			Next
		Next

		sun.normalise()
					
		Local lmap:Int[, ] = New Int[HeightMap.Width, HeightMap.Height]
		For Local x:Int = 0 To (HeightMap.Width - 1)
			For Local z:Int = 0 To (HeightMap.Height - 1)
				lmap[x, z] = 0
			Next
		Next
		
		For Local x:Int = 0 To (HeightMap.Width - 1)
			For Local z:Int = 0 To (HeightMap.Height - 1)
		
				Local f:Float = 0.1 
						
				tmp1.X = norm[x, z].X
				tmp1.Y = norm[x, z].Y
				tmp1.Z = norm[x, z].Z

				tmp1.normalise()

				f :+ (0.5 * (1.0 + TSimpleVector.dotProduct(tmp1, sun) ))
				If f > 1 Then f = 1
			
				If LockedLine(x, z, PeekFloat(HeightMap.Map, (x * HeightMap.Height + z) * 4) * 255, sun) Then f :/ 2		' shade the shadow
				
				If f < 0 Then f = 0
			
				lmap[x, z] = Int(f * 255)
			Next
		Next
	
		For Local x:Int = 1 To (HeightMap.Width - 1)
    			For Local z:Int = 0 To (HeightMap.Height - 1)
	   			lmap[x, z] = lmap[(x - 1), z] * (1 - k) + lmap[x, z] * k
    			Next
    		Next

    		For Local x:Int = (HeightMap.Width - 3) To 0 Step -1
      		For Local z:Int = 0 To (HeightMap.Height - 1)
	    			lmap[x, z] = lmap[(x + 1), z] * (1 - k) + lmap[x, z] * k
      		Next
    		Next

    		For Local x:Int = 0 To (HeightMap.Width - 1)
      		For Local z:Int = 1 To (HeightMap.Height - 1)
	    			lmap[x, z] = lmap[x, (z - 1)] * (1 - k) + lmap[x, z] * k
      		Next
    		Next

    		For Local x:Int = 0 To (HeightMap.Width - 1)
      		For Local z:Int = (HeightMap.Height - 3) To 0 Step -1
	    			lmap[x, z] = lmap[x, (z + 1)] * (1 - k) + lmap[x, z] * k
      		Next
    		Next
	
		For Local x:Int = 0 To (HeightMap.Width - 1)
			For Local z:Int = 0 To (HeightMap.Height - 1)
				WritePixel (Pixmap, x, z, lmap[x, z] Shl 16 | lmap[x, z] Shl 8 | lmap[x, z])
			Next
		Next

	EndMethod


	Method LockedLine:Int(x1:Float, y1:Float, z1:Float, sun:TSimpleVector)
	Rem
	Utility function used by renderShadowsToPixmap
  	PORTED and MODIFIED code from the blitzbasic.com code archives.
	****  ORIGINAL AUTHOR: Tim Fisher ****
	EndRem
	
		Local x2:Float = sun.X
		Local y2:Float = sun.Y
		Local z2:Float = sun.Z
	
		While Not ((x1 > HeightMap.Width - 1) Or (y1 > HeightMap.Height - 1) Or (z1 > 255) Or (x1 < 0) Or (y1 < 0)) 
		
			If (Int(HeightMap.getHeightAt(x1, y1) * 255) > z1) Then Return True
				
			x1 :+ (x2 * 2)
			y1 :+ (z2 * 2)
			z1 :+ (y2 * 2)
	
		Wend
	
		Return False
	
	EndMethod



EndType


Type TSimpleVector

	Rem
	Utility class used by shadow mapping code.
	PORTED and MODIFIED code from the blitzbasic.com code archives.
	****  ORIGINAL AUTHORS: Chroma and Tim Fisher ****
	EndRem

	Function Create:TSimpleVector(wx:Float, wy:Float, wz:Float)
	
		Local vec:TSimpleVector = New TSimpleVector
		
		vec.setXYZ wx, wy, wz
		
		Return vec
	
	EndFunction

	Field tol:Float

	Field X:Float
	Field Y:Float
	Field Z:Float
	
	Method New()
		tol = 0.001
		X = 0.0
		Y = 0.0
		Z = 0.0
	EndMethod
	
	Method setXYZ(vx:Float = 0.0, vy:Float = 0.0, vz:Float = 0.0)
		X = vx
		Y = vy
		Z = vz
	EndMethod 

	Method normalise()
		Local mag:Float = Sqr((X * X) + (Y * Y) + (Z * Z))
		X :/ mag
		Y :/ mag
		Z :/ mag
	
		If (Abs(X) < tol) X = 0.0
		If (Abs(Y) < tol) Y = 0.0
		If (Abs(Z) < tol) Z = 0.0
	EndMethod

	Method add(v2:TSimpleVector, v3:TSimpleVector)
		X = v2.X + v3.X
		Y = v2.Y + v3.Y
		Z = v2.Z + v3.Z
	EndMethod
	
	Method sub(v2:TSimpleVector, v3:TSimpleVector)
		X = v2.X - v3.X
		Y = v2.Y - v3.Y
		Z = v2.Z - v3.Z
	EndMethod

	Method crossProduct(u:TSimpleVector, v:TSimpleVector)
		X =  u.Y * v.Z  -  u.Z * v.Y 
		Y = -u.X * v.Z  +  u.Z * v.X 
		Z =  u.X * v.Y  -  u.Y * v.X 
	EndMethod

	Function dotProduct:Float(u:TSimpleVector, v:TSimpleVector)
		Return (u.X * v.X) + (u.Y * v.Y) + (u.Z * v.Z)
	End Function

End Type

HMap04.4.bmx
(required)

Rem

HeightMap Toolbox
V0.4.4

September 2009

TODO: **** Improve and expose C-coded random functions (?Use Brucey's Random module?). Remove BRL.Random dependencies. ****

PURPOSE

	A self-contained class of heightmap creation, processing, exporting, and 
	importing utilities.


METHODS AND FUNCTIONS:
	
	create
	clone
	
	generateRandomMap
	generateHillMap
	generateParticleMap			
	generateFaultMap
	generatePerlinMap
	generateMPDMap
		recurseMPD
		MPD
	
	fill
	normalise
	smoothen
	flatten
	makeCoast
	invert
	islandise
	maskHeightRange
	lowerCenter
	
	getMin
	getMax
	
	importPNG
	importImageFile
	importBin
	importPixmap
	exportBin

	blendMapsAdd	
	blendMapsSub	
	blendMapsHi
	blendMapsLo

	blendBrushRaise
	blendBrushLower
	blendBrushHi
	blendBrushLo

	renderToPixmap
	renderRectToPixmap
	renderToColorPixmap
	renderRectToColorPixmap
	renderToTexturePixmap
	
End Rem


SuperStrict

Import "hmap04.4.c"
Import BRL.PNGLoader
Import BRL.JPGLoader
Import BRL.TGALoader
Import BRL.BMPLoader
Import BRL.FileSystem
Import BRL.Random

Extern "C"

	Function createRandomMap(bnk:Byte Ptr, w:Int, h:Int, seed:Int)
	Function createHillMap(bnk:Byte Ptr, w:Int, h:Int, seed:Int, numhills:Int, maxhsize:Int, island:Int)
	Function createParticleMap(bnk:Byte Ptr, w:Int, h:Int, seed:Int, particles:Int, clusters:Int, ..
		mthd:Int, vals:Byte Ptr, valsize:Int)
	Function createFaultMap(bnk:Byte Ptr, w:Int, h:Int, seed:Int, realism:Int)
	Function createPerlinMap(bnk:Byte Ptr, w:Int, h:Int, seed:Int, muliplier:Float)
	Function createMPDMap(bnk:Byte Ptr, w:Int, h:Int, seed:Int, grain:Float)
	
	Function fillMap(bnk:Byte Ptr, w:Int, h:Int, val:Float)
	Function normaliseMap(bnk:Byte Ptr, w:Int, h:Int)
	Function smoothenMap(bnk:Byte Ptr, w:Int, h:Int, k:Float)
	Function flattenMap(bnk:Byte Ptr, w:Int, h:Int, val:Float)
	Function makeCoast(bnk:Byte Ptr, w:Int, h:Int, extent:Float, depth:Float)
	Function invertMap(bnk:Byte Ptr, w:Int, h:Int)
	Function islandiseMap(bnk:Byte Ptr, w:Int, h:Int, amt:Float, fragmentation:Float)
	Function lowerCentreMap(bnk:Byte Ptr, w:Int, h:Int)
	
	Function cBlendMapsAdd(src1:Byte Ptr, src1w:Int, src1h:Int, ..
		src2:Byte Ptr, src2w:Int, src2h:Int, ..
			outp:Byte Ptr, outpw:Int, outph:Int)
			
	Function cBlendMapsSub(src1:Byte Ptr, src1w:Int, src1h:Int, ..
		src2:Byte Ptr, src2w:Int, src2h:Int, ..
			outp:Byte Ptr, outpw:Int, outph:Int)
			
	Function cBlendMapsHi(src1:Byte Ptr, src1w:Int, src1h:Int, ..
		src2:Byte Ptr, src2w:Int, src2h:Int, ..
			outp:Byte Ptr, outpw:Int, outph:Int)

	Function cBlendMapsLo(src1:Byte Ptr, src1w:Int, src1h:Int, ..
		src2:Byte Ptr, src2w:Int, src2h:Int, ..
			outp:Byte Ptr, outpw:Int, outph:Int)

	Function cBlendBrushRaise(bnk:Byte Ptr, w:Int, h:Int, ..
			brush:Byte Ptr, bw:Int, bh:Int, offx:Int, offz:Int, p:Float)
			
	Function cBlendBrushLower(bnk:Byte Ptr, w:Int, h:Int, ..
			brush:Byte Ptr, bw:Int, bh:Int, offx:Int, offz:Int, p:Float)

	Function cBlendBrushHi(bnk:Byte Ptr, w:Int, h:Int, ..
			brush:Byte Ptr, bw:Int, bh:Int, offx:Int, offz:Int, clear:Int)

	Function cBlendBrushLo(bnk:Byte Ptr, w:Int, h:Int, ..
			brush:Byte Ptr, bw:Int, bh:Int, offx:Int, offz:Int, clear:Int)
	
	Function cMaskHeightRange (bnk:Byte Ptr, w:Int, h:Int, ..
		low:Float, high:Float, tomax:Int, low_edge:Float, high_edge:Float)

	Function cGetMin:Float(bnk:Byte Ptr, w:Int, h:Int)
	
	Function cGetMax:Float(bnk:Byte Ptr, w:Int, h:Int)
	
EndExtern


Const STYLE_DISCREET:Int = 0
Const STYLE_BLENDED:Int = 1

Const METHOD_STICKY:Int = 0
Const METHOD_ROLLING:Int = 1


Type THeightMap


	' ********************* CLASS FUNCTIONS ********************


	Function Create:THeightMap(w:Int = 128, h:Int = 128)
	Rem
	Create a new heightmap with dimensions w x h
	Returns a a new THeightMap instance
	EndRem
		
		Local hm:THeightMap = New THeightMap
		
		hm.Width = w
		hm.Height = h
		hm.Map = CreateBank((hm.Width * hm.Height) * 4)		'4 = # of bytes in a float
		hm.fill 0.0
		
		Return hm
	
	EndFunction


	Function blendMapsAdd(src1:THeightMap, src2:THeightMap, outp:THeightMap)
  	Rem 
  	Blends two maps using an additive process.
  	src1: source THeightMap instance #1.
  	src2: source THeightMap instance #2.
  	outp: output THeightMap instance into which the results will be stored.
  	End Rem

		cblendMapsAdd BankBuf(src1.Map), src1.Width, src1.Height, ..
			BankBuf(src2.Map), src2.Width, src2.Height, ..
				BankBuf(outp.Map), outp.Width, outp.Height
	
  	End Function


  	Function blendMapsSub(src1:THeightMap, src2:THeightMap, outp:THeightMap)
  	Rem 
  	Blends two maps using an subtractive process.
  	src1: source THeightMap instance #1.
  	src2: source THeightMap instance #2.
  	outp: output THeightMap instance into which the results will be stored.
  	End Rem

		cblendMapsSub BankBuf(src1.Map), src1.Width, src1.Height, ..
			BankBuf(src2.Map), src2.Width, src2.Height, ..
				BankBuf(outp.Map), outp.Width, outp.Height
	
  	End Function


  	Function blendMapsHi(src1:THeightMap, src2:THeightMap, outp:THeightMap)
  	Rem 
  	Blends two maps, favouring the highest value.
  	src1: source THeightMap instance #1.
  	src2: source THeightMap instance #2.
  	outp: output THeightMap instance into which the results will be stored.
  	End Rem

		cblendMapsHi BankBuf(src1.Map), src1.Width, src1.Height, ..
			BankBuf(src2.Map), src2.Width, src2.Height, ..
				BankBuf(outp.Map), outp.Width, outp.Height
	
  	End Function


  	Function blendMapsLo(src1:THeightMap, src2:THeightMap, outp:THeightMap)
  	Rem 
  	Blends two maps, favouring the lowest value.
  	src1: source THeightMap instance #1.
  	src2: source THeightMap instance #2.
  	outp: output THeightMap instance into which the results will be stored.
  	End Rem

		cblendMapsLo BankBuf(src1.Map), src1.Width, src1.Height, ..
			BankBuf(src2.Map), src2.Width, src2.Height, ..
				BankBuf(outp.Map), outp.Width, outp.Height
	
  	End Function


	' ********************* END OF CLASS FUNCTIONS ********************


  	Field Width:Int, Height:Int
  	Field Map:TBank				  	'Height values (floats) >=0.0 <=1.0 normalised


	Method clone:THeightMap()
	Rem
	Copies / clones the THeightMap instance and returns the result as a new object.
	Returns the clone as a THeightMap instance.
	EndRem
	
		Local cl:THeightMap = THeightMap.Create(Width, Height)

		CopyBank(Map, 0, cl.Map, 0, Width * Height * 4)
			
		Return cl
	
	EndMethod


	Method fill(val:Float = 0.0)
	Rem 
	Fill the heightmap with a specific value.
	val: the value to fill the heightmap with.
	EndRem
	
		fillMap BankBuf(Map), Width, Height, val
	
	EndMethod


	Method getHeight:Float(x:Int, z:Int)
	Rem
	Get a height value at a coordinate.
	x: 0 to Width - 1.
	z: 0 to Height - 1.
	Returns the value at the specified x, z coordinate.
	EndRem
	
		Return PeekFloat(Map, (x * Height + z) * 4)
	
	EndMethod


	Method setHeight(x:Int, z:Int, val:Float)
	Rem
	Set a height value at a coordinate.
	x: 0 to Width - 1.
	z: 0 to Height - 1.
	Returns the value at the specified x, z coordinate.
	EndRem
	
		PokeFloat(Map, (x * Height + z) * 4, val)
	
	EndMethod


	Method getMin:Float()
	Rem
	Get the lowest value in the map.
	Returns the value.
	EndRem
	
		Return cGetMin(BankBuf(Map), Width, Height)
	
	EndMethod
	
	
	Method getMax:Float()
	Rem
	get the heighest value in the map.
	Returns the value.
	EndRem
	
		Return cGetMax(BankBuf(Map), Width, Height)
	
	EndMethod


  	Method generateRandomMap(seed:Int = 0)
  	Rem 
  	Create a map of random height between 0.0 and 1.0.
  	seed: random seed. Use Millisecs() to generate a different result every time.
  	End Rem

		createRandomMap BankBuf(Map), Width, Height, seed
		
  	End Method


	Method generateHillMap(seed:Int = 0, numhills:Int = 1000, maxhsize:Int, island:Int = False)
   	Rem
  	Create a map using the "hill algorithm".
  	seed: random seed. Use Millisecs() to generate a different result every time.
  	numhills: number of hills. (>1000) is best. Minimum 1.
  	maxhsize: maximum hill radius. For best results, value should be significantly 
  	less than the map's shortest dimension.
	island: create an island-like result. True/False
  	End Rem

		createHillMap BankBuf(Map), Width, Height, seed, numhills, maxhsize, island

 	End Method


  	Method generateParticleMap(seed:Int = 0, particles:Int = 500, clusters:Int = 1000, ..
		mthd:Int = METHOD_STICKY, values:Int[] = Null)
  	Rem 
  	seed: random seed. Use Millisecs() to generate a different result every time.
  	particles: number of particles to calculate per cluster. Minimum 1.
  	clusters: number of clusters: higher number gives greater map density. Minimum 1.
	mthd: algorithm method: METHOD_STICKY or METHOD_ROILLING.
	values: algorithm variation.
  	End Rem

		If values = Null Then values = [1, -1, 1, -1]
		
		Local vals:TBank = CreateBank(values.length * 4)
		For Local i:Int = 0 To values.length - 1
			PokeInt vals, i * 4, values[i]
		Next

		createParticleMap BankBuf(Map), Width, Height, seed, particles, clusters, mthd, BankBuf(vals), values.length

		vals = Null

	End Method


	Method generateFaultMap(seed:Int = 0, realism:Int = 500)
 	Rem 
  	Generate a map using the "fault line" algorithm.
  	seed: random seed. Use Millisecs() To generate a different result every time.
  	realism: number of fault lines: higher number (> 500) gives greater realism. Minimum 1.
  	End Rem

		createFaultMap BankBuf(Map), Width, Height, seed, realism

 	End Method


	Method generateMPDMap(seed:Int = 0, grain:Float = 0.5)
	Rem
	PORTED And MODIFIED code from the BlitzCoder.com code database.

  	**** ORIGINAL B3D CODE AUTHOR: Simon Wetterlind 13-08-2002 ****
  	**** v.0.9.3 - Revised: 18-11-2002 by Simon Wetterlind. ****

  	These methods are used To generate a terrain map using the 
  	Midpoint Displacement (ie Diamond Square / Plasma) fractal algorithm.

  	seed: random seed. Use MilliSecs() To generate a different result every time.
  	grain is the "graininess" i.e. the influence of randomness.
	End Rem
		
		createMPDMap BankBuf(Map), Width, Height, seed, grain

	EndMethod


	Method generatePerlinMap(seed:Int = 0, multiplier:Float = 2.0)
	Rem
	Generate a map using the "perlin noise" alogorithm.
  	PORTED And MODIFIED code from the blitzbasic.com code archives.
  	**** ORIGINAL B3D CODE AUTHOR: Shawn C. Swift ****
  	NOTE: This Method will only work on maps with equal Width And 
  	Height dimensions that are a power of two: eg 256 x 256.
  	seed: random seed. Use MilliSecs() To generate a different result every time.
  	multiplier: algorithm variation.
	EndRem	
			
		createPerlinMap BankBuf(Map), Width, Height, seed, multiplier

	EndMethod


  	Method smoothen(k:Float = 0.5)
   	Rem 
  	Smooth the map values.
  	Some maps require more smoothing than others to create realistic terrains.
  	k: smoothing factor. Minumum 0.0 (extreme). Maxumum 1.0 (no smoothing).
  	End Rem

		smoothenMap BankBuf(Map), Width, Height, k

  	End Method


  	Method flatten(val:Float = 2.0)
  	Rem
  	'Flatten' the map values.
  	value: flattening amount. 1 = no flattening. Minimum 1. Suggested Maximum 4.
  	End Rem

		flattenMap BankBuf(Map), Width, Height, val

	EndMethod


  	Method Coastalise(extent:Float = 0.5, depth:Float = 0.5)
  	Rem 
  	Create a crude coastline effect. For best results, smoothing should be applied 
  	after this process.
  	extent: extent of coastalisation. 0.0 to 1.0 = None To 100%.
  	depth: depth. 0.0 To 1.0 = Shallow to deep.
  	End Rem

		makeCoast BankBuf(Map), Width, Height, extent, depth

  	End Method


	Method invert()
	Rem
	Invert the map
	End Rem
	
		invertMap BankBuf(Map), Width, Height
			
	EndMethod

	
	Method islandise(amt:Float = 0.0, fragmentation:Float = 0.5)
	Rem
	Attempt to turn the heightmap into an island by applying an 'island mask'.
	amt: Height retention amount. Minimum 0.0, Maximum 1.0.
		 The higher the retention amount the greater the distortion will be.
	fragmentation: amount of island fragmention.
	EndRem
		
		islandiseMap BankBuf(Map), Width, Height, amt, fragmentation
	
	EndMethod


	Method maskHeightRange(low:Float = 0.25, high:Float = 0.75, ..
		tomax:Int = True, low_edge:Float = 0.0, high_edge:Float = 0.0)
	Rem
	Turn the heightmap into an mask.
	low: Low value of range. Minimum 0.0, Maximum high.
	high: High value of range. Minimum low, Maximum 1.0.
		 The higher the retention amount the greater the distortion will be.
	tomax: Set values within range to 1.0.
	low_edge: amount above low to NOT set to 1.0 if tomax = true.
	high_edge: amount below high to NOT set to 1.0 if tomax = true.
	EndRem
	
		cMaskHeightRange BankBuf(Map), Width, Height, low, high, tomax, low_edge, high_edge
		
	EndMethod


	Method lowerCentre()
	Rem
	Lower the center (basically the opposite of islandise)
	End Rem
	
		lowerCentreMap BankBuf(Map), Width, Height	
			
	EndMethod	


  	Method blendBrushRaise(brush:THeightMap Var, offx:Int = 0, offz:Int = 0, p:Float = 0.1)
  	Rem 
  	Blends a brush (ie a small heightmap) with the heightmap using an additive process.
  	brush: brush THeightMap instance.
  	offx: x coordinate in heightmap to start brush blend 
  	offz: z coordinate in heightmap to start brush blend
  	p: brush pressure: 0.0 to 1.0. (0% to 100%)
  	End Rem

		cBlendBrushRaise BankBuf(Map), Width, Height, ..
			BankBuf(brush.Map), brush.Width, brush.Height, offx, offz, p

  	End Method


  	Method blendBrushLower(brush:THeightMap Var, offx:Int = 0, offz:Int = 0, p:Float = 0.1)
  	Rem 
  	Blends a brush (ie a small heightmap) with the heightmap using an subtractive process.
  	brush: brush THeightMap instance.
  	offx: x coordinate in heightmap to start brush blend 
  	offz: z coordinate in heightmap to start brush blend
  	p: brush pressure: 0.0 to 1.0. (0% to 100%)
  	End Rem

		cBlendBrushLower BankBuf(Map), Width, Height, ..
			BankBuf(brush.Map), brush.Width, brush.Height, offx, offz, p

  	End Method


  	Method blendBrushHi(brush:THeightMap Var, offx:Int = 0, offz:Int = 0, clear:Int = False)
  	Rem 
  	Blends a brush (ie a small heightmap) with the heightmap favouring the highest value.
  	brush: brush THeightMap instance.
  	offx: x coordinate in heightmap To start brush blend 
  	offz: z coordinate in heightmap To start brush blend
  	clear: clear the values in the brush that were not blended: True/False
  	End Rem

		cBlendBrushHi BankBuf(Map), Width, Height, ..
			BankBuf(brush.Map), brush.Width, brush.Height, offx, offz, clear

	End Method


  	Method blendBrushLo(brush:THeightMap Var, offx:Int = 0, offz:Int = 0, clear:Int = False)
  	Rem 
  	Blends a brush (ie a small heightmap) with the heightmap favouring the lowest value.
  	brush: brush THeightMap instance.
  	offx: x coordinate in heightmap To start brush blend 
  	offz: z coordinate in heightmap To start brush blend
  	clear: clear the values in the brush that were not blended: True/False
  	End Rem

		cBlendBrushLo BankBuf(Map), Width, Height, ..
			BankBuf(brush.Map), brush.Width, brush.Height, offx, offz, clear

	End Method


  	Method renderToPixmap(pm:TPixmap, offx:Int = 0, offz:Int = 0)
  	Rem
  	Render the map to a BlitzMax pixmap object (grey scale style).
  	pm: Destination TPixmap object. Must be the same dimensions as the heightmap. 
		The pixmap format should be PF_RGB888.
  	offx: x offset (pixels) into pm. >=0 and <pm width.
  	offz: z offset (pixels) into pm. >=0 and <pm height.
  	End Rem

		If Not pm Then Return
		
		If (pm.format <> PF_RGB888) Then Return
		
		Local pmw:Int = PixmapWidth(pm)
		Local pmh:Int = PixmapHeight(pm)

    		If Not ((offx >= 0) And (offx < pmw)) Then Return
    		If Not ((offz >= 0) And (offz < pmh)) Then Return

    		For Local x:Int = 0 To (Width - 1)
      		For Local z:Int = 0 To (Height - 1)
				If ((offx + x) < pmw) And ((offz + z) < pmh)
          			Local v:Int = Floor(getHeight(x, z) * 255)
          			WritePixel(pm, (offx + x), (offz + z), v Shl 16 | v Shl 8 | v Shl 0)
        			EndIf
      		Next
    		Next

		
  	EndMethod


	Method renderRectToPixmap(pm:TPixmap, offx:Int = 0, offz:Int = 0, ..
		rectx:Int = 0, rectz:Int = 0, rectx2:Int = 0, rectz2:Int = 0)
	Rem
	Render a rectangular heightmap section to a pixmap (greyscale style).
	pm: Destination TPixmap object.	The pixmap format should be PF_RGB888.
  	offx: x offset (pixels) into pm. >=0 and <pm width.
  	offz: z offset (pixels) into pm. >=0 and <pm height.
	rectx: top left x coordinate of heightmap
	rectz: top left z coordinate of heightmap
	rectx2: bottom right x coordinate of heightmap
	rectz2: bottom right z coordinate of heightmap
	EndRem
	
		If Not pm Then Return
		
		If (pm.format <> PF_RGB888) Then Return

		Local pmw:Int = PixmapWidth(pm)
		Local pmh:Int = PixmapHeight(pm)
	
    		If Not ((offx >= 0) And (offx < pmw)) Then Return
	    	If Not ((offz >= 0) And (offz < pmh)) Then Return
	    	If Not ((rectx >= 0) And (rectx < Width)) Then Return
	    	If Not ((rectz >= 0) And (rectz < Height)) Then Return
	    	If Not (rectx2 >= rectx) Then Return
	    	If Not (rectz2 >= rectz) Then Return

   		For Local x:Int = rectx To rectx2
   			For Local z:Int = rectz To rectz2
				If ((offx + x) < pmw) And ((offz + z) < pmh)
       				Local v:Int = Floor(PeekFloat(Map, (x * Height + z) * 4) * 255)
       				WritePixel(pm, (offx + x), (offz + z), v Shl 16 | v Shl 8 | v Shl 0)
       			EndIf
   			Next
   		Next

	EndMethod


	Method renderToColorPixmap(pm:TPixmap, offx:Int = 0, offz:Int = 0, colarr:Int[] = Null, style:Int = STYLE_DISCREET)
	Rem
  	Render the map to a BlitzMax pixmap object (colormap style).
  	pm: Destination TPixmap object. Must be the same dimensions as the heightmap. 
		The pixmap format should be PF_RGB888.
  	offx: x offset (pixels) into pm. >=0 and <pm width.
  	offz: z offset (pixels) into pm. >=0 and <pm height.
	colarr: Array of integers - each integer represents a color in RGB format.
	style: 0 - discrete colors, 1 - blended colors (use constants COLORMAP_DISCREET, COLORMAP_BLENDED).
  	End Rem
		If Not pm Then Return

		Local pmw:Int = PixmapWidth(pm)
		Local pmh:Int = PixmapHeight(pm)

   		If Not ((offx >= 0) And (offx < pmw)) Then Return
   		If Not ((offz >= 0) And (offz < pmh)) Then Return

		If (pm.format <> PF_RGB888) Then Return

		If (colarr.length <= 1) Or (colarr = Null) Then colarr = [$0000FF, $00FF00, $888888]
	
		Local div:Float = 1.0 / Float(colarr.length)
	
		Select style 
		
			Case STYLE_DISCREET
				For Local x:Int = 0 To (Width - 1)
   					For Local z:Int = 0 To (Height - 1)

						If ((offx + x) < pmw) And ((offz + z) < pmh)
				
       						For Local i:Int = 0 To colarr.length - 1
		
								Local lvl:Float = Float(i) * div
		
								If (PeekFloat(Map,(x * height + z) * 4) >= lvl) Then ..
									WritePixel pm, (offx + x), (offz + z), colarr[i]
							Next

						EndIf
		
					Next
				Next

			Case STYLE_BLENDED
	
	   			For Local x:Int = 0 To (Width - 1)
   					For Local z:Int = 0 To (Height - 1)
	
						If ((offx + x) < pmw) And ((offz + z) < pmh)

							If (PeekFloat(Map,(x * height + z) * 4)) > (1.0 - div) 
								WritePixel(pm, (offx + x), (offz + z), colarr[colarr.length - 1])
							Else
								Local val:Float = 0.0
								Local r:Int = 0
								Local g:Int = 0
								Local b:Int = 0
		
								For Local i:Int = 0 To (colarr.length - 1)
																
									Local ir:Byte = colarr[i]
									Local ig:Byte = colarr[i] Shr 8
									Local ib:Byte = colarr[i] Shr 16
						
									Local factor:Float = (div - Abs(val - (PeekFloat(Map,(x * height + z) * 4)))) / div
									If factor < 0.0 Then factor = 0.0 Else If factor > 1.0 Then factor = 1.0
												
									r :+ (factor * ir)
									g :+ (factor * ig) 
									b :+ (factor * ib) 
	
									val :+ div
						
								Next

								WritePixel(pm, (offx + x), (offz + z), b Shl 16 | g Shl 8 | r)
	
							EndIf
	
						EndIf
					
					Next
				Next
		
		EndSelect
		
	EndMethod 


	Method renderToTexturePixmap(pm:TPixmap, offx:Int = 0, offz:Int = 0, arr:Object[] = Null, style:Int = STYLE_DISCREET)
	Rem
  	Render the heightmap to a BlitzMax pixmap object (using textures).
  	pm: Destination TPixmap object. Must be the same dimensions as the heightmap. 
		The pixmap format should be PF_RGB888.
  	offx: x offset (pixels) into pm. >=0 and <pm width.
  	offz: z offset (pixels) into pm. >=0 and <pm height.
	arr: Array of urls (file names) OR pixmaps to use for texturing
			style: 0 - discrete edges, 1 - blended edges (use constants TEXTUREMAP_DISCREET, TEXTUREMAP_BLENDED).
  	End Rem

		If Not pm Then Return

		Local pmw:Int = PixmapWidth(pm)
		Local pmh:Int = PixmapHeight(pm)

   		If Not ((offx >= 0) And (offx < pmw)) Then Return
   		If Not ((offz >= 0) And (offz < pmh)) Then Return

		If (pm.format <> PF_RGB888) Then Return

		If (arr.length <= 1) Or (arr = Null) Then Return
	
		Local textures:TPixmap[arr.length]
		
		For Local i:Int = 0 To (textures.length - 1)
		
			If String(arr[i]) 
				textures[i] = LoadPixmap(String(arr[i]))
			Else
				If TPixmap(arr[i]) Then textures[i] = TPixmap(arr[i])
			EndIf
				
			If Not textures[i]
				textures[i] = CreatePixmap(Width, Height, PF_RGB888)
				Local r:Byte = Rand(64, 255)
				Local g:Byte = Rand(64, 255)
				Local b:Byte = Rand(64, 255)
				For Local x:Int = 0 To PixmapWidth(textures[i]) - 1
					For Local z:Int = 0 To PixmapHeight(textures[i]) - 1
						WritePixel textures[i], x, z, b Shl 16 | g Shl 8 | r
					Next
				Next
			EndIf	
				
			If textures[i].format <> PF_RGB888 Then textures[i] = ConvertPixmap(textures[i], PF_RGB888)
			If (Width <> PixmapWidth(textures[i])) Or (Height <> PixmapHeight(textures[i])) Then textures[i] = ResizePixmap(textures[i], Width, Height)
		Next
	
		Local div:Float = 1.0 / Float(textures.length)
	
		Select style 
		
			Case STYLE_DISCREET
				For Local x:Int = 0 To (Width - 1)
   					For Local z:Int = 0 To (Height - 1)

						If ((offx + x) < pmw) And ((offz + z) < pmh)
				
       						For Local i:Int = 0 To textures.length - 1
		
								Local lvl:Float = Float(i) * div
		
								If PeekFloat(Map, (x * height + z) * 4) >= lvl Then ..
									WritePixel pm, (offx + x), (offz + z), ReadPixel(textures[i], x, z)
							Next

						EndIf
		
					Next
				Next

			Case STYLE_BLENDED
	
	   			For Local x:Int = 0 To (Width - 1)
   					For Local z:Int = 0 To (Height - 1)
	
						If ((offx + x) < pmw) And ((offz + z) < pmh)

							If PeekFloat(Map, (x * height + z) * 4) > (1.0 - div) 
								WritePixel pm, (offx + x), (offz + z), ReadPixel(textures[textures.length - 1], x, z)
							Else
								Local val:Float = 0.0
								Local r:Int = 0
								Local g:Int = 0
								Local b:Int = 0
		
								For Local i:Int = 0 To (textures.length - 1)
														
									Local px:Int = ReadPixel(textures[i], x, z)					
																
									Local ir:Byte = px
									Local ig:Byte = px Shr 8
									Local ib:Byte = px Shr 16
						
									Local factor:Float = (div - Abs(val - PeekFloat(Map, (x * height + z) * 4))) / div
									If factor < 0.0 Then factor = 0.0 Else If factor > 1.0 Then factor = 1.0
												
									r :+ (factor * ir)
									g :+ (factor * ig) 
									b :+ (factor * ib) 
	
									val :+ div
						
								Next

								WritePixel(pm, (offx + x), (offz + z), b Shl 16 | g Shl 8 | r)
	
							EndIf
	
						EndIf
					
					Next
				Next

		EndSelect
				
		For Local i:Int = 0 To (textures.length - 1)
			textures[i] = Null
		Next
		
		GCCollect
				
	EndMethod 


  	Method importPNG:Int(url:String)
  	Rem
	Import from a PNG file.
	url: source file name. Only the blue component data is used.
	Returns True if successful.
  	End Rem

    		Local pm:TPixmap = LoadPixmapPNG(url)

    		If Not pm Return False      
    	
		Return importPixmap(pm)

 	End Method


	Method importPixmap:Int(pm:TPixmap)
  	Rem
	Import from an existing TPixmap.
	pm: source TPixmap. Only the blue component data is used.
	Returns True if successful.
  	End Rem

    		If Not pm Return False      
    	
		If (pm.format <> PF_RGB888) Then pm = ConvertPixmap(pm, PF_RGB888)

		Local pmw:Int = PixmapWidth(pm)
		Local pmh:Int = PixmapHeight(pm)

	    	ResizeBank Map, (pmw * pmh * 4)
   
    		For Local x:Int = 0 To (Width - 1)
      		For Local z:Int = 0 To (Height - 1)
        			Local c:Int = ReadPixel(pm, x, z)
        			c :| c Shr 16
        			PokeFloat Map, (x * Height + z) * 4, $0000 | c
      		Next
		Next

	    	normaliseMap BankBuf(Map), Width, Height

		Return True

 	End Method
	

 	Method exportBin:Int(url:String = "test.bin")
  	Rem 
	Save heightmap data as a binary file. 
	File Structure:
    	1 * Int (Width)
    	1 * Int (Height) 
    	Width * Height * Floats (height values) 
	url: target file name.
	Returns True if successful.
  	End Rem

    		Local result:Int = CreateFile(url)

    		If Not result Then Return False

    		Local file:TStream = OpenFile(url, False, True)

    		WriteInt(file, Width)
    		WriteInt(file, Height)

    		For Local x:Int = 0 To (Width - 1)
      		For Local z:Int = 0 To (Height - 1)
        			WriteFloat file, PeekFloat(Map, (x * Height + z) * 4)
      		Next
    		Next
    
    		CloseFile(file)

    		Return True
	
  	End Method


  	Method importBin:Int(url:String = "test.bin")
  	Rem
	Load heightmap data from a binary file that was previously saved using exportBin. 
	url: source file name.
	Returns True if successful. 
  	End Rem

	    	Local file:TStream = OpenFile(url, True, False)

    		If Not file Return False

		Width = ReadInt(file)
		Height = ReadInt(file)

   		ResizeBank Map, (Width * Height * 4)

    		For Local x:Int = 0 To (Width - 1)
      		For Local z:Int = 0 To (Height - 1)
        			PokeFloat Map, (x * Height + z) * 4, ReadFloat(file)
      		Next
    		Next

		CloseFile(file)

    		Return True

  	End Method


	Method importImageFile:Int(url:String)
  	Rem
	Import from a jpg, png, tga or bmp file.
	url: source file name. Only the blue component data is used.
	Returns True if successful.
  	End Rem

    		Local pm:TPixmap = LoadPixmap(url)

    		If Not pm Return False      
    	
		Return importPixmap(pm)

 	End Method


	Method getHeightAt:Float(x:Int, z:Int)
	
		Return PeekFloat(Map, (x * Height + z) * 4)	
	
	EndMethod


EndType

test1.bmx

Rem

	Heightmap Toolbox Test #1 - Generation and Processing example.

	(*) - Indicates an essential step in creating and setting up a heightmap.
	(#) - Indicates an essential step in rendering a heightmap to the screen.

End Rem

' ------------- INITIALISATION -------------

SuperStrict

'(*) Import the core Heightmap Toolbox class
Import "hmap04.4.bmx"

'Set the application title
AppTitle = "Heightmap Generation and Processing Example"

'Set the graphics driver to OpenGL
SetGraphicsDriver GLMax2DDriver()

'(#) Set the screen resolution
Graphics 800, 600, 0

'Set the blend mode
SetBlend(SOLIDBLEND)
    
'(*) Create a new blank THeightMap with dimensions width X height.
'For MOST algorithms (all except Perlin) the width and height can be 
'dissimilar values (eg 355, 200) but usually the width and height 
'are the same as each other and a power of two.
Global HMap1:THeightMap = THeightMap.Create(256, 256)

'(#) Declare and create a TPixmap object on which to render a greyscale representation of the heightmap.
'Note that the pixmap's width and height should be the same as the heightmap's width and height.
Global Pm1:TPixmap = CreatePixmap(HMap1.Width, HMap1.Height, PF_RGB888)

'Create a TImage variable to use for rendering (faster than Pixmaps).
Global Img1:TImage

Cls

drawWait()

'(*) Generate a heightmap using the Midpoint Displacement algorithm
'There are several algorithms to choose from, some quicker than others, that produce
'differing results. See the handleKeys() function below for other methods.
HMap1.generateMPDMap(MilliSecs(), 0.5)

drawMenu()

'(#) Render a greyscale representation of the heightmap to the relevent TPixmap object
HMap1.renderToPixmap(Pm1, 0, 0)

'(#) Draw the pixmap onto the backbuffer
DrawPixmap(Pm1, 0, 0)

Flip

' ------------- MAIN LOOP -------------

While Not KeyHit(KEY_ESCAPE)

	handleKeys()
	drawScreen()
	
	Delay 1

Wend

End

' ------------- FUNCTIONS -------------

Function handleKeys()

	If KeyHit(KEY_1)
		drawWait()
		HMap1.generateMPDMap(MilliSecs(), 0.5)
		HMap1.renderToPixmap(Pm1, 0, 0)
		Return
	EndIf
	
	If KeyHit(KEY_2)
		drawWait()
		HMap1.generatePerlinMap(MilliSecs(), 1.7)
		HMap1.renderToPixmap(Pm1, 0, 0)
		Return
	EndIf

	If KeyHit(KEY_3)
		drawWait()
		HMap1.generateHillMap(MilliSecs(), 500, (HMap1.Width * 0.25))
		HMap1.renderToPixmap(Pm1, 0, 0)
		Return
	EndIf

	If KeyHit(KEY_4)
		drawWait()
		HMap1.generateParticleMap(MilliSecs(), 500, 1000, METHOD_STICKY)
		HMap1.renderToPixmap(Pm1, 0, 0)
		Return
	EndIf

	If KeyHit(KEY_5)
		drawWait()
		HMap1.generateParticleMap(MilliSecs(), 500, 1000, METHOD_ROLLING)
		HMap1.renderToPixmap(Pm1, 0, 0)
		Return
	EndIf

	If KeyHit(KEY_6)
		drawWait()
		HMap1.generateFaultMap(MilliSecs(), 500)
		HMap1.renderToPixmap(Pm1, 0, 0)
		Return
	EndIf

	If KeyHit(KEY_7)
		drawWait()
		HMap1.generateRandomMap(MilliSecs())
		HMap1.renderToPixmap(Pm1, 0, 0)
		Return
	EndIf

	If KeyHit(KEY_8)
		drawWait()
		HMap1.fill(0.0)
		HMap1.renderToPixmap(Pm1, 0, 0)
		Return
	EndIf

	If KeyHit(KEY_F1)
		drawWait()
		If SavePixmapPNG(pm1, "test.png") Then ..
			Notify("test.png saved.") Else Notify("test.png could NOT be saved.")
		Return
	EndIf

	If KeyHit(KEY_F2)
		drawWait()
		Local result:Int = HMap1.exportBIN("test.bin")
		If result Notify("test.bin saved.") Else Notify("test.bin could NOT be saved.")
		Return
	EndIf

	If KeyHit(KEY_F5)
		drawWait()
		Local result:Int = HMap1.importPNG("test.png")
		If Not result Notify("test.png could NOT be imported. Check that the file exists.")
		Pm1 = ResizePixmap(Pm1, HMap1.Width, HMap1.Height)
		HMap1.renderToPixmap(Pm1, 0, 0)
		Return
	EndIf

	If KeyHit(KEY_F6)
		drawWait()
		Local result:Int = HMap1.importBIN("test.bin")
		If Not result Notify("test.bin could NOT be imported. Check that the file exists.")
		Pm1 = ResizePixmap(Pm1, HMap1.Width, HMap1.Height)
		HMap1.renderToPixmap(Pm1, 0, 0)
		Return
	EndIf

	If KeyHit(KEY_S)
		drawWait()
		HMap1.smoothen(0.8)
		HMap1.renderToPixmap(Pm1, 0, 0)
		Return
	EndIf

	If KeyHit(KEY_F)
		drawWait()
		HMap1.flatten(1.5)
		HMap1.renderToPixmap(Pm1, 0, 0)
		Return
	EndIf

	If KeyHit(KEY_L)
		drawWait()
		HMap1.lowerCentre()
		HMap1.renderToPixmap(Pm1, 0, 0)
		Return
	EndIf

	If KeyHit(KEY_C)
		drawWait()
		HMap1.Coastalise(0.25, 0.25)
		HMap1.renderToPixmap(Pm1, 0, 0)
		Return
	EndIf

	If KeyHit(KEY_I)
		drawWait()
		HMap1.islandise 0.0, 0.15
		HMap1.renderToPixmap(Pm1, 0, 0)
		Return
	EndIf


End Function

Function drawWait()

	DrawText "Please wait...", 0, 0
	Flip
	
EndFunction

Function drawScreen()

	Cls
	drawMenu()
	DrawPixmap(Pm1, 0, 0)
	Flip
	
EndFunction

Function drawMenu()

	DrawText "Press a key (ESC quits):", 5, 270
	DrawText "------------------------", 5, 285

	DrawText "(1) Midpoint Displacement", 5, 300
	DrawText "(2) Perlin", 5, 320
	DrawText "(3) Hill", 5, 340
	DrawText "(4) Sticky Particle", 5, 360
	DrawText "(5) Rolling Particle", 5, 380
	DrawText "(6) Faultline", 5, 400
	DrawText "(7) Random", 5, 420
	DrawText "(8) Clear", 5, 440
	
	DrawText "(S) Smoothen", 250, 300
	DrawText "(F) Flatten", 250, 320
	DrawText "(L) Lower Center", 250, 340
	DrawText "(C) Make Coast", 250, 360
	DrawText "(I) Islandise", 250, 380
	
	DrawText "(F1) Export PNG - test.png", 450, 300
	DrawText "(F2) Export BIN - test.bin", 450, 320
	DrawText "(F5) Import PNG - test.png", 450, 380
	DrawText "(F6) Import BIN - test.bin", 450, 400

End Function

test2.bmx

Rem

	Heightmap Toolbox Test #2 - Blending example.

End Rem


' ------------- INITIALISATION -------------

SuperStrict

Import "hmap04.4.bmx"

AppTitle = "Blending Example"

SetGraphicsDriver GLMax2DDriver()

Graphics 800, 600, 0
SetBlend(SOLIDBLEND)

Global HMap1:THeightMap = THeightMap.Create(256, 256)
Global HMap2:THeightMap = THeightMap.Create(256, 256)
Global HMapR:THeightMap = THeightMap.Create(256, 256)

Global Pm1:TPixmap = CreatePixmap(HMap1.Width, HMap1.Height, PF_RGB888)
Global Pm2:TPixmap = CreatePixmap(HMap2.Width, HMap2.Height, PF_RGB888)
Global PmR:TPixmap = CreatePixmap(HMapR.Width, HMapR.Height, PF_RGB888)

drawWait()

HMap1.generateHillMap MilliSecs(), 500, (HMap1.Width * 0.25)
HMap2.generateParticleMap MilliSecs(), 500, 1000, Rand(METHOD_STICKY, METHOD_ROLLING)

HMap1.renderToPixmap Pm1, 0, 0
HMap2.renderToPixmap Pm2, 0, 0

' ------------- MAIN LOOP -------------

While Not KeyHit(KEY_ESCAPE)

	handleKeys()
	drawScreen()
	
	Delay 1

Wend

End

' ------------- FUNCTIONS -------------

Function handleKeys()

	If KeyHit(KEY_1)
		drawWait()
		THeightMap.BlendMapsAdd(HMap1, HMap2, HMapR)
		HMapR.renderToPixmap(PmR, 0, 0)
		Return
	EndIf
	
	If KeyHit(KEY_2)
		drawWait()
		THeightMap.BlendMapsSub(HMap1, HMap2, HMapR)
		HMapR.renderToPixmap(PmR, 0, 0)
		Return
	EndIf

	If KeyHit(KEY_3)
		drawWait()
		THeightMap.BlendMapsHi(HMap1, HMap2, HMapR)
		HMapR.renderToPixmap(PmR, 0, 0)
		Return
	EndIf

	If KeyHit(KEY_4)
		drawWait()
		THeightMap.BlendMapsLo(HMap1, HMap2, HMapR)
		HMapR.renderToPixmap(PmR, 0, 0)
		Return
	EndIf


End Function

Function drawWait()

	DrawText "Please wait...", 0, 0
	Flip
	
EndFunction

Function drawScreen()

	Cls
	drawMenu()
	DrawPixmap(Pm1, 0, 0)
	DrawPixmap(Pm2, Pm1.Width, 0)
	DrawPixmap(PmR, Pm1.Width + Pm2.Width, 0)
	Flip
	
EndFunction

Function drawMenu()

	DrawText "Press a key (ESC quits):", 5, 270
	DrawText "------------------------", 5, 285

	DrawText "(1) Blend Add", 5, 300
	DrawText "(2) Blend Sub", 5, 320
	DrawText "(3) Blend Hi", 5, 340
	DrawText "(4) Blend Lo", 5, 360

End Function

HeightMap ToolBox V0.4.4 Part 2

(Posted 2010-05-13)

test3.bmx

Rem

	Heightmap Toolbox Test #3 - Brush example.
	
	NOTE: 	A 'brush' in HeightMap Toolbox is just a small THeightMap instance.

End Rem

' ------------- INITIALISATION -------------

SuperStrict

Import "hmap04.4.bmx"

AppTitle = "Brush Example"

SetGraphicsDriver GLMax2DDriver()

Graphics 800, 600, 0

Global HMap1:THeightMap = THeightMap.Create(256, 256)
HMap1.generateMPDMap(MilliSecs(), 0.5)

Global Brush:THeightMap = THeightMap.Create(32, 32)
Brush.generateHillMap(MilliSecs(), 100, 15, True)

Global Pm1:TPixmap = CreatePixmap(HMap1.Width, HMap1.Height, PF_RGB888)
HMap1.renderToPixmap(Pm1, 0, 0)

Global PmBrush:TPixmap = CreatePixmap(Brush.Width, Brush.Height, PF_RGB888)
Brush.renderToPixmap(PmBrush, 0, 0)

SetBlend ALPHABLEND
SetAlpha 1.0

HideMouse

' ------------- MAIN LOOP -------------

While Not KeyHit(KEY_ESCAPE)

  	Cls

	DrawText "Left Click - Raise", 5, 300
	DrawText "Right Click - Lower", 5, 320
	DrawText "[Space] - Highest", 5, 340
	DrawText "[Enter] - Lowest", 5, 360
	DrawText "I - Invert", 5, 380

  	Local mx:Int = MouseX()
  	Local my:Int = MouseY()

  	DrawPixmap(Pm1, 0, 0)
  	DrawPixmap(PmBrush, mx, my)

  	If MouseDown(1)
    	If mx >= 0 And mx < HMap1.Width
      		If my >= 0 And my < HMap1.Height
				HMap1.BlendBrushRaise(Brush, mx, my, 0.05)
				HMap1.renderRectToPixmap(Pm1, 0, 0, mx, my, (mx + (Brush.Width - 1)), (my + (Brush.Height - 1)))
      		EndIf
    	EndIf
  	EndIf
  
  	If MouseDown(2)
    	If mx >= 0 And mx < HMap1.Width
      		If my >= 0 And my < HMap1.Height
				HMap1.BlendBrushLower(Brush, mx, my, 0.05)
				HMap1.renderRectToPixmap(Pm1, 0, 0, mx, my, (mx + (Brush.Width - 1)), (my + (Brush.Height - 1)))
      		EndIf
    	EndIf
  	EndIf

	If KeyHit(KEY_SPACE)
	   	If mx >= 0 And mx < HMap1.Width
      		If my >= 0 And my < HMap1.Height
				HMap1.BlendBrushHi(Brush, mx, my)
				HMap1.renderRectToPixmap(Pm1, 0, 0, mx, my, (mx + (Brush.Width - 1)), (my + (Brush.Height - 1)))
			EndIf
		EndIf
	EndIf

	If KeyHit(KEY_ENTER)
	   	If mx >= 0 And mx < HMap1.Width
      		If my >= 0 And my < HMap1.Height
				HMap1.BlendBrushLo(Brush, mx, my)
				HMap1.renderRectToPixmap(Pm1, 0, 0, mx, my, (mx + (Brush.Width - 1)), (my + (Brush.Height - 1)))
			EndIf
		EndIf
	EndIf

	If KeyHit(KEY_I)
		Brush.invert()
		Brush.RenderToPixmap(PmBrush)
	EndIf

  	Flip

	Delay 1

Wend

End

test4.bmx

Rem

	Heightmap Toolbox Test #4 - Shadow Map example.

End Rem

' ------------- INITIALISATION -------------

SuperStrict

Import "hmap04.4.bmx"
Import "TShadowMap.bmx"

AppTitle = "Shadow Map Example"

SetGraphicsDriver GLMax2DDriver()

Graphics 800, 600, 0
    
drawWait()

Global HMap1:THeightMap = THeightMap.Create(256, 256)
HMap1.generateHillMap(MilliSecs(), 500, (HMap1.Width * 0.25))

Global Pm1:TPixmap = CreatePixmap(HMap1.Width, HMap1.Height, PF_RGB888)
generate HMap1, Pm1

Global ShadowMap:TShadowMap = TShadowMap.Create(HMap1, 1.0, 2.0, -1.0)

' ------------- MAIN LOOP -------------

While Not KeyHit(KEY_ESCAPE)

	handleKeys()
	drawScreen()

	Delay(1)

Wend

End

' ------------- FUNCTIONS -------------

Function handleKeys()

	If KeyHit(KEY_1)
		drawWait()
		generate HMap1, Pm1
		ShadowMap.Calculate
		Return
	EndIf

	If KeyHit(KEY_F1)
	
		drawWait()

		If SavePixmapPNG(ShadowMap.Pixmap, "shadows.png") Then ..
			Notify("shadows.png saved.") Else Notify("shadows.png could NOT be saved.")

		If SavePixmapPNG(Pm1, "test.png") Then ..
			Notify("test.png saved.") Else Notify("test.png could NOT be saved.")
	
		Return
		
	EndIf

End Function

Function drawWait()

	DrawText "Please wait...", 0, 0
	Flip
	
EndFunction

Function drawScreen()

	Cls
	drawMenu()
	DrawPixmap(Pm1, 0, 0)
	DrawPixmap(ShadowMap.Pixmap, Pm1.Width, 0)
	Flip
	
EndFunction

Function drawMenu()

	DrawText "Press a key (ESC quits):", 5, 270
	DrawText "------------------------", 5, 285
	DrawText "(1) Generate heightmap and shadow map", 5, 300
	DrawText "(F1) Export PNGs - test.png & shadows.png", 5, 320
	
End Function

Function generate(hm:THeightmap Var, pm:TPixmap Var)

	Local algorithm:Int = Rand(0, 4)
	
	Select algorithm
	
		Case 0
			hm.generateMPDMap(MilliSecs(), Rnd(0.25, 0.75))
	
		Case 1
			hm.generatePerlinMap(MilliSecs(), Rnd(1.0, 2.0))

		Case 2
			hm.generateHillMap(MilliSecs(), Rand(500, 1000), (hm.Width * Rnd(0.1, 0.25)))

		Case 3
			hm.generateParticleMap MilliSecs(), 1000, 1000, ..
				Rand(METHOD_STICKY, METHOD_ROLLING), [Rand(-1, 1), Rand(-1, 1), Rand(-1, 1), Rand(-1, 1)]

		Case 4
			hm.generateFaultMap(MilliSecs(), Rand(500, 1000))
	
	EndSelect

	hm.renderToPixmap(pm, 0, 0)

End Function

test5.bmx

Rem

	Heightmap Toolbox Test #5 - Color Map example.
	
End Rem

' ------------- INITIALISATION -------------

SuperStrict

Import "hmap04.4.bmx"

AppTitle = "Color Map Example"

SetGraphicsDriver GLMax2DDriver()

Graphics 800, 600, 0
SetBlend SOLIDBLEND
    
Global HMap1:THeightMap = THeightMap.Create(256, 256)

Global PmColor:TPixmap = CreatePixmap(HMap1.Width, HMap1.Height, PF_RGB888)
Global PmColor2:TPixmap = CreatePixmap(HMap1.Width, HMap1.Height, PF_RGB888)

Global ColorArray:Int[] = [$0000FF, $80FF00, $00FF00, $888888, $AAAAAA, $FFFFFF]

drawWait()

generate HMap1, PmColor, PmColor2, ColorArray


' ------------- MAIN LOOP -------------

While Not KeyHit(KEY_ESCAPE)

	handleKeys()
	drawScreen()

	Delay 1

Wend

End

' ------------- FUNCTIONS -------------

Function handleKeys()

	If KeyHit(KEY_1)
	
		drawWait()
		generate HMap1, PmColor, PmColor2, ColorArray
		Return
		
	EndIf

	If KeyHit(KEY_F1)
	
		drawWait()

		If SavePixmapPNG(PMColor, "testc.png") Then ..
			Notify("testc.png saved.") Else Notify("testc.png could Not be saved.")

		If SavePixmapPNG(PMColor2, "testc2.png") Then .. 
			Notify("testc2.png saved.") Else Notify("testc2.png could NOT be saved.")
	
		Return
		
	EndIf

End Function

Function drawWait()

	DrawText "Please wait...", 0, 0
	Flip
	
EndFunction

Function drawScreen()

	Cls
	drawMenu()
	DrawPixmap PmColor, 0, 0
	DrawPixmap pmColor2, PmColor.width + 5, 0
	Flip
	
EndFunction

Function drawMenu()

	DrawText "Press a key (ESC quits):", 5, 270
	DrawText "------------------------", 5, 285
	DrawText "(1) Generate heightmap and color maps", 5, 300
	DrawText "(F1) Export PNGs - testc.png, testc2.png", 5, 320
	
End Function

Function generate(hm:THeightmap Var, pm:TPixmap Var, pm2:TPixmap Var, carr:Int[])

	Local algorithm:Int = Rand(0, 4)
	
	Select algorithm
	
		Case 0
			hm.generateMPDMap(MilliSecs(), Rnd(0.25, 0.75))
	
		Case 1
			hm.generatePerlinMap(MilliSecs(), Rnd(1.0, 2.0))

		Case 2
			hm.generateHillMap(MilliSecs(), Rand(500, 1000), (hm.Width * Rnd(0.1, 0.25)))

		Case 3
			hm.generateParticleMap MilliSecs(), 1000, 1000, ..
				Rand(METHOD_STICKY, METHOD_ROLLING), [Rand(-1, 1), Rand(-1, 1), Rand(-1, 1), Rand(-1, 1)]

		Case 4
			hm.generateFaultMap(MilliSecs(), Rand(500, 1000))
	
	EndSelect

	HMap1.renderToColorPixmap(pm, 0, 0, carr, STYLE_DISCREET)
	HMap1.renderToColorPixmap(pm2, 0, 0, carr, STYLE_BLENDED)

End Function

test6.bmx

Rem

	Heightmap Toolbox Test #6 - Texture Map example.
	
End Rem

' ------------- INITIALISATION -------------

SuperStrict

Import "hmap04.4.bmx"

AppTitle = "Texture Map Example"

SetGraphicsDriver GLMax2DDriver()

Graphics 800, 600, 0
SetBlend(SOLIDBLEND)
    
Global HMap1:THeightMap = THeightMap.Create(256, 256)

Global PmTexture:TPixmap = CreatePixmap(HMap1.Width, HMap1.Height, PF_RGB888)
Global Pmtexture2:TPixmap = CreatePixmap(HMap1.Width, HMap1.Height, PF_RGB888)

genSampleTextures()

SetColor 255, 255, 255

Global TextureURLs:String[] = ["texture1.png", "texture2.png", "texture3.png", "texture4.png"]

drawWait()

generate HMap1, PmTexture, PmTexture2, TextureURLs


' ------------- MAIN LOOP -------------

While Not KeyHit(KEY_ESCAPE)

	handleKeys()
	drawScreen()

	Delay 1

Wend

End

' ------------- FUNCTIONS -------------

Function handleKeys()

	If KeyHit(KEY_1)
		drawWait()
		generate HMap1, PmTexture, PmTexture2, TextureURLs
		Return
	EndIf

	If KeyHit(KEY_F1)
		drawWait()
		If SavePixmapPNG(PmTexture, "tex.png") Then ..
			Notify("tex.png saved.") Else Notify("tex.png could Not be saved.")
		If SavePixmapPNG(PmTexture2, "tex2.png") Then ..
			Notify("tex2.png saved.") Else Notify("tex2.png could Not be saved.")	
		Return
	EndIf

End Function

Function drawWait()

	DrawText "Please wait...", 0, 0
	Flip
	
EndFunction

Function drawScreen()

	Cls
	drawMenu()
	DrawPixmap PmTexture, 0, 0
	DrawPixmap PmTexture2, PmTexture.width + 5, 0
	Flip
	
EndFunction

Function drawMenu()

	DrawText "Press a key (ESC quits):", 5, 270
	DrawText "------------------------", 5, 285
	DrawText "(1) Generate heightmap and texture maps", 5, 300
	DrawText "(F1) Export PNGs - tex.png, tex2.png", 5, 320
	
End Function


Function genSampleTextures()

	SetBlend SOLIDBLEND
	DrawText "Generating sample textures...", 0, 0
	Flip

	Cls
	For Local x:Int = 0 To HMap1.width - 1
		For Local z:Int = 0 To HMap1.height - 1
			Local v:Byte = Rand(128, 196)
			SetColor 88, 88, v
			Plot x, z
		Next
	Next
	SavePixmapPNG(GrabPixmap(0, 0, HMap1.width, HMap1.height), "texture1.png", 9)

	Cls
	For Local x:Int = 0 To HMap1.width - 1
		For Local z:Int = 0 To HMap1.height - 1
			SetColor 0, Rand(128, 196), 0
			Plot x, z
		Next
	Next
	SavePixmapPNG(GrabPixmap(0, 0, HMap1.width, HMap1.height), "texture2.png", 9)

	Cls
	For Local x:Int = 0 To HMap1.width - 1
		For Local z:Int = 0 To HMap1.height - 1
			SetColor 0, Rand(196, 255), 0
			Plot x, z
		Next
	Next
	SavePixmapPNG(GrabPixmap(0, 0, HMap1.width, HMap1.height), "texture3.png", 9)

	Cls
	For Local x:Int = 0 To HMap1.width - 1
		For Local z:Int = 0 To HMap1.height - 1
			Local v:Byte = Rand(128, 196)
			SetColor v, v, v
			Plot x, z
		Next
	Next
	SavePixmapPNG(GrabPixmap(0, 0, HMap1.width, HMap1.height), "texture4.png", 9)

	Cls

End Function


Function generate(hm:THeightmap Var, pm:TPixmap Var, pm2:TPixmap Var, tarr:String[])

	Local algorithm:Int = Rand(0, 4)
	
	Select algorithm
	
		Case 0
			hm.generateMPDMap(MilliSecs(), Rnd(0.25, 0.75))
	
		Case 1
			hm.generatePerlinMap(MilliSecs(), Rnd(1.0, 2.0))

		Case 2
			hm.generateHillMap(MilliSecs(), Rand(500, 1000), (hm.Width * Rnd(0.1, 0.25)))

		Case 3
			hm.generateParticleMap MilliSecs(), 1000, 1000, ..
				Rand(METHOD_STICKY, METHOD_ROLLING), [Rand(-1, 1), Rand(-1, 1), Rand(-1, 1), Rand(-1, 1)]

		Case 4
			hm.generateFaultMap(MilliSecs(), Rand(500, 1000))
	
	EndSelect

	HMap1.renderToTexturePixmap(pm, 0, 0, tarr, STYLE_DISCREET)
	HMap1.renderToTexturePixmap(pm2, 0, 0, tarr, STYLE_BLENDED)

End Function

test7.bmx

Rem

	Heightmap Toolbox Test #7 - Mask Height Range example.

End Rem

' ------------- INITIALISATION -------------

SuperStrict

Import "hmap04.4.bmx"

AppTitle = "Mask Height Range Example"

SetGraphicsDriver GLMax2DDriver()

Graphics 800, 600, 0

Local HMap1:THeightMap = THeightMap.Create(256, 256)

Local Pm1:TPixmap = CreatePixmap(HMap1.Width, HMap1.Height, PF_RGB888)

Cls

drawWait()

generate HMap1, Pm1

drawMenu()

' ------------- MAIN LOOP -------------

While Not KeyHit(KEY_ESCAPE)

	If MouseHit(MOUSE_LEFT) Then generate HMap1, Pm1

	If KeyHit(KEY_1)
		drawWait()
		HMap1.maskHeightRange 0.75, 1.0
		HMap1.renderToPixmap Pm1, 0, 0
	EndIf
	
	If KeyHit(KEY_2)
		drawWait()
		HMap1.maskHeightRange 0.25, 0.75, True, 0.05, 0.05
		HMap1.renderToPixmap Pm1, 0, 0
	EndIf
	
	If KeyHit(KEY_3)
		drawWait()
		HMap1.maskHeightRange 0.25, 0.75, True, 0.15, 0.15
		HMap1.renderToPixmap Pm1, 0, 0
	EndIf
	
	If KeyHit(KEY_4)
		drawWait()
		HMap1.maskHeightRange 0.25, 0.75, False
		HMap1.renderToPixmap Pm1, 0, 0
	EndIf
	
	If KeyHit(KEY_I)
		drawWait()
		HMap1.invert
		HMap1.renderToPixmap Pm1, 0, 0
	EndIf
	
		
	drawMenu()
	DrawPixmap Pm1, 0, 0
	Flip
	
	Delay 1

Wend

End

' ------------- FUNCTIONS -------------

Function drawWait()

	DrawText "Please wait...", 0, 0
	Flip
	
EndFunction

Function generate(hm:THeightmap Var, pm:TPixmap Var)

	Local algorithm:Int = Rand(0, 4)
	
	Select algorithm
	
		Case 0
			hm.generateMPDMap(MilliSecs(), Rnd(0.25, 0.75))
	
		Case 1
			hm.generatePerlinMap(MilliSecs(), Rnd(1.0, 2.0))

		Case 2
			hm.generateHillMap(MilliSecs(), Rand(500, 1000), (hm.Width * Rnd(0.1, 0.25)))

		Case 3
			hm.generateParticleMap MilliSecs(), 1000, 1000, ..
				Rand(METHOD_STICKY, METHOD_ROLLING), [Rand(-1, 1), Rand(-1, 1), Rand(-1, 1), Rand(-1, 1)]

		Case 4
			hm.generateFaultMap(MilliSecs(), Rand(500, 1000))
	
	EndSelect

	hm.renderToPixmap(pm, 0, 0)

End Function

Function drawMenu()

	DrawText "Press a key (ESC quits):", 5, 270
	DrawText "------------------------", 5, 285

	DrawText "(LEFT CLICK) Generate new heightmap", 5, 300
	DrawText "(1) Mask without edges", 5, 320
	DrawText "(2) Mask with narrow edges", 5, 340
	DrawText "(3) Mask with wide edges", 5, 360
	DrawText "(4) Mask retaining height vales", 5, 380
	
	DrawText "(I) Invert", 5, 400
		
End Function

A While...

(Posted 2009-07-25)

It has been quite some time since I posted my previous work log but I'm still here and viewing the forums every day. During the past six months I've coded many unpublished algorithms, tools and applications. Some are useful toward my casual RPG, others not so much.

I've not found a suitable 3D module, though Max3D has the most potential so far.

Happy New Year!

(Posted 2008-12-31)

I've decided to release the latest HeightMap ToolBox here in my worklog. You'll need a c-compiler...

HeightMap ToolBox V0.4.3

{superseded code removed}

Happy new year 2

(Posted 2008-12-31)

{superseded code removed}

Miscellaneous stuff...

(Posted 2008-10-28)

I�ve been busy the past two months, more-so with real-life matters than Blitz programming, and have done very little related to my primary RPG project. I�ve coded some mask and alpha-map generation algorithms for use in my texturing system and that�s about it. Consequently my �Heightmap Toolbox� is up to Version 0.4.2 (the version in the Code Archives is 0.3.6), but because it�s mostly C-code now it will remain �in-house�.

For something different, I decided to take advantage of my Apple developer membership and download the iPhone SDK. After learning Objective C, which is not so bad once you get used to its conventions, Apple�s associated UI frameworks killed my resolve. I just could not stomach the very heavy modern OO design.

Perhaps it makes things easier for the current generation of programmers, but my old-school brain can�t hack it. Especially when even basic data types (like ints) must be treated as objects. It seems terribly inefficient to me, considering your target hardware is a mobile phone, given that in every situation I�ve encountered, OO compilation adds noticeable performance overhead. (I should mention that the official Objective C language specification apparently supports the use of C-native data types. However, where the iPhone SDK is concerned this seems not to be the case � I may be wrong?)

I do find some object-oriented language features indispensable, like encapsulation and, occasionally, inheritance. I just think you can take it too far, and end up making more work for yourself.

A small diversion had me code a text �terminal� that did not require DirectX or OpenGL. The goal was to create a cross-platform component that could be used in a coloured text �Roguelike� game. I planned to code it in C, interfacing with the WindowsXP built-in Terminal/Console control (and the OSX equivalent), and then provide a BlitzMax wrapper. With the help of the MSDN docs I managed to get quite far with the Windows XP version. It was when I fired up XCode on my Mac, logged onto the ADC and started rummaging around, I came to my senses and gave up. Such adventures remind me that, fundamentally, nothing is actually simple in computer programming.

So I turned my efforts to MaxGui. I could not base my text terminal on the TextArea gadget because that does not allow individual character foreground and background colourization. (And a brief poke around the gadget code told me I couldn�t be arsed figuring out how to modify it to do so). In the end I created something based on the HTMLView gadget that worked pretty well on XP and OSX. There�s a few little rough edges that need ironing out, but I�m bored with that project now.

The other topic I want to write about relates to a thread in the general forum about alternative (to BlitzMax / Blitz3D) languages. I�ve seen quite a few comments in support of things like Unity3D and Shiva. For me, these heavy GUI IDE environments are a real hindrance to development, possibly because my game procedurally generates content at runtime, and these tools apparently provide very limited support for such an approach. I also find myself overwhelmed by the interfaces, unable to find where to put what, and when. I suspect I�m in the minority, but the day simple yet powerful language-based systems like BlitzMax die is the day I quit programming�

And now C++

(Posted 2008-09-05)

In my previous worklog entry I mentioned that I ported a large chunk of my code to C. Well, I decided to go the extra mile and port it to C++. To be honest I'm not impressed. Object orientation apparently adds significant overhead (at least as far as the MinGW compiler is concerned). So I think I'll be sticking to plain old C where optimal performance is concerned.

On the BlitzMax 3D engine/module front, I purchased the Leadwerks Engine for evaluation. It's respectable enough, though with some caveats. For starters it's Windows only, and you need a shader 3 capable graphics card. Secondly, I've not been able to replicate my simple Blitz3D engine/viewer using it, because attempts to stretch a texture to match the terrain size results in the jumbling up of the texture.

Plain old C

(Posted 2008-08-11)

For curiosity�s sake, I spent the past week porting a large chunk of my BlitzMax code-base to C. It has been many years since I last coded in C, but everything proceeded as planned and I managed to gain a few seconds in the generation of a 1024x1024 landscape. Gains in the generation of smaller landscapes proved less impressive, so overall it seems BlitzMax is reasonably optimised.

With regards to my previous worklog, I�ve devised an interesting player/actor stat system. I look forward to implementing it within a full featured engine, as that will be the only way I can truly test its functionality.

The quest for an appropriate BlitzMax 3d module continues. At the moment, FLOW looks like a really good option. Of course, Max3d is also on the cards. Unfortunately niether have been released yet and probably wont be for a while.

Ongoing progress

(Posted 2008-07-03)

Progress continues at a respectable pace, though I�ve deviated slightly along the way.

Object Placement Algorithms

I devised some generic object placement algorithms that produce good, natural-looking results. The system populates a map with several thousand trees, rocks and plants in less than a second. The thing is, it will need to be reworked / customized / or perhaps even redone entirely depending on the 3d solution I choose to go with.

Will I need to limit the number of unique objects in the map so as to utilise single surface �layers�? Will I need to code distribution filters corresponding to object-pooling techniques? Will shadows be shader-based or use older methods? What about object reflections across water bodies?

The answers to these and other questions will depend on what 3D module / solution I choose. And for optimal performance and memory consumption my object placement algorithms must be designed accordingly. So I�ve decided to suspend work on this (and other renderer-dependent systems) for the time being.

Ultra Simple Terrain Generator

USTG is basically an �in-house� tool that allows me to generate a terrain (heightmap, shadowmap, texture) with a single click. I rewrote version 1.0 from scratch, based around the latest MaxGUI SVN code and my latest algorithms. I�ve been toying with the idea of releasing an improved version to the public, Freeware, but I suspect there would be little interest.

Procedural Textures

My terrain texturing system generates its results using pre-made texture files, however, I wondered if I could procedurally generate them instead, thus saving on storage space and bandwidth. I spent some time adapting my fractal algorithms to use colour-sets instead of texture files. The results were okay and probably passable but I decided the file-based method produced better looking results. Another downside to the procedural approach is it added about five seconds to the terrain generation time.

Orthographic Experiments

In my quest for a suitable BlitzMax 3d module I investigated MiniB3d versus Blitz3dSDK. Unfortunately Minib3d lacks a built-in terrain system and I�m not very fond of �pure� mesh terrains because of their high memory requirements and texture seaming issues when chunking, so I decided to experiment with a �retro� 3D orthographic style, set atop a custom flat �grid plane�. (eg Ultima 8, except 3d instead of 2d)

It was an interesting exercise that let me try out different methods of handling large quantities of scenery objects (eg trees, plants, rocks, etc), trying to find the best one. I tried four methods: single-surface layering, real-time creation/deletion, list-based object pooling and array-based object pooling. The conclusion: any of the later three methods perform equally as well as each other, at least where the simple orthographic map I created is concerned. Probably the best approach is a combination of layering and pooling. Again, this will be dependent on the chosen 3D module.

As for MiniB3d versus Blitz3dSDK, they perform similarly on my mid-range PC.

Regarding Blitz3DSDK, I�m not keen on the reliance on integer handles. It�s awkward to program for if you�re used to objects. You can code around it by writing wrapper objects, but there are cons to that.

Stat / Attribute System

Most recently, I�m coding the stat / attribute system for my game �actors� (eg the player, enemies, etc). Currently it�s very generic, suitable for use in a CRPG construction set, capable of run-time modification (eg adding, removing of attributes, skills, traits, etc), but I�m thinking this is superfluous. I�m going to rework it, �hard-code� it, for performance and code-simplicity reasons.

Terrain adventures

(Posted 2008-05-08)

I�ve �completed� a terrain generation system that I�m reasonably happy with. It�s not perfect or ultra-realistic, but the results are interesting and variable.

A 512x512 terrain takes five seconds to generate (on my 2.4Ghz Core2Quad processor) and comprises a height map, shadow map, texture map, mini-map, detail textures and skybox.

The generator is coded in BlitzMax. However, the viewer/game engine is coded in Blitz3D because I�ve yet to find a suitable BlitzMax 3D module. I�m using Blitz3D�s built-in terrain capabilities � quick, resource-efficient, easy. The downside is I�m not able to code a respectable multi-texturing and texture-splatting demonstration.

Here are some screenshots:

Terrain 1:

Terrain 2:

Terrain 3:

Next up is the object-placement system (for trees, vegetation, rocks, encampments, ruins, etc). I�ve already created some prototypes that produce natural-looking results, but I need to re-think and/or optimise my approach since they are unacceptably slow.

A beginning

(Posted 2008-05-08)

For years I�ve been designing and coding components for use in a casual RPG. It�s about time I started documenting my efforts.

The basic plan is to create a system that can generate a 3D game to be �completed� in 30 minutes. The user plays the role of a lone adventurer sent into an expansive outdoor environment seeking fame and fortune by collecting useful plants, rocks, artefacts and other items, and defeating regional enemies. At the end of the game a score is awarded.

The player�s abilities, weapons and tools can be �upgraded�, and part of the challenge is selecting the appropriate ones for the current environment. Combat is tactical, turn-based, with possibly an option for real-time, action-orientated combat for a quicker adventure (10 � 15 minutes).

Each game is populated with different enemies and objects (some interactive), selected from a pool of hundreds. Terrains are generated using fractals, and significantly variable. Also, one or two random environment events can occur. In combination these factors should provide a good variety of games.

The setting will be �alien-world science-fiction�, with additional �packs� released later that provide other settings. It will depend on the availability and affordability of media.