gamesmakerВсе о создании игр и не только

#include <cmath>
const float EPSILON = 0.001f;
struct vertex//вершины
{float x,y,z;
unsigned long color;};
class vector3//3-хмерный вектор
{public:
float x,y,z;
vector3() : x(0), y(0), z(0) {}
vector3(vector3& v) : x(v.x), y(v.y), z(v.z) {}
vector3(float _x, float _y, float _z) : x(_x),y(_y),z(_z){}
vector3& operator=(vector3 v)
{x=v.x;
y=v.y;
z=v.z;
return *this;}
bool operator==(vector3 v)
{
	if (fabs(x-v.x) < EPSILON)
		if (fabs(y-v.y) < EPSILON)
			if (fabs(z-v.z) < EPSILON)
				return true;
	return false;}
float mag()
{
	return sqrt(x*x+y*y+z*z);
}
vector3 operator- ()
{
	return vector3(-x,-y,-z);
}
// сложение векторов
vector3 operator+ (vector3& v)
{
	return vector3(x+v.x,y+v.y,z+v.z);
}
// разность векторов
vector3 operator- (vector3& v)
{
	return vector3(x-v.x,y-v.y,z-v.z);
}
// умножение вектора  на скаляр
vector3 operator* (float& a)
{
	return vector3(x*a,y*a,z*a);
}
// деление вектора  на скаляр
vector3 operator/ (float& a)
{
	float b = 1.0f / a;
	return vector3 (x*b,y*b,z*b);
}
// скалярное произедение векторов (dot product)
float operator* (vector3& v)
{
	return x*v.x+y*v.y+z*v.z;
}
// векторное произведение векторов (cross product)
vector3 Cross(vector3& v)
{
	return vector3(y*v.z - z*v.y, z*v.x - x*v.z, x*v.y - y*v.x);
}

vector3& operator+= (vector3& v)
{
	x += v.x; y += v.y; z += v.z;
	return *this;
}

vector3& operator-= (vector3& v)
{
	x -= v.x; y -= v.y; z -= v.z;
	return *this;
}

vector3& operator*= (float& a)
{
	x *= a; y *= a; z *= a;
	return *this;
}

vector3& operator/= (float& a)
{
	float b = 1.0f/a;
	x *= b; y *= b; z *= b;
	return *this;
}
void Normalize ()
{
  float magnitude = mag();
  if (magnitude > 0)
  {
    float invertedMag = 1 / magnitude;
    x *= invertedMag;
    y *= invertedMag;
    z *= invertedMag;
  }
}
};
class vector4//4-хмерный вектор
{public:
float x,y,z,w;
vector4(){x=0;
y=0;
z=0;
w=1;}
vector4(vector4 &v)
{x=v.x;
y=v.y;
z=v.z;
w=v.w;}
vector4(float _x, float _y, float _z, float _w)
{x=_x;
y=_y;
z=_z;
w=_w;}
vector4& operator=(vector4 v)
{x=v.x;
y=v.y;
z=v.z;
w=v.w;
return *this;}
bool operator==(vector4 v)
{
	if (fabs(x-v.x) < EPSILON)
		if (fabs(y-v.y) < EPSILON)
			if (fabs(z-v.z) < EPSILON)
				return true;
	return false;}
float mag()
{
	return sqrt(x*x+y*y+z*z);
}
vector4 operator- ()
{
	return vector4(-x,-y,-z,w);
}
// сложение векторов
vector4 operator+ (vector4& v)
{
	return vector4(x+v.x,y+v.y,z+v.z,(w+v.w)/2);
}
// разность векторов
vector4 operator- (vector4& v)
{
	return vector4(x-v.x,y-v.y,z-v.z,(w+v.w)/2);
}
// умножение вектора  на скаляр
vector4 operator* (float& a)
{
	return vector4(x*a,y*a,z*a,w);
}
// деление вектора  на скаляр
vector4 operator/ (float& a)
{
	float b = 1.0f / a;
	return vector4 (x*b,y*b,z*b,w);
}
// скалярное произедение векторов (dot product)
float operator* (vector4& v)
{
	return x*v.x+y*v.y+z*v.z;
}
// векторное произведение векторов (cross product)
vector4 Cross(vector4& v)
{
	return vector4(y*v.z - z*v.y, z*v.x - x*v.z, x*v.y - y*v.x,(w+v.w)/2);
}

vector4& operator+= (vector4& v)
{
	x += v.x; y += v.y; z += v.z;
	return *this;
}

vector4& operator-= (vector4& v)
{
	x -= v.x; y -= v.y; z -= v.z;
	return *this;
}

vector4& operator*= (float& a)
{
	x *= a; y *= a; z *= a;
	return *this;
}

vector4& operator/= (float& a)
{
	float b = 1.0f/a;
	x *= b; y *= b; z *= b;
	return *this;
}
void Normalize ()
{
  float magnitude = mag();
  if (magnitude > 0)
  {
    float invertedMag = 1 / magnitude;
    x *= invertedMag;
    y *= invertedMag;
    z *= invertedMag;
  }
}
};
class Matrix//матрицы
{public:
float _11, _12, _13, _14;
float _21, _22, _23, _24;
float _31, _32, _33, _34;
float _41, _42, _43, _44;
Matrix();//конструктор
void RotationAroundAxis(vector3 &, float);//вращение
};
Matrix::Matrix () : _11(1), _12(0), _13(0), _14(0),
                    _21(0), _22(1), _23(0), _24(0),
                    _31(0), _32(0), _33(1), _34(0),
                    _41(0), _42(0), _43(0), _44(1)
{}
void Matrix::RotationAroundAxis(vector3& v, float angle)
{
  _11 = v.x * v.x * (1 - cos(angle)) + cos(angle);
  _12 = v.x * v.y * (1 - cos(angle)) + v.z * sin(angle);
  _13 = v.x * v.z * (1 - cos(angle)) - v.y * sin(angle);

  _21 = v.x * v.y * (1 - cos(angle)) - v.z * sin(angle);
  _22 = v.y * v.y * (1 - cos(angle)) + cos(angle);
  _23 = v.y * v.z * (1 - cos(angle)) + v.x * sin(angle);

  _31 = v.x * v.z * (1 - cos(angle)) + v.y * sin(angle);
  _32 = v.y * v.z * (1 - cos(angle)) - v.x * sin(angle);
  _33 = v.z * v.z * (1 - cos(angle)) + cos(angle);
}
void multiplication (vector4& v, Matrix& m)
{
  v.x = v.x * m._11 + v.y * m._21 + v.z * m._31 + v.w * m._41;
  v.y = v.x * m._12 + v.y * m._22 + v.z * m._32 + v.w * m._42;
  v.z = v.x * m._13 + v.y * m._23 + v.z * m._33 + v.w * m._43;
  v.w = v.x * m._14 + v.y * m._24 + v.z * m._34 + v.w * m._44;
}
//перемножение вектора  на матрицу
void multiplication (vector3& v, Matrix& m)
{
  v.x = v.x * m._11 + v.y * m._21 + v.z * m._31;
  v.y = v.x * m._12 + v.y * m._22 + v.z * m._32;
  v.z = v.x * m._13 + v.y * m._23 + v.z * m._33;
}
void transformations (vertex& Vertex, vector4& vector, Matrix& matWorld,
                      Matrix& matCam, Matrix& matProj)//изменение вектора
{
  vector4 tempv = vector;
  multiplication(tempv,matWorld);
  multiplication(tempv,matCam);
  multiplication(tempv,matProj);
  tempv.x /= tempv.w;
  tempv.y /= tempv.w;
  tempv.z /= tempv.w;
  tempv.w /= tempv.w;
  Vertex.x = tempv.x;
  Vertex.y = tempv.y;
  Vertex.z = tempv.z;
}

class MovableObject//класс объекта
{vector3 i,j,k,v;
public:
	MovableObject () : i(1,0,0), j(0,1,0), k(0,0,1), v(0,0,0) {}
	void Heading(float angle)//вращение  по у
{
  Matrix rotationMatrix;
  angle = angle*3.14f/180;
  rotationMatrix.RotationAroundAxis(vector3(0,1,0),angle);
  multiplication(i,rotationMatrix);
  multiplication(k,rotationMatrix);
}
void Bank(float angle)//вращение  по z (отсутствует
{
  Matrix rotationMatrix;
  angle = angle*3.14f/180;
  rotationMatrix.RotationAroundAxis(k,angle);
  multiplication(i,rotationMatrix);
  multiplication(j,rotationMatrix);	
}

void Pitch(float angle)//вращение  по х
{
  Matrix rotationMatrix;
  angle = angle*3.14f/180;
  rotationMatrix.RotationAroundAxis(vector3(i.x,0,i.z),angle);
  multiplication(j,rotationMatrix);
  multiplication(k,rotationMatrix);
}
void Strafe(float dx) { v += vector3(i.x,0,i.z) * dx; }//смещение
void Fly (float dy)   { v += vector3(0,j.y,0) * dy; }
void Walk (float dz)  { v += vector3(k.x,0,k.z) * dz; }
void CreateMatWorld(Matrix& matCam)//переход  к мировой матрице
{
  k.Normalize();
  j = k.Cross(i);
  j.Normalize();
  i = j.Cross(k);
  i.Normalize();
  matCam._11 = i.x;
  matCam._12 = i.y;
  matCam._13 = i.z;
  matCam._21 = j.x;
  matCam._22 = j.y;
  matCam._23 = j.z;
  matCam._31 = k.x;
  matCam._32 = k.y;
  matCam._33 = k.z;
  matCam._41 = v.x;
  matCam._42 = v.y;
  matCam._43 = v.z;
}};
class Camera//класс камеры
{vector3 i,j,k,v;
public:
	void Heading(float angle)
{
  Matrix rotationMatrix;
  angle = angle*3.14f/180;
  rotationMatrix.RotationAroundAxis(vector3(0,1,0),angle);
  multiplication(i,rotationMatrix);
  multiplication(k,rotationMatrix);
}
	float angleAroundZ;
	void Bank(float angle)
{
  if (angleAroundZ < 45 && angleAroundZ > -45)
    angleAroundZ += angle;
  if ((angleAroundZ >= 45 && angle > 0) || (angleAroundZ <= -45 && angle < 0))
  {
    angleAroundZ -= angle;
    return;
  }
  Matrix RotationMatrix;
  angle = angle*3.14f/180;
  RotationMatrix.RotationAroundAxis(k,angle);
  multiplication(i,RotationMatrix);
  multiplication(j,RotationMatrix);
}
void Pitch(float angle)
{
  Matrix rotationMatrix;
  angle = angle*3.14f/180;
  rotationMatrix.RotationAroundAxis(vector3(i.x,0,i.z),angle);
  multiplication(j,rotationMatrix);
  multiplication(k,rotationMatrix);
}
void Strafe(float dx) { v += vector3(i.x,0,i.z) * dx; }
void Fly (float dy)   { v += vector3(0,j.y,0) * dy; }
void Walk (float dz)  { v += vector3(k.x,0,k.z) * dz; }
Camera () : i(1,0,0), j(0,1,0), k(0,0,1), v(0,0,0) {}
void CreateMatCam(Matrix& matCam)//переход  к матрице камеры
{
  k.Normalize();
  j = k.Cross(i);
  j.Normalize();
  i = j.Cross(k);
  i.Normalize();
  matCam._11 = i.x;
  matCam._12 = j.x;
  matCam._13 = k.x;
  matCam._21 = i.y;
  matCam._22 = j.y;
  matCam._23 = k.y;
  matCam._31 = i.z;
  matCam._32 = j.z;
  matCam._33 = k.z;
  matCam._41 = -(i*v);
  matCam._42 = -(j*v);
  matCam._43 = -(k*v);
}
};
#define INITGUID
#include <Windows.h>
#include <d3d9.h>
#include "Microsoft DirectX SDK (June 2010)\Include\d3dx9.h"
#include <dinput.h>
#define DIRECTINPUT_VERSION 0x800
#pragma comment(lib, "d3d9.lib")
//#pragma comment(lib, "d3dx9.lib")
#pragma comment(lib, "dinput8.lib")
HWND hWnd;
MovableObject cube;
Camera camera;
vertex Cube[8];
vertex Obj[8];
LRESULT __stdcall WndProc(HWND hWnd, UINT message,
             WPARAM wParam, LPARAM lParam)//обработчик сообщений
{
  switch (message)
  {
  case WM_DESTROY:
    PostQuitMessage(0);
    return 0;
  case WM_CLOSE:
    exit(0);
  case WM_QUIT:
    return 0;
  default:
      return DefWindowProc(hWnd,message,wParam,lParam);
}

  return 0;}
IDirectInput8* di=0;//переменные
IDirectInputDevice8* mouse=0,*keyboard=0;
char buffer[256];
DIMOUSESTATE dims;
IDirect3D9* d3d=0;
IDirect3DDevice9* videocard=0;
IDirect3DVertexBuffer9* vb = NULL,*ob=NULL;
IDirect3DIndexBuffer9* ib=NULL;
vector4 vertices[8] = 
{
  vector4(-1,-1,-1,1),
  vector4(-1,1,-1,1),
  vector4(1,-1,-1,1),
  vector4(1,1,-1,1),
  vector4(-1,-1,1,1),
  vector4(-1,1,1,1),
  vector4(1,-1,1,1),
  vector4(1,1,1,1)
};
unsigned short indices[]={
  0, 1, 2,
  1, 3, 2,
  0, 1, 5,
  0, 4, 5,
  4, 5, 6,
  5, 7, 6,
  2, 3, 7,
  2, 6, 7,
  0, 2, 6,
  0, 4, 6,
  1, 3, 7,
  1, 5, 7,
};

vector4 object[]=
{vector4(-3,-3,-3,1),
  vector4(-3,3,-3,1),
  vector4(3,-3,-3,1),
  vector4(3,3,-3,1),
  vector4(-3,-3,3,1),
  vector4(-3,3,3,1),
  vector4(3,-3,3,1),
  vector4(3,3,3,1)
};
unsigned short index[]={
  0, 1, 2,
  1, 3, 2,
  0, 1, 5,
  0, 4, 5,
  4, 5, 6,
  5, 7, 6,
  2, 3, 7,
  2, 6, 7,
  0, 2, 6,
  0, 4, 6,
  1, 3, 7,
  1, 5, 7,
};
Matrix matWorld,matCam,matProj;
bool Init(HINSTANCE hInstance)//инициализация
{
  
 if FAILED( DirectInput8Create(hInstance,           // экземпляр приложения
               DIRECTINPUT_VERSION, // версия DirectInput
               IID_IDirectInput8,   // глобальный идентификатор (COM)
               (void**)&di, // адрес указателя объекта DirectInput
               NULL))return 0;
 if FAILED(di->CreateDevice(GUID_SysKeyboard,  // устройство ввода   с клавиатуры
             &keyboard,            // адрес указателя   на устройство
             NULL))return 0;
 keyboard->SetDataFormat(&c_dfDIKeyboard);
keyboard->SetCooperativeLevel(hWnd,DISCL_FOREGROUND | DISCL_NONEXCLUSIVE);
keyboard->Acquire();
if(FAILED(di->CreateDevice(GUID_SysMouse,  // устройство ввода   с мыши
  &mouse,                        // адрес указателя   на устройство
  NULL)))return 0;

mouse->SetDataFormat(&c_dfDIMouse);
mouse->SetCooperativeLevel(hWnd,DISCL_FOREGROUND | DISCL_NONEXCLUSIVE);
mouse->Acquire();
if FAILED(d3d = Direct3DCreate9(D3D_SDK_VERSION))return 0;

  D3DPRESENT_PARAMETERS pp;
  ZeroMemory(&pp,sizeof(pp));

  pp.BackBufferWidth = 500;
  pp.BackBufferHeight = 500;
  pp.BackBufferFormat = D3DFMT_X8R8G8B8;
  pp.BackBufferCount = 1;
  pp.SwapEffect = D3DSWAPEFFECT_DISCARD;
  pp.hDeviceWindow = hWnd;
  pp.Windowed = true;
  if FAILED(d3d->CreateDevice(D3DADAPTER_DEFAULT,
                    D3DDEVTYPE_REF,hWnd,
                    D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                    &pp, &videocard))return 0;
  
  videocard->CreateVertexBuffer( 8*sizeof(vertex), D3DUSAGE_WRITEONLY,
                         D3DFVF_XYZ|D3DFVF_DIFFUSE, D3DPOOL_DEFAULT,
                         &vb,NULL);
videocard->CreateVertexBuffer( 8* sizeof(vertex), D3DUSAGE_WRITEONLY,
                         D3DFVF_XYZ|D3DFVF_DIFFUSE, D3DPOOL_DEFAULT,
                         &ob,NULL);
videocard->CreateIndexBuffer( 72*sizeof(unsigned short),
                        D3DUSAGE_WRITEONLY, D3DFMT_INDEX16,
                        D3DPOOL_DEFAULT, &ib, NULL );
videocard->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE );
videocard->SetRenderState( D3DRS_LIGHTING, FALSE );
return 1;
}
void Delete()//удаление
{
if(ib!=NULL)ib->Release();
if(ob!=NULL)ob->Release();
if(vb!=NULL)vb->Release();
if(videocard!=NULL)videocard->Release();
if(d3d!=NULL)d3d->Release();
if(keyboard!=NULL){keyboard->Unacquire();
keyboard->Release();}
if(mouse!=NULL){mouse->Unacquire();
mouse->Release();}
if(di!=NULL)di->Release();}
void Input()//ввод
{if FAILED(mouse->GetDeviceState(sizeof(DIMOUSESTATE),&dims))mouse->Acquire();
if FAILED(keyboard->GetDeviceState(sizeof(buffer),buffer))keyboard->Acquire();
camera.Heading(dims.lY);
camera.Bank(dims.lZ);
camera.Pitch(dims.lX);
int dx=0,dy=0,dz=0;
if(buffer[DIK_A]||buffer[DIK_LEFT])dx--;
if(buffer[DIK_D]||buffer[DIK_RIGHT])dx++;
if(buffer[DIK_W]||buffer[DIK_UP])dy--;
if(buffer[DIK_S]||buffer[DIK_DOWN])dy++;
if(buffer[DIK_R])dz++;
if(buffer[DIK_F])dz--;
cube.Fly(dy);
cube.Strafe(dx);
cube.Walk(dz);
camera.Fly(dy);
camera.Strafe(dx);
camera.Walk(dz);}
void Rendering()//рисование
{Input();
camera.CreateMatCam(matCam);
cube.CreateMatWorld(matWorld);
for(int i=0;i<8;i++){Cube[i].color=0x00ffffff;
transformations(Cube[i],vertices[i],matWorld,matCam,matProj);
Obj[i].color=0x00ffffff;
transformations(Obj[i],object[i],matWorld,matCam,matProj);
}
void *vvb=NULL, *iib=NULL, *ovb=NULL, *oib=NULL;
vb->Lock(0,sizeof(Cube),(void**)&vvb,0);
memcpy(vvb,Cube,sizeof(Cube));
vb->Unlock();
ob->Lock(0,sizeof(Obj),(void**)&ovb,0);
memcpy(ovb,Obj,sizeof(Obj));
ob->Unlock();
ib->Lock(0,sizeof(indices)+sizeof(index),(void**)&iib,0);
memcpy(iib,indices,sizeof(indices));
iib = static_cast<unsigned short*>(iib) + 36;
memcpy(iib,index,sizeof(index));
ib->Unlock();
videocard->BeginScene();
videocard->SetStreamSource(0,vb,0,sizeof(vertex));
videocard->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,0,0,8,0,12);
videocard->SetStreamSource(0,vb,0,sizeof(vertex));
videocard->DrawIndexedPrimitive(D3DPT_LINELIST,0,0,8,36,12);
videocard->EndScene();
videocard->Present(NULL,NULL,NULL,NULL);}
int __stdcall WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
                      LPSTR lpCmdLine, int nCmdShow)//главная функция
{WNDCLASS wc;
  wc.style = CS_OWNDC;
  wc.lpfnWndProc = WndProc;
  wc.cbClsExtra = 0;
  wc.cbWndExtra = 0;
  wc.hbrBackground = (HBRUSH)(6);
  wc.hCursor = LoadCursor(NULL, IDC_ARROW);
  wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
  wc.hInstance = hInstance;
  wc.lpszClassName = L"class";
  wc.lpszMenuName = NULL;

  if FAILED(RegisterClass(&wc))return 0;

  if(FAILED(hWnd = CreateWindow(L"class",L"Проверка камеры DirectX-самостоятельная работа",
                           WS_OVERLAPPEDWINDOW,200,100,
                           500,500,NULL,NULL,hInstance,NULL)))return 0;
  ShowWindow(hWnd,nCmdShow);
  UpdateWindow(hWnd);
  Init(hInstance);
MSG msg;
while(true){
if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
    {
      if (msg.message == WM_QUIT)
        break;
      TranslateMessage(&msg);
      DispatchMessage(&msg);
    Rendering();}
}
Delete();
return 0;}