6. Чертеж сцены
В данной работе сцена состоит из 9 одинаковых сфер и 20 цилиндров. Восемь сфер лежат в вершинах абстрактного куба, а еще одна сфера находится на пересечении диагоналей куба.
Двенадцать цилиндров лежат на ребрах куба, а еще восемь цилиндров соединяют сферы, лежащие в вершинах куба, с центральной сферой.
Проекции на три плоскости полученного трехмерного объекта:
XOY XOZ YOZ
7. Текст программы
#include <windows.h>
#include <d3dx9.h>
#include <dinput.h>
#pragma comment(lib,"dinput8.lib");
#pragma comment(lib,"dxguid.lib");
#pragma comment(lib,"d3d9.lib");
#pragma comment(lib, "d3dx9.lib");
#define KEYDOWN(name, key)(name[key]&0x80)
HWND hwnd;
HINSTANCE inst;
void WINAPI InitialInput();
char keyboard[256]; // Буфер
DIMOUSESTATE mouse;
struct CAMERA
{
float RotateDown;
float RotateRight;
float MoveForward;
float MoveUp;
float MoveRight;
}cam;
bool lig1=true,lig2=true,lig3=true,ligp1=false,ligp2=false,ligp3=false;
int speedx=0,speedy=0,speedz=0;
bool spxp=false,spyp=false,spzp=false;
bool f=false,k=false;
POINT thisPos;
POINT prevPos;
D3DXMATRIX matView,m,p,l;
IDirect3D9 *D3dObject;
IDirect3DDevice9 *D3dDevice;
ID3DXMesh *Mesh;
ID3DXMesh *Mesh1;
const float anglePlusX = D3DX_PI/180;
const float anglePlusY = D3DX_PI/180;
const float anglePlusZ = D3DX_PI/180;
float rotX = 0, rotY = 0, rotZ = 0;
struct Vertex
{
D3DXVECTOR3 pos;
D3DXVECTOR3 n;
};
#define CUSTOM_FVF (D3DFVF_XYZ | D3DFVF_NORMAL)
const int nGridX = 200;
const int nGridAngle = 50;
const float nstepAngle = D3DX_PI/2 / nGridAngle;
const int nnumVertices = nGridAngle * nGridX * 6 ;
const int mGridAngle = 100;
const float mstepAngle = D3DX_PI/2 / mGridAngle;
const int mnumVertices = mGridAngle * mGridAngle * 6 ;
void __stdcall TimerProc
(
HWND hwnd,
UINT uMsg,
UINT_PTR idEvent,
DWORD dwTime
);
LRESULT __stdcall MainWindowProc
(
HWND hwnd,
UINT msg,
WPARAM wParam,
LPARAM lParam
);
void DrawWindowArea(HWND hwnd);
int __stdcall WinMain
(
HINSTANCE instance,
HINSTANCE previousInstance,
LPSTR commandLine,
int commandShow
)
{
inst=instance;
WNDCLASS wc;
ZeroMemory(&wc, sizeof(wc));
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.hInstance = instance;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.lpszClassName = L"mywndclass";
wc.lpfnWndProc = MainWindowProc;
if( !RegisterClass(&wc) )
return 0;
HWND AppWnd = CreateWindow
(
L"mywndclass",
L"Визуализация трехмерной модели",
WS_OVERLAPPEDWINDOW,
40, 40, 1000, 1000,
NULL,
NULL,
instance,
NULL
);
if( !AppWnd )return 0;
D3dObject = Direct3DCreate9(D3D_SDK_VERSION);
if( !D3dObject )return 0;
D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory( &d3dpp, sizeof(d3dpp) );
d3dpp.Windowed = TRUE;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.EnableAutoDepthStencil = TRUE;
d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
d3dpp.BackBufferHeight = 1024;
d3dpp.BackBufferWidth = 1280;
HRESULT res;
res = D3dObject -> CreateDevice
(
D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
AppWnd,
D3DCREATE_HARDWARE_VERTEXPROCESSING,
&d3dpp,
&D3dDevice
);
if( res != D3D_OK )
{
D3dObject -> Release();
return 0;
}
//Mesh для цилиндра
Vertex *p;
int k = 0;
ID3DXMesh *MeshTmp;
res = D3DXCreateMeshFVF
(
nnumVertices/3,
nnumVertices,
D3DXMESH_SYSTEMMEM,
CUSTOM_FVF,
D3dDevice,
&MeshTmp
);
if( res != D3D_OK )
{
D3dDevice -> Release();
D3dObject -> Release();
return 0;
}
MeshTmp -> LockVertexBuffer(0, (void**)&p);
float r=0.125, l=1.3;
float nstepX = l/nGridX;
for(int i = -nGridX/2; i < nGridX/2; ++i)
for(int j = 0; j < nGridAngle; ++j)
{
float x1, y1, z1;
float x2, y2, z2;
float x3, y3, z3;
float rot = j * nstepAngle;
float rotNext = rot + nstepAngle;
float cosRot = cosf(rot);
float cosRotNext = cosf(rotNext);
float sinRot = sinf(rot);
float sinRotNext = sinf(rotNext);
x1 = i* nstepX;
y1 = r * cosRot;
z1 = r * sinRot;
p[k].pos = D3DXVECTOR3(x1, y1, z1);
p[k].n.x = 0;
p[k].n.y = cosRot;
p[k].n.z = sinRot;
++k;
x2 = x1;
y2 = r * cosRotNext;
z2 = r * sinRotNext;
p[k].pos = D3DXVECTOR3(x2, y2, z2);
p[k].n.x = 0;
p[k].n.y = cosRotNext;
p[k].n.z = sinRotNext;
++k;
x3 = x1 + nstepX;
y3 = r * cosRot;
z3 = r * sinRot;
p[k].pos = D3DXVECTOR3(x3, y3, z3);
p[k].n.x = 0;
p[k].n.y = cosRot;
p[k].n.z = sinRot;
++k;
p[k].pos = D3DXVECTOR3(x3, y3, z3);
p[k].n = p[k-1].n;
++k;
p[k].pos = D3DXVECTOR3(x2, y2, z2);
p[k].n = p[k-3].n;
++k;
p[k].pos = D3DXVECTOR3(x3, y2, z2);
p[k].n = p[k-4].n;
++k;
}
MeshTmp -> UnlockVertexBuffer();
WORD *indexBuf;
MeshTmp -> LockIndexBuffer(0, (void**)&indexBuf);
for(int i = 0; i < nnumVertices; ++i)indexBuf[i] = i;
MeshTmp -> UnlockIndexBuffer();
DWORD *adjArray = new DWORD[ nnumVertices * sizeof(DWORD) ];
D3DXWeldVertices
(
MeshTmp,
0,
0,
NULL,
adjArray,
NULL,
NULL
);
MeshTmp -> OptimizeInplace
(
D3DXMESHOPT_COMPACT,
adjArray,
NULL,
NULL,
NULL
);
MeshTmp -> CloneMeshFVF
(
D3DXMESH_WRITEONLY,
CUSTOM_FVF,
D3dDevice,
&Mesh
);
MeshTmp -> Release();
//Mesh для шара
ID3DXMesh *MeshTmp1;
res = D3DXCreateMeshFVF
(
mnumVertices/3,
mnumVertices,
D3DXMESH_SYSTEMMEM,
CUSTOM_FVF,
D3dDevice,
&MeshTmp1
);
if( res != D3D_OK )
{
D3dDevice -> Release();
D3dObject -> Release();
return 0;
}
MeshTmp1 -> LockVertexBuffer(0, (void**)&p);
k = 0;
float R = 0.4;
for(int i = 0; i < mGridAngle; ++i)
{
for(int j = 0; j < mGridAngle; ++j)
{
float x1, y1, z1;
float x2, y2, z2;
float x3, y3, z3;
float Arot = i * mstepAngle;
float ArotNext = Arot + mstepAngle;
float Brot = j * mstepAngle;
float BrotNext = Brot + mstepAngle;
float AcosRot = cosf(Arot);
float AcosRotNext = cosf(ArotNext);
float AsinRot = sinf(Arot);
float AsinRotNext = sinf(ArotNext);
float BcosRot = cosf(Brot);
float BcosRotNext = cosf(BrotNext);
float BsinRot = sinf(Brot);
float BsinRotNext = sinf(BrotNext);
x1 = R * AsinRot * BcosRot;
y1 = R * AcosRot;
z1 = R * AsinRot * BsinRot;
p[k].pos = D3DXVECTOR3(x1, y1, z1);
p[k].n.x = AsinRot * BcosRot;
p[k].n.y = AcosRot;
p[k].n.z = AsinRot * BsinRot;
++k;
x2 = R * AsinRot * BcosRotNext;
y2 = R * AcosRot;
z2 = R * AsinRot * BsinRotNext;
p[k].pos = D3DXVECTOR3(x2, y2, z2);
p[k].n.x = AsinRot * BcosRotNext;
p[k].n.y = AcosRot;
p[k].n.z = AsinRot * BsinRotNext;
++k;
x3 = R * AsinRotNext * BcosRot;
y3 = R * AcosRotNext;
z3 = R * AsinRotNext * BsinRot;
p[k].pos = D3DXVECTOR3(x3, y3, z3);
p[k].n.x = AsinRotNext * BcosRot;
p[k].n.y = AcosRotNext;
p[k].n.z = AsinRotNext * BsinRot;
++k;
p[k].pos = D3DXVECTOR3(x3, y3, z3);
p[k].n = p[k-1].n;
++k;
p[k].pos = D3DXVECTOR3(x2, y2, z2);
p[k].n = p[k-3].n;
++k;
x3 = R * AsinRotNext * BcosRotNext;
y3 = R * AcosRotNext;
z3 = R * AsinRotNext * BsinRotNext;
p[k].pos = D3DXVECTOR3(x3, y3, z3);
p[k].n.x = AsinRotNext * BcosRotNext;
p[k].n.y = AcosRotNext;
p[k].n.z = AsinRotNext * BsinRotNext;
++k;
}
}
MeshTmp1 -> UnlockVertexBuffer();
MeshTmp1 -> LockIndexBuffer(0, (void**)&indexBuf);
for(int i = 0; i < mnumVertices; ++i)indexBuf[i] = i;
MeshTmp1 -> UnlockIndexBuffer();
DWORD *adjArray1 = new DWORD[ mnumVertices * sizeof(DWORD) ];
D3DXWeldVertices
(
MeshTmp1,
0,
0,
NULL,
adjArray1,
NULL,
NULL
);
MeshTmp1 -> OptimizeInplace
(
D3DXMESHOPT_COMPACT,
adjArray,
NULL,
NULL,
NULL
);
MeshTmp1 -> CloneMeshFVF
(
D3DXMESH_WRITEONLY,
CUSTOM_FVF,
D3dDevice,
&Mesh1
);
MeshTmp1 -> Release();
delete [] adjArray;
//Материал
D3DMATERIAL9 material;
ZeroMemory(&material, sizeof(material));
material.Diffuse.r = 0.9f;
material.Diffuse.g = 0.9f;
material.Diffuse.b = 0.9f;
material.Diffuse.a = 1.0f;
material.Ambient.r = 0.1f;
material.Ambient.g = 0.1f;
material.Ambient.b = 0.1f;
material.Ambient.a = 1.0f;
material.Specular.r = 0.9f;
material.Specular.g = 0.9f;
material.Specular.b = 0.9f;
material.Specular.a = 1.0f;
material.Power = 10.0f;
D3dDevice -> SetMaterial(&material);
D3dDevice -> SetRenderState( D3DRS_SPECULARENABLE, TRUE );
//Свет
D3DLIGHT9 light1;
ZeroMemory(&light1, sizeof(light1));
light1.Type = D3DLIGHT_POINT;
light1.Diffuse.r = 1.0f;
light1.Diffuse.g = 1.0f;
light1.Diffuse.b = 0.0f;
light1.Specular.r = 1.0f;
light1.Specular.g = 1.0f;
light1.Specular.b = 0.5f;
light1.Position = D3DXVECTOR3( -1.2, 0, 0 );
light1.Range = 2;
light1.Attenuation0 = 0.0f;
light1.Attenuation1 = 0.0f;
light1.Attenuation2 = 5.0f;
D3DLIGHT9 light2;
ZeroMemory(&light2, sizeof(light2));
light2.Type = D3DLIGHT_SPOT;
light2.Diffuse.r = 0.0f;
light2.Diffuse.g = 1.0f;
light2.Diffuse.b = 0.0f;
light2.Specular.r = 0.5f;
light2.Specular.g = 1.0f;
light2.Specular.b = 0.5f;
light2.Position = D3DXVECTOR3( 0.5f, 0, -2 );
light2.Direction = D3DXVECTOR3( 0, 0, 1 );
light2.Range = 4;
light2.Falloff = 1.0f;
light2.Attenuation0 = 0.1f;
light2.Attenuation1 = 0.3f;
light2.Attenuation2 = 0.4f;
light2.Phi = D3DX_PI/4;
light2.Theta = D3DX_PI/8;
D3DLIGHT9 light3;
ZeroMemory(&light3, sizeof(light3));
light3.Type = D3DLIGHT_DIRECTIONAL;
light3.Diffuse.r = 1.0f;
light3.Diffuse.g = 0.0f;
light3.Diffuse.b = 0.0f;
light3.Specular.r = 0.5f;
light3.Specular.g = 0.1f;
light3.Specular.b = 0.1f;
light3.Direction = D3DXVECTOR3( -1, 1, -1 );
D3dDevice -> SetLight(0, &light1);
D3dDevice -> SetLight(1, &light2);
D3dDevice -> SetLight(2, &light3);
D3dDevice -> LightEnable(0, TRUE);
D3dDevice -> LightEnable(1, TRUE);
D3dDevice -> LightEnable(2, TRUE);
SetTimer(AppWnd, 1, 1, TimerProc);
ShowWindow(AppWnd, commandShow);
UpdateWindow(AppWnd);
MSG msg;
while( GetMessage(&msg, NULL, 0, 0) > 0 )
{
DispatchMessage(&msg);
}
KillTimer(AppWnd, 1);
Mesh -> Release();
Mesh1 -> Release();
D3dDevice -> Release();
D3dObject -> Release();
return msg.wParam;
}
LRESULT __stdcall MainWindowProc
(
HWND hwnd,
UINT msg,
WPARAM wParam,
LPARAM lParam
)
{
switch(msg)
{
case WM_PAINT:
DrawWindowArea(hwnd);
return 0;
case WM_DESTROY:
PostQuitMessage(0);
return 0;
}
return DefWindowProc(hwnd, msg, wParam, lParam);
}
void DrawCilindr(HWND hwnd, float x0, float y0, float z0, float yr, float zr)//рисование цилиндра
{
D3DXMATRIX matWorld, rotGen, m, p, q, t;
D3DXMatrixScaling(&t, 1, 1, 1);
D3DXMatrixTranslation(&p, x0, y0, z0);
D3DXMatrixRotationYawPitchRoll( &q, yr, 0, zr );
D3DXMatrixRotationYawPitchRoll( &rotGen, rotY, rotX, rotZ );
matWorld = q * p * rotGen;
D3dDevice -> SetTransform( D3DTS_WORLD, &matWorld );
Mesh -> DrawSubset(0);
D3DXMatrixRotationX(&m, D3DX_PI/2);
matWorld = m * q * p * rotGen;
D3dDevice -> SetTransform( D3DTS_WORLD, &matWorld );
Mesh -> DrawSubset(0);
D3DXMatrixRotationX(&m, -D3DX_PI/2);
matWorld = m * q * p * rotGen;
D3dDevice -> SetTransform( D3DTS_WORLD, &matWorld );
Mesh -> DrawSubset(0);
D3DXMatrixRotationX(&m, D3DX_PI);
matWorld = m * q * p * rotGen;
D3dDevice -> SetTransform( D3DTS_WORLD, &matWorld );
Mesh -> DrawSubset(0);
}
void DrawSphere(HWND hwnd, float x0, float y0, float z0)//рисование сферы
{
D3DXMATRIX matWorld, rotGen, m, p, t;
D3DXMatrixTranslation(&p, x0, y0, z0);
D3DXMatrixRotationYawPitchRoll( &rotGen, rotY, rotX, rotZ );
matWorld = p * rotGen;
D3dDevice -> SetTransform( D3DTS_WORLD, &matWorld );
Mesh1 -> DrawSubset(0);
D3DXMatrixRotationY(&m, D3DX_PI);
matWorld = m * matWorld;
D3dDevice -> SetTransform( D3DTS_WORLD, &matWorld );
Mesh1 -> DrawSubset(0);
D3DXMatrixRotationX(&m, D3DX_PI/2);
matWorld = m * p * rotGen;
D3dDevice -> SetTransform( D3DTS_WORLD, &matWorld );
Mesh1 -> DrawSubset(0);
D3DXMatrixRotationY(&m, D3DX_PI);
matWorld = m * matWorld;
D3dDevice -> SetTransform( D3DTS_WORLD, &matWorld );
Mesh1 -> DrawSubset(0);
D3DXMatrixRotationX(&m, -D3DX_PI/2);
matWorld = m * p * rotGen;
D3dDevice -> SetTransform( D3DTS_WORLD, &matWorld );
Mesh1 -> DrawSubset(0);
D3DXMatrixRotationY(&m, D3DX_PI);
matWorld = m * matWorld;
D3dDevice -> SetTransform( D3DTS_WORLD, &matWorld );
Mesh1 -> DrawSubset(0);
D3DXMatrixRotationX(&m, D3DX_PI);
matWorld = m * p * rotGen;
D3dDevice -> SetTransform( D3DTS_WORLD, &matWorld );
Mesh1 -> DrawSubset(0);
D3DXMatrixRotationY(&m, D3DX_PI);
matWorld = m * matWorld;
D3dDevice -> SetTransform( D3DTS_WORLD, &matWorld );
Mesh1 -> DrawSubset(0);
}
void DrawWindowArea(HWND hwnd)
{
D3dDevice -> Clear
(
0,
NULL,
D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
D3DCOLOR_XRGB(100, 100, 100),
1,
0
);
InitialInput();
RECT wndRect;
GetClientRect(hwnd, &wndRect);
ValidateRect(hwnd, &wndRect);
if(!k)
{
D3DXVECTOR3 eye( cam.MoveRight, cam.MoveUp, -7+cam.MoveForward);
D3DXVECTOR3 at ( cam.MoveRight, cam.MoveUp, -6.0+cam.MoveForward);
D3DXVECTOR3 up (0, 1, 0);
D3DXMatrixLookAtLH( &matView, &eye, &at, &up );
k=true;
}
D3DXMatrixTranslation(&p, cam.MoveRight, cam.MoveUp, cam.MoveForward);
D3DXMatrixRotationYawPitchRoll( &m, cam.RotateRight, cam.RotateDown, 0 );
matView=matView*m*p;
cam.RotateDown=0;
cam.RotateRight=0;
cam.MoveForward=0;
cam.MoveUp=0;
cam.MoveRight=0;
D3DXMATRIX matProj;
D3DXMatrixPerspectiveFovLH( &matProj, D3DX_PI/4, (float)(wndRect.right-wndRect.left)/(float)(wndRect.bottom-wndRect.top), 0.3, 100 );
D3dDevice -> SetTransform( D3DTS_VIEW, &matView );
D3dDevice -> SetTransform( D3DTS_PROJECTION, &matProj );
D3dDevice -> BeginScene();
DrawCilindr(hwnd,0,1,1,0,0);
DrawCilindr(hwnd,0,1,-1,0,0);
DrawCilindr(hwnd,0,-1,1,0,0);
DrawCilindr(hwnd,0,-1,-1,0,0);
DrawCilindr(hwnd,1,0,1,0,D3DX_PI/2);
DrawCilindr(hwnd,1,0,-1,0,D3DX_PI/2);
DrawCilindr(hwnd,-1,0,1,0,D3DX_PI/2);
DrawCilindr(hwnd,-1,0,-1,0,D3DX_PI/2);
DrawCilindr(hwnd,1,1,0,D3DX_PI/2,0);
DrawCilindr(hwnd,1,-1,0,D3DX_PI/2,0);
DrawCilindr(hwnd,-1,1,0,D3DX_PI/2,0);
DrawCilindr(hwnd,-1,-1,0,D3DX_PI/2,0);
DrawCilindr(hwnd,0.5,0.5,-0.5,D3DX_PI*0.25,D3DX_PI*0.196);
DrawCilindr(hwnd,-0.5,0.5,-0.5,D3DX_PI*0.75,D3DX_PI*0.196);
DrawCilindr(hwnd,0.5,0.5,0.5,-D3DX_PI*0.25,D3DX_PI*0.196);
DrawCilindr(hwnd,-0.5,0.5,0.5,-D3DX_PI*0.75,D3DX_PI*0.196);
DrawCilindr(hwnd,0.5,-0.5,-0.5,D3DX_PI*0.25,D3DX_PI*-0.196);
DrawCilindr(hwnd,-0.5,-0.5,-0.5,D3DX_PI*0.75,D3DX_PI*-0.196);
DrawCilindr(hwnd,0.5,-0.5,0.5,-D3DX_PI*0.25,D3DX_PI*-0.196);
DrawCilindr(hwnd,-0.5,-0.5,0.5,-D3DX_PI*0.75,D3DX_PI*-0.196);
DrawSphere(hwnd,0,0,0);
DrawSphere(hwnd,1,1,1);
DrawSphere(hwnd,1,1,-1);
DrawSphere(hwnd,1,-1,1);
DrawSphere(hwnd,1,-1,-1);
DrawSphere(hwnd,-1,1,1);
DrawSphere(hwnd,-1,1,-1);
DrawSphere(hwnd,-1,-1,1);
DrawSphere(hwnd,-1,-1,-1);
D3dDevice -> EndScene();
D3dDevice -> Present(NULL, NULL, NULL, NULL);
}
void __stdcall TimerProc
(
HWND hwnd,
UINT uMsg,
UINT_PTR idEvent,
DWORD dwTime
)
{
DrawWindowArea(hwnd);
rotX += speedx*anglePlusX;
if( rotX > 2*D3DX_PI )rotX -= 2*D3DX_PI;
rotY += speedy*anglePlusY;
if( rotY > 2*D3DX_PI )rotY -= 2*D3DX_PI;
rotZ += speedz*anglePlusZ;
if( rotZ > 2*D3DX_PI )rotZ -= 2*D3DX_PI;
}
void WINAPI InitialInput()
{
HRESULT hr;
LPDIRECTINPUT8 pInput = NULL;
LPDIRECTINPUTDEVICE8 pKeyboard = NULL;
LPDIRECTINPUTDEVICE8 pMouse = NULL;
DIMOUSESTATE mouse;
// Создание основного объекта
DirectInput8Create(inst, DIRECTINPUT_VERSION,IID_IDirectInput8, (void**)&pInput, NULL);
// Создание устройства клавиатуры и мыши
pInput->CreateDevice(GUID_SysKeyboard, &pKeyboard, NULL);
pInput->CreateDevice(GUID_SysMouse, &pMouse, NULL);
// Установка формата данных клавиатуры и мыши
pKeyboard -> SetDataFormat(&c_dfDIKeyboard);
pMouse -> SetDataFormat(&c_dfDIMouse);
// Установка уровня взаимодействия клавиатуры и мыши
pKeyboard -> SetCooperativeLevel(hwnd, DISCL_FOREGROUND | DISCL_NONEXCLUSIVE);
pMouse -> SetCooperativeLevel(hwnd, DISCL_FOREGROUND| DISCL_NONEXCLUSIVE);
// Захват доступа к клавиатуре
pKeyboard -> Acquire();
// Полученние данных с клавиатуры
pKeyboard -> GetDeviceState(sizeof(keyboard),(LPVOID)&keyboard) ;
// Обработка клавиши < 1 >
if(KEYDOWN(keyboard, DIK_1))
{
if(!ligp1)
{
lig1=!lig1;
D3dDevice -> LightEnable(0, lig1);
}
ligp1=true;
}
else ligp1=false;
// Обработка клавиши < 2 >
if(KEYDOWN(keyboard, DIK_2))
{
if(!ligp2)
{
lig2=!lig2;
D3dDevice -> LightEnable(1, lig2);
}
ligp2=true;
}
else ligp2=false;
// Обработка клавиши < 3 >
if(KEYDOWN(keyboard, DIK_3))
{
if(!ligp3)
{
lig3=!lig3;
D3dDevice -> LightEnable(2, lig3);
}
ligp3=true;
}
else ligp3=false;
// Обработка клавиши < ESCAPE >
if(KEYDOWN(keyboard, DIK_ESCAPE))PostQuitMessage(0);
// Обработка клавиши < X >
if(KEYDOWN(keyboard, DIK_X))
{
if(!spxp)
{
speedx++;
if(speedx>3)speedx-=4;
}
spxp=true;
}
else spxp=false;
// Обработка клавиши < Y >
if(KEYDOWN(keyboard, DIK_Y))
{
if(!spyp)
{
speedy++;
if(speedy>3)speedy-=4;
}
spyp=true;
}
else spyp=false;
// Обработка клавиши < Z >
if(KEYDOWN(keyboard, DIK_Z))
{
if(!spzp)
{
speedz++;
if(speedz>3)speedz-=4;
}
spzp=true;
}
else spzp=false;
// Обработка клавиши < LEFT >
if(KEYDOWN(keyboard, DIK_LEFT))cam.MoveRight+=0.1;
// Обработка клавиши < RIGHT >
if(KEYDOWN(keyboard, DIK_RIGHT))cam.MoveRight-=0.1;
// Обработка клавиши < Up >
if(KEYDOWN(keyboard, DIK_UP))cam.MoveForward-=0.1;
// Обработка клавиши < Down >
if(KEYDOWN(keyboard, DIK_DOWN))cam.MoveForward+=0.1;
// Обработка клавиши < Page Down >
if(KEYDOWN(keyboard, DIK_PGDN))cam.MoveUp+=0.1;
// Обработка клавиши < Page Up >
if(KEYDOWN(keyboard, DIK_PGUP))cam.MoveUp-=0.1;
// Захват доступа
pMouse -> Acquire();
// Полученние данных от мыши
pMouse->GetDeviceState(sizeof(DIMOUSESTATE),(LPVOID)&mouse);
if(!f)
{
GetCursorPos(&prevPos);
GetCursorPos(&thisPos);
f = true;
}
GetCursorPos(&thisPos);
// Обработка нажатия левой кнопки мыши
if( mouse.rgbButtons[1] &0x80)
{
if(thisPos.x < prevPos.x)
{
cam.RotateRight+=D3DX_PI/200;
if( cam.RotateRight < 2*D3DX_PI )cam.RotateRight += 2*D3DX_PI;
}
if(thisPos.x > prevPos.x)
{
cam.RotateRight-=D3DX_PI/200;
if( cam.RotateRight > 0 )cam.RotateRight -= 2*D3DX_PI;
}
if(thisPos.y < prevPos.y)
{
cam.RotateDown+=D3DX_PI/200;
if( cam.RotateDown > 2*D3DX_PI )cam.RotateDown -= 2*D3DX_PI;
}
if(thisPos.y > prevPos.y)
{
cam.RotateDown-=D3DX_PI/200;
if( cam.RotateDown < 0 )cam.RotateDown += 2*D3DX_PI;
}
prevPos.x=thisPos.x;
prevPos.y=thisPos.y;
}
}