void OGF::MakeProgressive	(float metric_limit)
{
	// test
	// there is no-sense to simplify small models
	// for batch size 50,100,200 - we are CPU-limited anyway even on nv30
	// for nv40 and up the better guess will probably be around 500
	if (faces.size()<c_PM_FaceLimit)		return		;

const u32 c_LMAP_size			= 1024;		// pixels
const u32 c_VB_maxSize			= 4096*1024;	// bytes
const u32 c_VB_maxVertices		= 65535;	// count
const u32 c_vCacheSize			= 24;		// entries
const u32 c_SS_LowVertLimit		= 64;		// polys
const u32 c_SS_HighVertLimit		= 2*1024;	// polys
const u32 c_SS_maxsize			= 32;		// meters
const u32 c_PM_FaceLimit		= 128;		// face-limit
const float c_PM_MetricLimit_static	= 0.10f;	// vertex-count-simplification-limit
const float c_PM_MetricLimit_mu		= 0.05f;	// vertex-count-simplification-limit

//. AlexMX added for draft build mode
	if (g_params.m_quality==ebqDraft)		return		;

	progressive_cs.Enter	();

	//////////////////////////////////////////////////////////////////////////
	// NORMAL
	vecOGF_V	_saved_vertices		=	vertices	;
	vecOGF_F	_saved_faces		=	faces		;

	{
		// prepare progressive geom
		VIPM_Init				();
		//clMsg("--- append v start .");
		for (u32 v_idx=0;  v_idx<vertices.size(); v_idx++)	
			VIPM_AppendVertex	(vertices[v_idx].P,	vertices[v_idx].UV[0]					);
		//clMsg("--- append f start .");
		for (u32 f_idx=0;  f_idx<faces.size();    f_idx++)	
			VIPM_AppendFace		(faces[f_idx].v[0],	faces[f_idx].v[1],	faces[f_idx].v[2]	);
		//clMsg("--- append end.");

		// Convert
		VIPM_Result*	VR		= 0;
		try						{
						VR		= VIPM_Convert			(u32(25),1.f,1);
		} catch (...)			{
			progressive_clear	()		;
			clMsg				("* mesh simplification failed: access violation");
		}
		if (0==VR)				{
			progressive_clear	()		;
			clMsg				("* mesh simplification failed");
		}
		while (VR && VR->swr_records.size()>0)	{
			// test metric
			u32		_full	=	vertices.size	()		;
			u32		_remove	=	VR->swr_records.size()	;
			u32		_simple	=	_full - _remove			;
			float	_metric	=	float(_remove)/float(_full);
			if		(_metric<metric_limit)		{
				progressive_clear				()		;
				clMsg	("* mesh simplified from [%4dv] to [%4dv], nf[%4d] ==> em[%0.2f]-discarded",_full,_simple,VR->indices.size()/3,metric_limit);
				break									;
			} else {
				clMsg	("* mesh simplified from [%4dv] to [%4dv], nf[%4d] ==> em[%0.2f]-accepted", _full,_simple,VR->indices.size()/3,metric_limit);
			}

			// OK
			// Permute vertices
			for(u32 i=0; i<vertices.size(); i++)
				vertices[VR->permute_verts[i]]=_saved_vertices[i];

			// Fill indices
			faces.resize			(VR->indices.size()/3);
			for (u32 f_idx=0; f_idx<faces.size(); f_idx++){
				faces[f_idx].v[0]	= VR->indices[f_idx*3+0];
				faces[f_idx].v[1]	= VR->indices[f_idx*3+1];
				faces[f_idx].v[2]	= VR->indices[f_idx*3+2];
			}
			// Fill SWR
			m_SWI.count				= VR->swr_records.size();
			m_SWI.sw				= xr_alloc<FSlideWindow>(m_SWI.count);
			for (u32 swr_idx=0; swr_idx!=m_SWI.count; swr_idx++){
				FSlideWindow& dst	= m_SWI.sw[swr_idx];
				VIPM_SWR& src		= VR->swr_records[swr_idx];
				dst.num_tris		= src.num_tris;
				dst.num_verts		= src.num_verts;
				dst.offset			= src.offset;
			}

			break	;
		}
		// cleanup
		VIPM_Destroy			();
	}

	//////////////////////////////////////////////////////////////////////////
	// FAST-PATH
	if (progressive_test() && x_vertices.size() && x_faces.size())
	{
		// prepare progressive geom
		VIPM_Init				();
		Fvector2				zero; zero.set		(0,0);
		for (u32 v_idx=0;  v_idx<x_vertices.size(); v_idx++)	VIPM_AppendVertex	(x_vertices[v_idx].P,	zero						);
		for (u32 f_idx=0;  f_idx<x_faces.size();    f_idx++)	VIPM_AppendFace		(x_faces[f_idx].v[0],	x_faces[f_idx].v[1],	x_faces[f_idx].v[2]	);

		VIPM_Result*	VR		= 0;
		try						{
			VR		= VIPM_Convert			(u32(25),1.f,1);
		} catch (...)			{
			faces				= _saved_faces		;
			vertices			= _saved_vertices	;
			progressive_clear	()		;
			clMsg				("* X-mesh simplification failed: access violation");
		}
		if (0==VR)				{
			faces				= _saved_faces		;
			vertices			= _saved_vertices	;
			progressive_clear	()		;
			clMsg				("* X-mesh simplification failed");
		} else {
			// Convert
			/*
			VIPM_Result*	VR		= VIPM_Convert		(u32(25),1.f,1);
			VERIFY			(VR->swr_records.size()>0)	;
			*/

			// test metric
			u32		_full	=	vertices.size	()		;
			u32		_remove	=	VR->swr_records.size()	;
			u32		_simple	=	_full - _remove			;
			float	_metric	=	float(_remove)/float(_full);
			clMsg	("X mesh simplified from [%4dv] to [%4dv], nf[%4d]",_full,_simple,VR ? VR->indices.size()/3 : 0);

			// OK
			vec_XV					vertices_saved;

			// Permute vertices
			vertices_saved			= x_vertices;
			for(u32 i=0; i<x_vertices.size(); i++)
				x_vertices[VR->permute_verts[i]]=vertices_saved[i];

			// Fill indices
			x_faces.resize			(VR->indices.size()/3);
			for (u32 f_idx=0; f_idx<x_faces.size(); f_idx++){
				x_faces[f_idx].v[0]	= VR->indices[f_idx*3+0];
				x_faces[f_idx].v[1]	= VR->indices[f_idx*3+1];
				x_faces[f_idx].v[2]	= VR->indices[f_idx*3+2];
			}

			// Fill SWR
			x_SWI.count				= VR->swr_records.size();
			x_SWI.sw				= xr_alloc<FSlideWindow>(x_SWI.count);
			for (u32 swr_idx=0; swr_idx!=x_SWI.count; swr_idx++){
				FSlideWindow& dst	= x_SWI.sw[swr_idx];
				VIPM_SWR& src		= VR->swr_records[swr_idx];
				dst.num_tris		= src.num_tris;
				dst.num_verts		= src.num_verts;
				dst.offset			= src.offset;
			}
		}

		// cleanup
		VIPM_Destroy			();
	}

	progressive_cs.Leave	();
}