Добавил:
Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз: Предмет: Файл:

ИГС / Lab_03 / SurfBSpline / SurfBSpline / SurfBSpline

.cpp
Скачиваний:
6
Добавлен:
17.04.2018
Размер:
18.8 Кб
Скачать
//пустая коробка и координатные оси мировой системы координат
//проектируются ортографически на видовую систему координат

//вращение одной системы координат относительно другой
//выполнятеся с помощь мышки и стрелок клавиатуры

//рисуем элементарную B-сплайновую поверхности

#define STRICT
#include <windows.h>
#include <math.h>
#include <stdio.h>
#include <tchar.h>

// Имя класса окна
WCHAR Cname[] = L"SurfClass";      
// Заголовок окна
WCHAR Title[] = L"Korneev V.        "
          L" Elementary B-spline Surface     rotation  by  mouse  and  keyboard (arrows) ";  

//углы поворота видовой системы координат
struct ANGLS {
	double fi, teta;
};

static ANGLS angl,anglOld;

//координаты точек в мировой системе координат
struct POINT3 {
	double x, y, z;
};

static POINT3 Point[8];

//флаги для работы с мышкой
struct TDATA {

	BOOL ButtonDown;
	BOOL Drawing;
};

static TDATA Dat;

//координаты мышки
struct CORD {
	int x, y;
};

static CORD corOld;

//координаты в пикселях на экране
struct POINT2 {
	int x, y;
};



//прототипы функций
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
void SurfCreate();
void SurfDestroy();
void SurfPaint(HWND);
void DrawBox(HDC, ANGLS);
void PointCorns();
void SurfDC(HWND);
void SurfLButtonDown(int,int);
void SurfMouseMove(int,int);
void SurfLButtonUp();
void PointCorns();
void Picture(HDC);
void Axes(HDC);
inline double Xe(double,double);
inline double Ye(double,double,double);
inline int xn(double);
inline int ym(double);
void SplineSurf(HDC);



int WINAPI WinMain(HINSTANCE hInstance,       //идентификатор приложения
				   HINSTANCE hPrevInstance,
				   LPSTR     lpCmdParam, 
				   int       nCmdShow)     
{

	
	MSG msg;    // структура для работы с сообщениями
	
	//регистрация класса окна приложения
	//------------------------------------------------------------------------
	WNDCLASS wc;  // структура для регистрации класса окна приложения

	wc.style          = 0; 
	wc.lpfnWndProc    = (WNDPROC)WndProc;         //адрес функции окна
	wc.cbClsExtra     = 0;       
	wc.cbWndExtra     = 0;       
	wc.hInstance      = hInstance;       //идентификатор приложения
	wc.hIcon          = LoadIcon(hInstance, (LPCTSTR)IDI_APPLICATION); 
	wc.hCursor		  = LoadCursor(NULL, IDC_ARROW);  
	wc.hbrBackground  = (HBRUSH)GetStockObject(GRAY_BRUSH);   
	wc.lpszMenuName   = 0;       
	wc.lpszClassName  = Cname;      

	if(!RegisterClass(&wc))  //регистрация класса окна приложения
		return 0;


	//создание окна приложения
	//------------------------------------------------------------------------
	 HWND hWnd;       // идентификатор окна приложения

	 hWnd = CreateWindow(Cname,
						 Title,
						 WS_OVERLAPPEDWINDOW,
                         0, //x - координата л.в. угла
                         0,  //y - координата л.в. угла
                         1024, //ширина окна
                         768, //высота окна
//						 CW_USEDEFAULT, 
//						 CW_USEDEFAULT, 
//						 CW_USEDEFAULT, 
//						 CW_USEDEFAULT, 
						 NULL,         //идентификатор окна-родителя     
						 NULL,          //идентификатор меню
						 hInstance,     //идентификатор приложения
						 NULL);         

	if(!hWnd)
		return 0;


	// Рисуем окно. Для этого после функции ShowWindow,
    // рисующей  окно, вызываем функцию UpdateWindows,
    // посылающую сообщение WM_PAINT в функцию окна
 	//--------------------------------------------------------------------------
	ShowWindow(hWnd,nCmdShow);
	UpdateWindow(hWnd); 


	// Запускаем цикл обработки сообщений
	//-------------------------------------------------------------------------
  
	while(GetMessage(&msg,NULL,0,0)) 
	{
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}

	return 0;

}



//оконная процедура обрабатывающая сообщения
LRESULT CALLBACK  WndProc(HWND hwnd, UINT msg,
						WPARAM wParam, LPARAM lParam)
{
	int x,y;
	switch(msg)
	{
		case WM_CREATE:
			SurfCreate();
			break;

		case WM_PAINT:
			SurfPaint(hwnd);
			break;
		case WM_LBUTTONDOWN:
				x = LOWORD(lParam);
				y = HIWORD(lParam);
				SurfLButtonDown(x,y);
			break;

		case WM_LBUTTONUP:
				SurfLButtonUp();
			break;


		case WM_MOUSEMOVE:
				x = LOWORD(lParam);
				y = HIWORD(lParam);
				SurfMouseMove(x,y);
				SurfDC(hwnd);
			break;

		case WM_DESTROY:
			SurfDestroy();
			break;

		case WM_KEYDOWN:
			switch(wParam)
			{
				case VK_LEFT:
					angl.fi += 10;
					SurfDC(hwnd);
					break;

				case VK_RIGHT:
					angl.fi -= 10;
					SurfDC(hwnd);
					break;

				case VK_UP:
					angl.teta += 10;
					SurfDC(hwnd);
					break;

				case VK_DOWN:
					angl.teta -= 10;
					SurfDC(hwnd);
					break;
			}
			break;



		default:
			return DefWindowProc(hwnd,msg,wParam,lParam);
	}

	return 0L;
}



//размеры поля вывода в мировых координатах и в пикселях
double xe1, xe2, ye1, ye2;
int    ne1, ne2, me1, me2;

//максимальные длины координатных осей - мировые координтаы
  double xmax, ymax, zmax;

//угловые коэффициенты
double sf,cf,st,ct;


//координаты 16-ти опорных векторов
//для элементарной B-сплайновой поверхности
POINT3 Ve[4][4];


//Текстура, число точек в рисунке текстуры
const int Ntext = 100;
//координты текстуры
double ut[Ntext], vt[Ntext];




//Выполняется при создании окна
void SurfCreate()
{
	//размеры поля вывода в мировых координатах и в пикселях
	xe1 = -4.5;  xe2 =   4.5; ye1 =  -4.5; ye2 =  4.5;
	ne1 = 150; ne2 = 850; me1 = 720; me2 = 40;

	//максимальные длины координатных осей - мировые координтаы
	xmax=3., ymax=3., zmax=3.;


	//углы поворота системы координат - начальные значения
	angl.fi = 30; angl.teta = 60;

	//координаты коробки в мировой системе координат
	PointCorns();

	//располагаем 16 точек на элементе сферичской поверхности
	double phi, tet, dphi, dtet;
	double phib, phie, tetb, tete;
	int Nphi=4, Ntet = 4;
	phib = 0; phie = 120; tetb = 20; tete = 90;
	dphi = (phie - phib)/(Nphi-1); dtet = (tete - tetb)/(Ntet-1);

	//задаем значения основных опорных точек в мировой системе координат
	for(int n = 0; n < Nphi; n++)
	{
   		phi = phib + dphi*n;
		for(int m = 0; m < Ntet; m++)
		{
      		tet = tetb + dtet*m;
	      	Ve[n][m].x = 4*sin(3.14159/180*tet)*cos(3.14159/180*phi);
		  	Ve[n][m].y = 4*sin(3.14159/180*tet)*sin(3.14159/180*phi);
			Ve[n][m].z = 4*cos(3.14159/180*tet);
		}
	}


	//Задается массив для рисунка текстуры
	double ro, t, dt = 6.28/(Ntext-1);
	for(int i=0; i<Ntext; i++)
	{
   		t = dt*i;
		ro = 0.5*cos(4.*t)*cos(4.*t);
		ut[i] = ro*cos(t)+0.5;
		vt[i] = ro*sin(t)+0.5;
	}

}


//Выполняется при закрытии окна
void SurfDestroy()
{
	PostQuitMessage(0);   //закрываем окно
}


//четыре В-сплайновые функции
double Bspline(int i, double t)
{
	double b;
	double t2 = t*t, t3 = t2*t;
	switch(i)
	{
	case 0:  b = (1 - 3*t + 3*t2 -   t3)/6; break;
	case 1:  b = (4       - 6*t2 + 3*t3)/6; break;
	case 2:  b = (1 + 3*t + 3*t2 - 3*t3)/6; break;
	case 3:  b =                     t3/6;  break;
	}
	return b;
}



//элементарная B-сплайновая поверхность
POINT3 BsplineSurf(double u, double v)
{
	POINT3 Bz;
	
	double Bzu[4], Bzv[4];
	for(int n=0; n<4; n++)
	{
		Bzu[n] = Bspline(n,u);  Bzv[n] = Bspline(n,v);
	}
	
	Bz.x = 0; Bz.y = 0; Bz.z = 0;
	for(int i=0; i<4; i++)
		for(int j=0; j<4; j++)
		{
			Bz.x += Bzu[i]*Bzv[j]*Ve[i][j].x;
			Bz.y += Bzu[i]*Bzv[j]*Ve[i][j].y;
			Bz.z += Bzu[i]*Bzv[j]*Ve[i][j].z;
		}
	return Bz;
}



//Рисует картину в ответ на сообщение WM_PAINT
void SurfPaint(HWND hwnd)
{
	PAINTSTRUCT ps;

	//получаем контест экрана
	HDC hdcWin = BeginPaint(hwnd, &ps);

	//рисуем графические объекты
	Picture(hdcWin);

	//освобождаем контекст экрана
	EndPaint(hwnd, &ps);
}

//Рисует картину в ответ на сообщение WM_MOUSEMOVE
void SurfDC(HWND hwnd)
{

	//получаем контест экрана
	HDC hdcWin = GetDC(hwnd);

	//рисуем графические объекты
	Picture(hdcWin);

	//освобождаем контекст экрана
	ReleaseDC(hwnd, hdcWin);

}



//рисуем графические объекты
void Picture(HDC hdcWin)
{
	//создаем контекст памяти связаный с контекстом экрана
	HDC hdcMem = CreateCompatibleDC(hdcWin); 
	//создаем битовую карту совместмую с контекстом экрана
	HBITMAP hBitmap = CreateCompatibleBitmap(hdcWin, ne2, me1); 
    //помещаем битовую карту в контекст памяти
    HBITMAP hBitmapOld = (HBITMAP)SelectObject(hdcMem, hBitmap); 

	//создание прямоугольной области для вывода углов поворота
	HRGN hrgn1 = CreateRectRgn(ne1,me2-30,ne2,me2-2);

	//заливаем выделенную область светлоголубым цветом
	HBRUSH hBrush0 = CreateSolidBrush(RGB(0xA6,0xCA,0xF0));
    FillRgn(hdcMem,hrgn1,hBrush0);
	//обведение границы области заданной кистью
	HBRUSH hBrush1 = CreateSolidBrush(RGB(0xFF,0xFF,0xC0));
	FrameRgn(hdcMem,hrgn1,hBrush1,2,2);

	//выводим значения углов поворота в область hrgn1
	TCHAR ss[20];
	SetBkColor(hdcMem,RGB(0xA6,0xCA,0xF0));
	SetTextColor(hdcMem,RGB(0,0,0x80));
	swprintf_s(ss,20,_T("fi = %4.0lf"),angl.fi);
	TextOut(hdcMem,(ne1+ne2)/2-80,me2-25,ss,9);
	swprintf_s(ss,20,_T("teta = %4.0lf"),angl.teta);
	TextOut(hdcMem,(ne1+ne2)/2+20,me2-25,ss,11);

	//удаляем область hrgn1
	DeleteObject(hrgn1); 

	//создание прямоугольной области в которой рисуем графический объект
	HRGN hrgn2 = CreateRectRgn(ne1,me2,ne2,me1);

	//заливаем выделенную область светлосерым цветом
	HBRUSH hBrush2 = CreateSolidBrush(RGB(0xC0,0xC0,0xC0));
	FillRgn(hdcMem,hrgn2,hBrush2);

	//ограничиваем область вывода изображения
	SelectClipRgn(hdcMem,hrgn2);

	//вычисляем синусы и косисинусы новых значений углов поворота
	sf=sin(3.14159*angl.fi/180);
	cf=cos(3.14159*angl.fi/180);
	st=sin(3.14159*angl.teta/180);
	ct=cos(3.14159*angl.teta/180);

	//рисуем координатные оси
	Axes(hdcMem);


	SplineSurf(hdcMem);


	//рисуем коробку 
	DrawBox(hdcMem, angl);
	
	//копируем контекст памяти в контекст экрана
	BitBlt(hdcWin,ne1,me2-30,ne2,me1,hdcMem,ne1,me2-30,SRCCOPY); 
   

	//убираем созданные графические объекты
	DeleteObject(hBrush0);
	DeleteObject(hBrush1);
	DeleteObject(hBrush2);
	DeleteObject(hrgn2);

	SelectObject(hdcMem, hBitmapOld); //востанавливаем контекст памяти
	DeleteObject(hBitmap); //убираем битовую карту
	DeleteDC(hdcMem);  //  освобождаем контекст памяти
}



//рисуем сплайновую поверхность
void SplineSurf(HDC hdc)
{

	//рисуем сплайновую поверхностьс Безье с помощью линий
	HPEN hPen1 = CreatePen(PS_SOLID,1,RGB(255,255,0));
	HPEN hPenOld = (HPEN)SelectObject(hdc,hPen1);

	double xt,yt,zt,xe,ye;
	int x1, y1, x2, y2;
	
	//"горизонтальные линии"
	//число горизонтальных линий
	int Nsp = 2;
	int Ns = 10;
	double v, u, du = 1.0/(Ns-1), dv = 1.0/(Nsp-1);

	for (int i=0; i<Nsp; i++)
	{
   		v = dv*i;
		u = 0;

		xt = BsplineSurf(u,v).x;
		yt = BsplineSurf(u,v).y;
		zt = BsplineSurf(u,v).z;

		xe = Xe(xt,yt);
		ye = Ye(xt,yt,zt);

		x1 = xn(xe);
		y1 = ym(ye);

        MoveToEx(hdc,x1,y1,0);

		for(int j=1; j<Ns; j++)
		{
			u = du*j;

			xt = BsplineSurf(u,v).x;
			yt = BsplineSurf(u,v).y;
			zt = BsplineSurf(u,v).z;

			xe = Xe(xt,yt);
			ye = Ye(xt,yt,zt);

			x1 = xn(xe);
			y1 = ym(ye);

			LineTo(hdc,x1,y1);
		}

	}

	//"вертикальные линии"
	//число ветикальных линий
	int Msp = 2;
	int Ms = 10;
   	dv = 1.0/(Ms-1); du = 1.0/(Msp-1);

	for (int i=0; i<Msp; i++)
	{
   		u = du*i;
		v = 0;

		xt = BsplineSurf(u,v).x;
		yt = BsplineSurf(u,v).y;
		zt = BsplineSurf(u,v).z;

		xe = Xe(xt,yt);
		ye = Ye(xt,yt,zt);

		x1 = xn(xe);
		y1 = ym(ye);

       	MoveToEx(hdc,x1,y1,0);

		for(int j=1; j<Ms; j++)
		{
			v = dv*j;

			xt = BsplineSurf(u,v).x;
			yt = BsplineSurf(u,v).y;
			zt = BsplineSurf(u,v).z;

			xe = Xe(xt,yt);
			ye = Ye(xt,yt,zt);

			x1 = xn(xe);
			y1 = ym(ye);

			LineTo(hdc,x1,y1);
		}
	}


	//рисуем узор текстуры
	HPEN hPen3 = CreatePen(PS_SOLID,1,RGB(100,100,255));
	SelectObject(hdc,hPen3);

	
	xt = BsplineSurf(ut[0],vt[0]).x;
	yt = BsplineSurf(ut[0],vt[0]).y;
	zt = BsplineSurf(ut[0],vt[0]).z;

	xe = Xe(xt,yt);
	ye = Ye(xt,yt,zt);

	x1 = xn(xe);
	y1 = ym(ye);

    MoveToEx(hdc,x1,y1,0);

	for(int k=1; k<Ntext; k++)
	{
		xt = BsplineSurf(ut[k],vt[k]).x;
		yt = BsplineSurf(ut[k],vt[k]).y;
		zt = BsplineSurf(ut[k],vt[k]).z;

		xe = Xe(xt,yt);
		ye = Ye(xt,yt,zt);

		x1 = xn(xe);
		y1 = ym(ye);

		LineTo(hdc,x1,y1);
	}



	//рисуем полигональную сетку с помощью линий белого цветоа

	HPEN hPen2 = CreatePen(PS_SOLID,1,RGB(255,255,255));
	SelectObject(hdc,hPen2);

	//горизонтальные линии
   for(int m = 0; m <4; m++)
   {
		xe = Xe(Ve[0][m].x,Ve[0][m].y);
		ye = Ye(Ve[0][m].x,Ve[0][m].y,Ve[0][m].z);
		x1=xn(xe);
		y1=ym(ye);
		for(int k=1; k<4; k++)
		{
			xe = Xe(Ve[k][m].x,Ve[k][m].y);
			ye = Ye(Ve[k][m].x,Ve[k][m].y,Ve[k][m].z);
			x2 = xn(xe);
			y2 = ym(ye);
			MoveToEx(hdc,x1,y1,0);
			LineTo(hdc,x2,y2);

			x1 = x2; y1 = y2;
		}
	}

	//вертикальные  линии
   for(int k = 0; k <4; k++)
   {
		xe = Xe(Ve[k][0].x,Ve[k][0].y);
		ye = Ye(Ve[k][0].x,Ve[k][0].y,Ve[k][0].z);
		x1=xn(xe);
		y1=ym(ye);
		for(int m=1; m<4; m++)
		{
			xe = Xe(Ve[k][m].x,Ve[k][m].y);
			ye = Ye(Ve[k][m].x,Ve[k][m].y,Ve[k][m].z);
			x2 = xn(xe);
			y2 = ym(ye);
			MoveToEx(hdc,x1,y1,0);
			LineTo(hdc,x2,y2);

			x1 = x2; y1 = y2;
		}
	}

	

	//востанавливаем в контексте старое перо
	SelectObject(hdc,hPenOld);
	//убираем созданные графические объекты
	DeleteObject(hPen1);
	DeleteObject(hPen2);
	DeleteObject(hPen3);
	
}




//рисуем координатные оси
void Axes(HDC hdc)
{
	//выбираем цвет для координатных осей
	HPEN hPen = CreatePen(PS_SOLID,1,RGB(0,255,255));
	HPEN hPenOld = (HPEN)SelectObject(hdc,hPen);

	//координаты проектируемой точки в видовой системе координат
	double xe, ye;
	//координаты пикселов
	int x1,y1,x2,y2;

	//рисуем ось Ox
	xe=Xe(-xmax/3,0);
	ye=Ye(-xmax/3,0,0);
	x1=xn(xe);
	y1=ym(ye);             
	xe=Xe(1.5*xmax,0);
	ye=Ye(1.5*xmax,0,0);
	x2=xn(xe);
	y2=ym(ye);
	MoveToEx(hdc,x1,y1,0);
	LineTo(hdc,x2,y2);

	//делаем надпись на оси заданным цветом
	SetBkColor(hdc,RGB(0xC0,0xC0,0xC0));
	SetTextColor(hdc,RGB(120,120,120));
	TextOut(hdc,x2, y2, _T("X"),1);
	
	//рисуем ось Oy
	xe=Xe(0,-ymax/3);
	ye=Ye(0,-ymax/3,0);
	x1=xn(xe);
	y1=ym(ye);
	xe=Xe(0,1.5*ymax);
	ye=Ye(0,1.5*ymax,0);
	x2=xn(xe);
	y2=ym(ye);
	MoveToEx(hdc,x1,y1,0);
	LineTo(hdc,x2,y2);

	TextOut(hdc,x2, y2, _T("Y"),1);

	//рисуем ось Oz
	xe=Xe(0,0);
	ye=Ye(0,0,-zmax/3);
	x1=xn(xe);
	y1=ym(ye);
	xe=Xe(0,0);
	ye=Ye(0,0,1.5*zmax);
	x2=xn(xe);
	y2=ym(ye);
	MoveToEx(hdc,x1,y1,0);
	LineTo(hdc,x2,y2);

	TextOut(hdc,x2, y2, _T("Z"),1);

	//востанавливаем в контексте старое перо
	SelectObject(hdc,hPenOld);
	//убираем созданные графические объекты
	DeleteObject(hPen);

}

//координаты коробки - в мировой системе координат
void	PointCorns()
{
	Point[0].x =  xmax; Point[0].y =  ymax; Point[0].z = -zmax;
	Point[1].x = -xmax; Point[1].y =  ymax; Point[1].z = -zmax;
	Point[2].x = -xmax; Point[2].y = -ymax; Point[2].z = -zmax;
	Point[3].x =  xmax; Point[3].y = -ymax; Point[3].z = -zmax;
	Point[4].x =  xmax; Point[4].y =  ymax; Point[4].z = zmax;
	Point[5].x = -xmax; Point[5].y =  ymax; Point[5].z = zmax;
	Point[6].x = -xmax; Point[6].y = -ymax; Point[6].z = zmax;
	Point[7].x =  xmax; Point[7].y = -ymax; Point[7].z = zmax;
}


//рисует коробку 
void DrawBox(HDC hdc, ANGLS an)
{

	HPEN hPen = CreatePen(PS_SOLID,1,RGB(160,160,160));
	HPEN hPenOld = (HPEN)SelectObject(hdc,hPen);

   double xe, ye;
	int x1,y1,x2,y2;
	double xt1,yt1,zt1,xt2,yt2,zt2;
   int j;

	for(int i=0; i<4; i++)
	{
		j = i + 1;
		if(j==4)
			j = 0;
		xt1 = Point[i].x; yt1 = Point[i].y; zt1 = Point[i].z;
		xt2 = Point[j].x; yt2 = Point[j].y; zt2 = Point[j].z;

		xe=Xe(xt1,yt1);
		ye=Ye(xt1,yt1,zt1);
		x1=xn(xe);
		y1=ym(ye);

		xe=Xe(xt2,yt2);
		ye=Ye(xt2,yt2,zt2);
		x2=xn(xe);
		y2=ym(ye);

		MoveToEx(hdc,x1,y1,0);
		LineTo(hdc,x2,y2);
	}

	for(int i=4; i<8; i++)
	{
		j = i + 1;
		if(j==8)
			j = 4;
		xt1 = Point[i].x; yt1 = Point[i].y; zt1 = Point[i].z;
		xt2 = Point[j].x; yt2 = Point[j].y; zt2 = Point[j].z;

		xe=Xe(xt1,yt1);
		ye=Ye(xt1,yt1,zt1);
		x1=xn(xe);
		y1=ym(ye);

		xe=Xe(xt2,yt2);
		ye=Ye(xt2,yt2,zt2);
		x2=xn(xe);
		y2=ym(ye);

		MoveToEx(hdc,x1,y1,0);
		LineTo(hdc,x2,y2);
	}

	for(int i=0; i<4; i++)
	{
		xt1 =   Point[i].x; yt1 =   Point[i].y; zt1 =   Point[i].z;
		xt2 = Point[i+4].x; yt2 = Point[i+4].y; zt2 = Point[i+4].z;

		xe=Xe(xt1,yt1);
		ye=Ye(xt1,yt1,zt1);
		x1=xn(xe);
		y1=ym(ye);

		xe=Xe(xt2,yt2);
		ye=Ye(xt2,yt2,zt2);
		x2=xn(xe);
		y2=ym(ye);

		MoveToEx(hdc,x1,y1,0);
		LineTo(hdc,x2,y2);
	}

	for(int i=0; i<2; i++)
	{
		xt1 =   Point[i].x; yt1 =   Point[i].y; zt1 =   Point[i].z;
		xt2 = Point[i+2].x; yt2 = Point[i+2].y; zt2 = Point[i+2].z;

		xe=Xe(xt1,yt1);
		ye=Ye(xt1,yt1,zt1);
		x1=xn(xe);
		y1=ym(ye);

		xe=Xe(xt2,yt2);
		ye=Ye(xt2,yt2,zt2);
		x2=xn(xe);
		y2=ym(ye);

		MoveToEx(hdc,x1,y1,0);
		LineTo(hdc,x2,y2);
	}

	//востанавливаем в контексте старое перо
	SelectObject(hdc,hPenOld);
	DeleteObject(hPen);

}





//переход в видовую систему координат и отрографическое проектирование
inline double Xe(double x,double y)
{
  return -sf*x+cf*y;
}

//переход в видовую систему координат и отрографическое проектирование
inline double Ye(double x,double y,double z)
{
  return -ct*cf*x-ct*sf*y+st*z;
}


//перевод видовых координат в координты пикселей
//переход от координаты x к пикселю  n
inline int xn(double x)
{
	return (int)((x - xe1)/(xe2 - xe1)*(ne2 - ne1)) + ne1;
}

//переход от координаты y к пикселю  m
inline int ym(double y)
{
	return (int)((y - ye1)/(ye2 - ye1)*(me2 - me1)) + me1;
}






//при нажатии левой кнопки мыши 
void SurfLButtonDown( int x, int y)
{
	Dat.ButtonDown = TRUE;
	Dat.Drawing = FALSE;

	anglOld.fi = angl.fi;
	anglOld.teta = angl.teta;
	corOld.x = x;
	corOld.y = y;

}



//при движении мыши и нажатой левой кнопки мыши
void SurfMouseMove(int x, int y)
{
	if(Dat.ButtonDown)
	{
		Dat.Drawing = TRUE;

		angl.fi += corOld.x-x;
		angl.teta += corOld.y-y;

		corOld.x = x; corOld.y = y;

		anglOld.fi   = angl.fi;
		anglOld.teta   = angl.teta;
	}
}



//устанавливает нужные флаги при отпускании правой кнопки мыши
void SurfLButtonUp()
{
	if(Dat.ButtonDown && Dat.Drawing)
	{
		Dat.Drawing = FALSE;
	}
	Dat.ButtonDown = FALSE;
}





Соседние файлы в папке SurfBSpline
  • #
    17.04.201818.8 Кб6SurfBSpline.cpp
  • #
    17.04.20184.21 Кб6SurfBSpline.vcproj
  • #
    17.04.20181.42 Кб6SurfBSpline.vcproj.VICTOR1.victor.user