Как вы увеличиваете текстуры DirectX 11? ⇐ C++

[Anonymous]

У меня есть пример кода, который создает текстуру 320x180 и отображает ее в сферооценке, который начинается с 320x180 внутреннего размера. Я думал, что использования d3d11_filter_min_mag_mip_point будет достаточно, чтобы получить пиксельный эффект, но это не так. Что мне не хватает? src = "https://i.sstatic.net/wiazczgy.png"/>
и вот весь воспроизводимый пример кода:
compile in powershell с (cl. \ cpu.cpp) -and (./cpu.exe) Class = "Lang-None PrettyPrint-Override">// gpu.hlsl

struct pixeldesc
{
float4 position : SV_POSITION;
float2 texcoord : TEX;
};

Texture2D mytexture : register(t0);
SamplerState mysampler : register(s0);

pixeldesc VsMain(uint vI : SV_VERTEXID)
{
pixeldesc output;
output.texcoord = float2(vI % 2, vI / 2);
output.position = float4(output.texcoord * float2(2, -2) - float2(1, -1), 0, 1);
return output;
}

float4 PsMain(pixeldesc pixel) : SV_TARGET
{
return float4(mytexture.Sample(mysampler, pixel.texcoord).rgb, 1);
}
< /code>
// cpu.cpp

#pragma comment(lib, "user32")
#pragma comment(lib, "d3d11")
#pragma comment(lib, "d3dcompiler")

#include
#include
#include

int winw = 320*1;
int winh = 180*1;

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
if (uMsg == WM_DESTROY) {
PostQuitMessage(0);
return 0;
}
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd) {
WNDCLASSA wndclass = { 0, WindowProc, 0, 0, 0, 0, 0, 0, 0, "d8" };

RegisterClassA(&wndclass);

RECT winbox;
winbox.left = GetSystemMetrics(SM_CXSCREEN) / 2 - winw / 2;
winbox.top = GetSystemMetrics(SM_CYSCREEN) / 2 - winh / 2;
winbox.right = winbox.left + winw;
winbox.bottom = winbox.top + winh;
AdjustWindowRectEx(&winbox, WS_OVERLAPPEDWINDOW, false, 0);

HWND window = CreateWindowExA(0, "d8", "testing d3d11 upscaling", WS_OVERLAPPEDWINDOW|WS_VISIBLE,
winbox.left,
winbox.top,
winbox.right - winbox.left,
winbox.bottom - winbox.top,
0, 0, 0, 0);

D3D_FEATURE_LEVEL featurelevels[] = { D3D_FEATURE_LEVEL_11_0 };

DXGI_SWAP_CHAIN_DESC swapchaindesc = {};
swapchaindesc.BufferDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
swapchaindesc.SampleDesc.Count = 1;
swapchaindesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapchaindesc.BufferCount = 2;
swapchaindesc.OutputWindow = window;
swapchaindesc.Windowed = TRUE;
swapchaindesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;

IDXGISwapChain* swapchain;

ID3D11Device* device;
ID3D11DeviceContext* devicecontext;

D3D11CreateDeviceAndSwapChain(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, D3D11_CREATE_DEVICE_BGRA_SUPPORT, featurelevels, ARRAYSIZE(featurelevels), D3D11_SDK_VERSION, &swapchaindesc, &swapchain, &device, nullptr, &devicecontext);

ID3D11Texture2D* framebuffer;
swapchain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&framebuffer); // get the swapchain's buffer

ID3D11RenderTargetView* framebufferRTV;
device->CreateRenderTargetView(framebuffer, nullptr, &framebufferRTV); // and make it a render target [view]

ID3DBlob* vertexshaderCSO;
D3DCompileFromFile(L"gpu.hlsl", 0, 0, "VsMain", "vs_5_0", 0, 0, &vertexshaderCSO, 0);
ID3D11VertexShader* vertexshader;
device->CreateVertexShader(vertexshaderCSO->GetBufferPointer(), vertexshaderCSO->GetBufferSize(), 0, &vertexshader);

ID3DBlob* pixelshaderCSO;
D3DCompileFromFile(L"gpu.hlsl", 0, 0, "PsMain", "ps_5_0", 0, 0, &pixelshaderCSO, 0);
ID3D11PixelShader* pixelshader;
device->CreatePixelShader(pixelshaderCSO->GetBufferPointer(), pixelshaderCSO->GetBufferSize(), 0, &pixelshader);

D3D11_RASTERIZER_DESC rasterizerdesc = { D3D11_FILL_SOLID, D3D11_CULL_NONE };
ID3D11RasterizerState* rasterizerstate;
device->CreateRasterizerState(&rasterizerdesc, &rasterizerstate);

D3D11_SAMPLER_DESC samplerdesc = { D3D11_FILTER_MIN_MAG_MIP_POINT, D3D11_TEXTURE_ADDRESS_WRAP, D3D11_TEXTURE_ADDRESS_WRAP, D3D11_TEXTURE_ADDRESS_WRAP };
ID3D11SamplerState* samplerstate;
device->CreateSamplerState(&samplerdesc, &samplerstate);

unsigned char texturedata[320*180*4];
for (int i = 0; i < 320*180*4; i++) {
texturedata = rand() % 0xff;
}

D3D11_TEXTURE2D_DESC texturedesc = {};
texturedesc.Width = 320;
texturedesc.Height = 180;
texturedesc.MipLevels = 1;
texturedesc.ArraySize = 1;
texturedesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
texturedesc.SampleDesc.Count = 1;
texturedesc.Usage = D3D11_USAGE_IMMUTABLE;
texturedesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;

D3D11_SUBRESOURCE_DATA textureSRD = {};
textureSRD.pSysMem = texturedata;
textureSRD.SysMemPitch = 320 * 4;

ID3D11Texture2D* texture;
device->CreateTexture2D(&texturedesc, &textureSRD, &texture);

ID3D11ShaderResourceView* textureSRV;
device->CreateShaderResourceView(texture, nullptr, &textureSRV);

D3D11_VIEWPORT viewport = { 0, 0, winw, winh, 0, 1 };

MSG msg = { 0 };
while (msg.message != WM_QUIT) {
if (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else {
devicecontext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);

devicecontext->VSSetShader(vertexshader, nullptr, 0);

devicecontext->RSSetViewports(1, &viewport);
devicecontext->RSSetState(rasterizerstate);

devicecontext->PSSetShader(pixelshader, nullptr, 0);
devicecontext->PSSetShaderResources(0, 1, &textureSRV);
devicecontext->PSSetSamplers(0, 1, &samplerstate);

devicecontext->OMSetRenderTargets(1, &framebufferRTV, nullptr);

devicecontext->Draw(4, 0);

swapchain->Present(1, 0);
}
}
}


Подробнее здесь: https://stackoverflow.com/questions/796 ... 1-textures