Обсуждение и выбор комплектующих, новости из мира железа т.5

 ну ясно, мне было это вообще не интересно

#pragma comment(lib, "d3d9.lib")
#pragma comment(lib, "d3dx9.lib")
#pragma comment(lib, "Winmm.lib")
#include <fstream>			 // Подключаем заголовочный файл потоков ввода/вывода
#include <windows.h>         // Подключаем заголовочный файл Windows
#include <mmsystem.h>        // Подключаем системную библеотеку
#include <d3d9.h>            // Подключаем заголовочный файл DirectX 9 SDK
#include <d3dx9.h>           // Подключаем из D3DX утилит для работы с матрицами


//-----------------------------------------------------------------------------------
// Глобальные переменные
//-----------------------------------------------------------------------------------
LPDIRECT3D9                 pDirect3D          = NULL;      // Главный Direct3D обьект
LPDIRECT3DDEVICE9           pDirect3DDevice    = NULL;      // Устройство 
LPDIRECT3DVERTEXBUFFER9     pBufferVershin     = NULL;      // Буфер вершин
LPDIRECT3DINDEXBUFFER9      pBufferIndex       = NULL;      // Индексный буфер 
LPDIRECT3DTEXTURE9	        pTextura001        = NULL;      // Текстyра

using namespace std;
ofstream out("out.txt");	// файл для вывода технической информации

int DEPTH = 10;

// коэффециенты освещения фонга
struct FONG
{
	float Ka, Kd, Ks, Kp;
};

// источник
struct COLOR
{
	float r, g, b;
};

// источник
struct LIGHT
{
	float x, y, z;
	COLOR c;
};

// вершины в 3D
struct VEC
{
	float x, y, z;
};

// сфера
struct SPHERE
{
	VEC p;
	float r;
	FONG f;
};

// цилиндр
struct CYLINDER
{
	VEC o;
	VEC Dir;
	float r;
	float H_min;
	float H_max;
	FONG f;
};

// вершины многоугольника-сечения
struct POLYGON
{
	float x, y;			//координаты 0..1
};

// формат буфера вершин
struct CUSTOMVERTEX
{
    FLOAT x,  y,  z;		//кординаты
    FLOAT nx, ny, nz;		//нормали
	FLOAT tu, tv;			//техтура
};
#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ|D3DFVF_NORMAL|D3DFVF_TEX1)  // Формат буфера вершин

// камера
struct VISION
{
	int X, Y;			// размер поверхности вывода
	VEC Eye;			// координаты камеры
	VEC u, v, w;		// направленность камеры(w)
	float O;			// угол зрения
	float N;			// расстояние до экрана
};

VISION V;

//-----------------------------------------------------------------------------------
// рассчет квадрата вектора
//-----------------------------------------------------------------------------------
inline float QW(const VEC &v)
{
	return v.x*v.x + v.y*v.y + v.z*v.z;
}
//-----------------------------------------------------------------------------------
// рассчет скалярного произведения векторов
//-----------------------------------------------------------------------------------
inline float MUL(const VEC &v1, const VEC &v2)
{
	return v1.x*v2.x + v1.y*v2.y + v1.z*v2.z;
}

//-----------------------------------------------------------------------------------
// рассчет векторного произведения векторов
//-----------------------------------------------------------------------------------
inline VEC MUL_VEC(const VEC &v1, const VEC &v2)
{
	VEC v;
	v.x = v1.y*v2.z - v1.z*v2.y;
	v.y = v1.z*v2.x - v1.x*v2.z;
	v.z = v1.x*v2.y - v1.y*v2.x;
	return v;
}

//-----------------------------------------------------------------------------------
// нормализация вектора
//-----------------------------------------------------------------------------------
inline void NORMALIZE(VEC &v)
{
	float lenght = sqrt(QW(v));
	v.x /= lenght;
	v.y /= lenght;
	v.z /= lenght;
}

//-----------------------------------------------------------------------------------
// добавление сферы
//-----------------------------------------------------------------------------------
int sphere_count = 0;
SPHERE sphere[100];
void add_sphare(float x, float y, float z, float r, FONG f)
{
	sphere[sphere_count].p.x = x;
	sphere[sphere_count].p.y = y;
	sphere[sphere_count].p.z = z;
	sphere[sphere_count].r = r;
	sphere[sphere_count].f = f;
	sphere_count++;
}

//-----------------------------------------------------------------------------------
// добавление цилиндра
//-----------------------------------------------------------------------------------
int cylinder_count = 0;
CYLINDER cylinder[100];
void add_cylinder(float x, float y, float z, float dx, float dy, float dz, float r, float H_min, float H_max, FONG f)
{
	cylinder[cylinder_count].o.x = x;
	cylinder[cylinder_count].o.y = y;
	cylinder[cylinder_count].o.z = z;
	cylinder[cylinder_count].Dir.x = dx;
	cylinder[cylinder_count].Dir.y = dy;
	cylinder[cylinder_count].Dir.z = dz;
	NORMALIZE(cylinder[cylinder_count].Dir);
	cylinder[cylinder_count].r = r;
	cylinder[cylinder_count].H_min = H_min;
	cylinder[cylinder_count].H_max = H_max;
	cylinder[cylinder_count].f = f;
	cylinder_count++;
}

/*int parallelepiped_count = 0;
PARALLELEPIPED parallelepiped[100];*/

//-----------------------------------------------------------------------------------
// добавление точечного источника
//-----------------------------------------------------------------------------------
int light_count = 0;
LIGHT light[100];
void add_light(float x, float y, float z, float r, float g, float b)
{
	light[light_count].x = x;
	light[light_count].y = y;
	light[light_count].z = z;
	light[light_count].c.r = r;
	light[light_count].c.g = g;
	light[light_count].c.b = b;
	light_count++;
}

bool First;	// первый луч?
//-----------------------------------------------------------------------------------
// проверка значений, выбор годного
//-----------------------------------------------------------------------------------
inline bool prob(float &t1, float &t2, float &t)
{
	if(t1 <= 0) t1 = t2;
	if(t2 <= 0) t2 = t1;
	if(abs(t1) < 0.01) t1 = t2;
	//if(abs(t2) < 0.01) t2 = t1;
	t = min(t1, t2);
	return (t > 0 && abs(t) >= 0.01 && (t > 1 || First == false));
}

//-----------------------------------------------------------------------------------
// Рассчет точки пересечения луча с первым объектом
// Возвращает:
//	t_min - точка пересечения луча с ближайшей фигурой
//	figure - тип фигуры (1-шар, 2-цилиндр, 3-параллелепипед) или -1 если нет пересечения
//	index - номер фигуры
//-----------------------------------------------------------------------------------
inline void Test(const VEC &Eye, const VEC &Dir, float &t_min, int &figure, int &index, VEC &Normal)
{
	int i;
	VEC v1,v2,v3;			// промежуточные векторы
	float k1,k2, a,b,c,D;	// промежуточные скаляры
	float t,t1,t2;
	bool stat;

	figure = -1;
	// Обход сфер
	for(i = 0; i < sphere_count; i++)
	{
		float a, b, c, t, t1, t2, D;
		//|Eye + t*Dir - sphare[i]| = r;
		//|Eye - sphare[i] + t*Dir| = r;
		v1.x = Eye.x - sphere[i].p.x;
		v1.y = Eye.y - sphere[i].p.y;
		v1.z = Eye.z - sphere[i].p.z;
		//|t*Dir + v1| = r;
		//(Dir)^2*t^2 + 2*(v1, Dir)*t + v1^2 - r^2 = 0
		a = QW(Dir);
		b = 2*MUL(v1, Dir);
		c = QW(v1) - sphere[i].r*sphere[i].r;
		D = b*b-4*a*c;
		if(D > 0)
		{
			D = sqrt(D);
			t1 = (-b-D)/(2*a);
			t2 = (-b+D)/(2*a);
			if(prob(t1, t2, t))
			{
				if(t < t_min || figure == -1)
				{
					t_min = t;
					figure = 1;
					index = i;
					Normal.x = v1.x + t*Dir.x;
					Normal.y = v1.y + t*Dir.y;
					Normal.z = v1.z + t*Dir.z;
					NORMALIZE(Normal);
				}
			}
		}
	}
	// Обход цилиндров
	for(i = 0; i < cylinder_count; i++)
	{
	// пересечение с гранями цилиндра
		// p = Eye+t*Dir - луч
		// op = (Eye+t*Dir)-cylinder[i].o - вектор от начала цилиндра до точки p(t) луча
		//			hp = op - cylinder[i].Dir*(op,cylinder[i].Dir) - перпендикуляр от центра цилиндра к точке p
		//			условие: |hp| = cylinder[i].r
		// 1)	v1 = Eye-cylinder[i].o
		v1.x = Eye.x-cylinder[i].o.x;
		v1.y = Eye.y-cylinder[i].o.y;
		v1.z = Eye.z-cylinder[i].o.z;
		// op = v1+t*Dir
		// hp = v1+t*Dir - cylinder[i].Dir*(v1+t*Dir,cylinder[i].Dir)
		// (v1+t*Dir,cylinder[i].Dir) =
		// (v1.x+t*Dir.x)*cylinder[i].Dir.x+
		// (v1.y+t*Dir.y)*cylinder[i].Dir.y+
		// (v1.z+t*Dir.z)*cylinder[i].Dir.z
		// (v1+t*Dir,cylinder[i].Dir) = k1+t*k2
		// 2)	k1 = (v1.x*cylinder[i].Dir.x+v1.y*cylinder[i].Dir.y+v1.z*cylinder[i].Dir.z)
		//		k2 = (Dir.x*cylinder[i].Dir.x+Dir.y*cylinder[i].Dir.y+Dir.z*cylinder[i].Dir.z)
		k1 = MUL(v1, cylinder[i].Dir);
		k2 = MUL(Dir, cylinder[i].Dir);
		// hp = v1+t*Dir - cylinder[i].Dir*(k1+t*k2)
		// 3)	v2 = v1-cylinder[i].Dir*k1
		//		v3 = Dir-cylinder[i].Dir*k2
		v2.x = v1.x-cylinder[i].Dir.x*k1;
		v2.y = v1.y-cylinder[i].Dir.y*k1;
		v2.z = v1.z-cylinder[i].Dir.z*k1;
		v3.x = Dir.x-cylinder[i].Dir.x*k2;
		v3.y = Dir.y-cylinder[i].Dir.y*k2;
		v3.z = Dir.z-cylinder[i].Dir.z*k2;
		// hp = v2+t*v3
		// условие: (t*v3 + v2)^2 - cylinder[i].r^2 = 0
		// v3^2*t^2 + 2*(v3,v2)*t + (v2^2 - cylinder[i].r^2) = 0
		a = QW(v3);
		b = 2*MUL(v3,v2);
		c = QW(v2) - cylinder[i].r*cylinder[i].r;
		D = b*b-4*a*c;
		if(D > 0)
		{
			D = sqrt(D);
			t1 = (-b-D)/(2*a);
			t2 = (-b+D)/(2*a);
			// Не выходит ли точка за пределы цилиндра
			// v4 = op = (v1+t*Dir) - вектор из начала цилиндра к найденной точке пересечения
			// (v4, cylinder[i].Dir) - длина проэкции op на ось цилиндра
			// Условие: cylinder[i].H_min < (v4, cylinder[i].Dir) < cylinder[i].H_max
			stat = false;
			VEC v4;
			float k3;
			v4.x = v1.x+t1*Dir.x;
			v4.y = v1.y+t1*Dir.y;
			v4.z = v1.z+t1*Dir.z;
			k3 = MUL(v4, cylinder[i].Dir);
			if(k3 < cylinder[i].H_min || k3 > cylinder[i].H_max) t1 = t2; else stat = true;
			v4.x = v1.x+t2*Dir.x;
			v4.y = v1.y+t2*Dir.y;
			v4.z = v1.z+t2*Dir.z;
			k3 = MUL(v4, cylinder[i].Dir);
			if(k3 < cylinder[i].H_min || k3 > cylinder[i].H_max) t2 = t1; else stat = true;
			// стандартные проверки
			if(stat && prob(t1, t2, t))
			{
				if(t < t_min || figure == -1)
				{
					t_min = t;
					figure = 2;
					index = i;
					Normal.x = v2.x + t*v3.x;
					Normal.y = v2.y + t*v3.y;
					Normal.z = v2.z + t*v3.z;
					NORMALIZE(Normal);
				}
			}
		}
	// пересечение с основаниями цилиндра
		stat = false;
		VEC v4, v5;
		// Первое основание (начало цилиндра)
		// p = Eye+t*Dir - луч
		// op = (Eye+t*Dir)-cylinder[i].o - вектор от начала цилиндра до точки p(t) луча
		//			условие: (op, cylinder[i].Dir) = 0
		// k1+t*k2 = 0
		// t = (cylinder[i].H_min-k1)/k2
		t1 = (cylinder[i].H_min-k1)/k2;
		//			условие: |op| < cylinder[i].r
		v4.x = -cylinder[i].Dir.x*cylinder[i].H_min + v1.x + t1*Dir.x;
		v4.y = -cylinder[i].Dir.y*cylinder[i].H_min + v1.y + t1*Dir.y;
		v4.z = -cylinder[i].Dir.z*cylinder[i].H_min + v1.z + t1*Dir.z;
		// Второе основание (начало цилиндра)
		//			условие: (op, cylinder[i].Dir) = cylinder[i].H_max
		// k1+t*k2 = cylinder[i].H_max
		// t = (cylinder[i].H_max-k1)/k2
		t2 = (cylinder[i].H_max-k1)/k2;
		//			условие: |Op| = |Oo + op| = 
		//					 |-cylinder[i].Dir*cylinder[i].H_max + op| < cylinder[i].r
		v5.x = -cylinder[i].Dir.x*cylinder[i].H_max + v1.x + t2*Dir.x;
		v5.y = -cylinder[i].Dir.y*cylinder[i].H_max + v1.y + t2*Dir.y;
		v5.z = -cylinder[i].Dir.z*cylinder[i].H_max + v1.z + t2*Dir.z;
		if(QW(v4) > cylinder[i].r*cylinder[i].r) t1 = t2; else stat = true;
		if(QW(v5) > cylinder[i].r*cylinder[i].r) t2 = t1; else stat = true;
		if(stat && prob(t1, t2, t))
		{
			if(t < t_min || figure == -1)
			{
				t_min = t;
				figure = 2;
				index = i;
				Normal = cylinder[i].Dir;
			}
		}
	}
}

//-----------------------------------------------------------------------------------
// Рассчет интенсивности освещения точки с учетом только видимых из этой точки источников
// p - точка
// n - нормаль к поверхности в точке
// Dir0 - направление луча, попадающего в точку p
//-----------------------------------------------------------------------------------
inline COLOR Intensity(const VEC &p, const VEC &n, const FONG &f, const VEC &Dir0)
{
	COLOR E = {0,0,0};
	float t_min;
	int figure, index;
	VEC Dir, R, n0;
	VEC ttt;
	// Dir - направление на источник
	// R - направление зеркального отражения источника
	// n0 - второй п-р в плоскости лучей
	float lenght, I;
	for(int i = 0; i < light_count; i++)
	{
		Dir.x = light[i].x - p.x;
		Dir.y = light[i].y - p.y;
		Dir.z = light[i].z - p.z;
		lenght = QW(Dir);
		I = 1.f/lenght;
		lenght = sqrt(lenght);
		NORMALIZE(Dir);
		Test(p, Dir, t_min, figure, index, ttt);//тут используется слишком мощная функция
		if(figure == -1 || lenght < t_min)
		{
			float mnoj;
			float h;
			n0 = MUL_VEC(n, MUL_VEC(n, Dir));
			NORMALIZE(n0);
			h = -2*MUL(Dir, n0);
			R = Dir;
			R.x += n0.x * h;
			R.y += n0.y * h;
			R.z += n0.z * h;
			NORMALIZE(R);
			mnoj = abs(f.Kd * MUL(n, Dir)) + pow(abs(f.Ks * MUL(R, Dir0)),f.Kp);
			// источник не заслонен
			E.r += I * light[i].c.r * (mnoj + f.Ka);
			E.g += I * light[i].c.g * (mnoj + f.Ka);
			E.b += I * light[i].c.b * (mnoj + f.Ka);
		}
	}
	return E;
}

//-----------------------------------------------------------------------------------
// рассчет цвета луча
//-----------------------------------------------------------------------------------
COLOR Ray(const VEC &Eye, const VEC &Dir, int H)
{
	COLOR E = {0,0,0};
	if(H < 0) return E;
	COLOR dE;
	float t_min;
	int figure, index;
	VEC Point, Normal, Dir2;
	FONG fong;
	Test(Eye, Dir, t_min, figure, index, Normal);
	if(figure == -1) return E;	
	Point.x = Eye.x + t_min*Dir.x;
	Point.y = Eye.y + t_min*Dir.y;
	Point.z = Eye.z + t_min*Dir.z;
	if(figure == 1)	//сфера
	{
		fong = sphere[index].f;
	}else
	if(figure == 2)	//цилиндр
	{
		fong = cylinder[index].f;
	}
	if(First)
	{
		E.r += .1f;// амбиентный свет
		E.g += .1f;
		E.b += .1f;
		t_min = 0;	//искусственно обнулили расстояние
		First = false;
	}
	// Point - видимая точка (точка пересечения)
	// Normal - нормаль к поверхности в точке пересечения с лучем
	// Dir2 - отраженный луч
	dE = Intensity(Point, Normal, fong, Dir);
	E.r += dE.r/(1+t_min*t_min);
	E.g += dE.g/(1+t_min*t_min);
	E.b += dE.b/(1+t_min*t_min);
	// зеркально отраженный луч - рекурсия
	float h = -MUL(Dir, Normal)*2;
	Dir2.x = Dir.x + Normal.x*h;
	Dir2.y = Dir.y + Normal.y*h;
	Dir2.z = Dir.z + Normal.z*h;
	NORMALIZE(Dir2);
	dE = Ray(Point, Dir2, H - 1);
	E.r += dE.r/(1+t_min*t_min);
	E.g += dE.g/(1+t_min*t_min);
	E.b += dE.b/(1+t_min*t_min);
	return E;
}

//-----------------------------------------------------------------------------------
// Пуск первого луча
//-----------------------------------------------------------------------------------
COLOR Get_color(float r, float c)
{
	COLOR E;
	VEC Dir;
	float uc, vr, H, W;
	//(r,c)->(vr,uc)
	W = V.N * tan(V.O/2.f) * 2.f;	// ширина экрана на расстоянии V.N от наблюдателя
	H = W * V.Y/V.X;			// ширина экрана на расстоянии V.N от наблюдателя
	vr = (r/V.X-.5f) * W;		// координаты точки этого экрана
	uc = (c/V.Y-.5f) * H;		// координаты точки этого экрана
	
	Dir.x = V.N*V.w.x + uc*V.u.x + vr*V.v.x;
	Dir.y = V.N*V.w.y + uc*V.u.y + vr*V.v.y;
	Dir.z = V.N*V.w.z + uc*V.u.z + vr*V.v.z;
	// Dir - направление луча
	// Eye - координаты начала луча
	First = true;
	NORMALIZE(Dir);
	E = Ray(V.Eye, Dir, DEPTH);
	if(E.r >= 1) E.r = 1;
	if(E.g >= 1) E.g = 1;
	if(E.b >= 1) E.b = 1;
	return E;
}
/*int parallelepiped_count = 0;
PARALLELEPIPED parallelepiped[100];*/











//-----------------------------------------------------------------------------------
// Инициализация Direct3D
//-----------------------------------------------------------------------------------
HRESULT InitialDirect3D( HWND hwnd )
{
    if( NULL == ( pDirect3D = Direct3DCreate9( D3D_SDK_VERSION ) ) )
	{
		out << "Direct3D dnt created" << endl;
		return E_FAIL;
	}
	else
	{
		out << "Direct3D created" << endl;
	}

    D3DPRESENT_PARAMETERS Direct3DParametr; 
    ZeroMemory( &Direct3DParametr, sizeof(Direct3DParametr) );
    Direct3DParametr.Windowed         = TRUE;
    Direct3DParametr.SwapEffect       = D3DSWAPEFFECT_DISCARD;// вариант заднего буфера, оптимальный для оконного режима
    Direct3DParametr.BackBufferFormat = D3DFMT_UNKNOWN;//Display.Format;
     Direct3DParametr.EnableAutoDepthStencil = TRUE;		//для нормальной работы буфера глубины
     Direct3DParametr.AutoDepthStencilFormat = D3DFMT_D16;	//16-битный буфер z-глубины
    Direct3DParametr.BackBufferCount = 1;
    
    if( FAILED( pDirect3D -> CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd,
                                      D3DCREATE_HARDWARE_VERTEXPROCESSING,
                                      &Direct3DParametr, &pDirect3DDevice ) ) )
	{
		out << "Direct3DDevice dnt created" << endl;
		return E_FAIL;
	}
	else
	{
		out << "Direct3DDevice created" << endl;
	}
    // Включаем отсеченние Direct3D
    pDirect3DDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_CW );// обход граней 3-ка по часовой стрелке
	// Подключаем Z буфер
    pDirect3DDevice->SetRenderState (D3DRS_ZENABLE, D3DZB_TRUE); 
    return S_OK;
}

//-----------------------------------------------------------------------------------
// Рисует плоский выпуклый n-угольник в 3D
// v-массив вершин
// p-массив точек привязанной текстуры
//-----------------------------------------------------------------------------------
int Vershin_count = 0, Index_count = 0;	// счетчики
CUSTOMVERTEX *Vershin;	// вершины
unsigned short *Index;	// индексы
void add_polygon(int n, VEC *v, POLYGON *p)
{
	float nx, ny, nz, scal;
	//b = (v[0] - v[1])
	//a = (v[2] - v[1])	
	nx = (v[0].y - v[1].y) * (v[2].z - v[1].z) - (v[0].z - v[1].z) * (v[2].y - v[1].y);
	ny = (v[0].z - v[1].z) * (v[2].x - v[1].x) - (v[0].x - v[1].x) * (v[2].z - v[1].z);
	nz = (v[0].x - v[1].x) * (v[2].y - v[1].y) - (v[0].y - v[1].y) * (v[2].x - v[1].x);
	scal = sqrt(nx*nx + ny*ny + nz*nz);
	nx /= scal;
	ny /= scal;
	nz /= scal;
	int offset = Vershin_count;
	for(int i = 0; i < n; i++)
	{//i-номер вершины
		Vershin[offset].x = v[i].x;
		Vershin[offset].y = v[i].y;
		Vershin[offset].z = v[i].z;
		Vershin[offset].nx = nx;
		Vershin[offset].ny = ny;
		Vershin[offset].nz = nz;
		Vershin[offset].tu  = p[i].x;
		Vershin[offset].tv  = p[i].y;
		offset++;
	}
	offset = Index_count;
	for(int i = 0; i < n - 2; i++)
	{
		Index[offset] =	Vershin_count + 0; offset++;
		Index[offset] =	Vershin_count + i + 1; offset++;
		Index[offset] =	Vershin_count + i + 2; offset++;
	}
	Vershin_count += n;
	Index_count += (n - 2) * 3;
}

//-----------------------------------------------------------------------------------
// инициализация объекта сцены
//-----------------------------------------------------------------------------------
HRESULT InitialObject()
{
	Vershin = new CUSTOMVERTEX[4];
	Index = new unsigned short[6];
	VEC *v = new VEC[4];
	POLYGON *p = new POLYGON[4];
	v[0].x = 1;
	v[0].y = -1;
	v[0].z = 0;
	p[0].x = 1;
	p[0].y = 0;
	v[1].x = 1;
	v[1].y = 1;
	v[1].z = 0;
	p[1].x = 1;
	p[1].y = 1;
	v[2].x = -1;
	v[2].y = 1;
	v[2].z = 0;
	p[2].x = 0;
	p[2].y = 1;
	v[3].x = -1;
	v[3].y = -1;
	v[3].z = 0;
	p[3].x = 0;
	p[3].y = 0;
	add_polygon(4, v, p);
	if( FAILED( pDirect3DDevice->CreateTexture(V.X, V.Y, 0, 0,
                                  D3DFMT_A8R8G8B8,
                                  D3DPOOL_MANAGED, 
								  &pTextura001, NULL)))
	{
		out << "Texture dnt created" << endl;
		return E_FAIL;
	}
	else
	{
		out << "Texture created" << endl;
	}   

	// Создаем буфер вершин
    if( FAILED( pDirect3DDevice->CreateVertexBuffer( Vershin_count * sizeof(CUSTOMVERTEX),
        0, D3DFVF_CUSTOMVERTEX,D3DPOOL_DEFAULT, &pBufferVershin, NULL ) ) )
	{
		out << "VertexBuffer dnt created" << endl;
		return E_FAIL;
	}
	else
	{
		out << "VertexBuffer created" << endl;
	}   
    //Блокируем
    VOID* pBV;
    if( FAILED( pBufferVershin->Lock( 0, Vershin_count * sizeof(CUSTOMVERTEX), (void**)&pBV, 0 ) ) ) 
	{
		out << "VertexBuffer dnt locked" << endl;
		return E_FAIL;
	}
	else
	{
		out << "VertexBuffer locked" << endl;
	}   
    //Копируем
    memcpy( pBV, Vershin, Vershin_count * sizeof(CUSTOMVERTEX) );
    // Разблокируем
    pBufferVershin->Unlock(); 
    // Создаем индексный буфер
    pDirect3DDevice->CreateIndexBuffer(  Index_count * sizeof(unsigned short), 
       0, D3DFMT_INDEX16, D3DPOOL_DEFAULT,&pBufferIndex, NULL);
    //Блокируем
    VOID* pBI;
    pBufferIndex->Lock( 0, Index_count * sizeof(unsigned short), (void**)&pBI, 0 );
    //Копируем
    memcpy( pBI, Index, Index_count * sizeof(unsigned short) );
    // Разблокируем
    pBufferIndex->Unlock();
   return S_OK;
}
//-----------------------------------------------------------------------------
// Мировая матрица, матрица вида, матрица проекции
//-----------------------------------------------------------------------------
VOID Matrix()
{
    D3DXMATRIX MatrixWorld;			// Мировая матрица
    D3DXMATRIX MatrixView;			// Матрица вида
    D3DXMATRIX MatrixProjection;	// Матрица проекции
    // MatrixWorld
	D3DXMatrixRotationY( &MatrixWorld, 0 );
    pDirect3DDevice->SetTransform( D3DTS_WORLD,&MatrixWorld );
    // MatrixView
    D3DXMatrixLookAtLH( &MatrixView,  &D3DXVECTOR3 ( 0, 0, -2 ),
                                      &D3DXVECTOR3 ( 0, 0, 0),
                                      &D3DXVECTOR3 ( 0, 1, 0 ));
    pDirect3DDevice->SetTransform( D3DTS_VIEW, &MatrixView );
    // MatrixProjection
    D3DXMatrixPerspectiveFovLH( &MatrixProjection, D3DX_PI/4, 1.0f, 1.0f, 1000.0f );
    pDirect3DDevice->SetTransform( D3DTS_PROJECTION, &MatrixProjection );
}
//-----------------------------------------------------------------------------------
//  Рисуем
//-----------------------------------------------------------------------------------
VOID RenderingDirect3D()
{
    
    if(pDirect3DDevice == NULL)        // Не отвалился ли интерфейс
	{
		out << "Direct3DDevice is lost" << endl;
		return;
	}	
    pDirect3DDevice->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
                              D3DCOLOR_XRGB(30,50,75), 1.0f, 0 );
    // Начало сцены
    pDirect3DDevice->BeginScene();     
    
    // Здесь происходит прорисовка сцены
	
  ////////////
  // Заполнение текстуры
  D3DLOCKED_RECT text_rect;
  if (FAILED(pTextura001->LockRect(0, &text_rect, 0, 0)))
   return;

  BYTE* dst=(BYTE*)text_rect.pBits;
	for (int i=0; i<V.Y; i++)
	for (int j=0; j<V.X; j++)
	{
		COLOR E = Get_color((float)j, (float)i);
		int c = D3DCOLOR_XRGB((int)(E.r*255), (int)(E.g*255), (int)(E.b*255));
		if(c != 0)
			*(DWORD *)(dst+i*text_rect.Pitch+j*4) = c;
	}
  pTextura001->UnlockRect(0);
  ////////////
    D3DMATERIAL9  Material; // Материал
    D3DXVECTOR3 VectorDir;	// направление

	//  Установим материал
	ZeroMemory( &Material, sizeof(D3DMATERIAL9) );
    Material.Diffuse.r = Material.Ambient.r = 1.f;
    Material.Diffuse.g = Material.Ambient.g = 1.f;
    Material.Diffuse.b = Material.Ambient.b = 1.f;
    Material.Diffuse.a = Material.Ambient.a = 1.f;
    pDirect3DDevice->SetMaterial( &Material );
	
    pDirect3DDevice->SetRenderState( D3DRS_AMBIENT, D3DCOLOR_XRGB(255, 255, 255) );
	
	Matrix();

    pDirect3DDevice->SetStreamSource( 0, pBufferVershin, 0, sizeof(CUSTOMVERTEX) );
    pDirect3DDevice->SetFVF( D3DFVF_CUSTOMVERTEX );
    pDirect3DDevice->SetIndices(pBufferIndex);
    pDirect3DDevice->SetTexture (0, pTextura001);

    // Вывод объекта
    pDirect3DDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, Vershin_count, 0, Index_count/3);
    // Конец сцены
    pDirect3DDevice->EndScene();       
    // Выводим на экран из заднего буфера
    pDirect3DDevice->Present( NULL, NULL, NULL, NULL );
	Sleep(10);
}
//-----------------------------------------------------------------------------------
//  Освобождает захваченные ресурсы
//-----------------------------------------------------------------------------------
VOID DeleteDirect3D()
{
     if( pTextura001 != NULL )
        pTextura001->Release();

     if( pBufferIndex  != NULL)
        pBufferIndex->Release(); 

    if( pBufferVershin  != NULL)
        pBufferVershin->Release(); 

    if( pDirect3DDevice != NULL) 
        pDirect3DDevice->Release();

    if( pDirect3D != NULL)
        pDirect3D->Release();
}
//-----------------------------------------------------------------------------------
// Здесь происходит обработка сообщений
//-----------------------------------------------------------------------------------
LRESULT CALLBACK MainWinProc(HWND   hwnd,            
					        UINT    msg,              
                            WPARAM  wparam,           
                            LPARAM  lparam)          
{
switch(msg)
	{	
	
     case WM_DESTROY: 
		{
		DeleteDirect3D();
		PostQuitMessage(0);
		return(0);
		} 
     case WM_KEYDOWN: 
		{
			//out << wparam << endl;
		if(wparam == VK_ADD)		//+
		{
			V.Eye.z /= 1.05f;
		}
		if(wparam == VK_SUBTRACT)	//-
		{
			V.Eye.z *= 1.05f;
		}
		if(wparam == VK_LEFT)		//<-
		{
			V.Eye.x -= 0.5f;
		}
		if(wparam == VK_RIGHT)		//->
		{
			V.Eye.x += 0.5f;
		}
		if(wparam == VK_UP)			//^
		{
			V.Eye.y += 0.5f;
		}
		if(wparam == VK_DOWN)		//v
		{
			V.Eye.y -= 0.5f;
		}
        if(wparam == VK_ESCAPE)
        PostQuitMessage(0);
		return 0;
		}
    } 
  return DefWindowProc(hwnd, msg, wparam, lparam);
} 
//-----------------------------------------------------------------------------------
// Функция
// WinMain
// Входная точка приложения
//-----------------------------------------------------------------------------------

int WINAPI WinMain(	HINSTANCE hinstance,
					HINSTANCE hprevinstance,
					LPSTR lpcmdline,
					int ncmdshow)
{

WNDCLASSEX windowsclass;  // Создаем класс
HWND	   hwnd;	      // Создаем дескриптор окна
MSG        msg;           // Идентификатор сообщения

// Определим класс окна WNDCLASSEX
windowsclass.cbSize         = sizeof(WNDCLASSEX);
windowsclass.style			= CS_CLASSDC;
windowsclass.lpfnWndProc	= MainWinProc;
windowsclass.cbClsExtra		= 0;
windowsclass.cbWndExtra		= 0;
windowsclass.hInstance		= GetModuleHandle(NULL);//hinstance;
windowsclass.hIcon			= NULL;
windowsclass.hCursor		= NULL;
windowsclass.hbrBackground	= NULL;
windowsclass.lpszMenuName	= NULL;
windowsclass.lpszClassName	= "WINDOWSCLASS";
windowsclass.hIconSm        = NULL;

// начальное положение камеры
/*V.X = 400;
V.Y = 300;
V.Eye.x = 0;
V.Eye.y = 0;
V.Eye.z = -30;
V.u.x = 0;
V.u.y = 1;
V.u.z = 0;
V.v.x = 1;
V.v.y = 0;
V.v.z = 0;
V.w.x = 0;
V.w.y = 0;
V.w.z = 1;
V.O = D3DX_PI/4;
V.N = 1;*/

// чтение параметров
{
	ifstream in("in.txt");
	in >> V.X;
	in >> V.Y;
	in >> V.Eye.x;
	in >> V.Eye.y;
	in >> V.Eye.z;
	in >> V.u.x;
	in >> V.u.y;
	in >> V.u.z;
	in >> V.v.x;
	in >> V.v.y;
	in >> V.v.z;
	in >> V.w.x;
	in >> V.w.y;
	in >> V.w.z;
	in >> V.O; V.O *= D3DX_PI;
	in >> V.N;
	FONG fongs[100];
	float a1,a2,a3,a4,a5,a6,a7,a8,a9;
	int N, i, ind;	
	// свойства материалов
	in >> N;
	for(i = 1; i <= N; i++)
	{
		in >> fongs[i].Ka >> fongs[i].Kd >> fongs[i].Ks >> fongs[i].Kp;
	}
	// источники
	in >> N;
	for(i = 1; i <= N; i++)
	{
		in >> a1 >> a2 >> a3 >> a4 >> a5 >> a6;
		add_light(a1,a2,a3,a4,a5,a6);
	}
	// сферы
	in >> N;
	for(i = 1; i <= N; i++)
	{
		in >> a1 >> a2 >> a3 >> a4 >> ind;
		add_sphare(a1,a2,a3,a4, fongs[ind]);
	}
	// цилиндры
	in >> N;
	for(i = 1; i <= N; i++)
	{
		in >> a1 >> a2 >> a3 >> a4 >> a5 >> a6 >> a7 >> a8 >> a9 >> ind;
		add_cylinder(a1,a2,a3,a4,a5,a6,a7,a8,a9, fongs[ind]);
	}
	in.close();
}
/*
FONG fong1 = {0, 2.0f, 1.0f, 20};
FONG fong2 = {0, 1.0f, 0.0f, 20};
FONG fong3 = {0, 0.9f, 0.8f, 20};
FONG fong4 = {0.05f, 0.0f, 0.9f, 10};

add_light(-7,0,-15, 35.f,0.f,0.f);
add_light(4.5f,0.0f,-10.0f, 0.0f,0.0f,2.5f);
add_light(0.3f,-1.7f,-11.7f, 0.5f,0.5f,0.5f);
add_light(-1,-1,-25, 0.f,0.01f,0.f);

add_sphare(2,0,-10, 3, fong1);
add_sphare(-2,0,-5, 1, fong2);
add_sphare(-2,-2,-12, 0.4f, fong3);
add_sphare(-3,0,-13.0f, 0.2f, fong4);

add_cylinder(-3,-1,-13, 1.f,2.f,1.f, 0.2f, 0, 3, fong1);
add_cylinder(12,10,10, -1.f,-1.f,-2.f, 0.15f, 0, 50, fong1);
add_cylinder(-1,-1,-25, 0.f,-1.f,-1.f, .05f, -.2f, .2f, fong1);
*/
/*
add_light(.2f,0,-25, 0.f,10.f,0.f);
add_light(-.2f,0,-25, 0.f,0.f,10.f);
add_sphare( .1f,0,-25, .2f, fong3);
add_sphare(-.1f,0,-25, .2f, fong3);
*/

// Зарегистрируем класс
if (!RegisterClassEx(&windowsclass))
{
	out << "windowsclass dnt registered" << endl;
	return 0;
}
else
{
	out << "windowsclass registered" << endl;
}   

// Теперь когда класс зарегестрирован можно создать окно

if (!(hwnd = CreateWindowEx(NULL,              // стиль окна
                       "WINDOWSCLASS",         // класс
					   "Hello!",               // название окна
					   WS_OVERLAPPEDWINDOW | WS_VISIBLE,//перекрывающееся, видимое окно
					   0,0,	                   // левый верхний угол
					   800,// ширина <GetSystemMetrics(SM_CXSCREEN)
					   600,// высота <GetSystemMetrics(SM_CYSCREEN)
					   GetDesktopWindow(),	   // дескриптор родительского окна 
					   NULL,	               // дескриптор меню
					   hinstance,              // дескриптор экземпляра приложения
					   NULL)))	               // указатель на данные окна                                            
{
	out << "window dnt created" << endl;
	return 0;
}
else
{
	out << "window created" << endl;
}   
     
 if( SUCCEEDED( InitialDirect3D( hwnd ) ) )
  { 
       if( SUCCEEDED( InitialObject( ) ) )
	    {
           ShowWindow( hwnd, SW_SHOWDEFAULT );
           UpdateWindow( hwnd );

              ZeroMemory( &msg, sizeof(msg));
              while( msg.message!=WM_QUIT) 
                {
                  if(PeekMessage( &msg, NULL,0,0,PM_REMOVE ))
		           {
			          TranslateMessage( &msg );
                      DispatchMessage( &msg );
                   }
                  else
                  RenderingDirect3D();
                } 
        }
  } 
   return 0;
}