struct wj_terrain_type {
	
//color information
	BYTE texID;			//texture ID
	float r,g,b;			//rgb color

	//factors
	float elevMax,elevMin;		//minimum and maximum elevation
	float slopeMax,slopeMin;	//minimum and maximum slope 
	
	//factor modifiers 
	float release;			//elevation release
	float sloperelease;		//slope release

	float skew;			//elevation skew
	float skewAzimuth;		//elevation skew azimuth
};
 

struct wj_texture_type {
	char texture[32];		//texture name
	int  width, height;		//dimensions
	BYTE *pb;			//data of the BMP
};
 

struct color_factor {
	float factor; 			//weight
	float r,g,b;			//color information
};
 

DWORD wj_texture_gen::TRender(float h,D3DXVECTOR3 &normal, float tu,float tv)
{
	//iterator in the terrain type collection
	iter_terrain it;
	
	//color factor collection and iterator
	std::list<color_factor> cols;
	std::list<color_factor>::iterator ci;

	//total factor used for normalization
	float totalfactor=0.0f;

	//slope of current point (the y value of the normal)
	float slope=normal.y;

	//the skew denominator
	float skewDenom=normal.x*normal.x+normal.z*normal.z;

	//are we to do skewing... 
        //if it is a flat terrain there is no need
	bool doSkew;

	//if skew denominator is "almost" 0 then terrain is flat
	if (skewDenom >0.00001) {
		//turn the skewing on and calculate the denominator
		doSkew=true;
		skewDenom=1.0f/sqrt(skewDenom);
	}
	else doSkew=false;;

	//iterate through terrain type collection
	for(it=g_resource.terrs.begin(); it!=g_resource.terrs.end();++it) {

		//the new color factor
		color_factor cf;

		//factor for this material (for clarity)
		float factor=1.0; 

		//first check - elevation
		float elv_max=it->elevMax;
		float elv_min=it->elevMin;

		//are we to do skewing ?
		if (doSkew) {
			//calculate 2D skew vector
			float skx=cos(it->skewAzimuth*PI/180);
			float sky=sin(it->skewAzimuth*PI/180);

			//skew scale value
			float scale=(normal.x*skx+normal.y*sky)*skewDenom;
			
			//adjust elevation limits
			elv_max+=it->skew*scale;
			elv_min+=it->skew*scale;
		}
		//current elevation release
		float rel=it->release;

		//if outside limit elevation AND release skip this one
		if (elv_max+rel<h) continue;
		if (elv_min-rel>h) continue;
		
		if (elv_max<h) {
				// we are in release compute the factor
				factor=1-(h-elv_max)/rel;
			}
		if (elv_min>h) {
				// we are in release compute the factor
				factor=1-(elv_min-h)/rel;
			}

		//now check the slopes...

		//slope release
		float srel=cos(PI/2-(it->sloperelease*PI/180));

		//calculate min and max slope
		float minslope=cos(it->slopeMin*PI/180);
		float maxslope=cos(it->slopeMax*PI/180);

		//reverse?
		if (minslope>maxslope) {
			float t=maxslope;maxslope=minslope;minslope=t;
		}

		//this slope is not supported for this type
		if (slope<minslope-srel) continue;
		if (slope>maxslope+srel) continue;

		//release?
		if (slope>maxslope) factor*=1-(slope-maxslope)/srel;
		if (slope<minslope) factor*=1-(minslope-slope)/srel;

		//this is our terrain type - get the color info
		if (it->texID==0xff) {
			cf.r=it->r;
			cf.g=it->g;
			cf.b=it->b;
			}
		else 
		  g_resource.GetTexturePixel(it->texID, tu,tv,cf.r,cf.g,cf.b);

		//and the factor
		cf.factor=factor;

		//add to the collection
		cols.push_front(cf);

		//add the factor to the total factor for normalization
		totalfactor+=factor;
	}

	//compute direct light
	float light=-D3DXVec3Dot(&dlight,&normal);
	if (light<0) light=0;

	//add static (ambient) light 
	light+=slight;

	//rgb values
	float r,g,b;
	r=g=b=0;

	//normalizing and acumulating factors
	for(ci=cols.begin();ci!=cols.end();ci++) {
		float factor=ci->factor/totalfactor;
		r+=ci->r*factor;
		g+=ci->g*factor;
		b+=ci->b*factor;
	}

	//light applied
	r*=light;
	g*=light;
	b*=light;

	//return the pixel color
	return RGB(b*255,g*255,r*255);
}