C++ DirectX Draw Triangle

-

C++ DirectX

Draw Triangle

1.Download Microsoft DirectX SDK (June 2010)
Install it

2.  main.cpp
// include the basic windows header files and the Direct3D header files
#define UNICODE
#include <windows.h>
#include <windowsx.h>
#include <d3d11.h>
#include "G:\SDK\Microsoft DirectX SDK (June 2010)\Include\D3DX10.h"
#include "G:\SDK\Microsoft DirectX SDK (June 2010)\Include\D3DX11.h"

// include the Direct3D Library file
#pragma comment (lib, "d3d11.lib")
#pragma comment (lib, "G:\\SDK\\Microsoft DirectX SDK (June 2010)\\Lib\\x86\\d3dx11.lib")
#pragma comment (lib, "G:\\SDK\\Microsoft DirectX SDK (June 2010)\\Lib\\x86\\d3dx10.lib")

// define the screen resolution
#define SCREEN_WIDTH  800
#define SCREEN_HEIGHT 600

// global declarations
IDXGISwapChain *swapchain;             // the pointer to the swap chain interface
ID3D11Device *dev;                     // the pointer to our Direct3D device interface
ID3D11DeviceContext *devcon;           // the pointer to our Direct3D device context
ID3D11RenderTargetView *backbuffer;    // the pointer to our back buffer
ID3D11InputLayout *pLayout;            // the pointer to the input layout
ID3D11VertexShader *pVS;               // the pointer to the vertex shader
ID3D11PixelShader *pPS;                // the pointer to the pixel shader
ID3D11Buffer *pVBuffer;                // the pointer to the vertex buffer

// a struct to define a single vertex
struct VERTEX { FLOAT X, Y, Z; D3DXCOLOR Color; };

// function prototypes
void InitD3D(HWND hWnd);    // sets up and initializes Direct3D
void RenderFrame(void);     // renders a single frame
void CleanD3D(void);        // closes Direct3D and releases memory
void InitGraphics(void);    // creates the shape to render
void InitPipeline(void);    // loads and prepares the shaders

// the WindowProc function prototype
LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);


// the entry point for any Windows program
int WINAPI WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
HWND hWnd;
WNDCLASSEX wc;

ZeroMemory(&wc, sizeof(WNDCLASSEX));

wc.cbSize = sizeof(WNDCLASSEX);
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = WindowProc;
wc.hInstance = hInstance;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.lpszClassName = L"WindowClass";

RegisterClassEx(&wc);

RECT wr = { 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT };
AdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, FALSE);

hWnd = CreateWindowEx(NULL,
L"WindowClass",
L"Our First Direct3D Program",
WS_OVERLAPPEDWINDOW,
300,
300,
wr.right - wr.left,
wr.bottom - wr.top,
NULL,
NULL,
hInstance,
NULL);

ShowWindow(hWnd, nCmdShow);

// set up and initialize Direct3D
InitD3D(hWnd);

// enter the main loop:

MSG msg;

while (TRUE)
{
if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);

if (msg.message == WM_QUIT)
break;
}

RenderFrame();
}

// clean up DirectX and COM
CleanD3D();

return msg.wParam;
}


// this is the main message handler for the program
LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_DESTROY:
{
PostQuitMessage(0);
return 0;
} break;
}

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


// this function initializes and prepares Direct3D for use
void InitD3D(HWND hWnd)
{
// create a struct to hold information about the swap chain
DXGI_SWAP_CHAIN_DESC scd;

// clear out the struct for use
ZeroMemory(&scd, sizeof(DXGI_SWAP_CHAIN_DESC));

// fill the swap chain description struct
scd.BufferCount = 1;                                   // one back buffer
scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;    // use 32-bit color
scd.BufferDesc.Width = SCREEN_WIDTH;                   // set the back buffer width
scd.BufferDesc.Height = SCREEN_HEIGHT;                 // set the back buffer height
scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;     // how swap chain is to be used
scd.OutputWindow = hWnd;                               // the window to be used
scd.SampleDesc.Count = 4;                              // how many multisamples
scd.Windowed = TRUE;                                   // windowed/full-screen mode
scd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;    // allow full-screen switching

// create a device, device context and swap chain using the information in the scd struct
D3D11CreateDeviceAndSwapChain(NULL,
D3D_DRIVER_TYPE_HARDWARE,
NULL,
NULL,
NULL,
NULL,
D3D11_SDK_VERSION,
&scd,
&swapchain,
&dev,
NULL,
&devcon);


// get the address of the back buffer
ID3D11Texture2D *pBackBuffer;
swapchain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&pBackBuffer);

// use the back buffer address to create the render target
dev->CreateRenderTargetView(pBackBuffer, NULL, &backbuffer);
pBackBuffer->Release();

// set the render target as the back buffer
devcon->OMSetRenderTargets(1, &backbuffer, NULL);


// Set the viewport
D3D11_VIEWPORT viewport;
ZeroMemory(&viewport, sizeof(D3D11_VIEWPORT));

viewport.TopLeftX = 0;
viewport.TopLeftY = 0;
viewport.Width = SCREEN_WIDTH;
viewport.Height = SCREEN_HEIGHT;

devcon->RSSetViewports(1, &viewport);

InitPipeline();
InitGraphics();
}


// this is the function used to render a single frame
void RenderFrame(void)
{
// clear the back buffer to a deep blue
devcon->ClearRenderTargetView(backbuffer, D3DXCOLOR(0.0f, 0.2f, 0.4f, 1.0f));

// select which vertex buffer to display
UINT stride = sizeof(VERTEX);
UINT offset = 0;
devcon->IASetVertexBuffers(0, 1, &pVBuffer, &stride, &offset);

// select which primtive type we are using
devcon->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);

// draw the vertex buffer to the back buffer
devcon->Draw(3, 0);

// switch the back buffer and the front buffer
swapchain->Present(0, 0);
}


// this is the function that cleans up Direct3D and COM
void CleanD3D(void)
{
swapchain->SetFullscreenState(FALSE, NULL);    // switch to windowed mode

// close and release all existing COM objects
pLayout->Release();
pVS->Release();
pPS->Release();
pVBuffer->Release();
swapchain->Release();
backbuffer->Release();
dev->Release();
devcon->Release();
}


// this is the function that creates the shape to render
void InitGraphics()
{
// create a triangle using the VERTEX struct
VERTEX OurVertices[] =
{
{0.0f, 0.5f, 0.0f, D3DXCOLOR(1.0f, 0.0f, 0.0f, 1.0f)},
{0.45f, -0.5, 0.0f, D3DXCOLOR(0.0f, 1.0f, 0.0f, 1.0f)},
{-0.45f, -0.5f, 0.0f, D3DXCOLOR(0.0f, 0.0f, 1.0f, 1.0f)}
};


// create the vertex buffer
D3D11_BUFFER_DESC bd;
ZeroMemory(&bd, sizeof(bd));

bd.Usage = D3D11_USAGE_DYNAMIC;                // write access access by CPU and GPU
bd.ByteWidth = sizeof(VERTEX) * 3;             // size is the VERTEX struct * 3
bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;       // use as a vertex buffer
bd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;    // allow CPU to write in buffer

dev->CreateBuffer(&bd, NULL, &pVBuffer);       // create the buffer


// copy the vertices into the buffer
D3D11_MAPPED_SUBRESOURCE ms;
devcon->Map(pVBuffer, NULL, D3D11_MAP_WRITE_DISCARD, NULL, &ms);    // map the buffer
memcpy(ms.pData, OurVertices, sizeof(OurVertices));                 // copy the data
devcon->Unmap(pVBuffer, NULL);                                      // unmap the buffer
}


// this function loads and prepares the shaders
void InitPipeline()
{
// load and compile the two shaders
ID3D10Blob *VS, *PS;
D3DX11CompileFromFile(L"shaders.shader", 0, 0, "VShader", "vs_4_0", 0, 0, 0, &VS, 0, 0);
D3DX11CompileFromFile(L"shaders.shader", 0, 0, "PShader", "ps_4_0", 0, 0, 0, &PS, 0, 0);

// encapsulate both shaders into shader objects
dev->CreateVertexShader(VS->GetBufferPointer(), VS->GetBufferSize(), NULL, &pVS);
dev->CreatePixelShader(PS->GetBufferPointer(), PS->GetBufferSize(), NULL, &pPS);

// set the shader objects
devcon->VSSetShader(pVS, 0, 0);
devcon->PSSetShader(pPS, 0, 0);

// create the input layout object
D3D11_INPUT_ELEMENT_DESC ied[] =
{
{"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0},
{"COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0},
};

dev->CreateInputLayout(ied, 2, VS->GetBufferPointer(), VS->GetBufferSize(), &pLayout);
devcon->IASetInputLayout(pLayout);
}

3. Shaders.shader
struct VOut
{
float4 position : SV_POSITION;
float4 color : COLOR;
};

VOut VShader(float4 position : POSITION, float4 color : COLOR)
{
VOut output;

output.position = position;
output.color = color;

return output;
}


float4 PShader(float4 position : SV_POSITION, float4 color : COLOR) : SV_TARGET
{
return color;
}

4. 最後 方案總管 


留言

張貼留言

這個網誌中的熱門文章

-
符號念法 大寫 小寫 寫法 念法 提示 Α α alpha ʹæ lfə Β β beta ʹbetə Γ γ gamma ʹgæ mə Δ δ delta ʹdɛltə Ε ε epsilon ʹepsɪlən 與Υυ 的區分在第一個音為 e Ζ ζ zeta ʹzitə Η η eta ʹeɪtə Θ θ theta ʹθitə Ι ι iota aɪʹɔʊtə iota Κ κ kappa ʹkæ pə Λ λ lambda ʹlæ pə Μ μ mu ʹmjuə Ν ν nu ʹnju Ξ ξ xi ʹsaɪ cy, 為了與Ψψ 區分可念 k-si , 也有人念 zi Ο ο omicron ʹɔʊmaɪkrən Π π pi ʹpaɪ 有 py 與 ʹpaɪ 兩種念法 Ρ ρ rho ʹrɔʊ Σ σ sigma ʹsɪgmə Τ τ tau ʹtau Υ υ upsilon ʹjupsɪlən 與 Ε ε 的區分在第一個音為 u 或 a Φ φ phi ʹfaɪ fy Χ χ chi ʹkaɪ ky Ψ ψ psi ʹpsaɪ cy, 為了與 Ξ ξ 區分可念 p-si, 也有人念 ʹpsaɪ Ω ω omega ʹɔʊmɛgə
閱讀完整內容

組合語言 Assembly Language

-
 組合語言 Assembly Language 1. ds=2300h ， bx=0200h ，那麼執行 mov ax,[bx] 指令後就會把 2300:0200 記憶體的資料取出 2byes 並存入 ax 2. SP 是堆疊指標，當使用 push 指令時， sp 會加 2 ，而執行 pop 時 sp 會減 2 3. data. pas0 db 'ABCD' pas2 db 'EFGH'   ; 假設資料段，是如此定義了兩個變數 　　　　　　　 ; pas0 位址的內含值是 'A' ， pas0+1 的內含值是 'B' 　　　　　　 ; pas0+2 位址的內含值是 'C' ， pas0+3 的內含值是 'D' 　　 ; pas0+4 位址的內含值是 'E' 也是等於 pas2 的內含值是 'E' 　　 ; 這個地方非常的奧秒吧，為什麼 [pas0+4]=[pas2] 的值 　　 ; 因為 'D' 的下一位址就是 'E' 4. 置放堆疊的記憶體區塊的 位址 ，就是 SS:SP 暫存器所指的位址 (1).PUSH ：將 sp 的值減 2 ，然後在將指定要放入堆疊的運算元存入 ss:[sp] (2).POP ：將 ss:[sp] 的值取出，並放入所指定的運算元內，然後 sp 的值加 2 jmpi jmpi  go,INITSEG jmpi为段间跳转指令 執行這條指令之後 CS = INITSEG IP = go db 前要加jmp org 100h jmp main msg db 'hello','$' main: ;your code ret 輸入字元 ah=01h return al ex: mov ah,01h int 21h ;al = [intput char] 輸出字元 al => result status ex: mov ah,01h
閱讀完整內容