diff --git a/source/geom/green.cpp b/source/geom/green.cpp
index 295f38180d7d608e13ff8e0081b9a68ea11016e1..ddf5720563f72f2e6ffc3ca1d7723cb9619045e7 100644
--- a/source/geom/green.cpp
+++ b/source/geom/green.cpp
@@ -6,7 +6,7 @@ See the license in LICENSE
 
 #include "green.h"
 
-Green::Green()
+CGreen::CGreen()
 {
 	//для растиетльности (с хардварным инстансингом)
 	//{
@@ -21,191 +21,197 @@ Green::Green()
 		D3DDECL_END()
 	};
 
-	Green::DXDevice->CreateVertexDeclaration(InstanceGreen, &VertexDeclarationGreen);
+	CGreen::m_pDXDevice->CreateVertexDeclaration(InstanceGreen, &m_pVertexDeclarationGreen);
 
-	Green::DXDevice->CreateVertexBuffer(
-		GREEN_MAX_ELEM_IN_DIP * sizeof(GreenDataVertex),
+	CGreen::m_pDXDevice->CreateVertexBuffer(
+		GREEN_MAX_ELEM_IN_DIP * sizeof(CGreenDataVertex),
 		D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY,
 		0,
 		D3DPOOL_DEFAULT/*D3DPOOL_MANAGED*/,
-		&TransVertBuf,
+		&m_pTransVertBuf,
 		0);
 
-	IRSData* tmparr = new IRSData();
-	ArrComFor.push_back(tmparr);
-	IRSData* tmparr2 = new IRSData();
-	ArrComFor.push_back(tmparr2);
+	CIRSData* tmparr = new CIRSData();
+	m_aArrComFor.push_back(tmparr);
+	CIRSData* tmparr2 = new CIRSData();
+	m_aArrComFor.push_back(tmparr2);
+
+	m_iCurrCountDrawObj = 0;
 }
 
-Green::~Green()
+CGreen::~CGreen()
 {
-	for (long i = 0; i < ArrModels.size(); ++i)
+	for (int i = 0; i < m_aGreens.size(); ++i)
 	{
-		mem_delete(ArrModels[i]);
+		mem_delete(m_aGreens[i]);
 	}
 
-	ArrModels.clear();
+	m_aGreens.clear();
 
-	mem_release(TransVertBuf);
-	mem_release(VertexDeclarationGreen);
+	mem_release(m_pTransVertBuf);
+	mem_release(m_pVertexDeclarationGreen);
 
-	while (ArrComFor.size() > 0)
+	while (m_aArrComFor.size() > 0)
 	{
-		mem_delete(ArrComFor[0]);
-		ArrComFor.erase(0);
+		mem_delete(m_aArrComFor[0]);
+		m_aArrComFor.erase(0);
 	}
 }
 
-Green::Model::Model()
+CGreen::CModel::CModel()
 {
-	ArrLod[0] = ArrLod[1] = ArrLod[2] = 0;
-	AllCountGreen = 0;
-	SplitsIDs = 0;
-	SplitsTree = 0;
-	AllTrans = 0;
-	ArrLod[0] = ArrLod[1] = ArrLod[2] = 0;
-	NavigateMesh = 0;
+	m_aLods[0] = m_aLods[1] = m_aLods[2] = 0;
+	m_uiCountObj = 0;
+	m_idCountSplits = 0;
+	m_pSplitsTree = 0;
+	m_pAllTrans = 0;
+	m_pPhysMesh = 0;
+	m_szName[0] = 0;
+
+	m_vMax = float3(0,0,0);
+	m_vMin = float3(0, 0, 0);
 }
 
-Green::Model::NavMesh::NavMesh()
+CGreen::CModel::CPhysMesh::CPhysMesh()
 {
-	arr_vertex = 0;
-	arr_index = 0;
-	count_vertex = 0;
-	count_index = 0;
-	arr_mtl = 0;
-	pathname = "";
+	m_pArrVertex = 0;
+	m_pArrIndex = 0;
+	m_iCountVertex = 0;
+	m_iCountIndex = 0;
+	m_pArrMtl = 0;
+	m_sPathName = "";
 }
 
-Green::Model::NavMesh::~NavMesh()
+CGreen::CModel::CPhysMesh::~CPhysMesh()
 {
-	mem_delete_a(arr_vertex);
-	count_vertex = 0;
-	mem_delete_a(arr_index);
-	mem_delete_a(arr_mtl);
-	count_index = 0;
+	mem_delete_a(m_pArrVertex);
+	m_iCountVertex = 0;
+	mem_delete_a(m_pArrIndex);
+	mem_delete_a(m_pArrMtl);
+	m_iCountIndex = 0;
 }
 
-Green::Model::~Model()
+CGreen::CModel::~CModel()
 {
-	mem_delete(SplitsTree);
-	mem_delete(AllTrans);
-	mem_delete(NavigateMesh);
+	mem_delete(m_pSplitsTree);
+	mem_delete(m_pAllTrans);
+	mem_delete(m_pPhysMesh);
 
-	mem_del(ArrLod[0]);
-	if (ArrLod[0] != ArrLod[1])
-		mem_del(ArrLod[1]);
+	mem_del(m_aLods[0]);
+	if (m_aLods[0] != m_aLods[1])
+		mem_del(m_aLods[1]);
 
-	if (ArrLod[0] != ArrLod[2] && ArrLod[1] != ArrLod[2])
-		mem_del(ArrLod[2]);
+	if (m_aLods[0] != m_aLods[2] && m_aLods[1] != m_aLods[2])
+		mem_del(m_aLods[2]);
 }
 
-Green::Segment::Segment()
+CGreen::CSegment::CSegment()
 {
 	for (int i = 0; i < GREEN_COUNT_TYPE_SEGMENTATION; ++i)
-		Splits[i] = 0;
+		m_aSplits[i] = 0;
 	
-	Data = 0;
-	CountAllGreen = 0;
-	BoundVolumeSys = 0;
-	BoundVolumeP = 0;
-	Id = -1;
-	BFNonEnd = false;
+	m_pObjData = 0;
+	m_iCountObj = 0;
+	m_pBoundVolumeSys = 0;
+	m_pBoundVolumeP = 0;
+	m_fDistForCamera = 0;
+	m_id = -1;
+	m_idNonEnd = false;
 }
 
-Green::Segment::~Segment()
+CGreen::CSegment::~CSegment()
 {
 	for (int i = 0; i<GREEN_COUNT_TYPE_SEGMENTATION; i++)
-		mem_delete(Splits[i]);
-	mem_delete_a(Data);
+		mem_delete(m_aSplits[i]);
+	mem_delete_a(m_pObjData);
 
-	mem_release_del(BoundVolumeSys);
-	mem_release_del(BoundVolumeP);
+	mem_release_del(m_pBoundVolumeSys);
+	mem_release_del(m_pBoundVolumeP);
 }
 
-Green::Lod::Lod()
+CGreen::CLod::CLod()
 {
-	model = 0;
+	m_pModel = 0;
 }
 
-Green::Lod::~Lod()
+CGreen::CLod::~CLod()
 {
-	idstex.clear();
-	mem_release_del(model);
+	m_aIDsTextures.clear();
+	mem_release_del(m_pModel);
 }
 
-Green::InfoRenderSegments::InfoRenderSegments()
+CGreen::CInfoRenderSegments::CInfoRenderSegments()
 {
-	Arr = 0; Count = 0; CountCom = 0;
+	m_ppSegments = 0; m_iCount = 0; m_iCountCom = 0;
 }
 
-Green::InfoRenderSegments::~InfoRenderSegments()
+CGreen::CInfoRenderSegments::~CInfoRenderSegments()
 {
-	mem_delete_a(Arr);
+	mem_delete_a(m_ppSegments);
 }
 
-Green::IRSData::IRSData()
+CGreen::CIRSData::CIRSData()
 {
 	
 }
 
-Green::IRSData::~IRSData()
+CGreen::CIRSData::~CIRSData()
 {
-	queue.clear();
+	m_aQueue.clear();
 
-	for (int i = 0; i < arr.size(); ++i)
+	for (int i = 0; i < m_aIRS.size(); ++i)
 	{
-		mem_delete(arr[i]);
+		mem_delete(m_aIRS[i]);
 	}
-	arr.clear();
+	m_aIRS.clear();
 }
 
 
-void Green::OnLostDevice()
+void CGreen::onLostDevice()
 {
-	mem_release_del(TransVertBuf);
+	mem_release_del(m_pTransVertBuf);
 }
 
-void Green::OnResetDevice()
+void CGreen::onResetDevice()
 {
-	Green::DXDevice->CreateVertexBuffer(
-		GREEN_MAX_ELEM_IN_DIP * sizeof(GreenDataVertex),
+	CGreen::m_pDXDevice->CreateVertexBuffer(
+		GREEN_MAX_ELEM_IN_DIP * sizeof(CGreenDataVertex),
 		D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY,
 		0,
 		D3DPOOL_DEFAULT/*D3DPOOL_MANAGED*/,
-		&TransVertBuf,
+		&m_pTransVertBuf,
 		0);
 }
 
-void Green::PreSegmentation(Model* model, float3* min_level, float3* max_level)
+void CGreen::preSegmentation(CModel* model, float3* min_level, float3* max_level)
 {
-	model->SplitsTree = new Segment();
+	model->m_pSplitsTree = new CSegment();
 
 	float3 tmpMin, tmpMax;
 	float3 tmpMin2, tmpMax2;
-	model->SplitsTree->BoundVolumeSys = SGCore_CrBound();
-	SGCore_FCompBoundBox(model->ArrLod[0]->model->m_pVertexBuffer, &(model->SplitsTree->BoundVolumeSys), model->ArrLod[0]->model->m_uiAllVertexCount, sizeof(vertex_static));
+	model->m_pSplitsTree->m_pBoundVolumeSys = SGCore_CrBound();
+	SGCore_FCompBoundBox(model->m_aLods[0]->m_pModel->m_pVertexBuffer, &(model->m_pSplitsTree->m_pBoundVolumeSys), model->m_aLods[0]->m_pModel->m_uiAllVertexCount, sizeof(vertex_static));
 
-	model->SplitsTree->BoundVolumeSys->getMinMax(&tmpMin2, &tmpMax2);
-	model->BBMax = tmpMax2 * (1.f + GREEN_GEN_RAND_SCALE);
-	model->BBMin = tmpMin2 * (1.f + GREEN_GEN_RAND_SCALE);
+	model->m_pSplitsTree->m_pBoundVolumeSys->getMinMax(&tmpMin2, &tmpMax2);
+	model->m_vMax = tmpMax2 * (1.f + GREEN_GEN_RAND_SCALE);
+	model->m_vMin = tmpMin2 * (1.f + GREEN_GEN_RAND_SCALE);
 	tmpMin = *min_level;
 	tmpMax = *max_level;
 
-	tmpMax.x += model->BBMax.x;
-	tmpMax.y += model->BBMax.y;
-	tmpMax.z += model->BBMax.z;
+	tmpMax.x += model->m_vMax.x;
+	tmpMax.y += model->m_vMax.y;
+	tmpMax.z += model->m_vMax.z;
 
-	tmpMin.x += model->BBMin.x;
-	tmpMin.y += model->BBMin.y;
-	tmpMin.z += model->BBMin.z;
+	tmpMin.x += model->m_vMin.x;
+	tmpMin.y += model->m_vMin.y;
+	tmpMin.z += model->m_vMin.z;
 
 	float tmpX = tmpMax.x - tmpMin.x;
 	float tmpY = tmpMax.y - tmpMin.y;
 	float tmpZ = tmpMax.z - tmpMin.z;
 
-	model->SplitsTree->BoundVolumeP = SGCore_CrBound();
-	model->SplitsTree->BoundVolumeP->setMinMax(&tmpMin, &tmpMax);
+	model->m_pSplitsTree->m_pBoundVolumeP = SGCore_CrBound();
+	model->m_pSplitsTree->m_pBoundVolumeP->setMinMax(&tmpMin, &tmpMax);
 
 	//выравниваем по квадрату
 	if (tmpX > tmpZ)
@@ -223,27 +229,27 @@ void Green::PreSegmentation(Model* model, float3* min_level, float3* max_level)
 		tmpMin.x -= tmpX;
 	}
 
-	model->SplitsTree->BoundVolumeSys->setMinMax(&tmpMin, &tmpMax);
+	model->m_pSplitsTree->m_pBoundVolumeSys->setMinMax(&tmpMin, &tmpMax);
 
-	model->SplitsTree->CountAllGreen = model->AllCountGreen;
-	if (model->AllCountGreen > 0)
+	model->m_pSplitsTree->m_iCountObj = model->m_uiCountObj;
+	if (model->m_uiCountObj > 0)
 	{
-		model->SplitsTree->Data = new GreenDataVertex[model->AllCountGreen];
-		memcpy(model->SplitsTree->Data, model->AllTrans, sizeof(GreenDataVertex)* model->AllCountGreen);
+		model->m_pSplitsTree->m_pObjData = new CGreenDataVertex[model->m_uiCountObj];
+		memcpy(model->m_pSplitsTree->m_pObjData, model->m_pAllTrans, sizeof(CGreenDataVertex)* model->m_uiCountObj);
 	}
 
-	if (model->SplitsTree->CountAllGreen > 0)
-		model->SplitsTree->BFNonEnd = true;
+	if (model->m_pSplitsTree->m_iCountObj > 0)
+		model->m_pSplitsTree->m_idNonEnd = true;
 	else
-		model->SplitsTree->BFNonEnd = false;
+		model->m_pSplitsTree->m_idNonEnd = false;
 
-	CycleSegmentation(model->SplitsTree, model);
+	cycleSegmentation(model->m_pSplitsTree, model);
 }
 
-void Green::CycleSegmentation(Segment* Split, Model* mesh)
+void CGreen::cycleSegmentation(CSegment* Split, CModel* mesh)
 {
-	Array<Segment*> queue;
-	long tmpcount = 0;
+	Array<CSegment*> queue;
+	int tmpcount = 0;
 	queue.push_back(Split);
 	float width = 0;
 	float depth = 0;
@@ -251,51 +257,51 @@ void Green::CycleSegmentation(Segment* Split, Model* mesh)
 
 	while (queue.size())
 	{
-		queue[0]->BoundVolumeSys->getMinMax(&min, &max);
+		queue[0]->m_pBoundVolumeSys->getMinMax(&min, &max);
 		if ((max.x - min.x)*0.5f > GREEN_BB_MIN_X && (max.z - min.z)*0.5f > GREEN_BB_MIN_Z)
 		{
-			Segmentation(queue[0], mesh);
+			segmentation(queue[0], mesh);
 			for (int i = 0; i < GREEN_COUNT_TYPE_SEGMENTATION; i++)
 			{
-				if (queue[0]->Splits[i])
-					queue.push_back(queue[0]->Splits[i]);
+				if (queue[0]->m_aSplits[i])
+					queue.push_back(queue[0]->m_aSplits[i]);
 			}
 		}
 		else
-			queue[0]->BFNonEnd = false;
+			queue[0]->m_idNonEnd = false;
 
 		queue.erase(0);
 		++tmpcount;
 	}
 }
 
-void Green::Segmentation(Segment* Split, Model* mesh)
+void CGreen::segmentation(CSegment* Split, CModel* mesh)
 {
 	Array<DWORD> ArrPoly[4];
 
 	for (int i = 0; i<4; i++)
-		Split->Splits[i] = new Segment();
+		Split->m_aSplits[i] = new CSegment();
 
 	ISXBound* ArrBound[4];
 	for (int i = 0; i < 4; ++i)
 		ArrBound[i] = SGCore_CrBound();
 
-	SGCore_0ComBoundBoxArr4(Split->BoundVolumeSys, (ArrBound));
+	SGCore_0ComBoundBoxArr4(Split->m_pBoundVolumeSys, (ArrBound));
 
 	float3 tmpmin, tmpmax;
 	for (int i = 0; i<4; ++i)
 	{
-		Split->Splits[i]->BoundVolumeSys = ArrBound[i];
-		Split->Splits[i]->BoundVolumeSys->getMinMax(&tmpmin, &tmpmax);
-		Split->Splits[i]->BoundVolumeP = SGCore_CrBound();
-		Split->Splits[i]->BoundVolumeP->setMinMax(&tmpmin, &tmpmax);
+		Split->m_aSplits[i]->m_pBoundVolumeSys = ArrBound[i];
+		Split->m_aSplits[i]->m_pBoundVolumeSys->getMinMax(&tmpmin, &tmpmax);
+		Split->m_aSplits[i]->m_pBoundVolumeP = SGCore_CrBound();
+		Split->m_aSplits[i]->m_pBoundVolumeP->setMinMax(&tmpmin, &tmpmax);
 	}
 
 	bool *tmp_arr_mesh_poly = 0;
-	if (Split->CountAllGreen)
+	if (Split->m_iCountObj)
 	{
-		tmp_arr_mesh_poly = new bool[Split->CountAllGreen];
-		for (int i = 0; i < Split->CountAllGreen; i++)
+		tmp_arr_mesh_poly = new bool[Split->m_iCountObj];
+		for (int i = 0; i < Split->m_iCountObj; i++)
 			tmp_arr_mesh_poly[i] = true;
 	}
 
@@ -303,16 +309,16 @@ void Green::Segmentation(Segment* Split, Model* mesh)
 	float3 tmpMin, tmpMax;
 	for (WORD i = 0; i<4; ++i)
 	{
-		Split->Splits[i]->BoundVolumeSys->getMinMax(&tmpMin, &tmpMax);
-		//SGCore_FCreateBoundingBoxMesh(&tmpMin, &tmpMax, &(Split->Splits[i]->BoundBox));
+		Split->m_aSplits[i]->m_pBoundVolumeSys->getMinMax(&tmpMin, &tmpMax);
+		//SGCore_FCreateBoundingBoxMesh(&tmpMin, &tmpMax, &(Split->m_aSplits[i]->BoundBox));
 
-		for (DWORD j = 0; j<Split->CountAllGreen; ++j)
+		for (DWORD j = 0; j<Split->m_iCountObj; ++j)
 		{
 			//если позици¤ провер¤емого полигона находитьс¤ в пределах ограничивающего паралелепипеда
 			if (
-				(long(tmpMax.x * 1000) >= long(Split->Data[j].m_vPosition.x * 1000) && long(tmpMin.x * 1000) <= long(Split->Data[j].m_vPosition.x * 1000))
+				(int(tmpMax.x * 1000) >= int(Split->m_pObjData[j].m_vPosition.x * 1000) && int(tmpMin.x * 1000) <= int(Split->m_pObjData[j].m_vPosition.x * 1000))
 				&&
-				(long(tmpMax.z * 1000) >= long(Split->Data[j].m_vPosition.z * 1000) && long(tmpMin.z * 1000) <= long(Split->Data[j].m_vPosition.z * 1000))
+				(int(tmpMax.z * 1000) >= int(Split->m_pObjData[j].m_vPosition.z * 1000) && int(tmpMin.z * 1000) <= int(Split->m_pObjData[j].m_vPosition.z * 1000))
 				&&
 				tmp_arr_mesh_poly[j]
 				)
@@ -328,137 +334,137 @@ void Green::Segmentation(Segment* Split, Model* mesh)
 
 	for (int i = 0; i<4; i++)
 	{
-		Split->Splits[i]->CountAllGreen = ArrPoly[i].size();
+		Split->m_aSplits[i]->m_iCountObj = ArrPoly[i].size();
 
-		if (Split->Splits[i]->CountAllGreen > 0)
+		if (Split->m_aSplits[i]->m_iCountObj > 0)
 		{
-			Split->Splits[i]->Data = new GreenDataVertex[Split->Splits[i]->CountAllGreen];
+			Split->m_aSplits[i]->m_pObjData = new CGreenDataVertex[Split->m_aSplits[i]->m_iCountObj];
 			for (DWORD k = 0; k < ArrPoly[i].size(); k++)
 			{
-				Split->Splits[i]->Data[k] = Split->Data[ArrPoly[i][k]];
+				Split->m_aSplits[i]->m_pObjData[k] = Split->m_pObjData[ArrPoly[i][k]];
 			}
 
-			AlignBound(mesh, Split->Splits[i]);
+			alignBound(mesh, Split->m_aSplits[i]);
 
 			ArrPoly[i].clear();
 		}
 
-		if (Split->Splits[i]->CountAllGreen > 0)
-			Split->Splits[i]->BFNonEnd = true;
+		if (Split->m_aSplits[i]->m_iCountObj > 0)
+			Split->m_aSplits[i]->m_idNonEnd = true;
 		else
 		{
-			Split->Splits[i]->BFNonEnd = false;
+			Split->m_aSplits[i]->m_idNonEnd = false;
 		}
 	}
 
-	mem_delete_a(Split->Data);
+	mem_delete_a(Split->m_pObjData);
 	mem_delete_a(tmp_arr_mesh_poly);
 }
 
-void Green::AlignBound(Model* model, Segment* split)
+void CGreen::alignBound(CModel* model, CSegment* split)
 {
-	if (split->CountAllGreen > 0)
+	if (split->m_iCountObj > 0)
 	{
-		float3 comMax = split->Data[0].m_vPosition;
-		float3 comMin = split->Data[0].m_vPosition;
+		float3 comMax = split->m_pObjData[0].m_vPosition;
+		float3 comMin = split->m_pObjData[0].m_vPosition;
 
-		for (int k = 0; k<split->CountAllGreen; ++k)
+		for (int k = 0; k<split->m_iCountObj; ++k)
 		{
-			if (split->Data[k].m_vPosition.y > comMax.y)
-				comMax.y = split->Data[k].m_vPosition.y;
+			if (split->m_pObjData[k].m_vPosition.y > comMax.y)
+				comMax.y = split->m_pObjData[k].m_vPosition.y;
 
-			if (split->Data[k].m_vPosition.y < comMin.y)
-				comMin.y = split->Data[k].m_vPosition.y;
+			if (split->m_pObjData[k].m_vPosition.y < comMin.y)
+				comMin.y = split->m_pObjData[k].m_vPosition.y;
 
 
-			if (split->Data[k].m_vPosition.x > comMax.x)
-				comMax.x = split->Data[k].m_vPosition.x;
+			if (split->m_pObjData[k].m_vPosition.x > comMax.x)
+				comMax.x = split->m_pObjData[k].m_vPosition.x;
 
-			if (split->Data[k].m_vPosition.x < comMin.x)
-				comMin.x = split->Data[k].m_vPosition.x;
+			if (split->m_pObjData[k].m_vPosition.x < comMin.x)
+				comMin.x = split->m_pObjData[k].m_vPosition.x;
 
 
-			if (split->Data[k].m_vPosition.z > comMax.z)
-				comMax.z = split->Data[k].m_vPosition.z;
+			if (split->m_pObjData[k].m_vPosition.z > comMax.z)
+				comMax.z = split->m_pObjData[k].m_vPosition.z;
 
-			if (split->Data[k].m_vPosition.z < comMin.z)
-				comMin.z = split->Data[k].m_vPosition.z;
+			if (split->m_pObjData[k].m_vPosition.z < comMin.z)
+				comMin.z = split->m_pObjData[k].m_vPosition.z;
 		}
 
 		float3 tmpMin, tmpMax;
 		float scalecoef = 1.f + GREEN_GEN_RAND_SCALE;
 
-		split->BoundVolumeSys->getMinMax(&tmpMin, &tmpMax);
-		tmpMax.y = comMax.y + model->BBMax.y * scalecoef;
-		tmpMin.y = comMin.y + model->BBMin.y * scalecoef;
+		split->m_pBoundVolumeSys->getMinMax(&tmpMin, &tmpMax);
+		tmpMax.y = comMax.y + model->m_vMax.y * scalecoef;
+		tmpMin.y = comMin.y + model->m_vMin.y * scalecoef;
 
-		split->BoundVolumeSys->setMinMax(&tmpMin, &tmpMax);
+		split->m_pBoundVolumeSys->setMinMax(&tmpMin, &tmpMax);
 
-		tmpMax.x = comMax.x + model->BBMax.x * scalecoef;
-		tmpMax.y = comMax.y + model->BBMax.y * scalecoef;
-		tmpMax.z = comMax.z + model->BBMax.z * scalecoef;
+		tmpMax.x = comMax.x + model->m_vMax.x * scalecoef;
+		tmpMax.y = comMax.y + model->m_vMax.y * scalecoef;
+		tmpMax.z = comMax.z + model->m_vMax.z * scalecoef;
 
-		tmpMin.x = comMin.x + model->BBMin.x * scalecoef;
-		tmpMin.y = comMin.y + model->BBMin.y * scalecoef;
-		tmpMin.z = comMin.z + model->BBMin.z * scalecoef;
+		tmpMin.x = comMin.x + model->m_vMin.x * scalecoef;
+		tmpMin.y = comMin.y + model->m_vMin.y * scalecoef;
+		tmpMin.z = comMin.z + model->m_vMin.z * scalecoef;
 
-		split->BoundVolumeP->setMinMax(&tmpMin, &tmpMax);
+		split->m_pBoundVolumeP->setMinMax(&tmpMin, &tmpMax);
 	}
 }
 
-void Green::SetSplitID(Model* model)
+void CGreen::setSplitID(CModel* model)
 {
-	Array<Segment*, GREEN_DEFAULT_RESERVE_COM> queue;
-	long tmpcount = 0;
-	queue.push_back(model->SplitsTree);
+	Array<CSegment*, GREEN_DEFAULT_RESERVE_COM> queue;
+	int tmpcount = 0;
+	queue.push_back(model->m_pSplitsTree);
 
 	while (queue.size())
 	{
-		SetSplitID2(model, queue[0], &queue);
+		setSplitID2(model, queue[0], &queue);
 
 		queue.erase(0);
 		++tmpcount;
 	}
 }
 
-void Green::SetSplitID2(Model* model, Segment* Split, Array<Segment*, GREEN_DEFAULT_RESERVE_COM>* queue)
+void CGreen::setSplitID2(CModel* model, CSegment* Split, Array<CSegment*, GREEN_DEFAULT_RESERVE_COM>* queue)
 {
 	if (Split)
 	{
-		Split->Id = model->SplitsIDs;
-		model->SplitsArr[Split->Id] = Split;
-		++(model->SplitsIDs);
+		Split->m_id = model->m_idCountSplits;
+		model->m_aSplitsArr[Split->m_id] = Split;
+		++(model->m_idCountSplits);
 		for (int i = 0; i < 4; i++)
 		{
-			if (Split->Splits[i])
-				queue->push_back(Split->Splits[i]);
+			if (Split->m_aSplits[i])
+				queue->push_back(Split->m_aSplits[i]);
 		}
 	}
 }
 
-void Green::CPUFillingArrIndeces(const ISXFrustum* frustum, float3* viewpos, ID id_arr)
+void CGreen::comArrIndeces(const ISXFrustum* frustum, const float3* viewpos, ID id_arr)
 {
 	GREEN_PRECOND_ARRCOMFOR_ERR_ID(id_arr);
 	
-	DWORD tmpcount = 0;
-	DWORD* tmpcountcom = 0;
-	Segment** tmpsegments = 0;
-	for (int i = 0; i < ArrModels.size(); ++i)
+	int tmpcount = 0;
+	int* tmpcountcom = 0;
+	CSegment** tmpsegments = 0;
+	for (int i = 0; i < m_aGreens.size(); ++i)
 	{
-		tmpcount = ArrComFor[id_arr]->arr[i]->Count;
-		ArrComFor[id_arr]->arr[i]->CountCom = 0;
-		tmpcountcom = &(ArrComFor[id_arr]->arr[i]->CountCom);
-		tmpsegments = ArrComFor[id_arr]->arr[i]->Arr;
+		tmpcount = m_aArrComFor[id_arr]->m_aIRS[i]->m_iCount;
+		m_aArrComFor[id_arr]->m_aIRS[i]->m_iCountCom = 0;
+		tmpcountcom = &(m_aArrComFor[id_arr]->m_aIRS[i]->m_iCountCom);
+		tmpsegments = m_aArrComFor[id_arr]->m_aIRS[i]->m_ppSegments;
 		
-		ArrComFor[id_arr]->queue.clearFast();
-		//long tmpcount = 0;
-		ArrComFor[id_arr]->queue.push_back(ArrModels[i]->SplitsTree);
+		m_aArrComFor[id_arr]->m_aQueue.clearFast();
+		//int tmpcount = 0;
+		m_aArrComFor[id_arr]->m_aQueue.push_back(m_aGreens[i]->m_pSplitsTree);
 
-		while (ArrComFor[id_arr]->queue.size())
+		while (m_aArrComFor[id_arr]->m_aQueue.size())
 		{
-			ComRecArrIndeces(frustum, tmpsegments, tmpcountcom, ArrComFor[id_arr]->queue[0], viewpos, &ArrComFor[id_arr]->queue, tmpcount);
+			comRecArrIndeces(frustum, tmpsegments, tmpcountcom, m_aArrComFor[id_arr]->m_aQueue[0], viewpos, &m_aArrComFor[id_arr]->m_aQueue, tmpcount);
 
-			ArrComFor[id_arr]->queue.erase(0);
+			m_aArrComFor[id_arr]->m_aQueue.erase(0);
 			//++tmpcount;
 		}
 	}
@@ -466,26 +472,26 @@ void Green::CPUFillingArrIndeces(const ISXFrustum* frustum, float3* viewpos, ID
 	int qwert = 0;
 }
 
-void Green::ComRecArrIndeces(const ISXFrustum* frustum, Segment** arrsplits, DWORD *count, Segment* comsegment, float3* viewpos, Array<Segment*, GREEN_DEFAULT_RESERVE_COM>* queue, ID curr_splits_ids_render)
+void CGreen::comRecArrIndeces(const ISXFrustum* frustum, CSegment** arrsplits, int *count, CSegment* comsegment, const float3* viewpos, Array<CSegment*, GREEN_DEFAULT_RESERVE_COM>* queue, ID curr_splits_ids_render)
 {
 	float3 jcenter;
 	float jradius;
 	ID SortId[GREEN_COUNT_TYPE_SEGMENTATION];
-	comsegment->BoundVolumeP->getSphere(&jcenter, &jradius);
+	comsegment->m_pBoundVolumeP->getSphere(&jcenter, &jradius);
 
-	if (comsegment->CountAllGreen > 0 && frustum->sphereInFrustum(&jcenter, jradius))
+	if (comsegment->m_iCountObj > 0 && frustum->sphereInFrustum(&jcenter, jradius))
 	{
-			if (comsegment->BFNonEnd)
+			if (comsegment->m_idNonEnd)
 			{
-				if (Green::UseSortFrontToBackSplits)
+				if (CGreen::m_isUseSortFrontToBackSplits)
 				{
 					for (int q = 0; q<GREEN_COUNT_TYPE_SEGMENTATION; ++q)
 					{
 						SortId[q] = -1;
-						if (comsegment->Splits[q])
+						if (comsegment->m_aSplits[q])
 						{
-							comsegment->Splits[q]->BoundVolumeP->getSphere(&jcenter, &jradius);
-							comsegment->Splits[q]->DistForCamera = SMVector3Length2((jcenter - (*viewpos))) - jradius*jradius;
+							comsegment->m_aSplits[q]->m_pBoundVolumeP->getSphere(&jcenter, &jradius);
+							comsegment->m_aSplits[q]->m_fDistForCamera = SMVector3Length2((jcenter - (*viewpos))) - jradius*jradius;
 						}
 					}
 
@@ -493,16 +499,16 @@ void Green::ComRecArrIndeces(const ISXFrustum* frustum, Segment** arrsplits, DWO
 					int tmpCountGreater = 0;
 					for (int i = 0; i<GREEN_COUNT_TYPE_SEGMENTATION; ++i)
 					{
-						if (comsegment->Splits[i])
+						if (comsegment->m_aSplits[i])
 						{
 							tmpCountGreater = 0;
-							pl1 = comsegment->Splits[i]->DistForCamera;
+							pl1 = comsegment->m_aSplits[i]->m_fDistForCamera;
 
 							for (int k = 0; k<GREEN_COUNT_TYPE_SEGMENTATION; ++k)
 							{
-								if (comsegment->Splits[k])
+								if (comsegment->m_aSplits[k])
 								{
-									pl2 = comsegment->Splits[k]->DistForCamera;
+									pl2 = comsegment->m_aSplits[k]->m_fDistForCamera;
 
 									if (i != k && pl2 >= pl1)
 										++tmpCountGreater;
@@ -525,149 +531,149 @@ void Green::ComRecArrIndeces(const ISXFrustum* frustum, Segment** arrsplits, DWO
 
 					for (int j = 0; j<GREEN_COUNT_TYPE_SEGMENTATION; ++j)
 					{
-						if (SortId[(GREEN_COUNT_TYPE_SEGMENTATION - 1) - j] != -1 && comsegment->Splits[SortId[(GREEN_COUNT_TYPE_SEGMENTATION-1) - j]])
-							queue->push_back(comsegment->Splits[SortId[(GREEN_COUNT_TYPE_SEGMENTATION-1) - j]]);
+						if (SortId[(GREEN_COUNT_TYPE_SEGMENTATION - 1) - j] != -1 && comsegment->m_aSplits[SortId[(GREEN_COUNT_TYPE_SEGMENTATION-1) - j]])
+							queue->push_back(comsegment->m_aSplits[SortId[(GREEN_COUNT_TYPE_SEGMENTATION-1) - j]]);
 					}
 				}
 				else
 				{
 					for (int j = 0; j < GREEN_COUNT_TYPE_SEGMENTATION; ++j)
 					{
-						if (comsegment->Splits[j])
-							queue->push_back(comsegment->Splits[j]);
+						if (comsegment->m_aSplits[j])
+							queue->push_back(comsegment->m_aSplits[j]);
 					}
 				}
 			}
 			else
 			{
-				if ((*count) < curr_splits_ids_render && comsegment->Data)
+				if ((*count) < curr_splits_ids_render && comsegment->m_pObjData)
 				{
 					arrsplits[(*count)] = comsegment;
-					comsegment->DistForCamera = 0;// SMVector3Length((jcenter - (*viewpos))) - jradius;
+					comsegment->m_fDistForCamera = 0;// SMVector3Length((jcenter - (*viewpos))) - jradius;
 					(*count)++;
 				}
 			}
 	}
 }
 
-void Green::GPURender2(DWORD timeDelta, float3* viewpos, ID nm, int lod, ID id_tex)
+void CGreen::render2(DWORD timeDelta, const float3* viewpos, ID nm, int lod, ID id_tex)
 {
 	//если есть что к отрисовке
-	if (RTCountDrawObj)
+	if (m_iCurrCountDrawObj)
 	{
-		Green::DXDevice->SetStreamSourceFreq(0, (D3DSTREAMSOURCE_INDEXEDDATA | RTCountDrawObj));
+		CGreen::m_pDXDevice->SetStreamSourceFreq(0, (D3DSTREAMSOURCE_INDEXEDDATA | m_iCurrCountDrawObj));
 
-		Green::DXDevice->SetStreamSourceFreq(1, (D3DSTREAMSOURCE_INSTANCEDATA | 1));
-		Green::DXDevice->SetStreamSource(1, TransVertBuf, 0, sizeof(GreenDataVertex));
+		CGreen::m_pDXDevice->SetStreamSourceFreq(1, (D3DSTREAMSOURCE_INSTANCEDATA | 1));
+		CGreen::m_pDXDevice->SetStreamSource(1, m_pTransVertBuf, 0, sizeof(CGreenDataVertex));
 
-		Green::DXDevice->SetStreamSource(0, ArrModels[nm]->ArrLod[lod]->model->m_pVertexBuffer, 0, sizeof(vertex_static));
-		Green::DXDevice->SetIndices(ArrModels[nm]->ArrLod[lod]->model->m_pIndexBuffer);
-		Green::DXDevice->SetVertexDeclaration(VertexDeclarationGreen);
+		CGreen::m_pDXDevice->SetStreamSource(0, m_aGreens[nm]->m_aLods[lod]->m_pModel->m_pVertexBuffer, 0, sizeof(vertex_static));
+		CGreen::m_pDXDevice->SetIndices(m_aGreens[nm]->m_aLods[lod]->m_pModel->m_pIndexBuffer);
+		CGreen::m_pDXDevice->SetVertexDeclaration(m_pVertexDeclarationGreen);
 
-		jCountIndex = 0;
-		for (DWORD i = 0; i < ArrModels[nm]->ArrLod[lod]->model->m_uiSubsetCount; i++)
+		int iCountIndex = 0;
+		for (DWORD i = 0; i < m_aGreens[nm]->m_aLods[lod]->m_pModel->m_uiSubsetCount; i++)
 		{
-			SGCore_MtlSet((id_tex > 0 ? id_tex : ArrModels[nm]->ArrLod[lod]->idstex[i]), 0);
+			SGCore_MtlSet((id_tex > 0 ? id_tex : m_aGreens[nm]->m_aLods[lod]->m_aIDsTextures[i]), 0);
 
-			if (ArrModels[nm]->TypeGreen == GREEN_TYPE_GRASS)
-					Green::DXDevice->SetVertexShaderConstantF(59, (float*)&float2_t(Green::BeginEndLessening, Green::DistLods.x), 1);
-				else
-					Green::DXDevice->SetVertexShaderConstantF(59, (float*)&float2_t(0,0), 1);
+			if (m_aGreens[nm]->m_typeGreen == GREEN_TYPE_GRASS)
+				CGreen::m_pDXDevice->SetVertexShaderConstantF(59, (float*)&float2_t(CGreen::m_fDistGrassLessening, CGreen::m_vDistLods.x), 1);
+			else
+				CGreen::m_pDXDevice->SetVertexShaderConstantF(59, (float*)&float2_t(0,0), 1);
 
-			Green::DXDevice->SetVertexShaderConstantF(60, (float*)viewpos, 1);
-			Green::DXDevice->SetVertexShaderConstantF(61, (float*)&(ArrModels[nm]->ArrLod[lod]->model->m_vBSphere), 1);
-			Green::DXDevice->SetVertexShaderConstantF(62, (float*)&(ArrModels[nm]->ArrLod[lod]->model->m_vBBMax), 1);
-			Green::DXDevice->SetVertexShaderConstantF(63, (float*)&(ArrModels[nm]->ArrLod[lod]->model->m_vBBMin), 1);
+			CGreen::m_pDXDevice->SetVertexShaderConstantF(60, (float*)viewpos, 1);
+			CGreen::m_pDXDevice->SetVertexShaderConstantF(61, (float*)&(m_aGreens[nm]->m_aLods[lod]->m_pModel->m_vBSphere), 1);
+			CGreen::m_pDXDevice->SetVertexShaderConstantF(62, (float*)&(m_aGreens[nm]->m_aLods[lod]->m_pModel->m_vBBMax), 1);
+			CGreen::m_pDXDevice->SetVertexShaderConstantF(63, (float*)&(m_aGreens[nm]->m_aLods[lod]->m_pModel->m_vBBMin), 1);
 
-			SGCore_DIP(D3DPT_TRIANGLELIST, 0, 0, ArrModels[nm]->ArrLod[lod]->model->m_pVertexCount[i], jCountIndex, ArrModels[nm]->ArrLod[lod]->model->m_pIndexCount[i] / 3);
-			Core_RIntSet(G_RI_INT_COUNT_POLY, Core_RIntGet(G_RI_INT_COUNT_POLY) + ((ArrModels[nm]->ArrLod[lod]->model->m_pIndexCount[i] / 3) * RTCountDrawObj));
-			jCountIndex += ArrModels[nm]->ArrLod[lod]->model->m_pIndexCount[i];
+			SGCore_DIP(D3DPT_TRIANGLELIST, 0, 0, m_aGreens[nm]->m_aLods[lod]->m_pModel->m_pVertexCount[i], iCountIndex, m_aGreens[nm]->m_aLods[lod]->m_pModel->m_pIndexCount[i] / 3);
+			Core_RIntSet(G_RI_INT_COUNT_POLY, Core_RIntGet(G_RI_INT_COUNT_POLY) + ((m_aGreens[nm]->m_aLods[lod]->m_pModel->m_pIndexCount[i] / 3) * m_iCurrCountDrawObj));
+			iCountIndex += m_aGreens[nm]->m_aLods[lod]->m_pModel->m_pIndexCount[i];
 		}
 
-		Green::DXDevice->SetStreamSourceFreq(0, 1);
-		Green::DXDevice->SetStreamSourceFreq(1, 1);
+		CGreen::m_pDXDevice->SetStreamSourceFreq(0, 1);
+		CGreen::m_pDXDevice->SetStreamSourceFreq(1, 1);
 	}
 }
 
-void Green::GPURender(DWORD timeDelta, float3* viewpos, GREEN_TYPE type, ID id_arr)
+void CGreen::render(DWORD timeDelta, const float3* viewpos, GREEN_TYPE type, ID id_arr)
 {
 	GREEN_PRECOND_ARRCOMFOR_ERR_ID(id_arr);
 
 	float3 jcenter;
 	float jradius;
 
-	for (int nm = 0; nm < ArrModels.size(); ++nm)
+	for (int nm = 0; nm < m_aGreens.size(); ++nm)
 	{
 		//если тип не указан
-		if (type != GREEN_TYPE_ALL && type != ArrModels[nm]->TypeGreen)
+		if (type != GREEN_TYPE_ALL && type != m_aGreens[nm]->m_typeGreen)
 			continue;
 
-		jarrsplits = ArrComFor[id_arr]->arr[nm]->Arr;
-		jcount = ArrComFor[id_arr]->arr[nm]->CountCom;
+		CSegment **ppArrSplits = m_aArrComFor[id_arr]->m_aIRS[nm]->m_ppSegments;
+		int iCount = m_aArrComFor[id_arr]->m_aIRS[nm]->m_iCountCom;
 
 		for (int lod = 0; lod < GREEN_COUNT_LOD; ++lod)
 		{
-			if (ArrModels[nm]->ArrLod[lod])
+			if (m_aGreens[nm]->m_aLods[lod])
 			{
-				RTGPUArrVerteces = 0;
-				TransVertBuf->Lock(0, 0, (void**)&RTGPUArrVerteces, D3DLOCK_DISCARD);
-				RTCountDrawObj = 0;
+				CGreenDataVertex* RTGPUArrVerteces = 0;
+				m_pTransVertBuf->Lock(0, 0, (void**)&RTGPUArrVerteces, D3DLOCK_DISCARD);
+				m_iCurrCountDrawObj = 0;
 
-				for (DWORD i = 0; i < jcount; i++)
+				for (DWORD i = 0; i < iCount; i++)
 				{
-					if (RTCountDrawObj + jarrsplits[i]->CountAllGreen >= GREEN_MAX_ELEM_IN_DIP)
+					if (m_iCurrCountDrawObj + ppArrSplits[i]->m_iCountObj >= GREEN_MAX_ELEM_IN_DIP)
 					{
-						TransVertBuf->Unlock();
-						GPURender2(timeDelta, viewpos, nm, lod, -1);
-						TransVertBuf->Lock(0, 0, (void**)&RTGPUArrVerteces, D3DLOCK_DISCARD);
-						RTCountDrawObj = 0;
+						m_pTransVertBuf->Unlock();
+						render2(timeDelta, viewpos, nm, lod, -1);
+						m_pTransVertBuf->Lock(0, 0, (void**)&RTGPUArrVerteces, D3DLOCK_DISCARD);
+						m_iCurrCountDrawObj = 0;
 					}
 
-					jarrsplits[i]->BoundVolumeP->getSphere(&jcenter, &jradius);
-					jarrsplits[i]->DistForCamera = SMVector3Length((jcenter - (*viewpos))) - jradius;
+					ppArrSplits[i]->m_pBoundVolumeP->getSphere(&jcenter, &jradius);
+					ppArrSplits[i]->m_fDistForCamera = SMVector3Length((jcenter - (*viewpos))) - jradius;
 
 					if (
 						//распределение по дистанции есесно и по лодам
 						(
-						(lod == 0 && jarrsplits[i]->DistForCamera <= Green::DistLods.x) ||
-						(lod == 1 && jarrsplits[i]->DistForCamera <= Green::DistLods.y && jarrsplits[i]->DistForCamera > Green::DistLods.x) ||
-						(lod == 2 && jarrsplits[i]->DistForCamera > Green::DistLods.y)
+						(lod == 0 && ppArrSplits[i]->m_fDistForCamera <= CGreen::m_vDistLods.x) ||
+						(lod == 1 && ppArrSplits[i]->m_fDistForCamera <= CGreen::m_vDistLods.y && ppArrSplits[i]->m_fDistForCamera > CGreen::m_vDistLods.x) ||
+						(lod == 2 && ppArrSplits[i]->m_fDistForCamera > CGreen::m_vDistLods.y)
 						)
 						)
 					{
 						//если это не трава
-						if (!(lod == 0 && ArrModels[nm]->TypeGreen == GREEN_TYPE_GRASS))
+						if (!(lod == 0 && m_aGreens[nm]->m_typeGreen == GREEN_TYPE_GRASS))
 						{
-							memcpy(RTGPUArrVerteces + (RTCountDrawObj),
-								jarrsplits[i]->Data,
-								jarrsplits[i]->CountAllGreen * sizeof(GreenDataVertex));
+							memcpy(RTGPUArrVerteces + (m_iCurrCountDrawObj),
+								ppArrSplits[i]->m_pObjData,
+								ppArrSplits[i]->m_iCountObj * sizeof(CGreenDataVertex));
 
-							RTCountDrawObj += jarrsplits[i]->CountAllGreen;
+							m_iCurrCountDrawObj += ppArrSplits[i]->m_iCountObj;
 						}
 						//иначе это трава, а ее по особенному рисуем
-						else if (lod == 0 && ArrModels[nm]->TypeGreen == GREEN_TYPE_GRASS)
+						else if (lod == 0 && m_aGreens[nm]->m_typeGreen == GREEN_TYPE_GRASS)
 						{
-							if (Green::CurrentFreqGrass >= 100)
+							if (CGreen::m_iRenderFreqGrass >= 100)
 							{
-								memcpy(RTGPUArrVerteces + (RTCountDrawObj),
-									jarrsplits[i]->Data,
-									jarrsplits[i]->CountAllGreen * sizeof(GreenDataVertex));
+								memcpy(RTGPUArrVerteces + (m_iCurrCountDrawObj),
+									ppArrSplits[i]->m_pObjData,
+									ppArrSplits[i]->m_iCountObj * sizeof(CGreenDataVertex));
 
-								RTCountDrawObj += jarrsplits[i]->CountAllGreen;
+								m_iCurrCountDrawObj += ppArrSplits[i]->m_iCountObj;
 							}
 							else
 							{
-								float percent = float(Green::CurrentFreqGrass) / 100.f;
-								float newCount = ((float)jarrsplits[i]->CountAllGreen * percent);
-								float step = float(jarrsplits[i]->CountAllGreen) / newCount;
+								float percent = float(CGreen::m_iRenderFreqGrass) / 100.f;
+								float newCount = ((float)ppArrSplits[i]->m_iCountObj * percent);
+								float step = float(ppArrSplits[i]->m_iCountObj) / newCount;
 								UINT lastCP = 0;
-								for (float k = 0; k < jarrsplits[i]->CountAllGreen; k += step)
+								for (float k = 0; k < ppArrSplits[i]->m_iCountObj; k += step)
 								{
 									UINT curCP = (int)floor(k + 0.5);;
 									if (curCP > lastCP)
 									{
-										memcpy(RTGPUArrVerteces + RTCountDrawObj, jarrsplits[i]->Data + curCP, sizeof(GreenDataVertex));
-										RTCountDrawObj += 1;
+										memcpy(RTGPUArrVerteces + m_iCurrCountDrawObj, ppArrSplits[i]->m_pObjData + curCP, sizeof(CGreenDataVertex));
+										m_iCurrCountDrawObj += 1;
 										lastCP = curCP;
 									}
 								}
@@ -676,77 +682,77 @@ void Green::GPURender(DWORD timeDelta, float3* viewpos, GREEN_TYPE type, ID id_a
 					}
 				}
 
-				TransVertBuf->Unlock();
+				m_pTransVertBuf->Unlock();
 
-				GPURender2(timeDelta, viewpos, nm, lod, -1);
+				render2(timeDelta, viewpos, nm, lod, -1);
 			}
 		}
 	}
 }
 
-void Green::GPURenderSingly(DWORD timeDelta, float3* viewpos, ID id, ID id_tex)
+void CGreen::renderSingly(DWORD timeDelta, const  float3* viewpos, ID id, ID id_tex)
 {
-	if (ArrModels.size() <= id)
+	if (m_aGreens.size() <= id)
 		return;
 
 	float3 jcenter;
 	float jradius;
 	ID id_arr = 0;
 
-	jarrsplits = ArrComFor[id_arr]->arr[id]->Arr;
-	jcount = ArrComFor[id_arr]->arr[id]->CountCom;
+	CSegment **ppArrSplits = m_aArrComFor[id_arr]->m_aIRS[id]->m_ppSegments;
+	int iCount = m_aArrComFor[id_arr]->m_aIRS[id]->m_iCountCom;
 
 	for (int lod = 0; lod < GREEN_COUNT_LOD; ++lod)
 	{
-		if (ArrModels[id]->ArrLod[lod])
+		if (m_aGreens[id]->m_aLods[lod])
 		{
-			RTGPUArrVerteces = 0;
-			TransVertBuf->Lock(0, 0, (void**)&RTGPUArrVerteces, D3DLOCK_DISCARD);
-			RTCountDrawObj = 0;
+			CGreenDataVertex* RTGPUArrVerteces = 0;
+			m_pTransVertBuf->Lock(0, 0, (void**)&RTGPUArrVerteces, D3DLOCK_DISCARD);
+			m_iCurrCountDrawObj = 0;
 
-			for (DWORD i = 0; i < jcount; i++)
+			for (int i = 0; i < iCount; i++)
 			{
-				if (RTCountDrawObj + jarrsplits[i]->CountAllGreen >= GREEN_MAX_ELEM_IN_DIP)
+				if (m_iCurrCountDrawObj + ppArrSplits[i]->m_iCountObj >= GREEN_MAX_ELEM_IN_DIP)
 				{
-					TransVertBuf->Unlock();
-					GPURender2(timeDelta, viewpos, id, lod, id_tex);
-					TransVertBuf->Lock(0, 0, (void**)&RTGPUArrVerteces, D3DLOCK_DISCARD);
-					RTCountDrawObj = 0;
+					m_pTransVertBuf->Unlock();
+					render2(timeDelta, viewpos, id, lod, id_tex);
+					m_pTransVertBuf->Lock(0, 0, (void**)&RTGPUArrVerteces, D3DLOCK_DISCARD);
+					m_iCurrCountDrawObj = 0;
 				}
 
-				jarrsplits[i]->BoundVolumeP->getSphere(&jcenter, &jradius);
-				jarrsplits[i]->DistForCamera = SMVector3Length((jcenter - (*viewpos))) - jradius;
+				ppArrSplits[i]->m_pBoundVolumeP->getSphere(&jcenter, &jradius);
+				ppArrSplits[i]->m_fDistForCamera = SMVector3Length((jcenter - (*viewpos))) - jradius;
 
 				if (
 					//распределение по дистанции есесно и по лодам
 					(
-					(lod == 0 && jarrsplits[i]->DistForCamera <= Green::DistLods.x) ||
-					(lod == 1 && jarrsplits[i]->DistForCamera <= Green::DistLods.y && jarrsplits[i]->DistForCamera > Green::DistLods.x) ||
-					(lod == 2 && jarrsplits[i]->DistForCamera > Green::DistLods.y) || !(ArrModels[id]->ArrLod[1])
+					(lod == 0 && ppArrSplits[i]->m_fDistForCamera <= CGreen::m_vDistLods.x) ||
+					(lod == 1 && ppArrSplits[i]->m_fDistForCamera <= CGreen::m_vDistLods.y && ppArrSplits[i]->m_fDistForCamera > CGreen::m_vDistLods.x) ||
+					(lod == 2 && ppArrSplits[i]->m_fDistForCamera > CGreen::m_vDistLods.y) || !(m_aGreens[id]->m_aLods[1])
 					)
 					)
 				{
-					if (!(lod == 0 && ArrModels[id]->TypeGreen == GREEN_TYPE_GRASS))
+					if (!(lod == 0 && m_aGreens[id]->m_typeGreen == GREEN_TYPE_GRASS))
 					{
-						memcpy(RTGPUArrVerteces + (RTCountDrawObj),
-							jarrsplits[i]->Data,
-							jarrsplits[i]->CountAllGreen * sizeof(GreenDataVertex));
+						memcpy(RTGPUArrVerteces + (m_iCurrCountDrawObj),
+							ppArrSplits[i]->m_pObjData,
+							ppArrSplits[i]->m_iCountObj * sizeof(CGreenDataVertex));
 
-						RTCountDrawObj += jarrsplits[i]->CountAllGreen;
+						m_iCurrCountDrawObj += ppArrSplits[i]->m_iCountObj;
 					}
 					else
 					{
 						float percent = 0.1f;
-						float newCount = ((float)jarrsplits[i]->CountAllGreen * percent);
-						float step = float(jarrsplits[i]->CountAllGreen) / newCount;
+						float newCount = ((float)ppArrSplits[i]->m_iCountObj * percent);
+						float step = float(ppArrSplits[i]->m_iCountObj) / newCount;
 						UINT lastCP = 0;
-						for (float k = 0; k < jarrsplits[i]->CountAllGreen; k += step)
+						for (float k = 0; k < ppArrSplits[i]->m_iCountObj; k += step)
 						{
 							UINT curCP = (int)floor(k + 0.5);;
 							if (curCP > lastCP)
 							{
-								memcpy(RTGPUArrVerteces + RTCountDrawObj, jarrsplits[i]->Data + curCP, sizeof(GreenDataVertex));
-								RTCountDrawObj += 1;
+								memcpy(RTGPUArrVerteces + m_iCurrCountDrawObj, ppArrSplits[i]->m_pObjData + curCP, sizeof(CGreenDataVertex));
+								m_iCurrCountDrawObj += 1;
 								lastCP = curCP;
 							}
 						}
@@ -754,74 +760,74 @@ void Green::GPURenderSingly(DWORD timeDelta, float3* viewpos, ID id, ID id_tex)
 				}
 			}
 
-			TransVertBuf->Unlock();
+			m_pTransVertBuf->Unlock();
 
-			GPURender2(timeDelta, viewpos, id, lod, id_tex);
+			render2(timeDelta, viewpos, id, lod, id_tex);
 		}
 	}
 }
 
-void Green::GPURenderObject(DWORD timeDelta, float3* viewpos, ID id, ID split, ID idobj, ID id_tex)
+void CGreen::renderObject(DWORD timeDelta, const float3* viewpos, ID id, ID split, ID idobj, ID id_tex)
 {
-	if (id < 0 || ArrModels.size() <= id || split < 0 || ArrModels[id]->SplitsArr.size() <= split || idobj < 0 || ArrModels[id]->SplitsArr[split]->CountAllGreen <= idobj)
+	if (id < 0 || m_aGreens.size() <= id || split < 0 || m_aGreens[id]->m_aSplitsArr.size() <= split || idobj < 0 || m_aGreens[id]->m_aSplitsArr[split]->m_iCountObj <= idobj)
 		return;
 
-	RTGPUArrVerteces = 0;
-	TransVertBuf->Lock(0, 0, (void**)&RTGPUArrVerteces, D3DLOCK_DISCARD);
-	memcpy(RTGPUArrVerteces, &(ArrModels[id]->SplitsArr[split]->Data[idobj]), sizeof(GreenDataVertex));
-	TransVertBuf->Unlock();
-	RTCountDrawObj = 1;
+	CGreenDataVertex* RTGPUArrVerteces = 0;
+	m_pTransVertBuf->Lock(0, 0, (void**)&RTGPUArrVerteces, D3DLOCK_DISCARD);
+	memcpy(RTGPUArrVerteces, &(m_aGreens[id]->m_aSplitsArr[split]->m_pObjData[idobj]), sizeof(CGreenDataVertex));
+	m_pTransVertBuf->Unlock();
+	m_iCurrCountDrawObj = 1;
 
-	GPURender2(timeDelta, viewpos, id, 0, id_tex);
+	render2(timeDelta, viewpos, id, 0, id_tex);
 }
 
-ID Green::Init(StaticGeom* geom, const char* name,
+ID CGreen::init(CStaticGeom* geom, const char* name,
 	const char* path_mask, 
 	float count_max, 
 	const char* path, const char* lod1, const char* lod2, 
 	const char* navmesh)
 {
-	if (geom->GetCountModel() > 0 && def_str_validate(path))
+	if (geom->getCountModel() > 0 && def_str_validate(path))
 	{
-		Model* tmpnewmpdel = new Model();
-		sprintf(tmpnewmpdel->Name, name);
-		tmpnewmpdel->MaskName = path_mask;
-		tmpnewmpdel->ArrLod[0] = new Lod();
-		tmpnewmpdel->ArrLod[1] = 0;
-		tmpnewmpdel->ArrLod[2] = 0;
+		CModel* tmpnewmpdel = new CModel();
+		sprintf(tmpnewmpdel->m_szName, name);
+		tmpnewmpdel->m_szMaskName = path_mask;
+		tmpnewmpdel->m_aLods[0] = new CLod();
+		tmpnewmpdel->m_aLods[1] = 0;
+		tmpnewmpdel->m_aLods[2] = 0;
 
 		if (!lod1 && !lod2)
-			tmpnewmpdel->TypeGreen = GREEN_TYPE_GRASS;
+			tmpnewmpdel->m_typeGreen = GREEN_TYPE_GRASS;
 		else
-			tmpnewmpdel->TypeGreen = GREEN_TYPE_TREE;
+			tmpnewmpdel->m_typeGreen = GREEN_TYPE_TREE;
 
 		char tmppath[1024];
 		sprintf(tmppath, "%s%s", Core_RStringGet(G_RI_STRING_PATH_GS_MESHES), path);
 
-		SGCore_StaticModelLoad(tmppath, &tmpnewmpdel->ArrLod[0]->model);
-		tmpnewmpdel->ArrLod[0]->path = path;
+		SGCore_StaticModelLoad(tmppath, &tmpnewmpdel->m_aLods[0]->m_pModel);
+		tmpnewmpdel->m_aLods[0]->m_sPath = path;
 		char tmppathtex[1024];
-		for (int i = 0; i < tmpnewmpdel->ArrLod[0]->model->m_uiSubsetCount; ++i)
+		for (int i = 0; i < tmpnewmpdel->m_aLods[0]->m_pModel->m_uiSubsetCount; ++i)
 		{
-			sprintf(tmppathtex, "%s.dds", tmpnewmpdel->ArrLod[0]->model->m_ppTextures[i]);
-			tmpnewmpdel->ArrLod[0]->idstex[i] = SGCore_MtlLoad(tmppathtex, (tmpnewmpdel->TypeGreen == GREEN_TYPE_TREE ? MTL_TYPE_TREE : MTL_TYPE_GRASS));
+			sprintf(tmppathtex, "%s.dds", tmpnewmpdel->m_aLods[0]->m_pModel->m_ppTextures[i]);
+			tmpnewmpdel->m_aLods[0]->m_aIDsTextures[i] = SGCore_MtlLoad(tmppathtex, (tmpnewmpdel->m_typeGreen == GREEN_TYPE_TREE ? MTL_TYPE_TREE : MTL_TYPE_GRASS));
 		}
 
 		if (def_str_validate(lod1))
 		{
 			if (stricmp(path, lod1) == 0)
-				tmpnewmpdel->ArrLod[1] = tmpnewmpdel->ArrLod[0];
+				tmpnewmpdel->m_aLods[1] = tmpnewmpdel->m_aLods[0];
 			else
 			{
-				tmpnewmpdel->ArrLod[1] = new Lod();
+				tmpnewmpdel->m_aLods[1] = new CLod();
 				sprintf(tmppath, "%s%s", Core_RStringGet(G_RI_STRING_PATH_GS_MESHES), lod1);
-				tmpnewmpdel->ArrLod[1]->path = lod1;
-				SGCore_StaticModelLoad(tmppath, &tmpnewmpdel->ArrLod[1]->model);
+				tmpnewmpdel->m_aLods[1]->m_sPath = lod1;
+				SGCore_StaticModelLoad(tmppath, &tmpnewmpdel->m_aLods[1]->m_pModel);
 
-				for (int i = 0; i < tmpnewmpdel->ArrLod[1]->model->m_uiSubsetCount; ++i)
+				for (int i = 0; i < tmpnewmpdel->m_aLods[1]->m_pModel->m_uiSubsetCount; ++i)
 				{
-					sprintf(tmppathtex, "%s.dds", tmpnewmpdel->ArrLod[1]->model->m_ppTextures[i]);
-					tmpnewmpdel->ArrLod[1]->idstex[i] = SGCore_MtlLoad(tmppathtex, (tmpnewmpdel->TypeGreen == GREEN_TYPE_TREE ? MTL_TYPE_TREE : MTL_TYPE_GRASS));
+					sprintf(tmppathtex, "%s.dds", tmpnewmpdel->m_aLods[1]->m_pModel->m_ppTextures[i]);
+					tmpnewmpdel->m_aLods[1]->m_aIDsTextures[i] = SGCore_MtlLoad(tmppathtex, (tmpnewmpdel->m_typeGreen == GREEN_TYPE_TREE ? MTL_TYPE_TREE : MTL_TYPE_GRASS));
 				}
 			}
 		}
@@ -829,54 +835,54 @@ ID Green::Init(StaticGeom* geom, const char* name,
 		if (def_str_validate(lod2))
 		{
 			if (stricmp(path, lod2) == 0)
-				tmpnewmpdel->ArrLod[2] = tmpnewmpdel->ArrLod[0];
+				tmpnewmpdel->m_aLods[2] = tmpnewmpdel->m_aLods[0];
 			else if (stricmp(lod1, lod2) == 0)
-				tmpnewmpdel->ArrLod[2] = tmpnewmpdel->ArrLod[1];
+				tmpnewmpdel->m_aLods[2] = tmpnewmpdel->m_aLods[1];
 			else
 			{
-				tmpnewmpdel->ArrLod[2] = new Lod();
+				tmpnewmpdel->m_aLods[2] = new CLod();
 				sprintf(tmppath, "%s%s", Core_RStringGet(G_RI_STRING_PATH_GS_MESHES), lod2);
-				tmpnewmpdel->ArrLod[2]->path = lod2;
-				SGCore_StaticModelLoad(tmppath, &tmpnewmpdel->ArrLod[2]->model);
+				tmpnewmpdel->m_aLods[2]->m_sPath = lod2;
+				SGCore_StaticModelLoad(tmppath, &tmpnewmpdel->m_aLods[2]->m_pModel);
 
-				for (int i = 0; i < tmpnewmpdel->ArrLod[2]->model->m_uiSubsetCount; ++i)
+				for (int i = 0; i < tmpnewmpdel->m_aLods[2]->m_pModel->m_uiSubsetCount; ++i)
 				{
-					sprintf(tmppathtex, "%s.dds", tmpnewmpdel->ArrLod[1]->model->m_ppTextures[i]);
-					tmpnewmpdel->ArrLod[2]->idstex[i] = SGCore_MtlLoad(tmppathtex, (tmpnewmpdel->TypeGreen == GREEN_TYPE_TREE ? MTL_TYPE_TREE : MTL_TYPE_GRASS));
+					sprintf(tmppathtex, "%s.dds", tmpnewmpdel->m_aLods[1]->m_pModel->m_ppTextures[i]);
+					tmpnewmpdel->m_aLods[2]->m_aIDsTextures[i] = SGCore_MtlLoad(tmppathtex, (tmpnewmpdel->m_typeGreen == GREEN_TYPE_TREE ? MTL_TYPE_TREE : MTL_TYPE_GRASS));
 				}
 			}
 		}
 
 		ISXBound* tmpbb = SGCore_CrBound();
-		SGCore_FCompBoundBox(tmpnewmpdel->ArrLod[0]->model->m_pVertexBuffer, &tmpbb, tmpnewmpdel->ArrLod[0]->model->m_uiAllVertexCount, sizeof(vertex_static));
+		SGCore_FCompBoundBox(tmpnewmpdel->m_aLods[0]->m_pModel->m_pVertexBuffer, &tmpbb, tmpnewmpdel->m_aLods[0]->m_pModel->m_uiAllVertexCount, sizeof(vertex_static));
 
 		float3 mmax, mmin;
 		tmpbb->getMinMax(&mmin, &mmax);
 		mem_release(tmpbb);
 
 		float3 tmpmin, tmpmax;
-		geom->GetMinMax(&tmpmin, &tmpmax);
+		geom->getMinMax(&tmpmin, &tmpmax);
 
 		if (def_str_validate(path_mask))
 		{
 			ID IDTexMask = SGCore_LoadTexAddName(path_mask, LOAD_TEXTURE_TYPE_LOAD);
 			SGCore_LoadTexAllLoad();
 
-			GenByTex(geom, tmpnewmpdel, IDTexMask, &mmin, &mmax, count_max);
+			genByTex(geom, tmpnewmpdel, IDTexMask, &mmin, &mmax, count_max);
 		}
 
-		PreSegmentation(tmpnewmpdel, &tmpmin, &tmpmax);
-		mem_delete_a(tmpnewmpdel->AllTrans);
+		preSegmentation(tmpnewmpdel, &tmpmin, &tmpmax);
+		mem_delete_a(tmpnewmpdel->m_pAllTrans);
 
-		SetSplitID(tmpnewmpdel);
+		setSplitID(tmpnewmpdel);
 		
-		ArrModels.push_back(tmpnewmpdel);
+		m_aGreens.push_back(tmpnewmpdel);
 		if (def_str_validate(navmesh))
 		{
-			SetGreenNav(ArrModels.size() - 1, navmesh);
+			setGreenNav(m_aGreens.size() - 1, navmesh);
 		}
-		AddModelInArrCom(ArrModels.size() - 1);
-		return ArrModels.size() - 1;
+		addModelInArrCom(m_aGreens.size() - 1);
+		return m_aGreens.size() - 1;
 	}
 	else
 	{
@@ -886,12 +892,12 @@ ID Green::Init(StaticGeom* geom, const char* name,
 	return -1;
 }
 
-void Green::GenByTex(StaticGeom* geom, Model* model, ID idmask, float3* min, float3* max, float count_max)
+void CGreen::genByTex(CStaticGeom* geom, CModel* model, ID idmask, float3* min, float3* max, float count_max)
 {
 	float CountMaxInPixel = count_max;
 
 	float3 tmpmin, tmpmax;
-	geom->GetMinMax(&tmpmin, &tmpmax);
+	geom->getMinMax(&tmpmin, &tmpmax);
 
 	float r2d = 0;
 
@@ -955,7 +961,7 @@ void Green::GenByTex(StaticGeom* geom, Model* model, ID idmask, float3* min, flo
 					tmppos2.x = (tmp2.x - OneEdX*0.5f) + randf(0.0, OneEdX);
 					tmppos2.z = (tmp2.z - OneEdY*0.5f) + randf(0.0, OneEdY);
 
-					if (model->TypeGreen == GREEN_TYPE_TREE)
+					if (model->m_typeGreen == GREEN_TYPE_TREE)
 					{
 						for (int k = 0; k < arrpos.size(); ++k)
 						{
@@ -969,16 +975,16 @@ void Green::GenByTex(StaticGeom* geom, Model* model, ID idmask, float3* min, flo
 					}
 
 					if (isintersect)
-						isintersect = geom->GetIntersectedRayY(&tmppos2);
+						isintersect = geom->getIntersectedRayY(&tmppos2);
 
 					if (isintersect)
 					{
 						arrpos.push_back(tmppos2);
 
-						++model->AllCountGreen;
+						++model->m_uiCountObj;
 
 						//если тип дерево, то на пиксель генерируем только одно дерево
-						if (model->TypeGreen == GREEN_TYPE_TREE)
+						if (model->m_typeGreen == GREEN_TYPE_TREE)
 							break;
 					}
 					else
@@ -992,31 +998,31 @@ void Green::GenByTex(StaticGeom* geom, Model* model, ID idmask, float3* min, flo
 
 	SGCore_LoadTexGetTex(idmask)->UnlockRect(0);
 
-	if (model->AllCountGreen <= 0)
+	if (model->m_uiCountObj <= 0)
 		return;
 
-	model->AllTrans = new GreenDataVertex[model->AllCountGreen];
+	model->m_pAllTrans = new CGreenDataVertex[model->m_uiCountObj];
 
-	for (DWORD i = 0; i<model->AllCountGreen; i++)
+	for (DWORD i = 0; i<model->m_uiCountObj; i++)
 	{
-		model->AllTrans[i].m_vPosition = arrpos[i];
-		model->AllTrans[i].m_vTexCoord.x = 1.f + randf(0.f, GREEN_GEN_RAND_SCALE);
-		model->AllTrans[i].m_vTexCoord.y = randf(0.f, GREEN_GEN_RAND_ROTATE_Y);
-		model->AllTrans[i].m_vTexCoord.z = 0;// (float(rand() % 200) / 100.f) - 1.f;
-		model->AllTrans[i].m_vSinCosRot.x = sinf(model->AllTrans[i].m_vTexCoord.y);
-		model->AllTrans[i].m_vSinCosRot.y = cosf(model->AllTrans[i].m_vTexCoord.y);
+		model->m_pAllTrans[i].m_vPosition = arrpos[i];
+		model->m_pAllTrans[i].m_vTexCoord.x = 1.f + randf(0.f, GREEN_GEN_RAND_SCALE);
+		model->m_pAllTrans[i].m_vTexCoord.y = randf(0.f, GREEN_GEN_RAND_ROTATE_Y);
+		model->m_pAllTrans[i].m_vTexCoord.z = 0;// (float(rand() % 200) / 100.f) - 1.f;
+		model->m_pAllTrans[i].m_vSinCosRot.x = sinf(model->m_pAllTrans[i].m_vTexCoord.y);
+		model->m_pAllTrans[i].m_vSinCosRot.y = cosf(model->m_pAllTrans[i].m_vTexCoord.y);
 	}
 	arrpos.clear();
 }
 
-ID Green::GetIDSplit(ID id, float3* pos)
+ID CGreen::getIDSplit(ID id, float3* pos)
 {
-	if (id < 0 || ArrModels.size() <= id)
+	if (id < 0 || m_aGreens.size() <= id)
 		return -1;
 
-	Array<Segment*> queue;
-	long tmpcount = 0;
-	queue.push_back(ArrModels[id]->SplitsTree);
+	Array<CSegment*> queue;
+	int tmpcount = 0;
+	queue.push_back(m_aGreens[id]->m_pSplitsTree);
 	float width = 0;
 	float depth = 0;
 	float3 min, max;
@@ -1024,47 +1030,47 @@ ID Green::GetIDSplit(ID id, float3* pos)
 
 	while (queue.size())
 	{
-		queue[0]->BoundVolumeSys->getMinMax(&min, &max);
+		queue[0]->m_pBoundVolumeSys->getMinMax(&min, &max);
 		if (max.x >= pos->x && max.z >= pos->z && min.x <= pos->x && min.z <= pos->z)
 		{
-			if (!(queue[0]->Splits[0]))
-				tmpidsplit = queue[0]->Id;
+			if (!(queue[0]->m_aSplits[0]))
+				tmpidsplit = queue[0]->m_id;
 			else
 			{
-				queue[0]->BFNonEnd = true;
-				++(queue[0]->CountAllGreen);
+				queue[0]->m_idNonEnd = true;
+				++(queue[0]->m_iCountObj);
 
 				float3 tmpMin, tmpMax;
 				float scalecoef = 1.f + GREEN_GEN_RAND_SCALE;
 
-				queue[0]->BoundVolumeSys->getMinMax(&tmpMin, &tmpMax);
-				if (tmpMax.y < (pos->y + ArrModels[id]->BBMax.y * scalecoef))
-					tmpMax.y = tmpMax.y + ArrModels[id]->BBMax.y * scalecoef;
+				queue[0]->m_pBoundVolumeSys->getMinMax(&tmpMin, &tmpMax);
+				if (tmpMax.y < (pos->y + m_aGreens[id]->m_vMax.y * scalecoef))
+					tmpMax.y = tmpMax.y + m_aGreens[id]->m_vMax.y * scalecoef;
 
-				if (tmpMin.y >(pos->y + ArrModels[id]->BBMin.y * scalecoef))
-					tmpMin.y = tmpMin.y + ArrModels[id]->BBMin.y * scalecoef;
+				if (tmpMin.y >(pos->y + m_aGreens[id]->m_vMin.y * scalecoef))
+					tmpMin.y = tmpMin.y + m_aGreens[id]->m_vMin.y * scalecoef;
 
-				queue[0]->BoundVolumeSys->setMinMax(&tmpMin, &tmpMax);
+				queue[0]->m_pBoundVolumeSys->setMinMax(&tmpMin, &tmpMax);
 
-				if (tmpMax.x < (pos->x + ArrModels[id]->BBMax.x * scalecoef))
-					tmpMax.x = tmpMax.x + ArrModels[id]->BBMax.x * scalecoef;
+				if (tmpMax.x < (pos->x + m_aGreens[id]->m_vMax.x * scalecoef))
+					tmpMax.x = tmpMax.x + m_aGreens[id]->m_vMax.x * scalecoef;
 
-				if (tmpMax.z < (pos->z + ArrModels[id]->BBMax.z * scalecoef))
-					tmpMax.z = tmpMax.z + ArrModels[id]->BBMax.z * scalecoef;
+				if (tmpMax.z < (pos->z + m_aGreens[id]->m_vMax.z * scalecoef))
+					tmpMax.z = tmpMax.z + m_aGreens[id]->m_vMax.z * scalecoef;
 
-				if (tmpMin.x >(pos->x + ArrModels[id]->BBMin.x * scalecoef))
-					tmpMin.x = tmpMin.x + ArrModels[id]->BBMin.x * scalecoef;
+				if (tmpMin.x >(pos->x + m_aGreens[id]->m_vMin.x * scalecoef))
+					tmpMin.x = tmpMin.x + m_aGreens[id]->m_vMin.x * scalecoef;
 
-				if (tmpMin.z >(pos->z + ArrModels[id]->BBMin.z * scalecoef))
-					tmpMin.z = tmpMin.z + ArrModels[id]->BBMin.z * scalecoef;
+				if (tmpMin.z >(pos->z + m_aGreens[id]->m_vMin.z * scalecoef))
+					tmpMin.z = tmpMin.z + m_aGreens[id]->m_vMin.z * scalecoef;
 
-				queue[0]->BoundVolumeP->setMinMax(&tmpMin, &tmpMax);
+				queue[0]->m_pBoundVolumeP->setMinMax(&tmpMin, &tmpMax);
 			}
 
 			for (int i = 0; i < GREEN_COUNT_TYPE_SEGMENTATION; i++)
 			{
-				if (queue[0]->Splits[i])
-					queue.push_back(queue[0]->Splits[i]);
+				if (queue[0]->m_aSplits[i])
+					queue.push_back(queue[0]->m_aSplits[i]);
 			}
 		}
 
@@ -1075,22 +1081,22 @@ ID Green::GetIDSplit(ID id, float3* pos)
 	return tmpidsplit;
 }
 
-ID Green::AddObject(ID id, float3* pos, GreenDataVertex* data, ID* idsplit)
+ID CGreen::addObject(ID id, float3* pos, CGreenDataVertex* data, ID* idsplit)
 {
-	if (id < 0 || ArrModels.size() <= id)
+	if (id < 0 || m_aGreens.size() <= id)
 		return -1;
 
-	ID tmpidsplit = GetIDSplit(id, pos);
+	ID tmpidsplit = getIDSplit(id, pos);
 
 	if (tmpidsplit < 0)
 		return -1;
 
-	int oldlen = ArrModels[id]->SplitsArr[tmpidsplit]->CountAllGreen;
-	GreenDataVertex* tmpdv = new GreenDataVertex[oldlen + 1];
+	int oldlen = m_aGreens[id]->m_aSplitsArr[tmpidsplit]->m_iCountObj;
+	CGreenDataVertex* tmpdv = new CGreenDataVertex[oldlen + 1];
 	if (oldlen > 0)
-		memcpy(tmpdv, ArrModels[id]->SplitsArr[tmpidsplit]->Data, oldlen * sizeof(GreenDataVertex));
+		memcpy(tmpdv, m_aGreens[id]->m_aSplitsArr[tmpidsplit]->m_pObjData, oldlen * sizeof(CGreenDataVertex));
 
-	GreenDataVertex tmpdvobj;
+	CGreenDataVertex tmpdvobj;
 	if (!data)
 	{
 		tmpdvobj.m_vPosition = *pos;
@@ -1106,13 +1112,13 @@ ID Green::AddObject(ID id, float3* pos, GreenDataVertex* data, ID* idsplit)
 		tmpdvobj.m_vPosition = *pos;
 	}
 
-	memcpy(tmpdv + oldlen, &tmpdvobj, sizeof(GreenDataVertex));
-	mem_delete_a(ArrModels[id]->SplitsArr[tmpidsplit]->Data);
-	ArrModels[id]->SplitsArr[tmpidsplit]->Data = tmpdv;
-	++(ArrModels[id]->SplitsArr[tmpidsplit]->CountAllGreen);
-	++(ArrModels[id]->AllCountGreen);
-	int currlen = ArrModels[id]->SplitsArr[tmpidsplit]->CountAllGreen;
-	AlignBound(ArrModels[id], ArrModels[id]->SplitsArr[tmpidsplit]);
+	memcpy(tmpdv + oldlen, &tmpdvobj, sizeof(CGreenDataVertex));
+	mem_delete_a(m_aGreens[id]->m_aSplitsArr[tmpidsplit]->m_pObjData);
+	m_aGreens[id]->m_aSplitsArr[tmpidsplit]->m_pObjData = tmpdv;
+	++(m_aGreens[id]->m_aSplitsArr[tmpidsplit]->m_iCountObj);
+	++(m_aGreens[id]->m_uiCountObj);
+	int currlen = m_aGreens[id]->m_aSplitsArr[tmpidsplit]->m_iCountObj;
+	alignBound(m_aGreens[id], m_aGreens[id]->m_aSplitsArr[tmpidsplit]);
 
 	if (idsplit)
 		*idsplit = tmpidsplit;
@@ -1120,69 +1126,69 @@ ID Green::AddObject(ID id, float3* pos, GreenDataVertex* data, ID* idsplit)
 	return oldlen;
 }
 
-void Green::DelObject(ID id, ID idsplit, ID idobj)
+void CGreen::deleteObject(ID id, ID idsplit, ID idobj)
 {
-	if (id < 0 || ArrModels.size() <= id || idsplit < 0 || ArrModels[id]->SplitsArr.size() <= idsplit || idobj < 0 || ArrModels[id]->SplitsArr[idsplit]->CountAllGreen <= idobj)
+	if (id < 0 || m_aGreens.size() <= id || idsplit < 0 || m_aGreens[id]->m_aSplitsArr.size() <= idsplit || idobj < 0 || m_aGreens[id]->m_aSplitsArr[idsplit]->m_iCountObj <= idobj)
 		return;
 
-	int oldlen = ArrModels[id]->SplitsArr[idsplit]->CountAllGreen;
-	GreenDataVertex* tmpdv = new GreenDataVertex[oldlen - 1];
-	memcpy(tmpdv, ArrModels[id]->SplitsArr[idsplit]->Data, idobj * sizeof(GreenDataVertex));
-	memcpy(tmpdv + idobj, ArrModels[id]->SplitsArr[idsplit]->Data + idobj + 1, ((oldlen - idobj) - 1)* sizeof(GreenDataVertex));
-	mem_delete_a(ArrModels[id]->SplitsArr[idsplit]->Data);
-	ArrModels[id]->SplitsArr[idsplit]->Data = tmpdv;
-	--(ArrModels[id]->SplitsArr[idsplit]->CountAllGreen);
-	--(ArrModels[id]->AllCountGreen);
-	AlignBound(ArrModels[id], ArrModels[id]->SplitsArr[idsplit]);
+	int oldlen = m_aGreens[id]->m_aSplitsArr[idsplit]->m_iCountObj;
+	CGreenDataVertex* tmpdv = new CGreenDataVertex[oldlen - 1];
+	memcpy(tmpdv, m_aGreens[id]->m_aSplitsArr[idsplit]->m_pObjData, idobj * sizeof(CGreenDataVertex));
+	memcpy(tmpdv + idobj, m_aGreens[id]->m_aSplitsArr[idsplit]->m_pObjData + idobj + 1, ((oldlen - idobj) - 1)* sizeof(CGreenDataVertex));
+	mem_delete_a(m_aGreens[id]->m_aSplitsArr[idsplit]->m_pObjData);
+	m_aGreens[id]->m_aSplitsArr[idsplit]->m_pObjData = tmpdv;
+	--(m_aGreens[id]->m_aSplitsArr[idsplit]->m_iCountObj);
+	--(m_aGreens[id]->m_uiCountObj);
+	alignBound(m_aGreens[id], m_aGreens[id]->m_aSplitsArr[idsplit]);
 }
 
-void Green::GetPosObject(ID id, ID idsplit, ID idobj, float3_t* pos)
+void CGreen::getPosObject(ID id, ID idsplit, ID idobj, float3_t* pos)
 {
-	if (!pos || id < 0 || ArrModels.size() <= id || idsplit < 0 || ArrModels[id]->SplitsArr.size() <= idsplit || idobj < 0 || ArrModels[id]->SplitsArr[idsplit]->CountAllGreen <= idobj)
+	if (!pos || id < 0 || m_aGreens.size() <= id || idsplit < 0 || m_aGreens[id]->m_aSplitsArr.size() <= idsplit || idobj < 0 || m_aGreens[id]->m_aSplitsArr[idsplit]->m_iCountObj <= idobj)
 		return;
 
-	*pos = ArrModels[id]->SplitsArr[idsplit]->Data[idobj].m_vPosition;
+	*pos = m_aGreens[id]->m_aSplitsArr[idsplit]->m_pObjData[idobj].m_vPosition;
 }
 
-void Green::SetPosObject(ID id, ID* idsplit, ID* idobj, float3_t* pos)
+void CGreen::setPosObject(ID id, ID* idsplit, ID* idobj, const float3_t* pos)
 {
-	if (!pos || !idsplit || !idobj || id < 0 || ArrModels.size() <= id || (*idsplit) < 0 || ArrModels[id]->SplitsArr.size() <= (*idsplit) || (*idobj) < 0 || ArrModels[id]->SplitsArr[(*idsplit)]->CountAllGreen <= (*idobj))
+	if (!pos || !idsplit || !idobj || id < 0 || m_aGreens.size() <= id || (*idsplit) < 0 || m_aGreens[id]->m_aSplitsArr.size() <= (*idsplit) || (*idobj) < 0 || m_aGreens[id]->m_aSplitsArr[(*idsplit)]->m_iCountObj <= (*idobj))
 		return;
 
-	if (GetIDSplit(id, &float3(*pos)) == (*idsplit))
-		ArrModels[id]->SplitsArr[(*idsplit)]->Data[(*idobj)].m_vPosition = *pos;
+	if (getIDSplit(id, &float3(*pos)) == (*idsplit))
+		m_aGreens[id]->m_aSplitsArr[(*idsplit)]->m_pObjData[(*idobj)].m_vPosition = *pos;
 	else
 	{
-		GreenDataVertex tmpdv = ArrModels[id]->SplitsArr[(*idsplit)]->Data[(*idobj)];
-		DelObject(id, (*idsplit), (*idobj));
-		(*idobj) = AddObject(id, &float3(*pos), &tmpdv, idsplit);
+		CGreenDataVertex tmpdv = m_aGreens[id]->m_aSplitsArr[(*idsplit)]->m_pObjData[(*idobj)];
+		deleteObject(id, (*idsplit), (*idobj));
+		(*idobj) = addObject(id, &float3(*pos), &tmpdv, idsplit);
 	}
 }
 
-void Green::Save(const char* path)
+void CGreen::save(const char* path)
 {
 	FILE* file = fopen(path, "wb");
 
-	int32_t countmodel = ArrModels.size();
+	int32_t countmodel = m_aGreens.size();
 	fwrite(&countmodel, sizeof(int32_t), 1, file);
 
-	for (long i = 0; i < ArrModels.size(); ++i)
+	for (int i = 0; i < m_aGreens.size(); ++i)
 	{
-		fwrite(&ArrModels[i]->TypeGreen, sizeof(int32_t), 1, file);
+		fwrite(&m_aGreens[i]->m_typeGreen, sizeof(int32_t), 1, file);
 
-		int32_t tmpstrlen = strlen(ArrModels[i]->Name);
+		int32_t tmpstrlen = strlen(m_aGreens[i]->m_szName);
 		fwrite(&tmpstrlen, sizeof(int32_t), 1, file);
-		fwrite(ArrModels[i]->Name, sizeof(char), tmpstrlen, file);
+		fwrite(m_aGreens[i]->m_szName, sizeof(char), tmpstrlen, file);
 
-		tmpstrlen = ArrModels[i]->MaskName.length();
+		tmpstrlen = m_aGreens[i]->m_szMaskName.length();
 		fwrite(&tmpstrlen, sizeof(int32_t), 1, file);
-		fwrite(ArrModels[i]->MaskName.c_str(), sizeof(char), tmpstrlen, file);
+		fwrite(m_aGreens[i]->m_szMaskName.c_str(), sizeof(char), tmpstrlen, file);
 
-		if (ArrModels[i]->NavigateMesh)
+		if (m_aGreens[i]->m_pPhysMesh)
 		{
-			tmpstrlen = strlen(ArrModels[i]->NavigateMesh->pathname.c_str());
+			tmpstrlen = strlen(m_aGreens[i]->m_pPhysMesh->m_sPathName.c_str());
 			fwrite(&tmpstrlen, sizeof(int32_t), 1, file);
-			fwrite(ArrModels[i]->NavigateMesh->pathname.c_str(), sizeof(char), tmpstrlen, file);
+			fwrite(m_aGreens[i]->m_pPhysMesh->m_sPathName.c_str(), sizeof(char), tmpstrlen, file);
 		}
 		else
 		{
@@ -1190,39 +1196,39 @@ void Green::Save(const char* path)
 			fwrite(&tmpstrlen, sizeof(int32_t), 1, file);
 		}
 
-		if (ArrModels[i]->TypeGreen == GREEN_TYPE_GRASS)
+		if (m_aGreens[i]->m_typeGreen == GREEN_TYPE_GRASS)
 		{
-			tmpstrlen = strlen(ArrModels[i]->ArrLod[0]->path.c_str());
+			tmpstrlen = strlen(m_aGreens[i]->m_aLods[0]->m_sPath.c_str());
 			fwrite(&tmpstrlen, sizeof(int32_t), 1, file);
-			fwrite(ArrModels[i]->ArrLod[0]->path.c_str(), sizeof(char), tmpstrlen, file);
+			fwrite(m_aGreens[i]->m_aLods[0]->m_sPath.c_str(), sizeof(char), tmpstrlen, file);
 		}
 		else
 		{
 			for (int k = 0; k < GREEN_COUNT_LOD; ++k)
 			{
-				tmpstrlen = ArrModels[i]->ArrLod[k]->path.length();
+				tmpstrlen = m_aGreens[i]->m_aLods[k]->m_sPath.length();
 				fwrite(&tmpstrlen, sizeof(int32_t), 1, file);
-				fwrite(ArrModels[i]->ArrLod[k]->path.c_str(), sizeof(char), tmpstrlen, file);
+				fwrite(m_aGreens[i]->m_aLods[k]->m_sPath.c_str(), sizeof(char), tmpstrlen, file);
 			}
 		}
 		
-		fwrite(&ArrModels[i]->BBMin.x, sizeof(float), 1, file);
-		fwrite(&ArrModels[i]->BBMin.y, sizeof(float), 1, file);
-		fwrite(&ArrModels[i]->BBMin.z, sizeof(float), 1, file);
+		fwrite(&m_aGreens[i]->m_vMin.x, sizeof(float), 1, file);
+		fwrite(&m_aGreens[i]->m_vMin.y, sizeof(float), 1, file);
+		fwrite(&m_aGreens[i]->m_vMin.z, sizeof(float), 1, file);
 
-		fwrite(&ArrModels[i]->BBMax.x, sizeof(float), 1, file);
-		fwrite(&ArrModels[i]->BBMax.y, sizeof(float), 1, file);
-		fwrite(&ArrModels[i]->BBMax.z, sizeof(float), 1, file);
+		fwrite(&m_aGreens[i]->m_vMax.x, sizeof(float), 1, file);
+		fwrite(&m_aGreens[i]->m_vMax.y, sizeof(float), 1, file);
+		fwrite(&m_aGreens[i]->m_vMax.z, sizeof(float), 1, file);
 
-		fwrite(&ArrModels[i]->AllCountGreen, sizeof(uint32_t), 1, file);
+		fwrite(&m_aGreens[i]->m_uiCountObj, sizeof(uint32_t), 1, file);
 
-		Array<Segment*> queue;
-		long tmpcount = 0;
-		queue.push_back(ArrModels[i]->SplitsTree);
+		Array<CSegment*> queue;
+		int tmpcount = 0;
+		queue.push_back(m_aGreens[i]->m_pSplitsTree);
 
 		while (queue.size())
 		{
-			SaveSplit(queue[0], file, &queue);
+			saveSplit(queue[0], file, &queue);
 
 			queue.erase(0);
 			++tmpcount;
@@ -1232,10 +1238,10 @@ void Green::Save(const char* path)
 	fclose(file);
 }
 
-void Green::SaveSplit(Segment* Split, FILE* file, Array<Segment*> * queue)
+void CGreen::saveSplit(CSegment* Split, FILE* file, Array<CSegment*> * queue)
 {
 	float3 jmin, jmax;
-	Split->BoundVolumeSys->getMinMax(&jmin, &jmax);
+	Split->m_pBoundVolumeSys->getMinMax(&jmin, &jmax);
 	fwrite(&jmin.x, sizeof(float), 1, file);
 	fwrite(&jmin.y, sizeof(float), 1, file);
 	fwrite(&jmin.z, sizeof(float), 1, file);
@@ -1244,7 +1250,7 @@ void Green::SaveSplit(Segment* Split, FILE* file, Array<Segment*> * queue)
 	fwrite(&jmax.y, sizeof(float), 1, file);
 	fwrite(&jmax.z, sizeof(float), 1, file);
 
-	Split->BoundVolumeP->getMinMax(&jmin, &jmax);
+	Split->m_pBoundVolumeP->getMinMax(&jmin, &jmax);
 	fwrite(&jmin.x, sizeof(float), 1, file);
 	fwrite(&jmin.y, sizeof(float), 1, file);
 	fwrite(&jmin.z, sizeof(float), 1, file);
@@ -1253,34 +1259,34 @@ void Green::SaveSplit(Segment* Split, FILE* file, Array<Segment*> * queue)
 	fwrite(&jmax.y, sizeof(float), 1, file);
 	fwrite(&jmax.z, sizeof(float), 1, file);
 
-	fwrite(&Split->CountAllGreen, sizeof(uint32_t), 1, file);
+	fwrite(&Split->m_iCountObj, sizeof(uint32_t), 1, file);
 
-	if (Split->CountAllGreen > 0)
+	if (Split->m_iCountObj > 0)
 		int qwerty = 0;
 
-	fwrite(&Split->BFNonEnd, sizeof(int8_t), 1, file);
+	fwrite(&Split->m_idNonEnd, sizeof(int8_t), 1, file);
 
 	bool isexists = true;
 
-	if (Split->Splits[0]/*!Split->Data && Split->CountAllGreen > 0*/)
+	if (Split->m_aSplits[0]/*!Split->m_pObjData && Split->m_iCountObj > 0*/)
 	{
 		fwrite(&isexists, sizeof(int8_t), 1, file);
 		for (int i = 0; i<GREEN_COUNT_TYPE_SEGMENTATION; i++)
 		{
-			if (Split->Splits[i])
-				queue->push_back(Split->Splits[i]);
+			if (Split->m_aSplits[i])
+				queue->push_back(Split->m_aSplits[i]);
 		}
 	}
 	else
 	{
 		isexists = false;
 		fwrite(&isexists, sizeof(int8_t), 1, file);
-		if (Split->CountAllGreen > 0)
-			fwrite(Split->Data, sizeof(GreenDataVertex), Split->CountAllGreen, file);
+		if (Split->m_iCountObj > 0)
+			fwrite(Split->m_pObjData, sizeof(CGreenDataVertex), Split->m_iCountObj, file);
 	}
 }
 
-void Green::Load(const char* path)
+void CGreen::load(const char* path)
 {
 	FILE* file = fopen(path, "rb");
 
@@ -1294,34 +1300,34 @@ void Green::Load(const char* path)
 	int32_t countmodel;
 	fread(&countmodel, sizeof(int32_t), 1, file);
 
-	for (long i = 0; i < countmodel; ++i)
+	for (int i = 0; i < countmodel; ++i)
 	{
 		tmpstr[0][0] = tmpstr[1][0] = tmpstr[2][0] = 0;
-		Model* tmpmodel = new Model();
-		fread(&tmpmodel->TypeGreen, sizeof(int32_t), 1, file);
+		CModel* tmpmodel = new CModel();
+		fread(&tmpmodel->m_typeGreen, sizeof(int32_t), 1, file);
 
-		int32_t tmpstrlen;// = strlen(ArrModels[i]->Name);
+		int32_t tmpstrlen;// = strlen(m_aGreens[i]->Name);
 		fread(&tmpstrlen, sizeof(int32_t), 1, file);
 		fread(tmpNameMask, sizeof(char), tmpstrlen, file);
 		tmpNameMask[tmpstrlen] = 0;
-		sprintf(tmpmodel->Name,"%s",tmpNameMask);
+		sprintf(tmpmodel->m_szName, "%s", tmpNameMask);
 
-		//tmpstrlen = ArrModels[i]->MaskName.length();
+		//tmpstrlen = m_aGreens[i]->m_szMaskName.length();
 		fread(&tmpstrlen, sizeof(int32_t), 1, file);
 		fread(tmpNameMask, sizeof(char), tmpstrlen, file);
 		tmpNameMask[tmpstrlen] = 0;
-		tmpmodel->MaskName = tmpNameMask;
+		tmpmodel->m_szMaskName = tmpNameMask;
 
 		fread(&tmpstrlen, sizeof(int32_t), 1, file);
 		if (tmpstrlen > 0)
 		{
 			fread(tmpNameMask, sizeof(char), tmpstrlen, file);
 			tmpNameMask[tmpstrlen] = 0;
-			tmpmodel->NavigateMesh = new Model::NavMesh();
-			tmpmodel->NavigateMesh->pathname = tmpNameMask;
+			tmpmodel->m_pPhysMesh = new CModel::CPhysMesh();
+			tmpmodel->m_pPhysMesh->m_sPathName = tmpNameMask;
 		}
 
-		if (tmpmodel->TypeGreen == GREEN_TYPE_GRASS)
+		if (tmpmodel->m_typeGreen == GREEN_TYPE_GRASS)
 		{
 			fread(&tmpstrlen, sizeof(int32_t), 1, file);
 			fread(tmpstr[0], sizeof(char), tmpstrlen, file);
@@ -1338,35 +1344,35 @@ void Green::Load(const char* path)
 		}
 
 		
-		tmpmodel->ArrLod[0] = new Lod();
-		tmpmodel->ArrLod[1] = 0;
-		tmpmodel->ArrLod[2] = 0;
+		tmpmodel->m_aLods[0] = new CLod();
+		tmpmodel->m_aLods[1] = 0;
+		tmpmodel->m_aLods[2] = 0;
 
 		sprintf(tmppath, "%s%s", Core_RStringGet(G_RI_STRING_PATH_GS_MESHES), tmpstr[0]);
-		SGCore_StaticModelLoad(tmppath, &tmpmodel->ArrLod[0]->model);
-		tmpmodel->ArrLod[0]->path = tmpstr[0];
+		SGCore_StaticModelLoad(tmppath, &tmpmodel->m_aLods[0]->m_pModel);
+		tmpmodel->m_aLods[0]->m_sPath = tmpstr[0];
 		char tmppathtex[1024];
-		for (int k = 0; k < tmpmodel->ArrLod[0]->model->m_uiSubsetCount; ++k)
+		for (int k = 0; k < tmpmodel->m_aLods[0]->m_pModel->m_uiSubsetCount; ++k)
 		{
-			sprintf(tmppathtex, "%s.dds", tmpmodel->ArrLod[0]->model->m_ppTextures[k]);
-			tmpmodel->ArrLod[0]->idstex[k] = SGCore_MtlLoad(tmppathtex, (tmpmodel->TypeGreen == GREEN_TYPE_TREE ? MTL_TYPE_TREE : MTL_TYPE_GRASS));
+			sprintf(tmppathtex, "%s.dds", tmpmodel->m_aLods[0]->m_pModel->m_ppTextures[k]);
+			tmpmodel->m_aLods[0]->m_aIDsTextures[k] = SGCore_MtlLoad(tmppathtex, (tmpmodel->m_typeGreen == GREEN_TYPE_TREE ? MTL_TYPE_TREE : MTL_TYPE_GRASS));
 		}
 
 		if (tmpstr[1][0])
 		{
 			if (stricmp(tmpstr[0], tmpstr[1]) == 0)
-				tmpmodel->ArrLod[1] = tmpmodel->ArrLod[0];
+				tmpmodel->m_aLods[1] = tmpmodel->m_aLods[0];
 			else
 			{
-				tmpmodel->ArrLod[1] = new Lod();
-				tmpmodel->ArrLod[1]->path = tmpstr[1];
+				tmpmodel->m_aLods[1] = new CLod();
+				tmpmodel->m_aLods[1]->m_sPath = tmpstr[1];
 				sprintf(tmppath, "%s%s", Core_RStringGet(G_RI_STRING_PATH_GS_MESHES), tmpstr[1]);
-				SGCore_StaticModelLoad(tmppath, &tmpmodel->ArrLod[1]->model);
+				SGCore_StaticModelLoad(tmppath, &tmpmodel->m_aLods[1]->m_pModel);
 
-				for (int k = 0; k < tmpmodel->ArrLod[1]->model->m_uiSubsetCount; ++k)
+				for (int k = 0; k < tmpmodel->m_aLods[1]->m_pModel->m_uiSubsetCount; ++k)
 				{
-					sprintf(tmppathtex, "%s.dds", tmpmodel->ArrLod[1]->model->m_ppTextures[k]);
-					tmpmodel->ArrLod[1]->idstex[k] = SGCore_MtlLoad(tmppathtex, (tmpmodel->TypeGreen == GREEN_TYPE_TREE ? MTL_TYPE_TREE : MTL_TYPE_GRASS));
+					sprintf(tmppathtex, "%s.dds", tmpmodel->m_aLods[1]->m_pModel->m_ppTextures[k]);
+					tmpmodel->m_aLods[1]->m_aIDsTextures[k] = SGCore_MtlLoad(tmppathtex, (tmpmodel->m_typeGreen == GREEN_TYPE_TREE ? MTL_TYPE_TREE : MTL_TYPE_GRASS));
 				}
 			}
 		}
@@ -1374,63 +1380,63 @@ void Green::Load(const char* path)
 		if (tmpstr[2][0])
 		{
 			if (stricmp(tmpstr[0], tmpstr[2]) == 0)
-				tmpmodel->ArrLod[2] = tmpmodel->ArrLod[0];
+				tmpmodel->m_aLods[2] = tmpmodel->m_aLods[0];
 			else if (stricmp(tmpstr[1], tmpstr[2]) == 0)
-				tmpmodel->ArrLod[2] = tmpmodel->ArrLod[1];
+				tmpmodel->m_aLods[2] = tmpmodel->m_aLods[1];
 			else
 			{
-				tmpmodel->ArrLod[2] = new Lod();
-				tmpmodel->ArrLod[2]->path = tmpstr[2];
+				tmpmodel->m_aLods[2] = new CLod();
+				tmpmodel->m_aLods[2]->m_sPath = tmpstr[2];
 				sprintf(tmppath, "%s%s", Core_RStringGet(G_RI_STRING_PATH_GS_MESHES), tmpstr[2]);
-				SGCore_StaticModelLoad(tmppath, &tmpmodel->ArrLod[2]->model);
+				SGCore_StaticModelLoad(tmppath, &tmpmodel->m_aLods[2]->m_pModel);
 
-				for (int k = 0; k < tmpmodel->ArrLod[2]->model->m_uiSubsetCount; ++k)
+				for (int k = 0; k < tmpmodel->m_aLods[2]->m_pModel->m_uiSubsetCount; ++k)
 				{
-					sprintf(tmppathtex, "%s.dds", tmpmodel->ArrLod[1]->model->m_ppTextures[k]);
-					tmpmodel->ArrLod[2]->idstex[k] = SGCore_MtlLoad(tmppathtex, (tmpmodel->TypeGreen == GREEN_TYPE_TREE ? MTL_TYPE_TREE : MTL_TYPE_GRASS));
+					sprintf(tmppathtex, "%s.dds", tmpmodel->m_aLods[1]->m_pModel->m_ppTextures[k]);
+					tmpmodel->m_aLods[2]->m_aIDsTextures[k] = SGCore_MtlLoad(tmppathtex, (tmpmodel->m_typeGreen == GREEN_TYPE_TREE ? MTL_TYPE_TREE : MTL_TYPE_GRASS));
 				}
 			}
 		}
 
-		fread(&tmpmodel->BBMin.x, sizeof(float), 1, file);
-		fread(&tmpmodel->BBMin.y, sizeof(float), 1, file);
-		fread(&tmpmodel->BBMin.z, sizeof(float), 1, file);
+		fread(&tmpmodel->m_vMin.x, sizeof(float), 1, file);
+		fread(&tmpmodel->m_vMin.y, sizeof(float), 1, file);
+		fread(&tmpmodel->m_vMin.z, sizeof(float), 1, file);
 
-		fread(&tmpmodel->BBMax.x, sizeof(float), 1, file);
-		fread(&tmpmodel->BBMax.y, sizeof(float), 1, file);
-		fread(&tmpmodel->BBMax.z, sizeof(float), 1, file);
+		fread(&tmpmodel->m_vMax.x, sizeof(float), 1, file);
+		fread(&tmpmodel->m_vMax.y, sizeof(float), 1, file);
+		fread(&tmpmodel->m_vMax.z, sizeof(float), 1, file);
 
-		fread(&tmpmodel->AllCountGreen, sizeof(uint32_t), 1, file);
+		fread(&tmpmodel->m_uiCountObj, sizeof(uint32_t), 1, file);
 
-		Array<Segment**> queue;
-		long tmpcount = 0;
-		queue.push_back(&(tmpmodel->SplitsTree));
+		Array<CSegment**> queue;
+		int tmpcount = 0;
+		queue.push_back(&(tmpmodel->m_pSplitsTree));
 
 		while (queue.size())
 		{
-			LoadSplit(queue[0], file, &queue);
+			loadSplit(queue[0], file, &queue);
 
-			if ((*queue[0])->Data)
-				tmpmodel->AllCountGreen += (*queue[0])->CountAllGreen;
+			if ((*queue[0])->m_pObjData)
+				tmpmodel->m_uiCountObj += (*queue[0])->m_iCountObj;
 			queue.erase(0);
 			++tmpcount;
 		}
 
-		SetSplitID(tmpmodel);
+		setSplitID(tmpmodel);
 
-		ArrModels.push_back(tmpmodel);
-		AddModelInArrCom(ArrModels.size() - 1);
+		m_aGreens.push_back(tmpmodel);
+		addModelInArrCom(m_aGreens.size() - 1);
 
-		if (tmpmodel->NavigateMesh)
-			SetGreenNav(ArrModels.size() - 1, tmpmodel->NavigateMesh->pathname.c_str());
+		if (tmpmodel->m_pPhysMesh)
+			setGreenNav(m_aGreens.size() - 1, tmpmodel->m_pPhysMesh->m_sPathName.c_str());
 	}
 
 	fclose(file);
 }
 
-void Green::LoadSplit(Segment** Split, FILE* file, Array<Segment**> * queue)
+void CGreen::loadSplit(CSegment** Split, FILE* file, Array<CSegment**> * queue)
 {
-	(*Split) = new Segment();
+	(*Split) = new CSegment();
 	float3 jmin, jmax;
 	fread(&jmin.x, sizeof(float), 1, file);
 	fread(&jmin.y, sizeof(float), 1, file);
@@ -1440,8 +1446,8 @@ void Green::LoadSplit(Segment** Split, FILE* file, Array<Segment**> * queue)
 	fread(&jmax.y, sizeof(float), 1, file);
 	fread(&jmax.z, sizeof(float), 1, file);
 
-	(*Split)->BoundVolumeSys = SGCore_CrBound();
-	(*Split)->BoundVolumeSys->setMinMax(&jmin, &jmax);
+	(*Split)->m_pBoundVolumeSys = SGCore_CrBound();
+	(*Split)->m_pBoundVolumeSys->setMinMax(&jmin, &jmax);
 
 
 	fread(&jmin.x, sizeof(float), 1, file);
@@ -1452,12 +1458,12 @@ void Green::LoadSplit(Segment** Split, FILE* file, Array<Segment**> * queue)
 	fread(&jmax.y, sizeof(float), 1, file);
 	fread(&jmax.z, sizeof(float), 1, file);
 
-	(*Split)->BoundVolumeP = SGCore_CrBound();
-	(*Split)->BoundVolumeP->setMinMax(&jmin, &jmax);
+	(*Split)->m_pBoundVolumeP = SGCore_CrBound();
+	(*Split)->m_pBoundVolumeP->setMinMax(&jmin, &jmax);
 
-	fread(&(*Split)->CountAllGreen, sizeof(uint32_t), 1, file);
+	fread(&(*Split)->m_iCountObj, sizeof(uint32_t), 1, file);
 
-	fread(&(*Split)->BFNonEnd, sizeof(int8_t), 1, file);
+	fread(&(*Split)->m_idNonEnd, sizeof(int8_t), 1, file);
 
 	bool isexists = false;
 	fread(&isexists, sizeof(int8_t), 1, file);
@@ -1466,38 +1472,38 @@ void Green::LoadSplit(Segment** Split, FILE* file, Array<Segment**> * queue)
 	{
 		for (int i = 0; i<GREEN_COUNT_TYPE_SEGMENTATION; i++)
 		{
-			queue->push_back(&((*Split)->Splits[i]));
+			queue->push_back(&((*Split)->m_aSplits[i]));
 		}
 	}
 	else
 	{
-		if ((*Split)->CountAllGreen > 0)
+		if ((*Split)->m_iCountObj > 0)
 		{
-			(*Split)->Data = new GreenDataVertex[(*Split)->CountAllGreen];
+			(*Split)->m_pObjData = new CGreenDataVertex[(*Split)->m_iCountObj];
 
-			fread((*Split)->Data, sizeof(GreenDataVertex)*(*Split)->CountAllGreen, 1, file);
+			fread((*Split)->m_pObjData, sizeof(CGreenDataVertex)*(*Split)->m_iCountObj, 1, file);
 		}
 	}
 }
 
-ID Green::AddArrForCom()
+ID CGreen::addArrForCom()
 {
-	IRSData* ttmpdata = new IRSData();
-	for (long i = 0; i < ArrModels.size(); ++i)
+	CIRSData* ttmpdata = new CIRSData();
+	for (int i = 0; i < m_aGreens.size(); ++i)
 	{
-		InfoRenderSegments* tmpirs = new InfoRenderSegments();
-		tmpirs->Count = ArrModels[i]->SplitsIDs;
-		tmpirs->Arr = new Segment*[ArrModels[i]->SplitsIDs];
-		tmpirs->CountCom = 0;
-		ttmpdata->arr.push_back(tmpirs);
+		CInfoRenderSegments* tmpirs = new CInfoRenderSegments();
+		tmpirs->m_iCount = m_aGreens[i]->m_idCountSplits;
+		tmpirs->m_ppSegments = new CSegment*[m_aGreens[i]->m_idCountSplits];
+		tmpirs->m_iCountCom = 0;
+		ttmpdata->m_aIRS.push_back(tmpirs);
 	}
 
 	ID id_arr = -1;
-	for (long i = 0; i < ArrComFor.size(); ++i)
+	for (int i = 0; i < m_aArrComFor.size(); ++i)
 	{
-		if (ArrComFor[i] == 0)
+		if (m_aArrComFor[i] == 0)
 		{
-			ArrComFor[i] = ttmpdata;
+			m_aArrComFor[i] = ttmpdata;
 			id_arr = i;
 			break;
 		}
@@ -1505,219 +1511,219 @@ ID Green::AddArrForCom()
 
 	if (id_arr == -1)
 	{
-		ArrComFor.push_back(ttmpdata);
-		id_arr = ArrComFor.size() - 1;
+		m_aArrComFor.push_back(ttmpdata);
+		id_arr = m_aArrComFor.size() - 1;
 	}
 
 	return id_arr;
 }
 
-bool Green::existsArrForCom(ID id)
+bool CGreen::existsArrForCom(ID id)
 {
-	return (ArrComFor.size() > id);
+	return (m_aArrComFor.size() > id);
 }
 
-void Green::DelArrForCom(ID id_arr)
+void CGreen::deleteArrForCom(ID id_arr)
 {
 	GREEN_PRECOND_ARRCOMFOR_ERR_ID(id_arr);
 
-	mem_delete(ArrComFor[id_arr]);
+	mem_delete(m_aArrComFor[id_arr]);
 }
 
-void Green::AddModelInArrCom(ID id_model)
+void CGreen::addModelInArrCom(ID id_model)
 {
 	GREEN_PRECOND_ARRCOMFOR_ERR_ID_MODEL(id_model);
 	
-	for (long i = 0; i < ArrComFor.size(); ++i)
+	for (int i = 0; i < m_aArrComFor.size(); ++i)
 	{
-		InfoRenderSegments* tmpirs = new InfoRenderSegments();
-		tmpirs->Count = ArrModels[id_model]->SplitsIDs;
-		tmpirs->Arr = new Segment*[ArrModels[id_model]->SplitsIDs];
-		tmpirs->CountCom = 0;
-		ArrComFor[i]->arr.push_back(tmpirs);
+		CInfoRenderSegments* tmpirs = new CInfoRenderSegments();
+		tmpirs->m_iCount = m_aGreens[id_model]->m_idCountSplits;
+		tmpirs->m_ppSegments = new CSegment*[m_aGreens[id_model]->m_idCountSplits];
+		tmpirs->m_iCountCom = 0;
+		m_aArrComFor[i]->m_aIRS.push_back(tmpirs);
 	}
 }
 
-void Green::DelModelInArrCom(ID id_model)
+void CGreen::deleteModelInArrCom(ID id_model)
 {
 	GREEN_PRECOND_ARRCOMFOR_ERR_ID_MODEL(id_model);
 
-	for (int i = 0; i < ArrComFor.size(); ++i)
+	for (int i = 0; i < m_aArrComFor.size(); ++i)
 	{
-		if (!(ArrComFor[i]))
+		if (!(m_aArrComFor[i]))
 			continue;
 
-		mem_delete(ArrComFor[i]->arr[id_model]);
-		ArrComFor[i]->arr.erase(id_model);
+		mem_delete(m_aArrComFor[i]->m_aIRS[id_model]);
+		m_aArrComFor[i]->m_aIRS.erase(id_model);
 	}
 }
 
-ID Green::GetCountGreen()
+ID CGreen::getCountGreen()
 {
-	return ArrModels.size();
+	return m_aGreens.size();
 }
 
-char* Green::GetGreenName(ID id)
+char* CGreen::getGreenName(ID id)
 {
-	if (id < ArrModels.size())
-		return ArrModels[id]->Name;
+	if (id < m_aGreens.size())
+		return m_aGreens[id]->m_szName;
 
 	return 0;
 }
 
-long Green::GetGreenCountGen(ID id)
+int CGreen::getGreenCountGen(ID id)
 {
-	if (id < ArrModels.size())
-		return ArrModels[id]->AllCountGreen;
+	if (id < m_aGreens.size())
+		return m_aGreens[id]->m_uiCountObj;
 
 	return -1;
 }
 
-long Green::GetGreenCountPoly(ID id)
+int CGreen::getGreenCountPoly(ID id)
 {
-	if (id < ArrModels.size() && ArrModels[id]->ArrLod[0])
-		return ArrModels[id]->ArrLod[0]->model->m_uiAllIndexCount / 3;
+	if (id < m_aGreens.size() && m_aGreens[id]->m_aLods[0])
+		return m_aGreens[id]->m_aLods[0]->m_pModel->m_uiAllIndexCount / 3;
 
 	return -1;
 }
 
-int Green::GetGreenTypeCountGen(ID id)
+int CGreen::getGreenTypeCountGen(ID id)
 {
-	if (id < ArrModels.size())
-		return ArrModels[id]->TypeGreen;
+	if (id < m_aGreens.size())
+		return m_aGreens[id]->m_typeGreen;
 
 	return -1;
 }
 
-const char* Green::GetGreenModel(ID id)
+const char* CGreen::getGreenModel(ID id)
 {
-	if (id < ArrModels.size())
-		return ArrModels[id]->ArrLod[0]->path.c_str();
+	if (id < m_aGreens.size())
+		return m_aGreens[id]->m_aLods[0]->m_sPath.c_str();
 
 	return 0;
 }
 
-const char* Green::GetGreenLod1(ID id)
+const char* CGreen::getGreenLod1(ID id)
 {
-	if (id < ArrModels.size() && ArrModels[id]->ArrLod[1])
-		return ArrModels[id]->ArrLod[1]->path.c_str();
+	if (id < m_aGreens.size() && m_aGreens[id]->m_aLods[1])
+		return m_aGreens[id]->m_aLods[1]->m_sPath.c_str();
 
 	return 0;
 }
 
-const char* Green::GetGreenLod2(ID id)
+const char* CGreen::getGreenLod2(ID id)
 {
-	if (id < ArrModels.size() && ArrModels[id]->ArrLod[2])
-		return ArrModels[id]->ArrLod[2]->path.c_str();
+	if (id < m_aGreens.size() && m_aGreens[id]->m_aLods[2])
+		return m_aGreens[id]->m_aLods[2]->m_sPath.c_str();
 
 	return 0;
 }
 
-const char* Green::GetGreenMask(ID id)
+const char* CGreen::getGreenMask(ID id)
 {
-	if (id < ArrModels.size())
-		return ArrModels[id]->MaskName.c_str();
+	if (id < m_aGreens.size())
+		return m_aGreens[id]->m_szMaskName.c_str();
 
 	return 0;
 }
 
-const char* Green::GetGreenNav(ID id)
+const char* CGreen::getGreenNav(ID id)
 {
-	if (id < ArrModels.size() && ArrModels[id]->NavigateMesh)
-		return ArrModels[id]->NavigateMesh->pathname.c_str();
+	if (id < m_aGreens.size() && m_aGreens[id]->m_pPhysMesh)
+		return m_aGreens[id]->m_pPhysMesh->m_sPathName.c_str();
 
 	return 0;
 }
 
-void Green::DelGreen(ID id)
+void CGreen::deleteGreen(ID id)
 {
-	if (id >= 0 && id < ArrModels.size())
+	if (id >= 0 && id < m_aGreens.size())
 	{
-		DelModelInArrCom(id);
-		mem_delete(ArrModels[id]);
-		ArrModels.erase(id);
+		deleteModelInArrCom(id);
+		mem_delete(m_aGreens[id]);
+		m_aGreens.erase(id);
 	}
 }
 
-void Green::Clear()
+void CGreen::clear()
 {
-	while(ArrModels.size() > 0)
+	while(m_aGreens.size() > 0)
 	{
-		DelModelInArrCom(0);
-		mem_delete(ArrModels[0]);
-		ArrModels.erase(0);
+		deleteModelInArrCom(0);
+		mem_delete(m_aGreens[0]);
+		m_aGreens.erase(0);
 	}
 
-	while (ArrComFor.size() > 2)
+	while (m_aArrComFor.size() > 2)
 	{
-		mem_delete(ArrComFor[2]);
-		ArrComFor.erase(2);
+		mem_delete(m_aArrComFor[2]);
+		m_aArrComFor.erase(2);
 	}
 }
 
-void Green::SetGreenLod(ID id, int lod, const char* pathname)
+void CGreen::setGreenLod(ID id, int lod, const char* pathname)
 {
-	if (!(lod >= 0 && lod < GREEN_COUNT_LOD && id >= 0 && id < ArrModels.size()))
+	if (!(lod >= 0 && lod < GREEN_COUNT_LOD && id >= 0 && id < m_aGreens.size()))
 		return;
 
 	bool isunic = true;
 
 	for (int i = 0; i < GREEN_COUNT_LOD; ++i)
 	{
-		if (ArrModels[id]->ArrLod[i] == ArrModels[id]->ArrLod[lod])
+		if (m_aGreens[id]->m_aLods[i] == m_aGreens[id]->m_aLods[lod])
 			isunic = false;
 	}
 
 	if (isunic)
-		mem_delete(ArrModels[id]->ArrLod[lod]);
+		mem_delete(m_aGreens[id]->m_aLods[lod]);
 
 	char tmppath[1024];
-	ArrModels[id]->ArrLod[lod] = new Lod();
-	ArrModels[id]->ArrLod[lod]->path = pathname;
+	m_aGreens[id]->m_aLods[lod] = new CLod();
+	m_aGreens[id]->m_aLods[lod]->m_sPath = pathname;
 	sprintf(tmppath, "%s%s", Core_RStringGet(G_RI_STRING_PATH_GS_MESHES), pathname);
-	SGCore_StaticModelLoad(tmppath, &ArrModels[id]->ArrLod[lod]->model);
+	SGCore_StaticModelLoad(tmppath, &m_aGreens[id]->m_aLods[lod]->m_pModel);
 
-	for (int k = 0; k < ArrModels[id]->ArrLod[lod]->model->m_uiSubsetCount; ++k)
+	for (int k = 0; k < m_aGreens[id]->m_aLods[lod]->m_pModel->m_uiSubsetCount; ++k)
 	{
-		sprintf(tmppath, "%s.dds", ArrModels[id]->ArrLod[lod]->model->m_ppTextures[k]);
-		ArrModels[id]->ArrLod[lod]->idstex[k] = SGCore_MtlLoad(tmppath, (ArrModels[id]->TypeGreen == GREEN_TYPE_TREE ? MTL_TYPE_TREE : MTL_TYPE_GRASS));
+		sprintf(tmppath, "%s.dds", m_aGreens[id]->m_aLods[lod]->m_pModel->m_ppTextures[k]);
+		m_aGreens[id]->m_aLods[lod]->m_aIDsTextures[k] = SGCore_MtlLoad(tmppath, (m_aGreens[id]->m_typeGreen == GREEN_TYPE_TREE ? MTL_TYPE_TREE : MTL_TYPE_GRASS));
 	}
 }
 
-void Green::SetGreenNav(ID id, const char* pathname)
+void CGreen::setGreenNav(ID id, const char* pathname)
 {
-	if (!(id >= 0 && id < ArrModels.size()))
+	if (!(id >= 0 && id < m_aGreens.size()))
 		return;
 
 	char tmpstr[1024];
 	sprintf(tmpstr, "%s", pathname);
 
-	mem_delete(ArrModels[id]->NavigateMesh);
-	ArrModels[id]->NavigateMesh = new Model::NavMesh();
+	mem_delete(m_aGreens[id]->m_pPhysMesh);
+	m_aGreens[id]->m_pPhysMesh = new CModel::CPhysMesh();
 
 	char tmppath[1024];
 	sprintf(tmppath, "%s%s", Core_RStringGet(G_RI_STRING_PATH_GS_MESHES), tmpstr);
-	ArrModels[id]->NavigateMesh->pathname = tmpstr;
+	m_aGreens[id]->m_pPhysMesh->m_sPathName = tmpstr;
 
 	ISXDataStaticModel* nmesh;
 	SGCore_StaticModelLoad(tmppath, &nmesh);
-	ArrModels[id]->NavigateMesh->count_vertex = nmesh->m_uiAllVertexCount;
-	ArrModels[id]->NavigateMesh->count_index = nmesh->m_uiAllIndexCount;
-	ArrModels[id]->NavigateMesh->arr_vertex = new float3_t[nmesh->m_uiAllVertexCount];
+	m_aGreens[id]->m_pPhysMesh->m_iCountVertex = nmesh->m_uiAllVertexCount;
+	m_aGreens[id]->m_pPhysMesh->m_iCountIndex = nmesh->m_uiAllIndexCount;
+	m_aGreens[id]->m_pPhysMesh->m_pArrVertex = new float3_t[nmesh->m_uiAllVertexCount];
 	vertex_static *pVert;
 	nmesh->m_pVertexBuffer->Lock(0, 0, (void **)&pVert, 0);
-	for (long i = 0; i < nmesh->m_uiAllVertexCount; ++i)
+	for (int i = 0; i < nmesh->m_uiAllVertexCount; ++i)
 	{
-		ArrModels[id]->NavigateMesh->arr_vertex[i] = pVert[i].Pos;
+		m_aGreens[id]->m_pPhysMesh->m_pArrVertex[i] = pVert[i].Pos;
 	}
 	nmesh->m_pVertexBuffer->Unlock();
 	
-	ArrModels[id]->NavigateMesh->arr_index = new uint32_t[nmesh->m_uiAllIndexCount];
-	ArrModels[id]->NavigateMesh->arr_mtl = new ID[nmesh->m_uiAllIndexCount];
+	m_aGreens[id]->m_pPhysMesh->m_pArrIndex = new uint32_t[nmesh->m_uiAllIndexCount];
+	m_aGreens[id]->m_pPhysMesh->m_pArrMtl = new ID[nmesh->m_uiAllIndexCount];
 	UINT* pInd;
 	nmesh->m_pIndexBuffer->Lock(0, 0, (void **)&pInd, 0);
 	DWORD prebias = 0;
-	long tmp_countindex = 0;
+	int tmp_countindex = 0;
 	char tmpnametex[SXGC_LOADTEX_MAX_SIZE_DIRNAME];
 	for (int i = 0; i < nmesh->m_uiSubsetCount; ++i)
 	{
@@ -1725,8 +1731,8 @@ void Green::SetGreenNav(ID id, const char* pathname)
 		ID tmpidmtl = SGCore_MtlLoad(tmpnametex, MTL_TYPE_TREE);
 		for (int k = 0; k < nmesh->m_pIndexCount[i]; ++k)
 		{
-			ArrModels[id]->NavigateMesh->arr_index[tmp_countindex] = pInd[nmesh->m_pStartIndex[i] + k] /*+ prebias*/;
-			ArrModels[id]->NavigateMesh->arr_mtl[tmp_countindex] = tmpidmtl;
+			m_aGreens[id]->m_pPhysMesh->m_pArrIndex[tmp_countindex] = pInd[nmesh->m_pStartIndex[i] + k] /*+ prebias*/;
+			m_aGreens[id]->m_pPhysMesh->m_pArrMtl[tmp_countindex] = tmpidmtl;
 			++tmp_countindex;
 		}
 		prebias += nmesh->m_pIndexCount[i];
@@ -1735,50 +1741,50 @@ void Green::SetGreenNav(ID id, const char* pathname)
 	mem_release_del(nmesh);
 }
 
-void Green::GetNavMeshAndTransform(float3_t*** arr_vertex, int32_t** arr_count_vertex, uint32_t*** arr_index, ID*** arr_mtl, int32_t** arr_count_index, GreenDataVertex*** arr_transform, int32_t** arr_count_transform, int32_t* arr_count_green)
+void CGreen::getNavMeshAndTransform(float3_t*** arr_vertex, int32_t** arr_count_vertex, uint32_t*** arr_index, ID*** arr_mtl, int32_t** arr_count_index, CGreenDataVertex*** arr_transform, int32_t** arr_count_transform, int32_t* arr_count_green)
 {
-	if (ArrModels.size() <= 0)
+	if (m_aGreens.size() <= 0)
 		return;
 
 	int count_green = 0;
 
-	for (int id = 0; id < ArrModels.size(); ++id)
+	for (int id = 0; id < m_aGreens.size(); ++id)
 	{
-		if (!(ArrModels[id]->NavigateMesh))
+		if (!(m_aGreens[id]->m_pPhysMesh))
 			continue;
 
-		Array<Segment*> queue;
-		long tmpcount = 0;
-		queue.push_back(ArrModels[id]->SplitsTree);
+		Array<CSegment*> queue;
+		int tmpcount = 0;
+		queue.push_back(m_aGreens[id]->m_pSplitsTree);
 
-		ArrModels[id]->AllCountGreen = 0;
+		m_aGreens[id]->m_uiCountObj = 0;
 
 		while (queue.size())
 		{
-			if (!(queue[0]->Splits[0]) && queue[0]->Data && queue[0]->CountAllGreen > 0)
+			if (!(queue[0]->m_aSplits[0]) && queue[0]->m_pObjData && queue[0]->m_iCountObj > 0)
 			{
-				int AllCountGreen = ArrModels[id]->AllCountGreen;
-				int CountAllGreen = queue[0]->CountAllGreen;
-				GreenDataVertex* tmpdv = new GreenDataVertex[ArrModels[id]->AllCountGreen + queue[0]->CountAllGreen];
-				if (ArrModels[id]->AllTrans)
-					memcpy(tmpdv, ArrModels[id]->AllTrans, sizeof(GreenDataVertex)* ArrModels[id]->AllCountGreen);
-				memcpy(tmpdv + ArrModels[id]->AllCountGreen, queue[0]->Data, sizeof(GreenDataVertex)* queue[0]->CountAllGreen);
-				mem_delete_a(ArrModels[id]->AllTrans);
-				ArrModels[id]->AllTrans = tmpdv;
-				ArrModels[id]->AllCountGreen += queue[0]->CountAllGreen;
+				int m_uiCountObj = m_aGreens[id]->m_uiCountObj;
+				int CountAllGreen = queue[0]->m_iCountObj;
+				CGreenDataVertex* tmpdv = new CGreenDataVertex[m_aGreens[id]->m_uiCountObj + queue[0]->m_iCountObj];
+				if (m_aGreens[id]->m_pAllTrans)
+					memcpy(tmpdv, m_aGreens[id]->m_pAllTrans, sizeof(CGreenDataVertex)* m_aGreens[id]->m_uiCountObj);
+				memcpy(tmpdv + m_aGreens[id]->m_uiCountObj, queue[0]->m_pObjData, sizeof(CGreenDataVertex)* queue[0]->m_iCountObj);
+				mem_delete_a(m_aGreens[id]->m_pAllTrans);
+				m_aGreens[id]->m_pAllTrans = tmpdv;
+				m_aGreens[id]->m_uiCountObj += queue[0]->m_iCountObj;
 			}
 
 			for (int i = 0; i < GREEN_COUNT_TYPE_SEGMENTATION; ++i)
 			{
-				if (queue[0]->Splits[i])
-					queue.push_back(queue[0]->Splits[i]);
+				if (queue[0]->m_aSplits[i])
+					queue.push_back(queue[0]->m_aSplits[i]);
 			}
 
 			queue.erase(0);
 			++tmpcount;
 		}
 
-		if (ArrModels[id]->AllTrans)
+		if (m_aGreens[id]->m_pAllTrans)
 			++count_green;
 	}
 
@@ -1794,57 +1800,57 @@ void Green::GetNavMeshAndTransform(float3_t*** arr_vertex, int32_t** arr_count_v
 	(*arr_mtl) = new ID*[count_green];
 	(*arr_count_index) = new int32_t[count_green];
 
-	(*arr_transform) = new GreenDataVertex*[count_green];
+	(*arr_transform) = new CGreenDataVertex*[count_green];
 	(*arr_count_transform) = new int32_t[count_green];
 
 	int curr_model = 0;
 
-	for (int i = 0; i < ArrModels.size(); ++i)
+	for (int i = 0; i < m_aGreens.size(); ++i)
 	{
-		if (!(ArrModels[i]->NavigateMesh))
+		if (!(m_aGreens[i]->m_pPhysMesh))
 			continue;
 
-		(*arr_vertex)[curr_model] = new float3_t[ArrModels[i]->NavigateMesh->count_vertex];
-		memcpy((*arr_vertex)[curr_model], ArrModels[i]->NavigateMesh->arr_vertex, sizeof(float3_t)* ArrModels[i]->NavigateMesh->count_vertex);
-		(*arr_count_vertex)[curr_model] = ArrModels[i]->NavigateMesh->count_vertex;
+		(*arr_vertex)[curr_model] = new float3_t[m_aGreens[i]->m_pPhysMesh->m_iCountVertex];
+		memcpy((*arr_vertex)[curr_model], m_aGreens[i]->m_pPhysMesh->m_pArrVertex, sizeof(float3_t)* m_aGreens[i]->m_pPhysMesh->m_iCountVertex);
+		(*arr_count_vertex)[curr_model] = m_aGreens[i]->m_pPhysMesh->m_iCountVertex;
 
-		(*arr_index)[curr_model] = new uint32_t[ArrModels[i]->NavigateMesh->count_index];
-		memcpy((*arr_index)[curr_model], ArrModels[i]->NavigateMesh->arr_index, sizeof(uint32_t)* ArrModels[i]->NavigateMesh->count_index);
-		(*arr_mtl)[curr_model] = new ID[ArrModels[i]->NavigateMesh->count_index];
-		memcpy((*arr_mtl)[curr_model], ArrModels[i]->NavigateMesh->arr_mtl, sizeof(ID)* ArrModels[i]->NavigateMesh->count_index);
-		(*arr_count_index)[curr_model] = ArrModels[i]->NavigateMesh->count_index;
+		(*arr_index)[curr_model] = new uint32_t[m_aGreens[i]->m_pPhysMesh->m_iCountIndex];
+		memcpy((*arr_index)[curr_model], m_aGreens[i]->m_pPhysMesh->m_pArrIndex, sizeof(uint32_t)* m_aGreens[i]->m_pPhysMesh->m_iCountIndex);
+		(*arr_mtl)[curr_model] = new ID[m_aGreens[i]->m_pPhysMesh->m_iCountIndex];
+		memcpy((*arr_mtl)[curr_model], m_aGreens[i]->m_pPhysMesh->m_pArrMtl, sizeof(ID)* m_aGreens[i]->m_pPhysMesh->m_iCountIndex);
+		(*arr_count_index)[curr_model] = m_aGreens[i]->m_pPhysMesh->m_iCountIndex;
 
-		(*arr_transform)[curr_model] = new GreenDataVertex[ArrModels[i]->AllCountGreen];
-		(*arr_count_transform)[curr_model] = ArrModels[i]->AllCountGreen;
-		for (long k = 0; k < ArrModels[i]->AllCountGreen; ++k)
+		(*arr_transform)[curr_model] = new CGreenDataVertex[m_aGreens[i]->m_uiCountObj];
+		(*arr_count_transform)[curr_model] = m_aGreens[i]->m_uiCountObj;
+		for (int k = 0; k < m_aGreens[i]->m_uiCountObj; ++k)
 		{
-			(*arr_transform)[curr_model][k] = ArrModels[i]->AllTrans[k];// SMMatrixScaling(float3(ArrModels[i]->AllTrans[k].TexCoord.x, ArrModels[i]->AllTrans[k].TexCoord.x, ArrModels[i]->AllTrans[k].TexCoord.x)) * SMMatrixRotationY(ArrModels[i]->AllTrans[k].TexCoord.y) * SMMatrixTranslation(ArrModels[i]->AllTrans[k].Position);
+			(*arr_transform)[curr_model][k] = m_aGreens[i]->m_pAllTrans[k];// SMMatrixScaling(float3(m_aGreens[i]->m_pAllTrans[k].TexCoord.x, m_aGreens[i]->m_pAllTrans[k].TexCoord.x, m_aGreens[i]->m_pAllTrans[k].TexCoord.x)) * SMMatrixRotationY(m_aGreens[i]->m_pAllTrans[k].TexCoord.y) * SMMatrixTranslation(m_aGreens[i]->m_pAllTrans[k].Position);
 		}
 
 		++curr_model;
 	}
 
-	for (int id = 0; id < ArrModels.size(); ++id)
+	for (int id = 0; id < m_aGreens.size(); ++id)
 	{
-		mem_delete_a(ArrModels[id]->AllTrans);
+		mem_delete_a(m_aGreens[id]->m_pAllTrans);
 	}
 }
 
-void Green::GetPartBeam(float3* pos, float3 * dir, Segment** arrsplits, DWORD *count, Segment* comsegment, ID curr_splits_ids_render)
+void CGreen::getPartBeam(const float3* pos, const float3 * dir, CSegment** arrsplits, int *count, CSegment* comsegment, ID curr_splits_ids_render)
 {
 	float3 center;
 	float radius;
-	comsegment->BoundVolumeP->getSphere(&center, &radius);
+	comsegment->m_pBoundVolumeP->getSphere(&center, &radius);
 
 	float distsqr = SGCore_0DistancePointBeam2(center, *pos, *dir);
-	if (comsegment->CountAllGreen > 0 && distsqr <= radius*radius)
+	if (comsegment->m_iCountObj > 0 && distsqr <= radius*radius)
 	{
-		if (comsegment->BFNonEnd)
+		if (comsegment->m_idNonEnd)
 		{
 			for (int j = 0; j<GREEN_COUNT_TYPE_SEGMENTATION; ++j)
 			{
-				if (comsegment->Splits[j])
-					GetPartBeam(pos, dir, arrsplits, count, comsegment->Splits[j], curr_splits_ids_render);
+				if (comsegment->m_aSplits[j])
+					getPartBeam(pos, dir, arrsplits, count, comsegment->m_aSplits[j], curr_splits_ids_render);
 			}
 		}
 		else
@@ -1859,9 +1865,9 @@ void Green::GetPartBeam(float3* pos, float3 * dir, Segment** arrsplits, DWORD *c
 	}
 }
 
-bool Green::TraceBeam(float3* start, float3* dir, float3* _res, ID* idgreen, ID* idsplits, ID* idobj, ID* idmtl)
+bool CGreen::traceBeam(const float3* start, const float3* dir, float3* _res, ID* idgreen, ID* idsplits, ID* idobj, ID* idmtl)
 {
-	if (ArrModels.size() <= 0)
+	if (m_aGreens.size() <= 0)
 		return false;
 
 	SXTriangle tmptri;
@@ -1873,37 +1879,37 @@ bool Green::TraceBeam(float3* start, float3* dir, float3* _res, ID* idgreen, ID*
 	res = (*start) + float3(10000.0f, 10000.0f, 10000.0f);
 	il = (*dir) * 10000.0f;
 	bool found = false;
-	InfoRenderSegments* irs = 0;
-	Model* model = 0;
+	CInfoRenderSegments* irs = 0;
+	CModel* model = 0;
 	float4x4 mat;
 
-	for (int id = 0; id < ArrModels.size(); ++id)
+	for (int id = 0; id < m_aGreens.size(); ++id)
 	{
-		model = ArrModels[id];
-		irs = ArrComFor[1]->arr[id];
-		irs->CountCom = 0;
+		model = m_aGreens[id];
+		irs = m_aArrComFor[1]->m_aIRS[id];
+		irs->m_iCountCom = 0;
 
-		GetPartBeam(start, dir, irs->Arr, &(irs->CountCom), model->SplitsTree, irs->Count);
+		getPartBeam(start, dir, irs->m_ppSegments, &(irs->m_iCountCom), model->m_pSplitsTree, irs->m_iCount);
 
 		vertex_static* pVertData = 0;
-		if (FAILED(model->ArrLod[0]->model->m_pVertexBuffer->Lock(0, 0, (void**)&pVertData, 0)))
+		if (FAILED(model->m_aLods[0]->m_pModel->m_pVertexBuffer->Lock(0, 0, (void**)&pVertData, 0)))
 			continue;
 
 		DWORD* pIndData = 0;
-		if (FAILED(model->ArrLod[0]->model->m_pIndexBuffer->Lock(0, 0, (void**)&pIndData, 0)))
+		if (FAILED(model->m_aLods[0]->m_pModel->m_pIndexBuffer->Lock(0, 0, (void**)&pIndData, 0)))
 			continue;
 
-		for (int k = 0; k < irs->CountCom; ++k)
+		for (int k = 0; k < irs->m_iCountCom; ++k)
 		{
-			for (int key = 0; key < irs->Arr[k]->CountAllGreen; ++key)
+			for (int key = 0; key < irs->m_ppSegments[k]->m_iCountObj; ++key)
 			{
 				UINT tmpcountind = 0;
-				for (int g = 0; g < model->ArrLod[0]->model->m_uiSubsetCount; ++g)
+				for (int g = 0; g < model->m_aLods[0]->m_pModel->m_uiSubsetCount; ++g)
 				{
-					for (int poly = 0; poly < model->ArrLod[0]->model->m_pIndexCount[g] / 3; ++poly)
+					for (int poly = 0; poly < model->m_aLods[0]->m_pModel->m_pIndexCount[g] / 3; ++poly)
 					{
-						float tmpscale = irs->Arr[k]->Data[key].m_vTexCoord.x;
-						mat = SMMatrixScaling(tmpscale, tmpscale, tmpscale) * SMMatrixRotationY(irs->Arr[k]->Data[key].m_vTexCoord.y) * SMMatrixTranslation(irs->Arr[k]->Data[key].m_vPosition);
+						float tmpscale = irs->m_ppSegments[k]->m_pObjData[key].m_vTexCoord.x;
+						mat = SMMatrixScaling(tmpscale, tmpscale, tmpscale) * SMMatrixRotationY(irs->m_ppSegments[k]->m_pObjData[key].m_vTexCoord.y) * SMMatrixTranslation(irs->m_ppSegments[k]->m_pObjData[key].m_vPosition);
 
 						tmptri.a = SMVector3Transform(pVertData[pIndData[poly]].Pos, mat);
 						tmptri.b = SMVector3Transform(pVertData[pIndData[poly + 1]].Pos, mat);
@@ -1920,24 +1926,24 @@ bool Green::TraceBeam(float3* start, float3* dir, float3* _res, ID* idgreen, ID*
 									*idgreen = id;
 
 								if (idsplits)
-									*idsplits = irs->Arr[k]->Id;
+									*idsplits = irs->m_ppSegments[k]->m_id;
 
 								if (idobj)
 									*idobj = key;
 
 								if (idmtl)
-									*idmtl = model->ArrLod[0]->idstex[g];
+									*idmtl = model->m_aLods[0]->m_aIDsTextures[g];
 							}
 						}
 					}
 
-					tmpcountind += model->ArrLod[0]->model->m_uiSubsetCount;
+					tmpcountind += model->m_aLods[0]->m_pModel->m_uiSubsetCount;
 				}
 			}
 		}
 
-		model->ArrLod[0]->model->m_pVertexBuffer->Unlock();
-		model->ArrLod[0]->model->m_pIndexBuffer->Unlock();
+		model->m_aLods[0]->m_pModel->m_pVertexBuffer->Unlock();
+		model->m_aLods[0]->m_pModel->m_pIndexBuffer->Unlock();
 	}
 
 	if (found && _res)
@@ -1946,20 +1952,20 @@ bool Green::TraceBeam(float3* start, float3* dir, float3* _res, ID* idgreen, ID*
 	return found;
 }
 
-void Green::GetPartBB(float3* bbmin, float3 * bbmax, Segment** arrsplits, DWORD *count, Segment* comsegment, ID curr_splits_ids_render)
+void CGreen::getPartBB(float3* bbmin, float3 * bbmax, CSegment** arrsplits, int *count, CSegment* comsegment, ID curr_splits_ids_render)
 {
 	float3 min,max;
 	float radius;
-	comsegment->BoundVolumeP->getMinMax(&min, &max);
+	comsegment->m_pBoundVolumeP->getMinMax(&min, &max);
 
-	if (comsegment->CountAllGreen > 0 && SGCore_0InretsectBox(bbmin, bbmax, &min, &max))
+	if (comsegment->m_iCountObj > 0 && SGCore_0InretsectBox(bbmin, bbmax, &min, &max))
 	{
-		if (comsegment->BFNonEnd)
+		if (comsegment->m_idNonEnd)
 		{
 			for (int j = 0; j<GREEN_COUNT_TYPE_SEGMENTATION; ++j)
 			{
-				if (comsegment->Splits[j])
-					GetPartBB(bbmin, bbmax, arrsplits, count, comsegment->Splits[j], curr_splits_ids_render);
+				if (comsegment->m_aSplits[j])
+					getPartBB(bbmin, bbmax, arrsplits, count, comsegment->m_aSplits[j], curr_splits_ids_render);
 			}
 		}
 		else
@@ -1974,49 +1980,49 @@ void Green::GetPartBB(float3* bbmin, float3 * bbmax, Segment** arrsplits, DWORD
 	}
 }
 
-bool Green::GetOccurencessLeafGrass(float3* bbmin, float3* bbmax, int physic_mtl)
+bool CGreen::getOccurencessLeafGrass(float3* bbmin, float3* bbmax, int physic_mtl)
 {
-	if (ArrModels.size() <= 0)
+	if (m_aGreens.size() <= 0)
 		return false;
 
 	bool isfound = false;
-	InfoRenderSegments* irs = 0;
-	Model* model = 0;
+	CInfoRenderSegments* irs = 0;
+	CModel* model = 0;
 	float3 p1, p2, p3, min, max;
 	float4x4 mat;
 
-	for (int id = 0; id < ArrModels.size() && !isfound; ++id)
+	for (int id = 0; id < m_aGreens.size() && !isfound; ++id)
 	{
-		model = ArrModels[id];
-		irs = ArrComFor[1]->arr[id];
-		irs->CountCom = 0;
+		model = m_aGreens[id];
+		irs = m_aArrComFor[1]->m_aIRS[id];
+		irs->m_iCountCom = 0;
 
-		GetPartBB(bbmin, bbmax, irs->Arr, &(irs->CountCom), model->SplitsTree, irs->Count);
+		getPartBB(bbmin, bbmax, irs->m_ppSegments, &(irs->m_iCountCom), model->m_pSplitsTree, irs->m_iCount);
 
 		vertex_static* pVertData = 0;
-		if (FAILED(model->ArrLod[0]->model->m_pVertexBuffer->Lock(0, 0, (void**)&pVertData, 0)))
+		if (FAILED(model->m_aLods[0]->m_pModel->m_pVertexBuffer->Lock(0, 0, (void**)&pVertData, 0)))
 			continue;
 
 		DWORD* pIndData = 0;
-		if (FAILED(model->ArrLod[0]->model->m_pIndexBuffer->Lock(0, 0, (void**)&pIndData, 0)))
+		if (FAILED(model->m_aLods[0]->m_pModel->m_pIndexBuffer->Lock(0, 0, (void**)&pIndData, 0)))
 			continue;
 
-		for (int g = 0; g < model->ArrLod[0]->model->m_uiSubsetCount && !isfound; ++g)
+		for (int g = 0; g < model->m_aLods[0]->m_pModel->m_uiSubsetCount && !isfound; ++g)
 		{
-			int pt = SGCore_MtlGetPhysicType(model->ArrLod[0]->idstex[g]);
-			if (SGCore_MtlGetPhysicType(model->ArrLod[0]->idstex[g]) != physic_mtl)
+			int pt = SGCore_MtlGetPhysicType(model->m_aLods[0]->m_aIDsTextures[g]);
+			if (SGCore_MtlGetPhysicType(model->m_aLods[0]->m_aIDsTextures[g]) != physic_mtl)
 				continue;
 
-			for (int k = 0; k < irs->CountCom && !isfound; ++k)
+			for (int k = 0; k < irs->m_iCountCom && !isfound; ++k)
 			{
-				for (int key = 0; key < irs->Arr[k]->CountAllGreen && !isfound; ++key)
+				for (int key = 0; key < irs->m_ppSegments[k]->m_iCountObj && !isfound; ++key)
 				{
 
 
-					for (int poly = 0; poly < model->ArrLod[0]->model->m_pIndexCount[g] / 3 && !isfound; ++poly)
+					for (int poly = 0; poly < model->m_aLods[0]->m_pModel->m_pIndexCount[g] / 3 && !isfound; ++poly)
 					{
-						float tmpscale = irs->Arr[k]->Data[key].m_vTexCoord.x;
-						mat = SMMatrixScaling(tmpscale, tmpscale, tmpscale) * SMMatrixRotationY(irs->Arr[k]->Data[key].m_vTexCoord.y) * SMMatrixTranslation(irs->Arr[k]->Data[key].m_vPosition);
+						float tmpscale = irs->m_ppSegments[k]->m_pObjData[key].m_vTexCoord.x;
+						mat = SMMatrixScaling(tmpscale, tmpscale, tmpscale) * SMMatrixRotationY(irs->m_ppSegments[k]->m_pObjData[key].m_vTexCoord.y) * SMMatrixTranslation(irs->m_ppSegments[k]->m_pObjData[key].m_vPosition);
 
 						p1 = SMVector3Transform(pVertData[pIndData[poly]].Pos, mat);
 						p2 = SMVector3Transform(pVertData[pIndData[poly + 1]].Pos, mat);
@@ -2063,8 +2069,8 @@ bool Green::GetOccurencessLeafGrass(float3* bbmin, float3* bbmax, int physic_mtl
 			}
 		}
 
-		model->ArrLod[0]->model->m_pVertexBuffer->Unlock();
-		model->ArrLod[0]->model->m_pIndexBuffer->Unlock();
+		model->m_aLods[0]->m_pModel->m_pVertexBuffer->Unlock();
+		model->m_aLods[0]->m_pModel->m_pIndexBuffer->Unlock();
 	}
 
 	return isfound;
diff --git a/source/geom/green.h b/source/geom/green.h
index 5bc914a6b6b18ebb061833261f4bdc5798126bed..3d006558e0b593e4db0e07242d70be74e7b25735 100644
--- a/source/geom/green.h
+++ b/source/geom/green.h
@@ -17,204 +17,306 @@ See the license in LICENSE
 #include "static_geom.h"
 #include "sxgeom.h"
 
-#define GREEN_COUNT_TYPE_SEGMENTATION 4
-#define GREEN_COUNT_LOD 3
-
-#define GREEN_DEFAULT_RESERVE_GEN 1024
-#define GREEN_DEFAULT_RESERVE_COM 1024
+//##########################################################################
 
 #define GREEN_PRECOND_ARRCOMFOR_ERR_ID(id_arr) \
-if (!(id_arr < ArrComFor.size()))\
+if (!(id_arr < m_aArrComFor.size()))\
 {\
 	LibReport(REPORT_MSG_LEVEL_ERROR, "%s - green: unresolved id '%d' for array of compute visible", GEN_MSG_LOCATION, id_arr); \
 }
 
 #define GREEN_PRECOND_ARRCOMFOR_ERR_ID_MODEL(id_model) \
-if (!(id_model < ArrModels.size() && ArrModels[id_model]))\
+if (!(id_model < m_aGreens.size() && m_aGreens[id_model]))\
 {\
 	LibReport(REPORT_MSG_LEVEL_ERROR, "%s - green: unresolved id '%d' for array of models", GEN_MSG_LOCATION, id_model); \
 }
 
-class Green
+//##########################################################################
+
+//! тип деления пространства для рендера растительности
+#define GREEN_COUNT_TYPE_SEGMENTATION 4
+
+//! количество лодов растительноси
+#define GREEN_COUNT_LOD 3
+
+#define GREEN_DEFAULT_RESERVE_GEN 1024
+#define GREEN_DEFAULT_RESERVE_COM 1024
+
+//##########################################################################
+
+//! класс растительности
+class CGreen
 {
 public:
 
-	static int CurrentFreqGrass;
-	static float2_t DistLods;
-	static float BeginEndLessening;
-	static bool UseSortFrontToBackSplits;
-	static IDirect3DDevice9* DXDevice;
+	//! плотность растительности при рендере (0,100]
+	static int m_iRenderFreqGrass;
+
+	//! дистанция лодов x - где заканчивается первый лод и начинается второй, y - где заканчивается второй и начинается третий лод
+	static float2_t m_vDistLods;
+
+	//! дистанция с которой начнет уменьшаться трава, пределы [0, m_vDistLods.x)
+	static float m_fDistGrassLessening;
+
+	//! использовать ли сортировку от ближнего к дальнему для сплитов
+	static bool m_isUseSortFrontToBackSplits;
+
+	//! direct3d device
+	static IDirect3DDevice9* m_pDXDevice;
+
+	//######################################################################
 
 	SX_ALIGNED_OP_MEM
 
-	Green();
-	~Green();
+	CGreen();
+	~CGreen();
 
-	ID Init(StaticGeom* geom, const char* name,
-		const char* path_mask,
-		float count_max,
-		const char* path, const char* lod1, const char* lod2,
-		const char* navmesh);
+	//**********************************************************************
 
-	ID GetIDSplit(ID id, float3* pos);
-	ID AddObject(ID id, float3* pos, GreenDataVertex* data, ID* idsplit);
-	void DelObject(ID id, ID idsplit, ID idobj);
-	void GetPosObject(ID id, ID idsplit, ID idobj, float3_t* pos);
-	void SetPosObject(ID id, ID* idsplit, ID* idobj, float3_t* pos);
+	ID init(
+		CStaticGeom *pGeom, const char *szName,
+		const char *szPathMask,
+		float fCountMax,
+		const char *szPath, const char *szLod1, const char *szLod2,
+		const char *szPhysMesh
+		);
 
-	void DelGreen(ID id);
+	ID getIDSplit(ID idGreen, float3 *pPos);
+	ID addObject(ID idGreen, float3 *pPos, CGreenDataVertex *pData, ID *pIDsplit);
+	void deleteObject(ID idGreen, ID idSplit, ID idObj);
+	void getPosObject(ID idGreen, ID idSplit, ID idObj, float3_t *pPos);
+	void setPosObject(ID idGreen, ID *pIDsplit, ID *pIDobj, const float3_t *pPos);
+
+	void deleteGreen(ID idGreen);
 	
-	void OnLostDevice();
-	void OnResetDevice();
+	void onLostDevice();
+	void onResetDevice();
 	
-	ID AddArrForCom();
-	bool existsArrForCom(ID id);
-	void DelArrForCom(ID id_arr);
+	ID addArrForCom();
+	bool existsArrForCom(ID idGreen);
+	void deleteArrForCom(ID idArr);
 	
-	void Save(const char* path);
-	void Load(const char* path);
-	void Clear();
-	void CPUFillingArrIndeces(const ISXFrustum* frustum, float3* viewpos, ID id_arr = 0);
-	void GPURender(DWORD timeDelta, float3* viewpos, GREEN_TYPE type, ID id_arr = 0);
-	void GPURenderSingly(DWORD timeDelta, float3* viewpos, ID id, ID id_tex);
-	void GPURenderObject(DWORD timeDelta, float3* viewpos, ID id, ID split, ID idobj, ID id_tex);
-
-	ID GetCountGreen();
-	char* GetGreenName(ID id);
-	long GetGreenCountGen(ID id);
-	long GetGreenCountPoly(ID id);
-	int GetGreenTypeCountGen(ID id);
-	const char* GetGreenModel(ID id);
-	const char* GetGreenLod1(ID id);
-	const char* GetGreenLod2(ID id);
-	const char* GetGreenMask(ID id);
-	const char* GetGreenNav(ID id);
-	void SetGreenLod(ID id, int lod, const char* pathname);
-	void SetGreenNav(ID id, const char* pathname);
-
-	void GetNavMeshAndTransform(float3_t*** arr_vertex, int32_t** arr_count_vertex, uint32_t*** arr_index, ID*** arr_mtl, int32_t** arr_count_index, GreenDataVertex*** arr_transform, int32_t** arr_count_transform, int32_t* arr_count_green);
-	bool GetOccurencessLeafGrass(float3* bbmin, float3* bbmax, int physic_mtl);
+	void save(const char *szPath);
+	void load(const char *szPath);
+	void clear();
+	void comArrIndeces(const ISXFrustum *pFrustum, const float3 *pViewPos, ID idArr = 0);
+	void render(DWORD timeDelta, const float3 *pViewPos, GREEN_TYPE type, ID idArr = 0);
+	void renderSingly(DWORD timeDelta, const float3 *pViewPos, ID id, ID idTexture);
+	void renderObject(DWORD timeDelta, const float3 *pViewPos, ID id, ID idSplit, ID idObj, ID idTexture);
+
+	ID getCountGreen();
+	char* getGreenName(ID idGreen);
+	int getGreenCountGen(ID idGreen);
+	int getGreenCountPoly(ID idGreen);
+	int getGreenTypeCountGen(ID idGreen);
+	const char* getGreenModel(ID idGreen);
+	const char* getGreenLod1(ID idGreen);
+	const char* getGreenLod2(ID idGreen);
+	const char* getGreenMask(ID idGreen);
+	const char* getGreenNav(ID idGreen);
+	void setGreenLod(ID idGreen, int iLod, const char *szPathName);
+	void setGreenNav(ID idGreen, const char *szPathName);
+
+	void getNavMeshAndTransform(float3_t ***pppArrVertex, int32_t **ppArrCountVertex, uint32_t ***pppArrIndex, ID ***pppArrMtl, int32_t **ppArrCountIndex, CGreenDataVertex ***pppArrTransform, int32_t **ppArrCountTransform, int32_t *pArrCountGreen);
+	bool getOccurencessLeafGrass(float3 *pMin, float3 *pMax, int iPhysicMtl);
 	
-	bool TraceBeam(float3* start, float3* dir, float3* _res, ID* idgreen, ID* idsplits, ID* idobj, ID* idmtl);
+	bool traceBeam(const float3 *pStart, const float3 *pDir, float3 *pResult, ID *pIDgreen, ID *pIDsplits, ID *pIDobj, ID *pIDmtl);
+
+	//######################################################################
 
-	//
-	struct Segment
+	//! сегмент пространства с растительностью
+	struct CSegment
 	{
 		SX_ALIGNED_OP_MEM
 
-		Segment();
-		~Segment();
+		CSegment();
+		~CSegment();
 
-		Segment* Splits[GREEN_COUNT_TYPE_SEGMENTATION]; //массив из 4 частей данного участка
+		//! массив из 4 частей данного участка
+		CSegment *m_aSplits[GREEN_COUNT_TYPE_SEGMENTATION]; 
 
-		GreenDataVertex* Data;
-		DWORD CountAllGreen;	//количество элементов
+		//! массив данных трансформаций каждого элемента данного куска
+		CGreenDataVertex *m_pObjData;
 
-		ISXBound* BoundVolumeSys;	//выравненный ограничивающий объем для равномерного деления
-		ISXBound* BoundVolumeP;		//облегающий ограничивающий объем
+		//! количество элементов
+		int m_iCountObj;	
 
-		float DistForCamera;
+		//! выравненный ограничивающий объем для равномерного деления
+		ISXBound *m_pBoundVolumeSys;
+
+		//! облегающий ограничивающий объем
+		ISXBound *m_pBoundVolumeP;		
+
+		//! дистация от камеры
+		float m_fDistForCamera;
+
+		//! идентификатор куска
+		ID m_id;	
+
+		//! имеет ли кусок куски внутри себя?
+		bool m_idNonEnd;
 
-		ID Id;	//идентификатор куска
-	
 		//ID3DXMesh* BoundBox;	//ограничивающий параллелепипед (меш)
-		bool BFNonEnd;//имеет ли кусок куски внутри себя?
 	};
 
-	struct Lod
+	//**********************************************************************
+
+	//! лод растительности
+	struct CLod
 	{
-		Lod();
-		~Lod();
-		String path;
-		Array<ID> idstex;
-		ISXDataStaticModel* model;
+		CLod();
+		~CLod();
+
+		//! путь до лода
+		String m_sPath;
+
+		//! массив текстур лода
+		Array<ID> m_aIDsTextures;
+
+		//! статическая модель
+		ISXDataStaticModel *m_pModel;
 	};
 
-	struct Model
+	//**********************************************************************
+
+	//! модель растительности, в том числе лоды и навигационные оболочки
+	struct CModel
 	{
 		SX_ALIGNED_OP_MEM
 
-		Model();
-		~Model();
+		CModel();
+		~CModel();
 
-		struct NavMesh
+		//! класс физической модели для растительности, формат модели стандартный
+		struct CPhysMesh
 		{
-			NavMesh();
-			~NavMesh();
-			float3_t* arr_vertex;
-			int32_t count_vertex;
-			uint32_t* arr_index;
-			ID* arr_mtl;
-			int32_t count_index;
-			String pathname;
+			CPhysMesh();
+			~CPhysMesh();
+
+			//! массив вершин
+			float3_t *m_pArrVertex;
+
+			//! количество вершин в массиве m_pArrVertex
+			int32_t m_iCountVertex;
+
+			//! массив индексов
+			uint32_t *m_pArrIndex;
+
+			//! количество индексов в массиве m_pArrIndex
+			int32_t m_iCountIndex;
+
+			//! массив id материалов последовательно для каждого индекса их m_pArrIndex
+			ID *m_pArrMtl;
+
+			//! путь до статической модели
+			String m_sPathName;
 		};
 
-		GREEN_TYPE TypeGreen;	//
-		String MaskName;
-		uint32_t AllCountGreen;	//сколько всего сгенерировано объектов
-		char Name[OBJECT_NAME_MAX_LEN];
-		NavMesh* NavigateMesh;
-
-		Segment* SplitsTree;
-		Array<Segment*> SplitsArr;
-		float3 BBMax, BBMin;
-		GreenDataVertex* AllTrans;//
-		Lod* ArrLod[GREEN_COUNT_LOD];
-		ID SplitsIDs;	//общее количество сегментов/спилтов
+		//! тип растительности
+		GREEN_TYPE m_typeGreen;
+
+		//! имя текстуры маски
+		String m_szMaskName;
+
+		//! сколько всего сгенерировано объектов
+		uint32_t m_uiCountObj;
+
+		//! имя объекта растительности
+		char m_szName[OBJECT_NAME_MAX_LEN];
+
+		//! физическая модель
+		CPhysMesh *m_pPhysMesh;
+
+		//! начальный/главный сплит пространства
+		CSegment *m_pSplitsTree;
+
+		//! массив всех конечных сплитов пространтва
+		Array<CSegment*> m_aSplitsArr;
+
+		//! экстремумы пространства занимаемого этой растительностью
+		float3 m_vMax, m_vMin;
+
+		//! массив трансформаций всех объектов растительности
+		CGreenDataVertex *m_pAllTrans;
+
+		//! массив лодов
+		CLod *m_aLods[GREEN_COUNT_LOD];
+
+		//! общее количество сегментов/сплитов
+		ID m_idCountSplits;
 	};
 
-	//структура содержащая минимальную необходимую информацию о сегменте модели
-	struct InfoRenderSegments
+	//**********************************************************************
+
+	//! структура содержащая минимальную необходимую информацию о сегменте модели для рендера
+	struct CInfoRenderSegments
 	{
-		InfoRenderSegments();
-		~InfoRenderSegments();
-		Segment** Arr;	//массив хранящий в себе указатели на сегменты REALTIME
-		DWORD Count;	//размер Arr 
-		DWORD CountCom;	//сколько сегментов записано в Arr	REALTIME
+		CInfoRenderSegments();
+		~CInfoRenderSegments();
+
+		//!массив хранящий в себе указатели на сегменты REALTIME
+		CSegment **m_ppSegments;
+
+		//! размер Arr 
+		int m_iCount;
+
+		//! сколько сегментов записано в Arr REALTIME 
+		int m_iCountCom;
 	};
 
-	struct IRSData
+	//**********************************************************************
+
+	//! данные для просчетов видимости
+	struct CIRSData
 	{
-		IRSData();
-		~IRSData();
-		Array<Segment*, GREEN_DEFAULT_RESERVE_COM> queue;
-		Array<InfoRenderSegments*> arr;
+		CIRSData();
+		~CIRSData();
+
+		//! очередь обработки просчетов видимости для каждого сегмента
+		Array<CSegment*, GREEN_DEFAULT_RESERVE_COM> m_aQueue;
+
+		//! массив информации для рендера сегментов
+		Array<CInfoRenderSegments*> m_aIRS;
 	};
 	
 protected:
-	Array<IRSData*> ArrComFor; //информация о сегментах для рендера
-	void SaveSplit(Segment* Split, FILE* file, Array<Segment*> * queue);
-	void LoadSplit(Segment** Split, FILE* file, Array<Segment**> * queue);
-	void GPURender2(DWORD timeDelta, float3* viewpos, ID nm, int lod, ID id_tex);
-	void AlignBound(Model* model, Segment* split);
-	void GenByTex(StaticGeom* geom, Model* model, ID idmask, float3* min, float3* max, float count_max);
-
-	void GetPartBeam(float3* pos, float3 * dir, Segment** arrsplits, DWORD *count, Segment* comsegment, ID curr_splits_ids_render);
-	void GetPartBB(float3* bbmin, float3 * bbmax, Segment** arrsplits, DWORD *count, Segment* comsegment, ID curr_splits_ids_render);
+	
+	void saveSplit(CSegment *pSplit, FILE *pFile, Array<CSegment*> *pQueue);
+	void loadSplit(CSegment **ppSplit, FILE * file, Array<CSegment**> *pQueue);
+	void render2(DWORD timeDelta, const float3 *pViewPos, ID nm, int iLod, ID idTexture);
+	void alignBound(CModel *pModel, CSegment *pSplit);
+	void genByTex(CStaticGeom *pGeom, CModel *pModel, ID idMask, float3 *pMin, float3 *pMax, float fCountMax);
 
-	void ComRecArrIndeces(const ISXFrustum* frustum, Segment** arrsplits, DWORD *count, Segment* comsegment, float3* viewpos, Array<Segment*, GREEN_DEFAULT_RESERVE_COM>* queue, ID curr_splits_ids_render);
+	void getPartBeam(const float3 *pPos, const float3 *pDir, CSegment **ppArrSplits, int *pCount, CSegment *pSegment, ID idCurrSplitRender);
+	void getPartBB(float3 *pMin, float3 *pMax, CSegment **ppArrSplits, int *pCount, CSegment *pSegment, ID idCurrSplitRender);
 
-	void AddModelInArrCom(ID id_model);
-	void DelModelInArrCom(ID id_model);
+	void comRecArrIndeces(const ISXFrustum *pFrustum, CSegment **ppArrSplits, int *pCount, CSegment *pSegment, const float3 *pViewPos, Array<CSegment*, GREEN_DEFAULT_RESERVE_COM> *pQueue, ID idCurrSplitRender);
 
-	Array<Model*> ArrModels;
-	IDirect3DVertexBuffer9* TransVertBuf;	//буфер вершин с трансформациями растительности
-	IDirect3DVertexDeclaration9* VertexDeclarationGreen;
+	void addModelInArrCom(ID idModel);
+	void deleteModelInArrCom(ID idModel);
 	
-	void PreSegmentation(Model* model, float3* min_level, float3* max_level);
-	void CycleSegmentation(Segment* Split, Model* mesh);
-	void Segmentation(Segment* Split, Model* mesh);
-	void SetSplitID(Model* model);
-	void SetSplitID2(Model* model, Segment* Split, Array<Segment*, GREEN_DEFAULT_RESERVE_COM>* queue);
+	void preSegmentation(CModel *pModel, float3 *pMinLevel, float3 *pMaxLevel);
+	void cycleSegmentation(CSegment *pSplit, CModel *pMesh);
+	void segmentation(CSegment *pSplit, CModel *pMesh);
+	void setSplitID(CModel *pModel);
+	void setSplitID2(CModel *pModel, CSegment *pSplit, Array<CSegment*, GREEN_DEFAULT_RESERVE_COM> *pQueue);
+
+	//**********************************************************************
+
+	//! информация о сегментах для рендера
+	Array<CIRSData*> m_aArrComFor;
+
+	//! количество элементов текущей растительности для отрисовки
+	int m_iCurrCountDrawObj;
 
-	long RTCountDrawObj;
-	GreenDataVertex* RTGPUArrVerteces;
-	D3DXMATRIX mat;
+	//! массив всех green
+	Array<CModel*> m_aGreens;
 
-	Segment** jarrsplits;
-	DWORD jcount;
+	//! буфер вершин с трансформациями растительности
+	IDirect3DVertexBuffer9 *m_pTransVertBuf;
 
-	DWORD jCountIndex;
+	//! декларация вершин
+	IDirect3DVertexDeclaration9 *m_pVertexDeclarationGreen;
 };
 
 
diff --git a/source/geom/static_geom.cpp b/source/geom/static_geom.cpp
index a29726b9ca7d1e90046ac09317f7aaf6c918f3f1..42b1ee3d74c7dab91c64a2bc8185ff7f3b7f8bbe 100644
--- a/source/geom/static_geom.cpp
+++ b/source/geom/static_geom.cpp
@@ -6,162 +6,164 @@ See the license in LICENSE
 
 #include "static_geom.h"
 
-StaticGeom::Segment::Segment()
+CStaticGeom::CSegment::CSegment()
 {
 	for (int i = 0; i < GEOM_COUNT_TYPE_SEGMENTATION_OCTO; ++i)
 	{
-		Splits[i] = 0;
+		m_aSplits[i] = 0;
 	}
 
-	ArrPoly = 0;
-	CountPoly = 0;
-	NumberGroup = 0;
-	NumberGroupModel = 0;
-	CountSubSet = 0;
-	CountAllPoly = 0;
-	BoundVolumeSys = 0;
-	BoundVolumeP = 0;
-	ID = -1;
-	SID = -1;
-	BFNonEnd = false;
+	m_ppArrPoly = 0;
+	m_pCountPoly = 0;
+	m_pNumberGroup = 0;
+	m_pNumberGroupModel = 0;
+	m_uiCountSubSet = 0;
+	m_uiCountAllPoly = 0;
+	m_pBoundVolumeSys = 0;
+	m_pBoundVolumeP = 0;
+	m_ID = -1;
+	m_SID = -1;
+	m_isNonEnd = false;
 }
 
-StaticGeom::Segment::~Segment()
+CStaticGeom::CSegment::~CSegment()
 {
 	for (int i = 0; i < GEOM_COUNT_TYPE_SEGMENTATION_OCTO; i++)
 	{
-		mem_delete(Splits[i]);
+		mem_delete(m_aSplits[i]);
 	}
-	mem_delete_a(NumberGroup);
-	mem_delete_a(NumberGroupModel);
-	mem_delete_a(CountPoly);
+	mem_delete_a(m_pNumberGroup);
+	mem_delete_a(m_pNumberGroupModel);
+	mem_delete_a(m_pCountPoly);
 	
-	if (ArrPoly)
+	if (m_ppArrPoly)
 	{
-		for (DWORD i = 0; i < CountSubSet; i++)
+		for (DWORD i = 0; i < m_uiCountSubSet; i++)
 		{
-			mem_delete_a(ArrPoly[i]);
+			mem_delete_a(m_ppArrPoly[i]);
 		}
 	}
 
-	mem_delete_a(ArrPoly);
-	mem_release_del(BoundVolumeSys);
-	mem_release_del(BoundVolumeP);
+	mem_delete_a(m_ppArrPoly);
+	mem_release_del(m_pBoundVolumeSys);
+	mem_release_del(m_pBoundVolumeP);
 	//ndx_release(BoundBox);
 }
 
-StaticGeom::Group::Group()
+CStaticGeom::CGroup::CGroup()
 {
-	name = "";
-	idtex = -1;
-	SortGroup = 0;
-	AllCountVertex = AllCountIndex = 0;
+	m_sName = "";
+	m_idTexture = -1;
+	m_iSortGroup = 0;
+	m_iCountVertex = m_iCountIndex = 0;
 }
 
-/*StaticGeom::Group::VertexBuff::VertexBuff()
+/*CStaticGeom::Group::VertexBuff::VertexBuff()
 {
 	arr = 0;
 	count = 0;
 }
 
-StaticGeom::Group::VertexBuff::~VertexBuff()
+CStaticGeom::Group::VertexBuff::~VertexBuff()
 {
 	mem_delete_a(arr);
 	count = 0;
 }*/
 
-StaticGeom::Group::~Group()
+CStaticGeom::CGroup::~CGroup()
 {
-	idtex = -1;
-	AllCountVertex = AllCountIndex = 0;
-	CountVertex.clear();
-	CountIndex.clear();
+	m_idTexture = -1;
+	m_iCountVertex = m_iCountIndex = 0;
+	m_aCountVertex.clear();
+	m_aCountIndex.clear();
 
-	for (long i = 0; i < VertexBuffer.size(); ++i)
+	for (int i = 0; i < m_aVertexBuffers.size(); ++i)
 	{
-		mem_release_del(VertexBuffer[i]);
+		mem_release_del(m_aVertexBuffers[i]);
 		//mem_delete(VertexBufferOrigin[i]);
 	}
 }
 
-StaticGeom::Model::Lod::Lod()
+CStaticGeom::CModel::CLod::CLod()
 {
-	PathName[0] = 0;
-	model = 0;
-	BoundVolume = SGCore_CrBound();
+	m_szPathName[0] = 0;
+	m_pModel = 0;
+	m_pBoundVolume = SGCore_CrBound();
 }
 
-StaticGeom::Model::Lod::~Lod()
+CStaticGeom::CModel::CLod::~CLod()
 {
-	mem_release_del(model);
-	mem_release_del(BoundVolume);
+	mem_release_del(m_pModel);
+	mem_release_del(m_pBoundVolume);
 }
 
-StaticGeom::Model::Model()
+CStaticGeom::CModel::CModel()
 {
-	SplitsIDs = SplitsIDsRender = 0;
-	ArrSplits = 0;
-	Position = float3(0,0,0);
-	Rotation = float3(0,0,0);
-	Scale = float3(1,1,1);
+	m_idCountSplits = m_idCountSplitsRender = 0;
+	m_pArrSplits = 0;
+	m_vPosition = float3(0, 0, 0);
+	m_vRotation = float3(0, 0, 0);
+	m_vScale = float3(1, 1, 1);
 
-	OldPosition = Position;
-	OldRotation = Rotation;
-	OldScale = Scale;
+	m_vOldPosition = m_vPosition;
+	m_vOldRotation = m_vRotation;
+	m_vOldScale = m_vScale;
 
-	CountPoly = 0;
+	m_uiCountPoly = 0;
 
-	Name[0] = 0;
-	PathName[0] = 0;
-	IsRenderLod = false;
+	m_szName[0] = 0;
+	m_szPathName[0] = 0;
+	m_isRenderLod = false;
 }
 
-StaticGeom::Model::~Model()
+CStaticGeom::CModel::~CModel()
 {
-	SplitsIDs = SplitsIDsRender = 0;
-	SubSet.clear();
-	mem_delete(ArrSplits);
+	m_idCountSplits = m_idCountSplitsRender = 0;
+	m_aSubSets.clear();
+	mem_delete(m_pArrSplits);
 }
 
-StaticGeom::InfoRenderSegments::InfoRenderSegments()
+CStaticGeom::CInfoRenderSegments::CInfoRenderSegments()
 {
-	Arr = 0; Count = 0; CountCom = 0;
+	m_ppSegments = 0; m_iCount = 0; m_iCountCom = 0;
 }
 
-StaticGeom::InfoRenderSegments::~InfoRenderSegments()
+CStaticGeom::CInfoRenderSegments::~CInfoRenderSegments()
 {
-	mem_delete_a(Arr);
+	mem_delete_a(m_ppSegments);
 }
 
-StaticGeom::IRSData::IRSData()
+CStaticGeom::CIRSData::CIRSData()
 {
 
 }
 
-StaticGeom::IRSData::~IRSData()
+CStaticGeom::CIRSData::~CIRSData()
 {
-	queue.clear();
-	for (int i = 0; i < arr.size(); ++i)
+	m_aQueue.clear();
+	for (int i = 0; i < m_aIRS.size(); ++i)
 	{
-		mem_delete(arr[i]);
+		mem_delete(m_aIRS[i]);
 	}
-	arr.clear();
+	m_aIRS.clear();
 }
 
-StaticGeom::StaticGeom()
+CStaticGeom::CStaticGeom()
 {
-	SizeRenderIndexBuffer = 0;
-	RenderIndexBuffer = 0;
-	RTCPUArrIndicesPtrs = 0;
+	m_iSizeRenderIndexBuffer = 0;
+	m_pRenderIndexBuffer = 0;
+
+	m_pppRTArrIndices = 0;
+	m_ppRTCountDrawPoly = 0;
+	m_pppRTCountDrawPolyModel = 0;
+	m_pppRTBeginIndexModel = 0;
 
-	WorldMat = SMMatrixIdentity();
+	m_mWorld = SMMatrixIdentity();
 
-	ArrMeshVertex = 0;
-	ArrMeshIndex = 0;
-	jvevyn = D3DXVECTOR3(0.0f, -1000.0f, 0.0f);
-	jvevyp = D3DXVECTOR3(0.0f, 1000.0f, 0.0f);
+	m_pCurrArrMeshVertex = 0;
+	m_pCurrArrMeshIndex = 0;
 
-	BoundVolume = SGCore_CrBound();
+	m_pBoundVolume = SGCore_CrBound();
 
 	/*D3DVERTEXELEMENT9 layoutstatic[] =
 	{
@@ -171,62 +173,62 @@ StaticGeom::StaticGeom()
 		D3DDECL_END()
 	};
 
-	StaticGeom::DXDevice->CreateVertexDeclaration(layoutstatic, &VertexDeclarationStatic);*/
+	CStaticGeom::m_pDXDevice->CreateVertexDeclaration(layoutstatic, &VertexDeclarationStatic);*/
 
-	IRSData* tmparr = new IRSData();
-	ArrComFor.push_back(tmparr);
-	IRSData* tmparr2 = new IRSData();
-	ArrComFor.push_back(tmparr2);
+	CIRSData* tmparr = new CIRSData();
+	m_aArrComFor.push_back(tmparr);
+	CIRSData* tmparr2 = new CIRSData();
+	m_aArrComFor.push_back(tmparr2);
 }
 
-StaticGeom::~StaticGeom()
+CStaticGeom::~CStaticGeom()
 {
-	for (long i = 0; i < ArrComFor.size(); ++i)
+	for (int i = 0; i < m_aArrComFor.size(); ++i)
 	{
-		mem_delete(ArrComFor[i]);
+		mem_delete(m_aArrComFor[i]);
 	}
 
-	ArrComFor.clear();
-	mem_delete_a(ArrMeshVertex);
-	mem_delete_a(ArrMeshIndex);
-	mem_release(RenderIndexBuffer);
+	m_aArrComFor.clear();
+	mem_delete_a(m_pCurrArrMeshVertex);
+	mem_delete_a(m_pCurrArrMeshIndex);
+	mem_release(m_pRenderIndexBuffer);
 	//mem_release(VertexDeclarationStatic);
-	mem_release(BoundVolume);
+	mem_release(m_pBoundVolume);
 
-	DelArrIndexPtr();
+	deleteArrIndexPtr();
 
-	for (long i = 0; i < AllModels.size(); ++i)
+	for (int i = 0; i < m_aAllModels.size(); ++i)
 	{
-		mem_delete(AllModels[i]);
+		mem_delete(m_aAllModels[i]);
 	}
-	AllModels.clear();
+	m_aAllModels.clear();
 
-	for (long i = 0; i < AllGroups.size(); ++i)
+	for (int i = 0; i < m_aAllGroups.size(); ++i)
 	{
-		mem_delete(AllGroups[i]);
+		mem_delete(m_aAllGroups[i]);
 	}
-	AllGroups.clear();
+	m_aAllGroups.clear();
 }
 
-void StaticGeom::OnLostDevice()
+void CStaticGeom::onLostDevice()
 {
-	mem_release_del(RenderIndexBuffer);
+	mem_release_del(m_pRenderIndexBuffer);
 }
 
-void StaticGeom::OnResetDevice()
+void CStaticGeom::onResetDevice()
 {
-	StaticGeom::DXDevice->CreateIndexBuffer(sizeof(uint32_t)* SizeRenderIndexBuffer, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFMT_INDEX32, D3DPOOL_DEFAULT/*D3DPOOL_MANAGED*/, &RenderIndexBuffer, 0);
+	CStaticGeom::m_pDXDevice->CreateIndexBuffer(sizeof(uint32_t)* m_iSizeRenderIndexBuffer, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFMT_INDEX32, D3DPOOL_DEFAULT/*D3DPOOL_MANAGED*/, &m_pRenderIndexBuffer, 0);
 }
 
-long StaticGeom::GetCountModel()
+int CStaticGeom::getCountModel()
 {
-	return AllModels.size();
+	return m_aAllModels.size();
 }
 
-ID StaticGeom::AddModel(const char* path, const char* lod1, const char* name)
+ID CStaticGeom::addModel(const char* path, const char* lod1, const char* name)
 {
 	LibReport(0, "load geometry: '%s'.. ", path);
-	DelArrIndexPtr();
+	deleteArrIndexPtr();
 
 	ISXDataStaticModel* model = 0;
 	
@@ -234,14 +236,14 @@ ID StaticGeom::AddModel(const char* path, const char* lod1, const char* name)
 	sprintf(tmppath, "%s%s", Core_RStringGet(G_RI_STRING_PATH_GS_MESHES), path);
 	SGCore_StaticModelLoad(tmppath, &model);
 
-	Model* tmpmodel = new Model();
-	ID tmpidmodel = AllModels.size() - 1;
+	CModel* tmpmodel = new CModel();
+	ID tmpidmodel = m_aAllModels.size() - 1;
 	if (!def_str_validate(name))
-		sprintf(tmpmodel->Name, "");
+		sprintf(tmpmodel->m_szName, "");
 	else
-		sprintf(tmpmodel->Name, "%s", name);
+		sprintf(tmpmodel->m_szName, "%s", name);
 
-	sprintf(tmpmodel->PathName, "%s", path);
+	sprintf(tmpmodel->m_szPathName, "%s", path);
 
 	bool isunictex = true;	//уникальна ли подгруппа в модели? (то есть, нет ли данной подгруппы в списке уже загруженных)
 
@@ -256,11 +258,11 @@ ID StaticGeom::AddModel(const char* path, const char* lod1, const char* name)
 
 	for (int i = 0; i < model->m_uiSubsetCount; ++i)
 	{
-		tmpmodel->CountPoly += model->m_pIndexCount[i] / 3;
+		tmpmodel->m_uiCountPoly += model->m_pIndexCount[i] / 3;
 
 		char tmptex[1024];
 		sprintf(tmptex, "%s.dds", model->m_ppTextures[i]);
-		tmpmodel->IDTex[i] = SGCore_MtlLoad(tmptex, MTL_TYPE_GEOM);
+		tmpmodel->m_aIDsTexures[i] = SGCore_MtlLoad(tmptex, MTL_TYPE_GEOM);
 
 		
 
@@ -273,16 +275,16 @@ ID StaticGeom::AddModel(const char* path, const char* lod1, const char* name)
 
 		isunictex = true;
 
-		for (int k = 0; k < AllGroups.size(); ++k)
+		for (int k = 0; k < m_aAllGroups.size(); ++k)
 		{
 			//сравниваем подгруппы только по имени, если имена одинаковые значит это одна и та же подгруппа
-			if (stricmp(AllGroups[k]->name.c_str(), model->m_ppTextures[i]) == 0)
+			if (stricmp(m_aAllGroups[k]->m_sName.c_str(), model->m_ppTextures[i]) == 0)
 			{
 				isunictex = false;
 
-				Model::GDataBuff gdb;
+				CModel::CSubSet gdb;
 
-				gdb.idgroup = k;
+				gdb.m_idGroup = k;
 
 				IDirect3DVertexBuffer9* vb;
 
@@ -290,25 +292,25 @@ ID StaticGeom::AddModel(const char* path, const char* lod1, const char* name)
 				vertex_static * pData2;
 
 				//если последний незаполненный буфер не вмещает в себ¤
-				if (AllGroups[k]->CountIndex[AllGroups[k]->CountIndex.size() - 1] / 3 + model->m_pIndexCount[i] / 3 > GEOM_MAX_POLY_IN_GROUP)
+				if (m_aAllGroups[k]->m_aCountIndex[m_aAllGroups[k]->m_aCountIndex.size() - 1] / 3 + model->m_pIndexCount[i] / 3 > GEOM_MAX_POLY_IN_GROUP)
 				{
 					//создаем новый
-					gdb.VertexStart = 0;
-					gdb.VertexCount = model->m_pVertexCount[i];
+					gdb.m_idVertexStart = 0;
+					gdb.m_uiVertexCount = model->m_pVertexCount[i];
 
-					StaticGeom::DXDevice->CreateVertexBuffer(sizeof(vertex_static)* model->m_pVertexCount[i], NULL, NULL, D3DPOOL_MANAGED, &vb, 0);
+					CStaticGeom::m_pDXDevice->CreateVertexBuffer(sizeof(vertex_static)* model->m_pVertexCount[i], NULL, NULL, D3DPOOL_MANAGED, &vb, 0);
 					
 					/*Group::VertexBuff* vborigin = new Group::VertexBuff();
 					vborigin->count = model->VertexCount[i];
 					vborigin->arr = new float3_t[vborigin->count];
-					for (long j = 0; j < model->VertexCount[i]; ++j)
+					for (int j = 0; j < model->VertexCount[i]; ++j)
 					{
 						vborigin->arr[j] = (model->ArrVertBuf + model->StartVertex[i] + j)->Pos;
 					}
-					AllGroups[k]->VertexBufferOrigin.push_back(vborigin);*/
+					m_aAllGroups[k]->VertexBufferOrigin.push_back(vborigin);*/
 					
-					AllGroups[k]->AllCountVertex += model->m_pVertexCount[i];
-					AllGroups[k]->CountVertex.push_back(model->m_pVertexCount[i]);
+					m_aAllGroups[k]->m_iCountVertex += model->m_pVertexCount[i];
+					m_aAllGroups[k]->m_aCountVertex.push_back(model->m_pVertexCount[i]);
 					//копируем данные в новый вершинный буфер
 					if (!FAILED(vb->Lock(0, 0, (void**)&pData, 0)))
 					{
@@ -316,115 +318,115 @@ ID StaticGeom::AddModel(const char* path, const char* lod1, const char* name)
 						vb->Unlock();
 					}
 
-					AllGroups[k]->VertexBuffer.push_back(vb);
+					m_aAllGroups[k]->m_aVertexBuffers.push_back(vb);
 
 
-					gdb.IndexStart = 0;
-					gdb.IndexCount = model->m_pIndexCount[i];
-					AllGroups[k]->AllCountIndex += model->m_pIndexCount[i];
-					AllGroups[k]->CountIndex.push_back(model->m_pIndexCount[i]);
+					gdb.m_idIndexStart = 0;
+					gdb.m_uiIndexCount = model->m_pIndexCount[i];
+					m_aAllGroups[k]->m_iCountIndex += model->m_pIndexCount[i];
+					m_aAllGroups[k]->m_aCountIndex.push_back(model->m_pIndexCount[i]);
 
-					gdb.idbuff = AllGroups[k]->VertexBuffer.size()-1;
+					gdb.m_idBuff = m_aAllGroups[k]->m_aVertexBuffers.size() - 1;
 
-					AllGroups[k]->ArrModels[gdb.idbuff].push_back(tmpmodel);
+					m_aAllGroups[k]->m_aModels[gdb.m_idBuff].push_back(tmpmodel);
 
-					if (SizeRenderIndexBuffer < model->m_pIndexCount[i])
+					if (m_iSizeRenderIndexBuffer < model->m_pIndexCount[i])
 					{
-						mem_release(RenderIndexBuffer);
-						SizeRenderIndexBuffer = model->m_pIndexCount[i];
-						StaticGeom::DXDevice->CreateIndexBuffer(sizeof(uint32_t)* SizeRenderIndexBuffer, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFMT_INDEX32, D3DPOOL_DEFAULT/*D3DPOOL_MANAGED*/, &RenderIndexBuffer, 0);
+						mem_release(m_pRenderIndexBuffer);
+						m_iSizeRenderIndexBuffer = model->m_pIndexCount[i];
+						CStaticGeom::m_pDXDevice->CreateIndexBuffer(sizeof(uint32_t)* m_iSizeRenderIndexBuffer, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFMT_INDEX32, D3DPOOL_DEFAULT/*D3DPOOL_MANAGED*/, &m_pRenderIndexBuffer, 0);
 					}
 				}
 				//иначе если влезет в буфер
 				else
 				{
 					//впихиваем в буфер
-					gdb.idbuff = AllGroups[k]->VertexBuffer.size() - 1;
-					Array<Model*>& tmparrmodel = AllGroups[k]->ArrModels[gdb.idbuff];
-					AllGroups[k]->ArrModels[gdb.idbuff].push_back(tmpmodel);
-					long lastvbnum = AllGroups[k]->VertexBuffer.size() - 1;
+					gdb.m_idBuff = m_aAllGroups[k]->m_aVertexBuffers.size() - 1;
+					Array<CModel*>& tmparrmodel = m_aAllGroups[k]->m_aModels[gdb.m_idBuff];
+					m_aAllGroups[k]->m_aModels[gdb.m_idBuff].push_back(tmpmodel);
+					int lastvbnum = m_aAllGroups[k]->m_aVertexBuffers.size() - 1;
 
-					StaticGeom::DXDevice->CreateVertexBuffer(sizeof(vertex_static)* (AllGroups[k]->CountVertex[lastvbnum] + model->m_pVertexCount[i]), NULL, NULL, D3DPOOL_MANAGED, &vb, 0);
+					CStaticGeom::m_pDXDevice->CreateVertexBuffer(sizeof(vertex_static)* (m_aAllGroups[k]->m_aCountVertex[lastvbnum] + model->m_pVertexCount[i]), NULL, NULL, D3DPOOL_MANAGED, &vb, 0);
 					
 					/*Group::VertexBuff* vborigin = new Group::VertexBuff();
-					vborigin->count = (AllGroups[k]->CountVertex[lastvbnum] + model->VertexCount[i]);
+					vborigin->count = (m_aAllGroups[k]->CountVertex[lastvbnum] + model->VertexCount[i]);
 					vborigin->arr = new float3_t[vborigin->count];
-					memcpy(vborigin->arr, AllGroups[k]->VertexBufferOrigin[lastvbnum]->arr, sizeof(float3_t) * AllGroups[k]->CountVertex[lastvbnum]);
-					for (long j = 0; j < model->VertexCount[i]; ++j)
+					memcpy(vborigin->arr, m_aAllGroups[k]->VertexBufferOrigin[lastvbnum]->arr, sizeof(float3_t) * m_aAllGroups[k]->CountVertex[lastvbnum]);
+					for (int j = 0; j < model->VertexCount[i]; ++j)
 					{
-						vborigin->arr[AllGroups[k]->CountVertex[lastvbnum]+j] = (model->ArrVertBuf + model->StartVertex[i] + j)->Pos;
+						vborigin->arr[m_aAllGroups[k]->CountVertex[lastvbnum]+j] = (model->ArrVertBuf + model->StartVertex[i] + j)->Pos;
 					}
-					mem_delete(AllGroups[k]->VertexBufferOrigin[lastvbnum]);
-					AllGroups[k]->VertexBufferOrigin[lastvbnum] = vborigin;*/
+					mem_delete(m_aAllGroups[k]->VertexBufferOrigin[lastvbnum]);
+					m_aAllGroups[k]->VertexBufferOrigin[lastvbnum] = vborigin;*/
 
-					gdb.VertexStart = AllGroups[k]->CountVertex[lastvbnum];
-					gdb.VertexCount = model->m_pVertexCount[i];
+					gdb.m_idVertexStart = m_aAllGroups[k]->m_aCountVertex[lastvbnum];
+					gdb.m_uiVertexCount = model->m_pVertexCount[i];
 					
 					if (!FAILED(vb->Lock(0, 0, (void**)&pData, 0)))
 					{
-						if (!FAILED(AllGroups[k]->VertexBuffer[lastvbnum]->Lock(0, 0, (void**)&pData2, 0)))
+						if (!FAILED(m_aAllGroups[k]->m_aVertexBuffers[lastvbnum]->Lock(0, 0, (void**)&pData2, 0)))
 						{
-							memcpy(pData, pData2, sizeof(vertex_static)* AllGroups[k]->CountVertex[lastvbnum]);
-							AllGroups[k]->VertexBuffer[lastvbnum]->Unlock();
+							memcpy(pData, pData2, sizeof(vertex_static)* m_aAllGroups[k]->m_aCountVertex[lastvbnum]);
+							m_aAllGroups[k]->m_aVertexBuffers[lastvbnum]->Unlock();
 						}
 
-						memcpy(pData + AllGroups[k]->CountVertex[lastvbnum], pVert + model->m_pStartVertex[i], sizeof(vertex_static)* (model->m_pVertexCount[i]));
+						memcpy(pData + m_aAllGroups[k]->m_aCountVertex[lastvbnum], pVert + model->m_pStartVertex[i], sizeof(vertex_static)* (model->m_pVertexCount[i]));
 						vb->Unlock();
 					}
 
-					AllGroups[k]->AllCountVertex += model->m_pVertexCount[i];
-					AllGroups[k]->CountVertex[lastvbnum] += model->m_pVertexCount[i];
-					mem_release(AllGroups[k]->VertexBuffer[lastvbnum]);
-					AllGroups[k]->VertexBuffer[lastvbnum] = vb;
+					m_aAllGroups[k]->m_iCountVertex += model->m_pVertexCount[i];
+					m_aAllGroups[k]->m_aCountVertex[lastvbnum] += model->m_pVertexCount[i];
+					mem_release(m_aAllGroups[k]->m_aVertexBuffers[lastvbnum]);
+					m_aAllGroups[k]->m_aVertexBuffers[lastvbnum] = vb;
 
-					gdb.IndexStart = AllGroups[k]->CountIndex[lastvbnum];
-					gdb.IndexCount = model->m_pIndexCount[i];
+					gdb.m_idIndexStart = m_aAllGroups[k]->m_aCountIndex[lastvbnum];
+					gdb.m_uiIndexCount = model->m_pIndexCount[i];
 
-					AllGroups[k]->AllCountIndex += model->m_pIndexCount[i];
-					AllGroups[k]->CountIndex[lastvbnum] += model->m_pIndexCount[i];
+					m_aAllGroups[k]->m_iCountIndex += model->m_pIndexCount[i];
+					m_aAllGroups[k]->m_aCountIndex[lastvbnum] += model->m_pIndexCount[i];
 
-					if (SizeRenderIndexBuffer < (AllGroups[k]->CountIndex[lastvbnum] + model->m_pIndexCount[i]))
+					if (m_iSizeRenderIndexBuffer < (m_aAllGroups[k]->m_aCountIndex[lastvbnum] + model->m_pIndexCount[i]))
 					{
-						mem_release(RenderIndexBuffer);
-						SizeRenderIndexBuffer = (AllGroups[k]->CountIndex[lastvbnum] + model->m_pIndexCount[i]);
-						StaticGeom::DXDevice->CreateIndexBuffer(sizeof(uint32_t)* SizeRenderIndexBuffer, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFMT_INDEX32, D3DPOOL_DEFAULT/*D3DPOOL_MANAGED*/, &RenderIndexBuffer, 0);
+						mem_release(m_pRenderIndexBuffer);
+						m_iSizeRenderIndexBuffer = (m_aAllGroups[k]->m_aCountIndex[lastvbnum] + model->m_pIndexCount[i]);
+						CStaticGeom::m_pDXDevice->CreateIndexBuffer(sizeof(uint32_t)* m_iSizeRenderIndexBuffer, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFMT_INDEX32, D3DPOOL_DEFAULT/*D3DPOOL_MANAGED*/, &m_pRenderIndexBuffer, 0);
 					}
 				}
 
-				tmpmodel->SubSet.push_back(gdb);
+				tmpmodel->m_aSubSets.push_back(gdb);
 			}
 		}
 
 		if (isunictex)
 		{
-			Group* ngroup = new Group();
-			Model::GDataBuff gdb;
+			CGroup* ngroup = new CGroup();
+			CModel::CSubSet gdb;
 
-			ngroup->ArrModels[0].push_back(tmpmodel);
+			ngroup->m_aModels[0].push_back(tmpmodel);
 
-			gdb.idbuff = 0;
-			gdb.idgroup = AllGroups.size();
-			gdb.VertexStart = 0;
-			gdb.VertexCount = model->m_pVertexCount[i];
-			gdb.IndexStart = 0;
-			gdb.IndexCount = model->m_pIndexCount[i];
+			gdb.m_idBuff = 0;
+			gdb.m_idGroup = m_aAllGroups.size();
+			gdb.m_idVertexStart = 0;
+			gdb.m_uiVertexCount = model->m_pVertexCount[i];
+			gdb.m_idIndexStart = 0;
+			gdb.m_uiIndexCount = model->m_pIndexCount[i];
 
-			tmpmodel->SubSet.push_back(gdb);
+			tmpmodel->m_aSubSets.push_back(gdb);
 
 			IDirect3DVertexBuffer9* vb;
-			StaticGeom::DXDevice->CreateVertexBuffer(sizeof(vertex_static)* model->m_pVertexCount[i], NULL, NULL, D3DPOOL_MANAGED, &vb, 0);
+			CStaticGeom::m_pDXDevice->CreateVertexBuffer(sizeof(vertex_static)* model->m_pVertexCount[i], NULL, NULL, D3DPOOL_MANAGED, &vb, 0);
 			
 			/*Group::VertexBuff* vborigin = new Group::VertexBuff();
 			vborigin->count = model->VertexCount[i];
 			vborigin->arr = new float3_t[vborigin->count];
 
-			for (long k = 0; k < model->VertexCount[i]; ++k)
+			for (int k = 0; k < model->VertexCount[i]; ++k)
 			{
 				vborigin->arr[k] = (model->ArrVertBuf + model->StartVertex[i] + k)->Pos;
 			}*/
 
-			ngroup->AllCountVertex = model->m_pVertexCount[i];
-			ngroup->CountVertex.push_back(model->m_pVertexCount[i]);
+			ngroup->m_iCountVertex = model->m_pVertexCount[i];
+			ngroup->m_aCountVertex.push_back(model->m_pVertexCount[i]);
 			vertex_static * pData;
 			if (!FAILED(vb->Lock(0, 0, (void**)&pData, 0)))
 			{
@@ -432,27 +434,27 @@ ID StaticGeom::AddModel(const char* path, const char* lod1, const char* name)
 				vb->Unlock();
 			}
 
-			ngroup->AllCountIndex = model->m_pIndexCount[i];
-			ngroup->CountIndex.push_back(model->m_pIndexCount[i]);
+			ngroup->m_iCountIndex = model->m_pIndexCount[i];
+			ngroup->m_aCountIndex.push_back(model->m_pIndexCount[i]);
 			
-			ngroup->VertexBuffer.push_back(vb);
+			ngroup->m_aVertexBuffers.push_back(vb);
 			//ngroup->VertexBufferOrigin.push_back(vborigin);
 			
-			if (SizeRenderIndexBuffer < model->m_pIndexCount[i])
+			if (m_iSizeRenderIndexBuffer < model->m_pIndexCount[i])
 			{
-				mem_release(RenderIndexBuffer);
-				SizeRenderIndexBuffer = model->m_pIndexCount[i];
-				StaticGeom::DXDevice->CreateIndexBuffer(sizeof(uint32_t)* SizeRenderIndexBuffer, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFMT_INDEX32, D3DPOOL_DEFAULT/*D3DPOOL_MANAGED*/, &RenderIndexBuffer, 0);
+				mem_release(m_pRenderIndexBuffer);
+				m_iSizeRenderIndexBuffer = model->m_pIndexCount[i];
+				CStaticGeom::m_pDXDevice->CreateIndexBuffer(sizeof(uint32_t)* m_iSizeRenderIndexBuffer, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFMT_INDEX32, D3DPOOL_DEFAULT/*D3DPOOL_MANAGED*/, &m_pRenderIndexBuffer, 0);
 			}
 
 			//char tmptex[1024];
 			//sprintf(tmptex, "%s.dds", model->ArrTextures[i]);
 
-			ngroup->idtex = tmpmodel->IDTex[i];// SGCore_LoadMtl(tmptex, MTL_GEOM);
-			ngroup->SortGroup = SGCore_MtlGetSort(ngroup->idtex);
-			ngroup->IsRenderSingly = SGCore_MtlGroupRenderIsSingly(ngroup->idtex);
-			ngroup->name = model->m_ppTextures[i];
-			AllGroups.push_back(ngroup);
+			ngroup->m_idTexture = tmpmodel->m_aIDsTexures[i];// SGCore_LoadMtl(tmptex, MTL_GEOM);
+			ngroup->m_iSortGroup = SGCore_MtlGetSort(ngroup->m_idTexture);
+			ngroup->m_isRenderSingly = SGCore_MtlGroupRenderIsSingly(ngroup->m_idTexture);
+			ngroup->m_sName = model->m_ppTextures[i];
+			m_aAllGroups.push_back(ngroup);
 		}
 
 
@@ -491,37 +493,37 @@ ID StaticGeom::AddModel(const char* path, const char* lod1, const char* name)
 
 		float3 tmpMM = SMVectorLerp(tmpMax, tmpMin, 0.5f);
 
-		D3DXPlaneFromPoints(&tmpmodel->SubSet[i].Plane,
+		D3DXPlaneFromPoints(&tmpmodel->m_aSubSets[i].m_oPlane,
 			&D3DXVECTOR3(pData[indeces[model->m_pStartIndex[i] + 0]].Pos.x, pData[indeces[model->m_pStartIndex[i] + 0]].Pos.y, pData[indeces[model->m_pStartIndex[i] + 0]].Pos.z),
 			&D3DXVECTOR3(pData[indeces[model->m_pStartIndex[i] + 1]].Pos.x, pData[indeces[model->m_pStartIndex[i] + 1]].Pos.y, pData[indeces[model->m_pStartIndex[i] + 1]].Pos.z),
 			&D3DXVECTOR3(pData[indeces[model->m_pStartIndex[i] + 2]].Pos.x, pData[indeces[model->m_pStartIndex[i] + 2]].Pos.y, pData[indeces[model->m_pStartIndex[i] + 2]].Pos.z));
 		model->m_pVertexBuffer->Unlock();
 		model->m_pIndexBuffer->Unlock();
 
-		tmpmodel->SubSet[i].Center = (float3_t)((tmpMax + tmpMin) * 0.5);
-		tmpmodel->SubSet[i].Min = tmpMin;
-		tmpmodel->SubSet[i].Max = tmpMax;
+		tmpmodel->m_aSubSets[i].m_vCenter = (float3_t)((tmpMax + tmpMin) * 0.5);
+		tmpmodel->m_aSubSets[i].m_vMin = tmpMin;
+		tmpmodel->m_aSubSets[i].m_vMax = tmpMax;
 	}
 
 	model->m_pVertexBuffer->Unlock();
 	model->m_pIndexBuffer->Unlock();
 
-	AllModels.push_back(tmpmodel);
+	m_aAllModels.push_back(tmpmodel);
 
-	SetModelLodPath(AllModels.size() - 1, lod1);
+	setModelLodPath(m_aAllModels.size() - 1, lod1);
 	
-	PreSegmentation(tmpmodel, model);
+	preSegmentation(tmpmodel, model);
 
-	SetSplitID(tmpmodel->ArrSplits, &tmpmodel->SplitsIDs, &tmpmodel->SplitsIDsRender);
+	setSplitID(tmpmodel->m_pArrSplits, &tmpmodel->m_idCountSplits, &tmpmodel->m_idCountSplitsRender);
 
-	AddModelInArrCom(AllModels.size() - 1);
+	addModelInArrCom(m_aAllModels.size() - 1);
 
-	InitArrIndexPtr();
+	initArrIndexPtr();
 
 	float3 jmin, jmax, jmin2, jmax2;
 
-	AllModels[AllModels.size()-1]->ArrSplits->BoundVolumeP->getMinMax(&jmin, &jmax);
-	BoundVolume->getMinMax(&jmin2, &jmax2);
+	m_aAllModels[m_aAllModels.size()-1]->m_pArrSplits->m_pBoundVolumeP->getMinMax(&jmin, &jmax);
+	m_pBoundVolume->getMinMax(&jmin2, &jmax2);
 
 	if (jmin2.x > jmin.x)
 		jmin2.x = jmin.x;
@@ -537,89 +539,89 @@ ID StaticGeom::AddModel(const char* path, const char* lod1, const char* name)
 	if (jmax2.z < jmax.z)
 		jmax2.z = jmax.z;
 
-	BoundVolume->setMinMax(&jmin2, &jmax2);
+	m_pBoundVolume->setMinMax(&jmin2, &jmax2);
 	
 	mem_release_del(model);
 
-	mem_delete_a(ArrMeshVertex);
-	mem_delete_a(ArrMeshIndex);
+	mem_delete_a(m_pCurrArrMeshVertex);
+	mem_delete_a(m_pCurrArrMeshIndex);
 
 	LibReport(0, " completed\n", path);
-	return AllModels.size() - 1;
+	return m_aAllModels.size() - 1;
 }
 
-void StaticGeom::DelModel(ID id)
+void CStaticGeom::deleteModel(ID id)
 {
-	if (id >= AllModels.size())
+	if (id >= m_aAllModels.size())
 		return;
 
-	Model* tmpmodel = AllModels[id];
+	CModel* tmpmodel = m_aAllModels[id];
 
 	//ПРЕЖДЕ НАДО ОЧИСТИТЬ БУФЕРЫ КОТОРЫЕ ЗАПОЛНЯЮТСЯ ИНДЕКСНЫМИ ДАННЫМИ, ИБО ПОСЛЕ УДАЛЕНИЯ МОДЕЛИ ДАННЫЕ ДЛЯ ОЧИТСКИ БУДУТ УЖЕ НЕКОРРЕТНЫЕ
-	DelArrIndexPtr();
+	deleteArrIndexPtr();
 
 	vertex_static* pData, *pData2, *pData3;
 	ID idgroup;
 	ID idbuff;
 
-	for (long i = 0; i < tmpmodel->SubSet.size(); ++i)
+	for (int i = 0; i < tmpmodel->m_aSubSets.size(); ++i)
 	{
-		idgroup = tmpmodel->SubSet[i].idgroup;
-		idbuff = tmpmodel->SubSet[i].idbuff;
+		idgroup = tmpmodel->m_aSubSets[i].m_idGroup;
+		idbuff = tmpmodel->m_aSubSets[i].m_idBuff;
 
-		long tmpcountvertexi = AllGroups[idgroup]->CountVertex[idbuff];
-		long tmpcountvertex = tmpmodel->SubSet[i].VertexCount;
-		long tmpcountstartvertex = tmpmodel->SubSet[i].VertexStart;
+		int tmpcountvertexi = m_aAllGroups[idgroup]->m_aCountVertex[idbuff];
+		int tmpcountvertex = tmpmodel->m_aSubSets[i].m_uiVertexCount;
+		int tmpcountstartvertex = tmpmodel->m_aSubSets[i].m_idVertexStart;
 
 		//если количество удаляемых вершин меньше чем общее количество вершин в буфере подгруппы
-		if (AllGroups[idgroup]->CountVertex[idbuff] > tmpmodel->SubSet[i].VertexCount)
+		if (m_aAllGroups[idgroup]->m_aCountVertex[idbuff] > tmpmodel->m_aSubSets[i].m_uiVertexCount)
 		{
 			//производим удаление, путем пересоздания есесно
 			IDirect3DVertexBuffer9* vb;
-			StaticGeom::DXDevice->CreateVertexBuffer(sizeof(vertex_static)* (AllGroups[idgroup]->CountVertex[idbuff] - tmpmodel->SubSet[i].VertexCount), NULL, NULL, D3DPOOL_MANAGED, &vb, 0);
+			CStaticGeom::m_pDXDevice->CreateVertexBuffer(sizeof(vertex_static)* (m_aAllGroups[idgroup]->m_aCountVertex[idbuff] - tmpmodel->m_aSubSets[i].m_uiVertexCount), NULL, NULL, D3DPOOL_MANAGED, &vb, 0);
 
 			/*Group::VertexBuff* vborigin = new Group::VertexBuff();
-			vborigin->count = (AllGroups[idgroup]->CountVertex[idbuff] - tmpmodel->SubSet[i].VertexCount);
+			vborigin->count = (m_aAllGroups[idgroup]->CountVertex[idbuff] - tmpmodel->m_aSubSets[i].VertexCount);
 			vborigin->arr = new float3_t[vborigin->count];*/
 
 			vb->Lock(0, 0, (void**)&pData, 0);
-			AllGroups[idgroup]->VertexBuffer[idbuff]->Lock(0, 0, (void**)&pData2, 0);
-			long tmpvertexstart = tmpmodel->SubSet[i].VertexStart;
-			memcpy(pData, pData2, sizeof(vertex_static)* tmpmodel->SubSet[i].VertexStart);
-			//memcpy(vborigin->arr, AllGroups[idgroup]->VertexBufferOrigin[idbuff]->arr, sizeof(float3_t)* tmpmodel->SubSet[i].VertexStart);
-			if (AllGroups[idgroup]->CountVertex[idbuff] - (tmpmodel->SubSet[i].VertexStart + tmpmodel->SubSet[i].VertexCount) > 0)
+			m_aAllGroups[idgroup]->m_aVertexBuffers[idbuff]->Lock(0, 0, (void**)&pData2, 0);
+			int tmpvertexstart = tmpmodel->m_aSubSets[i].m_idVertexStart;
+			memcpy(pData, pData2, sizeof(vertex_static)* tmpmodel->m_aSubSets[i].m_idVertexStart);
+			//memcpy(vborigin->arr, m_aAllGroups[idgroup]->VertexBufferOrigin[idbuff]->arr, sizeof(float3_t)* tmpmodel->m_aSubSets[i].VertexStart);
+			if (m_aAllGroups[idgroup]->m_aCountVertex[idbuff] - (tmpmodel->m_aSubSets[i].m_idVertexStart + tmpmodel->m_aSubSets[i].m_uiVertexCount) > 0)
 			{
-				memcpy(pData + tmpmodel->SubSet[i].VertexStart, pData2 + tmpmodel->SubSet[i].VertexStart + tmpmodel->SubSet[i].VertexCount, sizeof(vertex_static)* (AllGroups[idgroup]->CountVertex[idbuff] - (tmpmodel->SubSet[i].VertexStart + tmpmodel->SubSet[i].VertexCount)));
-				//memcpy(vborigin->arr + tmpmodel->SubSet[i].VertexStart, AllGroups[idgroup]->VertexBufferOrigin[idbuff]->arr + tmpmodel->SubSet[i].VertexStart + tmpmodel->SubSet[i].VertexCount, sizeof(float3_t)* (AllGroups[idgroup]->CountVertex[idbuff] - (tmpmodel->SubSet[i].VertexStart + tmpmodel->SubSet[i].VertexCount)));
+				memcpy(pData + tmpmodel->m_aSubSets[i].m_idVertexStart, pData2 + tmpmodel->m_aSubSets[i].m_idVertexStart + tmpmodel->m_aSubSets[i].m_uiVertexCount, sizeof(vertex_static)* (m_aAllGroups[idgroup]->m_aCountVertex[idbuff] - (tmpmodel->m_aSubSets[i].m_idVertexStart + tmpmodel->m_aSubSets[i].m_uiVertexCount)));
+				//memcpy(vborigin->arr + tmpmodel->m_aSubSets[i].VertexStart, m_aAllGroups[idgroup]->VertexBufferOrigin[idbuff]->arr + tmpmodel->m_aSubSets[i].VertexStart + tmpmodel->m_aSubSets[i].VertexCount, sizeof(float3_t)* (m_aAllGroups[idgroup]->CountVertex[idbuff] - (tmpmodel->m_aSubSets[i].VertexStart + tmpmodel->m_aSubSets[i].VertexCount)));
 
 			}
 
 			vb->Unlock();
-			AllGroups[idgroup]->VertexBuffer[idbuff]->Unlock();
+			m_aAllGroups[idgroup]->m_aVertexBuffers[idbuff]->Unlock();
 
 			//обновляем данные и производим замену
-			AllGroups[idgroup]->AllCountVertex -= tmpmodel->SubSet[i].VertexCount;
-			AllGroups[idgroup]->CountVertex[idbuff] -= tmpmodel->SubSet[i].VertexCount;
+			m_aAllGroups[idgroup]->m_iCountVertex -= tmpmodel->m_aSubSets[i].m_uiVertexCount;
+			m_aAllGroups[idgroup]->m_aCountVertex[idbuff] -= tmpmodel->m_aSubSets[i].m_uiVertexCount;
 
-			AllGroups[idgroup]->AllCountIndex -= tmpmodel->SubSet[i].IndexCount;
-			AllGroups[idgroup]->CountIndex[idbuff] -= tmpmodel->SubSet[i].IndexCount;
+			m_aAllGroups[idgroup]->m_iCountIndex -= tmpmodel->m_aSubSets[i].m_uiIndexCount;
+			m_aAllGroups[idgroup]->m_aCountIndex[idbuff] -= tmpmodel->m_aSubSets[i].m_uiIndexCount;
 
-			mem_release(AllGroups[idgroup]->VertexBuffer[idbuff]);
-			AllGroups[idgroup]->VertexBuffer[idbuff] = vb;
+			mem_release(m_aAllGroups[idgroup]->m_aVertexBuffers[idbuff]);
+			m_aAllGroups[idgroup]->m_aVertexBuffers[idbuff] = vb;
 
-			/*mem_delete(AllGroups[idgroup]->VertexBufferOrigin[idbuff]);
-			AllGroups[idgroup]->VertexBufferOrigin[idbuff] = vborigin;*/
+			/*mem_delete(m_aAllGroups[idgroup]->VertexBufferOrigin[idbuff]);
+			m_aAllGroups[idgroup]->VertexBufferOrigin[idbuff] = vborigin;*/
 		}
 		
 		//если количество моделей в массиве больше одной
-		if (AllGroups[idgroup]->ArrModels[idbuff].size() > 1)
+		if (m_aAllGroups[idgroup]->m_aModels[idbuff].size() > 1)
 		{
 			//находим удаляемую модель в массиве моделей в буфере данной подгруппы
-			long tmpidingroup = -1;	//id модели в текущем массиве, в подгруппе
-			for (int k = 0; k < AllGroups[idgroup]->ArrModels[idbuff].size(); ++k)
+			int tmpidingroup = -1;	//id модели в текущем массиве, в подгруппе
+			for (int k = 0; k < m_aAllGroups[idgroup]->m_aModels[idbuff].size(); ++k)
 			{
-				Model* tmptmpmodel = AllGroups[idgroup]->ArrModels[idbuff][k];
-				if (AllGroups[idgroup]->ArrModels[idbuff][k] == tmpmodel)
+				CModel* tmptmpmodel = m_aAllGroups[idgroup]->m_aModels[idbuff][k];
+				if (m_aAllGroups[idgroup]->m_aModels[idbuff][k] == tmpmodel)
 				{
 					tmpidingroup = k;
 					break;
@@ -634,43 +636,43 @@ void StaticGeom::DelModel(ID id)
 			}
 
 			//обновляем данные в подгруппе модели о стартовых позициях
-			for (int k = tmpidingroup + 1; k < AllGroups[idgroup]->ArrModels[idbuff].size(); ++k)
+			for (int k = tmpidingroup + 1; k < m_aAllGroups[idgroup]->m_aModels[idbuff].size(); ++k)
 			{
-				Model* tmptmpmodel = AllGroups[idgroup]->ArrModels[idbuff][k];
-				for (int j = 0; j < AllGroups[idgroup]->ArrModels[idbuff][k]->SubSet.size(); ++j)
+				CModel* tmptmpmodel = m_aAllGroups[idgroup]->m_aModels[idbuff][k];
+				for (int j = 0; j < m_aAllGroups[idgroup]->m_aModels[idbuff][k]->m_aSubSets.size(); ++j)
 				{
-					if (tmptmpmodel->SubSet[j].idgroup == idgroup)
+					if (tmptmpmodel->m_aSubSets[j].m_idGroup == idgroup)
 					{
-						tmptmpmodel->SubSet[j].IndexStart -= tmpmodel->SubSet[i].IndexCount;
-						tmptmpmodel->SubSet[j].VertexStart -= tmpmodel->SubSet[i].VertexCount;
+						tmptmpmodel->m_aSubSets[j].m_idIndexStart -= tmpmodel->m_aSubSets[i].m_uiIndexCount;
+						tmptmpmodel->m_aSubSets[j].m_idVertexStart -= tmpmodel->m_aSubSets[i].m_uiVertexCount;
 
 						break;
 					}
 				}
 
 				//обновляем также все индексы во всех сплитах
-				Array<Segment*, GEOM_DEFAULT_RESERVE_COM> queue;
-				queue.push_back(AllGroups[idgroup]->ArrModels[idbuff][k]->ArrSplits);
+				Array<CSegment*, GEOM_DEFAULT_RESERVE_COM> queue;
+				queue.push_back(m_aAllGroups[idgroup]->m_aModels[idbuff][k]->m_pArrSplits);
 
 				while (queue.size())
 				{
-					if (queue[0]->BFNonEnd)
+					if (queue[0]->m_isNonEnd)
 					{
 						for (int j = 0; j < GEOM_COUNT_TYPE_SEGMENTATION_OCTO; ++j)
 						{
-							if (queue[0]->Splits[j])
-								queue.push_back(queue[0]->Splits[j]);
+							if (queue[0]->m_aSplits[j])
+								queue.push_back(queue[0]->m_aSplits[j]);
 						}
 					}
 					else
 					{
-						for (int j = 0; j < queue[0]->CountSubSet; ++j)
+						for (int j = 0; j < queue[0]->m_uiCountSubSet; ++j)
 						{
-							if (queue[0]->NumberGroup[j] == idgroup )
+							if (queue[0]->m_pNumberGroup[j] == idgroup )
 							{
-								for (int q = 0; q < queue[0]->CountPoly[j]*3; ++q)
+								for (int q = 0; q < queue[0]->m_pCountPoly[j]*3; ++q)
 								{
-									queue[0]->ArrPoly[j][q] -= tmpmodel->SubSet[i].VertexCount;
+									queue[0]->m_ppArrPoly[j][q] -= tmpmodel->m_aSubSets[i].m_uiVertexCount;
 								}
 							}
 						}
@@ -681,67 +683,67 @@ void StaticGeom::DelModel(ID id)
 			}
 
 			//удал¤ем текущую удал¤емую модель из массива моделей буфера текущей подгруппы
-			AllGroups[idgroup]->ArrModels[idbuff].erase(tmpidingroup);
+			m_aAllGroups[idgroup]->m_aModels[idbuff].erase(tmpidingroup);
 		}
 		//если в буфере подгруппы всего одна модель, то значит эта та модель которую удаляем
-		else if (AllGroups[idgroup]->ArrModels[idbuff].size() == 1)
-			AllGroups[idgroup]->ArrModels[idbuff].erase(0);
+		else if (m_aAllGroups[idgroup]->m_aModels[idbuff].size() == 1)
+			m_aAllGroups[idgroup]->m_aModels[idbuff].erase(0);
 		
 		//если количество удалемых вершин больше либо равно количеству имеющихся в буфере подгруппы
 		if (tmpcountvertexi <= tmpcountvertex)
 		{
 			//то теряется смысл данного буфера, и надо его удалить
 
-			Group* tmpgroup = AllGroups[idgroup];
+			CGroup* tmpgroup = m_aAllGroups[idgroup];
 
-			tmpgroup->CountVertex.erase(idbuff);
-			tmpgroup->CountIndex.erase(idbuff);
-			mem_release(tmpgroup->VertexBuffer[idbuff]);
-			//IDirect3DVertexBuffer9* vb = AllGroups[idgroup]->VertexBuffer[idbuff];
-			tmpgroup->VertexBuffer.erase(idbuff);
-			tmpgroup->ArrModels.erase(idbuff);
-			//Group::VertexBuff* tmpduff = AllGroups[idgroup]->VertexBufferOrigin[idbuff];
+			tmpgroup->m_aCountVertex.erase(idbuff);
+			tmpgroup->m_aCountIndex.erase(idbuff);
+			mem_release(tmpgroup->m_aVertexBuffers[idbuff]);
+			//IDirect3DVertexBuffer9* vb = m_aAllGroups[idgroup]->VertexBuffer[idbuff];
+			tmpgroup->m_aVertexBuffers.erase(idbuff);
+			tmpgroup->m_aModels.erase(idbuff);
+			//Group::VertexBuff* tmpduff = m_aAllGroups[idgroup]->VertexBufferOrigin[idbuff];
 			/*mem_delete(tmpgroup->VertexBufferOrigin[idbuff]);
 			tmpgroup->VertexBufferOrigin.erase(idbuff);*/
 		}
 
 		//если подгруппа пустая, то обрабатываем все значения что больше идентификатора группы
-		if (AllGroups[idgroup]->CountVertex.size() <= 0)
+		if (m_aAllGroups[idgroup]->m_aCountVertex.size() <= 0)
 		{
-			//Group* tmpgroup = AllGroups[idgroup];
+			//Group* tmpgroup = m_aAllGroups[idgroup];
 			
 			//то есть декрементируем все идентфиикаторы подгрупп которые больше чем текущая удаляемая подгруппа
 			//декремент произодим и у текущей удаляемой модели, ибо все будет смещено, а значит и в этой моделе должно быть все смещенно для корретных просчетов
-			for (int k = 0; k < AllModels.size(); ++k)
+			for (int k = 0; k < m_aAllModels.size(); ++k)
 			{
-				Model* tmptmpmodel = AllModels[k];
+				CModel* tmptmpmodel = m_aAllModels[k];
 
-				for (long j = 0; j < tmptmpmodel->SubSet.size(); ++j)
+				for (int j = 0; j < tmptmpmodel->m_aSubSets.size(); ++j)
 				{
-					if (tmptmpmodel->SubSet[j].idgroup > idgroup)
-						--(tmptmpmodel->SubSet[j].idgroup);
+					if (tmptmpmodel->m_aSubSets[j].m_idGroup > idgroup)
+						--(tmptmpmodel->m_aSubSets[j].m_idGroup);
 				}
 
 				//также проходимся и по всем сплитам чтобы и там произвести декремент
-				Array<Segment*, GEOM_DEFAULT_RESERVE_COM> queue;
-				queue.push_back(tmptmpmodel->ArrSplits);
+				Array<CSegment*, GEOM_DEFAULT_RESERVE_COM> queue;
+				queue.push_back(tmptmpmodel->m_pArrSplits);
 
 				while (queue.size())
 				{
-					if (queue[0]->BFNonEnd)
+					if (queue[0]->m_isNonEnd)
 					{
 						for (int j = 0; j < GEOM_COUNT_TYPE_SEGMENTATION_OCTO; ++j)
 						{
-							if (queue[0]->Splits[j])
-								queue.push_back(queue[0]->Splits[j]);
+							if (queue[0]->m_aSplits[j])
+								queue.push_back(queue[0]->m_aSplits[j]);
 						}
 					}
 					else
 					{
-						for (int j = 0; j < queue[0]->CountSubSet; ++j)
+						for (int j = 0; j < queue[0]->m_uiCountSubSet; ++j)
 						{
-							if (queue[0]->NumberGroup[j] > idgroup)
-								--(queue[0]->NumberGroup[j]);
+							if (queue[0]->m_pNumberGroup[j] > idgroup)
+								--(queue[0]->m_pNumberGroup[j]);
 						}
 					}
 
@@ -750,16 +752,16 @@ void StaticGeom::DelModel(ID id)
 			}
 
 			//удаляем подгруппу, за ненадобностью
-			mem_delete(AllGroups[idgroup]);
-			AllGroups.erase(idgroup);
+			mem_delete(m_aAllGroups[idgroup]);
+			m_aAllGroups.erase(idgroup);
 		}
 		//если подгруппа не пустая то может быть тогда можно где-то совместить буферы?
 		else
 		{
-			for (long k = 0; k < AllGroups[idgroup]->VertexBuffer.size(); ++k)
+			for (int k = 0; k < m_aAllGroups[idgroup]->m_aVertexBuffers.size(); ++k)
 			{
 				//можно ли совместить буферы
-				if (idbuff != k && AllGroups[idgroup]->CountIndex[idbuff] / 3 + AllGroups[idgroup]->CountIndex[k] / 3 <= GEOM_MAX_POLY_IN_GROUP)
+				if (idbuff != k && m_aAllGroups[idgroup]->m_aCountIndex[idbuff] / 3 + m_aAllGroups[idgroup]->m_aCountIndex[k] / 3 <= GEOM_MAX_POLY_IN_GROUP)
 				{
 					//СОВМЕЩАЕМ ТЕКУЩИЙ ОБРАБАТЫВАЕМЫЙ БУФЕР (idbuff) (ИЗ КОТОРОГО МОДЕЛЬ БЫЛА УДАЛЕНА С БУФЕРОМ В КОТОРЙ ОН ВМЕЩАЕТСЯ (k)
 					//idbuff => k
@@ -767,74 +769,74 @@ void StaticGeom::DelModel(ID id)
 					//производим совмещение данных в буферах
 					//{
 					IDirect3DVertexBuffer9* vb;
-					StaticGeom::DXDevice->CreateVertexBuffer(sizeof(vertex_static)* (AllGroups[idgroup]->CountVertex[idbuff] + AllGroups[idgroup]->CountVertex[k]), NULL, NULL, D3DPOOL_MANAGED, &vb, 0);
+					CStaticGeom::m_pDXDevice->CreateVertexBuffer(sizeof(vertex_static)* (m_aAllGroups[idgroup]->m_aCountVertex[idbuff] + m_aAllGroups[idgroup]->m_aCountVertex[k]), NULL, NULL, D3DPOOL_MANAGED, &vb, 0);
 
 					/*Group::VertexBuff* vborigin = new Group::VertexBuff();
-					vborigin->count = (AllGroups[idgroup]->CountVertex[idbuff] + AllGroups[idgroup]->CountVertex[k]);
+					vborigin->count = (m_aAllGroups[idgroup]->CountVertex[idbuff] + m_aAllGroups[idgroup]->CountVertex[k]);
 					vborigin->arr = new float3_t[vborigin->count];*/
 
 					vb->Lock(0, 0, (void**)&pData, 0);
-					AllGroups[idgroup]->VertexBuffer[idbuff]->Lock(0, 0, (void**)&pData2, 0);
-					AllGroups[idgroup]->VertexBuffer[k]->Lock(0, 0, (void**)&pData3, 0);
+					m_aAllGroups[idgroup]->m_aVertexBuffers[idbuff]->Lock(0, 0, (void**)&pData2, 0);
+					m_aAllGroups[idgroup]->m_aVertexBuffers[k]->Lock(0, 0, (void**)&pData3, 0);
 
-					memcpy(pData, pData3, sizeof(vertex_static)* AllGroups[idgroup]->CountVertex[k]);
-					//memcpy(vborigin->arr, AllGroups[idgroup]->VertexBufferOrigin[k]->arr, sizeof(float3_t)* AllGroups[idgroup]->CountVertex[k]);
+					memcpy(pData, pData3, sizeof(vertex_static)* m_aAllGroups[idgroup]->m_aCountVertex[k]);
+					//memcpy(vborigin->arr, m_aAllGroups[idgroup]->VertexBufferOrigin[k]->arr, sizeof(float3_t)* m_aAllGroups[idgroup]->CountVertex[k]);
 
-					memcpy(pData + AllGroups[idgroup]->CountVertex[k], pData2, sizeof(vertex_static)* AllGroups[idgroup]->CountVertex[idbuff]);
-					//memcpy(vborigin->arr + AllGroups[idgroup]->CountVertex[k], AllGroups[idgroup]->VertexBufferOrigin[idbuff]->arr, sizeof(float3_t)* AllGroups[idgroup]->CountVertex[idbuff]);
+					memcpy(pData + m_aAllGroups[idgroup]->m_aCountVertex[k], pData2, sizeof(vertex_static)* m_aAllGroups[idgroup]->m_aCountVertex[idbuff]);
+					//memcpy(vborigin->arr + m_aAllGroups[idgroup]->CountVertex[k], m_aAllGroups[idgroup]->VertexBufferOrigin[idbuff]->arr, sizeof(float3_t)* m_aAllGroups[idgroup]->CountVertex[idbuff]);
 
 					vb->Unlock();
-					AllGroups[idgroup]->VertexBuffer[idbuff]->Unlock();
-					AllGroups[idgroup]->VertexBuffer[k]->Unlock();
+					m_aAllGroups[idgroup]->m_aVertexBuffers[idbuff]->Unlock();
+					m_aAllGroups[idgroup]->m_aVertexBuffers[k]->Unlock();
 					//}
 
 					//обновляем данные во всех моделях которые есть в текущем буфере
-					for (long m = 0; m < AllGroups[idgroup]->ArrModels[idbuff].size(); ++m)
+					for (int m = 0; m < m_aAllGroups[idgroup]->m_aModels[idbuff].size(); ++m)
 					{
-						long tmpsizearrmodls = AllGroups[idgroup]->ArrModels[idbuff].size();
-						Model* tmptmpmodel = AllGroups[idgroup]->ArrModels[idbuff][m];
+						int tmpsizearrmodls = m_aAllGroups[idgroup]->m_aModels[idbuff].size();
+						CModel* tmptmpmodel = m_aAllGroups[idgroup]->m_aModels[idbuff][m];
 						//обновляем данные в структуре инфе о перемещенном буфере
-						for (long j = 0; j < tmptmpmodel->SubSet.size(); ++j)
+						for (int j = 0; j < tmptmpmodel->m_aSubSets.size(); ++j)
 						{
-							if (tmptmpmodel->SubSet[j].idgroup == idgroup)
+							if (tmptmpmodel->m_aSubSets[j].m_idGroup == idgroup)
 							{
 								//а именно, текущий буфер
 								if (idbuff > k)
-									tmptmpmodel->SubSet[j].idbuff = k;
+									tmptmpmodel->m_aSubSets[j].m_idBuff = k;
 								else
-									tmptmpmodel->SubSet[j].idbuff = k - 1;
+									tmptmpmodel->m_aSubSets[j].m_idBuff = k - 1;
 
 								//и стартовые позиции
-								tmptmpmodel->SubSet[j].IndexStart += AllGroups[idgroup]->CountIndex[k];
-								tmptmpmodel->SubSet[j].VertexStart += AllGroups[idgroup]->CountVertex[k];
+								tmptmpmodel->m_aSubSets[j].m_idIndexStart += m_aAllGroups[idgroup]->m_aCountIndex[k];
+								tmptmpmodel->m_aSubSets[j].m_idVertexStart += m_aAllGroups[idgroup]->m_aCountVertex[k];
 								break;
 							}
 						}
 
 						//обновляем все индексы модели текущей подгруппы перемещенного буфера
 						//{
-						Array<Segment*, GEOM_DEFAULT_RESERVE_COM> queue;
-						queue.push_back(tmptmpmodel->ArrSplits);
+						Array<CSegment*, GEOM_DEFAULT_RESERVE_COM> queue;
+						queue.push_back(tmptmpmodel->m_pArrSplits);
 
 						while (queue.size())
 						{
-							if (queue[0]->BFNonEnd)
+							if (queue[0]->m_isNonEnd)
 							{
 								for (int j = 0; j < GEOM_COUNT_TYPE_SEGMENTATION_OCTO; ++j)
 								{
-									if (queue[0]->Splits[j])
-										queue.push_back(queue[0]->Splits[j]);
+									if (queue[0]->m_aSplits[j])
+										queue.push_back(queue[0]->m_aSplits[j]);
 								}
 							}
 							else
 							{
-								for (int j = 0; j < queue[0]->CountSubSet; ++j)
+								for (int j = 0; j < queue[0]->m_uiCountSubSet; ++j)
 								{
-									if (queue[0]->NumberGroup[j] == idgroup)
+									if (queue[0]->m_pNumberGroup[j] == idgroup)
 									{
-										for (int q = 0; q < queue[0]->CountPoly[j] * 3; ++q)
+										for (int q = 0; q < queue[0]->m_pCountPoly[j] * 3; ++q)
 										{
-											queue[0]->ArrPoly[j][q] += AllGroups[idgroup]->CountVertex[k];
+											queue[0]->m_ppArrPoly[j][q] += m_aAllGroups[idgroup]->m_aCountVertex[k];
 										}
 									}
 								}
@@ -848,15 +850,15 @@ void StaticGeom::DelModel(ID id)
 					//обновляем информацию во всех моделях у которых такая же подгруппа, но которые находились в буферах "выше"
 					//сообщаем что они стали ниже на единицу
 					//{
-					for (long j = idbuff+1; j < AllGroups[idgroup]->ArrModels.size(); ++j)
+					for (int j = idbuff+1; j < m_aAllGroups[idgroup]->m_aModels.size(); ++j)
 					{
-						for (long q = 0; q < AllGroups[idgroup]->ArrModels[j].size(); ++q)
+						for (int q = 0; q < m_aAllGroups[idgroup]->m_aModels[j].size(); ++q)
 						{
-							for (long g = 0; g < AllGroups[idgroup]->ArrModels[j][q]->SubSet.size(); ++g)
+							for (int g = 0; g < m_aAllGroups[idgroup]->m_aModels[j][q]->m_aSubSets.size(); ++g)
 							{
-								if (AllGroups[idgroup]->ArrModels[j][q]->SubSet[g].idgroup == idgroup && AllGroups[idgroup]->ArrModels[j][q]->SubSet[g].idbuff > idbuff)
+								if (m_aAllGroups[idgroup]->m_aModels[j][q]->m_aSubSets[g].m_idGroup == idgroup && m_aAllGroups[idgroup]->m_aModels[j][q]->m_aSubSets[g].m_idBuff > idbuff)
 								{
-									--(AllGroups[idgroup]->ArrModels[j][q]->SubSet[g].idbuff);
+									--(m_aAllGroups[idgroup]->m_aModels[j][q]->m_aSubSets[g].m_idBuff);
 								}
 							}
 						}
@@ -865,28 +867,28 @@ void StaticGeom::DelModel(ID id)
 
 					//обновляем информацию в k буфере, по ходу удаляем информацию в idbuff буфере
 					//{
-					AllGroups[idgroup]->CountVertex[k] += AllGroups[idgroup]->CountVertex[idbuff];
-					AllGroups[idgroup]->CountIndex[k] += AllGroups[idgroup]->CountIndex[idbuff];
+					m_aAllGroups[idgroup]->m_aCountVertex[k] += m_aAllGroups[idgroup]->m_aCountVertex[idbuff];
+					m_aAllGroups[idgroup]->m_aCountIndex[k] += m_aAllGroups[idgroup]->m_aCountIndex[idbuff];
 
-					mem_release(AllGroups[idgroup]->VertexBuffer[k]);
-					mem_release(AllGroups[idgroup]->VertexBuffer[idbuff]);
-					AllGroups[idgroup]->VertexBuffer[k] = vb;
+					mem_release(m_aAllGroups[idgroup]->m_aVertexBuffers[k]);
+					mem_release(m_aAllGroups[idgroup]->m_aVertexBuffers[idbuff]);
+					m_aAllGroups[idgroup]->m_aVertexBuffers[k] = vb;
 
-					/*mem_delete(AllGroups[idgroup]->VertexBufferOrigin[k]);
-					mem_delete(AllGroups[idgroup]->VertexBufferOrigin[idbuff]);
-					AllGroups[idgroup]->VertexBufferOrigin[k] = vborigin;*/
+					/*mem_delete(m_aAllGroups[idgroup]->VertexBufferOrigin[k]);
+					mem_delete(m_aAllGroups[idgroup]->VertexBufferOrigin[idbuff]);
+					m_aAllGroups[idgroup]->VertexBufferOrigin[k] = vborigin;*/
 
 					//перемещаем все модели из idbuff буфера в тот с которым совмещаем
-					for (long m = 0; m < AllGroups[idgroup]->ArrModels[idbuff].size(); ++m)
-						AllGroups[idgroup]->ArrModels[k].push_back(AllGroups[idgroup]->ArrModels[idbuff][m]);
+					for (int m = 0; m < m_aAllGroups[idgroup]->m_aModels[idbuff].size(); ++m)
+						m_aAllGroups[idgroup]->m_aModels[k].push_back(m_aAllGroups[idgroup]->m_aModels[idbuff][m]);
 
-					AllGroups[idgroup]->CountVertex.erase(idbuff);
-					AllGroups[idgroup]->CountIndex.erase(idbuff);
+					m_aAllGroups[idgroup]->m_aCountVertex.erase(idbuff);
+					m_aAllGroups[idgroup]->m_aCountIndex.erase(idbuff);
 
-					AllGroups[idgroup]->ArrModels.erase(idbuff);
+					m_aAllGroups[idgroup]->m_aModels.erase(idbuff);
 					
-					AllGroups[idgroup]->VertexBuffer.erase(idbuff);
-					//AllGroups[idgroup]->VertexBufferOrigin.erase(idbuff);
+					m_aAllGroups[idgroup]->m_aVertexBuffers.erase(idbuff);
+					//m_aAllGroups[idgroup]->VertexBufferOrigin.erase(idbuff);
 					//}
 					
 					//ПРЕРЫВАЕМ ЦИКЛ, ТАК КАК УЖЕ ОБЪЕДИНИЛИ И ЭТОГО ХВАТИТ
@@ -897,33 +899,33 @@ void StaticGeom::DelModel(ID id)
 	}
 
 	//удаляем модель из просчетов, как объект, и из массива тоже
-	DelModelInArrCom(id);
-	mem_delete(AllModels[id]);
-	AllModels.erase(id);
+	deleteModelInArrCom(id);
+	mem_delete(m_aAllModels[id]);
+	m_aAllModels.erase(id);
 
 	//реинициализируем буферы для индексных данных рендера
-	InitArrIndexPtr();
+	initArrIndexPtr();
 }
 
-void StaticGeom::SetSplitID(Segment* Split, ID* SplitsIDs, ID* SplitsIDsRender)
+void CStaticGeom::setSplitID(CSegment* Split, ID* SplitsIDs, ID* SplitsIDsRender)
 {
-	Array<Segment*> queue;
-	long tmpcount = 0;
+	Array<CSegment*> queue;
+	int tmpcount = 0;
 	queue.push_back(Split);
 
 	while (queue.size())
 	{
-		if (queue[0] && queue[0]->BFNonEnd)
+		if (queue[0] && queue[0]->m_isNonEnd)
 		{
-			queue[0]->ID = (*SplitsIDs);
+			queue[0]->m_ID = (*SplitsIDs);
 			++(*SplitsIDs);
 			for (int i = 0; i<GEOM_COUNT_TYPE_SEGMENTATION_OCTO; i++)
-				queue.push_back(queue[0]->Splits[i]);
+				queue.push_back(queue[0]->m_aSplits[i]);
 		}
 		else if (queue[0])
 		{
-			queue[0]->ID = (*SplitsIDs);
-			queue[0]->SID = (*SplitsIDsRender);
+			queue[0]->m_ID = (*SplitsIDs);
+			queue[0]->m_SID = (*SplitsIDsRender);
 			++(*SplitsIDs);
 			++(*SplitsIDsRender);
 		}
@@ -933,119 +935,121 @@ void StaticGeom::SetSplitID(Segment* Split, ID* SplitsIDs, ID* SplitsIDsRender)
 	}
 }
 
-void StaticGeom::DelArrIndexPtr()
+void CStaticGeom::deleteArrIndexPtr()
 {
-	if (RTCPUArrIndicesPtrs)
+	if (m_pppRTArrIndices)
 	{
-		for (long i = 0; i<AllGroups.size(); i++)
+		for (int i = 0; i < m_aAllGroups.size(); ++i)
 		{
-			for (long k = 0; k < AllGroups[i]->VertexBuffer.size(); ++k)
+			for (int k = 0; k < m_aAllGroups[i]->m_aVertexBuffers.size(); ++k)
 			{
-				mem_delete_a(RTCPUArrIndicesPtrs[i][k]);
-				mem_delete_a(RTCountDrawPolyModel[i][k]);
-				mem_delete_a(RTBeginIndexModel[i][k]);
+				mem_delete_a(m_pppRTArrIndices[i][k]);
+				mem_delete_a(m_pppRTCountDrawPolyModel[i][k]);
+				mem_delete_a(m_pppRTBeginIndexModel[i][k]);
 			}
-			mem_delete_a(RTCountDrawPoly[i]);
-			mem_delete_a(RTCountDrawPolyModel[i]);
-			mem_delete_a(RTBeginIndexModel[i]);
-			mem_delete_a(RTCPUArrIndicesPtrs[i]);
+			mem_delete_a(m_ppRTCountDrawPoly[i]);
+			mem_delete_a(m_pppRTCountDrawPolyModel[i]);
+			mem_delete_a(m_pppRTBeginIndexModel[i]);
+			mem_delete_a(m_pppRTArrIndices[i]);
 		}
 
-		mem_delete_a(RTCountDrawPoly);
-		mem_delete_a(RTCountDrawPolyModel);
-		mem_delete_a(RTBeginIndexModel);
-		mem_delete_a(RTCPUArrIndicesPtrs);
+		mem_delete_a(m_ppRTCountDrawPoly);
+		mem_delete_a(m_pppRTCountDrawPolyModel);
+		mem_delete_a(m_pppRTBeginIndexModel);
+		mem_delete_a(m_pppRTArrIndices);
 	}
 }
 
-void StaticGeom::InitArrIndexPtr()
+void CStaticGeom::initArrIndexPtr()
 {
-	RTCPUArrIndicesPtrs = new uint32_t**[AllGroups.size()];
-	RTCountDrawPoly = new uint32_t*[AllGroups.size()];
-	RTCountDrawPolyModel = new uint32_t**[AllGroups.size()];
-	RTBeginIndexModel = new uint32_t**[AllGroups.size()];
+	m_pppRTArrIndices = new uint32_t**[m_aAllGroups.size()];
+	m_ppRTCountDrawPoly = new uint32_t*[m_aAllGroups.size()];
+	m_pppRTCountDrawPolyModel = new uint32_t**[m_aAllGroups.size()];
+	m_pppRTBeginIndexModel = new uint32_t**[m_aAllGroups.size()];
 
-	for (DWORD i = 0; i<AllGroups.size(); i++)
+	for (int i = 0; i<m_aAllGroups.size(); i++)
 	{
-		RTCountDrawPoly[i] = new uint32_t[AllGroups[i]->VertexBuffer.size()];
-		RTCPUArrIndicesPtrs[i] = new uint32_t*[AllGroups[i]->VertexBuffer.size()];
-		RTCountDrawPolyModel[i] = new uint32_t*[AllGroups[i]->VertexBuffer.size()];
-		RTBeginIndexModel[i] = new uint32_t*[AllGroups[i]->VertexBuffer.size()];
+		m_ppRTCountDrawPoly[i] = new uint32_t[m_aAllGroups[i]->m_aVertexBuffers.size()];
+		m_pppRTArrIndices[i] = new uint32_t*[m_aAllGroups[i]->m_aVertexBuffers.size()];
+		m_pppRTCountDrawPolyModel[i] = new uint32_t*[m_aAllGroups[i]->m_aVertexBuffers.size()];
+		m_pppRTBeginIndexModel[i] = new uint32_t*[m_aAllGroups[i]->m_aVertexBuffers.size()];
 
-			for (long k = 0; k < AllGroups[i]->VertexBuffer.size(); ++k)
-			{
-				RTCPUArrIndicesPtrs[i][k] = new uint32_t[AllGroups[i]->CountIndex[k]];
-				RTCountDrawPolyModel[i][k] = new uint32_t[AllGroups[i]->ArrModels[k].size()];
-				RTBeginIndexModel[i][k] = new uint32_t[AllGroups[i]->ArrModels[k].size()];
-			}
+		for (int k = 0; k < m_aAllGroups[i]->m_aVertexBuffers.size(); ++k)
+		{
+			m_pppRTArrIndices[i][k] = new uint32_t[m_aAllGroups[i]->m_aCountIndex[k]];
+			m_pppRTCountDrawPolyModel[i][k] = new uint32_t[m_aAllGroups[i]->m_aModels[k].size()];
+			m_pppRTBeginIndexModel[i][k] = new uint32_t[m_aAllGroups[i]->m_aModels[k].size()];
+		}
 	}
 }
 
 
-void StaticGeom::CPUFillingArrIndeces(const ISXFrustum* frustum, float3* viewpos, ID id_arr)
+void CStaticGeom::comArrIndeces(const ISXFrustum* frustum, const float3* viewpos, ID id_arr)
 {
 	STATIC_PRECOND_ARRCOMFOR_ERR_ID(id_arr);
 
-	DWORD tmpcount = 0;
-	DWORD* tmpcountcom = 0;
-	Segment** tmpsegments = 0;
+	int tmpcount = 0;
+	int* tmpcountcom = 0;
+	CSegment** tmpsegments = 0;
 	float jradius;
 	float3 jcenter;
 
-	for(int i = 0, l = AllModels.size(); i < l; ++i)
+	for(int i = 0, l = m_aAllModels.size(); i < l; ++i)
 	{
 		if (id_arr == 0)
 		{
-			AllModels[i]->ArrSplits->BoundVolumeP->getSphere(&jcenter, &jradius);
-			AllModels[i]->ArrSplits->DistForCamera = SMVector3Length((jcenter - (*viewpos))) - jradius;
+			m_aAllModels[i]->m_pArrSplits->m_pBoundVolumeP->getSphere(&jcenter, &jradius);
+			m_aAllModels[i]->m_pArrSplits->m_fDistForCamera = SMVector3Length((jcenter - (*viewpos))) - jradius;
 		}
 
-		if (AllModels[i]->ArrSplits->DistForCamera >= StaticGeom::DistForLod && AllModels[i]->Lod0.model)
-			AllModels[i]->IsRenderLod = true;
+		if (m_aAllModels[i]->m_pArrSplits->m_fDistForCamera >= CStaticGeom::m_fDistForLod && m_aAllModels[i]->m_oLod0.m_pModel)
+			m_aAllModels[i]->m_isRenderLod = true;
 		else
 		{
-			AllModels[i]->IsRenderLod = false;
-			tmpcount = ArrComFor[id_arr]->arr[i]->Count;
-			ArrComFor[id_arr]->arr[i]->CountCom = 0;
-			tmpcountcom = &(ArrComFor[id_arr]->arr[i]->CountCom);
-			tmpsegments = ArrComFor[id_arr]->arr[i]->Arr;
+			m_aAllModels[i]->m_isRenderLod = false;
+			tmpcount = m_aArrComFor[id_arr]->m_aIRS[i]->m_iCount;
+			m_aArrComFor[id_arr]->m_aIRS[i]->m_iCountCom = 0;
+			tmpcountcom = &(m_aArrComFor[id_arr]->m_aIRS[i]->m_iCountCom);
+			tmpsegments = m_aArrComFor[id_arr]->m_aIRS[i]->m_ppSegments;
 
-			ArrComFor[id_arr]->queue.push_back(AllModels[i]->ArrSplits);
+			m_aArrComFor[id_arr]->m_aQueue.push_back(m_aAllModels[i]->m_pArrSplits);
 
-			while (ArrComFor[id_arr]->queue.size())
+			while (m_aArrComFor[id_arr]->m_aQueue.size())
 			{
-				ComRecArrIndeces(frustum, tmpsegments, tmpcountcom, ArrComFor[id_arr]->queue[0], viewpos, &ArrComFor[id_arr]->queue, tmpcount);
+				comRecArrIndeces(frustum, tmpsegments, tmpcountcom, m_aArrComFor[id_arr]->m_aQueue[0], viewpos, &m_aArrComFor[id_arr]->m_aQueue, tmpcount);
 
-				ArrComFor[id_arr]->queue.erase(0);
+				m_aArrComFor[id_arr]->m_aQueue.erase(0);
 				++tmpcount;
 			}
+
+			m_aArrComFor[id_arr]->m_aQueue.clear();
 		}
 
 		int qwert = 0;
 	}
 }
 
-void StaticGeom::ComRecArrIndeces(const ISXFrustum* frustum, Segment** arrsplits, DWORD *count, Segment* comsegment, float3* viewpos, Array<Segment*, GEOM_DEFAULT_RESERVE_COM>* queue, ID curr_splits_ids_render)
+void CStaticGeom::comRecArrIndeces(const ISXFrustum* frustum, CSegment** arrsplits, int *count, CSegment* comsegment, const float3* viewpos, Array<CSegment*, GEOM_DEFAULT_RESERVE_COM>* queue, ID curr_splits_ids_render)
 {
 	float jradius;
 	float3 jcenter;
-	comsegment->BoundVolumeP->getSphere(&jcenter, &jradius);
+	comsegment->m_pBoundVolumeP->getSphere(&jcenter, &jradius);
 
-	if (comsegment->CountAllPoly > 0 && (frustum->sphereInFrustum(&jcenter, jradius)))
+	if (comsegment->m_uiCountAllPoly > 0 && (frustum->sphereInFrustum(&jcenter, jradius)))
 	{
-			if (comsegment->BFNonEnd )
+			if (comsegment->m_isNonEnd )
 			{
-				if (StaticGeom::UseSortFrontToBackSplits)
+				if (CStaticGeom::m_isUseSortFrontToBackSplits)
 				{
-					long SortId[GEOM_COUNT_TYPE_SEGMENTATION_OCTO];
+					int SortId[GEOM_COUNT_TYPE_SEGMENTATION_OCTO];
 					float DistFor[GEOM_COUNT_TYPE_SEGMENTATION_OCTO];
 
 					for (int q = 0; q<GEOM_COUNT_TYPE_SEGMENTATION_OCTO; ++q)
 					{
 						SortId[q] = -1;
-						if (comsegment->Splits[q])
+						if (comsegment->m_aSplits[q])
 						{
-							comsegment->Splits[q]->BoundVolumeP->getSphere(&jcenter, &jradius);
+							comsegment->m_aSplits[q]->m_pBoundVolumeP->getSphere(&jcenter, &jradius);
 							DistFor[q] = SMVector3Length2((jcenter - (*viewpos))) - jradius*jradius;
 						}
 					}
@@ -1054,14 +1058,14 @@ void StaticGeom::ComRecArrIndeces(const ISXFrustum* frustum, Segment** arrsplits
 					int tmpCountGreater = 0;
 					for (int i = 0; i<GEOM_COUNT_TYPE_SEGMENTATION_OCTO; ++i)
 					{
-						if (comsegment->Splits[i])
+						if (comsegment->m_aSplits[i])
 						{
 							tmpCountGreater = 0;
 							pl1 = DistFor[i];
 
 							for (int k = 0; k<GEOM_COUNT_TYPE_SEGMENTATION_OCTO; ++k)
 							{
-								if (comsegment->Splits[k])
+								if (comsegment->m_aSplits[k])
 								{
 									pl2 = DistFor[k];
 
@@ -1086,16 +1090,16 @@ void StaticGeom::ComRecArrIndeces(const ISXFrustum* frustum, Segment** arrsplits
 
 					for (int j = 0; j<GEOM_COUNT_TYPE_SEGMENTATION_OCTO; ++j)
 					{
-						if (SortId[(GEOM_COUNT_TYPE_SEGMENTATION_OCTO - 1) - j] != -1 && comsegment->Splits[SortId[(GEOM_COUNT_TYPE_SEGMENTATION_OCTO - 1) - j]])
-							queue->push_back(comsegment->Splits[SortId[(GEOM_COUNT_TYPE_SEGMENTATION_OCTO - 1) - j]]);
+						if (SortId[(GEOM_COUNT_TYPE_SEGMENTATION_OCTO - 1) - j] != -1 && comsegment->m_aSplits[SortId[(GEOM_COUNT_TYPE_SEGMENTATION_OCTO - 1) - j]])
+							queue->push_back(comsegment->m_aSplits[SortId[(GEOM_COUNT_TYPE_SEGMENTATION_OCTO - 1) - j]]);
 					}
 				}
 				else
 				{
 					for (int j = 0; j<GEOM_COUNT_TYPE_SEGMENTATION_OCTO; ++j)
 					{
-						if (comsegment->Splits[j])
-							queue->push_back(comsegment->Splits[j]);
+						if (comsegment->m_aSplits[j])
+							queue->push_back(comsegment->m_aSplits[j]);
 					}
 				}
 			}
@@ -1104,7 +1108,7 @@ void StaticGeom::ComRecArrIndeces(const ISXFrustum* frustum, Segment** arrsplits
 				if ((*count) < curr_splits_ids_render)
 				{
 					arrsplits[(*count)] = comsegment;
-					comsegment->DistForCamera = SMVector3Length((jcenter - (*viewpos))) - jradius;
+					comsegment->m_fDistForCamera = SMVector3Length((jcenter - (*viewpos))) - jradius;
 					(*count)++;
 				}
 				/*else
@@ -1115,29 +1119,29 @@ void StaticGeom::ComRecArrIndeces(const ISXFrustum* frustum, Segment** arrsplits
 	}
 }
 
-bool StaticGeom::SortExistsForRender(int sort, ID id_arr)
+bool CStaticGeom::sortExistsForRender(int sort, ID id_arr)
 {
 	//валиден ли id_arr?
 	STATIC_PRECOND_ARRCOMFOR_ERR_ID(id_arr);
 
-	Segment** jarrsplits;
+	CSegment** jarrsplits;
 	ID jidbuff;
 	ID jnumgroup;
 
 	//проходимся по всем моделям
-	for (int i = 0, l = AllModels.size(); i < l; ++i)
+	for (int i = 0, l = m_aAllModels.size(); i < l; ++i)
 	{
-		if (ArrComFor[id_arr]->arr[i]->CountCom > 0)
+		if (m_aArrComFor[id_arr]->m_aIRS[i]->m_iCountCom > 0)
 		{
-			for (int j = 0, jl = ArrComFor[id_arr]->arr[i]->CountCom; j<jl; j++)
+			for (int j = 0, jl = m_aArrComFor[id_arr]->m_aIRS[i]->m_iCountCom; j<jl; j++)
 			{
-				jarrsplits = ArrComFor[id_arr]->arr[i]->Arr;
-				for (int k = 0; k<jarrsplits[j]->CountSubSet; ++k)
+				jarrsplits = m_aArrComFor[id_arr]->m_aIRS[i]->m_ppSegments;
+				for (int k = 0; k<jarrsplits[j]->m_uiCountSubSet; ++k)
 				{
-					jidbuff = AllModels[i]->SubSet[jarrsplits[j]->NumberGroupModel[k]].idbuff;
-					jnumgroup = jarrsplits[j]->NumberGroup[k];
+					jidbuff = m_aAllModels[i]->m_aSubSets[jarrsplits[j]->m_pNumberGroupModel[k]].m_idBuff;
+					jnumgroup = jarrsplits[j]->m_pNumberGroup[k];
 
-					if (SGCore_MtlGetSort(AllGroups[jnumgroup]->idtex) == sort)
+					if (SGCore_MtlGetSort(m_aAllGroups[jnumgroup]->m_idTexture) == sort)
 						return true;
 				}
 			}
@@ -1147,72 +1151,72 @@ bool StaticGeom::SortExistsForRender(int sort, ID id_arr)
 	return false;
 }
 
-void StaticGeom::GPURender(DWORD timeDelta, int sort_mtl, ID id_arr, ID exclude_model_id, ID exclude_group_id, bool is_sorted)
+void CStaticGeom::render(DWORD timeDelta, int sort_mtl, ID id_arr, ID exclude_model_id, ID exclude_group_id, bool is_sorted)
 {
 	//валиден ли id_arr?
 	STATIC_PRECOND_ARRCOMFOR_ERR_ID(id_arr);
 
-	Segment** jarrsplits;
+	CSegment** jarrsplits;
 	ID jidbuff;
 	ID jnumgroup;
 	
 	//обнуляем все данные об отрисованном в прошлый раз
-	for (int i = 0; i < AllGroups.size(); i++)
+	for (int i = 0; i < m_aAllGroups.size(); i++)
 	{
-		if (AllGroups[i])
+		if (m_aAllGroups[i])
 		{
-			for (int k = 0; k < AllGroups[i]->VertexBuffer.size(); ++k)
+			for (int k = 0; k < m_aAllGroups[i]->m_aVertexBuffers.size(); ++k)
 			{
-				RTCountDrawPoly[i][k] = 0;
+				m_ppRTCountDrawPoly[i][k] = 0;
 
-				for (int j = 0; j < AllGroups[i]->ArrModels[k].size(); ++j)
+				for (int j = 0; j < m_aAllGroups[i]->m_aModels[k].size(); ++j)
 				{
-					RTCountDrawPolyModel[i][k][j] = 0;
-					RTBeginIndexModel[i][k][j] = -1;
+					m_pppRTCountDrawPolyModel[i][k][j] = 0;
+					m_pppRTBeginIndexModel[i][k][j] = -1;
 				}
 			}
 		}
 	}
 	
 	//проходимся по всем моделям
-	for(int i = 0, l = AllModels.size(); i < l; ++i)
+	for(int i = 0, l = m_aAllModels.size(); i < l; ++i)
 	{
 		if (exclude_model_id == i && exclude_group_id < 0)
 			continue;
 
-		if (AllModels[i]->IsRenderLod)
+		if (m_aAllModels[i]->m_isRenderLod)
 		{
-			StaticGeom::DXDevice->SetStreamSource(0, AllModels[i]->Lod0.model->m_pVertexBuffer, 0, sizeof(vertex_static));
-			StaticGeom::DXDevice->SetIndices(AllModels[i]->Lod0.model->m_pIndexBuffer);
-			StaticGeom::DXDevice->SetVertexDeclaration(SGCore_StaticModelGetDecl());
-			for (int k = 0, kl = AllModels[i]->Lod0.model->m_uiSubsetCount; k < kl; ++k)
+			CStaticGeom::m_pDXDevice->SetStreamSource(0, m_aAllModels[i]->m_oLod0.m_pModel->m_pVertexBuffer, 0, sizeof(vertex_static));
+			CStaticGeom::m_pDXDevice->SetIndices(m_aAllModels[i]->m_oLod0.m_pModel->m_pIndexBuffer);
+			CStaticGeom::m_pDXDevice->SetVertexDeclaration(SGCore_StaticModelGetDecl());
+			for (int k = 0, kl = m_aAllModels[i]->m_oLod0.m_pModel->m_uiSubsetCount; k < kl; ++k)
 			{
-				if (AllModels[i]->Lod0.SortGroup == sort_mtl || sort_mtl == -1)
+				if (m_aAllModels[i]->m_oLod0.m_iSortGroup == sort_mtl || sort_mtl == -1)
 				{
-					SGCore_MtlSet(AllModels[i]->Lod0.IDsTexs[k], 0);
-					SGCore_DIP(D3DPT_TRIANGLELIST, 0, 0, AllModels[i]->Lod0.model->m_pVertexCount[k], AllModels[i]->Lod0.model->m_pStartIndex[k], AllModels[i]->Lod0.model->m_pIndexCount[k] / 3);
-					Core_RIntSet(G_RI_INT_COUNT_POLY, Core_RIntGet(G_RI_INT_COUNT_POLY) + AllModels[i]->Lod0.model->m_pIndexCount[k] / 3);
+					SGCore_MtlSet(m_aAllModels[i]->m_oLod0.m_aIDsTextures[k], 0);
+					SGCore_DIP(D3DPT_TRIANGLELIST, 0, 0, m_aAllModels[i]->m_oLod0.m_pModel->m_pVertexCount[k], m_aAllModels[i]->m_oLod0.m_pModel->m_pStartIndex[k], m_aAllModels[i]->m_oLod0.m_pModel->m_pIndexCount[k] / 3);
+					Core_RIntSet(G_RI_INT_COUNT_POLY, Core_RIntGet(G_RI_INT_COUNT_POLY) + m_aAllModels[i]->m_oLod0.m_pModel->m_pIndexCount[k] / 3);
 				}
 			}
 		}
-		else if (ArrComFor[id_arr]->arr[i]->CountCom > 0)
+		else if (m_aArrComFor[id_arr]->m_aIRS[i]->m_iCountCom > 0)
 		{
-			for(DWORD j = 0, jl = ArrComFor[id_arr]->arr[i]->CountCom; j<jl; j++)
+			for (DWORD j = 0, jl = m_aArrComFor[id_arr]->m_aIRS[i]->m_iCountCom; j<jl; j++)
 			{
-				jarrsplits = ArrComFor[id_arr]->arr[i]->Arr;
-				for (DWORD k = 0; k<jarrsplits[j]->CountSubSet; ++k)
+				jarrsplits = m_aArrComFor[id_arr]->m_aIRS[i]->m_ppSegments;
+				for (DWORD k = 0; k<jarrsplits[j]->m_uiCountSubSet; ++k)
 				{
-					jidbuff = AllModels[i]->SubSet[jarrsplits[j]->NumberGroupModel[k]].idbuff;
-					jnumgroup = jarrsplits[j]->NumberGroup[k];
+					jidbuff = m_aAllModels[i]->m_aSubSets[jarrsplits[j]->m_pNumberGroupModel[k]].m_idBuff;
+					jnumgroup = jarrsplits[j]->m_pNumberGroup[k];
 
-					if (exclude_model_id >= 0 && exclude_group_id == jarrsplits[j]->NumberGroupModel[k])
+					if (exclude_model_id >= 0 && exclude_group_id == jarrsplits[j]->m_pNumberGroupModel[k])
 						continue;
 
 					ID tmpcurrmodel = -1;
 
-					for(int q = 0, ql = AllGroups[jnumgroup]->ArrModels[jidbuff].size(); q<ql; ++q)
+					for(int q = 0, ql = m_aAllGroups[jnumgroup]->m_aModels[jidbuff].size(); q<ql; ++q)
 					{
-						if (AllGroups[jnumgroup]->ArrModels[jidbuff][q] == AllModels[i])
+						if (m_aAllGroups[jnumgroup]->m_aModels[jidbuff][q] == m_aAllModels[i])
 						{
 							tmpcurrmodel = q;
 							break;
@@ -1224,26 +1228,26 @@ void StaticGeom::GPURender(DWORD timeDelta, int sort_mtl, ID id_arr, ID exclude_
 						int qwert = 0;
 					}
 
-					int currsort = AllGroups[jnumgroup]->SortGroup;
+					int currsort = m_aAllGroups[jnumgroup]->m_iSortGroup;
 
-					if (AllGroups[jnumgroup]->SortGroup == sort_mtl || sort_mtl == -1)
+					if (m_aAllGroups[jnumgroup]->m_iSortGroup == sort_mtl || sort_mtl == -1)
 					{
 						if (
-							jarrsplits[j]->CountPoly[k] > 0 &&	//если количество полигонов больше 0
-							RTCountDrawPoly[jnumgroup][jidbuff] + jarrsplits[j]->CountPoly[k] <= AllGroups[jnumgroup]->CountIndex[jidbuff] / 3 	//если количество записанных полигонов в данную подгруппу меньше либо равно общему количеству полигонов которое содержит данна¤ подгруппа
+							jarrsplits[j]->m_pCountPoly[k] > 0 &&	//если количество полигонов больше 0
+							m_ppRTCountDrawPoly[jnumgroup][jidbuff] + jarrsplits[j]->m_pCountPoly[k] <= m_aAllGroups[jnumgroup]->m_aCountIndex[jidbuff] / 3 	//если количество записанных полигонов в данную подгруппу меньше либо равно общему количеству полигонов которое содержит данна¤ подгруппа
 							)
 						{
-							memcpy(RTCPUArrIndicesPtrs[jnumgroup][jidbuff] + (RTCountDrawPoly[jnumgroup][jidbuff] * 3),
-								jarrsplits[j]->ArrPoly[k],
-								jarrsplits[j]->CountPoly[k] * sizeof(uint32_t)* 3);
+							memcpy(m_pppRTArrIndices[jnumgroup][jidbuff] + (m_ppRTCountDrawPoly[jnumgroup][jidbuff] * 3),
+								jarrsplits[j]->m_ppArrPoly[k],
+								jarrsplits[j]->m_pCountPoly[k] * sizeof(uint32_t)* 3);
 
-							if (RTBeginIndexModel[jnumgroup][jidbuff][tmpcurrmodel] == -1)
+							if (m_pppRTBeginIndexModel[jnumgroup][jidbuff][tmpcurrmodel] == -1)
 							{
-								RTBeginIndexModel[jnumgroup][jidbuff][tmpcurrmodel] = RTCountDrawPoly[jnumgroup][jidbuff];
+								m_pppRTBeginIndexModel[jnumgroup][jidbuff][tmpcurrmodel] = m_ppRTCountDrawPoly[jnumgroup][jidbuff];
 							}
 
-							RTCountDrawPoly[jnumgroup][jidbuff] += jarrsplits[j]->CountPoly[k];
-							RTCountDrawPolyModel[jnumgroup][jidbuff][tmpcurrmodel] += jarrsplits[j]->CountPoly[k];
+							m_ppRTCountDrawPoly[jnumgroup][jidbuff] += jarrsplits[j]->m_pCountPoly[k];
+							m_pppRTCountDrawPolyModel[jnumgroup][jidbuff][tmpcurrmodel] += jarrsplits[j]->m_pCountPoly[k];
 						}
 					}
 				}
@@ -1258,57 +1262,57 @@ void StaticGeom::GPURender(DWORD timeDelta, int sort_mtl, ID id_arr, ID exclude_
 	if (!is_sorted)
 	{
 		//проходимся по всем подгруппам
-		for(int i = 0, l = AllGroups.size(); i < l; ++i)
+		for(int i = 0, l = m_aAllGroups.size(); i < l; ++i)
 		{
-			Group* tmpgroup = AllGroups[i];
-			if (!tmpgroup || tmpgroup->CountVertex.size() <= 0 || !(tmpgroup->SortGroup == sort_mtl || sort_mtl == -1))
+			CGroup* tmpgroup = m_aAllGroups[i];
+			if (!tmpgroup || tmpgroup->m_aCountVertex.size() <= 0 || !(tmpgroup->m_iSortGroup == sort_mtl || sort_mtl == -1))
 				continue;
 
 			//проходимся по всем буферам
-			for(int k = 0, kl = tmpgroup->VertexBuffer.size(); k<kl; ++k)
+			for (int k = 0, kl = tmpgroup->m_aVertexBuffers.size(); k<kl; ++k)
 			{
 				//если есть что к отрисовке
-				if (RTCountDrawPoly[i][k] > 0)
+				if (m_ppRTCountDrawPoly[i][k] > 0)
 				{
-					RenderIndexBuffer->Lock(0, 0, (void**)&(RTGPUArrIndicesPtrs2), D3DLOCK_DISCARD);
-					memcpy(RTGPUArrIndicesPtrs2, RTCPUArrIndicesPtrs[i][k], RTCountDrawPoly[i][k] * 3 * sizeof(uint32_t));
-					RenderIndexBuffer->Unlock();
+					m_pRenderIndexBuffer->Lock(0, 0, (void**)&(RTGPUArrIndicesPtrs2), D3DLOCK_DISCARD);
+					memcpy(RTGPUArrIndicesPtrs2, m_pppRTArrIndices[i][k], m_ppRTCountDrawPoly[i][k] * 3 * sizeof(uint32_t));
+					m_pRenderIndexBuffer->Unlock();
 
-					StaticGeom::DXDevice->SetStreamSource(0, tmpgroup->VertexBuffer[k], 0, sizeof(vertex_static));
-					StaticGeom::DXDevice->SetIndices(RenderIndexBuffer);
-					StaticGeom::DXDevice->SetVertexDeclaration(SGCore_StaticModelGetDecl());
+					CStaticGeom::m_pDXDevice->SetStreamSource(0, tmpgroup->m_aVertexBuffers[k], 0, sizeof(vertex_static));
+					CStaticGeom::m_pDXDevice->SetIndices(m_pRenderIndexBuffer);
+					CStaticGeom::m_pDXDevice->SetVertexDeclaration(SGCore_StaticModelGetDecl());
 
 					//если на данную подгруппу назначен раздельный рендер
-					if (tmpgroup->IsRenderSingly)
+					if (tmpgroup->m_isRenderSingly)
 					{
-						long tmpprevcountindex = 0;
+						int tmpprevcountindex = 0;
 
-						for(int j = 0, jl = tmpgroup->ArrModels[k].size(); j < jl; ++j)
+						for(int j = 0, jl = tmpgroup->m_aModels[k].size(); j < jl; ++j)
 						{
-							if (RTCountDrawPolyModel[i][k][j] > 0)
+							if (m_pppRTCountDrawPolyModel[i][k][j] > 0)
 							{
 								//ищем id материала подгруппы
 								//общий id использовать нельзя так как не зря стоит раздельный рендер
-								for (int q = 0; q < tmpgroup->ArrModels[k][j]->IDTex.size(); ++q)
+								for (int q = 0; q < tmpgroup->m_aModels[k][j]->m_aIDsTexures.size(); ++q)
 								{
-									if (i == tmpgroup->ArrModels[k][j]->SubSet[q].idgroup)
+									if (i == tmpgroup->m_aModels[k][j]->m_aSubSets[q].m_idGroup)
 									{
-										SGCore_MtlSet(tmpgroup->ArrModels[k][j]->IDTex[q], 0);
+										SGCore_MtlSet(tmpgroup->m_aModels[k][j]->m_aIDsTexures[q], 0);
 										break;
 									}
 								}
 								
-								SGCore_DIP(D3DPT_TRIANGLELIST, 0, 0, tmpgroup->CountVertex[k], tmpprevcountindex * 3, RTCountDrawPolyModel[i][k][j]);
-								tmpprevcountindex += RTCountDrawPolyModel[i][k][j];
-								Core_RIntSet(G_RI_INT_COUNT_POLY, Core_RIntGet(G_RI_INT_COUNT_POLY) + RTCountDrawPolyModel[i][k][j]);
+								SGCore_DIP(D3DPT_TRIANGLELIST, 0, 0, tmpgroup->m_aCountVertex[k], tmpprevcountindex * 3, m_pppRTCountDrawPolyModel[i][k][j]);
+								tmpprevcountindex += m_pppRTCountDrawPolyModel[i][k][j];
+								Core_RIntSet(G_RI_INT_COUNT_POLY, Core_RIntGet(G_RI_INT_COUNT_POLY) + m_pppRTCountDrawPolyModel[i][k][j]);
 							}
 						}
 					}
 					else
 					{
-						SGCore_MtlSet(tmpgroup->idtex, 0);
-						SGCore_DIP(D3DPT_TRIANGLELIST, 0, 0, tmpgroup->CountVertex[k], 0, RTCountDrawPoly[i][k]);
-						Core_RIntSet(G_RI_INT_COUNT_POLY, Core_RIntGet(G_RI_INT_COUNT_POLY) + RTCountDrawPoly[i][k]);
+						SGCore_MtlSet(tmpgroup->m_idTexture, 0);
+						SGCore_DIP(D3DPT_TRIANGLELIST, 0, 0, tmpgroup->m_aCountVertex[k], 0, m_ppRTCountDrawPoly[i][k]);
+						Core_RIntSet(G_RI_INT_COUNT_POLY, Core_RIntGet(G_RI_INT_COUNT_POLY) + m_ppRTCountDrawPoly[i][k]);
 					}
 				}
 			}
@@ -1317,142 +1321,142 @@ void StaticGeom::GPURender(DWORD timeDelta, int sort_mtl, ID id_arr, ID exclude_
 	//иначе рисуем по сортированному списку
 	else
 	{
-		for (int i = 0; i < DistGroup.size(); ++i)
+		for (int i = 0; i < m_aDistGroup.size(); ++i)
 		{
-			InfoGroup* tmpig = DistGroup[i];
-			Group* tmpgroup = AllGroups[tmpig->g_group];
+			CInfoGroup* tmpig = m_aDistGroup[i];
+			CGroup* tmpgroup = m_aAllGroups[tmpig->m_idGlobalGroup];
 
-			if (!tmpgroup || tmpgroup->CountVertex.size() <= 0 || !(tmpgroup->SortGroup == sort_mtl || sort_mtl == -1))
+			if (!tmpgroup || tmpgroup->m_aCountVertex.size() <= 0 || !(tmpgroup->m_iSortGroup == sort_mtl || sort_mtl == -1))
 				continue;
 
-			if (exclude_model_id == tmpig->model && (exclude_group_id < 0 || exclude_group_id == tmpig->group))
+			if (exclude_model_id == tmpig->m_idModel && (exclude_group_id < 0 || exclude_group_id == tmpig->m_idGroup))
 				continue;
 
-			ID id_buff = AllModels[tmpig->model]->SubSet[tmpig->group].idbuff;
+			ID id_buff = m_aAllModels[tmpig->m_idModel]->m_aSubSets[tmpig->m_idGroup].m_idBuff;
 
-			if (RTCountDrawPoly[tmpig->g_group][id_buff] > 0)
+			if (m_ppRTCountDrawPoly[tmpig->m_idGlobalGroup][id_buff] > 0)
 			{
 				ID id_model;
-				for (int j = 0; j < tmpgroup->ArrModels[id_buff].size(); ++j)
+				for (int j = 0; j < tmpgroup->m_aModels[id_buff].size(); ++j)
 				{
-					if (tmpgroup->ArrModels[id_buff][j] == AllModels[tmpig->model])
+					if (tmpgroup->m_aModels[id_buff][j] == m_aAllModels[tmpig->m_idModel])
 					{
 						id_model = j;
 						break;
 					}
 				}
 
-				RenderIndexBuffer->Lock(0, 0, (void**)&(RTGPUArrIndicesPtrs2), D3DLOCK_DISCARD);
-				memcpy(RTGPUArrIndicesPtrs2, RTCPUArrIndicesPtrs[tmpig->g_group][id_buff], RTCountDrawPoly[tmpig->g_group][id_buff]/*RTCountDrawPolyModel[tmpig->g_group][id_buff][id_model]*/ * 3 * sizeof(uint32_t));
-				RenderIndexBuffer->Unlock();
+				m_pRenderIndexBuffer->Lock(0, 0, (void**)&(RTGPUArrIndicesPtrs2), D3DLOCK_DISCARD);
+				memcpy(RTGPUArrIndicesPtrs2, m_pppRTArrIndices[tmpig->m_idGlobalGroup][id_buff], m_ppRTCountDrawPoly[tmpig->m_idGlobalGroup][id_buff]/*m_pppRTCountDrawPolyModel[tmpig->m_idGlobalGroup][id_buff][id_model]*/ * 3 * sizeof(uint32_t));
+				m_pRenderIndexBuffer->Unlock();
 
-				StaticGeom::DXDevice->SetStreamSource(0, tmpgroup->VertexBuffer[id_buff], 0, sizeof(vertex_static));
-				StaticGeom::DXDevice->SetIndices(RenderIndexBuffer);
-				StaticGeom::DXDevice->SetVertexDeclaration(SGCore_StaticModelGetDecl());
+				CStaticGeom::m_pDXDevice->SetStreamSource(0, tmpgroup->m_aVertexBuffers[id_buff], 0, sizeof(vertex_static));
+				CStaticGeom::m_pDXDevice->SetIndices(m_pRenderIndexBuffer);
+				CStaticGeom::m_pDXDevice->SetVertexDeclaration(SGCore_StaticModelGetDecl());
 
 
 
-				long tmpprevcountindex = AllModels[tmpig->model]->SubSet[tmpig->group].IndexStart/3;
+				int tmpprevcountindex = m_aAllModels[tmpig->m_idModel]->m_aSubSets[tmpig->m_idGroup].m_idIndexStart / 3;
 				
 
-				if (RTCountDrawPolyModel[tmpig->g_group][id_buff][id_model] > 0)
+				if (m_pppRTCountDrawPolyModel[tmpig->m_idGlobalGroup][id_buff][id_model] > 0)
 				{
 					//ищем id материала подгруппы
-					for (int q = 0; q < tmpgroup->ArrModels[id_buff][id_model]->IDTex.size(); ++q)
+					for (int q = 0; q < tmpgroup->m_aModels[id_buff][id_model]->m_aIDsTexures.size(); ++q)
 					{
-						if (tmpig->g_group == tmpgroup->ArrModels[id_buff][id_model]->SubSet[q].idgroup)
+						if (tmpig->m_idGlobalGroup == tmpgroup->m_aModels[id_buff][id_model]->m_aSubSets[q].m_idGroup)
 						{
-							SGCore_MtlSet(tmpgroup->ArrModels[id_buff][id_model]->IDTex[q], 0);
+							SGCore_MtlSet(tmpgroup->m_aModels[id_buff][id_model]->m_aIDsTexures[q], 0);
 							break;
 						}
 					}
-					SGCore_DIP(D3DPT_TRIANGLELIST, 0, 0, tmpgroup->CountVertex[id_buff], RTBeginIndexModel[tmpig->g_group][id_buff][id_model] * 3, RTCountDrawPolyModel[tmpig->g_group][id_buff][id_model]);
-					tmpprevcountindex += RTCountDrawPolyModel[tmpig->g_group][id_buff][id_model];
-					Core_RIntSet(G_RI_INT_COUNT_POLY, Core_RIntGet(G_RI_INT_COUNT_POLY) + RTCountDrawPolyModel[tmpig->g_group][id_buff][id_model]);
+					SGCore_DIP(D3DPT_TRIANGLELIST, 0, 0, tmpgroup->m_aCountVertex[id_buff], m_pppRTBeginIndexModel[tmpig->m_idGlobalGroup][id_buff][id_model] * 3, m_pppRTCountDrawPolyModel[tmpig->m_idGlobalGroup][id_buff][id_model]);
+					tmpprevcountindex += m_pppRTCountDrawPolyModel[tmpig->m_idGlobalGroup][id_buff][id_model];
+					Core_RIntSet(G_RI_INT_COUNT_POLY, Core_RIntGet(G_RI_INT_COUNT_POLY) + m_pppRTCountDrawPolyModel[tmpig->m_idGlobalGroup][id_buff][id_model]);
 				}
 			}
 		}
 	}
 }
 
-void StaticGeom::GPURenderSingly(DWORD timeDelta, ID id, ID id_tex)
+void CStaticGeom::renderSingly(DWORD timeDelta, ID id, ID id_tex)
 {
 	STATIC_PRECOND_ARRCOMFOR_ERR_ID_MODEL(id, _VOID);
-	Segment** jarrsplits;
-	long jidbuff;
-	long jnumgroup;
+	CSegment** jarrsplits;
+	int jidbuff;
+	int jnumgroup;
 
 	//обнуляем все данные об отрисованном в прошлый раз
-	for (int i = 0; i < AllGroups.size(); i++)
+	for (int i = 0; i < m_aAllGroups.size(); i++)
 	{
-		if (AllGroups[i])
+		if (m_aAllGroups[i])
 		{
-			for (int k = 0; k < AllGroups[i]->VertexBuffer.size(); ++k)
+			for (int k = 0; k < m_aAllGroups[i]->m_aVertexBuffers.size(); ++k)
 			{
-				RTCountDrawPoly[i][k] = 0;
+				m_ppRTCountDrawPoly[i][k] = 0;
 
-				for (int j = 0; j < AllGroups[i]->ArrModels[k].size(); ++j)
+				for (int j = 0; j < m_aAllGroups[i]->m_aModels[k].size(); ++j)
 				{
-					RTCountDrawPolyModel[i][k][j] = 0;
-					RTBeginIndexModel[i][k][j] = -1;
+					m_pppRTCountDrawPolyModel[i][k][j] = 0;
+					m_pppRTBeginIndexModel[i][k][j] = -1;
 				}
 			}
 		}
 	}
 
 
-	if (AllModels[id]->IsRenderLod)
+	if (m_aAllModels[id]->m_isRenderLod)
 	{
-		StaticGeom::DXDevice->SetStreamSource(0, AllModels[id]->Lod0.model->m_pVertexBuffer, 0, sizeof(vertex_static));
-		StaticGeom::DXDevice->SetIndices(AllModels[id]->Lod0.model->m_pIndexBuffer);
-		StaticGeom::DXDevice->SetVertexDeclaration(SGCore_StaticModelGetDecl());
-		for (int k = 0, kl = AllModels[id]->Lod0.model->m_uiSubsetCount; k < kl; ++k)
+		CStaticGeom::m_pDXDevice->SetStreamSource(0, m_aAllModels[id]->m_oLod0.m_pModel->m_pVertexBuffer, 0, sizeof(vertex_static));
+		CStaticGeom::m_pDXDevice->SetIndices(m_aAllModels[id]->m_oLod0.m_pModel->m_pIndexBuffer);
+		CStaticGeom::m_pDXDevice->SetVertexDeclaration(SGCore_StaticModelGetDecl());
+		for (int k = 0, kl = m_aAllModels[id]->m_oLod0.m_pModel->m_uiSubsetCount; k < kl; ++k)
 		{
-			SGCore_MtlSet((id_tex > 0 ? id_tex : AllModels[id]->Lod0.IDsTexs[k]), 0);
-			SGCore_DIP(D3DPT_TRIANGLELIST, 0, 0, AllModels[id]->Lod0.model->m_pVertexCount[k], AllModels[id]->Lod0.model->m_pStartIndex[k], AllModels[id]->Lod0.model->m_pIndexCount[k] / 3);
-			Core_RIntSet(G_RI_INT_COUNT_POLY, Core_RIntGet(G_RI_INT_COUNT_POLY) + AllModels[id]->Lod0.model->m_pIndexCount[k] / 3);
+			SGCore_MtlSet((id_tex > 0 ? id_tex : m_aAllModels[id]->m_oLod0.m_aIDsTextures[k]), 0);
+			SGCore_DIP(D3DPT_TRIANGLELIST, 0, 0, m_aAllModels[id]->m_oLod0.m_pModel->m_pVertexCount[k], m_aAllModels[id]->m_oLod0.m_pModel->m_pStartIndex[k], m_aAllModels[id]->m_oLod0.m_pModel->m_pIndexCount[k] / 3);
+			Core_RIntSet(G_RI_INT_COUNT_POLY, Core_RIntGet(G_RI_INT_COUNT_POLY) + m_aAllModels[id]->m_oLod0.m_pModel->m_pIndexCount[k] / 3);
 		}
 	}
-	else if (ArrComFor[0]->arr[id]->CountCom > 0)
+	else if (m_aArrComFor[0]->m_aIRS[id]->m_iCountCom > 0)
 	{
-		for (DWORD j = 0, jl = ArrComFor[0]->arr[id]->CountCom; j < jl; j++)
+		for (DWORD j = 0, jl = m_aArrComFor[0]->m_aIRS[id]->m_iCountCom; j < jl; j++)
 		{
-			jarrsplits = ArrComFor[0]->arr[id]->Arr;
-			for (DWORD k = 0; k < jarrsplits[j]->CountSubSet; ++k)
+			jarrsplits = m_aArrComFor[0]->m_aIRS[id]->m_ppSegments;
+			for (DWORD k = 0; k < jarrsplits[j]->m_uiCountSubSet; ++k)
 			{
-				jidbuff = AllModels[id]->SubSet[jarrsplits[j]->NumberGroupModel[k]].idbuff;
-				jnumgroup = jarrsplits[j]->NumberGroup[k];
+				jidbuff = m_aAllModels[id]->m_aSubSets[jarrsplits[j]->m_pNumberGroupModel[k]].m_idBuff;
+				jnumgroup = jarrsplits[j]->m_pNumberGroup[k];
 
 				ID tmpcurrmodel = -1;
 
-				for (int q = 0, ql = AllGroups[jnumgroup]->ArrModels[jidbuff].size(); q < ql; ++q)
+				for (int q = 0, ql = m_aAllGroups[jnumgroup]->m_aModels[jidbuff].size(); q < ql; ++q)
 				{
-					if (AllGroups[jnumgroup]->ArrModels[jidbuff][q] == AllModels[id])
+					if (m_aAllGroups[jnumgroup]->m_aModels[jidbuff][q] == m_aAllModels[id])
 					{
 						tmpcurrmodel = q;
 						break;
 					}
 				}
 
-				int currsort = AllGroups[jnumgroup]->SortGroup;
+				int currsort = m_aAllGroups[jnumgroup]->m_iSortGroup;
 
 				
 					if (
-						jarrsplits[j]->CountPoly[k] > 0 &&	//если количество полигонов больше 0
-						RTCountDrawPoly[jnumgroup][jidbuff] + jarrsplits[j]->CountPoly[k] <= AllGroups[jnumgroup]->CountIndex[jidbuff] / 3 	//если количество записанных полигонов в данную подгруппу меньше либо равно общему количеству полигонов которое содержит данна¤ подгруппа
+						jarrsplits[j]->m_pCountPoly[k] > 0 &&	//если количество полигонов больше 0
+						m_ppRTCountDrawPoly[jnumgroup][jidbuff] + jarrsplits[j]->m_pCountPoly[k] <= m_aAllGroups[jnumgroup]->m_aCountIndex[jidbuff] / 3 	//если количество записанных полигонов в данную подгруппу меньше либо равно общему количеству полигонов которое содержит данна¤ подгруппа
 						)
 					{
-						memcpy(RTCPUArrIndicesPtrs[jnumgroup][jidbuff] + (RTCountDrawPoly[jnumgroup][jidbuff] * 3),
-							jarrsplits[j]->ArrPoly[k],
-							jarrsplits[j]->CountPoly[k] * sizeof(uint32_t)* 3);
+						memcpy(m_pppRTArrIndices[jnumgroup][jidbuff] + (m_ppRTCountDrawPoly[jnumgroup][jidbuff] * 3),
+							jarrsplits[j]->m_ppArrPoly[k],
+							jarrsplits[j]->m_pCountPoly[k] * sizeof(uint32_t)* 3);
 
-						if (RTBeginIndexModel[jnumgroup][jidbuff][tmpcurrmodel] == -1)
+						if (m_pppRTBeginIndexModel[jnumgroup][jidbuff][tmpcurrmodel] == -1)
 						{
-							RTBeginIndexModel[jnumgroup][jidbuff][tmpcurrmodel] = RTCountDrawPoly[jnumgroup][jidbuff];
+							m_pppRTBeginIndexModel[jnumgroup][jidbuff][tmpcurrmodel] = m_ppRTCountDrawPoly[jnumgroup][jidbuff];
 						}
 
-						RTCountDrawPoly[jnumgroup][jidbuff] += jarrsplits[j]->CountPoly[k];
-						RTCountDrawPolyModel[jnumgroup][jidbuff][tmpcurrmodel] += jarrsplits[j]->CountPoly[k];
+						m_ppRTCountDrawPoly[jnumgroup][jidbuff] += jarrsplits[j]->m_pCountPoly[k];
+						m_pppRTCountDrawPolyModel[jnumgroup][jidbuff][tmpcurrmodel] += jarrsplits[j]->m_pCountPoly[k];
 					}
 			}
 		}
@@ -1461,70 +1465,70 @@ void StaticGeom::GPURenderSingly(DWORD timeDelta, ID id, ID id_tex)
 
 	uint32_t* RTGPUArrIndicesPtrs2;
 	
-	for (int i = 0; i < AllModels[id]->SubSet.size(); ++i)
+	for (int i = 0; i < m_aAllModels[id]->m_aSubSets.size(); ++i)
 	{
-		ID idgroup = AllModels[id]->SubSet[i].idgroup;
-		Group* tmpgroup = AllGroups[AllModels[id]->SubSet[i].idgroup];
-		ID id_buff = AllModels[id]->SubSet[i].idbuff;
+		ID idgroup = m_aAllModels[id]->m_aSubSets[i].m_idGroup;
+		CGroup* tmpgroup = m_aAllGroups[m_aAllModels[id]->m_aSubSets[i].m_idGroup];
+		ID id_buff = m_aAllModels[id]->m_aSubSets[i].m_idBuff;
 
 		ID id_model;
-		for (int j = 0; j < tmpgroup->ArrModels[id_buff].size(); ++j)
+		for (int j = 0; j < tmpgroup->m_aModels[id_buff].size(); ++j)
 		{
-			if (tmpgroup->ArrModels[id_buff][j] == AllModels[id])
+			if (tmpgroup->m_aModels[id_buff][j] == m_aAllModels[id])
 			{
 				id_model = j;
 				break;
 			}
 		}
 
-		RenderIndexBuffer->Lock(0, 0, (void**)&(RTGPUArrIndicesPtrs2), D3DLOCK_DISCARD);
-		memcpy(RTGPUArrIndicesPtrs2, RTCPUArrIndicesPtrs[idgroup][id_buff], RTCountDrawPoly[idgroup][id_buff]/*RTCountDrawPolyModel[tmpig->g_group][id_buff][id_model]*/ * 3 * sizeof(uint32_t));
-		RenderIndexBuffer->Unlock();
+		m_pRenderIndexBuffer->Lock(0, 0, (void**)&(RTGPUArrIndicesPtrs2), D3DLOCK_DISCARD);
+		memcpy(RTGPUArrIndicesPtrs2, m_pppRTArrIndices[idgroup][id_buff], m_ppRTCountDrawPoly[idgroup][id_buff]/*m_pppRTCountDrawPolyModel[tmpig->m_idGlobalGroup][id_buff][id_model]*/ * 3 * sizeof(uint32_t));
+		m_pRenderIndexBuffer->Unlock();
 
-		StaticGeom::DXDevice->SetStreamSource(0, tmpgroup->VertexBuffer[id_buff], 0, sizeof(vertex_static));
-		StaticGeom::DXDevice->SetIndices(RenderIndexBuffer);
-		StaticGeom::DXDevice->SetVertexDeclaration(SGCore_StaticModelGetDecl());
+		CStaticGeom::m_pDXDevice->SetStreamSource(0, tmpgroup->m_aVertexBuffers[id_buff], 0, sizeof(vertex_static));
+		CStaticGeom::m_pDXDevice->SetIndices(m_pRenderIndexBuffer);
+		CStaticGeom::m_pDXDevice->SetVertexDeclaration(SGCore_StaticModelGetDecl());
 
-		SGCore_MtlSet((id_tex > 0 ? id_tex : tmpgroup->idtex), 0);
+		SGCore_MtlSet((id_tex > 0 ? id_tex : tmpgroup->m_idTexture), 0);
 
-		SGCore_DIP(D3DPT_TRIANGLELIST, 0, 0, tmpgroup->CountVertex[id_buff], 0, RTCountDrawPoly[idgroup][id_buff]);
-		Core_RIntSet(G_RI_INT_COUNT_POLY, Core_RIntGet(G_RI_INT_COUNT_POLY) + RTCountDrawPoly[idgroup][id_buff]);
+		SGCore_DIP(D3DPT_TRIANGLELIST, 0, 0, tmpgroup->m_aCountVertex[id_buff], 0, m_ppRTCountDrawPoly[idgroup][id_buff]);
+		Core_RIntSet(G_RI_INT_COUNT_POLY, Core_RIntGet(G_RI_INT_COUNT_POLY) + m_ppRTCountDrawPoly[idgroup][id_buff]);
 	}
 }
 
-void StaticGeom::PreSegmentation(Model* mesh, ISXDataStaticModel* model)
+void CStaticGeom::preSegmentation(CModel* mesh, ISXDataStaticModel* model)
 {
 	vertex_static *CreateV;
-	mem_delete_a(ArrMeshVertex);
-	mem_delete_a(ArrMeshIndex);
-	CountVertex = model->m_uiAllVertexCount;
+	mem_delete_a(m_pCurrArrMeshVertex);
+	mem_delete_a(m_pCurrArrMeshIndex);
+	//CountVertex = model->m_uiAllVertexCount;
 	//копируем все вершины для текущих расчетов
-	ArrMeshVertex = new float3[model->m_uiAllVertexCount];
+	m_pCurrArrMeshVertex = new float3[model->m_uiAllVertexCount];
 
 	model->m_pVertexBuffer->Lock(0, 0, (void **)&CreateV, 0);
 	for (DWORD i = 0; i<model->m_uiAllVertexCount; i++)
 	{
-		ArrMeshVertex[i] = (CreateV[i].Pos.operator float3());
+		m_pCurrArrMeshVertex[i] = (CreateV[i].Pos.operator float3());
 	}
 	model->m_pVertexBuffer->Unlock();
 
-	ArrMeshIndex = new UINT[model->m_uiAllIndexCount];
+	m_pCurrArrMeshIndex = new UINT[model->m_uiAllIndexCount];
 	UINT* pInd;
 	model->m_pIndexBuffer->Lock(0, 0, (void **)&pInd, 0);
-	memcpy(ArrMeshIndex, pInd, sizeof(UINT)* model->m_uiAllIndexCount);
+	memcpy(m_pCurrArrMeshIndex, pInd, sizeof(UINT)* model->m_uiAllIndexCount);
 	model->m_pIndexBuffer->Unlock();
 
 	///////
 
-	mesh->ArrSplits = new Segment();
-	mesh->ArrSplits->CountAllPoly = model->m_uiAllIndexCount / 3;
-	LibReport(REPORT_MSG_LEVEL_NOTICE, "poly: %d, ", mesh->ArrSplits->CountAllPoly);
+	mesh->m_pArrSplits = new CSegment();
+	mesh->m_pArrSplits->m_uiCountAllPoly = model->m_uiAllIndexCount / 3;
+	LibReport(REPORT_MSG_LEVEL_NOTICE, "poly: %d, ", mesh->m_pArrSplits->m_uiCountAllPoly);
 
-	mesh->ArrSplits->BoundVolumeP = SGCore_CrBound();
-	mesh->ArrSplits->BoundVolumeP->calcBound(model->m_pVertexBuffer, model->m_uiAllVertexCount, sizeof(vertex_static));
+	mesh->m_pArrSplits->m_pBoundVolumeP = SGCore_CrBound();
+	mesh->m_pArrSplits->m_pBoundVolumeP->calcBound(model->m_pVertexBuffer, model->m_uiAllVertexCount, sizeof(vertex_static));
 
 	float3 tmpMin, tmpMax;
-	mesh->ArrSplits->BoundVolumeP->getMinMax(&tmpMin, &tmpMax);
+	mesh->m_pArrSplits->m_pBoundVolumeP->getMinMax(&tmpMin, &tmpMax);
 
 	int CountSplitsSys = 0;
 	int CountPolyInSegment = GEOM_MIN_COUNT_POLY;
@@ -1663,43 +1667,43 @@ void StaticGeom::PreSegmentation(Model* mesh, ISXDataStaticModel* model)
 		}
 	}
 
-	mesh->ArrSplits->BoundVolumeSys = SGCore_CrBound();
-	mesh->ArrSplits->BoundVolumeSys->setMinMax(&tmpMin, &tmpMax);
+	mesh->m_pArrSplits->m_pBoundVolumeSys = SGCore_CrBound();
+	mesh->m_pArrSplits->m_pBoundVolumeSys->setMinMax(&tmpMin, &tmpMax);
 	//}}
 
-	mesh->ArrSplits->CountSubSet = model->m_uiSubsetCount;
-	mesh->ArrSplits->NumberGroup = new uint32_t[model->m_uiSubsetCount];
-	mesh->ArrSplits->NumberGroupModel = new uint32_t[model->m_uiSubsetCount];
-	mesh->ArrSplits->CountPoly = new uint32_t[model->m_uiSubsetCount];
+	mesh->m_pArrSplits->m_uiCountSubSet = model->m_uiSubsetCount;
+	mesh->m_pArrSplits->m_pNumberGroup = new uint32_t[model->m_uiSubsetCount];
+	mesh->m_pArrSplits->m_pNumberGroupModel = new uint32_t[model->m_uiSubsetCount];
+	mesh->m_pArrSplits->m_pCountPoly = new uint32_t[model->m_uiSubsetCount];
 
 	/////
 
 	//заполняем массив с номаерами подгрупп и массив с количествами полигонов
 	for (DWORD i = 0; i<model->m_uiSubsetCount; i++)
 	{
-		mesh->ArrSplits->NumberGroupModel[i] = i;
-		mesh->ArrSplits->NumberGroup[i] = i;
-		mesh->ArrSplits->CountPoly[i] = model->m_pIndexCount[i] / 3;
+		mesh->m_pArrSplits->m_pNumberGroupModel[i] = i;
+		mesh->m_pArrSplits->m_pNumberGroup[i] = i;
+		mesh->m_pArrSplits->m_pCountPoly[i] = model->m_pIndexCount[i] / 3;
 	}
 
 	//создаем массивы с полигонами, каждый полигон принадлежит своей подгруппе
-	mesh->ArrSplits->ArrPoly = new uint32_t*[mesh->ArrSplits->CountSubSet];
-	for (DWORD i = 0; i<mesh->ArrSplits->CountSubSet; i++)
+	mesh->m_pArrSplits->m_ppArrPoly = new uint32_t*[mesh->m_pArrSplits->m_uiCountSubSet];
+	for (DWORD i = 0; i<mesh->m_pArrSplits->m_uiCountSubSet; i++)
 	{
-		mesh->ArrSplits->ArrPoly[i] = new uint32_t[mesh->ArrSplits->CountPoly[i] * 3];
+		mesh->m_pArrSplits->m_ppArrPoly[i] = new uint32_t[mesh->m_pArrSplits->m_pCountPoly[i] * 3];
 	}
 
 	//заполняем массивы с полигонами
 	for (DWORD i = 0; i<model->m_uiSubsetCount; i++)
 	{
-		memcpy(mesh->ArrSplits->ArrPoly[i], ArrMeshIndex + model->m_pStartIndex[i], model->m_pIndexCount[i] * sizeof(uint32_t));
+		memcpy(mesh->m_pArrSplits->m_ppArrPoly[i], m_pCurrArrMeshIndex + model->m_pStartIndex[i], model->m_pIndexCount[i] * sizeof(uint32_t));
 	}
 
 	//если количество полигонов и текущая установка деления позволяют делить дальше
-	if (mesh->ArrSplits->CountAllPoly >= CountPolyInSegment && CountSplitsSys != 0)
+	if (mesh->m_pArrSplits->m_uiCountAllPoly >= CountPolyInSegment && CountSplitsSys != 0)
 	{
-		mesh->ArrSplits->BFNonEnd = true;
-		CycleSegmentation(mesh->ArrSplits, mesh, model, CountSplitsSys, CountPolyInSegment);
+		mesh->m_pArrSplits->m_isNonEnd = true;
+		cycleSegmentation(mesh->m_pArrSplits, mesh, model, CountSplitsSys, CountPolyInSegment);
 	}
 	else
 	{
@@ -1707,61 +1711,61 @@ void StaticGeom::PreSegmentation(Model* mesh, ISXDataStaticModel* model)
 		//{{
 		Array<DWORD> tmpVert;
 		bool isunic = true;
-		for (DWORD q = 0; q<mesh->ArrSplits->CountSubSet; q++)
+		for (DWORD q = 0; q<mesh->m_pArrSplits->m_uiCountSubSet; q++)
 		{
 			tmpVert.clear();
-			tmpVert.push_back(mesh->ArrSplits->ArrPoly[q][0]);
-			for (DWORD k = 0; k<mesh->ArrSplits->CountPoly[q] * 3; k++)
+			tmpVert.push_back(mesh->m_pArrSplits->m_ppArrPoly[q][0]);
+			for (DWORD k = 0; k<mesh->m_pArrSplits->m_pCountPoly[q] * 3; k++)
 			{
 				isunic = true;
 				for (DWORD j = 0; j<tmpVert.size() && isunic; j++)
 				{
-					if (mesh->ArrSplits->ArrPoly[q][k] == tmpVert[j])
+					if (mesh->m_pArrSplits->m_ppArrPoly[q][k] == tmpVert[j])
 					{
 						isunic = false;
 					}
 				}
 
 				if (isunic)
-					tmpVert.push_back(mesh->ArrSplits->ArrPoly[q][k]);
+					tmpVert.push_back(mesh->m_pArrSplits->m_ppArrPoly[q][k]);
 			}
 
-			SGCore_OptimizeIndecesInSubsetUint32(mesh->ArrSplits->ArrPoly[q], mesh->ArrSplits->CountPoly[q], tmpVert.size());
+			SGCore_OptimizeIndecesInSubsetUint32(mesh->m_pArrSplits->m_ppArrPoly[q], mesh->m_pArrSplits->m_pCountPoly[q], tmpVert.size());
 		}
 		//}}
 
 		//иначе нельзя делить дальше
 		//приводим индексы куска к глобальному виду уровня
-		for (DWORD i = 0; i<mesh->ArrSplits->CountSubSet; i++)
+		for (DWORD i = 0; i<mesh->m_pArrSplits->m_uiCountSubSet; i++)
 		{
-			for (DWORD k = 0; k<mesh->ArrSplits->CountPoly[i] * 3; k++)
+			for (DWORD k = 0; k<mesh->m_pArrSplits->m_pCountPoly[i] * 3; k++)
 			{
-				mesh->ArrSplits->ArrPoly[i][k] -= model->m_pStartVertex[mesh->ArrSplits->NumberGroup[i]];
-				mesh->ArrSplits->ArrPoly[i][k] += mesh->SubSet[mesh->ArrSplits->NumberGroup[i]].VertexStart;
+				mesh->m_pArrSplits->m_ppArrPoly[i][k] -= model->m_pStartVertex[mesh->m_pArrSplits->m_pNumberGroup[i]];
+				mesh->m_pArrSplits->m_ppArrPoly[i][k] += mesh->m_aSubSets[mesh->m_pArrSplits->m_pNumberGroup[i]].m_idVertexStart;
 			}
-			mesh->ArrSplits->NumberGroup[i] = mesh->SubSet[mesh->ArrSplits->NumberGroup[i]].idgroup;
+			mesh->m_pArrSplits->m_pNumberGroup[i] = mesh->m_aSubSets[mesh->m_pArrSplits->m_pNumberGroup[i]].m_idGroup;
 		}
 
-		mesh->ArrSplits->BFNonEnd = false;
+		mesh->m_pArrSplits->m_isNonEnd = false;
 	}
 }
 
-void StaticGeom::CycleSegmentation(Segment *Split, Model* mesh, ISXDataStaticModel* model, long CountSplitsSys, long CountPolyInSegment)
+void CStaticGeom::cycleSegmentation(CSegment *Split, CModel* mesh, ISXDataStaticModel* model, int CountSplitsSys, int CountPolyInSegment)
 {
-	Array<Segment*> queue;
-	long tmpcount = 0;
+	Array<CSegment*> queue;
+	int tmpcount = 0;
 	queue.push_back(Split);
 
 	while (queue.size())
 	{
-		if (queue[0]->BFNonEnd)
+		if (queue[0]->m_isNonEnd)
 		{
-			Segmentation(queue[0], mesh, model, CountSplitsSys, CountPolyInSegment, &queue);
+			segmentation(queue[0], mesh, model, CountSplitsSys, CountPolyInSegment, &queue);
 
 			for (int i = 0; i < CountSplitsSys; i++)
 			{
-				if (queue[0]->Splits[i])
-					queue.push_back(queue[0]->Splits[i]);
+				if (queue[0]->m_aSplits[i])
+					queue.push_back(queue[0]->m_aSplits[i]);
 			}
 		}
 
@@ -1771,7 +1775,7 @@ void StaticGeom::CycleSegmentation(Segment *Split, Model* mesh, ISXDataStaticMod
 }
 
 
-void StaticGeom::Segmentation(Segment* Split, Model* mesh, ISXDataStaticModel* model, long CountSplitsSys, long CountPolyInSegment, Array<Segment*> * queue)
+void CStaticGeom::segmentation(CSegment* Split, CModel* mesh, ISXDataStaticModel* model, int CountSplitsSys, int CountPolyInSegment, Array<CSegment*> * queue)
 {
 	Array<DWORD> ArrPoly[8];
 	Array<DWORD> ArrGroup[8];
@@ -1779,7 +1783,7 @@ void StaticGeom::Segmentation(Segment* Split, Model* mesh, ISXDataStaticModel* m
 
 	for (int i = 0; i<CountSplitsSys; i++)
 	{
-		Split->Splits[i] = new Segment();
+		Split->m_aSplits[i] = new CSegment();
 	}
 
 	//получаем ограничивающие для деления и облегаемые объемы
@@ -1792,13 +1796,13 @@ void StaticGeom::Segmentation(Segment* Split, Model* mesh, ISXDataStaticModel* m
 			ArrBound[i] = SGCore_CrBound();
 		}
 		float3 tmpmin,tmpmax;
-		SGCore_0ComBoundBoxArr4(Split->BoundVolumeSys, (ArrBound));
+		SGCore_0ComBoundBoxArr4(Split->m_pBoundVolumeSys, (ArrBound));
 		for (int i = 0; i<CountSplitsSys; i++)
 		{
-			Split->Splits[i]->BoundVolumeSys = ArrBound[i];
-			Split->Splits[i]->BoundVolumeSys->getMinMax(&tmpmin, &tmpmax);
-			Split->Splits[i]->BoundVolumeP = SGCore_CrBound();
-			Split->Splits[i]->BoundVolumeP->setMinMax(&tmpmin, &tmpmax);
+			Split->m_aSplits[i]->m_pBoundVolumeSys = ArrBound[i];
+			Split->m_aSplits[i]->m_pBoundVolumeSys->getMinMax(&tmpmin, &tmpmax);
+			Split->m_aSplits[i]->m_pBoundVolumeP = SGCore_CrBound();
+			Split->m_aSplits[i]->m_pBoundVolumeP->setMinMax(&tmpmin, &tmpmax);
 		}
 	}
 	else if (CountSplitsSys == GEOM_COUNT_TYPE_SEGMENTATION_OCTO)
@@ -1808,45 +1812,45 @@ void StaticGeom::Segmentation(Segment* Split, Model* mesh, ISXDataStaticModel* m
 			ArrBound[i] = SGCore_CrBound();
 
 		float3 tmpmin, tmpmax;
-		SGCore_0ComBoundBoxArr8(Split->BoundVolumeSys, ArrBound);
+		SGCore_0ComBoundBoxArr8(Split->m_pBoundVolumeSys, ArrBound);
 
 		for (int i = 0; i<CountSplitsSys; i++)
 		{
-			Split->Splits[i]->BoundVolumeSys = ArrBound[i];
-			Split->Splits[i]->BoundVolumeSys->getMinMax(&tmpmin, &tmpmax);
-			Split->Splits[i]->BoundVolumeP = SGCore_CrBound();
-			Split->Splits[i]->BoundVolumeP->setMinMax(&tmpmin, &tmpmax);
+			Split->m_aSplits[i]->m_pBoundVolumeSys = ArrBound[i];
+			Split->m_aSplits[i]->m_pBoundVolumeSys->getMinMax(&tmpmin, &tmpmax);
+			Split->m_aSplits[i]->m_pBoundVolumeP = SGCore_CrBound();
+			Split->m_aSplits[i]->m_pBoundVolumeP->setMinMax(&tmpmin, &tmpmax);
 		}
 	}
 	//}}
 
-	bool *tmp_arr_mesh_poly = new bool[Split->CountAllPoly];
-	for (DWORD i = 0; i<Split->CountAllPoly; i++)
+	bool *tmp_arr_mesh_poly = new bool[Split->m_uiCountAllPoly];
+	for (DWORD i = 0; i<Split->m_uiCountAllPoly; i++)
 		tmp_arr_mesh_poly[i] = true;
 
 	DWORD CountInPoly = 0;
 	float3 tmpMin, tmpMax;
 	for (int i = 0; i<CountSplitsSys; i++)
 	{
-		Split->Splits[i]->BoundVolumeSys->getMinMax(&tmpMin, &tmpMax);
-		//SGCore_FCreateBoundingBoxMesh(&tmpMin, &tmpMax, &(Split->Splits[i]->BoundBox));
+		Split->m_aSplits[i]->m_pBoundVolumeSys->getMinMax(&tmpMin, &tmpMax);
+		//SGCore_FCreateBoundingBoxMesh(&tmpMin, &tmpMax, &(Split->m_aSplits[i]->BoundBox));
 		DWORD tmpNumCurrentPoly = 0;
-		for (DWORD j = 0; j<Split->CountSubSet; j++)
+		for (DWORD j = 0; j<Split->m_uiCountSubSet; j++)
 		{
-			for (DWORD k = 0; k<Split->CountPoly[j] * 3; k += 3)
+			for (DWORD k = 0; k<Split->m_pCountPoly[j] * 3; k += 3)
 			{
 				if (SGCore_0InPosPoints2D(&tmpMin, &tmpMax,
-					&ArrMeshVertex[Split->ArrPoly[j][k]],
-					&ArrMeshVertex[Split->ArrPoly[j][k + 1]],
-					&ArrMeshVertex[Split->ArrPoly[j][k + 2]]
+					&m_pCurrArrMeshVertex[Split->m_ppArrPoly[j][k]],
+					&m_pCurrArrMeshVertex[Split->m_ppArrPoly[j][k + 1]],
+					&m_pCurrArrMeshVertex[Split->m_ppArrPoly[j][k + 2]]
 					)
 					&& tmp_arr_mesh_poly[tmpNumCurrentPoly]
 					)
 				{
-					ArrPoly[i].push_back((Split->ArrPoly[j][k]));
-					ArrPoly[i].push_back((Split->ArrPoly[j][k + 1]));
-					ArrPoly[i].push_back((Split->ArrPoly[j][k + 2]));
-					ArrGroup[i].push_back((Split->NumberGroup[j]));
+					ArrPoly[i].push_back((Split->m_ppArrPoly[j][k]));
+					ArrPoly[i].push_back((Split->m_ppArrPoly[j][k + 1]));
+					ArrPoly[i].push_back((Split->m_ppArrPoly[j][k + 2]));
+					ArrGroup[i].push_back((Split->m_pNumberGroup[j]));
 
 					tmp_arr_mesh_poly[tmpNumCurrentPoly] = false;
 					CountInPoly++;
@@ -1859,22 +1863,22 @@ void StaticGeom::Segmentation(Segment* Split, Model* mesh, ISXDataStaticModel* m
 	//ИНОГДА ТУТ БЫЛО ЧЕТО НЕПОНЯТНОЕ
 	//ПОСЛЕ ТОГО КАК ГРАФИКА КАКИМ ТО МАГИЧЕСКИМ ОБРАЗОМ СТАЛА ЛУЧШЕ (КОСЯКИ С КУСТАМИ БЫЛИ ПРИ КОМПИЛЯЦИИ С /mt)
 	//ПРОПАЛИ НЕКОТОЫРЕ УЧАСТКИ ОДНОГО ЗДАНИЯ, ПОСЛЕ ТОГО КАК УБРАЛ ЭТОТ КОД ВСЕ СТАЛО НОРМАЛЬНО
-	if (CountInPoly < Split->CountAllPoly)
+	if (CountInPoly < Split->m_uiCountAllPoly)
 	{
 		DWORD tmpNumCurrentPolyDec = 0;
 		DWORD tmpNumCurrentPoly = 0;
 		float3 pos0, pos1, pos2, CenterPoly, Length, SphereCenter;
 		float ArrLength[8], ShereRadius;
 
-		for (DWORD j = 0; j<Split->CountSubSet; j++)
+		for (DWORD j = 0; j<Split->m_uiCountSubSet; j++)
 		{
-			for (DWORD k = 0; k<Split->CountPoly[j] * 3; k += 3)
+			for (DWORD k = 0; k<Split->m_pCountPoly[j] * 3; k += 3)
 			{
 				if (tmp_arr_mesh_poly[tmpNumCurrentPoly])
 				{
-					pos0 = ArrMeshVertex[Split->ArrPoly[j][k]];
-					pos1 = ArrMeshVertex[Split->ArrPoly[j][k + 1]];
-					pos2 = ArrMeshVertex[Split->ArrPoly[j][k + 2]];
+					pos0 = m_pCurrArrMeshVertex[Split->m_ppArrPoly[j][k]];
+					pos1 = m_pCurrArrMeshVertex[Split->m_ppArrPoly[j][k + 1]];
+					pos2 = m_pCurrArrMeshVertex[Split->m_ppArrPoly[j][k + 2]];
 
 					CenterPoly.x = CenterPoly.y = CenterPoly.z = 0;
 
@@ -1886,7 +1890,7 @@ void StaticGeom::Segmentation(Segment* Split, Model* mesh, ISXDataStaticModel* m
 
 					for (int q = 0; q<CountSplitsSys; q++)
 					{
-						Split->Splits[q]->BoundVolumeSys->getSphere(&SphereCenter, &ShereRadius);
+						Split->m_aSplits[q]->m_pBoundVolumeSys->getSphere(&SphereCenter, &ShereRadius);
 						Length = -SphereCenter + CenterPoly;
 						ArrLength[q] = SMVector3Length(Length);
 					}
@@ -1912,10 +1916,10 @@ void StaticGeom::Segmentation(Segment* Split, Model* mesh, ISXDataStaticModel* m
 						}
 					}
 
-					ArrPoly[Key].push_back((Split->ArrPoly[j][k]));
-					ArrPoly[Key].push_back((Split->ArrPoly[j][k + 1]));
-					ArrPoly[Key].push_back((Split->ArrPoly[j][k + 2]));
-					ArrGroup[Key].push_back((Split->NumberGroup[j]));
+					ArrPoly[Key].push_back((Split->m_ppArrPoly[j][k]));
+					ArrPoly[Key].push_back((Split->m_ppArrPoly[j][k + 1]));
+					ArrPoly[Key].push_back((Split->m_ppArrPoly[j][k + 2]));
+					ArrGroup[Key].push_back((Split->m_pNumberGroup[j]));
 					//ArrSerialNum[Key].push_back((Split->ArrSerialNum[j][k / 3]));
 
 					tmp_arr_mesh_poly[tmpNumCurrentPolyDec] = false;
@@ -1933,11 +1937,11 @@ void StaticGeom::Segmentation(Segment* Split, Model* mesh, ISXDataStaticModel* m
 		if (ArrPoly[i].size() > 0)
 		{
 			Array<DWORD> tmpNumSubSet;
-			Split->Splits[i]->CountSubSet = 0;
+			Split->m_aSplits[i]->m_uiCountSubSet = 0;
 
 			//предварительно записываем одну подгруппу в массив tmpNumSubSet
 			tmpNumSubSet.push_back(ArrGroup[i][0]);
-			Split->Splits[i]->CountSubSet++;
+			Split->m_aSplits[i]->m_uiCountSubSet++;
 			//вычисляем сколько всего у нас подгрупп
 			for (DWORD k = 0; k<ArrGroup[i].size(); k++)
 			{
@@ -1951,67 +1955,67 @@ void StaticGeom::Segmentation(Segment* Split, Model* mesh, ISXDataStaticModel* m
 				if (!tmpIsThereGroup)
 				{
 					tmpNumSubSet.push_back(ArrGroup[i][k]);
-					Split->Splits[i]->CountSubSet++;
+					Split->m_aSplits[i]->m_uiCountSubSet++;
 				}
 			}
 
 			//
-			Split->Splits[i]->NumberGroup = new uint32_t[Split->Splits[i]->CountSubSet];
-			Split->Splits[i]->NumberGroupModel = new uint32_t[Split->Splits[i]->CountSubSet];
+			Split->m_aSplits[i]->m_pNumberGroup = new uint32_t[Split->m_aSplits[i]->m_uiCountSubSet];
+			Split->m_aSplits[i]->m_pNumberGroupModel = new uint32_t[Split->m_aSplits[i]->m_uiCountSubSet];
 
-			for (DWORD k = 0; k<Split->Splits[i]->CountSubSet; k++)
+			for (DWORD k = 0; k<Split->m_aSplits[i]->m_uiCountSubSet; k++)
 			{
-				Split->Splits[i]->NumberGroup[k] = (tmpNumSubSet[k]);
-				Split->Splits[i]->NumberGroupModel[k] = (tmpNumSubSet[k]);
+				Split->m_aSplits[i]->m_pNumberGroup[k] = (tmpNumSubSet[k]);
+				Split->m_aSplits[i]->m_pNumberGroupModel[k] = (tmpNumSubSet[k]);
 			}
 
 			tmpNumSubSet.clear();
 
-			Split->Splits[i]->CountPoly = new uint32_t[Split->Splits[i]->CountSubSet];
+			Split->m_aSplits[i]->m_pCountPoly = new uint32_t[Split->m_aSplits[i]->m_uiCountSubSet];
 
-			//обнуление данных GlobalMesh->SplitMeshes[i]->CountPoly
-			for (DWORD j = 0; j<Split->Splits[i]->CountSubSet; j++)
+			//обнуление данных GlobalMesh->SplitMeshes[i]->m_pCountPoly
+			for (DWORD j = 0; j<Split->m_aSplits[i]->m_uiCountSubSet; j++)
 			{
-				Split->Splits[i]->CountPoly[j] = 0;
+				Split->m_aSplits[i]->m_pCountPoly[j] = 0;
 			}
-			Split->Splits[i]->CountAllPoly = 0;
+			Split->m_aSplits[i]->m_uiCountAllPoly = 0;
 
 			//вычисляем сколько полигонов в каждой подгруппе в данном сплите
 			for (DWORD k = 0; k<ArrPoly[i].size(); k += 3)
 			{
-				for (DWORD j = 0; j<Split->Splits[i]->CountSubSet; j++)
+				for (DWORD j = 0; j<Split->m_aSplits[i]->m_uiCountSubSet; j++)
 				{
-					if (Split->Splits[i]->NumberGroup[j] == (ArrGroup[i][k / 3]))
+					if (Split->m_aSplits[i]->m_pNumberGroup[j] == (ArrGroup[i][k / 3]))
 					{
-						Split->Splits[i]->CountPoly[j]++;
-						Split->Splits[i]->CountAllPoly++;
+						Split->m_aSplits[i]->m_pCountPoly[j]++;
+						Split->m_aSplits[i]->m_uiCountAllPoly++;
 					}
 				}
 			}
 
-			Split->Splits[i]->ArrPoly = new uint32_t*[Split->Splits[i]->CountSubSet];
+			Split->m_aSplits[i]->m_ppArrPoly = new uint32_t*[Split->m_aSplits[i]->m_uiCountSubSet];
 			
-			for (DWORD j = 0; j<Split->Splits[i]->CountSubSet; j++)
+			for (DWORD j = 0; j<Split->m_aSplits[i]->m_uiCountSubSet; j++)
 			{
-				Split->Splits[i]->ArrPoly[j] = new uint32_t[Split->Splits[i]->CountPoly[j] * 3];
+				Split->m_aSplits[i]->m_ppArrPoly[j] = new uint32_t[Split->m_aSplits[i]->m_pCountPoly[j] * 3];
 			}
-			uint32_t* tmpCountPG = new uint32_t[Split->Splits[i]->CountSubSet];
+			uint32_t* tmpCountPG = new uint32_t[Split->m_aSplits[i]->m_uiCountSubSet];
 
-			for (DWORD k = 0; k<Split->Splits[i]->CountSubSet; k++)
+			for (DWORD k = 0; k<Split->m_aSplits[i]->m_uiCountSubSet; k++)
 			{
 				tmpCountPG[k] = 0;
 			}
 
 			for (DWORD k = 0; k<ArrPoly[i].size(); k += 3)
 			{
-				for (DWORD j = 0; j<Split->Splits[i]->CountSubSet; j++)
+				for (DWORD j = 0; j<Split->m_aSplits[i]->m_uiCountSubSet; j++)
 				{
 
-					if (Split->Splits[i]->NumberGroup[j] == (ArrGroup[i][k / 3]))
+					if (Split->m_aSplits[i]->m_pNumberGroup[j] == (ArrGroup[i][k / 3]))
 					{
-						Split->Splits[i]->ArrPoly[j][tmpCountPG[j]] = (ArrPoly[i][k]);
-						Split->Splits[i]->ArrPoly[j][tmpCountPG[j] + 1] = (ArrPoly[i][k + 1]);
-						Split->Splits[i]->ArrPoly[j][tmpCountPG[j] + 2] = (ArrPoly[i][k + 2]);
+						Split->m_aSplits[i]->m_ppArrPoly[j][tmpCountPG[j]] = (ArrPoly[i][k]);
+						Split->m_aSplits[i]->m_ppArrPoly[j][tmpCountPG[j] + 1] = (ArrPoly[i][k + 1]);
+						Split->m_aSplits[i]->m_ppArrPoly[j][tmpCountPG[j] + 2] = (ArrPoly[i][k + 2]);
 
 						tmpCountPG[j] += 3;
 					}
@@ -2023,93 +2027,93 @@ void StaticGeom::Segmentation(Segment* Split, Model* mesh, ISXDataStaticModel* m
 
 			mem_delete_a(tmpCountPG);
 
-			EditVolume(mesh, Split->Splits[i]);
-			if (Split->Splits[i]->CountAllPoly > 0 && Split->Splits[i]->CountAllPoly > CountPolyInSegment)
+			editVolume(mesh, Split->m_aSplits[i]);
+			if (Split->m_aSplits[i]->m_uiCountAllPoly > 0 && Split->m_aSplits[i]->m_uiCountAllPoly > CountPolyInSegment)
 			{
-				Split->Splits[i]->BFNonEnd = true;
+				Split->m_aSplits[i]->m_isNonEnd = true;
 			}
 			else
 			{
-				Split->Splits[i]->BFNonEnd = false;
-				//EditVolume(mesh, Split->Splits[i]);
+				Split->m_aSplits[i]->m_isNonEnd = false;
+				//EditVolume(mesh, Split->m_aSplits[i]);
 
 				//оптимизация для Post TnL кэша
 				//{{
 				Array<uint32_t> tmpVert;
 				bool isunic = true;
-				for (DWORD q = 0; q<Split->Splits[i]->CountSubSet; q++)
+				for (DWORD q = 0; q<Split->m_aSplits[i]->m_uiCountSubSet; q++)
 				{
 					tmpVert.clear();
-					tmpVert.push_back(Split->Splits[i]->ArrPoly[q][0]);
-					for (DWORD k = 0; k<Split->Splits[i]->CountPoly[q] * 3; k++)
+					tmpVert.push_back(Split->m_aSplits[i]->m_ppArrPoly[q][0]);
+					for (DWORD k = 0; k<Split->m_aSplits[i]->m_pCountPoly[q] * 3; k++)
 					{
 						isunic = true;
 						for (DWORD j = 0; j<tmpVert.size() && isunic; j++)
 						{
-							if (Split->Splits[i]->ArrPoly[q][k] == tmpVert[j])
+							if (Split->m_aSplits[i]->m_ppArrPoly[q][k] == tmpVert[j])
 							{
 								isunic = false;
 							}
 						}
 
 						if (isunic)
-							tmpVert.push_back(Split->Splits[i]->ArrPoly[q][k]);
+							tmpVert.push_back(Split->m_aSplits[i]->m_ppArrPoly[q][k]);
 					}
 
-					SGCore_OptimizeIndecesInSubsetUint32(Split->Splits[i]->ArrPoly[q], Split->Splits[i]->CountPoly[q], tmpVert.size());
+					SGCore_OptimizeIndecesInSubsetUint32(Split->m_aSplits[i]->m_ppArrPoly[q], Split->m_aSplits[i]->m_pCountPoly[q], tmpVert.size());
 				}
 				//}}
 				
 
-				for (DWORD q = 0; q<Split->Splits[i]->CountSubSet; q++)
+				for (DWORD q = 0; q<Split->m_aSplits[i]->m_uiCountSubSet; q++)
 				{
-					for (DWORD k = 0; k<Split->Splits[i]->CountPoly[q] * 3; k++)
+					for (DWORD k = 0; k<Split->m_aSplits[i]->m_pCountPoly[q] * 3; k++)
 					{
-						Split->Splits[i]->ArrPoly[q][k] -= model->m_pStartVertex[Split->Splits[i]->NumberGroup[q]];
-						Split->Splits[i]->ArrPoly[q][k] += mesh->SubSet[Split->Splits[i]->NumberGroup[q]].VertexStart;
+						Split->m_aSplits[i]->m_ppArrPoly[q][k] -= model->m_pStartVertex[Split->m_aSplits[i]->m_pNumberGroup[q]];
+						Split->m_aSplits[i]->m_ppArrPoly[q][k] += mesh->m_aSubSets[Split->m_aSplits[i]->m_pNumberGroup[q]].m_idVertexStart;
 					}
 
-					Split->Splits[i]->NumberGroup[q] = mesh->SubSet[Split->Splits[i]->NumberGroup[q]].idgroup;
+					Split->m_aSplits[i]->m_pNumberGroup[q] = mesh->m_aSubSets[Split->m_aSplits[i]->m_pNumberGroup[q]].m_idGroup;
 				}
 			}
 		}
 		else
 		{
-			Split->Splits[i]->CountAllPoly = 0;
-			Split->Splits[i]->BFNonEnd = false;
+			Split->m_aSplits[i]->m_uiCountAllPoly = 0;
+			Split->m_aSplits[i]->m_isNonEnd = false;
 
-			mem_delete(Split->Splits[i]);
+			mem_delete(Split->m_aSplits[i]);
 		}
 	}
 
-	mem_delete_a(Split->NumberGroup);
+	mem_delete_a(Split->m_pNumberGroup);
 	
-	mem_delete_a(Split->CountPoly);
+	mem_delete_a(Split->m_pCountPoly);
 
-	for (DWORD k = 0; k<Split->CountSubSet; k++)
+	for (DWORD k = 0; k<Split->m_uiCountSubSet; k++)
 	{
-		mem_delete_a(Split->ArrPoly[k]);
+		mem_delete_a(Split->m_ppArrPoly[k]);
 	}
 
-	mem_delete_a(Split->ArrPoly);
+	mem_delete_a(Split->m_ppArrPoly);
 	mem_delete_a(tmp_arr_mesh_poly);
 }
 
-void StaticGeom::EditVolume(Model* mesh, Segment* Split)
+void CStaticGeom::editVolume(CModel* mesh, CSegment* Split)
 {
 	float3 Max, Min;
-	Max = ArrMeshVertex[(Split->ArrPoly[0][0])];
-	Min = ArrMeshVertex[(Split->ArrPoly[0][0])];
+	Max = m_pCurrArrMeshVertex[(Split->m_ppArrPoly[0][0])];
+	Min = m_pCurrArrMeshVertex[(Split->m_ppArrPoly[0][0])];
 
 	float3 Max2, Min2;
-	Split->BoundVolumeSys->getMinMax(&Min2, &Max2);
+	Split->m_pBoundVolumeSys->getMinMax(&Min2, &Max2);
 
 	float3 tmpf;
-	for (DWORD i = 0; i<Split->CountSubSet; i++)
+	for (int i = 0; i<Split->m_uiCountSubSet; ++i)
 	{
-		for (DWORD k = 0; k<Split->CountPoly[i] * 3; k++)
+		for (int k = 0; k<Split->m_pCountPoly[i] * 3; ++k)
 		{
-			tmpf = ArrMeshVertex[(Split->ArrPoly[i][k])];
+			tmpf = m_pCurrArrMeshVertex[(Split->m_ppArrPoly[i][k])];
 			if (tmpf.x > Max.x)
 				Max.x = tmpf.x;
 			if (tmpf.y > Max.y)
@@ -2129,41 +2133,41 @@ void StaticGeom::EditVolume(Model* mesh, Segment* Split)
 	//float3 Center = (Min + Max) * 0.5f;
 	//float Radius = SMVector3Length(Center - Max);
 
-	//Split->BoundVolumeP->SetSphere(&Center, &Radius);
-	Split->BoundVolumeP->setMinMax(&Min, &Max);
+	//Split->m_pBoundVolumeP->SetSphere(&Center, &Radius);
+	Split->m_pBoundVolumeP->setMinMax(&Min, &Max);
 }
 
-void StaticGeom::Save(const char* path)
+void CStaticGeom::save(const char* path)
 {
 	FILE* file = fopen(path, "wb");
 	
 	//записываем количество подгрупп
-	int32_t countgroup = AllGroups.size();
+	int32_t countgroup = m_aAllGroups.size();
 	fwrite(&countgroup, sizeof(int32_t), 1, file);
 
 	vertex_static * pData;
 
-	for (long i = 0; i < AllGroups.size(); ++i)
+	for (int i = 0; i < m_aAllGroups.size(); ++i)
 	{
-		int32_t tmpstrlen = AllGroups[i]->name.length();
+		int32_t tmpstrlen = m_aAllGroups[i]->m_sName.length();
 		fwrite(&tmpstrlen, sizeof(int32_t), 1, file);
-		fwrite(AllGroups[i]->name.c_str(), sizeof(char), tmpstrlen, file);
+		fwrite(m_aAllGroups[i]->m_sName.c_str(), sizeof(char), tmpstrlen, file);
 
 		//записываем количество буферов в подгруппе
-		int32_t countbuffingroup = AllGroups[i]->VertexBuffer.size();
+		int32_t countbuffingroup = m_aAllGroups[i]->m_aVertexBuffers.size();
 		fwrite(&countbuffingroup, sizeof(int32_t), 1, file);
 
-		for (long k = 0; k < AllGroups[i]->CountVertex.size(); ++k)
+		for (int k = 0; k < m_aAllGroups[i]->m_aCountVertex.size(); ++k)
 		{
 			//записываем количество моделей, которые используют данную подгруппу
-			int32_t countusingmodels = AllGroups[i]->ArrModels[k].size();
+			int32_t countusingmodels = m_aAllGroups[i]->m_aModels[k].size();
 			fwrite(&countusingmodels, sizeof(int32_t), 1, file);
 			int32_t tmpcountusingmodels = 0;
-			for (int32_t j = 0; j < AllGroups[i]->ArrModels[k].size(); ++j)
+			for (int32_t j = 0; j < m_aAllGroups[i]->m_aModels[k].size(); ++j)
 			{
-				for (int32_t q = 0; q < AllModels.size(); ++q)
+				for (int32_t q = 0; q < m_aAllModels.size(); ++q)
 				{
-					if (AllModels[q] == AllGroups[i]->ArrModels[k][j])
+					if (m_aAllModels[q] == m_aAllGroups[i]->m_aModels[k][j])
 					{
 						fwrite(&(q), sizeof(int32_t), 1, file);
 						++tmpcountusingmodels;
@@ -2173,55 +2177,55 @@ void StaticGeom::Save(const char* path)
 			}
 
 			//записываем количество вершин в буфере подгруппы
-			fwrite(&AllGroups[i]->CountVertex[k], sizeof(int32_t), 1, file);
+			fwrite(&m_aAllGroups[i]->m_aCountVertex[k], sizeof(int32_t), 1, file);
 
 			//записываем количество индексов в буфере подгруппы
-			fwrite(&AllGroups[i]->CountIndex[k], sizeof(int32_t), 1, file);
+			fwrite(&m_aAllGroups[i]->m_aCountIndex[k], sizeof(int32_t), 1, file);
 
 			//записываем весь вершинный буфер подгруппы
-			AllGroups[i]->VertexBuffer[k]->Lock(0, 0, (void**)&pData, 0);
-			fwrite(pData, sizeof(vertex_static), AllGroups[i]->CountVertex[k], file);
-			AllGroups[i]->VertexBuffer[k]->Unlock();
+			m_aAllGroups[i]->m_aVertexBuffers[k]->Lock(0, 0, (void**)&pData, 0);
+			fwrite(pData, sizeof(vertex_static), m_aAllGroups[i]->m_aCountVertex[k], file);
+			m_aAllGroups[i]->m_aVertexBuffers[k]->Unlock();
 		}
 	}
 
 	//записываем количество моделей
-	int32_t countmodels = AllModels.size();
+	int32_t countmodels = m_aAllModels.size();
 	fwrite(&countmodels, sizeof(int32_t), 1, file);
 
-	for (long i = 0; i < AllModels.size(); ++i)
+	for (int i = 0; i < m_aAllModels.size(); ++i)
 	{
-		int32_t countsubset = AllModels[i]->SubSet.size();
+		int32_t countsubset = m_aAllModels[i]->m_aSubSets.size();
 		fwrite(&countsubset, sizeof(int32_t), 1, file);
 
-		int32_t countlenstr = strlen(AllModels[i]->Name);
+		int32_t countlenstr = strlen(m_aAllModels[i]->m_szName);
 		fwrite(&countlenstr, sizeof(int32_t), 1, file);
-		fwrite(&AllModels[i]->Name, sizeof(char), countlenstr, file);
+		fwrite(&m_aAllModels[i]->m_szName, sizeof(char), countlenstr, file);
 
-		countlenstr = strlen(AllModels[i]->PathName);
+		countlenstr = strlen(m_aAllModels[i]->m_szPathName);
 		fwrite(&countlenstr, sizeof(int32_t), 1, file);
-		fwrite(&AllModels[i]->PathName, sizeof(char), countlenstr, file);
+		fwrite(&m_aAllModels[i]->m_szPathName, sizeof(char), countlenstr, file);
 
 		
-		fwrite(&AllModels[i]->CountPoly, sizeof(int32_t), 1, file);
+		fwrite(&m_aAllModels[i]->m_uiCountPoly, sizeof(int32_t), 1, file);
 		
-		fwrite(&AllModels[i]->Position.x, sizeof(float), 1, file);
-		fwrite(&AllModels[i]->Position.y, sizeof(float), 1, file);
-		fwrite(&AllModels[i]->Position.z, sizeof(float), 1, file);
+		fwrite(&m_aAllModels[i]->m_vPosition.x, sizeof(float), 1, file);
+		fwrite(&m_aAllModels[i]->m_vPosition.y, sizeof(float), 1, file);
+		fwrite(&m_aAllModels[i]->m_vPosition.z, sizeof(float), 1, file);
 
-		fwrite(&AllModels[i]->Rotation.x, sizeof(float), 1, file);
-		fwrite(&AllModels[i]->Rotation.y, sizeof(float), 1, file);
-		fwrite(&AllModels[i]->Rotation.z, sizeof(float), 1, file);
+		fwrite(&m_aAllModels[i]->m_vRotation.x, sizeof(float), 1, file);
+		fwrite(&m_aAllModels[i]->m_vRotation.y, sizeof(float), 1, file);
+		fwrite(&m_aAllModels[i]->m_vRotation.z, sizeof(float), 1, file);
 
-		fwrite(&AllModels[i]->Scale.x, sizeof(float), 1, file);
-		fwrite(&AllModels[i]->Scale.y, sizeof(float), 1, file);
-		fwrite(&AllModels[i]->Scale.z, sizeof(float), 1, file);
+		fwrite(&m_aAllModels[i]->m_vScale.x, sizeof(float), 1, file);
+		fwrite(&m_aAllModels[i]->m_vScale.y, sizeof(float), 1, file);
+		fwrite(&m_aAllModels[i]->m_vScale.z, sizeof(float), 1, file);
 
-		if (AllModels[i]->Lod0.model)
+		if (m_aAllModels[i]->m_oLod0.m_pModel)
 		{
-			countlenstr = strlen(AllModels[i]->Lod0.PathName);
+			countlenstr = strlen(m_aAllModels[i]->m_oLod0.m_szPathName);
 			fwrite(&countlenstr, sizeof(int32_t), 1, file);
-			fwrite(AllModels[i]->Lod0.PathName, sizeof(char), countlenstr, file);
+			fwrite(m_aAllModels[i]->m_oLod0.m_szPathName, sizeof(char), countlenstr, file);
 		}
 		else
 		{
@@ -2229,18 +2233,18 @@ void StaticGeom::Save(const char* path)
 			fwrite(&countlenstr, sizeof(int32_t), 1, file);
 		}
 
-		for (long k = 0; k < AllModels[i]->SubSet.size(); ++k)
+		for (int k = 0; k < m_aAllModels[i]->m_aSubSets.size(); ++k)
 		{
-			fwrite(&(AllModels[i]->SubSet[k]), sizeof(Model::GDataBuff), 1, file);
+			fwrite(&(m_aAllModels[i]->m_aSubSets[k]), sizeof(CModel::CSubSet), 1, file);
 		}
 
-		Array<Segment*> queue;
-		long tmpcount = 0;
-		queue.push_back(AllModels[i]->ArrSplits);
+		Array<CSegment*> queue;
+		int tmpcount = 0;
+		queue.push_back(m_aAllModels[i]->m_pArrSplits);
 
 		while (queue.size())
 		{
-			SaveSplit(queue[0], file, &queue);
+			saveSplit(queue[0], file, &queue);
 
 			queue.erase(0);
 			++tmpcount;
@@ -2250,10 +2254,10 @@ void StaticGeom::Save(const char* path)
 	fclose(file);
 }
 
-void StaticGeom::SaveSplit(Segment* Split, FILE* file, Array<Segment*> * queue)
+void CStaticGeom::saveSplit(CSegment* Split, FILE* file, Array<CSegment*> * queue)
 {
 	float3 jmin, jmax;
-	Split->BoundVolumeSys->getMinMax(&jmin, &jmax);
+	Split->m_pBoundVolumeSys->getMinMax(&jmin, &jmax);
 	fwrite(&jmin.x, sizeof(float), 1, file);
 	fwrite(&jmin.y, sizeof(float), 1, file);
 	fwrite(&jmin.z, sizeof(float), 1, file);
@@ -2262,7 +2266,7 @@ void StaticGeom::SaveSplit(Segment* Split, FILE* file, Array<Segment*> * queue)
 	fwrite(&jmax.y, sizeof(float), 1, file);
 	fwrite(&jmax.z, sizeof(float), 1, file);
 
-	Split->BoundVolumeP->getMinMax(&jmin, &jmax);
+	Split->m_pBoundVolumeP->getMinMax(&jmin, &jmax);
 	fwrite(&jmin.x, sizeof(float), 1, file);
 	fwrite(&jmin.y, sizeof(float), 1, file);
 	fwrite(&jmin.z, sizeof(float), 1, file);
@@ -2271,20 +2275,20 @@ void StaticGeom::SaveSplit(Segment* Split, FILE* file, Array<Segment*> * queue)
 	fwrite(&jmax.y, sizeof(float), 1, file);
 	fwrite(&jmax.z, sizeof(float), 1, file);
 
-	fwrite(&Split->CountAllPoly, sizeof(uint32_t), 1, file);
+	fwrite(&Split->m_uiCountAllPoly, sizeof(uint32_t), 1, file);
 
-	fwrite(&Split->BFNonEnd, sizeof(int8_t), 1, file);
+	fwrite(&Split->m_isNonEnd, sizeof(int8_t), 1, file);
 
-	if (Split->BFNonEnd)
+	if (Split->m_isNonEnd)
 	{
 		bool isexists = true;
 		for (int i = 0; i<GEOM_COUNT_TYPE_SEGMENTATION_OCTO; i++)
 		{
-			if (Split->Splits[i])
+			if (Split->m_aSplits[i])
 			{
 				isexists = true;
 				fwrite(&isexists, sizeof(int8_t), 1, file);
-				queue->push_back(Split->Splits[i]);
+				queue->push_back(Split->m_aSplits[i]);
 			}
 			else
 			{
@@ -2297,22 +2301,22 @@ void StaticGeom::SaveSplit(Segment* Split, FILE* file, Array<Segment*> * queue)
 	}
 	else
 	{
-		fwrite(&Split->CountSubSet, sizeof(uint32_t), 1, file);
-		fwrite(Split->NumberGroupModel, sizeof(uint32_t)*Split->CountSubSet, 1, file);
-		fwrite(Split->NumberGroup, sizeof(uint32_t)*Split->CountSubSet, 1, file);
-		fwrite(Split->CountPoly, sizeof(uint32_t)*Split->CountSubSet, 1, file);
+		fwrite(&Split->m_uiCountSubSet, sizeof(uint32_t), 1, file);
+		fwrite(Split->m_pNumberGroupModel, sizeof(uint32_t)*Split->m_uiCountSubSet, 1, file);
+		fwrite(Split->m_pNumberGroup, sizeof(uint32_t)*Split->m_uiCountSubSet, 1, file);
+		fwrite(Split->m_pCountPoly, sizeof(uint32_t)*Split->m_uiCountSubSet, 1, file);
 
-		for (long i = 0; i < Split->CountSubSet; ++i)
+		for (int i = 0; i < Split->m_uiCountSubSet; ++i)
 		{
-			fwrite(Split->ArrPoly[i], sizeof(uint32_t)*Split->CountPoly[i] * 3, 1, file);
+			fwrite(Split->m_ppArrPoly[i], sizeof(uint32_t)*Split->m_pCountPoly[i] * 3, 1, file);
 		}
 	}
 }
 
 
-void StaticGeom::Load(const char* path)
+void CStaticGeom::load(const char* path)
 {
-	DelArrIndexPtr();
+	deleteArrIndexPtr();
 
 	FILE* file = fopen(path, "rb");
 
@@ -2320,61 +2324,61 @@ void StaticGeom::Load(const char* path)
 	fread(&countgroup, sizeof(int32_t), 1, file);
 	Array<Array<Array<int32_t>>> tmpArrIdsModels;
 	vertex_static * pData;
-	long tmpbigersizebuff = 0;
+	int tmpbigersizebuff = 0;
 
-	for (long i = 0; i < countgroup; ++i)
+	for (int i = 0; i < countgroup; ++i)
 	{
-		Group* group = new Group();
+		CGroup* group = new CGroup();
 		tmpbigersizebuff = 0;
 		int32_t tmpstrlen;
 		char texname[1024];
 		fread(&tmpstrlen, sizeof(int32_t), 1, file);
 		fread(texname, sizeof(char), tmpstrlen, file);
 		texname[tmpstrlen] = 0;
-		group->name = texname;
+		group->m_sName = texname;
 		
-		group->AllCountVertex = 0;
-		group->AllCountIndex = 0;
+		group->m_iCountVertex = 0;
+		group->m_iCountIndex = 0;
 		
 		//записываем количество буферов в подгруппе
 		int32_t countbuffingroup = -1;
 		fread(&countbuffingroup, sizeof(int32_t), 1, file);
 		
-		for (long k = 0; k < countbuffingroup; ++k)
+		for (int k = 0; k < countbuffingroup; ++k)
 		{
 			//записываем количество моделей, которые используют данную подгруппу
 			int32_t countusingmodels;
 			fread(&countusingmodels, sizeof(int32_t), 1, file);
 			int32_t tmpnummodel;
-			for (long j = 0; j < countusingmodels; ++j)
+			for (int j = 0; j < countusingmodels; ++j)
 			{
 				fread(&tmpnummodel, sizeof(int32_t), 1, file);
 				tmpArrIdsModels[i][k].push_back(tmpnummodel);
 			}
 
 			//записываем количество вершин в буфере подгруппы
-			fread(&group->CountVertex[k], sizeof(int32_t), 1, file);
-			group->AllCountVertex += group->CountVertex[k];
+			fread(&group->m_aCountVertex[k], sizeof(int32_t), 1, file);
+			group->m_iCountVertex += group->m_aCountVertex[k];
 			
 			//записываем количество индексов в буфере подгруппы
-			fread(&group->CountIndex[k], sizeof(int32_t), 1, file);
-			group->AllCountIndex += group->CountIndex[k];
+			fread(&group->m_aCountIndex[k], sizeof(int32_t), 1, file);
+			group->m_iCountIndex += group->m_aCountIndex[k];
 
-			if (tmpbigersizebuff < group->CountIndex[k])
-				tmpbigersizebuff = group->CountIndex[k];
+			if (tmpbigersizebuff < group->m_aCountIndex[k])
+				tmpbigersizebuff = group->m_aCountIndex[k];
 
 			IDirect3DVertexBuffer9* vb;
-			StaticGeom::DXDevice->CreateVertexBuffer(sizeof(vertex_static)* group->CountVertex[k], NULL, NULL, D3DPOOL_MANAGED, &vb, 0);
+			CStaticGeom::m_pDXDevice->CreateVertexBuffer(sizeof(vertex_static)* group->m_aCountVertex[k], NULL, NULL, D3DPOOL_MANAGED, &vb, 0);
 
 			//записываем весь вершинный буфер подгруппы
 			vb->Lock(0, 0, (void**)&pData, 0);
-			fread(pData, sizeof(vertex_static), group->CountVertex[k], file);
+			fread(pData, sizeof(vertex_static), group->m_aCountVertex[k], file);
 		
 			/*Group::VertexBuff* vborigin = new Group::VertexBuff();
 			vborigin->count = group->CountVertex[k];
 			vborigin->arr = new float3_t[vborigin->count];
 
-			for (long j = 0; j < vborigin->count; ++j)
+			for (int j = 0; j < vborigin->count; ++j)
 			{
 				vborigin->arr[j] = pData[j].Pos;
 			}*/
@@ -2382,109 +2386,109 @@ void StaticGeom::Load(const char* path)
 			//UpdateArrMeshVertex2(group->CountVertex[k], pData);
 			vb->Unlock();
 
-			group->VertexBuffer.push_back(vb);
+			group->m_aVertexBuffers.push_back(vb);
 			//group->VertexBufferOrigin.push_back(vborigin);
 		}
 		
 		char tmptex[1024];
-		sprintf(tmptex, "%s.dds", group->name.c_str());
+		sprintf(tmptex, "%s.dds", group->m_sName.c_str());
 
-		group->idtex = SGCore_MtlLoad(tmptex, MTL_TYPE_GEOM);
-		group->IsRenderSingly = SGCore_MtlGroupRenderIsSingly(group->idtex);
-		group->SortGroup = SGCore_MtlGetSort(group->idtex);
-		AllGroups.push_back(group);
+		group->m_idTexture = SGCore_MtlLoad(tmptex, MTL_TYPE_GEOM);
+		group->m_isRenderSingly = SGCore_MtlGroupRenderIsSingly(group->m_idTexture);
+		group->m_iSortGroup = SGCore_MtlGetSort(group->m_idTexture);
+		m_aAllGroups.push_back(group);
 		
-		if (RenderIndexBuffer == 0 || SizeRenderIndexBuffer < tmpbigersizebuff)
+		if (m_pRenderIndexBuffer == 0 || m_iSizeRenderIndexBuffer < tmpbigersizebuff)
 		{
-			mem_release(RenderIndexBuffer);
-			SizeRenderIndexBuffer = tmpbigersizebuff;
-			StaticGeom::DXDevice->CreateIndexBuffer(sizeof(uint32_t)* SizeRenderIndexBuffer, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFMT_INDEX32, D3DPOOL_DEFAULT/*D3DPOOL_MANAGED*/, &RenderIndexBuffer, 0);
+			mem_release(m_pRenderIndexBuffer);
+			m_iSizeRenderIndexBuffer = tmpbigersizebuff;
+			CStaticGeom::m_pDXDevice->CreateIndexBuffer(sizeof(uint32_t)* m_iSizeRenderIndexBuffer, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFMT_INDEX32, D3DPOOL_DEFAULT/*D3DPOOL_MANAGED*/, &m_pRenderIndexBuffer, 0);
 		}
 	}
 
 	//записываем количество моделей
-	int32_t countmodels = AllModels.size();
+	int32_t countmodels = m_aAllModels.size();
 	fread(&countmodels, sizeof(int32_t), 1, file);
 
-	for (long i = 0; i < countmodels; ++i)
+	for (int i = 0; i < countmodels; ++i)
 	{
-		AllModels.push_back(0);
-		AllModels[i] = new Model();
+		m_aAllModels.push_back(0);
+		m_aAllModels[i] = new CModel();
 
 		int32_t countsubset;
 		fread(&countsubset, sizeof(int32_t), 1, file);
 
 		int32_t countlenstr = 0;
 		fread(&countlenstr, sizeof(int32_t), 1, file);
-		fread(&AllModels[i]->Name, sizeof(char), countlenstr, file);
-		AllModels[i]->Name[countlenstr] = 0;
+		fread(&m_aAllModels[i]->m_szName, sizeof(char), countlenstr, file);
+		m_aAllModels[i]->m_szName[countlenstr] = 0;
 
 		countlenstr = 0;
 		fread(&countlenstr, sizeof(int32_t), 1, file);
-		fread(&AllModels[i]->PathName, sizeof(char), countlenstr, file);
-		AllModels[i]->PathName[countlenstr] = 0;
+		fread(&m_aAllModels[i]->m_szPathName, sizeof(char), countlenstr, file);
+		m_aAllModels[i]->m_szPathName[countlenstr] = 0;
 
-		fread(&AllModels[i]->CountPoly, sizeof(int32_t), 1, file);
+		fread(&m_aAllModels[i]->m_uiCountPoly, sizeof(int32_t), 1, file);
 
-		fread(&AllModels[i]->Position.x, sizeof(float), 1, file);
-		fread(&AllModels[i]->Position.y, sizeof(float), 1, file);
-		fread(&AllModels[i]->Position.z, sizeof(float), 1, file);
+		fread(&m_aAllModels[i]->m_vPosition.x, sizeof(float), 1, file);
+		fread(&m_aAllModels[i]->m_vPosition.y, sizeof(float), 1, file);
+		fread(&m_aAllModels[i]->m_vPosition.z, sizeof(float), 1, file);
 
-		fread(&AllModels[i]->Rotation.x, sizeof(float), 1, file);
-		fread(&AllModels[i]->Rotation.y, sizeof(float), 1, file);
-		fread(&AllModels[i]->Rotation.z, sizeof(float), 1, file);
+		fread(&m_aAllModels[i]->m_vRotation.x, sizeof(float), 1, file);
+		fread(&m_aAllModels[i]->m_vRotation.y, sizeof(float), 1, file);
+		fread(&m_aAllModels[i]->m_vRotation.z, sizeof(float), 1, file);
 
-		fread(&AllModels[i]->Scale.x, sizeof(float), 1, file);
-		fread(&AllModels[i]->Scale.y, sizeof(float), 1, file);
-		fread(&AllModels[i]->Scale.z, sizeof(float), 1, file);
+		fread(&m_aAllModels[i]->m_vScale.x, sizeof(float), 1, file);
+		fread(&m_aAllModels[i]->m_vScale.y, sizeof(float), 1, file);
+		fread(&m_aAllModels[i]->m_vScale.z, sizeof(float), 1, file);
 
-		AllModels[i]->OldPosition = AllModels[i]->Position;
-		AllModels[i]->OldRotation = AllModels[i]->Rotation;
-		AllModels[i]->OldScale = AllModels[i]->Scale;
+		m_aAllModels[i]->m_vOldPosition = m_aAllModels[i]->m_vPosition;
+		m_aAllModels[i]->m_vOldRotation = m_aAllModels[i]->m_vRotation;
+		m_aAllModels[i]->m_vOldScale = m_aAllModels[i]->m_vScale;
 
-		WorldMat = SMMatrixScaling(AllModels[i]->Scale) * SMMatrixRotationX(AllModels[i]->Rotation.x) * SMMatrixRotationY(AllModels[i]->Rotation.y) * SMMatrixRotationZ(AllModels[i]->Rotation.z) * SMMatrixTranslation(AllModels[i]->Position);
+		m_mWorld = SMMatrixScaling(m_aAllModels[i]->m_vScale) * SMMatrixRotationX(m_aAllModels[i]->m_vRotation.x) * SMMatrixRotationY(m_aAllModels[i]->m_vRotation.y) * SMMatrixRotationZ(m_aAllModels[i]->m_vRotation.z) * SMMatrixTranslation(m_aAllModels[i]->m_vPosition);
 
 		fread(&countlenstr, sizeof(int32_t), 1, file);
 
 		if (countlenstr > 0)
 		{
-			fread(AllModels[i]->Lod0.PathName, sizeof(char), countlenstr, file);
-			AllModels[i]->Lod0.PathName[countlenstr] = 0;
-			SetModelLodPath(i, AllModels[i]->Lod0.PathName);
+			fread(m_aAllModels[i]->m_oLod0.m_szPathName, sizeof(char), countlenstr, file);
+			m_aAllModels[i]->m_oLod0.m_szPathName[countlenstr] = 0;
+			setModelLodPath(i, m_aAllModels[i]->m_oLod0.m_szPathName);
 		}
 
-		for (long k = 0; k < countsubset; ++k)
+		for (int k = 0; k < countsubset; ++k)
 		{
-			Model::GDataBuff gdb;
-			fread(&gdb, sizeof(Model::GDataBuff), 1, file);
-			AllModels[i]->SubSet.push_back(gdb);
+			CModel::CSubSet gdb;
+			fread(&gdb, sizeof(CModel::CSubSet), 1, file);
+			m_aAllModels[i]->m_aSubSets.push_back(gdb);
 
 			char tmptex[1024];
-			sprintf(tmptex, "%s.dds", AllGroups[gdb.idgroup]->name.c_str());
-			AllModels[i]->IDTex[k] = SGCore_MtlLoad(tmptex, MTL_TYPE_GEOM);
+			sprintf(tmptex, "%s.dds", m_aAllGroups[gdb.m_idGroup]->m_sName.c_str());
+			m_aAllModels[i]->m_aIDsTexures[k] = SGCore_MtlLoad(tmptex, MTL_TYPE_GEOM);
 		}
 
-		Array<Segment**> queue;
-		long tmpcount = 0;
-		queue.push_back(&(AllModels[i]->ArrSplits));
+		Array<CSegment**> queue;
+		int tmpcount = 0;
+		queue.push_back(&(m_aAllModels[i]->m_pArrSplits));
 
 		while (queue.size())
 		{
-			LoadSplit(queue[0], file, &queue);
+			loadSplit(queue[0], file, &queue);
 
 			queue.erase(0);
 			++tmpcount;
 		}
 
-		Segment* tmpsegment = AllModels[i]->ArrSplits;
-		SetSplitID(AllModels[i]->ArrSplits, &(AllModels[i]->SplitsIDs), (&AllModels[i]->SplitsIDsRender));
+		CSegment* tmpsegment = m_aAllModels[i]->m_pArrSplits;
+		setSplitID(m_aAllModels[i]->m_pArrSplits, &(m_aAllModels[i]->m_idCountSplits), (&m_aAllModels[i]->m_idCountSplitsRender));
 
-		AddModelInArrCom(i);
+		addModelInArrCom(i);
 
 		float3 jmin, jmax, jmin2, jmax2;
 
-		AllModels[i]->ArrSplits->BoundVolumeP->getMinMax(&jmin, &jmax);
-		BoundVolume->getMinMax(&jmin2, &jmax2);
+		m_aAllModels[i]->m_pArrSplits->m_pBoundVolumeP->getMinMax(&jmin, &jmax);
+		m_pBoundVolume->getMinMax(&jmin2, &jmax2);
 
 		if (jmin2.x > jmin.x)
 			jmin2.x = jmin.x;
@@ -2500,29 +2504,29 @@ void StaticGeom::Load(const char* path)
 		if (jmax2.z < jmax.z)
 			jmax2.z = jmax.z;
 
-		BoundVolume->setMinMax(&jmin2, &jmax2);
+		m_pBoundVolume->setMinMax(&jmin2, &jmax2);
 	}
 
-	for (long i = 0; i < AllGroups.size(); ++i)
+	for (int i = 0; i < m_aAllGroups.size(); ++i)
 	{
-		for (long k = 0; k < tmpArrIdsModels[i].size(); ++k)
+		for (int k = 0; k < tmpArrIdsModels[i].size(); ++k)
 		{
-			for (long j = 0; j < tmpArrIdsModels[i][k].size(); ++j)
+			for (int j = 0; j < tmpArrIdsModels[i][k].size(); ++j)
 			{
-				AllGroups[i]->ArrModels[k][j] = AllModels[tmpArrIdsModels[i][k][j]];
+				m_aAllGroups[i]->m_aModels[k][j] = m_aAllModels[tmpArrIdsModels[i][k][j]];
 			}
 		}
 	}
 
-	InitArrIndexPtr();
+	initArrIndexPtr();
 
 	fclose(file);
 }
 
-void StaticGeom::LoadSplit(Segment** Split, FILE* file, Array<Segment**> * queue)
+void CStaticGeom::loadSplit(CSegment** Split, FILE* file, Array<CSegment**> * queue)
 {
 	float3 jmin, jmax;
-	(*Split) = new Segment();
+	(*Split) = new CSegment();
 
 	fread(&jmin.x, sizeof(float), 1, file);
 	fread(&jmin.y, sizeof(float), 1, file);
@@ -2532,8 +2536,8 @@ void StaticGeom::LoadSplit(Segment** Split, FILE* file, Array<Segment**> * queue
 	fread(&jmax.y, sizeof(float), 1, file);
 	fread(&jmax.z, sizeof(float), 1, file);
 
-	(*Split)->BoundVolumeSys = SGCore_CrBound();
-	(*Split)->BoundVolumeSys->setMinMax(&jmin, &jmax);
+	(*Split)->m_pBoundVolumeSys = SGCore_CrBound();
+	(*Split)->m_pBoundVolumeSys->setMinMax(&jmin, &jmax);
 
 
 	fread(&jmin.x, sizeof(float), 1, file);
@@ -2544,14 +2548,14 @@ void StaticGeom::LoadSplit(Segment** Split, FILE* file, Array<Segment**> * queue
 	fread(&jmax.y, sizeof(float), 1, file);
 	fread(&jmax.z, sizeof(float), 1, file);
 
-	(*Split)->BoundVolumeP = SGCore_CrBound();
-	(*Split)->BoundVolumeP->setMinMax(&jmin, &jmax);
+	(*Split)->m_pBoundVolumeP = SGCore_CrBound();
+	(*Split)->m_pBoundVolumeP->setMinMax(&jmin, &jmax);
 
-	fread(&(*Split)->CountAllPoly, sizeof(uint32_t), 1, file);
+	fread(&(*Split)->m_uiCountAllPoly, sizeof(uint32_t), 1, file);
 
-	fread(&(*Split)->BFNonEnd, sizeof(int8_t), 1, file);
+	fread(&(*Split)->m_isNonEnd, sizeof(int8_t), 1, file);
 
-	if ((*Split)->BFNonEnd)
+	if ((*Split)->m_isNonEnd)
 	{
 		bool isexists = false;
 
@@ -2559,80 +2563,80 @@ void StaticGeom::LoadSplit(Segment** Split, FILE* file, Array<Segment**> * queue
 		{
 			fread(&isexists, sizeof(int8_t), 1, file);
 			if (isexists)
-				queue->push_back(&((*Split)->Splits[i]));
+				queue->push_back(&((*Split)->m_aSplits[i]));
 
 			isexists = false;
 		}
 	}
 	else
 	{
-		fread(&(*Split)->CountSubSet, sizeof(uint32_t), 1, file);
+		fread(&(*Split)->m_uiCountSubSet, sizeof(uint32_t), 1, file);
 
-		(*Split)->NumberGroupModel = new uint32_t[(*Split)->CountSubSet];
-		(*Split)->NumberGroup = new uint32_t[(*Split)->CountSubSet];
-		(*Split)->CountPoly = new uint32_t[(*Split)->CountSubSet];
+		(*Split)->m_pNumberGroupModel = new uint32_t[(*Split)->m_uiCountSubSet];
+		(*Split)->m_pNumberGroup = new uint32_t[(*Split)->m_uiCountSubSet];
+		(*Split)->m_pCountPoly = new uint32_t[(*Split)->m_uiCountSubSet];
 
-		fread((*Split)->NumberGroupModel, sizeof(uint32_t)*(*Split)->CountSubSet, 1, file);
-		fread((*Split)->NumberGroup, sizeof(uint32_t)*(*Split)->CountSubSet, 1, file);
-		fread((*Split)->CountPoly, sizeof(uint32_t)*(*Split)->CountSubSet, 1, file);
+		fread((*Split)->m_pNumberGroupModel, sizeof(uint32_t)*(*Split)->m_uiCountSubSet, 1, file);
+		fread((*Split)->m_pNumberGroup, sizeof(uint32_t)*(*Split)->m_uiCountSubSet, 1, file);
+		fread((*Split)->m_pCountPoly, sizeof(uint32_t)*(*Split)->m_uiCountSubSet, 1, file);
 
-		(*Split)->ArrPoly = new uint32_t*[(*Split)->CountSubSet];
+		(*Split)->m_ppArrPoly = new uint32_t*[(*Split)->m_uiCountSubSet];
 
-		for (long i = 0; i < (*Split)->CountSubSet; ++i)
+		for (int i = 0; i < (*Split)->m_uiCountSubSet; ++i)
 		{
-			(*Split)->ArrPoly[i] = new uint32_t[(*Split)->CountPoly[i] * 3];
-			fread((*Split)->ArrPoly[i], sizeof(uint32_t)*(*Split)->CountPoly[i] * 3, 1, file);
+			(*Split)->m_ppArrPoly[i] = new uint32_t[(*Split)->m_pCountPoly[i] * 3];
+			fread((*Split)->m_ppArrPoly[i], sizeof(uint32_t)*(*Split)->m_pCountPoly[i] * 3, 1, file);
 		}
 	}
 }
 
-void StaticGeom::SortGroup(float3* viewpos, int sort_mtl)
+void CStaticGeom::sortGroup(const float3* viewpos, int sort_mtl)
 {
 	float tmpradius = 0;
 	float tmpsidt = 0;
 	float3 tmpcenter = float3(0,0,0);
-	Model* tmpmodel;
+	CModel* tmpmodel;
 	Array<float> arr_dist;
 
-	long tmp_index_gd = 0;
+	int tmp_index_gd = 0;
 
 	float tmpdist = 999999;
 
-	for (int i = 0; i < AllModels.size(); ++i)
+	for (int i = 0; i < m_aAllModels.size(); ++i)
 	{
-		tmpmodel = AllModels[i];
-		for (int k = 0; k < tmpmodel->SubSet.size(); ++k)
+		tmpmodel = m_aAllModels[i];
+		for (int k = 0; k < tmpmodel->m_aSubSets.size(); ++k)
 		{
-			//if (sort_mtl == AllGroups[tmpmodel->SubSet[k].idgroup]->SortGroup)
+			//if (sort_mtl == m_aAllGroups[tmpmodel->m_aSubSets[k].idgroup]->SortGroup)
 			
-			tmpcenter = (tmpmodel->SubSet[k].Min + tmpmodel->SubSet[k].Max) * 0.5f;
-			tmpradius = SMVector3Length(tmpcenter - tmpmodel->SubSet[k].Max);
+			tmpcenter = (tmpmodel->m_aSubSets[k].m_vMin + tmpmodel->m_aSubSets[k].m_vMax) * 0.5f;
+			tmpradius = SMVector3Length(tmpcenter - tmpmodel->m_aSubSets[k].m_vMax);
 			//tmpmodel->GroupDist[k] = SMVector3Length((tmpcenter - (*viewpos))) - tmpradius;
 			
-			if (DistGroup.size() <= tmp_index_gd || !DistGroup[tmp_index_gd])
-				DistGroup[tmp_index_gd] = new InfoGroup();
+			if (m_aDistGroup.size() <= tmp_index_gd || !m_aDistGroup[tmp_index_gd])
+				m_aDistGroup[tmp_index_gd] = new CInfoGroup();
 
-			DistGroup[tmp_index_gd]->count = 0;
-			DistGroup[tmp_index_gd]->dist = SMVector3Length((tmpcenter - (*viewpos))) - tmpradius;
-			DistGroup[tmp_index_gd]->group = k;
-			DistGroup[tmp_index_gd]->g_group = tmpmodel->SubSet[k].idgroup;
-			DistGroup[tmp_index_gd]->model = i;
+			//m_aDistGroup[tmp_index_gd]->m_iCount = 0;
+			m_aDistGroup[tmp_index_gd]->m_fDist = SMVector3Length((tmpcenter - (*viewpos))) - tmpradius;
+			m_aDistGroup[tmp_index_gd]->m_idGroup = k;
+			m_aDistGroup[tmp_index_gd]->m_idGlobalGroup = tmpmodel->m_aSubSets[k].m_idGroup;
+			m_aDistGroup[tmp_index_gd]->m_idModel = i;
 
 			++tmp_index_gd;
 		}
 	}
 
-	for (int i = 0; i < DistGroup.size(); ++i)
+	for (int i = 0; i < m_aDistGroup.size(); ++i)
 	{
-		InfoGroup* tmpig = DistGroup[i];
+		CInfoGroup* tmpig = m_aDistGroup[i];
 		
 		int pos = i;
-		for (int k = i+1; k < DistGroup.size(); ++k)
+		for (int k = i+1; k < m_aDistGroup.size(); ++k)
 		{
-			InfoGroup* tmpig2 = DistGroup[k];
+			CInfoGroup* tmpig2 = m_aDistGroup[k];
 			int qwert = 0;
 
-			if (tmpig->dist > tmpig2->dist)
+			if (tmpig->m_fDist > tmpig2->m_fDist)
 			{
 				pos = k;
 				tmpig = tmpig2;
@@ -2641,27 +2645,27 @@ void StaticGeom::SortGroup(float3* viewpos, int sort_mtl)
 			}
 		}
 
-		DistGroup[pos] = DistGroup[i];
-		DistGroup[i] = tmpig;
+		m_aDistGroup[pos] = m_aDistGroup[i];
+		m_aDistGroup[i] = tmpig;
 
 		int qwert = 0;
 	}
 }
 
 
-void StaticGeom::GetIntersectedRayY2(float3* pos, Segment** arrsplits, DWORD *count, Segment* comsegment, ID curr_splits_ids_render)
+void CStaticGeom::getIntersectedRayY2(float3* pos, CSegment** arrsplits, int *count, CSegment* comsegment, ID curr_splits_ids_render)
 {
 	float3 jmin, jmax;
-	comsegment->BoundVolumeP->getMinMax(&jmin, &jmax);
+	comsegment->m_pBoundVolumeP->getMinMax(&jmin, &jmax);
 
-	if (comsegment->CountAllPoly > 0 && pos->x >= jmin.x && pos->z >= jmin.z && pos->x <= jmax.x && pos->z <= jmax.z)
+	if (comsegment->m_uiCountAllPoly > 0 && pos->x >= jmin.x && pos->z >= jmin.z && pos->x <= jmax.x && pos->z <= jmax.z)
 	{
-		if (comsegment->BFNonEnd)
+		if (comsegment->m_isNonEnd)
 		{
 			for (int j = 0; j<GEOM_COUNT_TYPE_SEGMENTATION_OCTO; j++)
 			{
-				if (comsegment->Splits[j])
-					GetIntersectedRayY2(pos, arrsplits, count, comsegment->Splits[j], curr_splits_ids_render);
+				if (comsegment->m_aSplits[j])
+					getIntersectedRayY2(pos, arrsplits, count, comsegment->m_aSplits[j], curr_splits_ids_render);
 			}
 		}
 		else
@@ -2676,8 +2680,11 @@ void StaticGeom::GetIntersectedRayY2(float3* pos, Segment** arrsplits, DWORD *co
 	}
 }
 
-bool StaticGeom::GetIntersectedRayY(float3* pos)
+bool CStaticGeom::getIntersectedRayY(float3* pos)
 {
+	D3DXVECTOR3 jpos;
+	float3 jvec0, jvec1, jvec2;
+
 	jpos = (D3DXVECTOR3)*pos;
 	BOOL Hit;
 	float u, v, Dist, CountDist;
@@ -2686,47 +2693,47 @@ bool StaticGeom::GetIntersectedRayY(float3* pos)
 	CountDist = -1000;
 	bool is_find = false;
 
-	for (int id = 0; id < AllModels.size(); ++id)
+	for (int id = 0; id < m_aAllModels.size(); ++id)
 	{
-		ArrComFor[1]->arr[id]->CountCom = 0;
+		m_aArrComFor[1]->m_aIRS[id]->m_iCountCom = 0;
 
-		GetIntersectedRayY2(pos, ArrComFor[1]->arr[id]->Arr, &(ArrComFor[1]->arr[id]->CountCom), AllModels[id]->ArrSplits, ArrComFor[1]->arr[id]->Count);
+		getIntersectedRayY2(pos, m_aArrComFor[1]->m_aIRS[id]->m_ppSegments, &(m_aArrComFor[1]->m_aIRS[id]->m_iCountCom), m_aAllModels[id]->m_pArrSplits, m_aArrComFor[1]->m_aIRS[id]->m_iCount);
 
-		for (DWORD k = 0; k<ArrComFor[1]->arr[id]->CountCom; ++k)
+		for (DWORD k = 0; k<m_aArrComFor[1]->m_aIRS[id]->m_iCountCom; ++k)
 		{
-			for (DWORD group = 0; group<ArrComFor[1]->arr[id]->Arr[k]->CountSubSet; group++)
+			for (DWORD group = 0; group<m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_uiCountSubSet; group++)
 			{
-				if (AllGroups[ArrComFor[1]->arr[id]->Arr[k]->NumberGroup[group]]->SortGroup > 0)
+				if (m_aAllGroups[m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_pNumberGroup[group]]->m_iSortGroup > 0)
 					continue;
 
-				ID idbuff = AllModels[id]->SubSet[ArrComFor[1]->arr[id]->Arr[k]->NumberGroupModel[group]].idbuff;
-				ID idgroup = ArrComFor[1]->arr[id]->Arr[k]->NumberGroup[group];
+				ID idbuff = m_aAllModels[id]->m_aSubSets[m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_pNumberGroupModel[group]].m_idBuff;
+				ID idgroup = m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_pNumberGroup[group];
 
 				vertex_static* pData = 0;
-				if (FAILED(AllGroups[idgroup]->VertexBuffer[idbuff]->Lock(0, 0, (void**)&pData, 0)))
+				if (FAILED(m_aAllGroups[idgroup]->m_aVertexBuffers[idbuff]->Lock(0, 0, (void**)&pData, 0)))
 					continue;
 
-				for (DWORD numpoly = 0; numpoly<ArrComFor[1]->arr[id]->Arr[k]->CountPoly[group] * 3; numpoly += 3)
+				for (DWORD numpoly = 0; numpoly<m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_pCountPoly[group] * 3; numpoly += 3)
 				{
 					Dist = -1000.f;
 					//находим все 3 вершины
-					/*jvec0 = ArrMeshVertex2[ArrComFor[1].arr[id]->Arr[k]->ArrPoly[group][numpoly]];
-					jvec1 = ArrMeshVertex2[ArrComFor[1].arr[id]->Arr[k]->ArrPoly[group][numpoly + 1]];
-					jvec2 = ArrMeshVertex2[ArrComFor[1].arr[id]->Arr[k]->ArrPoly[group][numpoly + 2]];*/
+					/*jvec0 = ArrMeshVertex2[m_aArrComFor[1].arr[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly]];
+					jvec1 = ArrMeshVertex2[m_aArrComFor[1].arr[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly + 1]];
+					jvec2 = ArrMeshVertex2[m_aArrComFor[1].arr[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly + 2]];*/
 					
-					//jvec0 = AllGroups[idgroup]->VertexBufferOrigin[idbuff]->arr[ArrComFor[1]->arr[id]->Arr[k]->ArrPoly[group][numpoly]];
-					//jvec1 = AllGroups[idgroup]->VertexBufferOrigin[idbuff]->arr[ArrComFor[1]->arr[id]->Arr[k]->ArrPoly[group][numpoly + 1]];
-					//jvec2 = AllGroups[idgroup]->VertexBufferOrigin[idbuff]->arr[ArrComFor[1]->arr[id]->Arr[k]->ArrPoly[group][numpoly + 2]];
+					//jvec0 = m_aAllGroups[idgroup]->VertexBufferOrigin[idbuff]->arr[m_aArrComFor[1]->arr[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly]];
+					//jvec1 = m_aAllGroups[idgroup]->VertexBufferOrigin[idbuff]->arr[m_aArrComFor[1]->arr[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly + 1]];
+					//jvec2 = m_aAllGroups[idgroup]->VertexBufferOrigin[idbuff]->arr[m_aArrComFor[1]->arr[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly + 2]];
 
-					jvec0 = pData[ArrComFor[1]->arr[id]->Arr[k]->ArrPoly[group][numpoly]].Pos;
-					jvec1 = pData[ArrComFor[1]->arr[id]->Arr[k]->ArrPoly[group][numpoly + 1]].Pos;
-					jvec2 = pData[ArrComFor[1]->arr[id]->Arr[k]->ArrPoly[group][numpoly + 2]].Pos;
+					jvec0 = pData[m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly]].Pos;
+					jvec1 = pData[m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly + 1]].Pos;
+					jvec2 = pData[m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly + 2]].Pos;
 
 					Hit = D3DXIntersectTri(&(jvec0.operator D3DXVECTOR3()),
 						&(jvec1.operator D3DXVECTOR3()),
 						&(jvec2.operator D3DXVECTOR3()),
 						&(jpos),
-						&jvevyn, &u, &v, &Dist);
+						&gс_vYmin, &u, &v, &Dist);
 
 					if (Hit && tmpy < (pos->y - Dist * 1000))
 					{
@@ -2739,7 +2746,7 @@ bool StaticGeom::GetIntersectedRayY(float3* pos)
 							&(jvec1.operator D3DXVECTOR3()),
 							&(jvec2.operator D3DXVECTOR3()),
 							&(jpos),
-							&jvevyp, &u, &v, &Dist);
+							&gс_vYmax, &u, &v, &Dist);
 						if (Hit)
 						{
 							pos->y += Dist * 1000;
@@ -2749,7 +2756,7 @@ bool StaticGeom::GetIntersectedRayY(float3* pos)
 					}
 				}
 
-				AllGroups[idgroup]->VertexBuffer[idbuff]->Unlock();
+				m_aAllGroups[idgroup]->m_aVertexBuffers[idbuff]->Unlock();
 			}
 		}
 	}
@@ -2757,30 +2764,30 @@ bool StaticGeom::GetIntersectedRayY(float3* pos)
 	return is_find;
 }
 
-void StaticGeom::GetMinMax(float3* min, float3* max)
+void CStaticGeom::getMinMax(float3* min, float3* max)
 {
-	BoundVolume->getMinMax(min, max);
+	m_pBoundVolume->getMinMax(min, max);
 }
 
-ID StaticGeom::AddArrForCom()
+ID CStaticGeom::addArrForCom()
 {
-	IRSData* ttmpdata = new IRSData();
+	CIRSData* ttmpdata = new CIRSData();
 	
-	for (int i = 0; i < AllModels.size(); ++i)
+	for (int i = 0; i < m_aAllModels.size(); ++i)
 	{
-		InfoRenderSegments* tmpirs = new InfoRenderSegments();
-		tmpirs->Count = AllModels[i]->SplitsIDsRender;
-		tmpirs->Arr = new Segment*[AllModels[i]->SplitsIDsRender];
-		tmpirs->CountCom = 0;
-		ttmpdata->arr.push_back(tmpirs);
+		CInfoRenderSegments* tmpirs = new CInfoRenderSegments();
+		tmpirs->m_iCount = m_aAllModels[i]->m_idCountSplitsRender;
+		tmpirs->m_ppSegments = new CSegment*[m_aAllModels[i]->m_idCountSplitsRender];
+		tmpirs->m_iCountCom = 0;
+		ttmpdata->m_aIRS.push_back(tmpirs);
 	}
 
 	ID id_arr = -1;
-	for (int i = 0; i < ArrComFor.size(); ++i)
+	for (int i = 0; i < m_aArrComFor.size(); ++i)
 	{
-		if (ArrComFor[i] == 0)
+		if (m_aArrComFor[i] == 0)
 		{
-			ArrComFor[i] = ttmpdata;
+			m_aArrComFor[i] = ttmpdata;
 			id_arr = i;
 			break;
 		}
@@ -2788,212 +2795,212 @@ ID StaticGeom::AddArrForCom()
 
 	if (id_arr == -1)
 	{
-		ArrComFor.push_back(ttmpdata);
-		id_arr = ArrComFor.size() - 1;
+		m_aArrComFor.push_back(ttmpdata);
+		id_arr = m_aArrComFor.size() - 1;
 	}
 
 	return id_arr;
 }
 
-bool StaticGeom::existsArrForCom(ID id)
+bool CStaticGeom::existsArrForCom(ID id)
 {
-	return (ArrComFor.size() > id);
+	return (m_aArrComFor.size() > id);
 }
 
-void StaticGeom::DelArrForCom(ID id_arr)
+void CStaticGeom::deleteArrForCom(ID id_arr)
 {
 	STATIC_PRECOND_ARRCOMFOR_ERR_ID(id_arr);
 
-	mem_delete(ArrComFor[id_arr]);
+	mem_delete(m_aArrComFor[id_arr]);
 }
 
-void StaticGeom::AddModelInArrCom(ID id_model)
+void CStaticGeom::addModelInArrCom(ID id_model)
 {
 	STATIC_PRECOND_ARRCOMFOR_ERR_ID_MODEL(id_model, _VOID);
 
-	for (long i = 0; i < ArrComFor.size(); ++i)
+	for (int i = 0; i < m_aArrComFor.size(); ++i)
 	{
-		InfoRenderSegments* tmpirs = new InfoRenderSegments();
-		tmpirs->Count = AllModels[id_model]->SplitsIDsRender;
-		tmpirs->Arr = new Segment*[AllModels[id_model]->SplitsIDsRender];
-		tmpirs->CountCom = 0;
-		ArrComFor[i]->arr.push_back(tmpirs);
+		CInfoRenderSegments* tmpirs = new CInfoRenderSegments();
+		tmpirs->m_iCount = m_aAllModels[id_model]->m_idCountSplitsRender;
+		tmpirs->m_ppSegments = new CSegment*[m_aAllModels[id_model]->m_idCountSplitsRender];
+		tmpirs->m_iCountCom = 0;
+		m_aArrComFor[i]->m_aIRS.push_back(tmpirs);
 	}
 }
 
-void StaticGeom::DelModelInArrCom(ID id_model)
+void CStaticGeom::deleteModelInArrCom(ID id_model)
 {
 	STATIC_PRECOND_ARRCOMFOR_ERR_ID_MODEL(id_model, _VOID);
 
-	for (int i = 0; i < ArrComFor.size(); ++i)
+	for (int i = 0; i < m_aArrComFor.size(); ++i)
 	{
-		if (!(ArrComFor[i]))
+		if (!(m_aArrComFor[i]))
 			continue;
 
-		mem_delete(ArrComFor[i]->arr[id_model]);
-		ArrComFor[i]->arr.erase(id_model);
+		mem_delete(m_aArrComFor[i]->m_aIRS[id_model]);
+		m_aArrComFor[i]->m_aIRS.erase(id_model);
 	}
 }
 
 ///
 
-char* StaticGeom::GetModelName(ID id)
+char* CStaticGeom::getModelName(ID id)
 {
-	if (id < AllModels.size())
-		return AllModels[id]->Name;
+	if (id < m_aAllModels.size())
+		return m_aAllModels[id]->m_szName;
 
 	return 0;
 }
 
-const char* StaticGeom::GetModelPathName(ID id)
+const char* CStaticGeom::getModelPathName(ID id)
 {
-	if (id < AllModels.size())
-		return AllModels[id]->PathName;
+	if (id < m_aAllModels.size())
+		return m_aAllModels[id]->m_szPathName;
 
 	return 0;
 }
 
-long StaticGeom::GetModelCountPoly(ID id)
+int CStaticGeom::getModelCountPoly(ID id)
 {
-	if (id < AllModels.size())
-		return AllModels[id]->CountPoly;
+	if (id < m_aAllModels.size())
+		return m_aAllModels[id]->m_uiCountPoly;
 
 	return -1;
 }
 
-void StaticGeom::GetModelMinMax(ID id, float3* min, float3* max)
+void CStaticGeom::getModelMinMax(ID id, float3* min, float3* max)
 {
-	if (id >= AllModels.size())
+	if (id >= m_aAllModels.size())
 		return;
 
-	AllModels[id]->ArrSplits->BoundVolumeP->getMinMax(min, max);
+	m_aAllModels[id]->m_pArrSplits->m_pBoundVolumeP->getMinMax(min, max);
 }
 
 
-float3* StaticGeom::GetModelPosition(ID id)
+float3* CStaticGeom::getModelPosition(ID id)
 {
-	if (id < AllModels.size())
-		return &AllModels[id]->Position;
+	if (id < m_aAllModels.size())
+		return &m_aAllModels[id]->m_vPosition;
 
 	return 0;
 }
 
-float3* StaticGeom::GetModelRotation(ID id)
+float3* CStaticGeom::getModelRotation(ID id)
 {
-	if (id < AllModels.size())
-		return &AllModels[id]->Rotation;
+	if (id < m_aAllModels.size())
+		return &m_aAllModels[id]->m_vRotation;
 
 	return 0;
 }
 
-float3* StaticGeom::GetModelScale(ID id)
+float3* CStaticGeom::getModelScale(ID id)
 {
-	if (id < AllModels.size())
-		return &AllModels[id]->Scale;
+	if (id < m_aAllModels.size())
+		return &m_aAllModels[id]->m_vScale;
 
 	return 0;
 }
 
-const char* StaticGeom::GetModelLodPath(ID id)
+const char* CStaticGeom::getModelLodPath(ID id)
 {
-	if (id < AllModels.size())
-		return AllModels[id]->Lod0.PathName;
+	if (id < m_aAllModels.size())
+		return m_aAllModels[id]->m_oLod0.m_szPathName;
 
 	return 0;
 }
 
-void StaticGeom::SetModelLodPath(ID id, const char* path)
+void CStaticGeom::setModelLodPath(ID id, const char* path)
 {
-	if (id < AllModels.size() && def_str_validate(path))
+	if (id < m_aAllModels.size() && def_str_validate(path))
 	{
-		mem_delete(AllModels[id]->Lod0.model);
-		AllModels[id]->Lod0.IDsTexs.clear();
-		//AllModels[id]->Lod0.model = new DataStaticModel();
+		mem_delete(m_aAllModels[id]->m_oLod0.m_pModel);
+		m_aAllModels[id]->m_oLod0.m_aIDsTextures.clear();
+		//m_aAllModels[id]->m_oLod0.model = new DataStaticModel();
 		char tmppath[1024];
 		sprintf(tmppath, "%s%s", Core_RStringGet(G_RI_STRING_PATH_GS_MESHES), path);
-		SGCore_StaticModelLoad(tmppath, &(AllModels[id]->Lod0.model));
+		SGCore_StaticModelLoad(tmppath, &(m_aAllModels[id]->m_oLod0.m_pModel));
 
 		char tmptex[1024];
 		ID tmpidmat;
-		for (int i = 0; i < AllModels[id]->Lod0.model->m_uiSubsetCount; ++i)
+		for (int i = 0; i < m_aAllModels[id]->m_oLod0.m_pModel->m_uiSubsetCount; ++i)
 		{
-			sprintf(tmptex, "%s.dds", AllModels[id]->Lod0.model->m_ppTextures[i]);
+			sprintf(tmptex, "%s.dds", m_aAllModels[id]->m_oLod0.m_pModel->m_ppTextures[i]);
 			tmpidmat = SGCore_MtlLoad(tmptex, MTL_TYPE_GEOM);
-			AllModels[id]->Lod0.IDsTexs.push_back(tmpidmat);
-			AllModels[id]->Lod0.SortGroup = SGCore_MtlGetSort(tmpidmat);
+			m_aAllModels[id]->m_oLod0.m_aIDsTextures.push_back(tmpidmat);
+			m_aAllModels[id]->m_oLod0.m_iSortGroup = SGCore_MtlGetSort(tmpidmat);
 		}
 
-		sprintf(AllModels[id]->Lod0.PathName,"%s",path);
+		sprintf(m_aAllModels[id]->m_oLod0.m_szPathName,"%s",path);
 		
-		AllModels[id]->Lod0.BoundVolume->calcBound(AllModels[id]->Lod0.model->m_pVertexBuffer, AllModels[id]->Lod0.model->m_uiAllVertexCount, sizeof(vertex_static));
+		m_aAllModels[id]->m_oLod0.m_pBoundVolume->calcBound(m_aAllModels[id]->m_oLod0.m_pModel->m_pVertexBuffer, m_aAllModels[id]->m_oLod0.m_pModel->m_uiAllVertexCount, sizeof(vertex_static));
 		
-		ApplyTransformLod(id);
+		applyTransformLod(id);
 	}
 }
 
-void StaticGeom::ApplyTransform(ID id)
+void CStaticGeom::applyTransform(ID id)
 {
-	if (id >= AllModels.size())
+	if (id >= m_aAllModels.size())
 		return;
-	Model* tmpmodel = AllModels[id];
+	CModel* tmpmodel = m_aAllModels[id];
 
-	float3 tmppos = tmpmodel->Position - tmpmodel->OldPosition;
-	float3 tmprot = tmpmodel->Rotation - tmpmodel->OldRotation;
-	float3 tmpscale = tmpmodel->Scale / tmpmodel->OldScale;
+	float3 tmppos = tmpmodel->m_vPosition - tmpmodel->m_vOldPosition;
+	float3 tmprot = tmpmodel->m_vRotation - tmpmodel->m_vOldRotation;
+	float3 tmpscale = tmpmodel->m_vScale / tmpmodel->m_vOldScale;
 
 	float3 jmin, jmax;
-	tmpmodel->ArrSplits->BoundVolumeP->getMinMax(&jmin, &jmax);
+	tmpmodel->m_pArrSplits->m_pBoundVolumeP->getMinMax(&jmin, &jmax);
 	float3 jcentererpos = (jmax + jmin)*0.5f;
 	
-	RotationMat = SMMatrixRotationX(tmprot.x) * SMMatrixRotationY(tmprot.y) * SMMatrixRotationZ(tmprot.z);
-	WorldMat = SMMatrixScaling(tmpscale) * RotationMat * SMMatrixTranslation(tmppos);
+	m_mRotation = SMMatrixRotationX(tmprot.x) * SMMatrixRotationY(tmprot.y) * SMMatrixRotationZ(tmprot.z);
+	m_mWorld = SMMatrixScaling(tmpscale) * m_mRotation * SMMatrixTranslation(tmppos);
 
 
-	ApplyTransformLod(id);
+	applyTransformLod(id);
 
 	vertex_static* pData;
 	float3_t* pData2;
-	long idgroup;
-	long idbuff;
+	int idgroup;
+	int idbuff;
 
-	long vertexstart, vertexcount;
+	int vertexstart, vertexcount;
 	
-	for (long i = 0; i < tmpmodel->SubSet.size(); ++i)
+	for (int i = 0; i < tmpmodel->m_aSubSets.size(); ++i)
 	{
-		tmpmodel->SubSet[i].Center = SMVector3Transform(tmpmodel->SubSet[i].Center, WorldMat);
-		D3DXPlaneTransform(&tmpmodel->SubSet[i].Plane, &tmpmodel->SubSet[i].Plane, &(WorldMat.operator D3DXMATRIX()));
+		tmpmodel->m_aSubSets[i].m_vCenter = SMVector3Transform(tmpmodel->m_aSubSets[i].m_vCenter, m_mWorld);
+		D3DXPlaneTransform(&tmpmodel->m_aSubSets[i].m_oPlane, &tmpmodel->m_aSubSets[i].m_oPlane, &(m_mWorld.operator D3DXMATRIX()));
 
 
-		tmpmodel->SubSet[i].Min.x -= jcentererpos.x;
-		tmpmodel->SubSet[i].Min.y -= jcentererpos.y;
-		tmpmodel->SubSet[i].Min.z -= jcentererpos.z;
+		tmpmodel->m_aSubSets[i].m_vMin.x -= jcentererpos.x;
+		tmpmodel->m_aSubSets[i].m_vMin.y -= jcentererpos.y;
+		tmpmodel->m_aSubSets[i].m_vMin.z -= jcentererpos.z;
 
-		tmpmodel->SubSet[i].Min = SMVector3Transform(tmpmodel->SubSet[i].Min, WorldMat);
+		tmpmodel->m_aSubSets[i].m_vMin = SMVector3Transform(tmpmodel->m_aSubSets[i].m_vMin, m_mWorld);
 
-		tmpmodel->SubSet[i].Min.x += jcentererpos.x;
-		tmpmodel->SubSet[i].Min.y += jcentererpos.y;
-		tmpmodel->SubSet[i].Min.z += jcentererpos.z;
+		tmpmodel->m_aSubSets[i].m_vMin.x += jcentererpos.x;
+		tmpmodel->m_aSubSets[i].m_vMin.y += jcentererpos.y;
+		tmpmodel->m_aSubSets[i].m_vMin.z += jcentererpos.z;
 
 
-		tmpmodel->SubSet[i].Max.x -= jcentererpos.x;
-		tmpmodel->SubSet[i].Max.y -= jcentererpos.y;
-		tmpmodel->SubSet[i].Max.z -= jcentererpos.z;
+		tmpmodel->m_aSubSets[i].m_vMax.x -= jcentererpos.x;
+		tmpmodel->m_aSubSets[i].m_vMax.y -= jcentererpos.y;
+		tmpmodel->m_aSubSets[i].m_vMax.z -= jcentererpos.z;
 
-		tmpmodel->SubSet[i].Max = SMVector3Transform(tmpmodel->SubSet[i].Max, WorldMat);
+		tmpmodel->m_aSubSets[i].m_vMax = SMVector3Transform(tmpmodel->m_aSubSets[i].m_vMax, m_mWorld);
 
-		tmpmodel->SubSet[i].Max.x += jcentererpos.x;
-		tmpmodel->SubSet[i].Max.y += jcentererpos.y;
-		tmpmodel->SubSet[i].Max.z += jcentererpos.z;
+		tmpmodel->m_aSubSets[i].m_vMax.x += jcentererpos.x;
+		tmpmodel->m_aSubSets[i].m_vMax.y += jcentererpos.y;
+		tmpmodel->m_aSubSets[i].m_vMax.z += jcentererpos.z;
 
 
 
-		idgroup = tmpmodel->SubSet[i].idgroup;
-		idbuff = tmpmodel->SubSet[i].idbuff;
-		//pData2 = AllGroups[idgroup]->VertexBufferOrigin[idbuff]->arr;
-		if (!FAILED(AllGroups[idgroup]->VertexBuffer[idbuff]->Lock(0, 0, (void**)&pData, 0)))
+		idgroup = tmpmodel->m_aSubSets[i].m_idGroup;
+		idbuff = tmpmodel->m_aSubSets[i].m_idBuff;
+		//pData2 = m_aAllGroups[idgroup]->VertexBufferOrigin[idbuff]->arr;
+		if (!FAILED(m_aAllGroups[idgroup]->m_aVertexBuffers[idbuff]->Lock(0, 0, (void**)&pData, 0)))
 		{
-			vertexstart = tmpmodel->SubSet[i].VertexStart;
-			vertexcount = tmpmodel->SubSet[i].VertexCount;
+			vertexstart = tmpmodel->m_aSubSets[i].m_idVertexStart;
+			vertexcount = tmpmodel->m_aSubSets[i].m_uiVertexCount;
 
 			for (int k = 0; k < vertexcount; ++k)
 			{
@@ -3001,53 +3008,53 @@ void StaticGeom::ApplyTransform(ID id)
 				pData[vertexstart + k].Pos.y -= jcentererpos.y;
 				pData[vertexstart + k].Pos.z -= jcentererpos.z;
 
-				pData[vertexstart + k].Pos = SMVector3Transform(pData[vertexstart + k].Pos, WorldMat);
-				pData[vertexstart + k].Norm = SMVector3Transform(pData[vertexstart + k].Norm, RotationMat);
+				pData[vertexstart + k].Pos = SMVector3Transform(pData[vertexstart + k].Pos, m_mWorld);
+				pData[vertexstart + k].Norm = SMVector3Transform(pData[vertexstart + k].Norm, m_mRotation);
 
 				pData[vertexstart + k].Pos.x += jcentererpos.x;
 				pData[vertexstart + k].Pos.y += jcentererpos.y;
 				pData[vertexstart + k].Pos.z += jcentererpos.z;
 			}
-			AllGroups[idgroup]->VertexBuffer[idbuff]->Unlock();
+			m_aAllGroups[idgroup]->m_aVertexBuffers[idbuff]->Unlock();
 		}
 	}
 
-	Array<Segment*, GEOM_DEFAULT_RESERVE_COM> queue;
-	long tmpcount = 0;
-	queue.push_back(tmpmodel->ArrSplits);
+	Array<CSegment*, GEOM_DEFAULT_RESERVE_COM> queue;
+	int tmpcount = 0;
+	queue.push_back(tmpmodel->m_pArrSplits);
 
 	float3 tmpmin, tmpmax;
 
 	while (queue.size())
 	{
-		queue[0]->BoundVolumeSys->getMinMax(&tmpmin, &tmpmax);
+		queue[0]->m_pBoundVolumeSys->getMinMax(&tmpmin, &tmpmax);
 		tmpmin -= jcentererpos;
 		tmpmax -= jcentererpos;
 
-		tmpmin = SMVector3Transform(tmpmin, WorldMat);
-		tmpmax = SMVector3Transform(tmpmax, WorldMat);
+		tmpmin = SMVector3Transform(tmpmin, m_mWorld);
+		tmpmax = SMVector3Transform(tmpmax, m_mWorld);
 
 		tmpmin += jcentererpos;
 		tmpmax += jcentererpos;
-		queue[0]->BoundVolumeSys->setMinMax(&tmpmin, &tmpmax);
+		queue[0]->m_pBoundVolumeSys->setMinMax(&tmpmin, &tmpmax);
 
-		queue[0]->BoundVolumeP->getMinMax(&tmpmin, &tmpmax);
+		queue[0]->m_pBoundVolumeP->getMinMax(&tmpmin, &tmpmax);
 		tmpmin -= jcentererpos;
 		tmpmax -= jcentererpos;
 
-		tmpmin = SMVector3Transform(tmpmin, WorldMat);
-		tmpmax = SMVector3Transform(tmpmax, WorldMat);
+		tmpmin = SMVector3Transform(tmpmin, m_mWorld);
+		tmpmax = SMVector3Transform(tmpmax, m_mWorld);
 
 		tmpmin += jcentererpos;
 		tmpmax += jcentererpos;
-		queue[0]->BoundVolumeP->setMinMax(&tmpmin, &tmpmax);
+		queue[0]->m_pBoundVolumeP->setMinMax(&tmpmin, &tmpmax);
 
-		if (queue[0]->BFNonEnd)
+		if (queue[0]->m_isNonEnd)
 		{
 			for (int i = 0; i<GEOM_COUNT_TYPE_SEGMENTATION_OCTO; ++i)
 			{
-				if (queue[0]->Splits[i])
-					queue.push_back(queue[0]->Splits[i]);
+				if (queue[0]->m_aSplits[i])
+					queue.push_back(queue[0]->m_aSplits[i]);
 			}
 		}
 
@@ -3055,101 +3062,101 @@ void StaticGeom::ApplyTransform(ID id)
 		++tmpcount;
 	}
 
-	tmpmodel->OldPosition = tmpmodel->Position;
-	tmpmodel->OldRotation = tmpmodel->Rotation;
-	tmpmodel->OldScale = tmpmodel->Scale;
+	tmpmodel->m_vOldPosition = tmpmodel->m_vPosition;
+	tmpmodel->m_vOldRotation = tmpmodel->m_vRotation;
+	tmpmodel->m_vOldScale = tmpmodel->m_vScale;
 }
 
-void StaticGeom::ApplyTransformLod(ID id)
+void CStaticGeom::applyTransformLod(ID id)
 {
-	if (id >= AllModels.size() || AllModels[id]->Lod0.model == 0)
+	if (id >= m_aAllModels.size() || m_aAllModels[id]->m_oLod0.m_pModel == 0)
 		return;
 
-	Model* tmpmodel = AllModels[id];
+	CModel* tmpmodel = m_aAllModels[id];
 	vertex_static* pData;
 
 	float3 jmin, jmax;
-	AllModels[id]->Lod0.BoundVolume->getMinMax(&jmin, &jmax);
+	m_aAllModels[id]->m_oLod0.m_pBoundVolume->getMinMax(&jmin, &jmax);
 	float3 jcentererpos = (jmax + jmin)*0.5f;
 
-	tmpmodel->Lod0.model->m_pVertexBuffer->Lock(0, 0, (void**)&pData, 0);
+	tmpmodel->m_oLod0.m_pModel->m_pVertexBuffer->Lock(0, 0, (void**)&pData, 0);
 
-	for (long i = 0; i < tmpmodel->Lod0.model->m_uiAllVertexCount; ++i)
+	for (int i = 0; i < tmpmodel->m_oLod0.m_pModel->m_uiAllVertexCount; ++i)
 	{
 		pData[i].Pos.x -= jcentererpos.x;
 		pData[i].Pos.y -= jcentererpos.y;
 		pData[i].Pos.z -= jcentererpos.z;
-		pData[i].Pos = SMVector3Transform(pData[i].Pos, WorldMat);
+		pData[i].Pos = SMVector3Transform(pData[i].Pos, m_mWorld);
 		pData[i].Pos.x += jcentererpos.x;
 		pData[i].Pos.y += jcentererpos.y;
 		pData[i].Pos.z += jcentererpos.z;
 	}
 
-	tmpmodel->Lod0.model->m_pVertexBuffer->Unlock();
+	tmpmodel->m_oLod0.m_pModel->m_pVertexBuffer->Unlock();
 
 	
 	jmin -= jcentererpos;
 	jmax -= jcentererpos;
 
-	jmin = SMVector3Transform(jmin, WorldMat);
-	jmax = SMVector3Transform(jmax, WorldMat);
+	jmin = SMVector3Transform(jmin, m_mWorld);
+	jmax = SMVector3Transform(jmax, m_mWorld);
 
 	jmin += jcentererpos;
 	jmax += jcentererpos;
-	tmpmodel->Lod0.BoundVolume->setMinMax(&jmin, &jmax);
+	tmpmodel->m_oLod0.m_pBoundVolume->setMinMax(&jmin, &jmax);
 }
 
-void StaticGeom::Clear()
+void CStaticGeom::clear()
 {
-	DelArrIndexPtr();
-	for (long i = 0; i < AllGroups.size(); ++i)
+	deleteArrIndexPtr();
+	for (int i = 0; i < m_aAllGroups.size(); ++i)
 	{
-		mem_delete(AllGroups[i]);
+		mem_delete(m_aAllGroups[i]);
 	}
-	AllGroups.clear();
+	m_aAllGroups.clear();
 
-	while (AllModels.size() > 0)
+	while (m_aAllModels.size() > 0)
 	{
-		DelModelInArrCom(0);
-		mem_delete(AllModels[0]);
-		AllModels.erase(0);
+		deleteModelInArrCom(0);
+		mem_delete(m_aAllModels[0]);
+		m_aAllModels.erase(0);
 	}
-	AllModels.clear();
+	m_aAllModels.clear();
 
-	while (ArrComFor.size() > 2)
+	while (m_aArrComFor.size() > 2)
 	{
-		mem_delete(ArrComFor[2]);
-		ArrComFor.erase(2);
+		mem_delete(m_aArrComFor[2]);
+		m_aArrComFor.erase(2);
 	}
 
 
-	mem_delete_a(ArrMeshVertex);
-	mem_delete_a(ArrMeshIndex);
-	CountVertex = 0;
+	mem_delete_a(m_pCurrArrMeshVertex);
+	mem_delete_a(m_pCurrArrMeshIndex);
+	//CountVertex = 0;
 
 	float3 jmin(0, 0, 0), jmax(0, 0, 0);
-	BoundVolume->setMinMax(&jmin,&jmax);
+	m_pBoundVolume->setMinMax(&jmin, &jmax);
 }
 
-void StaticGeom::GetArrBuffsGeom(float3_t*** arr_vertex, int32_t** arr_count_vertex, uint32_t*** arr_index, ID*** arr_mtl, int32_t** arr_count_index, int32_t* count_models)
+void CStaticGeom::getArrBuffsGeom(float3_t*** arr_vertex, int32_t** arr_count_vertex, uint32_t*** arr_index, ID*** arr_mtl, int32_t** arr_count_index, int32_t* count_models)
 {
-	(*count_models) = AllModels.size();
-	(*arr_vertex) = new float3_t*[AllModels.size()];
-	(*arr_index) = new uint32_t*[AllModels.size()];
-	(*arr_mtl) = new ID*[AllModels.size()];
-	(*arr_count_vertex) = new int32_t[AllModels.size()];
-	(*arr_count_index) = new int32_t[AllModels.size()];
+	(*count_models) = m_aAllModels.size();
+	(*arr_vertex) = new float3_t*[m_aAllModels.size()];
+	(*arr_index) = new uint32_t*[m_aAllModels.size()];
+	(*arr_mtl) = new ID*[m_aAllModels.size()];
+	(*arr_count_vertex) = new int32_t[m_aAllModels.size()];
+	(*arr_count_index) = new int32_t[m_aAllModels.size()];
 
 	vertex_static* pData;
 
-	for (long i = 0; i < AllModels.size(); ++i)
+	for (int i = 0; i < m_aAllModels.size(); ++i)
 	{
-		long sizevertex = 0;
-		long sizeindex = 0;
-		for (long k = 0; k < AllModels[i]->SubSet.size(); ++k)
+		int sizevertex = 0;
+		int sizeindex = 0;
+		for (int k = 0; k < m_aAllModels[i]->m_aSubSets.size(); ++k)
 		{
-			sizevertex += AllModels[i]->SubSet[k].VertexCount;
-			sizeindex += AllModels[i]->SubSet[k].IndexCount;
+			sizevertex += m_aAllModels[i]->m_aSubSets[k].m_uiVertexCount;
+			sizeindex += m_aAllModels[i]->m_aSubSets[k].m_uiIndexCount;
 		}
 
 		(*arr_vertex)[i] = new float3_t[sizevertex];
@@ -3159,50 +3166,50 @@ void StaticGeom::GetArrBuffsGeom(float3_t*** arr_vertex, int32_t** arr_count_ver
 		(*arr_count_vertex)[i] = sizevertex;
 		(*arr_count_index)[i] = sizeindex;
 
-		Array<long,1024> tmpbiasindex;
+		Array<int,1024> tmpbiasindex;
 
-		long curr_size_vertex = 0;
-		long tmp_pre_bias = 0;
-		for (long k = 0; k < AllModels[i]->SubSet.size(); ++k)
+		int curr_size_vertex = 0;
+		int tmp_pre_bias = 0;
+		for (int k = 0; k < m_aAllModels[i]->m_aSubSets.size(); ++k)
 		{
-			AllGroups[AllModels[i]->SubSet[k].idgroup]->VertexBuffer[AllModels[i]->SubSet[k].idbuff]->Lock(0, 0, (void**)&pData, 0);
+			m_aAllGroups[m_aAllModels[i]->m_aSubSets[k].m_idGroup]->m_aVertexBuffers[m_aAllModels[i]->m_aSubSets[k].m_idBuff]->Lock(0, 0, (void**)&pData, 0);
 
-			for (long j = 0; j < AllModels[i]->SubSet[k].VertexCount; ++j)
+			for (int j = 0; j < m_aAllModels[i]->m_aSubSets[k].m_uiVertexCount; ++j)
 			{
-				(*arr_vertex)[i][curr_size_vertex] = (float3_t)pData[AllModels[i]->SubSet[k].VertexStart + j].Pos;
+				(*arr_vertex)[i][curr_size_vertex] = (float3_t)pData[m_aAllModels[i]->m_aSubSets[k].m_idVertexStart + j].Pos;
 				++curr_size_vertex;
 			}
 
 			tmpbiasindex[k] = 0;
-			tmpbiasindex[k] = (tmpbiasindex[k] - AllModels[i]->SubSet[k].VertexStart) + tmp_pre_bias;
-			tmp_pre_bias += AllModels[i]->SubSet[k].VertexCount;
+			tmpbiasindex[k] = (tmpbiasindex[k] - m_aAllModels[i]->m_aSubSets[k].m_idVertexStart) + tmp_pre_bias;
+			tmp_pre_bias += m_aAllModels[i]->m_aSubSets[k].m_uiVertexCount;
 
-			AllGroups[AllModels[i]->SubSet[k].idgroup]->VertexBuffer[AllModels[i]->SubSet[k].idbuff]->Unlock();
+			m_aAllGroups[m_aAllModels[i]->m_aSubSets[k].m_idGroup]->m_aVertexBuffers[m_aAllModels[i]->m_aSubSets[k].m_idBuff]->Unlock();
 		}
 
-		Array<Segment*, GEOM_DEFAULT_RESERVE_COM> queue;
-		long tmpcount = 0;
-		queue.push_back(AllModels[i]->ArrSplits);
-		long curr_size_index = 0;
+		Array<CSegment*, GEOM_DEFAULT_RESERVE_COM> queue;
+		int tmpcount = 0;
+		queue.push_back(m_aAllModels[i]->m_pArrSplits);
+		int curr_size_index = 0;
 		while (queue.size())
 		{
-			if (queue[0]->BFNonEnd)
+			if (queue[0]->m_isNonEnd)
 			{
 				for (int i = 0; i<GEOM_COUNT_TYPE_SEGMENTATION_OCTO; ++i)
 				{
-					if (queue[0]->Splits[i])
-						queue.push_back(queue[0]->Splits[i]);
+					if (queue[0]->m_aSplits[i])
+						queue.push_back(queue[0]->m_aSplits[i]);
 				}
 			}
 			else
 			{
-				Segment* split = queue[0];
-				for (long k = 0; k < split->CountSubSet; ++k)
+				CSegment* split = queue[0];
+				for (int k = 0; k < split->m_uiCountSubSet; ++k)
 				{
-					for (long j = 0; j < split->CountPoly[k]*3; ++j)
+					for (int j = 0; j < split->m_pCountPoly[k]*3; ++j)
 					{
-						(*arr_index)[i][curr_size_index] = split->ArrPoly[k][j] + tmpbiasindex[split->NumberGroupModel[k]];
-						(*arr_mtl)[i][curr_size_index] = AllGroups[split->NumberGroup[k]]->idtex;
+						(*arr_index)[i][curr_size_index] = split->m_ppArrPoly[k][j] + tmpbiasindex[split->m_pNumberGroupModel[k]];
+						(*arr_mtl)[i][curr_size_index] = m_aAllGroups[split->m_pNumberGroup[k]]->m_idTexture;
 						++curr_size_index;
 					}
 				}
@@ -3214,63 +3221,63 @@ void StaticGeom::GetArrBuffsGeom(float3_t*** arr_vertex, int32_t** arr_count_ver
 	}
 }
 
-ID StaticGeom::GetModelCountGroups(ID id)
+ID CStaticGeom::getModelCountGroups(ID id)
 {
 	STATIC_PRECOND_ARRCOMFOR_ERR_ID_MODEL(id, -1);
 
-	return AllModels[id]->SubSet.size();
+	return m_aAllModels[id]->m_aSubSets.size();
 }
 
-ID StaticGeom::GetModelGroupIDMat(ID id, ID group)
+ID CStaticGeom::getModelGroupIDMat(ID id, ID group)
 {
 	STATIC_PRECOND_ERR_ID_GROUP(id, group , - 1);
 
-	return AllModels[id]->IDTex[group];
+	return m_aAllModels[id]->m_aIDsTexures[group];
 }
 
-void StaticGeom::GetModelGroupCenter(ID id, ID group, float3_t* center)
+void CStaticGeom::getModelGroupCenter(ID id, ID group, float3_t* center)
 {
 	STATIC_PRECOND_ERR_ID_GROUP(id, group, _VOID);
 
-	*center = AllModels[id]->SubSet[group].Center;
+	*center = m_aAllModels[id]->m_aSubSets[group].m_vCenter;
 }
 
-void StaticGeom::GetModelGroupMin(ID id, ID group, float3_t* min)
+void CStaticGeom::getModelGroupMin(ID id, ID group, float3_t* min)
 {
 	STATIC_PRECOND_ERR_ID_GROUP(id, group, _VOID);
 
-	*min = AllModels[id]->SubSet[group].Min;
+	*min = m_aAllModels[id]->m_aSubSets[group].m_vMin;
 }
 
-void StaticGeom::GetModelGroupMax(ID id, ID group, float3_t* max)
+void CStaticGeom::getModelGroupMax(ID id, ID group, float3_t* max)
 {
 	STATIC_PRECOND_ERR_ID_GROUP(id, group, _VOID);
 
-	*max = AllModels[id]->SubSet[group].Max;
+	*max = m_aAllModels[id]->m_aSubSets[group].m_vMax;
 }
 
-void StaticGeom::GetModelGroupPlane(ID id, ID group, D3DXPLANE* plane)
+void CStaticGeom::getModelGroupPlane(ID id, ID group, D3DXPLANE* plane)
 {
 	STATIC_PRECOND_ERR_ID_GROUP(id, group, _VOID);
 
-	*plane = AllModels[id]->SubSet[group].Plane;
+	*plane = m_aAllModels[id]->m_aSubSets[group].m_oPlane;
 }
 
-void StaticGeom::GetPartBeam(float3* pos, float3 * dir, Segment** arrsplits, DWORD *count, Segment* comsegment, ID curr_splits_ids_render)
+void CStaticGeom::getPartBeam(const float3* pos, const float3 * dir, CSegment** arrsplits, int *count, CSegment* comsegment, ID curr_splits_ids_render)
 {
 	float3 center;
 	float radius;
-	comsegment->BoundVolumeP->getSphere(&center, &radius);
+	comsegment->m_pBoundVolumeP->getSphere(&center, &radius);
 
 	float distsqr = SGCore_0DistancePointBeam2(center, *pos, *dir);
-	if (comsegment->CountAllPoly > 0 && distsqr <= radius*radius)
+	if (comsegment->m_uiCountAllPoly > 0 && distsqr <= radius*radius)
 	{
-		if (comsegment->BFNonEnd)
+		if (comsegment->m_isNonEnd)
 		{
 			for (int j = 0; j<GEOM_COUNT_TYPE_SEGMENTATION_OCTO; ++j)
 			{
-				if (comsegment->Splits[j])
-					GetPartBeam(pos, dir, arrsplits, count, comsegment->Splits[j], curr_splits_ids_render);
+				if (comsegment->m_aSplits[j])
+					getPartBeam(pos, dir, arrsplits, count, comsegment->m_aSplits[j], curr_splits_ids_render);
 			}
 		}
 		else
@@ -3285,9 +3292,9 @@ void StaticGeom::GetPartBeam(float3* pos, float3 * dir, Segment** arrsplits, DWO
 	}
 }
 
-bool StaticGeom::TraceBeam(float3* start, float3* dir, float3* _res, ID* idmodel, ID* idmtl)
+bool CStaticGeom::traceBeam(const float3* start, const float3* dir, float3* _res, ID* idmodel, ID* idmtl)
 {
-	if (AllModels.size() <= 0)
+	if (m_aAllModels.size() <= 0)
 		return false;
 
 	SXTriangle tmptri;
@@ -3300,28 +3307,28 @@ bool StaticGeom::TraceBeam(float3* start, float3* dir, float3* _res, ID* idmodel
 	il = (*dir) * 10000.0f;
 	bool found = false;
 
-	for (int id = 0; id < AllModels.size(); ++id)
+	for (int id = 0; id < m_aAllModels.size(); ++id)
 	{
-		ArrComFor[1]->arr[id]->CountCom = 0;
+		m_aArrComFor[1]->m_aIRS[id]->m_iCountCom = 0;
 
-		GetPartBeam(start, dir, ArrComFor[1]->arr[id]->Arr, &(ArrComFor[1]->arr[id]->CountCom), AllModels[id]->ArrSplits, ArrComFor[1]->arr[id]->Count);
+		getPartBeam(start, dir, m_aArrComFor[1]->m_aIRS[id]->m_ppSegments, &(m_aArrComFor[1]->m_aIRS[id]->m_iCountCom), m_aAllModels[id]->m_pArrSplits, m_aArrComFor[1]->m_aIRS[id]->m_iCount);
 
-		for (DWORD k = 0; k<ArrComFor[1]->arr[id]->CountCom; ++k)
+		for (DWORD k = 0; k<m_aArrComFor[1]->m_aIRS[id]->m_iCountCom; ++k)
 		{
-			for (DWORD group = 0; group<ArrComFor[1]->arr[id]->Arr[k]->CountSubSet; group++)
+			for (DWORD group = 0; group<m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_uiCountSubSet; group++)
 			{
-				ID idbuff = AllModels[id]->SubSet[ArrComFor[1]->arr[id]->Arr[k]->NumberGroupModel[group]].idbuff;
-				ID idgroup = ArrComFor[1]->arr[id]->Arr[k]->NumberGroup[group];
+				ID idbuff = m_aAllModels[id]->m_aSubSets[m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_pNumberGroupModel[group]].m_idBuff;
+				ID idgroup = m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_pNumberGroup[group];
 
 				vertex_static* pData = 0;
-				if (FAILED(AllGroups[idgroup]->VertexBuffer[idbuff]->Lock(0, 0, (void**)&pData, 0)))
+				if (FAILED(m_aAllGroups[idgroup]->m_aVertexBuffers[idbuff]->Lock(0, 0, (void**)&pData, 0)))
 					continue;
 
-				for (DWORD numpoly = 0; numpoly<ArrComFor[1]->arr[id]->Arr[k]->CountPoly[group] * 3; numpoly += 3)
+				for (DWORD numpoly = 0; numpoly<m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_pCountPoly[group] * 3; numpoly += 3)
 				{
-					tmptri.a = pData[ArrComFor[1]->arr[id]->Arr[k]->ArrPoly[group][numpoly]].Pos;
-					tmptri.b = pData[ArrComFor[1]->arr[id]->Arr[k]->ArrPoly[group][numpoly + 1]].Pos;
-					tmptri.c = pData[ArrComFor[1]->arr[id]->Arr[k]->ArrPoly[group][numpoly + 2]].Pos;
+					tmptri.a = pData[m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly]].Pos;
+					tmptri.b = pData[m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly + 1]].Pos;
+					tmptri.c = pData[m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly + 2]].Pos;
 
 					if (tmptri.IntersectLine((*start), il, &ip))
 					{
@@ -3334,12 +3341,12 @@ bool StaticGeom::TraceBeam(float3* start, float3* dir, float3* _res, ID* idmodel
 								*idmodel = id;
 
 							if (idmtl)
-								*idmtl = AllGroups[idgroup]->idtex;
+								*idmtl = m_aAllGroups[idgroup]->m_idTexture;
 						}
 					}
 				}
 
-				AllGroups[idgroup]->VertexBuffer[idbuff]->Unlock();
+				m_aAllGroups[idgroup]->m_aVertexBuffers[idbuff]->Unlock();
 			}
 		}
 	}
diff --git a/source/geom/static_geom.h b/source/geom/static_geom.h
index a4c1acbc3c3ea4380a4498e794d841210b9f43ca..a6c4d21a006c1b96c635bb82bbab0ce4efa8369a 100644
--- a/source/geom/static_geom.h
+++ b/source/geom/static_geom.h
@@ -12,308 +12,532 @@ See the license in LICENSE
 #include <gcore/sxgcore.h>
 #include "sxgeom.h"
 
+//##########################################################################
+
 #define STATIC_PRECOND_ARRCOMFOR_ERR_ID(id_arr) \
-if (!(id_arr < ArrComFor.size()))\
+if (!(id_arr < m_aArrComFor.size()))\
 {\
 	LibReport(REPORT_MSG_LEVEL_ERROR, "%s - static: unresolved id '%d' for array of compute visible", GEN_MSG_LOCATION, id_arr); \
 }
 
 #define STATIC_PRECOND_ARRCOMFOR_ERR_ID_MODEL(id_model, retval) \
-if (!(id_model < AllModels.size() && AllModels[id_model]))\
+if (!(id_model < m_aAllModels.size() && m_aAllModels[id_model]))\
 {\
 	LibReport(REPORT_MSG_LEVEL_ERROR, "%s - static: unresolved id '%d' for array of models", GEN_MSG_LOCATION, id_model); \
 	return retval;\
 }
 
 #define STATIC_PRECOND_ERR_ID_GROUP(id_model,id_group, ret_val) \
-if (!(id_model < AllModels.size() && AllModels[id_model] && id_group < AllModels[id_model]->SubSet.size()))\
+if (!(id_model < m_aAllModels.size() && m_aAllModels[id_model] && id_group < m_aAllModels[id_model]->m_aSubSets.size()))\
 {\
 	LibReport(REPORT_MSG_LEVEL_ERROR, "%s - static: unresolved id '%d' for array of group in model '%d'", GEN_MSG_LOCATION, id_group, id_model); \
 	return ret_val; \
 }
 
-//типы деления
+//##########################################################################
+
+/*! \name Типы деления
+@{*/
+
+//! квадро деление
 #define GEOM_COUNT_TYPE_SEGMENTATION_QUAD 4
+
+//! октоделение
 #define GEOM_COUNT_TYPE_SEGMENTATION_OCTO 8
-#define GEOM_DEFAULT_RESERVE_COM 512	/* резервация для просчетов */
 
-class StaticGeom
+//! резервное количество элементов для массива просчетов 
+#define GEOM_DEFAULT_RESERVE_COM 512	
+
+//!@}
+
+//**************************************************************************
+
+/*! Экстремумы Y координаты уровня
+@{*/
+
+//! минимальное значение по оси Y
+const D3DXVECTOR3 gс_vYmin = D3DXVECTOR3(0.0f, -1000.0f, 0.0f);
+
+//! максимальное значение по оси Y
+const D3DXVECTOR3 gс_vYmax = D3DXVECTOR3(0.0f, 1000.0f, 0.0f);
+
+//!@}
+
+//##########################################################################
+
+//! вся геометрия уровня
+class CStaticGeom
 {
 public:
 
-	static bool UseSortFrontToBackSplits;
-	static bool UseSortFrontToBackModels;
-	static IDirect3DDevice9* DXDevice;
-	static float DistForLod;
+	//! сортировать ли сплиты от ближнего к дальнему
+	static bool m_isUseSortFrontToBackSplits;
+
+
+	//static bool m_isUseSortFrontToBackModels;
+
+	//! direct3d device
+	static IDirect3DDevice9 *m_pDXDevice;
+
+	//! дистанция после которой будет рисоваться лод
+	static float m_fDistForLod;
 
-	StaticGeom();
-	~StaticGeom();
+	//**********************************************************************
+
+	CStaticGeom();
+	~CStaticGeom();
 
 	SX_ALIGNED_OP_MEM
+
+	//**********************************************************************
 	
-	//сегмент, кусок модели
-	struct Segment
+	//! сегмент, кусок модели
+	struct CSegment
 	{
-		Segment();
-		~Segment();
+		CSegment();
+		~CSegment();
+
+		//! массив из 4/8 частей данного участка
+		CSegment* m_aSplits[GEOM_COUNT_TYPE_SEGMENTATION_OCTO]; 
+
+		//! двумерный массив по количеству подгрупп, вложенный массив - все полигоны для данной подгруппы
+		uint32_t **m_ppArrPoly;	
+
+		//! массив с количеством полигонов на каждую подгруппу
+		uint32_t *m_pCountPoly;	
+
+		//! массив с номерами подгрупп в контексте уровня
+		uint32_t *m_pNumberGroup;	
+
+		//! массив с номерами подгрупп в контексте модели
+		uint32_t *m_pNumberGroupModel;
+
+		//! количество подгрупп
+		uint32_t m_uiCountSubSet;	
 
-		Segment* Splits[GEOM_COUNT_TYPE_SEGMENTATION_OCTO]; //массив из 4/8 частей данного участка
+		//! общее количество полигонов
+		uint32_t m_uiCountAllPoly;	
 
-		//для геометрии
-		uint32_t** ArrPoly;	//двумерный массив по количеству подгрупп, вложенный массив - все полигоны для данной подгруппы
-		uint32_t* CountPoly;	//массив с количеством полигонов на каждую подгруппу
-		uint32_t* NumberGroup;	//массив с номерами подгрупп в контексте уровня
-		uint32_t* NumberGroupModel;//массив с номерами подгрупп в контексте модели
-		uint32_t CountSubSet;	//количество подгрупп
-		uint32_t CountAllPoly;	//общее количество полигонов
 
-		ISXBound* BoundVolumeSys;	//выравненный ограничивающий объем для равномерного деления
-		ISXBound* BoundVolumeP;		//облегающий ограничивающий объем
+		//! выравненный ограничивающий объем для равномерного деления
+		ISXBound *m_pBoundVolumeSys;	
 
-		float DistForCamera;
+		//! облегающий ограничивающий объем
+		ISXBound *m_pBoundVolumeP;		
 
-		DWORD ID;	//идентификатор куска
-		DWORD SID;	//порядковый номер куска из массива рисующихся кусков
+		//! текущее расстояние до камеры (для определения когда рисовать лод)
+		float m_fDistForCamera;
+
+		//! идентификатор куска
+		ID m_ID;	
+
+		//! порядковый номер куска из массива рисующихся кусков
+		ID m_SID;	
+
+		//! имеет ли кусок куски внутри себя?
+		bool m_isNonEnd;
 
 		//ID3DXMesh* BoundBox;	//ограничивающий параллелепипед (меш)
-		bool BFNonEnd;//имеет ли кусок куски внутри себя?
 	};
 
-	
+	//**********************************************************************
 
-	//модель, главный юнит уровня
-	struct Model
+	//! модель, главный юнит уровня
+	struct CModel
 	{
-		Model();
-		~Model();
+		CModel();
+		~CModel();
 
 		SX_ALIGNED_OP_MEM
 
-		struct Lod
+		/*! Лод - низкополигональная модель, которая рисуется вместо оригинальной модели когда игрок на достаточном удалении от модели
+		 \warning Все материалы должны быть одного сорта!!!
+		*/
+		struct CLod
 		{
-			Lod();
-			~Lod();
-
-			int SortGroup;
-			char PathName[1024];
-			ISXDataStaticModel* model;
-			Array<ID> IDsTexs;
-			ISXBound* BoundVolume;
+			CLod();
+			~CLod();
+
+			//! сорт материала, принимается только один сорт, последней текстуры
+			int m_iSortGroup;
+
+			//! путь до модели лода в папке статиечской геометрии
+			char m_szPathName[1024];
+
+			//! указатель на объект ISXDataStaticModel
+			ISXDataStaticModel *m_pModel;
+
+			//! массив идентификаторов текстур, все текстуры должны быть одного сорта
+			Array<ID> m_aIDsTextures;
+
+			//! ограничивающий объем лода
+			ISXBound *m_pBoundVolume;
 		};
 
-		struct GDataBuff
+		//******************************************************************
+
+		/*! подгруппа модели */
+		struct CSubSet
 		{
-			int32_t idgroup;//id подгруппы в контексте уровня
-			int32_t idbuff;	//id буфера (в подгруппе) в который заисаны данные геометрии модели
-			int32_t IndexStart;
-			int32_t IndexCount;
-			int32_t VertexStart;
-			int32_t VertexCount;
-
-			D3DXPLANE Plane;
-			float3_t Max;
-			float3_t Min;
-			float3_t Center;
+			//! id подгруппы в контексте уровня
+			int32_t m_idGroup;
+
+			//! id буфера (в подгруппе) в который записаны данные геометрии модели
+			int32_t m_idBuff;
+
+			//! id стартового индекса подгруппы
+			int32_t m_idIndexStart;
+
+			//! количество индексов в подгруппе
+			int32_t m_uiIndexCount;
+
+			//! id стартовой вершины подгруппы
+			int32_t m_idVertexStart;
+
+			//! количество вершин в подгруппе
+			int32_t m_uiVertexCount;
+
+
+			//! плоскость подгруппы
+			D3DXPLANE m_oPlane;
+
+			//! максимум подгруппы
+			float3_t m_vMax;
+
+			//! минимум подгруппы
+			float3_t m_vMin;
+
+			//! центр подгруппы
+			float3_t m_vCenter;
 		};
 
+		//******************************************************************
 		
-		float3 Position;
-		float3 Rotation;
-		float3 Scale;
+		//! позиция модели
+		float3 m_vPosition;
+
+		//! повороты модели в радианах
+		float3 m_vRotation;
+
+		//! масштаб модели
+		float3 m_vScale;
+
 
-		float3 OldPosition;
-		float3 OldRotation;
-		float3 OldScale;
+		//! предыдущая позиция модели
+		float3 m_vOldPosition;
 
-		char Name[64];
-		char PathName[1024];
-		int32_t CountPoly;
+		//! предыдущие повороты модели в радианах
+		float3 m_vOldRotation;
 
-		Lod Lod0;
+		//! предыдущий масштаб модели
+		float3 m_vOldScale;
 
-		bool IsRenderLod;
 
-		Array<GDataBuff> SubSet;	//описание каждой подгруппы модели
-		Array<float> GroupDist;
-		Array<ID> IDTex;
-		Segment* ArrSplits;	//массив с сегментами	
-		ID SplitsIDs;	//общее количество сегментов/спилтов
-		ID SplitsIDsRender;	//количество рисубщихся сегментов
+		//! имя модели
+		char m_szName[64];
+
+		//! путь до модели
+		char m_szPathName[1024];
+
+		//! количество полигонов
+		int32_t m_uiCountPoly;
+
+		//! лод модели
+		CLod m_oLod0;
+
+		//! рисовать ил в данный момент лод или целую модель?
+		bool m_isRenderLod;
+
+
+		//! описание каждой подгруппы модели
+		Array<CSubSet> m_aSubSets;
+
+		Array<float> m_aGroupDist;
+
+		//! массив идентификаторов текстур для каждой подгруппы
+		Array<ID> m_aIDsTexures;
+
+		//! массив с сегментами
+		CSegment *m_pArrSplits;	
+
+		//! общее количество сегментов/спилтов
+		ID m_idCountSplits;	
+
+		//! количество рисующихся сегментов
+		ID m_idCountSplitsRender;	
 	};
 
+	//**********************************************************************
 
-	//подгруппа уровня
-	struct Group
+	/*! подгруппа статической геометрии уровня
+	 \note Подгруппа внутри имеет массив, в каждом из которых не более GEOM_MAX_POLY_IN_GROUP полигонов, поэтому можно шибко не беспокоится о количестве полигонов для конкретной подгруппы
+	*/
+	struct CGroup
 	{
-		Group();
-		~Group();
+		CGroup();
+		~CGroup();
 
-		/*struct VertexBuff
-		{
-			VertexBuff();
-			~VertexBuff();
-
-			float3_t* arr;
-			long count;
-		};*/
-
-		bool IsRenderSingly;
-		int SortGroup;//тип/вид/сорт подгруппы, для ранжирования рендера
-		String name;//имя текстуры
-		ID idtex;	//идентификатор текстуры
-		long AllCountVertex;	//общее количество вершин
-		long AllCountIndex;		//общее количество индексов
-		Array<int32_t, 4> CountVertex;	//количество вершин в буферах
-		Array<int32_t, 4> CountIndex;	//количество индексов в буферах
-		Array<Array<Model*>> ArrModels;
-		Array<IDirect3DVertexBuffer9*, 4> VertexBuffer;
-		//Array<VertexBuff*, 4> VertexBufferOrigin;
+		//! рисовать ли полигоны этой подгруппы отдельно для каждой модели? это может понадобится к примеру для полупрозрачных материалов
+		bool m_isRenderSingly;
+
+		//! тип/вид/сорт подгруппы, для ранжирования рендера
+		int m_iSortGroup;
+
+		//! имя текстуры
+		String m_sName;
+
+		//! идентификатор текстуры
+		ID m_idTexture;	
+
+		//! общее количество вершин
+		int m_iCountVertex;	
+
+		//! общее количество индексов
+		int m_iCountIndex;		
+
+		//! количество вершин в буферах
+		Array<int32_t, 4> m_aCountVertex;	
+
+		//! количество индексов в буферах
+		Array<int32_t, 4> m_aCountIndex;	
+
+		//! массив массивов моделей в текущей подгруппе, в каждом элементе массива не более GEOM_MAX_POLY_IN_GROUP полигонов
+		Array<Array<CModel*>> m_aModels;
+
+		//! массив буферов вершин
+		Array<IDirect3DVertexBuffer9*, 4> m_aVertexBuffers;
 	};
 
-	//структура содержащая минимальную необходимую информацию о сегменте модели
-	struct InfoRenderSegments
+	//**********************************************************************
+
+	//! структура содержащая минимальную необходимую информацию о сегменте модели для рендера
+	struct CInfoRenderSegments
 	{
-		InfoRenderSegments();
-		~InfoRenderSegments();
-		Segment** Arr;	//массив хранящий в себе указатели на сегменты REALTIME
-		DWORD Count;	//размер Arr 
-		DWORD CountCom;	//сколько сегментов записано в Arr	REALTIME
+		CInfoRenderSegments();
+		~CInfoRenderSegments();
+
+		//! массив хранящий в себе указатели на сегменты REALTIME
+		CSegment **m_ppSegments;
+
+		//! размер m_ppSegments 
+		int m_iCount;
+
+		//! сколько сегментов записано в m_ppSegments REALTIME
+		int m_iCountCom;	
 	};
 
-	struct IRSData
+	//**********************************************************************
+
+	//! данные для просчетов видимости
+	struct CIRSData
 	{
-		IRSData();
-		~IRSData();
-		Array<Segment*, GEOM_DEFAULT_RESERVE_COM> queue;
-		Array<InfoRenderSegments*> arr;
+		CIRSData();
+		~CIRSData();
+
+		//! очередь обработки просчетов видимости для каждого сегмента
+		Array<CSegment*, GEOM_DEFAULT_RESERVE_COM> m_aQueue;
+
+		//! массив информации для рендера сегментов
+		Array<CInfoRenderSegments*> m_aIRS;
 	};
 
-	void OnLostDevice();
-	void OnResetDevice();
+	//######################################################################
 
-	void Clear();
-	void Save(const char* path);
-	void Load(const char* path);
+	void onLostDevice();
+	void onResetDevice();
 
-	void SortGroup(float3* viewpos, int sort_mtl);
+	void clear();
+	void save(const char *szPath);
+	void load(const char *szPath);
+
+	void sortGroup(const float3 *pViewPos, int iSortMtl);
 	
-	long GetCountModel();
+	int getCountModel();
 
-	void CPUFillingArrIndeces(const ISXFrustum* frustum, float3* viewpos, ID id_arr = 0);
-	bool GetIntersectedRayY(float3* pos);
+	void comArrIndeces(const ISXFrustum *pFrustum, const float3 *pViewPos, ID idArr = 0);
+	bool getIntersectedRayY(float3 *pPos);
 
-	bool SortExistsForRender(int sort, ID id_arr = 0);
+	bool sortExistsForRender(int iSortMtl, ID idArr = 0);
 	
-	void GPURender(DWORD timeDelta, int sort_mtl, ID id_arr = 0, ID exclude_model_id = -1, ID exclude_group_id = -1, bool is_sorted = false);
-	void GPURenderSingly(DWORD timeDelta, ID id, ID id_tex);
-	ID AddModel(const char* path, const char* lod1, const char* name);
-	void DelModel(ID id);
-
-	void GetMinMax(float3* min,float3* max);
-
-	ID AddArrForCom();
-	bool existsArrForCom(ID id);
-	void DelArrForCom(ID id_arr);
-
-	char* GetModelName(ID id);
-	const char* GetModelPathName(ID id);
-	long GetModelCountPoly(ID id);
-	void GetModelMinMax(ID id, float3* min, float3* max);
-
-	float3* GetModelPosition(ID id);
-	float3* GetModelRotation(ID id);
-	float3* GetModelScale(ID id);
-
-	const char* GetModelLodPath(ID id);
-	void SetModelLodPath(ID id, const char* path);
-
-	void ApplyTransform(ID id);
-
-	ID GetModelCountGroups(ID id);
-	ID GetModelGroupIDMat(ID id, ID group);
-	void GetModelGroupCenter(ID id, ID group, float3_t* center);
-	void GetModelGroupMin(ID id, ID group, float3_t* min);
-	void GetModelGroupMax(ID id, ID group, float3_t* max);
-	void GetModelGroupPlane(ID id, ID group, D3DXPLANE* plane);
-
-	void GetArrBuffsGeom(float3_t*** arr_vertex, int32_t** arr_count_vertex, uint32_t*** arr_index, ID*** arr_mtl, int32_t** arr_count_index, int32_t* count_models);
-	/*
-	(*arr_vertex)[num_model][num_vertex] - вершины модели
-	(*arr_count_vertex)[num_model] - количество вершин для модели
-	(*arr_index)[num_model][num_vertex] - индексы модели
-	(*arr_mtl)[num_model][num_vertex] - материал для индекса
-	(*arr_count_index)[num_model] - количество индексов для модели
-	(*count_model); количество моделей
-	*/
+	void render(DWORD timeDelta, int iSortMtl, ID idArr = 0, ID idExcludeModel = -1, ID isExcludeGroup = -1, bool isSorted = false);
+	void renderSingly(DWORD timeDelta, ID idModel, ID idTexture);
+	ID addModel(const char *szPath, const char *szLod1, const char *szName);
+	void deleteModel(ID idModel);
 
-	
-	bool TraceBeam(float3* start, float3* dir, float3* _res, ID* idmodel, ID* idmtl);
+	void getMinMax(float3 *pMin, float3 *pMax);
+
+	ID addArrForCom();
+	bool existsArrForCom(ID idArr);
+	void deleteArrForCom(ID idArr);
+
+	char* getModelName(ID idModel);
+	const char* getModelPathName(ID idModel);
+	int getModelCountPoly(ID idModel);
+	void getModelMinMax(ID idModel, float3 *pMin, float3 *pMax);
+
+	float3* getModelPosition(ID idModel);
+	float3* getModelRotation(ID idModel);
+	float3* getModelScale(ID idModel);
+
+	const char* getModelLodPath(ID idModel);
+	void setModelLodPath(ID idModel, const char *szPath);
+
+	void applyTransform(ID idModel);
+
+	ID getModelCountGroups(ID idModel);
+	ID getModelGroupIDMat(ID idModel, ID idGroup);
+	void getModelGroupCenter(ID idModel, ID idGroup, float3_t *pCenter);
+	void getModelGroupMin(ID idModel, ID idGroup, float3_t *pMin);
+	void getModelGroupMax(ID idModel, ID idGroup, float3_t *pMax);
+	void getModelGroupPlane(ID idModel, ID idGroup, D3DXPLANE *pPlane);
+
+	void getArrBuffsGeom(
+		float3_t ***pppArrVertex,	//!< (*arr_vertex)[num_model][num_vertex] - вершины модели
+		int32_t	**ppArrCountVertex, //!< (*arr_count_vertex)[num_model] - количество вершин для модели
+		uint32_t ***pppArrIndex,	//!< (*arr_index)[num_model][num_vertex] - индексы модели
+		ID ***pppArrMtl,			//!< (*arr_mtl)[num_model][num_vertex] - материал для индекса
+		int32_t **ppArrCountIndex,	//!< (*arr_count_index)[num_model] - количество индексов для модели
+		int32_t *pCountModels		//!< (*count_model); количество моделей
+		);
+
+	bool traceBeam(const float3 *pStart, const float3 *Dir, float3 *pResult, ID *pIDmodel, ID *pIDmtl);
 
 protected:
 
-	struct InfoGroup
+	//! структура для сортировки моделей и их подгрупп по дальности от камеры
+	struct CInfoGroup
 	{
-		ID model;
-		ID group;
-		ID g_group;
-		float dist;
-		int count;
+		//! id модели
+		ID m_idModel;
+
+		//! id подгруппы модели
+		ID m_idGroup;
+
+		//! id подгруппы модели в контексте уровня
+		ID m_idGlobalGroup;
+
+		//! дистанция до наблюдателя
+		float m_fDist;
+
+		//int m_iCount;
 	};
-	Array<InfoGroup*> DistGroup;
-	Array<IRSData*> ArrComFor; //информация о сегментах для рендера
-	void AddModelInArrCom(ID id_model);
-	void DelModelInArrCom(ID id_model);
 
-	float4x4 WorldMat;
-	float4x4 RotationMat;
-	void ApplyTransformLod(ID id);
+	//! массив для сортировки подгрупп по дальности (для рендера полупрозрачных поверхностей)
+	Array<CInfoGroup*> m_aDistGroup;
+
+	//*********************************************************************
+
+	//! информация о сегментах для рендера
+	Array<CIRSData*> m_aArrComFor; 
 
-	ISXBound* BoundVolume;
+	//! добавляет данные о модели к данным для рендера
+	void addModelInArrCom(ID idModel);
 
-	void GetPartBeam(float3* pos, float3 * dir, Segment** arrsplits, DWORD *count, Segment* comsegment, ID curr_splits_ids_render);
+	//! удаляет данные о модели из данных о рендере
+	void deleteModelInArrCom(ID idModel);
 
-	void GetIntersectedRayY2(float3* pos, Segment** arrsplits, DWORD *count, Segment* comsegment, ID curr_splits_ids_render);
+	//**********************************************************************
 
-	void SaveSplit(Segment* Split, FILE* file, Array<Segment*> * queue);
-	void LoadSplit(Segment** Split, FILE* file, Array<Segment**> * queue);
+	//! мировая матрица трансформаций
+	float4x4 m_mWorld;
+
+	//! матрица трансформации поворотов (для нормалей)
+	float4x4 m_mRotation;
+
+	//! применяет трансформации для лода модели
+	void applyTransformLod(ID id);
+
+	//**********************************************************************
+
+	//! ограничивающий объем всего уровня
+	ISXBound *m_pBoundVolume;
+
+	//**********************************************************************
+
+	//! сохраняет сплит в файл
+	void saveSplit(CSegment *pSplit, FILE *pFile, Array<CSegment*> *pQueue);
+
+	//! читает сплит из файла
+	void loadSplit(CSegment **ppSplit, FILE *pFile, Array<CSegment**> *pQueue);
+
+	//**********************************************************************
+
+	void getPartBeam(const float3 *pPos, const float3 *pDir, CSegment **ppSplits, int *iCount, CSegment *pSegment, ID idCurrSplitRender);
+
+	void getIntersectedRayY2(float3 *pPos, CSegment **ppSplits, int *iCount, CSegment *pSegment, ID idCurrSplitRender);
+
+	void comRecArrIndeces(const ISXFrustum *pFrustum, CSegment **ppSplits, int *iCount, CSegment *pSegment, const float3 *pViewPos, Array<CSegment*, GEOM_DEFAULT_RESERVE_COM> *pQueue, ID idCurrSplitRender);
+
+	//*************************************************************************
+
+	//! подготовительный этап сегментации
+	void preSegmentation(CModel *pMesh, ISXDataStaticModel *pModel);	
+
+	//! сегментации модели
+	void segmentation(CSegment *pSplit, CModel *pMesh, ISXDataStaticModel *pModel, int iCountSplitsSys, int iCountPolyInSegment, Array<CSegment*> *pQueue);
+
+	//! рекусривный вызов сегментации
+	void cycleSegmentation(CSegment *pSplit, CModel *pMesh, ISXDataStaticModel *pModel, int iCountSplitsSys, int iCountPolyInSegment);
+
+	//! устанавливает m_pBoundVolumeP сплита так чтобы он полностью облегал сплит
+	void editVolume(CModel *pMesh, CSegment *pSplit);
+
+	//! установка каждому куску идентификатора, удаление пустых кусков
+	void setSplitID(CSegment *pSplit, ID * SplitsIDs, ID * SplitsIDsRender);
+
+	//**********************************************************************
+
+	/*! Данные текущей загружаемой модели
+	@{*/
+
+	//! массив вершин текущей модели
+	float3 *m_pCurrArrMeshVertex;
+
+	//! массив индексов текущей модели
+	UINT *m_pCurrArrMeshIndex;
+
+	//!@}
+
+	//**********************************************************************
+
+	//! массив моделей
+	Array<CModel*> m_aAllModels;
+
+	//! массив подгрупп
+	Array<CGroup*> m_aAllGroups;
+
+	//**********************************************************************
+
+	/*! real-time данные для рендера моделей
+	@{*/
+
+	//! создает основные массивы
+	void initArrIndexPtr();
+
+	//! удаляет все основные массивы
+	void deleteArrIndexPtr();
+	
 
-	void PreSegmentation(Model* mesh, ISXDataStaticModel* model);	//подготовительный этап сегментации
-	void Segmentation(Segment* Split, Model* mesh, ISXDataStaticModel* model, long CountSplitsSys, long CountPolyInSegment, Array<Segment*> * queue);	//сегментации модели
-	void CycleSegmentation(Segment* Split, Model* mesh, ISXDataStaticModel* model, long CountSplitsSys, long CountPolyInSegment);	//рекусривный вызов сегментации
-	void EditVolume(Model* mesh, Segment* Split);
-	void SetSplitID(Segment* Split, ID* SplitsIDs, ID* SplitsIDsRender);	//установка каждому куску идентификатора, удаление пустых кусков
-	void SetSplitID2(Segment* Split, ID* SplitsIDs, ID* SplitsIDsRender, Array<Segment*>* queue);
-	void ComRecArrIndeces(const ISXFrustum* frustum, Segment** arrsplits, DWORD *count, Segment* comsegment, float3* viewpos, Array<Segment*, GEOM_DEFAULT_RESERVE_COM>* queue, ID curr_splits_ids_render);
+	//! массив для хранения всех индексов которые будут отправлены на рендер сейчас
+	uint32_t ***m_pppRTArrIndices;	
 
-	//рабочие данные, используются внутри в методах
-	//{{
-	float3* ArrMeshVertex;
-	UINT* ArrMeshIndex;
-	long CountVertex;
+	//! массив для хранения размеров для каждого из массивов RTCPUArrIndicesPtrs
+	uint32_t **m_ppRTCountDrawPoly;
 
-	D3DXVECTOR3 jpos;
-	D3DXVECTOR3 jvevyp;
-	D3DXVECTOR3 jvevyn;
-	float3 jvec0, jvec1, jvec2;
+	//! массив для хранения количества рисуемых полигонов для каждой подгруппы для каждой модели
+	uint32_t ***m_pppRTCountDrawPolyModel;
 
-	//}}
+	//! массив для хранения начала индексов для каждой подгруппы для каждой модели
+	uint32_t ***m_pppRTBeginIndexModel;
 
-	//функции удаления и создания массивов RTCPUArrIndicesPtrs и RTCountDrawPoly
-	//при добавлении новой модели
-	void DelArrIndexPtr();
-	void InitArrIndexPtr();
 
-	uint32_t*** RTCPUArrIndicesPtrs;	//массив для хранения всех индексов которые будут отправлены на рендер сейчас
-	uint32_t** RTCountDrawPoly;			//массив для хранения размеров для каждого из массивов RTCPUArrIndicesPtrs
-	uint32_t*** RTCountDrawPolyModel;	//массив для хранения количества рисуемых полигонов для каждой подгруппы для каждой модели
-	uint32_t*** RTBeginIndexModel;		//массив для хранения начала индексов для каждой подгруппы для каждой модели
+	//! размер в элементах m_pRenderIndexBuffer
+	int m_iSizeRenderIndexBuffer;	
 
-	Array<Model*> AllModels;	//массив моделей
-	Array<Group*> AllGroups;	//массив подгрупп
-	//IDirect3DVertexDeclaration9* VertexDeclarationStatic;
+	//! индексный буфер, используется и изменяется в реайлтайме при рендере уровня, имеет размер самого большого индексного буфера из всех подгрупп моделей, создается в момент загрузки моделей
+	IDirect3DIndexBuffer9* m_pRenderIndexBuffer;
 
-	long SizeRenderIndexBuffer;	//размер в элементах RenderIndexBuffer
-	IDirect3DIndexBuffer9* RenderIndexBuffer;	//индексный буфер, используется и изменяется в реайлтайме при рендере уровня	
+	//!@}
 };
 
 #endif
diff --git a/source/geom/sxgeom.cpp b/source/geom/sxgeom.cpp
index 72a2facd12ad736617d1913646a448a7a79ff267..3e7b1551a544f5bd66aff962d5193fea4f636c1b 100644
--- a/source/geom/sxgeom.cpp
+++ b/source/geom/sxgeom.cpp
@@ -11,26 +11,28 @@ See the license in LICENSE
 #include "static_geom.h"
 #include "green.h"
 
-bool StaticGeom::UseSortFrontToBackSplits = true;
-bool StaticGeom::UseSortFrontToBackModels = true;
-IDirect3DDevice9* StaticGeom::DXDevice = 0;
-float StaticGeom::DistForLod = 200.f;
+//##########################################################################
+
+bool CStaticGeom::m_isUseSortFrontToBackSplits = true;
+//bool CStaticGeom::m_isUseSortFrontToBackModels = true;
+IDirect3DDevice9* CStaticGeom::m_pDXDevice = 0;
+float CStaticGeom::m_fDistForLod = 200.f;
 
-int Green::CurrentFreqGrass = 100;
-float2_t Green::DistLods = float2_t(50, 100);
-float Green::BeginEndLessening = 30;
-bool Green::UseSortFrontToBackSplits = false;
-IDirect3DDevice9* Green::DXDevice = 0;
+int CGreen::m_iRenderFreqGrass = 100;
+float2_t CGreen::m_vDistLods = float2_t(50, 100);
+float CGreen::m_fDistGrassLessening = 30;
+bool CGreen::m_isUseSortFrontToBackSplits = false;
+IDirect3DDevice9* CGreen::m_pDXDevice = 0;
 
 #if !defined(DEF_STD_REPORT)
 #define DEF_STD_REPORT
 report_func g_fnReportf = DefReport;
 #endif
 
-StaticGeom* GeometryObj = 0;
-Green* GreenObj = 0;
+CStaticGeom *g_pGeometry = 0;
+CGreen *g_pGreen = 0;
 
-#define GEOM_PRECOND(retval) if(!GeometryObj || !GreenObj){LibReport(REPORT_MSG_LEVEL_ERROR, "%s - sxgeom is not init", GEN_MSG_LOCATION); return retval;}
+#define GEOM_PRECOND(retval) if(!g_pGeometry || !g_pGreen){LibReport(REPORT_MSG_LEVEL_ERROR, "%s - sxgeom is not init", GEN_MSG_LOCATION); return retval;}
 
 //##########################################################################
 
@@ -58,18 +60,18 @@ SX_LIB_API void SGeom_0Create(const char *szName, bool isUnic)
 			}
 			else
 			{
-				StaticGeom::DXDevice = SGCore_GetDXDevice();
-				Green::DXDevice = SGCore_GetDXDevice();
-				GeometryObj = new StaticGeom();
-				GreenObj = new Green();
+				CStaticGeom::m_pDXDevice = SGCore_GetDXDevice();
+				CGreen::m_pDXDevice = SGCore_GetDXDevice();
+				g_pGeometry = new CStaticGeom();
+				g_pGreen = new CGreen();
 			}
 		}
 		else
 		{
-			StaticGeom::DXDevice = SGCore_GetDXDevice();
-			Green::DXDevice = SGCore_GetDXDevice();
-			GeometryObj = new StaticGeom();
-			GreenObj = new Green();
+			CStaticGeom::m_pDXDevice = SGCore_GetDXDevice();
+			CGreen::m_pDXDevice = SGCore_GetDXDevice();
+			g_pGeometry = new CStaticGeom();
+			g_pGreen = new CGreen();
 		}
 	}
 	else
@@ -78,24 +80,24 @@ SX_LIB_API void SGeom_0Create(const char *szName, bool isUnic)
 
 SX_LIB_API void SGeom_AKill()
 {
-	mem_delete(GeometryObj);
-	mem_delete(GreenObj);
+	mem_delete(g_pGeometry);
+	mem_delete(g_pGreen);
 }
 
 SX_LIB_API void SGeom_OnLostDevice()
 {
 	GEOM_PRECOND(_VOID);
 
-	GreenObj->OnLostDevice();
-	GeometryObj->OnLostDevice();
+	g_pGreen->onLostDevice();
+	g_pGeometry->onLostDevice();
 }
 
 SX_LIB_API void SGeom_OnResetDevice()
 {
 	GEOM_PRECOND(_VOID);
 
-	GreenObj->OnResetDevice();
-	GeometryObj->OnResetDevice();
+	g_pGreen->onResetDevice();
+	g_pGeometry->onResetDevice();
 }
 
 //##########################################################################
@@ -113,64 +115,64 @@ SX_LIB_API bool SGeom_0SettModelsGetSortFrontToBackModels()
 
 SX_LIB_API void SGeom_0SettModelsSetSortFrontToBackSplits(bool val)
 {
-	StaticGeom::UseSortFrontToBackSplits = val;
+	CStaticGeom::m_isUseSortFrontToBackSplits = val;
 }
 
 SX_LIB_API bool SGeom_0SettModelsGetSortFrontToBackSplits()
 {
-	return StaticGeom::UseSortFrontToBackSplits;
+	return CStaticGeom::m_isUseSortFrontToBackSplits;
 }
 
 
 SX_LIB_API float SGeom_0SettGreenGetDistLods1()
 {
-	return Green::DistLods.x;
+	return CGreen::m_vDistLods.x;
 }
 
 SX_LIB_API float SGeom_0SettGreenGetDistLods2()
 {
-	return Green::DistLods.y;
+	return CGreen::m_vDistLods.y;
 }
 
 SX_LIB_API int SGeom_0SettGreenGetFreqGrass()
 {
-	return Green::CurrentFreqGrass;
+	return CGreen::m_iRenderFreqGrass;
 }
 
 SX_LIB_API float SGeom_0SettGreenGetBeginEndLessening()
 {
-	return Green::BeginEndLessening;
+	return CGreen::m_fDistGrassLessening;
 }
 
 SX_LIB_API bool SGeom_0SettGreenGetSortFrontToBackSplits()
 {
-	return Green::UseSortFrontToBackSplits;
+	return CGreen::m_isUseSortFrontToBackSplits;
 }
 
 
 SX_LIB_API void SGeom_0SettGreenSetDistLods1(float val)
 {
-	Green::DistLods.x = val;
+	CGreen::m_vDistLods.x = val;
 }
 
 SX_LIB_API void SGeom_0SettGreenSetDistLods2(float val)
 {
-	Green::DistLods.y = val;
+	CGreen::m_vDistLods.y = val;
 }
 
 SX_LIB_API void SGeom_0SettGreenSetFreqGrass(int val)
 {
-	Green::CurrentFreqGrass = val;
+	CGreen::m_iRenderFreqGrass = val;
 }
 
 SX_LIB_API void SGeom_0SettGreenSetBeginEndLessening(float val)
 {
-	Green::BeginEndLessening = val;
+	CGreen::m_fDistGrassLessening = val;
 }
 
 SX_LIB_API void SGeom_0SettGreenSetSortFrontToBackSplits(bool val)
 {
-	Green::UseSortFrontToBackSplits = val;
+	CGreen::m_isUseSortFrontToBackSplits = val;
 }
 
 //##########################################################################
@@ -178,434 +180,435 @@ SX_LIB_API void SGeom_0SettGreenSetSortFrontToBackSplits(bool val)
 SX_LIB_API void SGeom_ModelsClear()
 {
 	GEOM_PRECOND(_VOID);
-	GeometryObj->Clear();
+	g_pGeometry->clear();
 }
 
-SX_LIB_API void SGeom_ModelsSave(const char* path)
+SX_LIB_API void SGeom_ModelsSave(const char *szPath)
 {
 	GEOM_PRECOND(_VOID);
-	GeometryObj->Save(path);
+	g_pGeometry->save(szPath);
 }
 
-SX_LIB_API void SGeom_ModelsLoad(const char* path)
+SX_LIB_API void SGeom_ModelsLoad(const char *szPath)
 {
 	GEOM_PRECOND(_VOID);
-	GeometryObj->Load(path);
+	g_pGeometry->load(szPath);
 }
 
-SX_LIB_API long SGeom_ModelsGetCount()
+SX_LIB_API int SGeom_ModelsGetCount()
 {
 	GEOM_PRECOND(-1);
-	return GeometryObj->GetCountModel();
+	return g_pGeometry->getCountModel();
 }
 
-SX_LIB_API void SGeom_ModelsComVisible(const ISXFrustum* frustum, float3* viewpos, ID id_arr)
+SX_LIB_API void SGeom_ModelsComVisible(const ISXFrustum *pFrustum, const float3 *pViewPos, ID idArr)
 {
 	GEOM_PRECOND(_VOID);
-	GeometryObj->CPUFillingArrIndeces(frustum, viewpos, id_arr);
+	g_pGeometry->comArrIndeces(pFrustum, pViewPos, idArr);
 }
 
-SX_LIB_API bool SGeom_ModelsSortExistsForRender(int sort, ID id_arr)
+SX_LIB_API bool SGeom_ModelsSortExistsForRender(int iSort, ID idArr)
 {
 	GEOM_PRECOND(false);
-	return GeometryObj->SortExistsForRender(sort, id_arr);
+	return g_pGeometry->sortExistsForRender(iSort, idArr);
 }
 
-SX_LIB_API void SGeom_ModelsRender(DWORD timeDelta, int sort_mtl, ID id_arr, bool is_sorted, ID exclude_model_id, ID exclude_group_id)
+SX_LIB_API void SGeom_ModelsRender(DWORD timeDelta, int iSortMtl, ID idArr, bool isSorted, ID idExcludeModel, ID idExcludeGroup)
 {
 	GEOM_PRECOND(_VOID);
-	GeometryObj->GPURender(timeDelta, sort_mtl, id_arr, exclude_model_id, exclude_group_id, is_sorted);
+	g_pGeometry->render(timeDelta, iSortMtl, idArr, idExcludeModel, idExcludeGroup, isSorted);
 }
 
-SX_LIB_API void SGeom_ModelsRenderSingly(DWORD timeDelta, ID id, ID id_tex)
+SX_LIB_API void SGeom_ModelsRenderSingly(DWORD timeDelta, ID idModel, ID idTexture)
 {
 	GEOM_PRECOND(_VOID);
-	GeometryObj->GPURenderSingly(timeDelta, id, id_tex);
+	g_pGeometry->renderSingly(timeDelta, idModel, idTexture);
 }
 
-SX_LIB_API ID SGeom_ModelsAddModel(const char* path, const char* lod1, const char* name)
+SX_LIB_API ID SGeom_ModelsAddModel(const char *szPath, const char *szLod1, const char *szName)
 {
 	GEOM_PRECOND(-1);
-	return GeometryObj->AddModel(path, lod1, name);
+	return g_pGeometry->addModel(szPath, szLod1, szName);
 }
 
-SX_LIB_API void SGeom_ModelsDelModel(ID id)
+SX_LIB_API void SGeom_ModelsDelModel(ID idModel)
 {
 	GEOM_PRECOND(_VOID);
-	GeometryObj->DelModel(id);
+	g_pGeometry->deleteModel(idModel);
 }
 
-SX_LIB_API void SGeom_ModelsGetMinMax(float3* min, float3* max)
+SX_LIB_API void SGeom_ModelsGetMinMax(float3 *pMin, float3 *pMax)
 {
 	GEOM_PRECOND(_VOID);
-	GeometryObj->GetMinMax(min, max);
+	g_pGeometry->getMinMax(pMin, pMax);
 }
 
 SX_LIB_API ID SGeom_ModelsAddArrForCom()
 {
 	GEOM_PRECOND(-1);
-	return GeometryObj->AddArrForCom();
+	return g_pGeometry->addArrForCom();
 }
 
-SX_LIB_API bool SGeom_ModelsExistsArrForCom(ID id)
+SX_LIB_API bool SGeom_ModelsExistsArrForCom(ID idModel)
 {
 	GEOM_PRECOND(false);
-	return GeometryObj->existsArrForCom(id);
+	return g_pGeometry->existsArrForCom(idModel);
 }
 
-SX_LIB_API void SGeom_ModelsDelArrForCom(ID id_arr)
+SX_LIB_API void SGeom_ModelsDelArrForCom(ID idArr)
 {
 	GEOM_PRECOND(_VOID);
-	GeometryObj->DelArrForCom(id_arr);
+	g_pGeometry->deleteArrForCom(idArr);
 }
 
 
-SX_LIB_API void SGeom_ModelsMGetMinMax(ID id, float3* min, float3* max)
+SX_LIB_API void SGeom_ModelsMGetMinMax(ID idModel, float3 *pMin, float3 *pMax)
 {
 	GEOM_PRECOND(_VOID);
-	return GeometryObj->GetModelMinMax(id, min, max);
+	return g_pGeometry->getModelMinMax(idModel, pMin, pMax);
 }
 
-SX_LIB_API char* SGeom_ModelsMGetName(ID id)
+SX_LIB_API char* SGeom_ModelsMGetName(ID idModel)
 {
 	GEOM_PRECOND(0);
-	return GeometryObj->GetModelName(id);
+	return g_pGeometry->getModelName(idModel);
 }
 
-SX_LIB_API const char* SGeom_ModelsMGetPathName(ID id)
+SX_LIB_API const char* SGeom_ModelsMGetPathName(ID idModel)
 {
 	GEOM_PRECOND(0);
-	return GeometryObj->GetModelPathName(id);
+	return g_pGeometry->getModelPathName(idModel);
 }
 
-SX_LIB_API long SGeom_ModelsMGetCountPoly(ID id)
+SX_LIB_API int SGeom_ModelsMGetCountPoly(ID idModel)
 {
 	GEOM_PRECOND(-1);
-	return GeometryObj->GetModelCountPoly(id);
+	return g_pGeometry->getModelCountPoly(idModel);
 }
 
 
-SX_LIB_API float3* SGeom_ModelsMGetPosition(ID id)
+SX_LIB_API float3* SGeom_ModelsMGetPosition(ID idModel)
 {
 	GEOM_PRECOND(0);
-	return GeometryObj->GetModelPosition(id);
+	return g_pGeometry->getModelPosition(idModel);
 }
 
-SX_LIB_API float3* SGeom_ModelsMGetRotation(ID id)
+SX_LIB_API float3* SGeom_ModelsMGetRotation(ID idModel)
 {
 	GEOM_PRECOND(0);
-	return GeometryObj->GetModelRotation(id);
+	return g_pGeometry->getModelRotation(idModel);
 }
 
-SX_LIB_API float3* SGeom_ModelsMGetScale(ID id)
+SX_LIB_API float3* SGeom_ModelsMGetScale(ID idModel)
 {
 	GEOM_PRECOND(0);
-	return GeometryObj->GetModelScale(id);
+	return g_pGeometry->getModelScale(idModel);
 }
 
 
-SX_LIB_API const char* SGeom_ModelsMGetLodPath(ID id)
+SX_LIB_API const char* SGeom_ModelsMGetLodPath(ID idModel)
 {
 	GEOM_PRECOND(0);
-	return GeometryObj->GetModelLodPath(id);
+	return g_pGeometry->getModelLodPath(idModel);
 }
 
-SX_LIB_API void SGeom_ModelsMSetLodPath(ID id, const char* path)
+SX_LIB_API void SGeom_ModelsMSetLodPath(ID idModel, const char *szPath)
 {
 	GEOM_PRECOND(_VOID);
-	GeometryObj->SetModelLodPath(id, path);
+	g_pGeometry->setModelLodPath(idModel, szPath);
 }
 
 
-SX_LIB_API void SGeom_ModelsMApplyTransform(ID id)
+SX_LIB_API void SGeom_ModelsMApplyTransform(ID idModel)
 {
 	GEOM_PRECOND(_VOID);
-	GeometryObj->ApplyTransform(id);
+	g_pGeometry->applyTransform(idModel);
 }
 
 
-SX_LIB_API void SGeom_ModelsMSortGroups(float3* viewpos, int sort_mtl)
+SX_LIB_API void SGeom_ModelsMSortGroups(const float3 *pViewPos, int iSortMtl)
 {
 	GEOM_PRECOND(_VOID);
-	GeometryObj->SortGroup(viewpos, sort_mtl);
+	g_pGeometry->sortGroup(pViewPos, iSortMtl);
 }
 
 
-SX_LIB_API ID SGeom_ModelsMGetCountGroups(ID id)
+SX_LIB_API ID SGeom_ModelsMGetCountGroups(ID idModel)
 {
 	GEOM_PRECOND(-1);
-	return GeometryObj->GetModelCountGroups(id);
+	return g_pGeometry->getModelCountGroups(idModel);
 }
 
-SX_LIB_API ID SGeom_ModelsMGetGroupIDMat(ID id, ID group)
+SX_LIB_API ID SGeom_ModelsMGetGroupIDMat(ID idModel, ID idGroup)
 {
 	GEOM_PRECOND(-1);
-	return GeometryObj->GetModelGroupIDMat(id, group);
+	return g_pGeometry->getModelGroupIDMat(idModel, idGroup);
 }
 
-SX_LIB_API void SGeom_ModelsMGetGroupCenter(ID id, ID group, float3_t* center)
+SX_LIB_API void SGeom_ModelsMGetGroupCenter(ID idModel, ID idGroup, float3_t *pCenter)
 {
 	GEOM_PRECOND(_VOID);
-	return GeometryObj->GetModelGroupCenter(id, group, center);
+	return g_pGeometry->getModelGroupCenter(idModel, idGroup, pCenter);
 }
 
-SX_LIB_API void SGeom_ModelsMGetGroupMin(ID id, ID group, float3_t* min)
+SX_LIB_API void SGeom_ModelsMGetGroupMin(ID idModel, ID idGroup, float3_t *pMin)
 {
 	GEOM_PRECOND(_VOID);
-	return GeometryObj->GetModelGroupMin(id, group, min);
+	return g_pGeometry->getModelGroupMin(idModel, idGroup, pMin);
 }
 
-SX_LIB_API void SGeom_ModelsMGetGroupMax(ID id, ID group, float3_t* max)
+SX_LIB_API void SGeom_ModelsMGetGroupMax(ID idModel, ID idGroup, float3_t *pMax)
 {
 	GEOM_PRECOND(_VOID);
-	return GeometryObj->GetModelGroupMax(id, group, max);
+	return g_pGeometry->getModelGroupMax(idModel, idGroup, pMax);
 }
 
-SX_LIB_API void SGeom_ModelsMGetGroupPlane(ID id, ID group, D3DXPLANE* plane)
+SX_LIB_API void SGeom_ModelsMGetGroupPlane(ID idModel, ID idGroup, D3DXPLANE *pPlane)
 {
 	GEOM_PRECOND(_VOID);
-	return GeometryObj->GetModelGroupPlane(id, group, plane);
+	return g_pGeometry->getModelGroupPlane(idModel, idGroup, pPlane);
 }
 
 
 
-SX_LIB_API void SGeom_ModelsGetArrBuffsGeom(float3_t*** arr_vertex, int32_t** arr_count_vertex, uint32_t*** arr_index, ID*** arr_mtl, int32_t** arr_count_index, int32_t* count_models)
+SX_LIB_API void SGeom_ModelsGetArrBuffsGeom(float3_t ***pppArrVertex, int32_t **ppArrCountVertex, uint32_t ***pppArrIndex, ID ***pppArrMtl, int32_t **ppArrCountIndex, int32_t *pCountModels)
 {
 	GEOM_PRECOND(_VOID);
-	GeometryObj->GetArrBuffsGeom(arr_vertex, arr_count_vertex, arr_index, arr_mtl, arr_count_index, count_models);
+	g_pGeometry->getArrBuffsGeom(pppArrVertex, ppArrCountVertex, pppArrIndex, pppArrMtl, ppArrCountIndex, pCountModels);
 }
 
-SX_LIB_API void SGeom_ModelsClearArrBuffsGeom(float3_t** arr_vertex, int32_t* arr_count_vertex, uint32_t** arr_index, ID** arr_mtl, int32_t* arr_count_index, int32_t count_models)
+SX_LIB_API void SGeom_ModelsClearArrBuffsGeom(float3_t **ppArrVertex, int32_t *pArrCountVertex, uint32_t **ppArrIndex, ID **ppArrMtl, int32_t *pArrCountIndex, int32_t iCountModels)
 {
-	for(int32_t i = 0; i < count_models; ++i)
+	for (int i = 0; i < iCountModels; ++i)
 	{
-		mem_delete_a(arr_vertex[i]);
-		mem_delete_a(arr_index[i]);
-		mem_delete_a(arr_mtl[i]);
+		mem_delete_a(ppArrVertex[i]);
+		mem_delete_a(ppArrIndex[i]);
+		mem_delete_a(ppArrMtl[i]);
 	}
-	mem_delete_a(arr_vertex);
-	mem_delete_a(arr_count_vertex);
-	mem_delete_a(arr_index);
-	mem_delete_a(arr_mtl);
-	mem_delete_a(arr_count_index);
+	mem_delete_a(ppArrVertex);
+	mem_delete_a(pArrCountVertex);
+	mem_delete_a(ppArrIndex);
+	mem_delete_a(ppArrMtl);
+	mem_delete_a(pArrCountIndex);
 }
 
-SX_LIB_API bool SGeom_ModelsTraceBeam(float3* start, float3* dir, float3* _res, ID* idmodel, ID* idmtl)
+SX_LIB_API bool SGeom_ModelsTraceBeam(const float3 *pStart, const float3 *pDir, float3 *pResult, ID *pIDmodel, ID *pIDmtl)
 {
 	GEOM_PRECOND(false);
-	return GeometryObj->TraceBeam(start, dir, _res, idmodel, idmtl);
+	return g_pGeometry->traceBeam(pStart, pDir, pResult, pIDmodel, pIDmtl);
 }
 
 //##########################################################################
 
-SX_LIB_API ID SGeom_GreenAddGreen(const char* name,
-	const char* path_mask,
-	float count_max,
-	const char* path, const char* lod1, const char* lod2,
-	const char* navmesh)
+SX_LIB_API ID SGeom_GreenAddGreen(
+	const char *szName,
+	const char *szPathMask,
+	float fCountMax,
+	const char *szPathLod0, const char *szPathLod1, const char *szPathLod2,
+	const char *szNavMesh)
 {
 	GEOM_PRECOND(-1);
-	return GreenObj->Init(GeometryObj, name, path_mask, count_max, path, lod1, lod2, navmesh);
+	return g_pGreen->init(g_pGeometry, szName, szPathMask, fCountMax, szPathLod0, szPathLod1, szPathLod2, szNavMesh);
 }
 
-SX_LIB_API ID SGeom_GreenAddObject(ID id, float3* pos, ID* idsplit)
+SX_LIB_API ID SGeom_GreenAddObject(ID idGreen, float3 *pPos, ID *pIDsplit)
 {
 	GEOM_PRECOND(-1);
-	return GreenObj->AddObject(id, pos, 0, idsplit);
+	return g_pGreen->addObject(idGreen, pPos, 0, pIDsplit);
 }
 
-SX_LIB_API void SGeom_GreenDelObject(ID id, ID idsplit, ID idobj)
+SX_LIB_API void SGeom_GreenDelObject(ID idGreen, ID idSplit, ID idObj)
 {
 	GEOM_PRECOND(_VOID);
-	return GreenObj->DelObject(id, idsplit, idobj);
+	return g_pGreen->deleteObject(idGreen, idSplit, idObj);
 }
 
-SX_LIB_API void SGeom_GreenGetPosObject(ID id, ID idsplit, ID idobj, float3_t* pos)
+SX_LIB_API void SGeom_GreenGetPosObject(ID idGreen, ID idSplit, ID idObj, float3_t *pPos)
 {
 	GEOM_PRECOND(_VOID);
-	GreenObj->GetPosObject(id, idsplit, idobj, pos);
+	g_pGreen->getPosObject(idGreen, idSplit, idObj, pPos);
 }
 
-SX_LIB_API void SGeom_GreenSetPosObject(ID id, ID* idsplit, ID* idobj, float3_t* pos)
+SX_LIB_API void SGeom_GreenSetPosObject(ID idGreen, ID *pIDsplit, ID *pIDobj, float3_t *pPos)
 {
 	GEOM_PRECOND(_VOID);
-	GreenObj->SetPosObject(id, idsplit, idobj, pos);
+	g_pGreen->setPosObject(idGreen, pIDsplit, pIDobj, pPos);
 }
 
-SX_LIB_API void SGeom_GreenDelGreen(ID id)
+SX_LIB_API void SGeom_GreenDelGreen(ID idGreen)
 {
 	GEOM_PRECOND(_VOID);
-	GreenObj->DelGreen(id);
+	g_pGreen->deleteGreen(idGreen);
 }
 
 SX_LIB_API ID SGeom_GreenAddArrForCom()
 {
 	GEOM_PRECOND(-1);
-	return GreenObj->AddArrForCom();
+	return g_pGreen->addArrForCom();
 }
 
-SX_LIB_API bool SGeom_GreenExistsArrForCom(ID id)
+SX_LIB_API bool SGeom_GreenExistsArrForCom(ID idGreen)
 {
 	GEOM_PRECOND(false);
-	return GreenObj->existsArrForCom(id);
+	return g_pGreen->existsArrForCom(idGreen);
 }
 
-SX_LIB_API void SGeom_GreenDelArrForCom(ID id_arr)
+SX_LIB_API void SGeom_GreenDelArrForCom(ID idArr)
 {
 	GEOM_PRECOND(_VOID);
-	GreenObj->DelArrForCom(id_arr);
+	g_pGreen->deleteArrForCom(idArr);
 }
 
-SX_LIB_API void SGeom_GreenSave(const char* path)
+SX_LIB_API void SGeom_GreenSave(const char *szPath)
 {
 	GEOM_PRECOND(_VOID);
-	GreenObj->Save(path);
+	g_pGreen->save(szPath);
 }
 
-SX_LIB_API void SGeom_GreenLoad(const char* path)
+SX_LIB_API void SGeom_GreenLoad(const char *szPath)
 {
 	GEOM_PRECOND(_VOID);
-	GreenObj->Load(path);
+	g_pGreen->load(szPath);
 }
 
 SX_LIB_API void SGeom_GreenClear()
 {
 	GEOM_PRECOND(_VOID);
-	GreenObj->Clear();
+	g_pGreen->clear();
 }
 
-SX_LIB_API void SGeom_GreenComVisible(const ISXFrustum* frustum, float3* viewpos, ID id_arr)
+SX_LIB_API void SGeom_GreenComVisible(const ISXFrustum* frustum, float3 *pViewPos, ID idArr)
 {
 	GEOM_PRECOND(_VOID);
-	GreenObj->CPUFillingArrIndeces(frustum, viewpos, id_arr);
+	g_pGreen->comArrIndeces(frustum, pViewPos, idArr);
 }
 
-SX_LIB_API void SGeom_GreenRender(DWORD timeDelta, float3* viewpos, GREEN_TYPE type, ID id_arr)
+SX_LIB_API void SGeom_GreenRender(DWORD timeDelta, float3 *pViewPos, GREEN_TYPE type, ID idArr)
 {
 	GEOM_PRECOND(_VOID);
-	GreenObj->GPURender(timeDelta, viewpos, type, id_arr);
+	g_pGreen->render(timeDelta, pViewPos, type, idArr);
 }
 
-SX_LIB_API void SGeom_GreenRenderSingly(DWORD timeDelta, float3* viewpos, ID id, ID id_tex)
+SX_LIB_API void SGeom_GreenRenderSingly(DWORD timeDelta, float3 *pViewPos, ID idGreen, ID idTexture)
 {
 	GEOM_PRECOND(_VOID);
-	GreenObj->GPURenderSingly(timeDelta, viewpos, id, id_tex);
+	g_pGreen->renderSingly(timeDelta, pViewPos, idGreen, idTexture);
 }
 
-SX_LIB_API void SGeom_GreenRenderObject(DWORD timeDelta, float3* viewpos, ID id, ID split, ID idobj, ID id_tex)
+SX_LIB_API void SGeom_GreenRenderObject(DWORD timeDelta, float3 *pViewPos, ID idGreen, ID idSplit, ID idObj, ID idTexture)
 {
 	GEOM_PRECOND(_VOID);
-	GreenObj->GPURenderObject(timeDelta, viewpos, id, split, idobj, id_tex);
+	g_pGreen->renderObject(timeDelta, pViewPos, idGreen, idSplit, idObj, idTexture);
 }
 
 
-SX_LIB_API long SGeom_GreenGetCount()
+SX_LIB_API int SGeom_GreenGetCount()
 {
 	GEOM_PRECOND(-1);
-	return GreenObj->GetCountGreen();
+	return g_pGreen->getCountGreen();
 }
 
-SX_LIB_API char* SGeom_GreenMGetName(ID id)
+SX_LIB_API char* SGeom_GreenMGetName(ID idGreen)
 {
 	GEOM_PRECOND(0);
-	return GreenObj->GetGreenName(id);
+	return g_pGreen->getGreenName(idGreen);
 }
 
-SX_LIB_API long SGeom_GreenMGetCountGen(ID id)
+SX_LIB_API int SGeom_GreenMGetCountGen(ID idGreen)
 {
 	GEOM_PRECOND(0);
-	return GreenObj->GetGreenCountGen(id);
+	return g_pGreen->getGreenCountGen(idGreen);
 }
 
-SX_LIB_API long SGeom_GreenMGetCountPoly(ID id)
+SX_LIB_API int SGeom_GreenMGetCountPoly(ID idGreen)
 {
 	GEOM_PRECOND(0);
-	return GreenObj->GetGreenCountPoly(id);
+	return g_pGreen->getGreenCountPoly(idGreen);
 }
 
-SX_LIB_API int SGeom_GreenMGetTypeCountGen(ID id)
+SX_LIB_API int SGeom_GreenMGetTypeCountGen(ID idGreen)
 {
 	GEOM_PRECOND(-1);
-	return GreenObj->GetGreenTypeCountGen(id);
+	return g_pGreen->getGreenTypeCountGen(idGreen);
 }
 
-SX_LIB_API const char* SGeom_GreenMGetModel(ID id)
+SX_LIB_API const char* SGeom_GreenMGetModel(ID idGreen)
 {
 	GEOM_PRECOND(0);
-	return GreenObj->GetGreenModel(id);
+	return g_pGreen->getGreenModel(idGreen);
 }
 
-SX_LIB_API const char* SGeom_GreenMGetLod1(ID id)
+SX_LIB_API const char* SGeom_GreenMGetLod1(ID idGreen)
 {
 	GEOM_PRECOND(0);
-	return GreenObj->GetGreenLod1(id);
+	return g_pGreen->getGreenLod1(idGreen);
 }
 
-SX_LIB_API const char* SGeom_GreenMGetLod2(ID id)
+SX_LIB_API const char* SGeom_GreenMGetLod2(ID idGreen)
 {
 	GEOM_PRECOND(0);
-	return GreenObj->GetGreenLod2(id);
+	return g_pGreen->getGreenLod2(idGreen);
 }
 
-SX_LIB_API const char* SGeom_GreenMGetMask(ID id)
+SX_LIB_API const char* SGeom_GreenMGetMask(ID idGreen)
 {
 	GEOM_PRECOND(0);
-	return GreenObj->GetGreenMask(id);
+	return g_pGreen->getGreenMask(idGreen);
 }
 
-SX_LIB_API const char* SGeom_GreenMGetNav(ID id)
+SX_LIB_API const char* SGeom_GreenMGetNav(ID idGreen)
 {
 	GEOM_PRECOND(0);
-	return GreenObj->GetGreenNav(id);
+	return g_pGreen->getGreenNav(idGreen);
 }
 
-SX_LIB_API void SGeom_GreenMSetLod(ID id, int lod, const char* pathname)
+SX_LIB_API void SGeom_GreenMSetLod(ID idGreen, int iLod, const char *szPathName)
 {
 	GEOM_PRECOND(_VOID);
-	GreenObj->SetGreenLod(id, lod, pathname);
+	g_pGreen->setGreenLod(idGreen, iLod, szPathName);
 }
 
-SX_LIB_API void SGeom_GreenMSetNav(ID id, const char* pathname)
+SX_LIB_API void SGeom_GreenMSetNav(ID idGreen, const char *szPathName)
 {
 	GEOM_PRECOND(_VOID);
-	GreenObj->SetGreenNav(id, pathname);
+	g_pGreen->setGreenNav(idGreen, szPathName);
 }
 
 
-SX_LIB_API void SGeom_GreenGetNavMeshAndTransform(float3_t*** arr_vertex, int32_t** arr_count_vertex, uint32_t*** arr_index, ID*** arr_mtl, int32_t** arr_count_index, GreenDataVertex*** arr_transform, int32_t** arr_count_transform, int32_t* arr_count_green)
+SX_LIB_API void SGeom_GreenGetNavMeshAndTransform(float3_t ***pppArrVertex, int32_t **ppArrVountVertex, uint32_t ***pppArrIndex, ID ***pppArrMtl, int32_t **ppArrCountIndex, CGreenDataVertex ***pppArrTransform, int32_t **ppArrCountTransform, int32_t *pArrCountGreen)
 {
 	GEOM_PRECOND(_VOID);
-	GreenObj->GetNavMeshAndTransform(arr_vertex, arr_count_vertex, arr_index, arr_mtl, arr_count_index, arr_transform, arr_count_transform, arr_count_green);
+	g_pGreen->getNavMeshAndTransform(pppArrVertex, ppArrVountVertex, pppArrIndex, pppArrMtl, ppArrCountIndex, pppArrTransform, ppArrCountTransform, pArrCountGreen);
 }
 
-SX_LIB_API void SGeom_GreenClearNavMeshAndTransform(float3_t** arr_vertex, int32_t* arr_count_vertex, uint32_t** arr_index, ID** arr_mtl, int32_t* arr_count_index, GreenDataVertex** arr_transform, int32_t* arr_count_transform, int32_t arr_count_green)
+SX_LIB_API void SGeom_GreenClearNavMeshAndTransform(float3_t **ppArrVertex, int32_t *pArrCountVertex, uint32_t **ppArrIndex, ID **ppArrMtl, int32_t *pArrCountIndex, CGreenDataVertex **ppArrTransform, int32_t *pArrCountTransform, int32_t iCountGreen)
 {
 	GEOM_PRECOND(_VOID);
 	
-	for (int i = 0; i < arr_count_green; ++i)
+	for (int i = 0; i < iCountGreen; ++i)
 	{
-		mem_delete_a(arr_vertex[i]);
-		mem_delete_a(arr_index[i]);
-		mem_delete_a(arr_mtl[i]);
-		mem_delete_a(arr_transform[i]);
+		mem_delete_a(ppArrVertex[i]);
+		mem_delete_a(ppArrIndex[i]);
+		mem_delete_a(ppArrMtl[i]);
+		mem_delete_a(ppArrTransform[i]);
 	}
-	mem_delete_a(arr_vertex);
-	mem_delete_a(arr_count_vertex);
-	mem_delete_a(arr_index);
-	mem_delete_a(arr_mtl);
-	mem_delete_a(arr_transform);
-	mem_delete_a(arr_count_transform);
-	mem_delete_a(arr_count_index);
+	mem_delete_a(ppArrVertex);
+	mem_delete_a(pArrCountVertex);
+	mem_delete_a(ppArrIndex);
+	mem_delete_a(ppArrMtl);
+	mem_delete_a(ppArrTransform);
+	mem_delete_a(pArrCountTransform);
+	mem_delete_a(pArrCountIndex);
 }
 
-SX_LIB_API bool SGeom_GreenTraceBeam(float3* start, float3* dir, float3* _res, ID* idgreen, ID* idsplits, ID* idobj, ID* idmtl)
+SX_LIB_API bool SGeom_GreenTraceBeam(float3 *pStart, float3 *pDir, float3 *pResult, ID *pIDgreen, ID *pIDsplits, ID *pIDobj, ID *pIDmtl)
 {
 	GEOM_PRECOND(false);
-	return GreenObj->TraceBeam(start, dir, _res, idgreen, idsplits, idobj, idmtl);
+	return g_pGreen->traceBeam(pStart, pDir, pResult, pIDgreen, pIDsplits, pIDobj, pIDmtl);
 }
 
-SX_LIB_API bool SGeom_GreenGetOccurencessLeafGrass(float3* bbmin, float3* bbmax, int physic_mtl)
+SX_LIB_API bool SGeom_GreenGetOccurencessLeafGrass(float3 *pMin, float3 *pMax, int iPhysicMtl)
 {
 	GEOM_PRECOND(false);
-	return GreenObj->GetOccurencessLeafGrass(bbmin, bbmax, physic_mtl);
+	return g_pGreen->getOccurencessLeafGrass(pMin, pMax, iPhysicMtl);
 }
diff --git a/source/geom/sxgeom.h b/source/geom/sxgeom.h
index 9da30798cc20fcf6481ef33aa2a78a521687363f..10c92c88f7e63663740913e3aead8e25fa264f19 100644
--- a/source/geom/sxgeom.h
+++ b/source/geom/sxgeom.h
@@ -47,7 +47,7 @@ See the license in LICENSE
 SX_LIB_API long SGeom_0GetVersion();			
 
 //! установить новую функцию вывода сообщений
-SX_LIB_API void SGeom_Dbg_Set(report_func rf);	
+SX_LIB_API void SGeom_Dbg_Set(report_func fnFunc);	
 
 //! инициализация подсистемы
 SX_LIB_API void SGeom_0Create(	
@@ -182,32 +182,32 @@ SX_LIB_API void SGeom_ModelsSave(const char *szPath);
 SX_LIB_API void SGeom_ModelsLoad(const char *szPath);	
 
 //! количество моделей в текущем списке
-SX_LIB_API long SGeom_ModelsGetCount();	
+SX_LIB_API int SGeom_ModelsGetCount();	
 
 //! просчитать видимость всех моделей для фрустума 
 SX_LIB_API void SGeom_ModelsComVisible(	
 	const ISXFrustum *pFrustum,	//!< фрустум для которого считаем видимость моделей
-	float3 *vViewPos,		//!< позиция источника фрустума чтобы просчитать дистанцию
-	ID idArr = 0			//!< идентификатор массива информации о видимости для фрустума, создается через #SGeom_ModelsAddArrForCom, если 0 то считаем в дефолтный
+	const float3 *pViewPos,		//!< позиция источника фрустума чтобы просчитать дистанцию
+	ID idArr = 0				//!< идентификатор массива информации о видимости для фрустума, создается через #SGeom_ModelsAddArrForCom, если 0 то считаем в дефолтный
 	);	
 
-//! есть ли сорт материала sort который просчитан к отрисовке в массиве просчетов id_arr
+//! есть ли сорт материала iSort который просчитан к отрисовке в массиве просчетов idArr
 SX_LIB_API bool SGeom_ModelsSortExistsForRender(
 	int iSort, 		//!< искомый сорт
 	ID idArr = 0	//!< идентификатор массива информации о видимости для фрустума, создается через #SGeom_ModelsAddArrForCom, если 0 то считаем в дефолтный
 	);
 
-//! отрисовка всех моделей, на основе информации о видимости из массива видимости id_arr
+//! отрисовка всех моделей, на основе информации о видимости из массива видимости idArr
 SX_LIB_API void SGeom_ModelsRender(
-	DWORD timeDelta,			//!< время рендера кадра в млсек
+	DWORD timeDelta,		//!< время рендера кадра в млсек
 	int iSort,				//!< сорт материала, для ранжирования геометрии по "сортам", по умолчанию 0
-	ID idArr = 0,				//!< идентификатор массива с информацией о видимости
-	bool canSorted = false,		//!< использовать ли информацию о сортировке подгрупп front to back
+	ID idArr = 0,			//!< идентификатор массива с информацией о видимости
+	bool canSorted = false,	//!< использовать ли информацию о сортировке подгрупп front to back
 	ID idExcludeModel = -1,	//!< идентификатор модели которую необходимо исключить из рендера (на случай отрисовки отражений)
 	ID idExcludeGroup = -1	//!< идентификатор подгруппы которую надо исключить из рендера, либо указать значение меньше 0, тогда отсекется целая модель с id exclude_model_id	
 	);
 
-//! индивидуальная отрисовка модели, на основе информации о видимости из массива видимости id_arr = 0
+//! индивидуальная отрисовка модели, на основе информации о видимости из массива видимости idArr = 0
 SX_LIB_API void SGeom_ModelsRenderSingly(
 	DWORD timeDelta,//!< время рендера кадра в млсек
 	ID idModel,		//!< идентификатор модели
@@ -227,7 +227,7 @@ SX_LIB_API ID SGeom_ModelsAddModel(
 /*! удалить модель под номером id
  \warning Поверхностные тесты не дали ошибок, однако внутренняя организация хранения данных чрезвычайно сложна (по нашему мнению), поэтому могут быть ошибки, в том числе и критические, но пока обнаружить их не удалось
 */
-SX_LIB_API void SGeom_ModelsDelModel(ID id);	
+SX_LIB_API void SGeom_ModelsDelModel(ID idModel);	
 
 //! получить общий ограничивающий объем всего списка моделей
 SX_LIB_API void SGeom_ModelsGetMinMax(float3 *pMin, float3 *pMax);	
@@ -268,7 +268,7 @@ SX_LIB_API char* SGeom_ModelsMGetName(ID idModel);
 SX_LIB_API const char* SGeom_ModelsMGetPathName(ID idModel);	
 
 //! получить количество полигонов модели
-SX_LIB_API long SGeom_ModelsMGetCountPoly(ID idModel);		
+SX_LIB_API int SGeom_ModelsMGetCountPoly(ID idModel);		
 
 
 //! получить позицию модели
@@ -299,8 +299,8 @@ SX_LIB_API void SGeom_ModelsMApplyTransform(ID idModel);
  \note Рендер по этой сортировке возможен только индивидуально для каждой  подгруппы модели. В данной версии сделано для поддержки полупрозрачных поверхностей.
 */
 SX_LIB_API void SGeom_ModelsMSortGroups(
-	float3 *pViewPos,	//!< позиция наблюдателя относительно которой будет произведена сортировка
-	int iSortMtl		//!< сорт материала для которого будет произведена сортировка
+	const float3 *pViewPos,	//!< позиция наблюдателя относительно которой будет произведена сортировка
+	int iSortMtl			//!< сорт материала для которого будет произведена сортировка
 	);
 
 //**************************************************************************
@@ -326,7 +326,7 @@ SX_LIB_API void SGeom_ModelsMGetGroupCenter(ID idModel, ID idGroup, float3_t *pC
 SX_LIB_API void SGeom_ModelsMGetGroupMin(ID idModel, ID idGroup, float3_t *pMin);
 
 //! записвыает в max максимум (максимальную позицию) центр подгруппы group
-SX_LIB_API void SGeom_ModelsMGetGroupMax(ID idModel, ID idGroup, float3_t* max);
+SX_LIB_API void SGeom_ModelsMGetGroupMax(ID idModel, ID idGroup, float3_t *pMax);
 
 //! записвыает в plane плоскость подгруппы group
 SX_LIB_API void SGeom_ModelsMGetGroupPlane(ID idModel, ID idGroup, D3DXPLANE *pPlane);
@@ -358,7 +358,14 @@ SX_LIB_API void SGeom_ModelsClearArrBuffsGeom(
 	int32_t CountModels			//!< count_model - количество моделей
 	);
 
-SX_LIB_API bool SGeom_ModelsTraceBeam(float3 *pStart, float3 *pDir, float3 *pRes, ID *idModel, ID *idMtl);
+//! трассировка луча, из pStart в направлении pDir, в случае пересечения возвращает true, иначе false, в pRes записывает координаты пересечения если есть
+SX_LIB_API bool SGeom_ModelsTraceBeam(
+	const float3 *pStart,	//!< стартовая точка луча
+	const float3 *pDir,		//!< направление луча
+	float3 *pRes,			//!< если есть пересечение запишет координаты
+	ID *idModel,			//!< если есть пересечение запишет id модели
+	ID *idMtl				//!< если есть пересечение запишет id материала
+	);
 
 //!@} sxgeom
 
@@ -408,7 +415,7 @@ enum GREEN_TYPE
 };
 
 //! структура трансформаций растительности
-struct GreenDataVertex
+struct CGreenDataVertex
 {
 	float3_t m_vPosition;	//!< позиция
 	float3_t m_vTexCoord;	//!< x - общий масштаб,y - поворот по оси y, z -
@@ -460,21 +467,21 @@ SX_LIB_API ID SGeom_GreenAddGreen(
 
 //! добавить объект растительности
 SX_LIB_API ID SGeom_GreenAddObject(
-	ID id,			//!< идентификатор растительности к которой добавляем
+	ID idGreen,		//!< идентификатор растительности к которой добавляем
 	float3 *vPos,	//!< позиция в которой будет находится объект
 	ID *pIDsplit	//!< запишет идентификатор сплита, в котором был добавлен объект
 	);
 
 //! удалить объект растительности
 SX_LIB_API void SGeom_GreenDelObject(
-	ID id,		//!< идентификатор растительности
+	ID idGreen,	//!< идентификатор растительности
 	ID idSplit,	//!< идентификатор слпита из которого надо удалить
 	ID idObj	//!< идентификатор объекта который надо удалить
 	);
 
 //! в pos записывает позицию объекта растительности
 SX_LIB_API void SGeom_GreenGetPosObject(
-	ID id,			//!< идентификатор растительности
+	ID idGreen,		//!< идентификатор растительности
 	ID idSplit,		//!< идентификатор слпита
 	ID idObj,		//!< идентификатор объекта
 	float3_t *pPos	//!< вектор в который будет записана позиция
@@ -484,14 +491,14 @@ SX_LIB_API void SGeom_GreenGetPosObject(
  \note Так как новая позиция объекта растительности может выходит за пределы текущего сплита и может входить в другой сплит, то указатели idsplit и idobj могут быть изменены после вызова данной функции
 */
 SX_LIB_API void SGeom_GreenSetPosObject(
-	ID id,			//!< идентификатор растительности
+	ID idGreen,		//!< идентификатор растительности
 	ID* idSplit,	//!< идентификатор слпита
 	ID* idObj,		//!< идентификатор объекта
 	float3_t *pPos	//!< пновая позиция объекта растительности
 	);
 
 //! удалить единицу растительности
-SX_LIB_API void SGeom_GreenDelGreen(ID id);	
+SX_LIB_API void SGeom_GreenDelGreen(ID idGreen);
 
 //**************************************************************************
 
@@ -506,7 +513,7 @@ SX_LIB_API void SGeom_GreenDelGreen(ID id);
 SX_LIB_API ID SGeom_GreenAddArrForCom();			
 
 //! существует ли массив просчетов с номером id
-SX_LIB_API bool SGeom_GreenExistsArrForCom(ID id);
+SX_LIB_API bool SGeom_GreenExistsArrForCom(ID idGreen);
 
 //! удалить массив просчетов
 SX_LIB_API void SGeom_GreenDelArrForCom(ID idArr);	
@@ -527,23 +534,23 @@ SX_LIB_API void SGeom_GreenClear();
 //! просчитать видимость всей растительности для фрустума
 SX_LIB_API void SGeom_GreenComVisible(
 	const ISXFrustum *pFrustum,	//!< фрустум для которого считаем видимость моделей
-	float3 *pViewPos,		//!< позиция источника фрустума чтобы просчитать дистанцию
-	ID idArr = 0			//!< идентификатор массива информации о видимости для фрустума, создается через #SGeom_ModelsAddArrForCom, если 0 то считаем в дефолтный
+	float3 *pViewPos,			//!< позиция источника фрустума чтобы просчитать дистанцию
+	ID idArr = 0				//!< идентификатор массива информации о видимости для фрустума, создается через #SGeom_ModelsAddArrForCom, если 0 то считаем в дефолтный
 	);
 
 //! отрисовка растительности
 SX_LIB_API void SGeom_GreenRender(
-	DWORD timeDelta,	//!< время рендера кадра
-	float3 *pViewPos,	//!< позиция наблюдателя (для которого будет рендер)
-	GREEN_TYPE typeGreen,//!< тип рисуемой растительности из перечисления GeomGreenType, указав GeomGreenType::ggtr_all будут отрисованы все типы растительности
-	ID idArr = 0		//!< идентификатор массива просчетов видимости (создается #SGeom_GreenAddArrForCom)
+	DWORD timeDelta,		//!< время рендера кадра
+	float3 *pViewPos,		//!< позиция наблюдателя (для которого будет рендер)
+	GREEN_TYPE typeGreen,	//!< тип рисуемой растительности из перечисления GeomGreenType, указав GeomGreenType::ggtr_all будут отрисованы все типы растительности
+	ID idArr = 0			//!< идентификатор массива просчетов видимости (создается #SGeom_GreenAddArrForCom)
 	);
 
 //! индивидуальная отрисовка растительности по идентификатору, массив просчетов по умолчанию (0)
 SX_LIB_API void SGeom_GreenRenderSingly(
 	DWORD timeDelta,	//!< время рендера кадра
 	float3 *pViewPos,	//!< позиция наблюдателя (для которого будет рендер)
-	ID id,				//!< идентификатор растительности
+	ID idGreen,			//!< идентификатор растительности
 	ID idTex = -1		//!< идентификатор материала, который будет применен ко всем объектам и подгруппам растительности, -1 если надо использовать назначенные материалы
 	);
 
@@ -551,14 +558,14 @@ SX_LIB_API void SGeom_GreenRenderSingly(
 SX_LIB_API void SGeom_GreenRenderObject(
 	DWORD timeDelta,	//!< время рендера кадра
 	float3 *pViewPos,	//!< позиция наблюдателя (для которого будет рендер)
-	ID id,				//!< идентификатор растительности
+	ID idGreen,			//!< идентификатор растительности
 	ID idSplit,			//!< идентификатор сплита (в котором находится объект)
 	ID idObj,			//!< идентификатор объекта (в сплите)
 	ID idTex = -1		//!< идентификатор материала, который будет применен ко всем объектам и подгруппам растительности, -1 если надо использовать назначенные материалы
 	);
 
 //!< получить количество единиц растительности (по видам есесно)
-SX_LIB_API long SGeom_GreenGetCount();	
+SX_LIB_API int SGeom_GreenGetCount();	
 
 //**************************************************************************
 
@@ -567,38 +574,39 @@ SX_LIB_API long SGeom_GreenGetCount();
 @{*/
 
 //! получить имя
-SX_LIB_API char* SGeom_GreenMGetName(ID id);		
+SX_LIB_API char* SGeom_GreenMGetName(ID idGreen);
 
 //! получить количество сгенерированных элементов
-SX_LIB_API long SGeom_GreenMGetCountGen(ID id);		
+SX_LIB_API int SGeom_GreenMGetCountGen(ID idGreen);
 
 //! получить количество в модели (0 лод)
-SX_LIB_API long SGeom_GreenMGetCountPoly(ID id);	
+SX_LIB_API int SGeom_GreenMGetCountPoly(ID idGreen);
 
 //! получить тип растительности
-SX_LIB_API int SGeom_GreenMGetTypeCountGen(ID id);	
+SX_LIB_API int SGeom_GreenMGetTypeCountGen(ID idGreen);
 
 //! получить путь до модели относительно стандартного пути
-SX_LIB_API const char* SGeom_GreenMGetModel(ID id);	
+SX_LIB_API const char* SGeom_GreenMGetModel(ID idGreen);
 
 //! получить путь до первого лода модели относительно стандартного пути
-SX_LIB_API const char* SGeom_GreenMGetLod1(ID id);	
+SX_LIB_API const char* SGeom_GreenMGetLod1(ID idGreen);
 
 //! получить путь до второго лода модели относительно стандартного пути
-SX_LIB_API const char* SGeom_GreenMGetLod2(ID id);	
+SX_LIB_API const char* SGeom_GreenMGetLod2(ID idGreen);
 
 //! получить путь до маски по которой сгенерирована растительность, относительно стандартного пути
-SX_LIB_API const char* SGeom_GreenMGetMask(ID id);	
+SX_LIB_API const char* SGeom_GreenMGetMask(ID idGreen);
 
 //! получить путь до лода навигации относительно стандартного пути
-SX_LIB_API const char* SGeom_GreenMGetNav(ID id);	
+SX_LIB_API const char* SGeom_GreenMGetNav(ID idGreen);
 
 //! установить лод (для рендера)
 SX_LIB_API void SGeom_GreenMSetLod(
-	ID id,					//!< идентификатор единицы растительности
+	ID idGreen,				//!< идентификатор единицы растительности
 	int iLod,				//!< номер лода от 0 до 2 включительно
 	const char *szPathName	//!< путь до модели относительно стандартного пути
 	);	
+
 SX_LIB_API void SGeom_GreenMSetNav(ID id, const char *szPathName);	//!< установить лод навигации, pathname путь до модели относительно стандартного пути
 
 //!@}
@@ -610,13 +618,13 @@ SX_LIB_API void SGeom_GreenMSetNav(ID id, const char *szPathName);	//!< уста
 */
 SX_LIB_API void SGeom_GreenGetNavMeshAndTransform(
 	float3_t ***pppVertices,			//!< (*arr_vertex)[num_green_mesh_nav][num_vertex] - вершины модели
-	int32_t **ppCountVertices,		//!< (*arr_count_vertex)[num_green_mesh_nav] - количество вершин для модели
-	uint32_t ***pppIndeces,			//!< (*arr_index)[num_green_mesh_nav][num_vertex] - индексы модели
-	ID ***pppMtl,					//!< (*arr_mtl)[num_green_mesh_nav][num_vertex] - материал для индекса
-	int32_t **ppCountIndeces,		//!< (*arr_count_index)[num_green_mesh_nav] - количество индексов для модели
-	GreenDataVertex ***pppTransforms,//!< (*arr_transform)[num_green_mesh_nav][num_obj] - трансформации модели навигации
-	int32_t **ppCountTransforms,	//!< (*arr_count_transform)[num_green_mesh_nav] - количество матриц для трансформаций
-	int32_t *pCountGreens			//!< (*arr_count_green) - количество единиц растительности по видам
+	int32_t **ppCountVertices,			//!< (*arr_count_vertex)[num_green_mesh_nav] - количество вершин для модели
+	uint32_t ***pppIndeces,				//!< (*arr_index)[num_green_mesh_nav][num_vertex] - индексы модели
+	ID ***pppMtl,						//!< (*arr_mtl)[num_green_mesh_nav][num_vertex] - материал для индекса
+	int32_t **ppCountIndeces,			//!< (*arr_count_index)[num_green_mesh_nav] - количество индексов для модели
+	CGreenDataVertex ***pppTransforms,	//!< (*arr_transform)[num_green_mesh_nav][num_obj] - трансформации модели навигации
+	int32_t **ppCountTransforms,		//!< (*arr_count_transform)[num_green_mesh_nav] - количество матриц для трансформаций
+	int32_t *pCountGreens				//!< (*arr_count_green) - количество единиц растительности по видам
 	);
 
 /*! Очищает папять, выделенную в SGeom_GreenGetNavMeshAndTransform
@@ -627,7 +635,7 @@ SX_LIB_API void SGeom_GreenClearNavMeshAndTransform(
 	uint32_t **ppIndeces,			//!< (*arr_index)[num_green_mesh_nav][num_vertex] - индексы модели
 	ID **ppMtl,						//!< (*arr_mtl)[num_green_mesh_nav][num_vertex] - материал для индекса
 	int32_t *pCountIndeces,			//!< (*arr_count_index)[num_green_mesh_nav] - количество индексов для модели
-	GreenDataVertex **ppTransforms,	//!< (*arr_transform)[num_type_green][num_elem] - трансформации модели навигации
+	CGreenDataVertex **ppTransforms,//!< (*arr_transform)[num_type_green][num_elem] - трансформации модели навигации
 	int32_t *pCountTransforms,		//!< (*arr_count_transform)[num_type_green] - количество матриц для трансформаций
 	int32_t iCountGreens			//!< (*arr_count_green) - количество единиц растительности по видам
 	);
diff --git a/source/physics/PhyWorld.cpp b/source/physics/PhyWorld.cpp
index c58e7a5f889da2addf227d8936bee5f796267645..96673b9700b6f8192fa2c3cf95af9f22004e1dc1 100644
--- a/source/physics/PhyWorld.cpp
+++ b/source/physics/PhyWorld.cpp
@@ -187,7 +187,7 @@ void PhyWorld::LoadGeom(const char * file)
 	uint32_t** green_arr_index;
 	ID** green_arr_mtl;
 	int32_t* green_arr_count_index;
-	GreenDataVertex** green_arr_transform;
+	CGreenDataVertex** green_arr_transform;
 	int32_t* green_arr_count_transform;
 	int32_t green_arr_count_green;
 
diff --git a/source/score/sxscore.cpp b/source/score/sxscore.cpp
index a4dc51178cb68bc1a3566a3bca666538b10f8ab7..31197743bc4f962a26158c20ad0dba38b8edc33e 100644
--- a/source/score/sxscore.cpp
+++ b/source/score/sxscore.cpp
@@ -14,9 +14,9 @@ See the license in LICENSE
 report_func g_fnReportf = DefReport;
 #endif
 
-MainSound* MSound = 0;
+MainSound *g_pManagerSound = 0;
 
-#define SCORE_PRECOND(retval) if(!MSound){LibReport(-1, "%s - sxsound is not init", GEN_MSG_LOCATION); return retval;}
+#define SCORE_PRECOND(retval) if(!g_pManagerSound){LibReport(-1, "%s - sxsound is not init", GEN_MSG_LOCATION); return retval;}
 
 //##########################################################################
 
@@ -30,13 +30,13 @@ SX_LIB_API void SSCore_Dbg_Set(report_func rf)
 	g_fnReportf = rf;
 }
 
-SX_LIB_API void SSCore_0Create(const char* name, HWND hwnd, bool is_unic)
+SX_LIB_API void SSCore_0Create(const char *szName, HWND hWnd, bool isUnic)
 {
-	if (name && strlen(name) > 1)
+	if (szName && strlen(szName) > 1)
 	{
-		if (is_unic)
+		if (isUnic)
 		{
-			HANDLE hMutex = CreateMutex(NULL, FALSE, name);
+			HANDLE hMutex = CreateMutex(NULL, FALSE, szName);
 			if (GetLastError() == ERROR_ALREADY_EXISTS)
 			{
 				CloseHandle(hMutex);
@@ -44,14 +44,14 @@ SX_LIB_API void SSCore_0Create(const char* name, HWND hwnd, bool is_unic)
 			}
 			else
 			{
-				MSound = new MainSound();
-				MSound->Init(hwnd);
+				g_pManagerSound = new MainSound();
+				g_pManagerSound->Init(hWnd);
 			}
 		}
 		else
 		{
-			MSound = new MainSound();
-			MSound->Init(hwnd);
+			g_pManagerSound = new MainSound();
+			g_pManagerSound->Init(hWnd);
 		}
 	}
 	else
@@ -60,7 +60,7 @@ SX_LIB_API void SSCore_0Create(const char* name, HWND hwnd, bool is_unic)
 
 SX_LIB_API void SSCore_AKill()
 {
-	mem_delete(MSound);
+	mem_delete(g_pManagerSound);
 }
 
 //#############################################################################
@@ -69,259 +69,259 @@ SX_LIB_API void SSCore_Clear()
 {
 	SCORE_PRECOND(_VOID);
 
-	MSound->Clear();
+	g_pManagerSound->Clear();
 }
 
 
-SX_LIB_API void SSCore_Update(const float3* viewpos, const float3* viewdir)
+SX_LIB_API void SSCore_Update(const float3 *pViewPos, const float3 *pViewDir)
 {
 	SCORE_PRECOND(_VOID);
 
-	MSound->Update(viewpos, viewdir);
+	g_pManagerSound->Update(pViewPos, pViewDir);
 }
 
 SX_LIB_API int SSCore_SndsPlayCountGet()
 {
 	SCORE_PRECOND(0);
 
-	return MSound->SoundsPlayCountGet();
+	return g_pManagerSound->SoundsPlayCountGet();
 }
 
 SX_LIB_API int SSCore_SndsLoadCountGet()
 {
 	SCORE_PRECOND(0);
 
-	return MSound->SoundsLoadCountGet();
+	return g_pManagerSound->SoundsLoadCountGet();
 }
 
-SX_LIB_API ID SSCore_SndCreate2d(const char *file, bool looping, DWORD size_stream)
+SX_LIB_API ID SSCore_SndCreate2d(const char *szFile, bool isLooping, UINT uiSizeStream)
 {
 	SCORE_PRECOND(-1);
 
-	return MSound->SoundCreate2d(file, looping, size_stream);
+	return g_pManagerSound->SoundCreate2d(szFile, isLooping, uiSizeStream);
 }
 
-SX_LIB_API ID SSCore_SndCreate3d(const char *file, bool looping, DWORD size_stream, float dist, float shift_pan)
+SX_LIB_API ID SSCore_SndCreate3d(const char *szFile, bool isLooping, UINT uiSizeStream, float fDist, float fShiftPan)
 {
 	SCORE_PRECOND(-1);
 
-	return MSound->SoundCreate3d(file, looping, size_stream, dist, shift_pan);
+	return g_pManagerSound->SoundCreate3d(szFile, isLooping, uiSizeStream, fDist, fShiftPan);
 }
 
-SX_LIB_API ID SSCore_SndCreate2dInst(const char *file, bool looping, DWORD size_stream)
+SX_LIB_API ID SSCore_SndCreate2dInst(const char *szFile, bool isLooping, UINT uiSizeStream)
 {
 	SCORE_PRECOND(-1);
 
-	return  MSound->SoundCreate2dInst(file, looping, size_stream);
+	return  g_pManagerSound->SoundCreate2dInst(szFile, isLooping, uiSizeStream);
 }
 
-SX_LIB_API ID SSCore_SndCreate3dInst(const char *file, bool looping, DWORD size_stream, float dist, float shift_pan)
+SX_LIB_API ID SSCore_SndCreate3dInst(const char *szFile, bool isLooping, UINT uiSizeStream, float fDist, float fShiftPan)
 {
 	SCORE_PRECOND(-1);
 
-	return  MSound->SoundCreate3dInst(file, looping, size_stream, dist, shift_pan);
+	return  g_pManagerSound->SoundCreate3dInst(szFile, isLooping, uiSizeStream, fDist, fShiftPan);
 }
 
-SX_LIB_API ID SSCore_SndFind2dInst(const char *file)
+SX_LIB_API ID SSCore_SndFind2dInst(const char *szFile)
 {
 	SCORE_PRECOND(-1);
 
-	return MSound->SoundFind2dInst(file);
+	return g_pManagerSound->SoundFind2dInst(szFile);
 }
 
-SX_LIB_API ID SSCore_SndFind3dInst(const char *file)
+SX_LIB_API ID SSCore_SndFind3dInst(const char *szFile)
 {
 	SCORE_PRECOND(-1);
 
-	return MSound->SoundFind3dInst(file);
+	return g_pManagerSound->SoundFind3dInst(szFile);
 }
 
-SX_LIB_API void SSCore_SndInstancePlay2d(ID id, int volume, int pan)
+SX_LIB_API void SSCore_SndInstancePlay2d(ID idSound, int iVolume, int iPan)
 {
 	SCORE_PRECOND(_VOID);
 
-	MSound->SoundInstancePlay2d(id, volume, pan);
+	g_pManagerSound->SoundInstancePlay2d(idSound, iVolume, iPan);
 }
 
-SX_LIB_API void SSCore_SndInstancePlay3d(ID id, const float3* pos)
+SX_LIB_API void SSCore_SndInstancePlay3d(ID idSound, const float3 *pPos)
 {
 	SCORE_PRECOND(_VOID);
 
-	MSound->SoundInstancePlay3d(id, pos);
+	g_pManagerSound->SoundInstancePlay3d(idSound, pPos);
 }
 
 
-SX_LIB_API bool SSCore_SndIsInit(ID id)
+SX_LIB_API bool SSCore_SndIsInit(ID idSound)
 {
 	SCORE_PRECOND(false);
 
-	return MSound->SoundIsInit(id);
+	return g_pManagerSound->SoundIsInit(idSound);
 }
 
-SX_LIB_API void SSCore_SndDelete(ID id)
+SX_LIB_API void SSCore_SndDelete(ID idSound)
 {
 	SCORE_PRECOND(_VOID);
 
-	MSound->SoundDelete(id);
+	g_pManagerSound->SoundDelete(idSound);
 }
 
 
-SX_LIB_API void SSCore_SndPlay(ID id, int looping)
+SX_LIB_API void SSCore_SndPlay(ID idSound, int isLooping)
 {
 	SCORE_PRECOND(_VOID);
 
-	MSound->SoundPlay(id, looping);
+	g_pManagerSound->SoundPlay(idSound, isLooping);
 }
 
-SX_LIB_API void SSCore_SndPause(ID id)
+SX_LIB_API void SSCore_SndPause(ID idSound)
 {
 	SCORE_PRECOND(_VOID);
 
-	MSound->SoundPause(id);
+	g_pManagerSound->SoundPause(idSound);
 }
 
-SX_LIB_API void SSCore_SndStop(ID id)
+SX_LIB_API void SSCore_SndStop(ID idSound)
 {
 	SCORE_PRECOND(_VOID);
 
-	MSound->SoundStop(id);
+	g_pManagerSound->SoundStop(idSound);
 }
 
 
-SX_LIB_API void SSCore_SndStateSet(ID id, SOUND_OBJSTATE state)
+SX_LIB_API void SSCore_SndStateSet(ID idSound, SOUND_OBJSTATE state)
 {
 	SCORE_PRECOND(_VOID);
 
-	MSound->SoundStateSet(id, state);
+	g_pManagerSound->SoundStateSet(idSound, state);
 }
 
-SX_LIB_API SOUND_OBJSTATE SSCore_SndStateGet(ID id)
+SX_LIB_API SOUND_OBJSTATE SSCore_SndStateGet(ID idSound)
 {
 	SCORE_PRECOND(SOUND_OBJSTATE_STOP);
 
-	return MSound->SoundStateGet(id);
+	return g_pManagerSound->SoundStateGet(idSound);
 }
 
-SX_LIB_API void SSCore_SndPosCurrSet(ID id, DWORD pos, int type)
+SX_LIB_API void SSCore_SndPosCurrSet(ID idSound, UINT uiPos, int iType)
 {
 	SCORE_PRECOND(_VOID);
 
-	MSound->SoundPosCurrSet(id, pos, type);
+	g_pManagerSound->SoundPosCurrSet(idSound, uiPos, iType);
 }
 
-SX_LIB_API DWORD SSCore_SndPosCurrGet(ID id, int type)
+SX_LIB_API UINT SSCore_SndPosCurrGet(ID idSound, int iType)
 {
 	SCORE_PRECOND(0);
 
-	return MSound->SoundPosCurrGet(id, type);
+	return g_pManagerSound->SoundPosCurrGet(idSound, iType);
 }
 
 
-SX_LIB_API void SSCore_SndVolumeSet(ID id, long volume, int type)
+SX_LIB_API void SSCore_SndVolumeSet(ID idSound, int iVolume, int iType)
 {
 	SCORE_PRECOND(_VOID);
 
-	MSound->SoundVolumeSet(id, volume, type);
+	g_pManagerSound->SoundVolumeSet(idSound, iVolume, iType);
 }
 
-SX_LIB_API long SSCore_SndVolumeGet(ID id, int type)
+SX_LIB_API int SSCore_SndVolumeGet(ID idSound, int iType)
 {
 	SCORE_PRECOND(0);
 
-	return MSound->SoundVolumeGet(id, type);
+	return g_pManagerSound->SoundVolumeGet(idSound, iType);
 }
 
 
-SX_LIB_API void SSCore_SndPanSet(ID id, long value, int type)
+SX_LIB_API void SSCore_SndPanSet(ID idSound, int iValue, int iType)
 {
 	SCORE_PRECOND(_VOID);
 
-	MSound->SoundPanSet(id, value, type);
+	g_pManagerSound->SoundPanSet(idSound, iValue, iType);
 }
 
-SX_LIB_API long SSCore_SndPanGet(ID id, int type)
+SX_LIB_API int SSCore_SndPanGet(ID idSound, int iType)
 {
 	SCORE_PRECOND(0);
 
-	return MSound->SoundPanGet(id, type);
+	return g_pManagerSound->SoundPanGet(idSound, iType);
 }
 
 
-SX_LIB_API void SSCore_SndFreqCurrSet(ID id, DWORD value)
+SX_LIB_API void SSCore_SndFreqCurrSet(ID idSound, UINT fValue)
 {
 	SCORE_PRECOND(_VOID);
 
-	MSound->SoundFreqCurrSet(id, value);
+	g_pManagerSound->SoundFreqCurrSet(idSound, fValue);
 }
 
-SX_LIB_API DWORD SSCore_SndFreqCurrGet(ID id)
+SX_LIB_API UINT SSCore_SndFreqCurrGet(ID idSound)
 {
 	SCORE_PRECOND(0);
 
-	return MSound->SoundFreqCurrGet(id);
+	return g_pManagerSound->SoundFreqCurrGet(idSound);
 }
 
-SX_LIB_API DWORD SSCore_SndFreqOriginGet(ID id)
+SX_LIB_API UINT SSCore_SndFreqOriginGet(ID idSound)
 {
 	SCORE_PRECOND(0);
 
-	return MSound->SoundFreqOriginGet(id);
+	return g_pManagerSound->SoundFreqOriginGet(idSound);
 }
 
-SX_LIB_API void SSCore_SndPosWSet(ID id, const float3* pos)
+SX_LIB_API void SSCore_SndPosWSet(ID idSound, const float3 *pPos)
 {
 	SCORE_PRECOND(_VOID);
 
-	MSound->SoundPosWSet(id, pos);
+	g_pManagerSound->SoundPosWSet(idSound, pPos);
 }
 
-SX_LIB_API void SSCore_SndPosWGet(ID id, float3* pos)
+SX_LIB_API void SSCore_SndPosWGet(ID idSound, float3 *pPos)
 {
 	SCORE_PRECOND(_VOID);
 
-	MSound->SoundPosWGet(id, pos);
+	g_pManagerSound->SoundPosWGet(idSound, pPos);
 }
 
 
-SX_LIB_API int SSCore_SndLengthSecGet(ID id)
+SX_LIB_API int SSCore_SndLengthSecGet(ID idSound)
 {
 	SCORE_PRECOND(0);
 
-	return MSound->SoundLengthSecGet(id);
+	return g_pManagerSound->SoundLengthSecGet(idSound);
 }
 
-SX_LIB_API DWORD SSCore_SndBytesPerSecGet(ID id)
+SX_LIB_API UINT SSCore_SndBytesPerSecGet(ID idSound)
 {
 	SCORE_PRECOND(0);
 
-	return MSound->SoundBytesPerSecGet(id);
+	return g_pManagerSound->SoundBytesPerSecGet(idSound);
 }
 
-SX_LIB_API DWORD SSCore_SndSizeGet(ID id)
+SX_LIB_API UINT SSCore_SndSizeGet(ID idSound)
 {
 	SCORE_PRECOND(0);
 
-	return MSound->SoundSizeGet(id);
+	return g_pManagerSound->SoundSizeGet(idSound);
 }
 
-SX_LIB_API void SSCore_SndFileGet(ID id, char* path)
+SX_LIB_API void SSCore_SndFileGet(ID idSound, char *szPath)
 {
 	SCORE_PRECOND(_VOID);
 
-	MSound->SoundFileGet(id, path);
+	g_pManagerSound->SoundFileGet(idSound, szPath);
 }
 
 
-SX_LIB_API float SSCore_SndDistAudibleGet(ID id)
+SX_LIB_API float SSCore_SndDistAudibleGet(ID idSound)
 {
 	SCORE_PRECOND(0);
 
-	return MSound->SoundDistAudibleGet(id);
+	return g_pManagerSound->SoundDistAudibleGet(idSound);
 }
 
-SX_LIB_API void SSCore_SndDistAudibleSet(ID id, float value)
+SX_LIB_API void SSCore_SndDistAudibleSet(ID idSound, float fValue)
 {
 	SCORE_PRECOND(_VOID);
 
-	MSound->SoundDistAudibleSet(id, value);
+	g_pManagerSound->SoundDistAudibleSet(idSound, fValue);
 }
diff --git a/source/score/sxscore.h b/source/score/sxscore.h
index 60bb521832c017a0e3248c2cafca5a11e28f3512..05472b192f826f93ca89438953b55c8265245ca9 100644
--- a/source/score/sxscore.h
+++ b/source/score/sxscore.h
@@ -35,7 +35,7 @@ See the license in LICENSE
 
 #undef SX_LIB_API
 #define SX_LIB_API extern "C" __declspec (dllimport)
-#include <core\\sxcore.h>
+#include <core/sxcore.h>
 
 #ifdef SX_DLL
 #undef SX_LIB_API
@@ -51,13 +51,13 @@ See the license in LICENSE
 SX_LIB_API long SSCore_0GetVersion();			
 
 //! установить новую функцию вывода сообщений
-SX_LIB_API void SSCore_Dbg_Set(report_func rf);	
+SX_LIB_API void SSCore_Dbg_Set(report_func fnFunc);	
 
 //! инициализация подсистемы
 SX_LIB_API void SSCore_0Create(	
-	const char* name,			//!< имя
-	HWND hwnd,
-	bool is_unic = true			//!< должна ли подсистема быть уникальной по имени
+	const char *szName,	//!< имя
+	HWND hWnd,			//!< хэндл окна к которому привязывается звук
+	bool isUnic = true	//!< должна ли подсистема быть уникальной по имени
 	);
 
 //! уничтожение подсистемы
@@ -136,8 +136,8 @@ SX_LIB_API void SSCore_Clear();
 
 //! обновление состояний всех звуков
 SX_LIB_API void SSCore_Update(
-	const float3* viewpos,	//!< текущая позиция наблюдателя
-	const float3* viewdir	//!< текущее направление взгляда
+	const float3 *pViewPpos,//!< текущая позиция наблюдателя
+	const float3 *pViewDir	//!< текущее направление взгляда
 	);	
 
 //! количество проигрываемых на данный момент звуков
@@ -148,144 +148,144 @@ SX_LIB_API int SSCore_SndsLoadCountGet();
 
 //! загрузка 2d (фонового) звука
 SX_LIB_API ID SSCore_SndCreate2d(
-	const char *file,		//!< путь до файла, относительно стандартного
-	bool looping = false,	//!< зацикливать ли воспроизведение
-	DWORD size_stream = 0	//!< размер потока в байтах для потокового воспроизведения, если 0 тогда полностью грузить в память
+	const char *szFile,		//!< путь до файла, относительно стандартного
+	bool isLooping = false,	//!< зацикливать ли воспроизведение
+	UINT uiSizeStream = 0	//!< размер потока в байтах для потокового воспроизведения, если 0 тогда полностью грузить в память
 	);
 
 //! загрузка 3d звука
 SX_LIB_API ID SSCore_SndCreate3d(
-	const char *file,		//!< путь до файла, относительно стандартного
-	bool looping,			//!< зацикливать ли воспроизведение
-	DWORD size_stream,		//!< размер потока в байтах для потокового воспроизведения, если 0 тогда полностью грузить в память
-	float dist,				//!< радиус слышимости в метрах
-	float shift_pan = 0.1f	//!< изменение позиционирования звука [0-1], на сколько будет смещен звук (между ушами слушателя) при поворотах камеры к источнику звука, чем ближе к объекту тем меньше разница в позиционировании при поворотах
+	const char *szFile,		//!< путь до файла, относительно стандартного
+	bool isLooping,			//!< зацикливать ли воспроизведение
+	UINT uiSizeStream,		//!< размер потока в байтах для потокового воспроизведения, если 0 тогда полностью грузить в память
+	float fDist,			//!< радиус слышимости в метрах
+	float fShiftPan = 0.1f	//!< изменение позиционирования звука [0-1], на сколько будет смещен звук (между ушами слушателя) при поворотах камеры к источнику звука, чем ближе к объекту тем меньше разница в позиционировании при поворотах
 	);
 
 //! воспроизведение инстанса 2d звука
 SX_LIB_API void SSCore_SndInstancePlay2d(
-	ID id,				//!< идентификатор звука
-	int volume = 100,	//!< громкость [0-100]
-	int pan = 0			//!< смещение между ушами [-100 - 100]
+	ID idSound,			//!< идентификатор звука
+	int iVolume = 100,	//!< громкость [0-100]
+	int iPan = 0		//!< смещение между ушами [-100 - 100]
 	);
 
 //! воспроизведение инстанса 3d звука
 SX_LIB_API void SSCore_SndInstancePlay3d(
-	ID id,				//!< идентификатор звука
-	const float3* pos	//!< позиция воспроизведения инстанса
+	ID idSound,			//!< идентификатор звука
+	const float3 *pPos	//!< позиция воспроизведения инстанса
 	);
 
 //! загрузка 2d звукового файла и пометка его как объект выдающий инстансы, аргументы аналогичны #SSCore_SndCreate2d
-SX_LIB_API ID SSCore_SndCreate2dInst(const char *file, bool looping = false, DWORD size_stream = 0);
+SX_LIB_API ID SSCore_SndCreate2dInst(const char *szFile, bool isLooping = false, UINT uiSizeStream = 0);
 
 //! загрузка 3d звукового файла и пометка его как объект выдающий инстансы, аргументы аналогичны #SSCore_SndCreate3d
-SX_LIB_API ID SSCore_SndCreate3dInst(const char *file, bool looping, DWORD size_stream, float dist, float shift_pan = 0.1f);
+SX_LIB_API ID SSCore_SndCreate3dInst(const char *szFile, bool isLooping, UINT uiSizeStream, float fDist, float fShiftPan = 0.1f);
 
 //! поиск 2d звука (выдающего инстансы) по относительному пути загрузки,возвращает его ID (в случае успеха) иначе <0
-SX_LIB_API ID SSCore_SndFind2dInst(const char * file);
+SX_LIB_API ID SSCore_SndFind2dInst(const char *szFile);
 
 //! поиск 3d звука (выдающего инстансы) по относительному пути загрузки,возвращает его ID (в случае успеха) иначе <0
-SX_LIB_API ID SSCore_SndFind3dInst(const char * file);
+SX_LIB_API ID SSCore_SndFind3dInst(const char *szFile);
 
 
 //! инициализирован ли звук с идентификатором id
-SX_LIB_API bool SSCore_SndIsInit(ID id);	
+SX_LIB_API bool SSCore_SndIsInit(ID idSound);
 
 //! удалить звук по его id
-SX_LIB_API void SSCore_SndDelete(ID id);	
+SX_LIB_API void SSCore_SndDelete(ID idSound);
 
 
 //! воспроизвести звук, looping зацикливать ли воспроизведение, 0 - нет, >0 да, <0 не учитывать данное значение
-SX_LIB_API void	SSCore_SndPlay(ID id, int looping = -1);	
+SX_LIB_API void	SSCore_SndPlay(ID idSound, int looping = -1);
 
 //! приостановить
-SX_LIB_API void	SSCore_SndPause(ID id);						
+SX_LIB_API void	SSCore_SndPause(ID idSound);
 
 //! остановить
-SX_LIB_API void	SSCore_SndStop(ID id);						
+SX_LIB_API void	SSCore_SndStop(ID idSound);
 
 
 //! устанавливает состояние проигрывания звука
-SX_LIB_API void SSCore_SndStateSet(ID id, SOUND_OBJSTATE state);
+SX_LIB_API void SSCore_SndStateSet(ID idSound, SOUND_OBJSTATE state);
 
 //! возвращает состояние проигрывания звука на данный момент
-SX_LIB_API SOUND_OBJSTATE SSCore_SndStateGet(ID id);
+SX_LIB_API SOUND_OBJSTATE SSCore_SndStateGet(ID idSound);
 
 //! устанавить позицию проигрывания
 SX_LIB_API void SSCore_SndPosCurrSet(
-	ID id,						//!< идентификатор звука
-	DWORD pos,					//!< значение позиции исходя из параметра type
-	int type = SOUND_POS_BYTES	//!< тип значения pos, SOUND_POS_
+	ID idSound,					//!< идентификатор звука
+	UINT uiPos,					//!< значение позиции исходя из параметра type
+	int iType = SOUND_POS_BYTES	//!< тип значения pos, SOUND_POS_
 	);	
 
 //! возвращает позицию проигрывания
-SX_LIB_API DWORD SSCore_SndPosCurrGet(
-	ID id,						//!< идентификатор звука
-	int type = SOUND_POS_BYTES	//!< тип возвращаемого значения, SOUND_POS_
+SX_LIB_API UINT SSCore_SndPosCurrGet(
+	ID idSound,					//!< идентификатор звука
+	int iType = SOUND_POS_BYTES	//!< тип возвращаемого значения, SOUND_POS_
 	);
 
 //! устанавить громкость
 SX_LIB_API void SSCore_SndVolumeSet(
-	ID id,						//!< идентификатор звука
-	long volume,				//!< значение громкости исходя из параметра type
-	int type = SOUND_VOL_PCT	//!< тип значения volume, SOUND_VOL_
+	ID idSound,					//!< идентификатор звука
+	int iVolume,				//!< значение громкости исходя из параметра type
+	int iType = SOUND_VOL_PCT	//!< тип значения volume, SOUND_VOL_
 	);
 
 //! возвращает громкость
-SX_LIB_API long SSCore_SndVolumeGet(
-	ID id,						//!< идентификатор звука
-	int type = SOUND_VOL_PCT	//!< тип возвращаемого значения, SOUND_VOL_
+SX_LIB_API int SSCore_SndVolumeGet(
+	ID idSound,					//!< идентификатор звука
+	int iType = SOUND_VOL_PCT	//!< тип возвращаемого значения, SOUND_VOL_
 	);
 
 //! установка позиционирования между ушами
 SX_LIB_API void SSCore_SndPanSet(
-	ID id,						//!< идентификатор звука
-	long value,					//!< значение позиционирования исходя из параметра type
-	int type = SOUND_VOL_PCT	//!< тип значения value, SOUND_VOL_
+	ID idSound,					//!< идентификатор звука
+	int iValue,					//!< значение позиционирования исходя из параметра type
+	int iType = SOUND_VOL_PCT	//!< тип значения value, SOUND_VOL_
 	);
 
 //! возвращает позиционирование между ушами
-SX_LIB_API long SSCore_SndPanGet(
-	ID id,						//!< идентификатор звука
+SX_LIB_API int SSCore_SndPanGet(
+	ID idSound,						//!< идентификатор звука
 	int type = SOUND_VOL_PCT	//!< тип возвращаемого значения, SOUND_VOL_
 	);
 
 
 //! установка частоты воспроизведения
-SX_LIB_API void SSCore_SndFreqCurrSet(ID id, DWORD value);	
+SX_LIB_API void SSCore_SndFreqCurrSet(ID idSound, UINT uiValue);
 
 //! возвращает текущую частоту воспроизведения
-SX_LIB_API DWORD SSCore_SndFreqCurrGet(ID id);				
+SX_LIB_API UINT SSCore_SndFreqCurrGet(ID idSound);
 
 //! возвращает оригинальную частоту воспроизведения
-SX_LIB_API DWORD SSCore_SndFreqOriginGet(ID id);			
+SX_LIB_API UINT SSCore_SndFreqOriginGet(ID idSound);
 
 
 //! установка мировой позиции звука (только для 3d звуков)
-SX_LIB_API void SSCore_SndPosWSet(ID id, const float3* pos);		
+SX_LIB_API void SSCore_SndPosWSet(ID idSound, const float3 *pPos);
 
 //! возвращает мировую позицию звука (только для 3d звуков)
-SX_LIB_API void SSCore_SndPosWGet(ID id, float3* pos);		
+SX_LIB_API void SSCore_SndPosWGet(ID idSound, float3 *pPos);
 
 
 //! длина в секундах
-SX_LIB_API int SSCore_SndLengthSecGet(ID id);				
+SX_LIB_API int SSCore_SndLengthSecGet(ID idSound);
 
 //! количество байт в секунде
-SX_LIB_API DWORD SSCore_SndBytesPerSecGet(ID id);			
+SX_LIB_API UINT SSCore_SndBytesPerSecGet(ID idSound);
 
 //! размер в байтах PCM данных
-SX_LIB_API DWORD SSCore_SndSizeGet(ID id);					
+SX_LIB_API UINT SSCore_SndSizeGet(ID idSound);
 
 //! относительный путь до звукового файла
-SX_LIB_API void SSCore_SndFileGet(ID id, char* path);		
+SX_LIB_API void SSCore_SndFileGet(ID idSound, char *szPath);		
 
 
 //! возвращает дистанцию слышимости
-SX_LIB_API float SSCore_SndDistAudibleGet(ID id);				
+SX_LIB_API float SSCore_SndDistAudibleGet(ID idSound);
 
 //! установка дистанции слышимости в метрах
-SX_LIB_API void SSCore_SndDistAudibleSet(ID id, float value);	
+SX_LIB_API void SSCore_SndDistAudibleSet(ID idSound, float fVfalue);
 
 //!@}