【C++】DirectX9サンプルコードで始めるゲーム描画入門—初期化とレンダリングループの実装

#include <windows.h>
// ウィンドウプロシージャの宣言
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR, int nCmdShow)
{
    // ウィンドウクラスの設定
    WNDCLASSEX wc = {};
    wc.cbSize = sizeof(WNDCLASSEX);
    wc.style = CS_HREDRAW | CS_VREDRAW; // ウィンドウの再描画スタイル
    wc.lpfnWndProc = WndProc;           // ウィンドウプロシージャの指定
    wc.cbClsExtra = 0;                  // 追加メモリなし
    wc.cbWndExtra = 0;                  // 追加メモリなし
    wc.hInstance = hInstance;           // インスタンスハンドル
    wc.hIcon = LoadIcon(nullptr, IDI_APPLICATION); // アイコン
    wc.hCursor = LoadCursor(nullptr, IDC_ARROW);   // カーソル
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1); // 背景色
    wc.lpszMenuName = nullptr;          // メニューなし
    wc.lpszClassName = L"MyWindowClass"; // クラス名
    wc.hIconSm = LoadIcon(nullptr, IDI_APPLICATION); // 小アイコン
    // ウィンドウクラスの登録
    if (!RegisterClassEx(&wc))
    {
        MessageBox(nullptr, L"ウィンドウクラスの登録に失敗しました。", L"エラー", MB_OK | MB_ICONERROR);
        return 0;
    }
    // ウィンドウの作成
    HWND hwnd = CreateWindowEx(
        0,
        wc.lpszClassName,
        L"DirectX9 Sample Window",
        WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT,
        800, 600,
        nullptr,
        nullptr,
        hInstance,
        nullptr);
    if (!hwnd)
    {
        MessageBox(nullptr, L"ウィンドウの作成に失敗しました。", L"エラー", MB_OK | MB_ICONERROR);
        return 0;
    }
    ShowWindow(hwnd, nCmdShow);
    UpdateWindow(hwnd);
    // メッセージループはここで行う(後述)
    return 0;
}
// ウィンドウプロシージャの定義
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch (msg)
    {
    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    default:
        return DefWindowProc(hwnd, msg, wParam, lParam);
    }
}

MSG msg = {};
while (true)
{
    // メッセージがあるかどうかをチェックし、あれば取得する
    if (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE))
    {
        if (msg.message == WM_QUIT)
            break; // WM_QUITが来たらループを抜けて終了
        TranslateMessage(&msg); // キーボードメッセージの変換
        DispatchMessage(&msg);  // ウィンドウプロシージャにメッセージを送る
    }
    else
    {
        // メッセージがない場合はここで描画処理などを行う
        // 例: RenderFrame();
    }
}

#include <windows.h>
#include <d3d9.h>
#pragma comment(lib, "d3d9.lib")
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR, int nCmdShow)
{
    // Direct3D9オブジェクトの生成
    IDirect3D9* pD3D = Direct3DCreate9(D3D_SDK_VERSION);
    if (!pD3D)
    {
        MessageBox(nullptr, L"Direct3D9の生成に失敗しました。", L"エラー", MB_OK | MB_ICONERROR);
        return 0;
    }
    // ここでデバイス作成などを行う
    // 使用後は解放
    pD3D->Release();
    return 0;
}

D3DPRESENT_PARAMETERS d3dpp = {};
d3dpp.Windowed = TRUE; // ウィンドウモード
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.BackBufferFormat = D3DFMT_X8R8G8B8;
d3dpp.BackBufferWidth = 800;
d3dpp.BackBufferHeight = 600;
d3dpp.EnableAutoDepthStencil = TRUE; // 深度バッファを自動生成
d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8; // 24ビット深度＋8ビットステンシル
d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_ONE; // 垂直同期あり

IDirect3DDevice9* pDevice = nullptr;
HRESULT hr = pD3D->CreateDevice(
    D3DADAPTER_DEFAULT,          // デフォルトのグラフィックスアダプター
    D3DDEVTYPE_HAL,              // ハードウェア抽象レイヤーを使用
    hwnd,                       // 描画対象のウィンドウハンドル
    D3DCREATE_HARDWARE_VERTEXPROCESSING, // 頂点処理をGPUで行う
    &d3dpp,                     // プレゼンテーションパラメータ
    &pDevice                    // 作成したデバイスのポインタ
);
if (FAILED(hr))
{
    MessageBox(nullptr, L"Direct3Dデバイスの作成に失敗しました。", L"エラー", MB_OK | MB_ICONERROR);
    pD3D->Release();
    return 0;
}

d3dpp.Windowed = FALSE; // フルスクリーン
d3dpp.BackBufferWidth = 1920;
d3dpp.BackBufferHeight = 1080;
d3dpp.FullScreen_RefreshRateInHz = 60; // 60Hz

HRESULT hr = pDevice->TestCooperativeLevel();
if (hr == D3DERR_DEVICELOST)
{
    // デバイスロスト中。描画は行わない。
    return;
}
else if (hr == D3DERR_DEVICENOTRESET)
{
    // リセット可能です。リソースを解放してリセットを試みる。
    // 例: ReleaseResources();
    hr = pDevice->Reset(&d3dpp);
    if (SUCCEEDED(hr))
    {
        // リセット成功。リソースを再作成。
        // 例: CreateResources();
    }
}
else if (hr == D3D_OK)
{
    // 正常。描画処理を続行。
}

pDevice->Clear(
    0,              // クリアする矩形の数(0は全画面)
    nullptr,        // クリアする矩形の配列(nullptrで全画面)
    D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, // バックバッファと深度バッファをクリア
    D3DCOLOR_XRGB(0, 0, 64), // クリア色(暗い青)
    1.0f,           // 深度バッファの初期値
    0               // ステンシルバッファの初期値
);

if (SUCCEEDED(pDevice->BeginScene()))
{
    // ここに描画処理を記述
    // 例: pDevice->DrawPrimitive(...);
    pDevice->EndScene();
}

pDevice->Present(nullptr, nullptr, nullptr, nullptr);

#include <windows.h>
#include <chrono>
const int TARGET_FPS = 60;
const int FRAME_TIME_MS = 1000 / TARGET_FPS;
auto lastTime = std::chrono::high_resolution_clock::now();
while (true)
{
    // メッセージ処理(省略)
    // 描画処理開始
    pDevice->Clear(0, nullptr, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0, 0, 64), 1.0f, 0);
    if (SUCCEEDED(pDevice->BeginScene()))
    {
        // 描画コマンド
        pDevice->EndScene();
    }
    pDevice->Present(nullptr, nullptr, nullptr, nullptr);
    // フレーム時間計測
    auto currentTime = std::chrono::high_resolution_clock::now();
    auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(currentTime - lastTime).count();
    if (elapsed < FRAME_TIME_MS)
    {
        Sleep(FRAME_TIME_MS - elapsed);
    }
    lastTime = std::chrono::high_resolution_clock::now();
}

#include <d3d9.h>
// カスタム頂点構造体
struct CUSTOMVERTEX
{
    FLOAT x, y, z;   // 頂点の位置
    FLOAT u, v;      // テクスチャ座標
};
// FVFコードの定義
#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ | D3DFVF_TEX1)

IDirect3DVertexBuffer9* pVertexBuffer = nullptr;
// 頂点数
const int vertexCount = 4;
// 頂点バッファの作成
HRESULT hr = pDevice->CreateVertexBuffer(
    sizeof(CUSTOMVERTEX) * vertexCount, // バッファサイズ
    0,                                  // 使用フラグ(通常は0)
    D3DFVF_CUSTOMVERTEX,                // FVFコード
    D3DPOOL_MANAGED,                    // メモリプール
    &pVertexBuffer,                     // 作成したバッファのポインタ
    nullptr);
if (FAILED(hr))
{
    MessageBox(nullptr, L"頂点バッファの作成に失敗しました。", L"エラー", MB_OK | MB_ICONERROR);
    return;
}
// バッファのロック
CUSTOMVERTEX* pVertices = nullptr;
hr = pVertexBuffer->Lock(0, 0, (void**)&pVertices, 0);
if (FAILED(hr))
{
    MessageBox(nullptr, L"頂点バッファのロックに失敗しました。", L"エラー", MB_OK | MB_ICONERROR);
    return;
}
// 頂点データの設定(四角形の4頂点)
pVertices[0] = { -1.0f,  1.0f, 0.0f, 0.0f, 0.0f }; // 左上
pVertices[1] = {  1.0f,  1.0f, 0.0f, 1.0f, 0.0f }; // 右上
pVertices[2] = { -1.0f, -1.0f, 0.0f, 0.0f, 1.0f }; // 左下
pVertices[3] = {  1.0f, -1.0f, 0.0f, 1.0f, 1.0f }; // 右下
// バッファのアンロック
pVertexBuffer->Unlock();

IDirect3DIndexBuffer9* pIndexBuffer = nullptr;
const int indexCount = 6; // 2三角形 × 3頂点
hr = pDevice->CreateIndexBuffer(
    sizeof(WORD) * indexCount,
    0,
    D3DFMT_INDEX16, // 16ビットインデックス
    D3DPOOL_MANAGED,
    &pIndexBuffer,
    nullptr);
if (FAILED(hr))
{
    MessageBox(nullptr, L"インデックスバッファの作成に失敗しました。", L"エラー", MB_OK | MB_ICONERROR);
    return;
}
WORD* pIndices = nullptr;
hr = pIndexBuffer->Lock(0, 0, (void**)&pIndices, 0);
if (FAILED(hr))
{
    MessageBox(nullptr, L"インデックスバッファのロックに失敗しました。", L"エラー", MB_OK | MB_ICONERROR);
    return;
}
// インデックスデータの設定(2つの三角形)
pIndices[0] = 0; pIndices[1] = 1; pIndices[2] = 2; // 三角形1
pIndices[3] = 2; pIndices[4] = 1; pIndices[5] = 3; // 三角形2
pIndexBuffer->Unlock();

// 頂点フォーマットの設定
pDevice->SetFVF(D3DFVF_CUSTOMVERTEX);
// 頂点バッファのセット
pDevice->SetStreamSource(0, pVertexBuffer, 0, sizeof(CUSTOMVERTEX));
// インデックスバッファのセット
pDevice->SetIndices(pIndexBuffer);
// プリミティブの描画(インデックス付き三角形リスト)
pDevice->DrawIndexedPrimitive(
    D3DPT_TRIANGLELIST, // プリミティブタイプ
    0,                  // ベース頂点インデックス
    0,                  // 最小頂点インデックス
    4,                  // 頂点数
    0,                  // インデックス開始位置
    2                   // プリミティブ数(三角形2つ)
);

#include <d3dx9.h>
#pragma comment(lib, "d3dx9.lib")
IDirect3DTexture9* pTexture = nullptr;
// テクスチャの読み込み
HRESULT hr = D3DXCreateTextureFromFile(pDevice, L"texture.png", &pTexture);
if (FAILED(hr))
{
    MessageBox(nullptr, L"テクスチャの読み込みに失敗しました。", L"エラー", MB_OK | MB_ICONERROR);
    return;
}

pDevice->SetTexture(0, pTexture);

pDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
pDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
pDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
pDevice->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
pDevice->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);

struct CUSTOMVERTEX
{
    FLOAT x, y, z;   // 頂点位置
    FLOAT u, v;      // テクスチャ座標
};

// 頂点入力構造体
struct VS_INPUT
{
    float4 position : POSITION; // 頂点位置(x,y,z,w)
    float2 texcoord : TEXCOORD0; // テクスチャ座標
};
// 頂点出力構造体
struct VS_OUTPUT
{
    float4 position : POSITION; // 変換後の位置
    float2 texcoord : TEXCOORD0; // テクスチャ座標をそのまま渡す
};
// 定数バッファ(行列)
uniform float4x4 WorldViewProj;
// 頂点シェーダー関数
VS_OUTPUT main(VS_INPUT input)
{
    VS_OUTPUT output;
    // ワールド・ビュー・射影行列で頂点位置を変換
    output.position = mul(input.position, WorldViewProj);
    output.texcoord = input.texcoord;
    return output;
}

#include <d3d9.h>
#include <d3dx9.h>
#pragma comment(lib, "d3d9.lib")
#pragma comment(lib, "d3dx9.lib")
IDirect3DVertexShader9* pVertexShader = nullptr;
ID3DXConstantTable* pConstantTable = nullptr;
HRESULT CompileVertexShader(IDirect3DDevice9* pDevice)
{
    ID3DXBuffer* pCode = nullptr;
    ID3DXBuffer* pErrors = nullptr;
    // HLSLコード(文字列で記述)
    const char* vsCode =
        "struct VS_INPUT { float4 position : POSITION; float2 texcoord : TEXCOORD0; };"
        "struct VS_OUTPUT { float4 position : POSITION; float2 texcoord : TEXCOORD0; };"
        "uniform float4x4 WorldViewProj;"
        "VS_OUTPUT main(VS_INPUT input) {"
        " VS_OUTPUT output;"
        " output.position = mul(input.position, WorldViewProj);"
        " output.texcoord = input.texcoord;"
        " return output;"
        "}";
    HRESULT hr = D3DXCompileShader(
        vsCode,
        strlen(vsCode),
        nullptr,
        nullptr,
        "main",
        "vs_3_0", // シェーダーモデル3.0
        0,
        &pCode,
        &pErrors,
        &pConstantTable);
    if (FAILED(hr))
    {
        if (pErrors)
        {
            MessageBoxA(nullptr, (char*)pErrors->GetBufferPointer(), "Vertex Shader Compile Error", MB_OK);
            pErrors->Release();
        }
        return hr;
    }
    hr = pDevice->CreateVertexShader((DWORD*)pCode->GetBufferPointer(), &pVertexShader);
    pCode->Release();
    if (FAILED(hr))
        return hr;
    return S_OK;
}

struct PS_INPUT
{
    float2 texcoord : TEXCOORD0;
};
uniform sampler2D tex;
float4 main(PS_INPUT input) : COLOR
{
    // テクスチャの色を取得して返す
    return tex2D(tex, input.texcoord);
}

IDirect3DPixelShader9* pPixelShader = nullptr;
ID3DXConstantTable* pPSConstantTable = nullptr;
HRESULT CompilePixelShader(IDirect3DDevice9* pDevice)
{
    ID3DXBuffer* pCode = nullptr;
    ID3DXBuffer* pErrors = nullptr;
    const char* psCode =
        "struct PS_INPUT { float2 texcoord : TEXCOORD0; };"
        "uniform sampler2D tex;"
        "float4 main(PS_INPUT input) : COLOR {"
        " return tex2D(tex, input.texcoord);"
        "}";
    HRESULT hr = D3DXCompileShader(
        psCode,
        strlen(psCode),
        nullptr,
        nullptr,
        "main",
        "ps_3_0",
        0,
        &pCode,
        &pErrors,
        &pPSConstantTable);
    if (FAILED(hr))
    {
        if (pErrors)
        {
            MessageBoxA(nullptr, (char*)pErrors->GetBufferPointer(), "Pixel Shader Compile Error", MB_OK);
            pErrors->Release();
        }
        return hr;
    }
    hr = pDevice->CreatePixelShader((DWORD*)pCode->GetBufferPointer(), &pPixelShader);
    pCode->Release();
    if (FAILED(hr))
        return hr;
    return S_OK;
}

D3DXMATRIX worldViewProj;
// 行列の計算(例として単位行列)
D3DXMatrixIdentity(&worldViewProj);
// 定数テーブルから変数を取得してセット
pConstantTable->SetMatrix(pDevice, "WorldViewProj", &worldViewProj);

pDevice->SetTexture(0, pTexture);

#include <d3dx9.h>
#pragma comment(lib, "d3dx9.lib")
ID3DXSprite* pSprite = nullptr;
HRESULT hr = D3DXCreateSprite(pDevice, &pSprite);
if (FAILED(hr))
{
    MessageBox(nullptr, L"スプライトオブジェクトの作成に失敗しました。", L"エラー", MB_OK | MB_ICONERROR);
    return;
}

pSprite->Begin(D3DXSPRITE_ALPHABLEND); // アルファブレンド有効で開始
// 描画したいテクスチャをセットし、位置を指定して描画
pSprite->Draw(
    pTexture,           // 描画するテクスチャ
    nullptr,            // 描画するテクスチャの矩形(nullptrで全体)
    nullptr,            // スケーリング・回転の中心(nullptrで左上)
    &D3DXVECTOR3(x, y, 0.0f), // 描画位置
    D3DCOLOR_ARGB(255, 255, 255, 255) // 色(白で不透明)
);
pSprite->End();

D3DXMATRIX mat;
D3DXVECTOR2 center(32.0f, 32.0f); // テクスチャ中心(例: 64x64テクスチャの半分)
D3DXVECTOR2 position(x, y);
float rotation = D3DXToRadian(45.0f); // 45度回転
float scale = 1.5f;
D3DXMatrixTransformation2D(
    &mat,
    nullptr,
    0.0f,
    &D3DXVECTOR2(scale, scale),
    ¢er,
    rotation,
    &position);
pSprite->SetTransform(&mat);
pSprite->Begin(D3DXSPRITE_ALPHABLEND);
pSprite->Draw(pTexture, nullptr, nullptr, nullptr, D3DCOLOR_ARGB(255, 255, 255, 255));
pSprite->End();

ID3DXFont* pFont = nullptr;
HRESULT hr = D3DXCreateFont(
    pDevice,
    24,             // フォントサイズ
    0,              // フォント幅(0で自動)
    FW_NORMAL,      // フォントの太さ
    1,              // ミップマップレベル
    FALSE,          // イタリック体かどうか
    DEFAULT_CHARSET,
    OUT_DEFAULT_PRECIS,
    DEFAULT_QUALITY,
    DEFAULT_PITCH | FF_DONTCARE,
    L"Arial",       // フォント名
    &pFont);
if (FAILED(hr))
{
    MessageBox(nullptr, L"フォントの作成に失敗しました。", L"エラー", MB_OK | MB_ICONERROR);
    return;
}

pSprite->Begin(D3DXSPRITE_ALPHABLEND);
// スプライト描画
pSprite->Draw(pTexture, nullptr, nullptr, &D3DXVECTOR3(100, 100, 0), D3DCOLOR_ARGB(255, 255, 255, 255));
// テキスト描画
RECT rect = { 200, 200, 0, 0 };
pFont->DrawText(nullptr, L"Hello, DirectX9!", -1, &rect, DT_NOCLIP, D3DCOLOR_ARGB(255, 255, 255, 0));
pSprite->End();

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch (msg)
    {
    case WM_KEYDOWN:
        if (wParam == VK_LEFT)
        {
            // 左矢印キーが押された
            OutputDebugString(L"Left arrow key pressed\n");
        }
        else if (wParam == VK_ESCAPE)
        {
            // ESCキーが押されたらアプリ終了
            PostQuitMessage(0);
        }
        return 0;
    case WM_KEYUP:
        // キーが離されたときの処理
        return 0;
    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    default:
        return DefWindowProc(hwnd, msg, wParam, lParam);
    }
}

if (GetAsyncKeyState(VK_SPACE) & 0x8000)
{
    // スペースキーが押されている間の処理
}

case WM_MOUSEMOVE:
{
    int x = LOWORD(lParam); // マウスのX座標
    int y = HIWORD(lParam); // マウスのY座標
    wchar_t buf[100];
    swprintf_s(buf, L"Mouse moved: X=%d, Y=%d\n", x, y);
    OutputDebugString(buf);
}
return 0;

POINT pt;
GetCursorPos(&pt);
ScreenToClient(hwnd, &pt);
// pt.x, pt.y がウィンドウ内のマウス座標

#include <Xinput.h>
#pragma comment(lib, "Xinput.lib")
XINPUT_STATE state;
ZeroMemory(&state, sizeof(XINPUT_STATE));
DWORD dwResult = XInputGetState(0, &state); // 0はコントローラー番号
if (dwResult == ERROR_SUCCESS)
{
    // コントローラーが接続されている
    WORD buttons = state.Gamepad.wButtons;
    if (buttons & XINPUT_GAMEPAD_A)
    {
        OutputDebugString(L"Aボタンが押されています\n");
    }
    SHORT leftTrigger = state.Gamepad.bLeftTrigger;
    SHORT rightTrigger = state.Gamepad.bRightTrigger;
    SHORT leftThumbX = state.Gamepad.sThumbLX;
    SHORT leftThumbY = state.Gamepad.sThumbLY;
    // スティックの値は-32768～32767の範囲
}
else
{
    // コントローラーが接続されていない
}

while (true)
{
    // メッセージ処理(省略)
    DWORD result = XInputGetState(0, &state);
    if (result == ERROR_SUCCESS)
    {
        // 入力処理
    }
    // 描画処理など
}

XINPUT_VIBRATION vibration = {};
vibration.wLeftMotorSpeed = 65535;  // 左モーター最大
vibration.wRightMotorSpeed = 0;     // 右モーター停止
XInputSetState(0, &vibration);

#include <windows.h>
#include <dsound.h>
#pragma comment(lib, "dsound.lib")
#pragma comment(lib, "dxguid.lib")
IDirectSound8* pDirectSound = nullptr;
bool InitializeDirectSound(HWND hwnd)
{
    // DirectSoundオブジェクトの作成
    HRESULT hr = DirectSoundCreate8(nullptr, &pDirectSound, nullptr);
    if (FAILED(hr))
    {
        MessageBox(hwnd, L"DirectSoundの作成に失敗しました。", L"エラー", MB_OK | MB_ICONERROR);
        return false;
    }
    // 協調レベルの設定(優先度レベル)
    hr = pDirectSound->SetCooperativeLevel(hwnd, DSSCL_PRIORITY);
    if (FAILED(hr))
    {
        MessageBox(hwnd, L"DirectSoundの協調レベル設定に失敗しました。", L"エラー", MB_OK | MB_ICONERROR);
        pDirectSound->Release();
        pDirectSound = nullptr;
        return false;
    }
    return true;
}

IDirectSoundBuffer* pPrimaryBuffer = nullptr;
IDirectSoundBuffer8* pSecondaryBuffer = nullptr;
bool CreateSoundBuffer(WAVEFORMATEX* pwfx, BYTE* pData, DWORD dataSize)
{
    // プライマリバッファの作成(音質設定用)
    DSBUFFERDESC dsbd = {};
    dsbd.dwSize = sizeof(DSBUFFERDESC);
    dsbd.dwFlags = DSBCAPS_PRIMARYBUFFER;
    dsbd.dwBufferBytes = 0;
    dsbd.lpwfxFormat = nullptr;
    HRESULT hr = pDirectSound->CreateSoundBuffer(&dsbd, &pPrimaryBuffer, nullptr);
    if (FAILED(hr))
    {
        MessageBox(nullptr, L"プライマリバッファの作成に失敗しました。", L"エラー", MB_OK | MB_ICONERROR);
        return false;
    }
    // プライマリバッファのフォーマット設定
    hr = pPrimaryBuffer->SetFormat(pwfx);
    if (FAILED(hr))
    {
        MessageBox(nullptr, L"プライマリバッファのフォーマット設定に失敗しました。", L"エラー", MB_OK | MB_ICONERROR);
        return false;
    }
    // セカンダリバッファの作成(実際の音声データ用)
    DSBUFFERDESC dsbd2 = {};
    dsbd2.dwSize = sizeof(DSBUFFERDESC);
    dsbd2.dwFlags = DSBCAPS_CTRLVOLUME | DSBCAPS_GLOBALFOCUS;
    dsbd2.dwBufferBytes = dataSize;
    dsbd2.lpwfxFormat = pwfx;
    IDirectSoundBuffer* pTempBuffer = nullptr;
    hr = pDirectSound->CreateSoundBuffer(&dsbd2, &pTempBuffer, nullptr);
    if (FAILED(hr))
    {
        MessageBox(nullptr, L"セカンダリバッファの作成に失敗しました。", L"エラー", MB_OK | MB_ICONERROR);
        return false;
    }
    // IDirectSoundBuffer8に変換
    hr = pTempBuffer->QueryInterface(IID_IDirectSoundBuffer8, (void**)&pSecondaryBuffer);
    pTempBuffer->Release();
    if (FAILED(hr))
    {
        MessageBox(nullptr, L"セカンダリバッファのインターフェース取得に失敗しました。", L"エラー", MB_OK | MB_ICONERROR);
        return false;
    }
    // バッファに音声データを書き込む
    void* pBuffer = nullptr;
    DWORD bufferSize = 0;
    hr = pSecondaryBuffer->Lock(0, dataSize, &pBuffer, &bufferSize, nullptr, nullptr, 0);
    if (FAILED(hr))
    {
        MessageBox(nullptr, L"バッファのロックに失敗しました。", L"エラー", MB_OK | MB_ICONERROR);
        return false;
    }
    memcpy(pBuffer, pData, dataSize);
    pSecondaryBuffer->Unlock(pBuffer, bufferSize, nullptr, 0);
    return true;
}

// 通常再生
pSecondaryBuffer->Play(0, 0, 0);
// ループ再生
pSecondaryBuffer->Play(0, 0, DSBPLAY_LOOPING);

IDirect3DTexture9* pTexture = nullptr;
HRESULT hr = pDevice->CreateTexture(256, 256, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &pTexture, nullptr);
if (SUCCEEDED(hr))
{
    // テクスチャを使用する処理
    // 使用後は必ずReleaseを呼ぶ
    pTexture->Release();
    pTexture = nullptr;
}

#include <vector>
#include <d3d9.h>
std::vector<IUnknown*> g_DeferredReleaseList;
// 解放予約関数
void AddToDeferredRelease(IUnknown* pObj)
{
    if (pObj)
    {
        g_DeferredReleaseList.push_back(pObj);
    }
}
// 遅延解放実行関数
void ExecuteDeferredRelease()
{
    for (IUnknown* pObj : g_DeferredReleaseList)
    {
        pObj->Release();
    }
    g_DeferredReleaseList.clear();
}

// デバイスロスト時の処理例
void OnDeviceLost()
{
    // 解放が必要なリソースを遅延解放リストに追加
    AddToDeferredRelease(pTexture);
    pTexture = nullptr;
    AddToDeferredRelease(pVertexBuffer);
    pVertexBuffer = nullptr;
    // 他のリソースも同様に追加
}
// デバイスリセット前に遅延解放を実行
void OnDeviceReset()
{
    ExecuteDeferredRelease();
    // リソースの再作成処理
}

HRESULT hr = pD3D->CreateDevice(
    D3DADAPTER_DEFAULT,
    D3DDEVTYPE_HAL,
    hwnd,
    D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_DEBUG,
    &d3dpp,
    &pDevice);

#include <chrono>
auto start = std::chrono::high_resolution_clock::now();
// 描画処理
auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();
wchar_t buf[100];
swprintf_s(buf, L"Frame render time: %lld microseconds\n", duration);
OutputDebugString(buf);

HRESULT hr = pD3D->CreateDevice(
    D3DADAPTER_DEFAULT,
    D3DDEVTYPE_HAL,
    hwnd,
    D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_MULTITHREADED,
    &d3dpp,
    &pDevice);

#include <windows.h>
CRITICAL_SECTION csDeviceAccess;
void Initialize()
{
    InitializeCriticalSection(&csDeviceAccess);
}
void Cleanup()
{
    DeleteCriticalSection(&csDeviceAccess);
}
void ThreadSafeDraw(IDirect3DDevice9* pDevice)
{
    EnterCriticalSection(&csDeviceAccess);
    // デバイスへの描画コマンド
    pDevice->BeginScene();
    // 描画処理
    pDevice->EndScene();
    LeaveCriticalSection(&csDeviceAccess);
}

class IScene
{
public:
    virtual ~IScene() {}
    virtual void Initialize() = 0;
    virtual void Update(float deltaTime) = 0;
    virtual void Render() = 0;
    virtual void Shutdown() = 0;
};
class SceneManager
{
private:
    IScene* currentScene = nullptr;
public:
    void ChangeScene(IScene* newScene)
    {
        if (currentScene)
        {
            currentScene->Shutdown();
            delete currentScene;
        }
        currentScene = newScene;
        if (currentScene)
        {
            currentScene->Initialize();
        }
    }
    void Update(float deltaTime)
    {
        if (currentScene)
            currentScene->Update(deltaTime);
    }
    void Render()
    {
        if (currentScene)
            currentScene->Render();
    }
    ~SceneManager()
    {
        if (currentScene)
        {
            currentScene->Shutdown();
            delete currentScene;
        }
    }
};

class TitleScene : public IScene
{
public:
    void Initialize() override { /* 初期化処理 */ }
    void Update(float deltaTime) override { /* 入力処理など */ }
    void Render() override { /* 描画処理 */ }
    void Shutdown() override { /* 解放処理 */ }
};
int main()
{
    SceneManager sceneManager;
    sceneManager.ChangeScene(new TitleScene());
    while (true)
    {
        float deltaTime = 0.016f; // 仮のフレーム時間
        sceneManager.Update(deltaTime);
        sceneManager.Render();
    }
}

class Component
{
public:
    virtual ~Component() {}
    virtual void Update(float deltaTime) {}
    virtual void Render() {}
};
class TransformComponent : public Component
{
public:
    float x, y, z;
    TransformComponent() : x(0), y(0), z(0) {}
};
class RenderComponent : public Component
{
public:
    void Render() override
    {
        // 描画処理
    }
};
class GameObject
{
private:
    std::vector<Component*> components;
public:
    ~GameObject()
    {
        for (auto comp : components)
            delete comp;
    }
    template<typename T>
    T* GetComponent()
    {
        for (auto comp : components)
        {
            T* casted = dynamic_cast<T*>(comp);
            if (casted)
                return casted;
        }
        return nullptr;
    }
    void AddComponent(Component* comp)
    {
        components.push_back(comp);
    }
    void Update(float deltaTime)
    {
        for (auto comp : components)
            comp->Update(deltaTime);
    }
    void Render()
    {
        for (auto comp : components)
            comp->Render();
    }
};

GameObject* player = new GameObject();
player->AddComponent(new TransformComponent());
player->AddComponent(new RenderComponent());
while (true)
{
    float deltaTime = 0.016f;
    player->Update(deltaTime);
    player->Render();
}

#include <d3d9.h>
#include <d3dx9.h>
// カスタム頂点構造体(位置と色)
struct CUSTOMVERTEX
{
    FLOAT x, y, z;    // 頂点の3D座標
    DWORD color;      // 頂点カラー(ARGB)
};
// Flexible Vertex Formatの定義
#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ | D3DFVF_DIFFUSE)

// 三角形の頂点データ
CUSTOMVERTEX vertices[] =
{
    { 0.0f,  1.0f, 0.0f, 0xFFFF0000 }, // 頂点1：赤色、上
    { 1.0f, -1.0f, 0.0f, 0xFF00FF00 }, // 頂点2：緑色、右下
    {-1.0f, -1.0f, 0.0f, 0xFF0000FF }  // 頂点3：青色、左下
};

IDirect3DVertexBuffer9* pVertexBuffer = nullptr;
// 頂点バッファの作成
HRESULT hr = pDevice->CreateVertexBuffer(
    sizeof(vertices),
    0,
    D3DFVF_CUSTOMVERTEX,
    D3DPOOL_MANAGED,
    &pVertexBuffer,
    nullptr);
if (FAILED(hr))
{
    MessageBox(nullptr, L"頂点バッファの作成に失敗しました。", L"エラー", MB_OK | MB_ICONERROR);
    return;
}
// バッファのロック
void* pVertices = nullptr;
hr = pVertexBuffer->Lock(0, sizeof(vertices), (void**)&pVertices, 0);
if (FAILED(hr))
{
    MessageBox(nullptr, L"頂点バッファのロックに失敗しました。", L"エラー", MB_OK | MB_ICONERROR);
    return;
}
// 頂点データのコピー
memcpy(pVertices, vertices, sizeof(vertices));
// バッファのアンロック
pVertexBuffer->Unlock();

D3DXMATRIX matWorld;
float angle = 0.0f; // 回転角度(ラジアン)
// 毎フレーム更新する例
void UpdateRotation(float deltaTime)
{
    angle += deltaTime; // 角度を増加(例：1秒で1ラジアン回転)
    if (angle > D3DX_PI * 2)
        angle -= D3DX_PI * 2;
    // Z軸回転行列の生成
    D3DXMatrixRotationZ(&matWorld, angle);
    // ワールド行列をデバイスにセット
    pDevice->SetTransform(D3DTS_WORLD, &matWorld);
}

struct CUSTOMVERTEX
{
    FLOAT x, y, z;   // 頂点の3D座標
    FLOAT u, v;      // テクスチャ座標
};
#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ | D3DFVF_TEX1)

CUSTOMVERTEX vertices[] =
{
    { -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 }  // 右下
};

WORD indices[] = {
    0, 1, 2, // 三角形1(左上、右上、左下)
    2, 1, 3  // 三角形2(左下、右上、右下)
};

// 頂点バッファ作成例(省略)
// インデックスバッファ作成例(省略)
pDevice->SetFVF(D3DFVF_CUSTOMVERTEX);
pDevice->SetStreamSource(0, pVertexBuffer, 0, sizeof(CUSTOMVERTEX));
pDevice->SetIndices(pIndexBuffer);
pDevice->DrawIndexedPrimitive(
    D3DPT_TRIANGLELIST,
    0,
    0,
    4,
    0,
    2);

// アルファブレンドを有効にする
pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
// ソースブレンドファクター(描画するピクセルのアルファ値を使用)
pDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
// デスティネーションブレンドファクター(既存のピクセルの逆アルファ値を使用)
pDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);

pDevice->SetRenderState(D3DRS_ZWRITEENABLE, FALSE);

pDevice->SetRenderState(D3DRS_ZWRITEENABLE, TRUE);
pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);

#include <d3dx9.h>
D3DXVECTOR3 eyePos(0.0f, 0.0f, -5.0f);    // カメラの位置
D3DXVECTOR3 lookAt(0.0f, 0.0f, 0.0f);     // 注視点(カメラが見る方向)
D3DXVECTOR3 upDir(0.0f, 1.0f, 0.0f);      // 上方向ベクトル
D3DXMATRIX matView;
D3DXMatrixLookAtLH(&matView, &eyePos, &lookAt, &upDir);
// ビュー行列をデバイスにセット
pDevice->SetTransform(D3DTS_VIEW, &matView);

void UpdateCamera(float deltaTime)
{
    float speed = 5.0f; // 移動速度
    // キーボード入力例(GetAsyncKeyStateを使用)
    if (GetAsyncKeyState('W') & 0x8000)
        eyePos.z += speed * deltaTime; // 前進
    if (GetAsyncKeyState('S') & 0x8000)
        eyePos.z -= speed * deltaTime; // 後退
    if (GetAsyncKeyState('A') & 0x8000)
        eyePos.x -= speed * deltaTime; // 左移動
    if (GetAsyncKeyState('D') & 0x8000)
        eyePos.x += speed * deltaTime; // 右移動
    // 注視点をカメラの前方に設定(単純な例)
    lookAt = D3DXVECTOR3(eyePos.x, eyePos.y, eyePos.z + 1.0f);
    // ビュー行列の再計算
    D3DXMatrixLookAtLH(&matView, &eyePos, &lookAt, &upDir);
    pDevice->SetTransform(D3DTS_VIEW, &matView);
}

float fovY = D3DXToRadian(45.0f); // 垂直方向の視野角(45度)
float aspectRatio = (float)windowWidth / (float)windowHeight; // アスペクト比
float nearZ = 0.1f;  // 近クリップ面
float farZ = 1000.0f; // 遠クリップ面
D3DXMATRIX matProj;
D3DXMatrixPerspectiveFovLH(&matProj, fovY, aspectRatio, nearZ, farZ);
// 射影行列をデバイスにセット
pDevice->SetTransform(D3DTS_PROJECTION, &matProj);

void OnResize(int newWidth, int newHeight)
{
    float newAspect = (float)newWidth / (float)newHeight;
    D3DXMatrixPerspectiveFovLH(&matProj, fovY, newAspect, nearZ, farZ);
    pDevice->SetTransform(D3DTS_PROJECTION, &matProj);
}

pSprite->Begin(D3DXSPRITE_ALPHABLEND);
// 例：画面左上にテクスチャを描画
D3DXVECTOR3 position(10.0f, 10.0f, 0.0f);
pSprite->Draw(pTexture, nullptr, nullptr, &position, D3DCOLOR_ARGB(255, 255, 255, 255));
pSprite->End();

RECT rect = { 50, 50, 0, 0 };
pFont->DrawText(nullptr, L"Score: 100", -1, &rect, DT_NOCLIP, D3DCOLOR_ARGB(255, 255, 255, 0));

pDevice->SetRenderState(D3DRS_ZENABLE, FALSE);
// 描画処理
pDevice->SetRenderState(D3DRS_ZENABLE, TRUE);

ImGui::CreateContext();
ImGui_ImplWin32_Init(hwnd);
ImGui_ImplDX9_Init(pDevice);

ImGui_ImplDX9_NewFrame();
ImGui_ImplWin32_NewFrame();
ImGui::NewFrame();
// UI構築例
ImGui::Begin("Debug Window");
ImGui::Text("FPS: %.1f", ImGui::GetIO().Framerate);
ImGui::End();
ImGui::EndFrame();
ImGui::Render();
ImGui_ImplDX9_RenderDrawData(ImGui::GetDrawData());

ImGui_ImplDX9_Shutdown();
ImGui_ImplWin32_Shutdown();
ImGui::DestroyContext();

HRESULT hr = pDevice->TestCooperativeLevel();
if (hr == D3DERR_DEVICELOST)
{
    // 描画不可。待機するなどの処理
    return;
}
else if (hr == D3DERR_DEVICENOTRESET)
{
    // リセット処理
    CleanupDefaultPoolResources(); // リソース解放
    hr = pDevice->Reset(&d3dpp);
    if (SUCCEEDED(hr))
    {
        RecreateDefaultPoolResources(); // リソース再作成
    }
}
else if (hr == D3D_OK)
{
    // 通常描画処理
}

ID3DXBuffer* pErrorBuffer = nullptr;
HRESULT hr = D3DXCompileShader(
    shaderCode,
    strlen(shaderCode),
    nullptr,
    nullptr,
    "main",
    "ps_3_0",
    0,
    &pCode,
    &pErrorBuffer,
    nullptr);
if (FAILED(hr))
{
    if (pErrorBuffer)
    {
        OutputDebugStringA((char*)pErrorBuffer->GetBufferPointer());
        pErrorBuffer->Release();
    }
    // エラー処理
}