C++とDirectX 12で始めるゲームプログラミング

#include <iostream>
#include <d3d12.h>
#include <dxgi1_4.h>
#include <d3dcompiler.h>

#pragma comment(lib, "d3d12.lib")
#pragma comment(lib, "dxgi.lib")
#pragma comment(lib, "d3dcompiler.lib")

int main() {
    std::cout << "DirectX 12 is ready!" << std::endl;
    return 0;
}

#ifdef _DEBUG
#include <dxgidebug.h>
#endif

#ifdef _DEBUG
    IDXGIDebug1* debugInterface = nullptr;
    if (SUCCEEDED(DXGIGetDebugInterface1(0, IID_PPV_ARGS(&debugInterface))))
    {
        debugInterface->ReportLiveObjects(DXGI_DEBUG_ALL, DXGI_DEBUG_RLO_ALL);
        debugInterface->Release();
    }
#endif

ComPtr<ID3D12CommandQueue> commandQueue;

D3D12_COMMAND_QUEUE_DESC queueDesc = {};
queueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
queueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT; // 通常の描画コマンド用

HRESULT hr = device->CreateCommandQueue(&queueDesc, IID_PPV_ARGS(&commandQueue));
if (FAILED(hr))
{
    // エラー処理
}

ComPtr<ID3D12GraphicsCommandList> commandList;
ComPtr<ID3D12CommandAllocator> commandAllocator;

// コマンドアロケータの作成
HRESULT hr = device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&commandAllocator));
if (FAILED(hr))
{
    // エラー処理
}

// コマンドリストの作成
hr = device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, commandAllocator.Get(), nullptr, IID_PPV_ARGS(&commandList));
if (FAILED(hr))
{
    // エラー処理
}

// コマンドリストの初期状態はクローズされている必要がある
commandList->Close();

ComPtr<ID3D12Resource> vertexBuffer;

// ヒーププロパティの設定
D3D12_HEAP_PROPERTIES heapProperties = {};
heapProperties.Type = D3D12_HEAP_TYPE_DEFAULT; // GPUのみがアクセス
heapProperties.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
heapProperties.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
heapProperties.CreationNodeMask = 0;
heapProperties.VisibleNodeMask = 0;

// リソースの説明の設定
D3D12_RESOURCE_DESC bufferDesc = {};
bufferDesc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
bufferDesc.Alignment = 0;
bufferDesc.Width = vertexBufferSize; // バッファサイズ
bufferDesc.Height = 1;
bufferDesc.DepthOrArraySize = 1;
bufferDesc.MipLevels = 1;
bufferDesc.Format = DXGI_FORMAT_UNKNOWN;
bufferDesc.SampleDesc.Count = 1;
bufferDesc.SampleDesc.Quality = 0;
bufferDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
bufferDesc.Flags = D3D12_RESOURCE_FLAG_NONE;

// リソースの作成
HRESULT hr = device->CreateCommittedResource(
    &heapProperties,
    D3D12_HEAP_FLAG_NONE,
    &bufferDesc,
    D3D12_RESOURCE_STATE_COPY_DEST, // 初期状態はコピー先
    nullptr,
    IID_PPV_ARGS(&vertexBuffer));

if (FAILED(hr))
{
    // エラー処理
}

D3D12_RESOURCE_BARRIER barrier = {};
barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
barrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
barrier.Transition.pResource = texture.Get(); // 状態を変更するリソース
barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_COPY_DEST; // 変更前の状態
barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE; // 変更後の状態

commandList->ResourceBarrier(1, &barrier);

ComPtr<ID3D12Resource> uploadBuffer;
// (Upload Bufferの作成は省略)

void* mappedData;
uploadBuffer->Map(0, nullptr, &mappedData);
memcpy(mappedData, vertexData, vertexBufferSize); // データのコピー
uploadBuffer->Unmap(0, nullptr);

#include <d3dcompiler.h>

// シェーダーをコンパイルする関数
HRESULT CompileShader(
    const std::wstring& filename,  // シェーダーファイルのパス
    const std::string& entryPoint, // エントリーポイント名
    const std::string& target,     // シェーダーターゲット (例: "vs_5_0", "ps_5_0")
    ComPtr<ID3DBlob>& shaderBlob) // コンパイルされたシェーダーのバイトコード
{
    UINT compileFlags = 0;
#ifdef _DEBUG
    compileFlags |= D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION;
#endif

    ComPtr<ID3DBlob> errorBlob;
    HRESULT hr = D3DCompileFromFile(
        filename.c_str(),
        nullptr,
        D3D_COMPILE_STANDARD_FILE_INCLUDE,
        entryPoint.c_str(),
        target.c_str(),
        compileFlags,
        0,
        &shaderBlob,
        &errorBlob);

    if (FAILED(hr))
    {
        if (errorBlob)
        {
            OutputDebugStringA(reinterpret_cast<char*>(errorBlob->GetBufferPointer()));
        }
        return hr;
    }

    return S_OK;
}

// シェーダーのコンパイル例
ComPtr<ID3DBlob> vertexShaderBlob;
HRESULT hr = CompileShader(L"VertexShader.hlsl", "VSMain", "vs_5_0", vertexShaderBlob);
if (FAILED(hr))
{
    // エラー処理
}

ComPtr<ID3DBlob> pixelShaderBlob;
hr = CompileShader(L"PixelShader.hlsl", "PSMain", "ps_5_0", pixelShaderBlob);
if (FAILED(hr))
{
    // エラー処理
}

// パイプラインステートオブジェクト (PSO) の作成
D3D12_GRAPHICS_PIPELINE_STATE_DESC psoDesc = {};
psoDesc.InputLayout = inputLayoutDesc; // 入力レイアウト
psoDesc.pRootSignature = rootSignature.Get(); // ルートシグネチャ
psoDesc.VS = CD3DX12_SHADER_BYTECODE(vertexShaderBlob.Get()); // 頂点シェーダー
psoDesc.PS = CD3DX12_SHADER_BYTECODE(pixelShaderBlob.Get()); // ピクセルシェーダー
psoDesc.RasterizerState = CD3DX12_RASTERIZER_DESC(D3D12_DEFAULT); // ラスタライザーステート
psoDesc.BlendState = CD3DX12_BLEND_DESC(D3D12_DEFAULT); // ブレンドステート
psoDesc.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC(D3D12_DEFAULT); // 深度ステンシルステート
psoDesc.SampleMask = UINT_MAX;
psoDesc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
psoDesc.NumRenderTargets = 1;
psoDesc.RTVFormats[0] = DXGI_FORMAT_R8G8B8A8_UNORM; // レンダーターゲット形式
psoDesc.SampleDesc.Count = 1;

ComPtr<ID3D12PipelineState> pipelineState;
HRESULT hr = device->CreateGraphicsPipelineState(&psoDesc, IID_PPV_ARGS(&pipelineState));
if (FAILED(hr))
{
    // エラー処理
}

// ルートシグネチャの定義
CD3DX12_ROOT_PARAMETER rootParameters[1];
CD3DX12_ROOT_CONSTANTS rootConstants(sizeof(ConstantBuffer) / 4, 0); // 定数バッファのサイズを DWORD (4バイト) 単位で指定
rootParameters[0].InitAsConstants(rootConstants, D3D12_SHADER_VISIBILITY_VERTEX); // 頂点シェーダーからアクセス

// ルートシグネチャの説明
CD3DX12_ROOT_SIGNATURE_DESC rootSigDesc(1, rootParameters, 0, nullptr, D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT);

// ルートシグネチャのシリアライズ
ComPtr<ID3DBlob> signature;
ComPtr<ID3DBlob> error;
hr = D3D12SerializeRootSignature(&rootSigDesc, D3D_ROOT_SIGNATURE_VERSION_1, &signature, &error);
if (FAILED(hr))
{
    // エラー処理
}

// ルートシグネチャの作成
ComPtr<ID3D12RootSignature> rootSignature;
hr = device->CreateRootSignature(0, signature->GetBufferPointer(), signature->GetBufferSize(), IID_PPV_ARGS(&rootSignature));
if (FAILED(hr))
{
    // エラー処理
}

// 入力レイアウトの定義
D3D12_INPUT_ELEMENT_DESC inputElementDescs[] =
{
    { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
    { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }
};

// 入力レイアウトの説明
D3D12_INPUT_LAYOUT_DESC inputLayoutDesc = {};
inputLayoutDesc.pInputElementDescs = inputElementDescs;
inputLayoutDesc.NumElements = _countof(inputElementDescs);

// ルートシグネチャの定義
CD3DX12_ROOT_PARAMETER rootParameters[2];
CD3DX12_DESCRIPTOR_RANGE descriptorRange;

// テクスチャのディスクリプタレンジ
descriptorRange.Init(D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 1, 0); // テクスチャを1つ

// ルートパラメータの初期化
rootParameters[0].InitAsConstantBufferView(0); // 定数バッファ
rootParameters[1].InitAsDescriptorTable(1, &descriptorRange); // テクスチャ

// ルートシグネチャの説明
CD3DX12_ROOT_SIGNATURE_DESC rootSigDesc(2, rootParameters, 0, nullptr, D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT);

// ルートシグネチャのシリアライズ
ComPtr<ID3DBlob> signature;
ComPtr<ID3DBlob> error;
HRESULT hr = D3D12SerializeRootSignature(&rootSigDesc, D3D_ROOT_SIGNATURE_VERSION_1, &signature, &error);
if (FAILED(hr))
{
    // エラー処理
}

// ルートシグネチャの作成
ComPtr<ID3D12RootSignature> rootSignature;
hr = device->CreateRootSignature(0, signature->GetBufferPointer(), signature->GetBufferSize(), IID_PPV_ARGS(&rootSignature));
if (FAILED(hr))
{
    // エラー処理
}

// パイプラインステートオブジェクト (PSO) の作成
D3D12_GRAPHICS_PIPELINE_STATE_DESC psoDesc = {};
psoDesc.InputLayout = inputLayoutDesc; // 入力レイアウト
psoDesc.pRootSignature = rootSignature.Get(); // ルートシグネチャ
psoDesc.VS = CD3DX12_SHADER_BYTECODE(vertexShaderBlob.Get()); // 頂点シェーダー
psoDesc.PS = CD3DX12_SHADER_BYTECODE(pixelShaderBlob.Get()); // ピクセルシェーダー
psoDesc.RasterizerState = CD3DX12_RASTERIZER_DESC(D3D12_DEFAULT); // ラスタライザーステート
psoDesc.BlendState = CD3DX12_BLEND_DESC(D3D12_DEFAULT); // ブレンドステート
psoDesc.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC(D3D12_DEFAULT); // 深度ステンシルステート
psoDesc.SampleMask = UINT_MAX;
psoDesc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
psoDesc.NumRenderTargets = 1;
psoDesc.RTVFormats[0] = DXGI_FORMAT_R8G8B8A8_UNORM; // レンダーターゲット形式
psoDesc.SampleDesc.Count = 1;

ComPtr<ID3D12PipelineState> pipelineState;
HRESULT hr = device->CreateGraphicsPipelineState(&psoDesc, IID_PPV_ARGS(&pipelineState));
if (FAILED(hr))
{
    // エラー処理
}

// コマンドリストへの描画コマンドの記録
commandList->SetGraphicsRootSignature(rootSignature.Get()); // ルートシグネチャの設定
commandList->SetPipelineState(pipelineState.Get()); // PSOの設定
commandList->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST); // プリミティブトポロジーの設定
commandList->IASetVertexBuffers(0, 1, &vertexBufferView); // 頂点バッファの設定
commandList->DrawInstanced(3, 1, 0, 0); // 描画命令

struct Vertex
{
    float Position[3]; // 頂点の位置
};

// 三角形の頂点データ
Vertex vertices[] =
{
    { { 0.0f, 0.5f, 0.0f } },    // 上
    { { 0.5f, -0.5f, 0.0f } },   // 右下
    { { -0.5f, -0.5f, 0.0f } }  // 左下
};

const UINT vertexBufferSize = sizeof(vertices); // 頂点バッファのサイズ

ComPtr<ID3D12Resource> vertexBuffer;
ComPtr<ID3D12Resource> vertexBufferUploadHeap;

// ヒーププロパティの設定 (Upload Heap)
D3D12_HEAP_PROPERTIES heapProperties = {};
heapProperties.Type = D3D12_HEAP_TYPE_UPLOAD;
heapProperties.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
heapProperties.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
heapProperties.CreationNodeMask = 0;
heapProperties.VisibleNodeMask = 0;

// リソースの説明の設定 (Buffer)
D3D12_RESOURCE_DESC bufferDesc = {};
bufferDesc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
bufferDesc.Alignment = 0;
bufferDesc.Width = vertexBufferSize;
bufferDesc.Height = 1;
bufferDesc.DepthOrArraySize = 1;
bufferDesc.MipLevels = 1;
bufferDesc.Format = DXGI_FORMAT_UNKNOWN;
bufferDesc.SampleDesc.Count = 1;
bufferDesc.SampleDesc.Quality = 0;
bufferDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
bufferDesc.Flags = D3D12_RESOURCE_FLAG_NONE;

// リソースの作成 (Upload Heap)
HRESULT hr = device->CreateCommittedResource(
    &heapProperties,
    D3D12_HEAP_FLAG_NONE,
    &bufferDesc,
    D3D12_RESOURCE_STATE_GENERIC_READ,
    nullptr,
    IID_PPV_ARGS(&vertexBufferUploadHeap));

if (FAILED(hr))
{
    // エラー処理
}

// 頂点バッファへのデータコピー
void* dataBegin;
CD3DX12_RANGE readRange(0, 0);  // CPUが読み込まないことを示す
hr = vertexBufferUploadHeap->Map(0, &readRange, &dataBegin);
if (FAILED(hr))
{
   // エラー処理
}
memcpy(dataBegin, vertices, vertexBufferSize);
vertexBufferUploadHeap->Unmap(0, nullptr);

// 頂点バッファビューの作成
D3D12_VERTEX_BUFFER_VIEW vertexBufferView = {};
vertexBufferView.BufferLocation = vertexBufferUploadHeap->GetGPUVirtualAddress(); // GPUアドレス
vertexBufferView.StrideInBytes = sizeof(Vertex); // 頂点サイズ
vertexBufferView.SizeInBytes = vertexBufferSize; // バッファサイズ

// 入力レイアウトの定義
D3D12_INPUT_ELEMENT_DESC inputElementDescs[] =
{
    { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }
};

// 入力レイアウトの説明
D3D12_INPUT_LAYOUT_DESC inputLayoutDesc = {};
inputLayoutDesc.pInputElementDescs = inputElementDescs;
inputLayoutDesc.NumElements = _countof(inputElementDescs);

ComPtr<ID3D12RootSignature> rootSignature;

// ルートシグネチャの説明
D3D12_ROOT_SIGNATURE_DESC rootSigDesc;
rootSigDesc.NumParameters = 0;
rootSigDesc.pParameters = nullptr;
rootSigDesc.NumStaticSamplers = 0;
rootSigDesc.pStaticSamplers = nullptr;
rootSigDesc.Flags = D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT;

// シリアライズしてルートシグネチャを作成
ComPtr<ID3DBlob> signature;
ComPtr<ID3DBlob> error;
HRESULT hr = D3D12SerializeRootSignature(&rootSigDesc, D3D_ROOT_SIGNATURE_VERSION_1, &signature, &error);

if(error)
{
    OutputDebugStringA((char*)error->GetBufferPointer());
}

if (FAILED(hr))
{
    // エラー処理
}

hr = device->CreateRootSignature(0, signature->GetBufferPointer(), signature->GetBufferSize(), IID_PPV_ARGS(&rootSignature));
if (FAILED(hr))
{
    // エラー処理
}

#include <d3dcompiler.h>

// シェーダーのコンパイル（前のセクションで定義）
ComPtr<ID3DBlob> vertexShaderBlob;
HRESULT hr = CompileShader(L"VertexShader.hlsl", "VSMain", "vs_5_0", vertexShaderBlob);
if (FAILED(hr))
{
    // エラー処理
}

ComPtr<ID3DBlob> pixelShaderBlob;
hr = CompileShader(L"PixelShader.hlsl", "PSMain", "ps_5_0", pixelShaderBlob);
if (FAILED(hr))
{
    // エラー処理
}

// パイプラインステートオブジェクト (PSO) の作成
D3D12_GRAPHICS_PIPELINE_STATE_DESC psoDesc = {};
psoDesc.InputLayout = inputLayoutDesc; // 入力レイアウト
psoDesc.pRootSignature = rootSignature.Get(); // ルートシグネチャ
psoDesc.VS = CD3DX12_SHADER_BYTECODE(vertexShaderBlob.Get()); // 頂点シェーダー
psoDesc.PS = CD3DX12_SHADER_BYTECODE(pixelShaderBlob.Get()); // ピクセルシェーダー
psoDesc.RasterizerState = CD3DX12_RASTERIZER_DESC(D3D12_DEFAULT); // ラスタライザーステート
psoDesc.BlendState = CD3DX12_BLEND_DESC(D3D12_DEFAULT); // ブレンドステート
psoDesc.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC(D3D12_DEFAULT); // 深度ステンシルステート
psoDesc.SampleMask = UINT_MAX;
psoDesc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLELIST;
psoDesc.NumRenderTargets = 1;
psoDesc.RTVFormats[0] = DXGI_FORMAT_R8G8B8A8_UNORM; // レンダーターゲット形式
psoDesc.SampleDesc.Count = 1;

ComPtr<ID3D12PipelineState> pipelineState;
hr = device->CreateGraphicsPipelineState(&psoDesc, IID_PPV_ARGS(&pipelineState));
if (FAILED(hr))
{
    // エラー処理
}

// コマンドリストへの描画コマンドの記録
commandList->SetGraphicsRootSignature(rootSignature.Get()); // ルートシグネチャの設定
commandList->SetPipelineState(pipelineState.Get()); // PSOの設定
commandList->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST); // プリミティブトポロジーの設定
commandList->IASetVertexBuffers(0, 1, &vertexBufferView); // 頂点バッファの設定
commandList->DrawInstanced(3, 1, 0, 0); // 描画命令 (3頂点、1インスタンス)

commandList->Close();
ID3D12CommandList* ppCommandLists[] = { commandList.Get() };
commandQueue->ExecuteCommandLists(_countof(ppCommandLists), ppCommandLists);

#include <DirectXTex.h>

ComPtr<ID3D12Resource> texture; // テクスチャリソース
ComPtr<ID3D12Resource> textureUploadHeap; // アップロードヒープ

// テクスチャ画像のファイルパス
std::wstring texturePath = L"texture.png"; // 例：texture.png

// DirectXTexを使用して画像をロード
ScratchImage image;
HRESULT hr = LoadFromWICFile(texturePath.c_str(), WIC_FLAGS_NONE, nullptr, image);
if (FAILED(hr))
{
    // エラー処理
}

// テクスチャリソースの説明を作成
D3D12_RESOURCE_DESC textureDesc = {};
textureDesc.MipLevels = image.GetMetadata().mipLevels;
textureDesc.Format = image.GetMetadata().format;
textureDesc.Width = image.GetMetadata().width;
textureDesc.Height = (UINT)image.GetMetadata().height;
textureDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
textureDesc.DepthOrArraySize = 1;
textureDesc.SampleDesc.Count = 1;
textureDesc.SampleDesc.Quality = 0;
textureDesc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;

// テクスチャリソースの作成 (Default Heap)
D3D12_HEAP_PROPERTIES heapProperties = {};
heapProperties.Type = D3D12_HEAP_TYPE_DEFAULT;
heapProperties.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
heapProperties.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
heapProperties.CreationNodeMask = 0;
heapProperties.VisibleNodeMask = 0;

hr = device->CreateCommittedResource(
    &heapProperties,
    D3D12_HEAP_FLAG_NONE,
    &textureDesc,
    D3D12_RESOURCE_STATE_COPY_DEST,
    nullptr,
    IID_PPV_ARGS(&texture));
if (FAILED(hr))
{
    // エラー処理
}

// アップロードヒープの作成
UINT64 uploadBufferSize;
device->GetCopyableFootprints(&textureDesc, 0, 1, 0, nullptr, nullptr, nullptr, &uploadBufferSize);

D3D12_RESOURCE_DESC uploadBufferDesc = {};
uploadBufferDesc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
uploadBufferDesc.Alignment = 0;
uploadBufferDesc.Width = uploadBufferSize;
uploadBufferDesc.Height = 1;
uploadBufferDesc.DepthOrArraySize = 1;
uploadBufferDesc.MipLevels = 1;
uploadBufferDesc.Format = DXGI_FORMAT_UNKNOWN;
uploadBufferDesc.SampleDesc.Count = 1;
uploadBufferDesc.SampleDesc.Quality = 0;
uploadBufferDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
uploadBufferDesc.Flags = D3D12_RESOURCE_FLAG_NONE;

heapProperties.Type = D3D12_HEAP_TYPE_UPLOAD;
hr = device->CreateCommittedResource(
    &heapProperties,
    D3D12_HEAP_FLAG_NONE,
    &uploadBufferDesc,
    D3D12_RESOURCE_STATE_GENERIC_READ,
    nullptr,
    IID_PPV_ARGS(&textureUploadHeap));
if (FAILED(hr))
{
    // エラー処理
}

// テクスチャデータをアップロードヒープにコピー
D3D12_SUBRESOURCE_DATA textureData = {};
textureData.pData = image.GetPixels();
textureData.RowPitch = image.GetImages()->rowPitch;
textureData.SlicePitch = image.GetImages()->slicePitch;

UpdateSubresource(commandList.Get(), texture.Get(), textureUploadHeap.Get(), 0, 0, 1, &textureData);

// リソースバリアを設定して、テクスチャをシェーダーリソースとして使用できるようにする
D3D12_RESOURCE_BARRIER barrier = {};
barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
barrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
barrier.Transition.pResource = texture.Get();
barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_COPY_DEST;
barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;

commandList->ResourceBarrier(1, &barrier);

ComPtr<ID3D12DescriptorHeap> samplerHeap;

// サンプラーヒープの説明
D3D12_DESCRIPTOR_HEAP_DESC samplerHeapDesc = {};
samplerHeapDesc.NumDescriptors = 1;
samplerHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER;
samplerHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE; // シェーダーから参照可能
samplerHeapDesc.NodeMask = 0;

HRESULT hr = device->CreateDescriptorHeap(&samplerHeapDesc, IID_PPV_ARGS(&samplerHeap));
if (FAILED(hr))
{
    // エラー処理
}

// サンプラーの作成
D3D12_SAMPLER_DESC samplerDesc = {};
samplerDesc.Filter = D3D12_FILTER_MIN_MAG_MIP_LINEAR; // 線形フィルタリング
samplerDesc.AddressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP; // U方向のアドレスモード
samplerDesc.AddressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP; // V方向のアドレスモード
samplerDesc.AddressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP; // W方向のアドレスモード
samplerDesc.MipLODBias = 0;
samplerDesc.MaxAnisotropy = 1;
samplerDesc.ComparisonFunc = D3D12_COMPARISON_FUNC_ALWAYS;
samplerDesc.BorderColor[0] = 0;
samplerDesc.BorderColor[1] = 0;
samplerDesc.BorderColor[2] = 0;
samplerDesc.BorderColor[3] = 0;
samplerDesc.MinLOD = 0;
samplerDesc.MaxLOD = D3D12_FLOAT32_MAX;

// サンプラーのディスクリプタを作成
device->CreateSampler(&samplerDesc, samplerHeap->GetCPUDescriptorHandleForHeapStart());

// ルートシグネチャの定義
CD3DX12_ROOT_PARAMETER rootParameters[2];
CD3DX12_DESCRIPTOR_RANGE textureDescriptorRange;
CD3DX12_DESCRIPTOR_RANGE samplerDescriptorRange;

// テクスチャのディスクリプタレンジ
textureDescriptorRange.Init(D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 1, 0); // テクスチャを1つ

// サンプラーのディスクリプタレンジ
samplerDescriptorRange.Init(D3D12_DESCRIPTOR_RANGE_TYPE_SAMPLER, 1, 0); // サンプラーを1つ

// ルートパラメータの初期化
rootParameters[0].InitAsConstantBufferView(0); // 定数バッファ (例：ワールド・ビュー・プロジェクション行列)
rootParameters[1].InitAsDescriptorTable(1, &textureDescriptorRange, D3D12_SHADER_VISIBILITY_PIXEL); // テクスチャ
// サンプラーはテクスチャと同じディスクリプタテーブルで渡すこともできます

// スタティックサンプラー (ルートシグネチャ内で定義)
D3D12_STATIC_SAMPLER_DESC staticSamplers[1];
staticSamplers[0].Filter = D3D12_FILTER_MIN_MAG_MIP_LINEAR;
staticSamplers[0].AddressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP;
staticSamplers[0].AddressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP;
staticSamplers[0].AddressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP;
staticSamplers[0].MipLODBias = 0;
staticSamplers[0].MaxAnisotropy = 1;
staticSamplers[0].ComparisonFunc = D3D12_COMPARISON_FUNC_ALWAYS;
staticSamplers[0].BorderColor = D3D12_STATIC_BORDER_COLOR_TRANSPARENT_BLACK;
staticSamplers[0].MinLOD = 0;
staticSamplers[0].MaxLOD = D3D12_FLOAT32_MAX;
staticSamplers[0].ShaderRegister = 0; // s0
staticSamplers[0].RegisterSpace = 0;
staticSamplers[0].ShaderVisibility = D3D12_SHADER_VISIBILITY_PIXEL;

// ルートシグネチャの説明
CD3DX12_ROOT_SIGNATURE_DESC rootSigDesc(2, rootParameters, 1, staticSamplers, D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT);

// ルートシグネチャのシリアライズ、作成（省略）

struct Vertex
{
    float Position[3];
    float TexCoord[2]; // テクスチャ座標
};

// 頂点データ
Vertex vertices[] =
{
    { { 0.0f, 0.5f, 0.0f }, { 0.5f, 0.0f } },
    { { 0.5f, -0.5f, 0.0f }, { 1.0f, 1.0f } },
    { { -0.5f, -0.5f, 0.0f }, { 0.0f, 1.0f } }
};

// テクスチャとサンプラーのディスクリプタヒープを設定
ID3D12DescriptorHeap* ppHeaps[] = { textureHeap.Get(), samplerHeap.Get() };
commandList->SetDescriptorHeaps(_countof(ppHeaps), ppHeaps);

// ルートシグネチャのディスクリプタテーブルを設定
commandList->SetGraphicsRootDescriptorTable(1, textureHeap->GetGPUDescriptorHandleForHeapStart());