yes, I use that blurrrrrer in my editor in a slightly modified form (the outer dependencies to be removed are: Map_Progressbar, map_loadpanel, map_loadbar):

Code:
// for lightmap - okay - mod
void TerEdit_Lm_Blur(var passes, BMAP* canvas, var treshold, var strength)
{
	sys_marker("b01");
	
	set( map_loadpanel , SHOW);
	wait(3);
	
	var size_x = bmap_width(canvas);
	var size_y = bmap_height(canvas);
	
	VECTOR canvas_size;
	vec_set(canvas_size,vector(size_x, size_y, 0));
	
	var i;
	var px;
	var py;
	
	var 	format;
	var 	pixel;
	var 	pixelalpha;										// not used only dummy value holder	
	COLOR pixelcolor;
	vec_set(pixelcolor,vector(128,128,128));
	
	// own color and 8 neighbours
	VECTOR sample1;
	VECTOR sample2;
	VECTOR sample3;
	VECTOR sample4;
	VECTOR sample5;
	VECTOR sample6;
	VECTOR sample7;
	VECTOR sample8;
	VECTOR sample9; 
	
	VECTOR sampleX;
	vec_set(sampleX,vector(128,128,128));
	
	sys_marker(NULL);
	
	i=0;
	for (i=0;i<passes;i++)
		{
			for (py=0;py<canvas_size.y;py++)
				{					
					format = bmap_lock(canvas,0);  
					
//					draw_text( "PRESS 'B' TO BREAK LIGHTMAP CREATION!" , 150 , 100 , vector(255,255,255) );
//					if (key_b) break;
//					wait(1);
					
					for (px=0;px<canvas_size.x;px++)
						{
							sys_marker("b01");														
//							pixel=pixel_for_bmap(canvas,clamp((canvas_size.x-1)-px,0,canvas_size.x-1),clamp(py,0,canvas_size.x-1));
							pixel=pixel_for_bmap(canvas,px,py);
							pixel_to_vec(sample1,pixelalpha,format,pixel);
							
							if ( abs(128-sample1.x) < treshold)			// (sample1.x+sample1.y+sample1.z)/3 < 128-treshold - both +/- treshold
								{
									
									sys_marker(NULL);
									sys_marker("b02");
									if (px>0)
										{
				//							pixel=pixel_for_bmap(canvas,clamp((canvas_size.x-1)-px-1,0,canvas_size.x-1),clamp(py,0,canvas_size.x-1));
											pixel=pixel_for_bmap(canvas,px-1,py);
											pixel_to_vec(sample2,pixelalpha,format,pixel);
										}
									else
										{
											vec_set(sample2,sampleX);
										}
									
									sys_marker(NULL);
									sys_marker("b03");
									if ((px>0) && (py<canvas_size.y-2))
										{
				//							pixel=pixel_for_bmap(canvas,clamp((canvas_size.x-1)-px-1,0,canvas_size.x-1),clamp(py+1,0,canvas_size.x-1));
											pixel=pixel_for_bmap(canvas,px-1,py+1);
											pixel_to_vec(sample3,pixelalpha,format,pixel);
										}
									else
										{
											vec_set(sample3,sampleX);
										}
									
									sys_marker(NULL);
									sys_marker("b04");
									if (py<canvas_size.y-2)
										{
				//							pixel=pixel_for_bmap(canvas,clamp((canvas_size.x-1)-px,0,canvas_size.x-1),clamp(py+1,0,canvas_size.x-1));
											pixel=pixel_for_bmap(canvas,px,py+1);
											pixel_to_vec(sample4,pixelalpha,format,pixel);
										}
									else
										{
											vec_set(sample4,sampleX);
										}
									
									sys_marker(NULL);
									sys_marker("b05");
									if ((px<canvas_size.x-2) && (py<canvas_size.y-2))
										{
				//							pixel=pixel_for_bmap(canvas,clamp((canvas_size.x-1)-px+1,0,canvas_size.x-1),clamp(py+1,0,canvas_size.x-1));
											pixel=pixel_for_bmap(canvas,px+1,py+1);
											pixel_to_vec(sample5,pixelalpha,format,pixel);
										}
									else
										{
											vec_set(sample5,sampleX);
										}
									
									sys_marker(NULL);
									sys_marker("b06");
									if (px<canvas_size.x-2)
										{
				//							pixel=pixel_for_bmap(canvas,clamp((canvas_size.x-1)-px+1,0,canvas_size.x-1),clamp(py,0,canvas_size.x-1));
											pixel=pixel_for_bmap(canvas,px+1,py);
											pixel_to_vec(sample6,pixelalpha,format,pixel);
										}
									else
										{
											vec_set(sample6,sampleX);
										}
									
									sys_marker(NULL);
									sys_marker("b07");
									if ((px<canvas_size.x-2) && (py>0))
										{
				//							pixel=pixel_for_bmap(canvas,clamp((canvas_size.x-1)-px+1,0,canvas_size.x-1),clamp(py-1,0,canvas_size.x-1));
											pixel=pixel_for_bmap(canvas,px+1,py-1);
											pixel_to_vec(sample7,pixelalpha,format,pixel);
										}
									else
										{
											vec_set(sample7,sampleX);
										}
									
									sys_marker(NULL);
									sys_marker("b08");
									if (py>0)
										{
				//							pixel=pixel_for_bmap(canvas,clamp((canvas_size.x-1)-px,0,canvas_size.x-1),clamp(py-1,0,canvas_size.x-1));
											pixel=pixel_for_bmap(canvas,px,py-1);
											pixel_to_vec(sample8,pixelalpha,format,pixel);
										}
									else
										{
											vec_set(sample8,sampleX);
										}
									
									sys_marker(NULL);
									sys_marker("b09");
									if ((px>0) && (py>0))
										{
				//							pixel=pixel_for_bmap(canvas,clamp((canvas_size.x-1)-px-1,0,canvas_size.x-1),clamp(py-1,0,canvas_size.x-1));
											pixel=pixel_for_bmap(canvas,px-1,py-1);
											pixel_to_vec(sample9,pixelalpha,format,pixel);
										}
									else
										{
											vec_set(sample9,sampleX);
										}
										
									sys_marker(NULL);
									sys_marker("b10");
									// weighted average = ( own*7 , W*2 , NW , N*2 , NE , E*2 , SE , S*2 , SW ) / 19
									pixelcolor.red		= integer((sample1.x*strength + sample2.x*2 + sample3.x + sample4.x*2 + sample5.x + sample6.x*2 + sample7.x + sample8.x*2 + sample9.x)/(12+strength));
									pixelcolor.green	= integer((sample1.y*strength + sample2.y*2 + sample3.y + sample4.y*2 + sample5.y + sample6.y*2 + sample7.y + sample8.y*2 + sample9.y)/(12+strength));
									pixelcolor.blue	= integer((sample1.z*strength + sample2.z*2 + sample3.z + sample4.z*2 + sample5.z + sample6.z*2 + sample7.z  +sample8.z*2 + sample9.z)/(12+strength));
									
									sys_marker(NULL);
									sys_marker("b11");
									pixel=pixel_for_vec(pixelcolor,100,format);
		//							pixel_to_bmap(canvas,(canvas_size.x-1)-px,py,pixel);
									pixel_to_bmap(canvas,px,py,pixel);														
									sys_marker(NULL);
									
								}	// treshold check
						}			// for px
					
					bmap_unlock(canvas);
					
					Map_Progressbar(py/canvas_size.y*100);
					wait_for(Map_Progressbar);					
					
					draw_text( "PRESS 'B' TO BREAK BLURRING!" , 150 , 100 , vector(255,255,255) );
					if (key_b) break;
					
					wait(1); // without a wait after each line the loop could get too big if the shadow map is huge
					
				} 					// for py
		}							// for i
	
	reset(map_loadbar,SHOW); 
	reset( map_loadpanel , SHOW);
	wait(1);
}



Free world editor for 3D Gamestudio: MapBuilder Editor