DirectX 8 Graphics. Частицы (Particles)

// g_pD3DDevice - предварительно созданный и проинициализированный объект устройства Direct 3D.

// Определяем (define) кастомную FVF-структуру и её дескриптор.
typedef struct {
	FLOAT x, y, z; // Локальные 3D-координаты.
	FLOAT u, v; // Координаты текстуры.
}sVertex;

#define VertexFVF(D3DFVF_XYZ | D3DFVF_TEX1)

// Вершинный буфер частиц и их текстура.
IDirect3DVertexBuffer8 *g_pParticleVB = NULL;
IDirect3DTexture8 *g_pParticleTexture = NULL;

BOOL SetupParticle()
{
	BYTE *Ptr;
	sVertex Verts[4] =
	{
		{-1.0f, 1.0f, 0.0f, 0.0f, 0.0f},
		{1.0f, 1.0f, 0.0f, 1.0f, 0.0f},
		{-1.0f, -1.0f, 0.0f, 0.0f, 1.0f},
		{1.0f, -1.0f, 0.0f, 1.0f, 1.0f}
	};

	// Создаём вершинный буфер частиц и заполняем данные.
	if(FAILED(g_pD3DDevice->CreateVertexBuffer(sizeof(sVertex)*4, 0,
		VertexFVF, D3DPOOL_DEFAULT, &g_pParticleVB)))
		return FALSE;
	
	if(FAILED(g_pParticleVB->Lock(0, 0, (BYTE**)&Ptr, 0)))
		return FALSE;
	
	memcpy(Ptr, Verts, sizeof(Verts));
	
	g_pParticleVB->Unlock; // Получаем текстуру частицы.
	
	D3DCreateTextureFromFile(g_pD3DDevice, "particle.bmp", &g_pParticleTexture);
	return TRUE;
}

BOOL DrawParticle(float x, float y, float z, float scale)
{
	D3DXMATRIX matWorld, matView, matTransposed;
	D3DXMATRIX matTrans, matScale;
	D3DMATERIAL8 d3dm;
	
	// Назначаем рендерстейты (альфа-смешивание и его атрибуты).
	g_pD3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
	g_pD3DDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
	g_pD3DDevice->SetRenderState(D3DRS_DESTBLEND_ONE);
	
	// Включаем фоновое (ambient) освещение.
	g_pD3DDevice->SetRenderState(D3DRS_AMBIENT, 0xffffff);
	
	// Назначаем вершинному буферу частиц поток-источник (source stream).
	g_pD3DDevice->SetStreamSource(0, g_pParticle_VB, sizeof(sVertex));
	
	// Назначаем в качестве вершинного шейдера ранее созданную FVF-структуру частицы.
	g_pD3DDevice->SetVertexShader(VertexFVF);
	
	// Назначаем текстуру.
	g_pD3DDevice->SetTexture(0, g_pParticleTexture);
	
	// Назначаем цвет частицы.
	ZeroMemory(&d3dm, sizeof(D3DMATERIAL8));
	d3dm.Diffuse.r = d3dm.Ambient.r = 1.0f;
	d3dm.Diffuse.g = d3dm.Ambient.g = 1.0f;
	d3dm.Diffuse.b = d3dm.Ambient.b = 0.0f;
	d3dm.Diffuse.a	= d3dm.Ambient.a = 1.0f;
	
	// Строим матрицу масштабирования (scaling matrix).
	D3DXMatrixScaling(&matScale, scale, scale, scale);
	
	// Строим матрицу трансляции (translation matrix).
	D3DXMatrixTranslation(&matTrans, x, y, z);
	
	// Строим матрицу билборда (billboard matrix).
	g_pD3DDevice->GetTransform(D3DTS_VIEW, &matView);
	D3DXMatrixTranspose(&matTransposed, &matView);
	
	// Комбинируем матрицы для получения мировой матрицы трансляции (world translation matrix).
	D3DXMatrixMultiply(&matWorld, &matScale, &matTransposed);
	D3DXMatrixMultiply(&matWorld, &matWorld, &matTrans);
	
	// Назначаем полученную мировую матрицу трансляции
	// в качестве действующей в объекте устройства Direct3D.
	g_pD3DDevice->SetTransform(D3DTS_WORLD, &matWorld);
	
	// Рисуем частицу.
	g_pD3DDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2); // Выключаем альфа-смешивание.
	g_pD3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
	
	return TRUE;
}

/**************************************************
WinMain.cpp
Chapter 6 Particle Demo

Programming Role-Playing Games with DirectX
by Jim Adams (01 Jan 2002)

Required libraries:
  WINMM.LIB, D3D8.LIB, and D3DX8.LIB
**************************************************/

// Include files
#include <windows.h>
#include <stdio.h>
#include "d3d8.h"
#include "d3dx8.h"

// Window handles, class and caption text
// Дескриптор окна, класс и текст тулбара
HWND          g_hWnd;
HINSTANCE     g_hInst;
static char   g_szClass[]   = "ParticleClass";
static char   g_szCaption[] = "Particle Demo by Jim Adams";

// The Direct3D and Device object
IDirect3D8       *g_pD3D       = NULL;
IDirect3DDevice8 *g_pD3DDevice = NULL;

// The particle vertex format and descriptor
// FVF-структура частицы и её дескриптор
typedef struct {
  FLOAT x, y, z;    // 3D coordinates
  D3DCOLOR Diffuse; // Color
  FLOAT u, v;       // Texture coordinates
} sVertex;
#define VERTEXFVF (D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1)

// The Particle vertex buffer and texture
// Вершинный буфер частицы и её текстура
IDirect3DVertexBuffer8 *g_pParticleVB      = NULL;
IDirect3DTexture8      *g_pParticleTexture = NULL;

// Create a structure for tracking particles
// Создаём структуру для отслеживания частиц
typedef struct sParticle {
  float    XPos, YPos, ZPos;  // Coordinates
  float    XAdd, YAdd, ZAdd;  // Movement values. Значения смещения
  float    Red, Green, Blue;  // Colors
  long     Timer, Counter;    // Current and update counter. Текущее время и счётчик

  sParticle()
  {
    // Position particle at origin
	// Начальное положение частицы
    XPos = YPos = ZPos = 0.0f;

    // Get a random update counter
	// Случайно обновляем счётчик
    Counter = rand() % 50 + 10;
    Timer = 0;

    // Get a random speed
	// Получаем случайную скорость
    XAdd = (float)(rand() % 11) - 5.0f;
    YAdd = (float)(rand() % 11) - 5.0f;
    ZAdd = (float)(rand() % 11) - 5.0f;

    // Get a random color
	// Получаем случайный цвет
    Red   = (float)(rand() % 101) / 100.0f;
    Green = (float)(rand() % 101) / 100.0f;
    Blue  = (float)(rand() % 101) / 100.0f;
  }
} sParticle;

sParticle *g_pParticles = NULL;

// Function prototypes
int PASCAL WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR szCmdLine, int nCmdShow);
long FAR PASCAL WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

BOOL DoInit();
BOOL DoShutdown();
BOOL DoFrame();
BOOL SetupParticles();

int PASCAL WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR szCmdLine, int nCmdShow)
{
  WNDCLASSEX wcex;
  MSG        Msg;

  g_hInst = hInst;

  // Create the window class here and register it
  // Создаём оконный класс и регистрируем его
  wcex.cbSize        = sizeof(wcex);
  wcex.style         = CS_CLASSDC;
  wcex.lpfnWndProc   = WindowProc;
  wcex.cbClsExtra    = 0;
  wcex.cbWndExtra    = 0;
  wcex.hInstance     = hInst;
  wcex.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
  wcex.hCursor       = LoadCursor(NULL, IDC_ARROW);
  wcex.hbrBackground = NULL;
  wcex.lpszMenuName  = NULL;
  wcex.lpszClassName = g_szClass;
  wcex.hIconSm       = LoadIcon(NULL, IDI_APPLICATION);
  if(!RegisterClassEx(&wcex))
    return FALSE;

  // Create the Main Window
  // Создаём окно программы
  g_hWnd = CreateWindow(g_szClass, g_szCaption,
        WS_CAPTION | WS_SYSMENU,
        0, 0, 400, 400,
        NULL, NULL,
        hInst, NULL );
  if(!g_hWnd)
    return FALSE;
  ShowWindow(g_hWnd, SW_NORMAL);
  UpdateWindow(g_hWnd);

  // Run init function and return on error
  if(DoInit() == FALSE)
    return FALSE;

  // Start message pump, waiting for signal to quit
  // Стартуем конвейер выборки сообщений
  ZeroMemory(&Msg, sizeof(MSG));
  while(Msg.message != WM_QUIT) {
    if(PeekMessage(&Msg, NULL, 0, 0, PM_REMOVE)) {
      TranslateMessage(&Msg);
      DispatchMessage(&Msg);
    }
    if(DoFrame() == FALSE)
      break;
  }

  // Run shutdown function
  DoShutdown();
  
  UnregisterClass(g_szClass, hInst);

  return Msg.wParam;
}

long FAR PASCAL WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
  switch(uMsg) {
    case WM_DESTROY:
      PostQuitMessage(0);
      return 0;
  }

  return DefWindowProc(hWnd, uMsg, wParam, lParam);
}

BOOL DoInit()
{
  D3DPRESENT_PARAMETERS d3dpp;
  D3DDISPLAYMODE        d3ddm;
  D3DXMATRIX            matView, matProj;

  // Do a windowed mode initialization of Direct3D
  // Инициализируем объект устройства Direct3D
  // для работы в оконном режиме
  if((g_pD3D = Direct3DCreate8(D3D_SDK_VERSION)) == NULL)
    return FALSE;
  if(FAILED(g_pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &d3ddm)))
    return FALSE;
  ZeroMemory(&d3dpp, sizeof(d3dpp));
  d3dpp.Windowed = TRUE;
  d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
  d3dpp.BackBufferFormat = d3ddm.Format;
  d3dpp.EnableAutoDepthStencil = TRUE;
  d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
  if(FAILED(g_pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, g_hWnd,
                                  D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                                  &d3dpp, &g_pD3DDevice)))
    return FALSE;

  // Set the render states
  g_pD3DDevice->SetRenderState(D3DRS_LIGHTING, TRUE);
  g_pD3DDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE);

  // Set ambient light to highest level (to see particles)
  // Устанавливаем цвет подсветки и его наивысшее значение
  // (чтобы видеть частицы)
  g_pD3DDevice->SetRenderState(D3DRS_AMBIENT, 0xFFFFFFFF);

  // Create and set the projection transformation
  // Создаём и назначаем трансформацию проекции
  D3DXMatrixPerspectiveFovLH(&matProj, D3DX_PI/4, 1.0f, 1.0f, 1000.0f);
  g_pD3DDevice->SetTransform(D3DTS_PROJECTION, &matProj);

  // Create and set the view transformation
  // Создаём и назначаем трансформацию вида
  D3DXMatrixLookAtLH(&matView, &D3DXVECTOR3(0.0f, 0.0f, -500.0f), &D3DXVECTOR3(0.0f, 0.0f, 0.0f), &D3DXVECTOR3(0.0f, 1.0f, 0.0f));
  g_pD3DDevice->SetTransform(D3DTS_VIEW, &matView);

  // Create the vertices
  // Создаём частицы
  SetupParticles();

  return TRUE;
}

BOOL DoShutdown()
{
  // Free particles
  // Освобождаем частицы
  if(g_pParticles != NULL)
    delete [] g_pParticles;

  // Release textures and vertex buffers
  // Очищаем память от текстур и вершинных буферов
  if(g_pParticleTexture != NULL)
    g_pParticleTexture->Release();

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

  // Release device and 3D objects
  if(g_pD3DDevice != NULL)
    g_pD3DDevice->Release();

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

  return TRUE;
}

BOOL DoFrame()
{
  D3DXMATRIX matView, matWorld, matTransposed, matTrans;
  static D3DMATERIAL8 Mat;
  static BOOL InitMat = TRUE;
  static DWORD Counter = timeGetTime();

  // Limit to 30fps
  // Ограничиваем частоту кадров до 30 в сек.
  if(timeGetTime() < Counter+33)
    return TRUE;
  Counter = timeGetTime();

  // Configure the material if first time called
  // При первом вызове настраиваем материал
  if(InitMat == TRUE) {
    InitMat = FALSE;
    ZeroMemory(&Mat, sizeof(Mat));
    Mat.Diffuse.a = Mat.Ambient.a = 0.5f;
  }

  // Clear device backbuffer
  g_pD3DDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_RGBA(0,64,128,255), 1.0f, 0);

  if(SUCCEEDED(g_pD3DDevice->BeginScene())) {

    // Set the particle source, shader, and texture
	// Назначаем источник частиц, шейдер и текстуру
    g_pD3DDevice->SetStreamSource(0, g_pParticleVB, sizeof(sVertex));
    g_pD3DDevice->SetVertexShader(VERTEXFVF);
    g_pD3DDevice->SetTexture(0, g_pParticleTexture);

    // Get and set the transposed view matrix (billboard technique)
	// Получаем и назначаем транспонированную матрицу вида
	// (техника билбордов)
    g_pD3DDevice->GetTransform(D3DTS_VIEW, &matView);
    D3DXMatrixTranspose(&matTransposed, &matView);

    // Enable alpha blending
	// Включаем альфа-смешивание
    g_pD3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
    g_pD3DDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
    g_pD3DDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ONE);

    // Loop through all particles and draw them
	// Зацикленно проходим через каждую частицу
	// и отрисовываем их
    for(short i=0;i<512;i++) {

      // Move particle first
	  // Сперва перемещаем частицы
      g_pParticles[i].XPos += g_pParticles[i].XAdd;
      g_pParticles[i].YPos += g_pParticles[i].YAdd;
      g_pParticles[i].ZPos += g_pParticles[i].ZAdd;

      // Reverse movements if past counter
	  // При достижении счётчиком порогового значения,
	  // меняем направление движ. частицы на обратное
      if((g_pParticles[i].Timer += 1) >= g_pParticles[i].Counter) {
        g_pParticles[i].Timer = 0;
        g_pParticles[i].XAdd *= -1.0f;
        g_pParticles[i].YAdd *= -1.0f;
        g_pParticles[i].ZAdd *= -1.0f;
      }

      // Setup the particle's world transformation
	  // Настраиваем мировую матрицу частиц
      D3DXMatrixTranslation(&matTrans, g_pParticles[i].XPos, \
                                       g_pParticles[i].YPos, \
                                       g_pParticles[i].ZPos);
      D3DXMatrixMultiply(&matWorld, &matTrans, &matTransposed);
      g_pD3DDevice->SetTransform(D3DTS_WORLD, &matWorld);

      // Set the particle's material
	  // Назначаем материал частицы
      Mat.Diffuse.r = Mat.Ambient.r = g_pParticles[i].Red;
      Mat.Diffuse.g = Mat.Ambient.g = g_pParticles[i].Green;
      Mat.Diffuse.b = Mat.Ambient.b = g_pParticles[i].Blue;
      g_pD3DDevice->SetMaterial(&Mat);

      // Draw the particle
	  // Отрисовываем частицу
      g_pD3DDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2);
    }

    // Clear the texture usage
    g_pD3DDevice->SetTexture(0, NULL);

    // End the scene
    g_pD3DDevice->EndScene();
  }

  // Display the scene
  // Выводим сцену на экран
  g_pD3DDevice->Present(NULL, NULL, NULL, NULL);

  return TRUE;
}

BOOL SetupParticles()
{
  BYTE *Ptr;
  sVertex Verts[4] = {
    { -50.0f, 50.0f, 0.0f, 0xFFFFFFFF, 0.0f, 0.0f },
    {  50.0f, 50.0f, 0.0f, 0xFFFFFFFF, 1.0f, 0.0f },
    { -50.0f,  0.0f, 0.0f, 0xFFFFFFFF, 0.0f, 1.0f },
    {  50.0f,  0.0f, 0.0f, 0xFFFFFFFF, 1.0f, 1.0f }
  };

  // Create vertex buffers and set data
  // Создаём вершинный буфер и размещаем в нём вершины
  g_pD3DDevice->CreateVertexBuffer(sizeof(Verts)*4, 0,        \
                  VERTEXFVF, D3DPOOL_DEFAULT, &g_pParticleVB);
  g_pParticleVB->Lock(0,0, (BYTE**)&Ptr, 0);
  memcpy(Ptr, Verts, sizeof(Verts));
  g_pParticleVB->Unlock();

  // Get textures 
  // Получаем текстуру
  D3DXCreateTextureFromFile(g_pD3DDevice, "Particle.bmp", &g_pParticleTexture);

  // Create some particles
  // Генерим частицы
  g_pParticles = new sParticle[512]();

  return TRUE;
}

...
// Include files
#include <windows.h>
#include <stdio.h>
#include "d3d8.h"
#include "d3dx8.h"
...

$(WindowsSdkDir)include

Error LNK1123: сбой при преобразовании в COFF: файл недопустим или поврежден

...
Required libraries:
  WINMM.LIB, D3D8.LIB and D3DX8.LIB
...

...
  // Get textures 
  // Получаем текстуру
  D3DXCreateTextureFromFile(g_pD3DDevice, "Particle.bmp", &g_pParticleTexture);
...