diff --git a/source/common b/source/common
index 0361e21a0a5ef7f642f7717fdd0f81930e73f309..817245b1612ce3b347067f6f40f915b62652cde4 160000
--- a/source/common
+++ b/source/common
@@ -1 +1 @@
-Subproject commit 0361e21a0a5ef7f642f7717fdd0f81930e73f309
+Subproject commit 817245b1612ce3b347067f6f40f915b62652cde4
diff --git a/source/mtllight/material.cpp b/source/mtllight/material.cpp
index 12342cb54d19ec61d854a1b0f214903aeabf3785..a3598d3c0649db4a221186797cf52462ce717f18 100644
--- a/source/mtllight/material.cpp
+++ b/source/mtllight/material.cpp
@@ -286,7 +286,7 @@ ID Materials::DelRefGetIDArr(ID key, ID inid, int cube)
 	if (!(key >= 0 && key < ArrDelRefMtrls.size()))
 		return -1;
 
-	return ArrDelRefMtrls[key]->GetIDArr(inid, cube);
+	return ArrDelRefMtrls[key]->getIDArr(inid, cube);
 }
 
 void Materials::DelRefAllDel()
@@ -360,7 +360,7 @@ void Materials::OnLostDevice()
 	for (long i = 0; i < ArrMaterials.size(); ++i)
 	{
 		if (ArrMaterials[i] && ArrMaterials[i]->Reflect)
-			ArrMaterials[i]->Reflect->OnLostDevice();
+			ArrMaterials[i]->Reflect->onLostDevice();
 	}
 }
 
@@ -369,7 +369,7 @@ void Materials::OnResetDevice()
 	for (long i = 0; i < ArrMaterials.size(); ++i)
 	{
 		if (ArrMaterials[i] && ArrMaterials[i]->Reflect)
-			ArrMaterials[i]->Reflect->OnResetDevice();
+			ArrMaterials[i]->Reflect->onResetDevice();
 	}
 }
 
@@ -432,13 +432,13 @@ MTLTYPE_REFLECT Materials::MtlTypeReflection(ID id)
 void Materials::MtlRefSetIDArr(ID id, ID inid, int cube, ID idarr)
 {
 	MTL_REF_PRE_COND_ID(id, _VOID);
-	ArrMaterials[id]->Reflect->SetIDArr(inid, cube, idarr);
+	ArrMaterials[id]->Reflect->setIDArr(inid, cube, idarr);
 }
 
 ID Materials::MtlRefGetIDArr(ID id, ID inid, int cube)
 {
 	MTL_REF_PRE_COND_ID(id,- 1);
-	return ArrMaterials[id]->Reflect->GetIDArr(inid, cube);
+	return ArrMaterials[id]->Reflect->getIDArr(inid, cube);
 }
 
 /*void Materials::MtlRefSetPlane(ID id, D3DXPLANE* plane)
@@ -456,41 +456,41 @@ ID Materials::MtlRefGetIDArr(ID id, ID inid, int cube)
 void Materials::MtlRefPreRenderPlane(ID id, D3DXPLANE* plane)
 {
 	MTL_REF_PRE_COND_ID(id, _VOID);
-	ArrMaterials[id]->Reflect->PreRenderRefPlane(plane);
+	ArrMaterials[id]->Reflect->preRenderRefPlane(plane);
 }
 
-ISXFrustum* Materials::MtlRefGetfrustum(ID id, int cube)
+const ISXFrustum* Materials::MtlRefGetfrustum(ID id, int cube)
 {
 	MTL_REF_PRE_COND_ID(id, 0);
-	if (cube == 0 || (cube > 0 && (ArrMaterials[id]->Reflect->GetTypeReflect() == MTLTYPE_REFLECT_CUBE_STATIC || ArrMaterials[id]->Reflect->GetTypeReflect() == MTLTYPE_REFLECT_CUBE_DYNAMIC)))
-		return ArrMaterials[id]->Reflect->ReflectFrustum[cube];
+	if (cube == 0 || (cube > 0 && (ArrMaterials[id]->Reflect->getTypeReflect() == MTLTYPE_REFLECT_CUBE_STATIC || ArrMaterials[id]->Reflect->getTypeReflect() == MTLTYPE_REFLECT_CUBE_DYNAMIC)))
+		return ArrMaterials[id]->Reflect->getFrustum(cube);
 	return 0;
 }
 
 void Materials::MtlRefPostRenderPlane(ID id)
 {
 	MTL_REF_PRE_COND_ID(id, _VOID);
-	ArrMaterials[id]->Reflect->PostRenderRefPlane();
+	ArrMaterials[id]->Reflect->postRenderRefPlane();
 }
 
 IDirect3DTexture9* Materials::MtlRefPlaneGetTex(ID id)
 {
  	MTL_REF_PRE_COND_ID(id, 0);
-	return ArrMaterials[id]->Reflect->GetRefPlaneTex();
+	return ArrMaterials[id]->Reflect->getRefPlaneTex();
 }
 
 
 void Materials::MtlRefSetMinMax(ID id, float3_t* min, float3_t* max)
 {
 	MTL_REF_PRE_COND_ID(id, _VOID);
-	ArrMaterials[id]->Reflect->SetMinMax(min,max);
+	ArrMaterials[id]->Reflect->setMinMax(min,max);
 }
 
 bool Materials::MtlRefIsAllowedRender(ID  id)
 {
 	MTL_REF_PRE_COND_ID(id, false);
 	if (ArrMaterials[id]->Reflect)
-		return ArrMaterials[id]->Reflect->AllowedRender();
+		return ArrMaterials[id]->Reflect->allowedRender();
 
 	return false;
 }
@@ -499,43 +499,43 @@ bool Materials::MtlRefIsAllowedRender(ID  id)
 void Materials::MtlRefCubeBeginRender(ID id, float3_t* center)
 {
 	MTL_REF_PRE_COND_ID(id, _VOID);
-	ArrMaterials[id]->Reflect->BeginRenderRefCube(center);
+	ArrMaterials[id]->Reflect->beginRenderRefCube(center);
 }
 
 void Materials::MtlRefCubePreRender(ID id, int cube, float4x4* world)
 {
 	MTL_REF_PRE_COND_ID(id, _VOID);
-	ArrMaterials[id]->Reflect->PreRenderRefCube(cube, world);
+	ArrMaterials[id]->Reflect->preRenderRefCube(cube, world);
 }
 
 void Materials::MtlRefCubePostRender(ID id, int cube)
 {
 	MTL_REF_PRE_COND_ID(id, _VOID);
-	ArrMaterials[id]->Reflect->PostRenderRefCube(cube);
+	ArrMaterials[id]->Reflect->postRenderRefCube(cube);
 }
 
 void Materials::MtlRefCubeEndRender(ID id, float3_t* viewpos)
 {
 	MTL_REF_PRE_COND_ID(id, _VOID);
-	ArrMaterials[id]->Reflect->EndRenderRefCube(viewpos);
+	ArrMaterials[id]->Reflect->endRenderRefCube(viewpos);
 }
 
 bool Materials::MtlRefUpdateCountUpdate( ID id, float3_t* viewpos)
 {
 	MTL_REF_PRE_COND_ID(id, false);
-	return ArrMaterials[id]->Reflect->UpdateCountUpdate(viewpos);
+	return ArrMaterials[id]->Reflect->updateCountUpdate(viewpos);
 }
 
 void Materials::MtlRefNullingCountUpdate(ID id)
 {
 	MTL_REF_PRE_COND_ID(id, _VOID);
-	ArrMaterials[id]->Reflect->NullingCountUpdate();
+	ArrMaterials[id]->Reflect->nullingCountUpdate();
 }
 
 IDirect3DCubeTexture9* Materials::RefCubeGetTex(ID id)
 {
 	MTL_REF_PRE_COND_ID(id, 0);
-	return ArrMaterials[id]->Reflect->GetRefCubeTex();
+	return ArrMaterials[id]->Reflect->getRefCubeTex();
 }
 
 
@@ -745,9 +745,9 @@ void Materials::MtlSetTypeReflection(ID id, MTLTYPE_REFLECT type)
 	if (ArrMaterials[id]->mtl->LightParam.TypeReflect != MTLTYPE_REFLECT_NONE)
 	{
 		if (!ArrMaterials[id]->Reflect)
-			ArrMaterials[id]->Reflect = new Reflection();
+			ArrMaterials[id]->Reflect = new CReflection();
 
-		ArrMaterials[id]->Reflect->Init(ArrMaterials[id]->mtl->LightParam.TypeReflect);
+		ArrMaterials[id]->Reflect->init(ArrMaterials[id]->mtl->LightParam.TypeReflect);
 	}
 }
 
@@ -1549,8 +1549,8 @@ ID Materials::MtlLoad(const char* name, MTLTYPE_MODEL type)
 
 		if (ArrMaterials[IsLoad]->Reflect){
 			UnitMaterial* tmpmtl = ArrMaterials[IsLoad];
-			tmpumtl->Reflect = new Reflection();
-			tmpumtl->Reflect->Init(ArrMaterials[IsLoad]->Reflect->TypeRef);
+			tmpumtl->Reflect = new CReflection();
+			tmpumtl->Reflect->init(ArrMaterials[IsLoad]->Reflect->getTypeReflect());
 		}
 
 		return AddUnitMaterial(tmpumtl);
@@ -1568,8 +1568,8 @@ ID Materials::MtlLoad(const char* name, MTLTYPE_MODEL type)
 		{
 			if (tmpumtl->mtl->LightParam.TypeReflect != MTLTYPE_REFLECT_NONE)
 			{
-				tmpumtl->Reflect = new Reflection();
-				tmpumtl->Reflect->Init(tmpumtl->mtl->LightParam.TypeReflect);
+				tmpumtl->Reflect = new CReflection();
+				tmpumtl->Reflect->init(tmpumtl->mtl->LightParam.TypeReflect);
 			}
 		}
 
@@ -1599,8 +1599,8 @@ void Materials::MtlReLoad(ID id, const char* name)
 	{
 		if (tmpumtl->mtl->LightParam.TypeReflect != MTLTYPE_REFLECT_NONE)
 		{
-			tmpumtl->Reflect = new Reflection();
-			tmpumtl->Reflect->Init(tmpumtl->mtl->LightParam.TypeReflect);
+			tmpumtl->Reflect = new CReflection();
+			tmpumtl->Reflect->init(tmpumtl->mtl->LightParam.TypeReflect);
 		}
 	}
 }
@@ -1955,10 +1955,10 @@ void Materials::Render(ID id, float4x4* world)
 		MLSet::DXDevice->SetTexture(MTL_TEX_R_REFLECTION, 0);
 	else
 	{
-		if (ArrMaterials[id]->Reflect->TypeRef == MTLTYPE_REFLECT_PLANE)
-			MLSet::DXDevice->SetTexture(MTL_TEX_R_REFLECTION, ArrMaterials[id]->Reflect->GetRefPlaneTex());
-		else if (ArrMaterials[id]->Reflect->TypeRef == MTLTYPE_REFLECT_CUBE_STATIC || ArrMaterials[id]->Reflect->TypeRef == MTLTYPE_REFLECT_CUBE_DYNAMIC)
-			MLSet::DXDevice->SetTexture(MTL_TEX_R_REFLECTION, ArrMaterials[id]->Reflect->GetRefCubeTex());
+		if (ArrMaterials[id]->Reflect->getTypeReflect() == MTLTYPE_REFLECT_PLANE)
+			MLSet::DXDevice->SetTexture(MTL_TEX_R_REFLECTION, ArrMaterials[id]->Reflect->getRefPlaneTex());
+		else if (ArrMaterials[id]->Reflect->getTypeReflect() == MTLTYPE_REFLECT_CUBE_STATIC || ArrMaterials[id]->Reflect->getTypeReflect() == MTLTYPE_REFLECT_CUBE_DYNAMIC)
+			MLSet::DXDevice->SetTexture(MTL_TEX_R_REFLECTION, ArrMaterials[id]->Reflect->getRefCubeTex());
 	}
 
 	MLSet::DXDevice->SetTexture(MTL_TEX_R_CURR_DEPTH, SGCore_RTGetTexture(MLSet::IDsRenderTargets::DepthScene0));
diff --git a/source/mtllight/material.h b/source/mtllight/material.h
index dba510a0e091903127c1b336c5969cba4016c1ab..65a5f56277dd809bce1e48ba3d6bb09898b3c203 100644
--- a/source/mtllight/material.h
+++ b/source/mtllight/material.h
@@ -77,7 +77,7 @@ public:
 	//void MtlRefSetPlane(ID id, D3DXPLANE* plane);
 	//void MtlRefSetCenter(ID id, float3_t* center);
 	void MtlRefPreRenderPlane(ID id, D3DXPLANE* plane);
-	ISXFrustum* MtlRefGetfrustum(ID id, int cube);
+	const ISXFrustum* MtlRefGetfrustum(ID id, int cube);
 	void MtlRefPostRenderPlane(ID id);
 	IDirect3DTexture9* MtlRefPlaneGetTex(ID id);
 
@@ -270,7 +270,7 @@ public:
 		~UnitMaterial();
 
 		Material* mtl;
-		Reflection* Reflect;
+		CReflection* Reflect;
 	};
 
 protected:
@@ -306,7 +306,7 @@ protected:
 
 	Array<UnitMaterial*> ArrMaterials;
 	Array<Material*> ArrMtrls;
-	Array<Reflection*> ArrDelRefMtrls;
+	Array<CReflection*> ArrDelRefMtrls;
 
 	bool IsIncrCountSurf;
 	int CurrIdSurf;
diff --git a/source/mtllight/reflection.cpp b/source/mtllight/reflection.cpp
index 1001b0bb0c64f9b515f5c043171045bea4fd016f..8e8d4fa9a3112a9319b5862a3b7a4c9e62beb9a9 100644
--- a/source/mtllight/reflection.cpp
+++ b/source/mtllight/reflection.cpp
@@ -6,178 +6,217 @@ See the license in LICENSE
 
 #include "reflection.h"
 
-Reflection::Reflection()
+CReflection::CReflection()
 {
-	IsComNow = true;
-	SurfaceReflect = 0;
-	TextureReflect = 0;
-	TextureCubeReflect = 0;
-	SurfaceZBuffer = 0;
-	BackBuffer = 0;
-	LastSurfaceZBuffer = 0;
-	ZNear = 0.0f;
-	CountUpdate = 0;
+	m_pSurface = 0;
+	m_pTexPlaneRef = 0;
+	m_pTexCubeRef = 0;
+	m_pBackBuffer = 0;
+	m_iCountUpdate = 0;
 
 	for (int i = 0; i < 6; ++i)
 	{
-		//IDArr[i] = -1;
-		ReflectFrustum[i] = 0;
-		CubeReflectSurface[i] = 0;
+		m_aFrustums[i] = 0;
 	}
 }
 
-Reflection::~Reflection()
+CReflection::~CReflection()
 {
 	for (int i = 0; i < 6; ++i)
 	{
-		mem_release_del(ReflectFrustum[i]);
+		mem_release_del(m_aFrustums[i]);
 	}
 
-	mem_release_del(BackBuffer);
-	mem_release_del(SurfaceZBuffer);
-	mem_release_del(LastSurfaceZBuffer);
-	mem_release_del(TextureReflect);
-	mem_release_del(SurfaceReflect);
+	mem_release_del(m_pBackBuffer);
+	mem_release_del(m_pTexPlaneRef);
+	mem_release_del(m_pSurface);
 
-	for (int i = 0; i < 6; i++)
-	{
-		mem_release_del(CubeReflectSurface[i]);
-	}
-
-	mem_release_del(TextureCubeReflect);
+	mem_release_del(m_pTexCubeRef);
 }
 
-void Reflection::SetIDArr(ID id, int cube, ID idarr)
+void CReflection::setIDArr(ID id, ID idFace, ID idArr)
 {
-	if (!(cube >= 0 && cube < 6))
+	if (!(idFace >= 0 && idFace < 6))
 		return;
 
-	if (id >= IDArr.size())
+	if (id >= m_aIDsArr.size())
 	{
 		ID* tmparr = new ID[6];
 		for (int i = 0; i < 6; ++i)
 			tmparr[i] = -1;
-		IDArr[id] = tmparr;
+		m_aIDsArr[id] = tmparr;
 	}
 
-	IDArr[id][cube] = idarr;
+	m_aIDsArr[id][idFace] = idArr;
 }
 
-int Reflection::GetCountIDArrs()
+int CReflection::getCountIDArrs()
 {
-	return IDArr.size();
+	return m_aIDsArr.size();
 }
 
-ID Reflection::GetIDArr(ID id, int cube)
+ID CReflection::getIDArr(ID id, ID idFace)
 {
-	if (!(cube >= 0 && cube < 6))
+	if (!(idFace >= 0 && idFace < 6))
 		return -1;
 
-	if (id < 0 || !(cube >= 0 && cube < 6) || !(id < IDArr.size()))
+	if (id < 0 || !(idFace >= 0 && idFace < 6) || !(id < m_aIDsArr.size()))
 		return -2;
 
-	return IDArr[id][cube];
+	return m_aIDsArr[id][idFace];
 }
 
-void Reflection::OnLostDevice()
+void CReflection::onLostDevice()
 {
-	mem_release_del(TextureReflect);
-	mem_release_del(TextureCubeReflect);
-	mem_release_del(SurfaceZBuffer);
-
-	mem_release_del(SurfaceReflect);
-
-	mem_release_del(CubeReflectSurface[0]);
-	mem_release_del(CubeReflectSurface[1]);
-	mem_release_del(CubeReflectSurface[2]);
-	mem_release_del(CubeReflectSurface[3]);
-	mem_release_del(CubeReflectSurface[4]);
-	mem_release_del(CubeReflectSurface[5]);
+	mem_release_del(m_pTexWork);
+	mem_release_del(m_pTexPlaneRef);
+	mem_release_del(m_pTexCubeRef);
+
+	mem_release_del(m_pSurface);
 }
 
-void Reflection::OnResetDevice()
+void CReflection::onResetDevice()
 {
-	if (TypeRef == MTLTYPE_REFLECT_PLANE)
+	D3DXCreateTexture(MLSet::DXDevice, MLSet::SizeTexReflection.x, MLSet::SizeTexReflection.y, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &m_pTexWork);
+
+	if (type_reflection == MTLTYPE_REFLECT_PLANE)
 	{
-		D3DXCreateTexture(MLSet::DXDevice, MLSet::SizeTexReflection.x, MLSet::SizeTexReflection.y, 0, D3DUSAGE_RENDERTARGET | D3DUSAGE_AUTOGENMIPMAP, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &TextureReflect);
-		MLSet::DXDevice->CreateDepthStencilSurface(MLSet::SizeTexReflection.x, MLSet::SizeTexReflection.y, D3DFMT_D24S8, D3DMULTISAMPLE_NONE, 0, TRUE, &SurfaceZBuffer, NULL);
+		D3DXCreateTexture(MLSet::DXDevice, MLSet::SizeTexReflection.x, MLSet::SizeTexReflection.y, 0, D3DUSAGE_RENDERTARGET | D3DUSAGE_AUTOGENMIPMAP, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &m_pTexPlaneRef);
 	}
-	else if (TypeRef == MTLTYPE_REFLECT_CUBE_STATIC || TypeRef == MTLTYPE_REFLECT_CUBE_DYNAMIC)
+	else if (type_reflection == MTLTYPE_REFLECT_CUBE_STATIC || type_reflection == MTLTYPE_REFLECT_CUBE_DYNAMIC)
 	{
-		D3DXCreateTexture(MLSet::DXDevice, MLSet::SizeTexReflection.x, MLSet::SizeTexReflection.x, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &TextureReflect);
-		D3DXCreateCubeTexture(MLSet::DXDevice, MLSet::SizeTexReflection.x, 0, D3DUSAGE_RENDERTARGET | D3DUSAGE_AUTOGENMIPMAP, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &TextureCubeReflect);
-		//MLSet::DXDevice->CreateCubeTexture(MLSet::SizeTexReflection.x, 0, D3DUSAGE_RENDERTARGET | D3DUSAGE_AUTOGENMIPMAP, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &TextureCubeReflect, NULL);
-		MLSet::DXDevice->CreateDepthStencilSurface(MLSet::SizeTexReflection.x, MLSet::SizeTexReflection.x, D3DFMT_D24S8, D3DMULTISAMPLE_NONE, 0, TRUE, &SurfaceZBuffer, NULL);
-		//TextureCubeReflect->SetAutoGenFilterType(D3DTEXF_LINEAR);
+		D3DXCreateCubeTexture(MLSet::DXDevice, MLSet::SizeTexReflection.x, 0, D3DUSAGE_RENDERTARGET | D3DUSAGE_AUTOGENMIPMAP, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &m_pTexCubeRef);
+		m_pTexCubeRef->SetAutoGenFilterType(D3DTEXF_LINEAR);
 	}
 
-	CountUpdate = 0;
+	m_iCountUpdate = 0;
 }
 
-void Reflection::Init(MTLTYPE_REFLECT howref)
+void CReflection::init(MTLTYPE_REFLECT howref)
 {
-	TypeRef = howref;
-	if (TypeRef == MTLTYPE_REFLECT_PLANE)
-	{
-		if (!ReflectFrustum[0])
-			ReflectFrustum[0] = SGCore_CrFrustum();
+	type_reflection = howref;
 
-		if (!TextureReflect)
-			D3DXCreateTexture(MLSet::DXDevice, MLSet::SizeTexReflection.x, MLSet::SizeTexReflection.y, 0, D3DUSAGE_RENDERTARGET | D3DUSAGE_AUTOGENMIPMAP, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &TextureReflect);
+	D3DXCreateTexture(MLSet::DXDevice, MLSet::SizeTexReflection.x, MLSet::SizeTexReflection.y, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &m_pTexWork);
 
-		if (!SurfaceZBuffer)
-			MLSet::DXDevice->CreateDepthStencilSurface(MLSet::SizeTexReflection.x, MLSet::SizeTexReflection.y, D3DFMT_D24S8, D3DMULTISAMPLE_NONE, 0, TRUE, &SurfaceZBuffer, NULL);
-	
+	if (type_reflection == MTLTYPE_REFLECT_PLANE)
+	{
+		if (!m_aFrustums[0])
+			m_aFrustums[0] = SGCore_CrFrustum();
+
+		if (!m_pTexPlaneRef)
+			D3DXCreateTexture(MLSet::DXDevice, MLSet::SizeTexReflection.x, MLSet::SizeTexReflection.y, 0, D3DUSAGE_RENDERTARGET | D3DUSAGE_AUTOGENMIPMAP, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &m_pTexPlaneRef);
 	}
-	else if (TypeRef == MTLTYPE_REFLECT_CUBE_STATIC || TypeRef == MTLTYPE_REFLECT_CUBE_DYNAMIC)
+	else if (type_reflection == MTLTYPE_REFLECT_CUBE_STATIC || type_reflection == MTLTYPE_REFLECT_CUBE_DYNAMIC)
 	{
 		for (int i = 0; i < 6; ++i)
 		{
-			if (!ReflectFrustum[i])
-				ReflectFrustum[i] = SGCore_CrFrustum();
+			if (!m_aFrustums[i])
+				m_aFrustums[i] = SGCore_CrFrustum();
 		}
 
-		D3DXCreateTexture(MLSet::DXDevice, MLSet::SizeTexReflection.x, MLSet::SizeTexReflection.x, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &TextureReflect);
-
-		if (!TextureCubeReflect)
-			D3DXCreateCubeTexture(MLSet::DXDevice, MLSet::SizeTexReflection.x, 0, D3DUSAGE_RENDERTARGET | D3DUSAGE_AUTOGENMIPMAP, D3DFMT_R5G6B5, D3DPOOL_DEFAULT, &TextureCubeReflect);
-			//MLSet::DXDevice->CreateCubeTexture(MLSet::SizeTexReflection.x, 0, D3DUSAGE_RENDERTARGET | D3DUSAGE_AUTOGENMIPMAP, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &TextureCubeReflect, NULL);
-		
-		if (!SurfaceZBuffer)
-			MLSet::DXDevice->CreateDepthStencilSurface(MLSet::SizeTexReflection.x, MLSet::SizeTexReflection.x, D3DFMT_D24S8, D3DMULTISAMPLE_NONE, 0, TRUE, &SurfaceZBuffer, NULL);
-	
+		if (!m_pTexCubeRef)
+			D3DXCreateCubeTexture(MLSet::DXDevice, MLSet::SizeTexReflection.x, 0, D3DUSAGE_RENDERTARGET | D3DUSAGE_AUTOGENMIPMAP, D3DFMT_R5G6B5, D3DPOOL_DEFAULT, &m_pTexCubeRef);
 	}
 	else
 	{
 
 	}
-	
 
-	CubeReflectSurface[0] = 0;
-	CubeReflectSurface[1] = 0;
-	CubeReflectSurface[2] = 0;
-	CubeReflectSurface[3] = 0;
-	CubeReflectSurface[4] = 0;
-	CubeReflectSurface[5] = 0;
+	m_iCountUpdate = 0;
+}
+
+MTLTYPE_REFLECT CReflection::getTypeReflect()
+{ 
+	return type_reflection; 
+}
+
+const ISXFrustum* CReflection::getFrustum(ID id)
+{ 
+	return m_aFrustums[id]; 
+}
+
+bool CReflection::updateCountUpdate(const float3_t* viewpos)
+{
+	if (!viewpos)
+		return false;
+
+	if (type_reflection == MTLTYPE_REFLECT_CUBE_STATIC)
+	{
+		if (m_iCountUpdate < MTL_REF_UPDATE_MAX_COUNT_FOR_STATIC)
+		{
+			++(m_iCountUpdate);
+			return true;
+		}
+		else
+			return false;
+	}
+
+	float dist = SMVector3Distance(m_vPosition, (*viewpos)) - SMVector3Length((m_vMin - m_vMax) *0.5f);
+	if (dist < MTL_REF_UPDATE_L0_DIST)
+		m_iCountUpdate = -1;
+	else if (dist < MTL_REF_UPDATE_L1_DIST && dist > MTL_REF_UPDATE_L0_DIST)
+	{
+		if (m_iCountUpdate > 1)
+			m_iCountUpdate = -1;
+	}
+	else if (dist < MTL_REF_UPDATE_L2_DIST && dist > MTL_REF_UPDATE_L1_DIST)
+	{
+		if (m_iCountUpdate > 2)
+			m_iCountUpdate = -1;
+	}
+	else if (dist > MTL_REF_UPDATE_L2_DIST)
+	{
+		m_iCountUpdate = 4;
+	}
+
+	++m_iCountUpdate;
 
-	CountUpdate = 0;
+	return (m_iCountUpdate == 0);
 }
 
-void Reflection::PreRenderRefPlane(D3DXPLANE* plane)
+bool CReflection::allowedRender()
+{
+	if (type_reflection == MTLTYPE_REFLECT_CUBE_STATIC)
+	{
+		if (m_iCountUpdate <= MTL_REF_UPDATE_MAX_COUNT_FOR_STATIC)
+		{
+			++(m_iCountUpdate);
+			return true;
+		}
+		else
+			return false;
+	}
+
+	return (m_iCountUpdate == 0);
+}
+
+void CReflection::nullingCountUpdate()
+{
+	m_iCountUpdate = 0;
+}
+
+IDirect3DCubeTexture9* CReflection::getRefCubeTex()
+{
+	return m_pTexCubeRef;
+}
+
+//##########################################################################
+
+void CReflection::preRenderRefPlane(const D3DXPLANE* plane)
 {
 	if (!plane)
 	{
-		LibReport(REPORT_MSG_LEVEL_WARNING, "%s - sxmtllight [reflection]: plane is NULL", GEN_MSG_LOCATION);
+		LibReport(REPORT_MSG_LEVEL_WARNING, "%s - [reflection]: plane is NULL", GEN_MSG_LOCATION);
 		return;
 	}
 
-	Plane = *plane;
+	//m_oPlane = *plane;
 
 	float4x4 viewmat;
 	Core_RMatrixGet(G_RI_MATRIX_VIEW, &viewmat);
 
 	D3DXMATRIX matReflect, matView;
-	D3DXMatrixReflect(&matReflect, &Plane);
+	D3DXMatrixReflect(&matReflect, plane);
 	
 	viewmat = float4x4(matReflect) * viewmat;
 	viewmat._12 = -viewmat._12;
@@ -185,114 +224,140 @@ void Reflection::PreRenderRefPlane(D3DXPLANE* plane)
 	viewmat._32 = -viewmat._32;
 	viewmat._42 = -viewmat._42;
 
-	ReflectFrustum[0]->update(&viewmat, &(MLSet::RefMProjPlane));
+	m_aFrustums[0]->update(&viewmat, &(MLSet::RefMProjPlane));
 
-	Core_RMatrixGet(G_RI_MATRIX_VIEW, &OldMatView);
-	Core_RMatrixGet(G_RI_MATRIX_PROJECTION, &OldMatProj);
-	Core_RMatrixGet(G_RI_MATRIX_VIEWPROJ, &OldMatViewProj);
+	Core_RMatrixGet(G_RI_MATRIX_VIEW, &m_mOldMatView);
+	Core_RMatrixGet(G_RI_MATRIX_PROJECTION, &m_mOldMatProj);
+	Core_RMatrixGet(G_RI_MATRIX_VIEWPROJ, &m_mOldMatViewProj);
 
 	Core_RMatrixSet(G_RI_MATRIX_VIEW, &viewmat);
 	Core_RMatrixSet(G_RI_MATRIX_PROJECTION, &MLSet::RefMProjPlane);
 	Core_RMatrixSet(G_RI_MATRIX_VIEWPROJ, &(viewmat * MLSet::RefMProjPlane));
 
-	MLSet::DXDevice->GetRenderTarget(0, &BackBuffer);
+	MLSet::DXDevice->GetRenderTarget(0, &m_pBackBuffer);
 
-	mem_release_del(SurfaceReflect);
-	TextureReflect->GetSurfaceLevel(0, &SurfaceReflect);
-	MLSet::DXDevice->SetRenderTarget(0, SurfaceReflect);
-	//MLSet::DXDevice->GetDepthStencilSurface(&LastSurfaceZBuffer);
-	//MLSet::DXDevice->SetDepthStencilSurface(SurfaceZBuffer);
+	mem_release_del(m_pSurface);
+	m_pTexWork->GetSurfaceLevel(0, &m_pSurface);
+	MLSet::DXDevice->SetRenderTarget(0, m_pSurface);
 	MLSet::DXDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_ARGB(0, 0, 0, 0), 1.0f, 0L);
 }
 
-void Reflection::PostRenderRefPlane()
+void CReflection::postRenderRefPlane()
 {
-	Core_RMatrixSet(G_RI_MATRIX_VIEW, &OldMatView);
-	Core_RMatrixSet(G_RI_MATRIX_PROJECTION, &OldMatProj);
-	Core_RMatrixSet(G_RI_MATRIX_VIEWPROJ, &OldMatViewProj);
+	Core_RMatrixSet(G_RI_MATRIX_VIEW, &m_mOldMatView);
+	Core_RMatrixSet(G_RI_MATRIX_PROJECTION, &m_mOldMatProj);
+	Core_RMatrixSet(G_RI_MATRIX_VIEWPROJ, &m_mOldMatViewProj);
+
+	mem_release_del(m_pSurface);
 
-	MLSet::DXDevice->SetRenderTarget(0, BackBuffer);
-	//MLSet::DXDevice->SetDepthStencilSurface(LastSurfaceZBuffer);
+	DWORD alphablend, alphatest, zenable, zwriteenable;
 
-	mem_release_del(BackBuffer);
-	mem_release_del(LastSurfaceZBuffer);
-	mem_release_del(SurfaceReflect);
+	MLSet::DXDevice->GetRenderState(D3DRS_ALPHABLENDENABLE, &alphablend);
+	MLSet::DXDevice->GetRenderState(D3DRS_ALPHATESTENABLE, &alphatest);
+	MLSet::DXDevice->GetRenderState(D3DRS_ZENABLE, &zenable);
+	MLSet::DXDevice->GetRenderState(D3DRS_ZWRITEENABLE, &zwriteenable);
 
-	if (GetAsyncKeyState(VK_NUMPAD9))
+	MLSet::DXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
+	MLSet::DXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);
+	MLSet::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
+	MLSet::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE);
+
+	m_pTexPlaneRef->GetSurfaceLevel(0, &m_pSurface);
+	MLSet::DXDevice->SetRenderTarget(0, m_pSurface);
+
+	SGCore_ShaderBind(SHADER_TYPE_VERTEX, MLSet::IDsShaders::VS::ScreenOut);
+	SGCore_ShaderBind(SHADER_TYPE_PIXEL, MLSet::IDsShaders::PS::ScreenOut);
+
+	MLSet::DXDevice->SetTexture(0, m_pTexWork);
+	SGCore_ScreenQuadDraw();
+
+	SGCore_ShaderUnBind();
+
+	MLSet::DXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, alphablend);
+	MLSet::DXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, alphatest);
+	MLSet::DXDevice->SetRenderState(D3DRS_ZENABLE, zenable);
+	MLSet::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, zwriteenable);
+
+	mem_release_del(m_pSurface);
+
+	MLSet::DXDevice->SetRenderTarget(0, m_pBackBuffer);
+	mem_release_del(m_pBackBuffer);
+
+	/*if (GetAsyncKeyState(VK_NUMPAD9))
 	{
 		char tmpstr[256];
 		sprintf(tmpstr, "C:\\1\\reflectionreflection.png");
-		D3DXSaveSurfaceToFile(tmpstr, D3DXIFF_PNG, SurfaceReflect, NULL, 0);
-	}
+		D3DXSaveTextureToFile(tmpstr, D3DXIFF_JPG, m_pTexPlaneRef, NULL);
+	}*/
+
+	//m_pTexPlaneRef->GenerateMipSubLevels();
 }
 
-IDirect3DTexture9* Reflection::GetRefPlaneTex()
+IDirect3DTexture9* CReflection::getRefPlaneTex()
 {
-	return TextureReflect;
+	return m_pTexPlaneRef;
 }
 
-////////////////////////
+//**************************************************************************
 
-void Reflection::SetMinMax(float3_t* min, float3_t* max)
+void CReflection::setMinMax(const float3_t *pMin, const float3_t *pMax)
 {
 	//если новые размеры отличаются от старых значит надо обновить отражения, если они были статические
-	if (PosMax.x != max->x || PosMax.y != max->y || PosMax.z != max->z || PosMin.x != min->x || PosMin.y != min->y || PosMin.z != min->z)
-		CountUpdate = 0;
+	if (m_vMin.x != pMax->x || m_vMin.y != pMax->y || m_vMin.z != pMax->z || m_vMax.x != pMin->x || m_vMax.y != pMin->y || m_vMax.z != pMin->z)
+		m_iCountUpdate = 0;
 
-	PosMax = *max;
-	PosMin = *min;
+	m_vMin = *pMax;
+	m_vMax = *pMin;
 }
 
-void Reflection::BeginRenderRefCube(float3_t* center)
+void CReflection::beginRenderRefCube(const float3_t* pCenter)
 {
-	if (!center)
+	if (!pCenter)
 	{
-		LibReport(REPORT_MSG_LEVEL_WARNING, "%s - sxmtllight [reflection]: position center is NULL", GEN_MSG_LOCATION);
+		LibReport(REPORT_MSG_LEVEL_WARNING, "%s - [reflection]: position center is NULL", GEN_MSG_LOCATION);
 		return;
 	}
 
-	Position = *center;
-	Core_RMatrixGet(G_RI_MATRIX_VIEW, &OldMatView);
-	Core_RMatrixGet(G_RI_MATRIX_PROJECTION, &OldMatProj);
-	Core_RMatrixGet(G_RI_MATRIX_VIEWPROJ, &OldMatViewProj);
+	m_vPosition = *pCenter;
+	Core_RMatrixGet(G_RI_MATRIX_VIEW, &m_mOldMatView);
+	Core_RMatrixGet(G_RI_MATRIX_PROJECTION, &m_mOldMatProj);
+	Core_RMatrixGet(G_RI_MATRIX_VIEWPROJ, &m_mOldMatViewProj);
 
-	MLSet::DXDevice->GetRenderTarget(0, &BackBuffer);
-	//MLSet::DXDevice->GetDepthStencilSurface(&LastSurfaceZBuffer);
-	//MLSet::DXDevice->SetDepthStencilSurface(SurfaceZBuffer);
+	MLSet::DXDevice->GetRenderTarget(0, &m_pBackBuffer);
 }
 
-void Reflection::PreRenderRefCube(int cube, float4x4* world)
+void CReflection::preRenderRefCube(ID idFace, const float4x4 *pWorld)
 {
 	//MLSet::DXDevice->SetTransform(D3DTS_PROJECTION, &((D3DXMATRIX)MLSet::RefMProjCube));
 
-	PositionReflect = SMVector3Transform(Position, *world);
+	if (pWorld)
+		m_vPosition = SMVector3Transform(m_vPosition, *pWorld);
 
-	MatrixView = SMMatrixLookAtLH(
-		PositionReflect,
-		((MLSet::OrientedCube[cube] + PositionReflect)),
-		MLSet::UpVectorsCube[cube]);
+	m_mView = SMMatrixLookAtLH(
+		m_vPosition,
+		((MLSet::OrientedCube[idFace] + m_vPosition)),
+		MLSet::UpVectorsCube[idFace]);
 
-	/*MLSet::DXDevice->SetTransform(D3DTS_VIEW, &MatrixView.operator D3DXMATRIX());
+	/*MLSet::DXDevice->SetTransform(D3DTS_VIEW, &m_mView.operator D3DXMATRIX());
 
-	MLSet::DXDevice->SetTransform(D3DTS_WORLD1, &((D3DXMATRIX)(MatrixView * MLSet::RefMProjCube)));*/
+	MLSet::DXDevice->SetTransform(D3DTS_WORLD1, &((D3DXMATRIX)(m_mView * MLSet::RefMProjCube)));*/
 
-	Core_RMatrixSet(G_RI_MATRIX_VIEW, &MatrixView);
+	Core_RMatrixSet(G_RI_MATRIX_VIEW, &m_mView);
 	Core_RMatrixSet(G_RI_MATRIX_PROJECTION, &MLSet::RefMProjCube);
-	Core_RMatrixSet(G_RI_MATRIX_VIEWPROJ, &(MatrixView * MLSet::RefMProjCube));
+	Core_RMatrixSet(G_RI_MATRIX_VIEWPROJ, &(m_mView * MLSet::RefMProjCube));
 
-	ReflectFrustum[cube]->update(&float4x4(MatrixView), &MLSet::RefMProjCube);
+	m_aFrustums[idFace]->update(&float4x4(m_mView), &MLSet::RefMProjCube);
 
-	mem_release_del(SurfaceReflect);
-	TextureReflect->GetSurfaceLevel(0, &SurfaceReflect);
-	MLSet::DXDevice->SetRenderTarget(0, SurfaceReflect);
+	mem_release_del(m_pSurface);
+	m_pTexWork->GetSurfaceLevel(0, &m_pSurface);
+	MLSet::DXDevice->SetRenderTarget(0, m_pSurface);
 
 	MLSet::DXDevice->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_ARGB(0, 0, 0, 0), 1, 0);
 }
 
-void Reflection::PostRenderRefCube(int cube)
+void CReflection::postRenderRefCube(ID idFace)
 {
-	mem_release_del(CubeReflectSurface[cube]);
-	mem_release(SurfaceReflect);
+	mem_release(m_pSurface);
 
 	DWORD alphablend, alphatest, zenable, zwriteenable;
 
@@ -306,14 +371,13 @@ void Reflection::PostRenderRefCube(int cube)
 	MLSet::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
 	MLSet::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE);
 
-	TextureCubeReflect->GetCubeMapSurface((D3DCUBEMAP_FACES)cube, 0, &CubeReflectSurface[cube]);
-	MLSet::DXDevice->SetRenderTarget(0, CubeReflectSurface[cube]);
-	//MLSet::DXDevice->Clear(0, 0, D3DCLEAR_TARGET, D3DCOLOR_ARGB(0, 255, 0, 0), 1, 0);
+	m_pTexCubeRef->GetCubeMapSurface((D3DCUBEMAP_FACES)idFace, 0, &m_pSurface);
+	MLSet::DXDevice->SetRenderTarget(0, m_pSurface);
 
 	SGCore_ShaderBind(SHADER_TYPE_VERTEX, MLSet::IDsShaders::VS::ScreenOut);
 	SGCore_ShaderBind(SHADER_TYPE_PIXEL, MLSet::IDsShaders::PS::ScreenOut);
 
-	MLSet::DXDevice->SetTexture(0, TextureReflect);
+	MLSet::DXDevice->SetTexture(0, m_pTexWork);
 	SGCore_ScreenQuadDraw();
 
 	SGCore_ShaderUnBind();
@@ -323,7 +387,6 @@ void Reflection::PostRenderRefCube(int cube)
 	MLSet::DXDevice->SetRenderState(D3DRS_ZENABLE, zenable);
 	MLSet::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, zwriteenable);
 
-
 	/*if(GetAsyncKeyState(VK_NUMPAD5))
 	{
 		char tmpstr[1024];
@@ -331,84 +394,18 @@ void Reflection::PostRenderRefCube(int cube)
 		D3DXSaveSurfaceToFile(tmpstr, D3DXIFF_PNG, CubeReflectSurface[cube], NULL, 0);
 	}*/
 	
-	mem_release_del(CubeReflectSurface[cube]);
+	mem_release_del(m_pSurface);
 }
 
-void Reflection::EndRenderRefCube(float3_t* viewpos)
+void CReflection::endRenderRefCube(const float3_t *pViewPos)
 {
-	Core_RMatrixSet(G_RI_MATRIX_VIEW, &OldMatView);
-	Core_RMatrixSet(G_RI_MATRIX_PROJECTION, &OldMatProj);
-	Core_RMatrixSet(G_RI_MATRIX_VIEWPROJ, &OldMatViewProj);
+	Core_RMatrixSet(G_RI_MATRIX_VIEW, &m_mOldMatView);
+	Core_RMatrixSet(G_RI_MATRIX_PROJECTION, &m_mOldMatProj);
+	Core_RMatrixSet(G_RI_MATRIX_VIEWPROJ, &m_mOldMatViewProj);
 
-	MLSet::DXDevice->SetRenderTarget(0, BackBuffer);
-	//MLSet::DXDevice->SetDepthStencilSurface(LastSurfaceZBuffer);
-	//mem_release_del(LastSurfaceZBuffer);
-	mem_release_del(BackBuffer);
+	MLSet::DXDevice->SetRenderTarget(0, m_pBackBuffer);
+	mem_release_del(m_pBackBuffer);
 
-	UpdateCountUpdate(viewpos);
+	updateCountUpdate(pViewPos);
 }
 
-bool Reflection::UpdateCountUpdate(float3_t* viewpos)
-{
-	if (!viewpos)
-		return false;
-
-	if (TypeRef == MTLTYPE_REFLECT_CUBE_STATIC)
-	{
-		if (CountUpdate < MTL_REF_UPDATE_MAX_COUNT_FOR_STATIC)
-		{
-			++(CountUpdate);
-			return true;
-		}
-		else
-			return false;
-	}
-
-	float dist = SMVector3Distance(PositionReflect, (*viewpos)) - SMVector3Length((PosMax - PosMin) *0.5f);
-	if (dist < MTL_REF_UPDATE_L0_DIST)
-		CountUpdate = -1;
-	else if (dist < MTL_REF_UPDATE_L1_DIST && dist > MTL_REF_UPDATE_L0_DIST)
-	{
-		if (CountUpdate > 1)
-			CountUpdate = -1;
-	}
-	else if (dist < MTL_REF_UPDATE_L2_DIST && dist > MTL_REF_UPDATE_L1_DIST)
-	{
-		if (CountUpdate > 2)
-			CountUpdate = -1;
-	}
-	else if (dist > MTL_REF_UPDATE_L2_DIST)
-	{
-		CountUpdate = 4;
-	}
-
-	++CountUpdate;
-
-	return (CountUpdate == 0);
-}
-
-bool Reflection::AllowedRender()
-{
-	if (TypeRef == MTLTYPE_REFLECT_CUBE_STATIC)
-	{
-		if (CountUpdate <= MTL_REF_UPDATE_MAX_COUNT_FOR_STATIC)
-		{
-			++(CountUpdate);
-			return true;
-		}
-		else
-			return false;
-	}
-
-	return (CountUpdate == 0);
-}
-
-void Reflection::NullingCountUpdate()
-{
-	CountUpdate = 0;
-}
-
-IDirect3DCubeTexture9* Reflection::GetRefCubeTex()
-{
-	return TextureCubeReflect;
-}
diff --git a/source/mtllight/reflection.h b/source/mtllight/reflection.h
index 019b26e56c3f2594ba4d7594b68d928a6a40ac70..39351d5e8b62c59759b8c88872a721d38e0a9b74 100644
--- a/source/mtllight/reflection.h
+++ b/source/mtllight/reflection.h
@@ -17,64 +17,122 @@ See the license in LICENSE
 #include "sxmtllight.h"
 #include "ml_data.h"
 
-class Reflection
+/*! класс отражений, возможны плоские отражения и кубические
+ \note автогенерация мип уровней не работала, пришлось сделать небольшой костыль:\n
+  - рисуем отражения в рабочую текстуру
+  - эту текстуру рисуем в текстуру отражений\n
+  при таком подходе все мип уровни генерируются
+*/
+class CReflection
 {
 public:
-	Reflection();
-	~Reflection();
+	CReflection();
+	~CReflection();
 
-	void OnLostDevice();
-	void OnResetDevice();
+	void onLostDevice();
+	void onResetDevice();
 
 	SX_ALIGNED_OP_MEM
 
-	void Init(MTLTYPE_REFLECT howref);
-	MTLTYPE_REFLECT GetTypeReflect(){ return TypeRef; };
-
-	void PreRenderRefPlane(D3DXPLANE* plane);
-	void PostRenderRefPlane();
-	IDirect3DTexture9* GetRefPlaneTex();
-
-	void BeginRenderRefCube(float3_t* center);
-	void PreRenderRefCube(int cube, float4x4* world);
-	void PostRenderRefCube(int cube);
-	void EndRenderRefCube(float3_t* viewpos);
-	bool UpdateCountUpdate(float3_t* viewpos);
-	bool AllowedRender();
-	void NullingCountUpdate();
-	IDirect3DCubeTexture9* GetRefCubeTex();
-
-	void SetMinMax(float3_t* min, float3_t* max);
-
-	void SetIDArr(ID id, int cube, ID idarr);
-	int GetCountIDArrs();
-	ID GetIDArr(ID id, int cube);
-
-	bool IsComNow;	//обрабатывать ли сейчас, на случай еси видно или нет
-	float3 PositionReflect;	//позиция откуда идут отражения, обновляется каждый раз
-	float3 Position;
-	float3 PosMin, PosMax;
-	float4x4 MatrixView;
-	ISXFrustum* ReflectFrustum[6];
-	Array<ID*> IDArr;
-
-	long CountUpdate;
-
-	//protected:
-	MTLTYPE_REFLECT TypeRef;
-	D3DXPLANE Plane;
-	float ZNear;
-	float4x4 OldMatProj,OldMatView,OldMatViewProj;
-	IDirect3DSurface9* BackBuffer;
-
-	IDirect3DSurface9* SurfaceZBuffer;
-	IDirect3DSurface9* LastSurfaceZBuffer;
-
-	IDirect3DTexture9* TextureReflect;
-	IDirect3DSurface9* SurfaceReflect;
-
-	IDirect3DSurface9* CubeReflectSurface[6];
-	IDirect3DCubeTexture9* TextureCubeReflect;
+	//! инициализация отражений
+	void init(MTLTYPE_REFLECT type);
+
+	//! возвращает тип отражения
+	MTLTYPE_REFLECT getTypeReflect();
+
+	//! возвращает фрустум по id, для плоских отражений 0, для кубических [0,5] 
+	const ISXFrustum* getFrustum(ID id);
+
+	//! обновление количесвтенных данных обновления, возаращет true в случае если можно рисовать отражения, false если отражения рисовать не надо, pViewPos - позиция наблюдателя (обязательно)
+	bool updateCountUpdate(const float3_t *pViewPos);
+	
+	//! разрешен ли рендер отражений
+	bool allowedRender();
+
+	//! обнуление информации об обновлении
+	void nullingCountUpdate();
+
+	//**********************************************************************
+
+	//! подготовка в рендеру плоских отражений, pPlane - плоскость отражения (обязательно)
+	void preRenderRefPlane(const D3DXPLANE *pPlane);
+
+	//! окончание рендера плоских отражений
+	void postRenderRefPlane();
+
+	//! возвращает текстуру с плоским отражением
+	IDirect3DTexture9* getRefPlaneTex();
+
+	//**********************************************************************
+
+	//! подготовка данных кубических отражений
+	void beginRenderRefCube(const float3_t *pCenter);
+
+	//! подготвка к рендеру кубических отражений грани, pWorld - мировая матрица модели которая принимает эти отражения
+	void preRenderRefCube(ID idFace, const float4x4 *pWorld);
+
+	//! окончание рендера кубических отражений для грани
+	void postRenderRefCube(ID idFace);
+
+	//! окончание подготовки кубических отражений, pViewPos - позиция наблюдателя (обязательно)
+	void endRenderRefCube(const float3_t *pViewPos);
+	
+
+	//! возвращает кубическую текстуру с отражением
+	IDirect3DCubeTexture9* getRefCubeTex();
+
+	//! установить экстремумы
+	void setMinMax(const float3_t *pMin, const float3_t *pMax);
+
+	//! запись данных массива прсочетов
+	void setIDArr(ID id, ID idFace, ID idArr);
+
+	//! размер массива массивов идентификаторов просчета 
+	int getCountIDArrs();
+
+	//! получить идентификатор массива просчета
+	ID getIDArr(ID id, ID idFace);
+
+protected:
+
+	//! позиция камеры для кубческих отражений
+	float3 m_vPosition;
+
+	//! экстремумы геометрии кубических отражений, по ним определяется необходимость обновления статических отражений, измеряется расстояние до камеры
+	float3 m_vMin, m_vMax;
+
+	//! матрица вида для отражений
+	float4x4 m_mView;
+
+	//! массив фрустумов, для плоских отражений используется только нулевой, для кубических все
+	ISXFrustum *m_aFrustums[6];
+
+	//! массивы идентификаторов для просчета видимости
+	Array<ID*> m_aIDsArr;
+
+	//! количество обновлений отражения
+	int m_iCountUpdate;
+
+	//! тип отражений
+	MTLTYPE_REFLECT type_reflection;
+
+	//! предыдущие матрицы
+	float4x4 m_mOldMatProj, m_mOldMatView, m_mOldMatViewProj;
+
+	//! указатель на бэк буфер
+	IDirect3DSurface9 *m_pBackBuffer;
+
+	//! текстура плоских отражений
+	IDirect3DTexture9 *m_pTexPlaneRef;
+
+	//! рабочий сюрфейс
+	IDirect3DSurface9 *m_pSurface;
+
+	//! рабочая текстура
+	IDirect3DTexture9 *m_pTexWork;
+
+	//! текстура кубических отражений
+	IDirect3DCubeTexture9 *m_pTexCubeRef;
 };
 
 #endif
\ No newline at end of file
diff --git a/source/mtllight/sxmtllight.cpp b/source/mtllight/sxmtllight.cpp
index 28f0badbf215d2cf88fceda366adacd617701b50..0bab051a7ab28919f1bd4fe8a8c8ed3ec1f4b0ad 100644
--- a/source/mtllight/sxmtllight.cpp
+++ b/source/mtllight/sxmtllight.cpp
@@ -819,7 +819,7 @@ SX_LIB_API void SML_MtlRefPreRenderPlane(ID id, D3DXPLANE* plane)
 	ArrMaterials->MtlRefPreRenderPlane(id, plane);
 }
 
-SX_LIB_API ISXFrustum* SML_MtlRefGetfrustum(ID id, int cube)
+SX_LIB_API const ISXFrustum* SML_MtlRefGetfrustum(ID id, int cube)
 {
 	ML_PRECOND(0);
 	return ArrMaterials->MtlRefGetfrustum(id, cube);
diff --git a/source/mtllight/sxmtllight.h b/source/mtllight/sxmtllight.h
index dfbb1bb0d4759ed695db764c672b05fc1d1bf5f2..304e0ef31a58a568a6279295e360b5c0c5352220 100644
--- a/source/mtllight/sxmtllight.h
+++ b/source/mtllight/sxmtllight.h
@@ -807,7 +807,7 @@ SX_LIB_API void SML_MtlRefNullingCountUpdate(ID id);
 SX_LIB_API void SML_MtlRefSetMinMax(ID id, float3_t *pMin, float3_t *pMax);//!< установка экстремумов материала
 
 //! возвращает фрустум отражения, cube - сторона куба
-SX_LIB_API ISXFrustum* SML_MtlRefGetfrustum(
+SX_LIB_API const ISXFrustum* SML_MtlRefGetfrustum(
 	ID id,		//!< идентификатора материала
 	int iCube	//!< сторона куба, если отражение плоское то необходимо указать в cube передать 0, иначе вернет NULL
 	);
diff --git a/source/physics/PhyWorld.cpp b/source/physics/PhyWorld.cpp
index 0522c6524147766bbd370b20f02bfda3cb738116..f90fc69ac4af1a33aa0292f8e93586d7452d5e6d 100644
--- a/source/physics/PhyWorld.cpp
+++ b/source/physics/PhyWorld.cpp
@@ -652,6 +652,15 @@ void PhyWorld::DebugDrawer::reportErrorWarning(const char * warningString)
 			LibReport(REPORT_MSG_LEVEL_WARNING, " %5.4f %5.4f %5.4f %5.4f\n", mat.m[3][0], mat.m[3][1], mat.m[3][2], mat.m[3][3]);
 		}
 
+		btTransform &trans = pObj->getWorldTransform();
+
+		LibReport(REPORT_MSG_LEVEL_WARNING, " 0x%08xf\n", &trans);
+		byte * pByte = (byte*)&trans;
+		for (int i = 0, l = sizeof(trans); i < l; ++i)
+		{
+			LibReport(REPORT_MSG_LEVEL_WARNING, " %02x", pByte[i]);
+		}
+
 		if (!pObj->getUserPointer())
 		{
 			LibReport(REPORT_MSG_LEVEL_WARNING, "getUserPointer() is NULL.\n");
diff --git a/source/render/render_func.cpp b/source/render/render_func.cpp
index a799ca304aa4f87b9cd921f7240aaaf803ed6515..e989a729eb3de4d7c290a6dc1bd3607b9a6d4ec4 100644
--- a/source/render/render_func.cpp
+++ b/source/render/render_func.cpp
@@ -299,6 +299,11 @@ void SXRenderFunc::ComVisibleForCamera()
 
 void SXRenderFunc::ComVisibleReflection()
 {
+	static const int *r_reflection_render = GET_PCVAR_INT("r_reflection_render");
+
+	if (r_reflection_render && (*r_reflection_render) == REFLECTION_RENDER_ONLY_SKY)
+		return;
+
 	for (int i = 0; i < SGeom_ModelsGetCount(); ++i)
 	{
 		for (int k = 0; k < SGeom_ModelsMGetCountGroups(i); ++k)
@@ -314,18 +319,32 @@ void SXRenderFunc::ComVisibleReflection()
 
 				SGeom_ModelsMGetGroupCenter(i, k, &center);
 				
-				if (SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GEOM, 0) < 0)
-					SML_MtlRefSetIDArr(idmat, RENDER_IDARRCOM_GEOM, 0, SGeom_ModelsAddArrForCom());
+				if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_GEOM)
+				{
+					if (SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GEOM, 0) < 0)
+						SML_MtlRefSetIDArr(idmat, RENDER_IDARRCOM_GEOM, 0, SGeom_ModelsAddArrForCom());
+				}
 
-				if (SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GREEN, 0) < 0)
-					SML_MtlRefSetIDArr(idmat, RENDER_IDARRCOM_GREEN, 0, SGeom_GreenAddArrForCom());
+				if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_GREEN)
+				{
+					if (SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GREEN, 0) < 0)
+						SML_MtlRefSetIDArr(idmat, RENDER_IDARRCOM_GREEN, 0, SGeom_GreenAddArrForCom());
+				}
 
-				if(SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_ANIM, 0) < 0)
-					SML_MtlRefSetIDArr(idmat, RENDER_IDARRCOM_ANIM, 0, SXAnim_ModelsAddArrForCom());
+				if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_ANIM)
+				{
+					if (SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_ANIM, 0) < 0)
+						SML_MtlRefSetIDArr(idmat, RENDER_IDARRCOM_ANIM, 0, SXAnim_ModelsAddArrForCom());
+				}
 
-				SGeom_ModelsComVisible(SML_MtlRefGetfrustum(idmat, 0), &float3(center), SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GEOM, 0));
-				SGeom_GreenComVisible(SML_MtlRefGetfrustum(idmat, 0), &float3(center), SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GREEN, 0));
-				SXAnim_ModelsComVisible(SML_MtlRefGetfrustum(idmat, 0), &float3(center), SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_ANIM, 0));
+				if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_GEOM)
+					SGeom_ModelsComVisible(SML_MtlRefGetfrustum(idmat, 0), &float3(center), SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GEOM, 0));
+
+				if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_GREEN)
+					SGeom_GreenComVisible(SML_MtlRefGetfrustum(idmat, 0), &float3(center), SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GREEN, 0));
+				
+				if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_ANIM)
+					SXAnim_ModelsComVisible(SML_MtlRefGetfrustum(idmat, 0), &float3(center), SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_ANIM, 0));
 			}
 			else if (typeref == MTLTYPE_REFLECT_CUBE_DYNAMIC)
 			{
@@ -336,18 +355,32 @@ void SXRenderFunc::ComVisibleReflection()
 
 				for (int j = 0; j<6; j++)
 				{
-					if (SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GEOM, k) < 0)
-						SML_MtlRefSetIDArr(idmat, RENDER_IDARRCOM_GEOM, k, SGeom_ModelsAddArrForCom());
+					if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_GEOM)
+					{
+						if (SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GEOM, k) < 0)
+							SML_MtlRefSetIDArr(idmat, RENDER_IDARRCOM_GEOM, k, SGeom_ModelsAddArrForCom());
+					}
 
-					if (SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GREEN, k) < 0)
-						SML_MtlRefSetIDArr(idmat, RENDER_IDARRCOM_GREEN, k, SGeom_GreenAddArrForCom());
+					if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_GREEN)
+					{
+						if (SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GREEN, k) < 0)
+							SML_MtlRefSetIDArr(idmat, RENDER_IDARRCOM_GREEN, k, SGeom_GreenAddArrForCom());
+					}
 
-					if(SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_ANIM, k) < 0)
-						SML_MtlRefSetIDArr(idmat, RENDER_IDARRCOM_ANIM, k, SXAnim_ModelsAddArrForCom());
+					if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_ANIM)
+					{
+						if (SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_ANIM, k) < 0)
+							SML_MtlRefSetIDArr(idmat, RENDER_IDARRCOM_ANIM, k, SXAnim_ModelsAddArrForCom());
+					}
+					
+					if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_GEOM)
+						SGeom_ModelsComVisible(SML_MtlRefGetfrustum(idmat, j), &float3(center), SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GEOM, k));
+					
+					if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_GREEN)
+						SGeom_GreenComVisible(SML_MtlRefGetfrustum(idmat, j), &float3(center), SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GEOM, k));
 					
-					SGeom_ModelsComVisible(SML_MtlRefGetfrustum(idmat, j), &float3(center), SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GEOM, k));
-					SGeom_GreenComVisible(SML_MtlRefGetfrustum(idmat, j), &float3(center), SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GEOM, k));
-					SXAnim_ModelsComVisible(SML_MtlRefGetfrustum(idmat, j), &float3(center), SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_ANIM, k));
+					if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_ANIM)
+						SXAnim_ModelsComVisible(SML_MtlRefGetfrustum(idmat, j), &float3(center), SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_ANIM, k));
 				}
 			}
 		}
@@ -1543,6 +1576,11 @@ void SXRenderFunc::ShaderRegisterData()
 
 void SXRenderFunc::UpdateReflectionScene(DWORD timeDelta)
 {
+	static const int *r_reflection_render = GET_PCVAR_INT("r_reflection_render");
+
+	float3 vObserverPos;
+	Core_RFloat3Get(G_RI_FLOAT3_OBSERVER_POSITION, &vObserverPos);
+
 	for (int i = 0; i < SGeom_ModelsGetCount(); ++i)
 	{
 		for (int k = 0; k < SGeom_ModelsMGetCountGroups(i); ++k)
@@ -1553,6 +1591,7 @@ void SXRenderFunc::UpdateReflectionScene(DWORD timeDelta)
 			float3_t center;
 			if (typeref == MTLTYPE_REFLECT_PLANE)
 			{
+				
 				if (!SML_MtlRefIsAllowedRender(idmat))
 				{
 					SML_MtlRefUpdateCountUpdate(idmat, &((float3_t)GData::ConstCurrCamPos));
@@ -1565,38 +1604,51 @@ void SXRenderFunc::UpdateReflectionScene(DWORD timeDelta)
 				SetSamplerFilter(0, 16, D3DTEXF_LINEAR);
 				SetSamplerAddress(0, 16, D3DTADDRESS_WRAP);
 
-
 				Core_RBoolSet(G_RI_BOOL_CLIPPLANE0, true);
 
 				Core_RFloat3Set(G_RI_FLOAT3_CLIPPLANE0_NORMAL, &float3(plane.a, plane.b, plane.c));
 				Core_RFloat3Set(G_RI_FLOAT3_CLIPPLANE0_POINT, &float3(center));
 
-				if (SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GEOM, 0) >= 0)
-					SGeom_ModelsRender(timeDelta, MTLTYPE_TRANSPARENCY_NONE, SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GEOM, 0), false, i, k);
+				if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_GEOM)
+				{
+					if (SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GEOM, 0) >= 0)
+						SGeom_ModelsRender(timeDelta, MTLTYPE_TRANSPARENCY_NONE, SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GEOM, 0), false, i, k);
+				}
 
-				if (SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GREEN, 0) >= 0)
-					SGeom_GreenRender(timeDelta, &float3(center), GREEN_TYPE_ALL, SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GREEN, 0));
+				if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_GREEN)
+				{
+					if (SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GREEN, 0) >= 0)
+						SGeom_GreenRender(timeDelta, &float3(center), GREEN_TYPE_ALL, SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GREEN, 0));
+				}
 
-				SXAnim_Render();
+				if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_ANIM)
+				{
+					SXAnim_Render();
+				}
 
 				SGCore_ShaderUnBind();
 
+				if (SGCore_SkyBoxIsCr())
+				{
+					GData::DXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
 
-				GData::DXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
+					GData::DXDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
+					GData::DXDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
 
-				GData::DXDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
-				GData::DXDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
+					GData::DXDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_INVDESTALPHA);
+					GData::DXDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_DESTALPHA);
 
-				GData::DXDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_INVDESTALPHA);
-				GData::DXDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_DESTALPHA);
+					GData::DXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);
+					SetSamplerAddress(0, 2, D3DTADDRESS_CLAMP);
 
-				GData::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
-				GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE);
-				Core_RMatrixSet(G_RI_MATRIX_PROJECTION, &GData::MRefPlaneSkyProj);
-				SGCore_SkyBoxRender(timeDelta, &float3(center));
-				GData::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE);
-				GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE);
-				GData::DXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
+					GData::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
+					GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE);
+					Core_RMatrixSet(G_RI_MATRIX_PROJECTION, &GData::MRefPlaneSkyProj);
+					SGCore_SkyBoxRender(timeDelta, &float3(center));
+					GData::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE);
+					GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE);
+					GData::DXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
+				}
 
 				SML_MtlRefPostRenderPlane(idmat);
 			}
@@ -1616,58 +1668,79 @@ void SXRenderFunc::UpdateReflectionScene(DWORD timeDelta)
 
 				SML_MtlRefCubeBeginRender(idmat, &center);
 
-				for (int j = 0; j<6; j++)
+				for (int j = 0; j < 6; j++)
 				{
-					Core_RMatrixGet(G_RI_MATRIX_WORLD, &SMMatrixIdentity());
+					Core_RMatrixSet(G_RI_MATRIX_WORLD, &SMMatrixIdentity());
 
 					SML_MtlRefCubePreRender(idmat, j, &(SMMatrixIdentity()));
 					SetSamplerFilter(0, 16, D3DTEXF_LINEAR);
 					SetSamplerAddress(0, 16, D3DTADDRESS_WRAP);
 
-					//если статические кубические отражения
-					if (SML_MtlGetTypeReflection(idmat) == MTLTYPE_REFLECT_CUBE_STATIC)
+					if (r_reflection_render && (*r_reflection_render) != 0)
 					{
-						//тогда считаем в массив камеры
-						SGeom_ModelsComVisible(SML_MtlRefGetfrustum(idmat, j), &float3(center), GData::DefaultGeomIDArr);
-						SGeom_ModelsRender(timeDelta, MTLTYPE_TRANSPARENCY_NONE, GData::DefaultGeomIDArr, false, i, k);
+						//если статические кубические отражения
+						if (SML_MtlGetTypeReflection(idmat) == MTLTYPE_REFLECT_CUBE_STATIC)
+						{
+							//тогда считаем в массив камеры
+							if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_GEOM)
+							{
+								SGeom_ModelsComVisible(SML_MtlRefGetfrustum(idmat, j), &float3(center), GData::DefaultGeomIDArr);
+								SGeom_ModelsRender(timeDelta, MTLTYPE_TRANSPARENCY_NONE, GData::DefaultGeomIDArr, false, i, k);
+							}
 
-						SGeom_GreenComVisible(SML_MtlRefGetfrustum(idmat, j), &float3(center), GData::DefaultGreenIDArr);
-						SGeom_GreenRender(timeDelta, &float3(center), GREEN_TYPE_ALL, GData::DefaultGreenIDArr);
-					}
-					else
-					{
-						if (SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GEOM, k) >= 0)
-							SGeom_ModelsRender(timeDelta, MTLTYPE_TRANSPARENCY_NONE, SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GEOM, k), false, i, k);
+							if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_GREEN)
+							{
+								SGeom_GreenComVisible(SML_MtlRefGetfrustum(idmat, j), &float3(center), GData::DefaultGreenIDArr);
+								SGeom_GreenRender(timeDelta, &float3(center), GREEN_TYPE_ALL, GData::DefaultGreenIDArr);
+							}
+						}
+						else
+						{
+							if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_GEOM)
+							{
+								if (SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GEOM, k) >= 0)
+									SGeom_ModelsRender(timeDelta, MTLTYPE_TRANSPARENCY_NONE, SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GEOM, k), false, i, k);
+							}
 
-						if (SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GREEN, k) >= 0)
-							SGeom_GreenRender(timeDelta, &GData::ConstCurrCamPos, GREEN_TYPE_ALL, SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GREEN, k));
+							if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_GREEN)
+							{
+								if (SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GREEN, k) >= 0)
+									SGeom_GreenRender(timeDelta, &GData::ConstCurrCamPos, GREEN_TYPE_ALL, SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GREEN, k));
+							}
 
-						SXAnim_Render();
+							if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_ANIM)
+							{
+								SXAnim_Render();
+							}
+						}
 					}
 
-					GData::DXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
+					if (SGCore_SkyBoxIsCr())
+					{
+						GData::DXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
 
-					GData::DXDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
-					GData::DXDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
+						GData::DXDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
+						GData::DXDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
 
-					GData::DXDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_INVDESTALPHA);
-					GData::DXDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_DESTALPHA);
+						GData::DXDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_INVDESTALPHA);
+						GData::DXDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_DESTALPHA);
 
-					GData::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
-					GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE);
+						GData::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
+						GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE);
 
-					GData::DXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);
-					SetSamplerAddress(0, 2, D3DTADDRESS_CLAMP);
+						GData::DXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);
+						SetSamplerAddress(0, 2, D3DTADDRESS_CLAMP);
 
-					Core_RMatrixSet(G_RI_MATRIX_PROJECTION, &GData::MRefCubeSkyProj);
+						Core_RMatrixSet(G_RI_MATRIX_PROJECTION, &GData::MRefCubeSkyProj);
 
-					SGCore_SkyBoxRender(timeDelta, &float3(center));
-					GData::DXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
+						SGCore_SkyBoxRender(timeDelta, &float3(center));
+						GData::DXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
 
-					SML_MtlRefCubePostRender(idmat, j);
+						SML_MtlRefCubePostRender(idmat, j);
 
-					GData::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE);
-					GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE);
+						GData::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE);
+						GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE);
+					}
 				}
 				SML_MtlRefCubeEndRender(idmat, &((float3_t)GData::ConstCurrCamPos));
 			}
diff --git a/source/render/render_func.h b/source/render/render_func.h
index 712347180fca5c532066aea0e728ebb2be3749e0..eb1b1a64c591567a3326e1444aab38839471d8ce 100644
--- a/source/render/render_func.h
+++ b/source/render/render_func.h
@@ -35,6 +35,14 @@ See the license in LICENSE
 #include <pp/sxpp.h>
 #include <decals/sxdecals.h>
 
+enum REFLECTION_RENDER
+{
+	REFLECTION_RENDER_ONLY_SKY	= 0,
+	REFLECTION_RENDER_GEOM		= 1,
+	REFLECTION_RENDER_GREEN		= 2,
+	REFLECTION_RENDER_ANIM		= 3,
+};
+
 //! пространство имен с орагнизацией рендера
 namespace SXRenderFunc
 {
diff --git a/source/skyxengine.cpp b/source/skyxengine.cpp
index 36647bb2c866a21ce610c1c58dfd69a5cbd2b55c..bd448aab6a0fa0fca83c23046a40e9ff0fd83889 100644
--- a/source/skyxengine.cpp
+++ b/source/skyxengine.cpp
@@ -453,6 +453,7 @@ void SkyXEngine_CreateLoadCVar()
 	Core_0RegisterCVarInt("r_texfilter_max_miplevel", 0, "Какой mip уровень текстур использовать? 0 - самый высокий, 1 - ниже на один уровень и т.д.");
 	Core_0RegisterCVarInt("r_stats", 1, "Показывать ли статистику? 0 - нет, 1 - fps и игровое время, 2 - показать полностью");
 
+	Core_0RegisterCVarInt("r_reflection_render", 0, "Режим рендера отражений 0 - отражения только от skybox, 1 - геометрия, 2 - растительность, 3 - анимационные модели");
 
 	Core_0RegisterCVarFloat("cl_mousesense", 0.001f, "Mouse sense value");