Открываю исходники Progamina3DEngine = 39 дней работы с DirectX

/**
 
 Copyright (c) 2011-2012, programina.            
 
 Компилируется в CodeBlocks 10.05 с компилятором MinGW
 Программа не работает без d3dx9_43.dll ( directx redist июльской сборки 2010 года  )
 
 Клавиша ESCAPE завершает работу программы
 Клавиши W, S, A, D - перемещение перса
 Мышь - вращение камеры
 
**/
 
#define INITGUID
#define DIRECTINPUT_VERSION 0x800
 
#include <C:\DXSDK\Include\d3d9.h>  //
#include <C:\DXSDK\Include\d3dx9.h> // Подключаемые заголовочные файлы
#include <C:\DXSDK\Include\dinput.h>    // У меня заголовочные файлы лежат в папке 'С:\DXSDK\Include\'
#include <C:\DXSDK\Include\d3dx9mesh.h> // Исправьте пути на свои
#include <C:\DXSDK\Include\d3dx9math.h> //
 
#include <windows.h>
#include <stdlib.h>
#include <stdio.h>
#include <io.h>
 
 
IDirect3D9      *d3d        = 0;
IDirect3DDevice9    *d3ddev     = 0;
IDirectInput8       *di     = 0;
IDirectInputDevice8 *mouse      = 0;
IDirectInputDevice8 *keyboard   = 0;
 
ID3DXMesh       *mesh       = 0;
ID3DXBuffer         *meshBuffer = 0;
IDirect3DTexture9   *meshTexture    = 0;
 
 
HINSTANCE   hinst;
int     nFunsterStil;
HWND        hwnd;
MSG     messages;
WNDCLASSEX  wincl;
 
// ширина и высота экрана
int iWidth  = GetSystemMetrics(SM_CXSCREEN);
int iHeight = GetSystemMetrics(SM_CYSCREEN);
 
// массивы имен модели и текстуры
const char  *modelName[4096];
const char  *textureName[4096];
 
// переменные вращения и движения камеры
float angleYaw      = 0.0;
float anglePitch    = 0.0;
float YawX      = 0.0;
float YawY      = 0.0;
float PitchX        = 0.0;
float PitchD        = 0.0;
float fPosX     = 0.0;
float fPosY     = 1.0;
float fPosZ     = 0.0;
 
// матрицы вида, проекции и объектов
D3DXMATRIX matView;
D3DXMATRIX matProjection;
D3DXMATRIX matWorldR[1024];
D3DXMATRIX matWorldT[1024];
 
// для работы с вводом
DIMOUSESTATE    dims;
char        kbstate[256];
 
float WAccel;           // скорость W
float SAccel;           // скорость S
float AAccel;           // скорость A
float DAccel;           // скорость D
 
float dltAccel;         // коэффициент нивелирующий ускорение и скорорсть при одновременном нажатии двух клавиш движения по разным осям на плоскости
 
float distcam   = 1.5;      // расстояние между камерой и персом
float f         = 1.0;      // Смещение камеры в бок
float angle     = 0.0;      // Разница между углом мыши и углом перса
float d_angle   = 0.0;      // Угол поворота перса
 
#define Pi 3.14159      // Число Пи
 
 
// позиция объекта и угол по 3 осям
float   modelX[8192];
float   modelY[8192];
float   modelZ[8192];
float   modelYaw[8192];
float   modelPitch[8192];
float   modelRoll[8192];
 
DWORD   i = 0;
 
#define MAX_SPEED 0.04
 
float   rot_spd = 0.0;
 
 
 
LRESULT CALLBACK WindowProcedure( HWND, UINT, WPARAM, LPARAM );
void InitWin();
void InitD3D();
void InitInput();
void Mouse();
void Keyboard();
void LoadModel( DWORD, const char*, const char* );
void DrawModel( DWORD, float, float, float, float, float, float );
void Projection( float, float, float );
void CameraTP( float, float, float, float, float, float, float, float );
void RotateAndMove();
void Release();
 
 
 
 
 
 
///===============================================================================================================================
/// Name:
/// Desc: Не знаю для чего еще она нужна, кроме выхода из программы при нажатии клавиши ESCAPE
///===============================================================================================================================
 
LRESULT CALLBACK WindowProcedure( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam )
{
    switch (message)
    {
        case WM_KEYDOWN:
            switch( wParam )
            {
                case VK_ESCAPE:
                    PostQuitMessage(0);
                    break;
            }
            break;
 
        default:
            return DefWindowProc (hwnd, message, wParam, lParam);
            break;
    }
    return 0;
}
 
 
///===============================================================================================================================
/// Name:
/// Desc: Инициализация окна
///===============================================================================================================================
 
void InitWin()
{
    wincl.hInstance     = hinst;
    wincl.lpszClassName = "GAME";
    wincl.lpfnWndProc   = WindowProcedure;
    wincl.style         = CS_DBLCLKS;
    wincl.cbSize        = sizeof (WNDCLASSEX);
    wincl.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hIconSm       = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hCursor       = LoadCursor (NULL, IDC_ARROW);
    wincl.lpszMenuName  = NULL;
    wincl.cbClsExtra    = 0;
    wincl.cbWndExtra    = 0;
    wincl.hbrBackground     = (HBRUSH)GetStockObject(BLACK_BRUSH);
    RegisterClassEx (&wincl);
    hwnd = CreateWindowEx ( 0, "GAME"," ", WS_POPUP, 0, 0, iWidth, iHeight, HWND_DESKTOP, 0,hinst, 0 );
 
    ShowWindow(hwnd, nFunsterStil);
    SetFocus(hwnd);
    UpdateWindow (hwnd);
    SetForegroundWindow(hwnd);
    ShowCursor(false);
}
 
 
///===============================================================================================================================
/// Name:
/// Desc: Инициализация DierctX
///===============================================================================================================================
 
void InitD3D()
{
    d3d = Direct3DCreate9( D3D_SDK_VERSION );
    D3DDISPLAYMODE d3ddm;
    d3d -> GetAdapterDisplayMode( D3DADAPTER_DEFAULT, &d3ddm );
 
    D3DPRESENT_PARAMETERS d3dpp;
    ZeroMemory( &d3dpp, sizeof(d3dpp) );
    d3dpp.BackBufferWidth           = iWidth;
    d3dpp.BackBufferHeight          = iHeight;
    d3dpp.AutoDepthStencilFormat        = D3DFMT_D24S8;
    d3dpp.EnableAutoDepthStencil        = true;
    d3dpp.BackBufferFormat          = D3DFMT_X8R8G8B8;
    d3dpp.SwapEffect            = D3DSWAPEFFECT_FLIP;
    d3dpp.Windowed                  = false;
    d3dpp.FullScreen_RefreshRateInHz    = D3DPRESENT_RATE_DEFAULT;
    d3dpp.PresentationInterval          = D3DPRESENT_INTERVAL_DEFAULT; // 60 Гц
 
    d3d     -> CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd, D3DCREATE_MIXED_VERTEXPROCESSING, &d3dpp, &d3ddev );
 
    d3ddev  -> SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
    d3ddev  -> SetRenderState( D3DRS_LIGHTING, false    );
    d3ddev  -> SetRenderState( D3DRS_ZENABLE, true      );
}
 
 
///===============================================================================================================================
/// Name:
/// Desc: Инициализация мыши и клавиатуры
///===============================================================================================================================
 
void InitInput()
{
        DirectInput8Create( GetModuleHandle(NULL),DIRECTINPUT_VERSION,IID_IDirectInput8,(void**)&di,NULL );
 
        di              -> CreateDevice( GUID_SysMouse,&mouse,NULL );
        mouse           -> SetDataFormat( &c_dfDIMouse );
        mouse           -> SetCooperativeLevel( hwnd,DISCL_FOREGROUND | DISCL_NONEXCLUSIVE );
        mouse           -> Acquire();
 
    di              -> CreateDevice( GUID_SysKeyboard,&keyboard,NULL );
        keyboard        -> SetDataFormat( &c_dfDIKeyboard );
        keyboard        -> SetCooperativeLevel( hwnd,DISCL_FOREGROUND | DISCL_NONEXCLUSIVE );
        keyboard        -> Acquire();
}
 
 
///===============================================================================================================================
/// Name:
/// Desc: Подсчет углов обзора камеры
///===============================================================================================================================
 
void Mouse()
{
    mouse -> GetDeviceState( sizeof(DIMOUSESTATE),&dims );
 
    angleYaw    += (dims.lX/125.0f +dims.lX/250.0f +dims.lX/500.0f +dims.lX/1000.0f)/10.0f;
    anglePitch  += (dims.lY/125.0f +dims.lY/250.0f +dims.lY/500.0f +dims.lY/1000.0f)/10.0f;
 
    if ( angleYaw >  2 * 3.1415926 )    { angleYaw = 0.0; }
    if ( angleYaw < -2 * 3.1415926 )    { angleYaw = 0.0; }
 
    YawX    =   cos(angleYaw);
    YawY    =   sin(angleYaw);
    PitchX  =       -sin(anglePitch);
 
    if (PitchX > 0) { PitchD = 1.0 - PitchX; }
    else        { PitchD = 1.0 + PitchX; }
 
    if (anglePitch >  1.0) anglePitch =  1.0;
    if (anglePitch < -1.0) anglePitch = -1.0;
}
 
 
///===============================================================================================================================
/// Name:
/// Desc: Подсчет скорости движения перса по осям X и Z
///===============================================================================================================================
 
void Keyboard()
{
    keyboard -> GetDeviceState( sizeof(kbstate),kbstate );
 
    if  ( (kbstate[DIK_W] & 0x80) && (kbstate[DIK_D] & 0x80) )  { dltAccel = 0.707 * 1.0; }
    else if ( (kbstate[DIK_W] & 0x80) && (kbstate[DIK_A] & 0x80) )  { dltAccel = 0.707 * 1.0; }
    else if ( (kbstate[DIK_S] & 0x80) && (kbstate[DIK_D] & 0x80) )  { dltAccel = 0.707 * 1.0; }
    else if ( (kbstate[DIK_S] & 0x80) && (kbstate[DIK_A] & 0x80) )  { dltAccel = 0.707 * 1.0; }
    else                                { dltAccel = 1.000 * 1.0; }
 
    if ( kbstate[DIK_W] & 0x80 && WAccel < MAX_SPEED )  { WAccel += 0.0005; }
    else                            { WAccel *= 0.90;   }
 
    if ( kbstate[DIK_S] & 0x80 && SAccel < MAX_SPEED )  { SAccel += 0.0005; }
    else                            { SAccel *= 0.90;   }
 
    if ( kbstate[DIK_A] & 0x80 && AAccel < MAX_SPEED )  { AAccel += 0.0005; }
    else                            { AAccel *= 0.90;   }
 
    if ( kbstate[DIK_D] & 0x80 && DAccel < MAX_SPEED )  { DAccel += 0.0005; }
    else                            { DAccel *= 0.90;   }
 
    /// вообщем та еще тригонометрия ... Изменяет скорость в зависимости от угла перса
    fPosX += ( WAccel * YawY );
    fPosZ += ( WAccel * YawX );
 
    fPosX -= ( SAccel * YawY );
    fPosZ -= ( SAccel * YawX );
 
    fPosX -= ( AAccel * YawX );
    fPosZ += ( AAccel * YawY );
 
    fPosX += ( DAccel * YawX );
    fPosZ -= ( DAccel * YawY );
}
 
 
///===============================================================================================================================
/// Name:
/// Desc: Рисует модель с параметрами позиционирования и повернутости по осям X, Y, Z
///===============================================================================================================================
 
void DrawModel( DWORD i, float modelX, float modelY, float modelZ, float modelYaw, float modelPitch, float modelRoll )
{
    D3DXMatrixRotationYawPitchRoll( &matWorldR[i], modelYaw, modelPitch, modelRoll );
    D3DXMatrixTranslation( &matWorldT[i], modelX, modelY, modelZ );
    d3ddev -> SetTransform( D3DTS_WORLD, &matWorldT[i] );
    d3ddev -> MultiplyTransform( D3DTS_WORLD, &matWorldR[i] );
 
    d3ddev -> SetTexture( 0, meshTexture );
    mesh -> DrawSubset( 0 );
}
 
 
///===============================================================================================================================
/// Name:
/// Desc: Загружает модель и текстуру
///===============================================================================================================================
 
void LoadModel( DWORD i, const char *modelName, const char *textureName )
{   
    D3DXLoadMeshFromX       ( modelName, D3DXMESH_SYSTEMMEM, d3ddev, NULL, &meshBuffer, NULL, &i, &mesh );
    D3DXCreateTextureFromFile   ( d3ddev, textureName, &meshTexture );
    meshBuffer -> Release();
}
 
 
///===============================================================================================================================
/// Name:
/// Desc: Проекция вида
///===============================================================================================================================
 
void Projection( float fAngleProjection, float fNear, float fFar )
{
    D3DXMatrixPerspectiveFovLH  ( &matProjection, fAngleProjection, (float)iWidth / (float)iHeight, fNear, fFar );
    d3ddev -> SetTransform      ( D3DTS_PROJECTION, &matProjection );
}
 
 
///===============================================================================================================================
/// Name:
/// Desc: Камера от 3-го лица, принимает параметры позиционирования, повернутости из предыдущих функций
///===============================================================================================================================
 
void CameraTP( float fPosX, float fPosY, float fPosZ, float YawY, float anglePitch, float YawX, float PitchD, float distcam )
{
    D3DXVECTOR3 vEyePt  ( fPosX-YawY*1.0, fPosY+anglePitch*1.0, fPosZ-YawX*1.0  );
    D3DXVECTOR3 vLookatPt   ( fPosX, fPosY, fPosZ                   );
    D3DXVECTOR3 vUpVec  ( 0.0f, 1.0f, 0.0f                  );
    D3DXMatrixLookAtLH  ( &matView, &vEyePt, &vLookatPt, &vUpVec );
    d3ddev -> SetTransform  ( D3DTS_VIEW, &matView );
}
 
 
///===============================================================================================================================
/// Name: RotateAndMove
/// Desc: Обеспечивает поворот перса в ту сторону, куда смотрит камера и неподвижность перса пока он не двигается
///===============================================================================================================================
 
void RotateAndMove()
{
    angle = d_angle - angleYaw;
 
    if ( (WAccel > 0.01 || SAccel > 0.01 || AAccel > 0.01 || DAccel > 0.01) && rot_spd < 0.1 )  { rot_spd += 0.01; }
    else                                                                                        { rot_spd *= 0.99; }
 
    if ( WAccel > 0.01 && SAccel < 0.01 && AAccel < 0.01 && DAccel < 0.01 )
    {
        if      ( sin(angle) > 0.1 )                    { d_angle -= rot_spd;           }
        else if ( sin(angle) <-0.1 )                        { d_angle += rot_spd;           }
        else if ( angle >= Pi - 0.11 && angle <= Pi+0.11 )          { d_angle -= rot_spd;           }
        else if ( angle <=-Pi + 0.11 && angle >=-Pi-0.11 )          { d_angle -= rot_spd;           }
        else if ( sin(angle) <= 0.1 && sin(angle) >= -0.1 )             { d_angle = angleYaw;           }
    }
 
    if ( SAccel > 0.01 && WAccel < 0.01 && AAccel < 0.01 && DAccel < 0.01 )
    {
        if      ( sin(angle+Pi) > 0.1 )                 { d_angle -= rot_spd;           }
        else if ( sin(angle+Pi) <-0.1 )                     { d_angle += rot_spd;           }
        else if ( angle >=-0.11 && angle <= 0.11 )              { d_angle -= rot_spd;           }
        else if ( angle <= 0.11 && angle >=-0.11 )              { d_angle -= rot_spd;           }
        else if ( sin(angle+Pi) <= 0.1 && sin(angle+Pi) >= -0.1 )       { d_angle = angleYaw+Pi;        }
    }
 
    if ( AAccel > 0.01 && WAccel < 0.01 && SAccel < 0.01 && DAccel < 0.01 )
    {
        if      ( sin(angle+Pi/2) > 0.1 )               { d_angle -= rot_spd;           }
        else if ( sin(angle+Pi/2) <-0.1 )                   { d_angle += rot_spd;           }
        else if ( angle >= Pi/2 - 0.11 && angle <= Pi/2+0.11 )          { d_angle -= rot_spd;           }
        else if ( sin(angle+Pi/2) <= 0.1 && sin(angle+Pi/2) >= -0.1 )       { d_angle = angleYaw-Pi/2;      }
    }
 
    if ( DAccel > 0.01 && WAccel < 0.01 && SAccel < 0.01 && AAccel < 0.01 )
    {
        if      ( sin(angle-Pi/2) > 0.1 )               { d_angle -= rot_spd;           }
        else if ( sin(angle-Pi/2) <-0.1 )                   { d_angle += rot_spd;           }
        else if ( angle <=-Pi/2 + 0.11 && angle >=-Pi/2-0.11 )          { d_angle += rot_spd;           }
        else if ( sin(angle-Pi/2) <= 0.1 && sin(angle-Pi/2) >= -0.1 )       { d_angle = angleYaw+Pi/2;      }
    }
 
    /// Для одновременного движения по осям X и Z ( например W и D или S и A )
 
    if ( WAccel > 0.01 && AAccel > 0.01 && SAccel < 0.01 && DAccel < 0.01 )
    {
        if      ( sin(angle+Pi/4) > 0.1 )               { d_angle -= rot_spd;           }
        else if ( sin(angle+Pi/4) <-0.1 )                   { d_angle += rot_spd;           }
        else if ( angle >= Pi-Pi/4 - 0.11 && angle <= Pi-Pi/4 + 0.11 )      { d_angle -= rot_spd;           }
        else if ( sin(angle+Pi/4) <= 0.1 && sin(angle+Pi/4) >= -0.1 )       { d_angle = angleYaw-Pi/4;      }
    }
 
    if ( WAccel > 0.01 && DAccel > 0.01 && SAccel < 0.01 && AAccel < 0.01 )
    {
        if      ( sin(angle-Pi/4) > 0.1 )               { d_angle -= rot_spd;           }
        else if ( sin(angle-Pi/4) <-0.1 )                   { d_angle += rot_spd;           }
        else if ( angle <= Pi+Pi/4 + 0.11 && angle >= Pi+Pi/4 - 0.11 )      { d_angle += rot_spd;           }
        else if ( sin(angle-Pi/4) <= 0.1 && sin(angle-Pi/4) >= -0.1 )       { d_angle = angleYaw+Pi/4;      }
    }
 
    if ( SAccel > 0.01 && AAccel > 0.01 && WAccel < 0.01 && DAccel < 0.01 )
    {
        if      ( sin(angle+Pi-Pi/4) > 0.1 )                { d_angle -= rot_spd;           }
        else if ( sin(angle+Pi-Pi/4) <-0.1 )                    { d_angle += rot_spd;           }
        else if ( angle >= Pi/4 - 0.11 && angle <= Pi/4 + 0.11 )        { d_angle -= rot_spd;           }
        else if ( sin(angle+Pi-Pi/4) <= 0.1 && sin(angle+Pi-Pi/4) >= -0.1 )     { d_angle = angleYaw+Pi+Pi/4;       }
    }
 
    if ( SAccel > 0.01 && DAccel > 0.01 && WAccel < 0.01 && AAccel < 0.01 )
    {
        if      ( sin(angle+Pi+Pi/4) > 0.1 )                { d_angle -= rot_spd;           }
        else if ( sin(angle+Pi+Pi/4) <-0.1 )                    { d_angle += rot_spd;           }
        else if ( angle <=-Pi/4 + 0.11 && angle >=-Pi/4 - 0.11 )        { d_angle += rot_spd;           }
        else if ( sin(angle+Pi+Pi/4) <= 0.1 && sin(angle+Pi+Pi/4) >= -0.1 )     { d_angle = angleYaw+Pi-Pi/4;       }
    }
}
 
 
///===============================================================================================================================
/// Name:
/// Desc: Освобождает ресурсы
///===============================================================================================================================
 
void Release()
{
    if (mouse != 0)
    {
        mouse -> Unacquire();
        mouse -> Release();
    }
    if (keyboard != 0)
    {
        keyboard -> Unacquire();
        keyboard -> Release();
    }
    if (di != 0)
    {
        di -> Release();
    }
    if( d3ddev != 0 )
    {
        d3ddev -> Release();
    }
    if( d3d != 0 )
    {
        d3d -> Release();
    }
}
 
 
 
 
 
 
 
 
 
 
///===============================================================================================================================
/// Name:
/// Desc: Главная функция
///===============================================================================================================================
 
int WINAPI WinMain ( HINSTANCE hinst, HINSTANCE hPrevInstance, LPSTR lpszArgument, int nFunsterStil )
{
    InitWin     ();
    InitD3D     ();
    InitInput   ();
 
    // Загрузка моделей
    LoadModel   ( 0, "model.x", "model.jpg" );
    LoadModel   ( 1, "model.x", "model.jpg" );
 
    while ( messages.message != WM_QUIT )
    {
        if( PeekMessage( &messages, NULL, 0, 0, PM_REMOVE ) )
        {
            TranslateMessage(&messages);
            DispatchMessage(&messages);
        }
        else
        {
            Mouse();
            Keyboard();
 
            Projection( D3DX_PI/4.0, 0.1, 1000.0 );
            CameraTP( fPosX+f*YawX, fPosY+0.50, fPosZ-f*YawY, YawY, anglePitch, YawX, PitchD, distcam );
 
            RotateAndMove();
 
            d3ddev -> BeginScene();
            d3ddev -> Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(192, 208, 192), 1.0f, 0 );
 
            // Рисование моделей
            DrawModel( 0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 );
            DrawModel( 1, fPosX, fPosY-0.75, fPosZ, d_angle, 0.0, 0.0 ); // Наш перс
 
            d3ddev -> EndScene();
            d3ddev -> Present( NULL, NULL, NULL, NULL );
        }
    }
    Release();
    return messages.wParam;
}