20.6 C
New York
Saturday, April 19, 2025
HomeGame Development
Game Development

shaders – Misplaced preview frames on ID3D10RenderTargetView in DirectX 10

Felipe
By Felipe
0
17
shaders – Misplaced preview frames on ID3D10RenderTargetView in DirectX 10


Drawback: This code ought to do a right-shifting trailing impact by accumulating earlier frames on g_pSurfaceImg[0] however fails.

Incorrect consequence: the picture that ought to be trailing simply shifts proper

#embrace 
#embrace 
#embrace 

const int width = 800;
const int peak = 600;
const int NUM_TEX = 4;
const int NUM_SHADERS = 3;
const int g_multisamples = 4;
const int g_multisamplequality = 4;

ID3D10Device* g_pDevice = nullptr;
IDXGISwapChain* g_pSwapChain = nullptr;
ID3D10RenderTargetView* g_pBackBufferRTV = nullptr;
ID3D10InputLayout* g_pInputLayout = nullptr;
ID3D10VertexShader* g_pVertexShader = nullptr;
ID3D10PixelShader* g_pPixelShader[NUM_SHADERS] = { nullptr };
ID3D10Buffer* g_pVertexBuffer = nullptr;
ID3D10BlendState* g_pBlendState = nullptr;
ID3D10RasterizerState* g_pRasterizerState = nullptr;

ID3D10ShaderResourceView* g_pBackgroundSRV = nullptr;
ID3D10Texture2D* g_pBackgroundTexture = nullptr;
ID3D10RenderTargetView* g_pBackgroundRTV = nullptr;

ID3D10ShaderResourceView* g_pTextureImg[NUM_TEX] = { nullptr };
ID3D10RenderTargetView* g_pSurfaceImg[NUM_TEX] = { nullptr };

ID3D10SamplerState* g_pSamplerState = nullptr;

struct Vertex {
    float place[3];
    float texCoord[2];
    float colour[4];
};

LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
    swap (msg) {
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    }
    return DefWindowProc(hWnd, msg, wParam, lParam);
}

bool CreateRenderTarget(int index, const char* filename) {
    HRESULT hr = D3DX10CreateShaderResourceViewFromFile(g_pDevice, filename, nullptr, nullptr, &g_pTextureImg[index], nullptr);
    if (FAILED(hr)) {
        char errorMsg[256];
        sprintf_s(errorMsg, "Didn't load texture from file: %s (Error: 0xpercent08X)", filename, hr);
        MessageBox(NULL, errorMsg, "Error", MB_OK);
        return false;
    }

    D3D10_TEXTURE2D_DESC desc = {};
    desc.Width = width;
    desc.Peak = peak;
    desc.MipLevels = 1;
    desc.ArraySize = 1;
    desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    desc.SampleDesc.Depend = g_multisamples;
    desc.SampleDesc.High quality = g_multisamplequality;
    desc.Utilization = D3D10_USAGE_DEFAULT;
    desc.BindFlags = D3D10_BIND_RENDER_TARGET | D3D10_BIND_SHADER_RESOURCE;

    ID3D10Texture2D* pSurfaceTmp = nullptr;
    hr = g_pDevice->CreateTexture2D(&desc, nullptr, &pSurfaceTmp);
    if (FAILED(hr)) {
        MessageBox(NULL, "Didn't create render texture", "Error", MB_OK);
        return false;
    }

    D3D10_RENDER_TARGET_VIEW_DESC rtvDesc = {};
    rtvDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    rtvDesc.ViewDimension = D3D10_RTV_DIMENSION_TEXTURE2DMS;
    hr = g_pDevice->CreateRenderTargetView(pSurfaceTmp, &rtvDesc, &g_pSurfaceImg[index]);
    if (FAILED(hr)) {
        char errorMsg[256];
        sprintf_s(errorMsg, "Didn't create render goal view for texture %d (Error: 0xpercent08X)", index, hr);
        MessageBox(NULL, errorMsg, "Error", MB_OK);
        return false;
    }

    if (index == 0) {
        hr = g_pDevice->CreateShaderResourceView(pSurfaceTmp, nullptr, &g_pTextureImg[index]);
        if (FAILED(hr)) {
            char errorMsg[256];
            sprintf_s(errorMsg, "Didn't create SRV for g_pSurfaceImg[0] (Error: 0xpercent08X)", hr);
            MessageBox(NULL, errorMsg, "Error", MB_OK);
            return false;
        }
    }

    return true;
}

bool InitD3D(HWND hWnd) {
    DXGI_SWAP_CHAIN_DESC sd;
    ZeroMemory(&sd, sizeof(sd));
    sd.BufferCount = 1;
    sd.BufferDesc.Width = width;
    sd.BufferDesc.Peak = peak;
    sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    sd.BufferDesc.RefreshRate.Numerator = 60;
    sd.BufferDesc.RefreshRate.Denominator = 1;
    sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
    sd.OutputWindow = hWnd;
    sd.SampleDesc.Depend = g_multisamples;
    sd.SampleDesc.High quality = g_multisamplequality;
    sd.Windowed = TRUE;

    HRESULT hr = D3D10CreateDeviceAndSwapChain(NULL, D3D10_DRIVER_TYPE_HARDWARE, NULL, 0, D3D10_SDK_VERSION, &sd, &g_pSwapChain, &g_pDevice);
    if (FAILED(hr)) {
        MessageBox(NULL, "Didn't create machine and swap chain", "Error", MB_OK);
        return false;
    }

    ID3D10Texture2D* pBackBuffer = nullptr;
    hr = g_pSwapChain->GetBuffer(0, __uuidof(ID3D10Texture2D), (LPVOID*)&pBackBuffer);
    if (FAILED(hr)) {
        MessageBox(NULL, "Didn't get again buffer", "Error", MB_OK);
        return false;
    }

    hr = g_pDevice->CreateRenderTargetView(pBackBuffer, nullptr, &g_pBackBufferRTV);
    pBackBuffer->Launch();
    if (FAILED(hr)) {
        MessageBox(NULL, "Didn't create again buffer RTV", "Error", MB_OK);
        return false;
    }

    hr = D3DX10CreateShaderResourceViewFromFile(g_pDevice, "E:/Music/Video/_elem/geom/triskel 2.png", nullptr, nullptr, &g_pBackgroundSRV, nullptr);
    if (FAILED(hr)) {
        MessageBox(NULL, "Didn't load background texture", "Error", MB_OK);
        return false;
    }

    D3D10_TEXTURE2D_DESC desc = {};
    desc.Width = width;
    desc.Peak = peak;
    desc.MipLevels = 1;
    desc.ArraySize = 1;
    desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    desc.SampleDesc.Depend = g_multisamples;
    desc.SampleDesc.High quality = g_multisamplequality;
    desc.Utilization = D3D10_USAGE_DEFAULT;
    desc.BindFlags = D3D10_BIND_RENDER_TARGET | D3D10_BIND_SHADER_RESOURCE;

    hr = g_pDevice->CreateTexture2D(&desc, nullptr, &g_pBackgroundTexture);
    if (FAILED(hr)) {
        MessageBox(NULL, "Didn't create background render texture", "Error", MB_OK);
        return false;
    }

    D3D10_RENDER_TARGET_VIEW_DESC rtvDesc = {};
    rtvDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    rtvDesc.ViewDimension = D3D10_RTV_DIMENSION_TEXTURE2DMS;
    hr = g_pDevice->CreateRenderTargetView(g_pBackgroundTexture, &rtvDesc, &g_pBackgroundRTV);
    if (FAILED(hr)) {
        MessageBox(NULL, "Didn't create background RTV", "Error", MB_OK);
        return false;
    }

    const char* filenames[NUM_TEX] = {
        "E:/Music/Video/_elem/geom/triskel 2.png",
        "E:/Music/Video/_elem/geom/triskel 2.png",
        "E:/Music/Video/_elem/geom/triskel 2.png",
        "E:/Music/Video/_elem/geom/triskel 2.png"
    };
    for (int i = 0; i < NUM_TEX; i++) {
        if (!CreateRenderTarget(i, filenames[i])) {
            char errorMsg[256];
            sprintf_s(errorMsg, "Didn't create render goal for texture %d", i);
            MessageBox(NULL, errorMsg, "Error", MB_OK);
            return false;
        }
    }

    D3D10_VIEWPORT vp = { 0, 0, width, peak, 0.0f, 1.0f };
    g_pDevice->RSSetViewports(1, &vp);

    D3D10_BLEND_DESC blendDesc = { 0 };
    blendDesc.AlphaToCoverageEnable = FALSE;
    blendDesc.BlendEnable[0] = TRUE;
    blendDesc.SrcBlend = D3D10_BLEND_SRC_ALPHA;
    blendDesc.DestBlend = D3D10_BLEND_INV_SRC_ALPHA;
    blendDesc.BlendOp = D3D10_BLEND_OP_ADD;
    blendDesc.SrcBlendAlpha = D3D10_BLEND_ONE;
    blendDesc.DestBlendAlpha = D3D10_BLEND_ZERO;
    blendDesc.BlendOpAlpha = D3D10_BLEND_OP_ADD;
    blendDesc.RenderTargetWriteMask[0] = D3D10_COLOR_WRITE_ENABLE_ALL;

    hr = g_pDevice->CreateBlendState(&blendDesc, &g_pBlendState);
    if (FAILED(hr)) {
        MessageBox(NULL, "Didn't create mix state", "Error", MB_OK);
        return false;
    }
    g_pDevice->OMSetBlendState(g_pBlendState, nullptr, 0xffffffff);

    D3D10_RASTERIZER_DESC rasterizerState;
    rasterizerState.CullMode = D3D10_CULL_NONE;
    rasterizerState.FillMode = D3D10_FILL_SOLID;
    rasterizerState.FrontCounterClockwise = false;
    rasterizerState.DepthBias = 0;
    rasterizerState.DepthBiasClamp = 0;
    rasterizerState.SlopeScaledDepthBias = 0;
    rasterizerState.DepthClipEnable = true;
    rasterizerState.ScissorEnable = false;
    rasterizerState.MultisampleEnable = true;
    rasterizerState.AntialiasedLineEnable = true;

    hr = g_pDevice->CreateRasterizerState(&rasterizerState, &g_pRasterizerState);
    if (FAILED(hr)) {
        MessageBox(NULL, "Didn't create rasterizer state", "Error", MB_OK);
        return false;
    }
    g_pDevice->RSSetState(g_pRasterizerState);

    const char* vertexShaderCode =
        "struct VS_INPUT { float3 place : POSITION; float2 texCoord : TEXCOORD; float4 colour : COLOR; };"
        "struct VS_OUTPUT { float4 place : SV_POSITION; float2 texCoord : TEXCOORD; float4 colour : COLOR; };"
        "VS_OUTPUT VS(VS_INPUT enter) {"
        "   VS_OUTPUT output;"
        "   float2 screenPos = enter.place.xy / float2(800.0, 600.0) * 2.0 - 1.0;"
        "   output.place = float4(screenPos, enter.place.z, 1.0);"
        "   output.texCoord = enter.texCoord;"
        "   output.colour = enter.colour;"
        "   return output;"
        "}";

    ID3D10Blob *pVSBlob = nullptr, *pPSBlob = nullptr, *pErrorBlob = nullptr;
    hr = D3D10CompileShader(vertexShaderCode, strlen(vertexShaderCode), NULL, NULL, NULL, "VS", "vs_4_0", 0, &pVSBlob, &pErrorBlob);
    if (FAILED(hr)) {
        if (pErrorBlob) {
            MessageBox(NULL, (char*)pErrorBlob->GetBufferPointer(), "Vertex Shader Error", MB_OK);
            pErrorBlob->Launch();
        }
        return false;
    }
    hr = g_pDevice->CreateVertexShader(pVSBlob->GetBufferPointer(), pVSBlob->GetBufferSize(), &g_pVertexShader);
    if (FAILED(hr)) return false;

    const char* pixelShaderCode0 =
        "Texture2D tex : register(t0);"
        "SamplerState sampler_main : register(s0);"
        "float4 PS(float4 colour : COLOR, float2 uv : TEXCOORD) : SV_TARGET {"
        "   return tex.Pattern(sampler_main, uv);"
        "}";

    hr = D3D10CompileShader(pixelShaderCode0, strlen(pixelShaderCode0), NULL, NULL, NULL, "PS", "ps_4_0", 0, &pPSBlob, &pErrorBlob);
    if (FAILED(hr)) {
        if (pErrorBlob) {
            MessageBox(NULL, (char*)pErrorBlob->GetBufferPointer(), "Pixel Shader 0 Error", MB_OK);
            pErrorBlob->Launch();
        }
        return false;
    }
    hr = g_pDevice->CreatePixelShader(pPSBlob->GetBufferPointer(), pPSBlob->GetBufferSize(), &g_pPixelShader[0]);
    if (FAILED(hr)) return false;

    const char* pixelShaderCode1 =
        "Texture2D tex : register(t0);"
        "SamplerState sampler_main : register(s0);"
        "float4 PS(float4 colour : COLOR, float2 uv : TEXCOORD) : SV_TARGET {"
        "   float4 ret = tex.Pattern(sampler_main, uv);"
        "   return float4(ret.rgb, ret.a * 0.93);"
        "}";

    hr = D3D10CompileShader(pixelShaderCode1, strlen(pixelShaderCode1), NULL, NULL, NULL, "PS", "ps_4_0", 0, &pPSBlob, &pErrorBlob);
    if (FAILED(hr)) {
        if (pErrorBlob) {
            MessageBox(NULL, (char*)pErrorBlob->GetBufferPointer(), "Pixel Shader 1 Error", MB_OK);
            pErrorBlob->Launch();
        }
        return false;
    }
    hr = g_pDevice->CreatePixelShader(pPSBlob->GetBufferPointer(), pPSBlob->GetBufferSize(), &g_pPixelShader[1]);
    if (FAILED(hr)) return false;

    const char* pixelShaderCode2 =
        "Texture2D tex : register(t0);"
        "SamplerState sampler_main : register(s0);"
        "float4 PS(float4 colour : COLOR, float2 uv : TEXCOORD) : SV_TARGET {"
        "   float2 uv2 = uv + float2(0.5, 0.0);"
        "   return tex.Pattern(sampler_main, uv2);"
        "}";

    hr = D3D10CompileShader(pixelShaderCode2, strlen(pixelShaderCode2), NULL, NULL, NULL, "PS", "ps_4_0", 0, &pPSBlob, &pErrorBlob);
    if (FAILED(hr)) {
        if (pErrorBlob) {
            MessageBox(NULL, (char*)pErrorBlob->GetBufferPointer(), "Pixel Shader 2 Error", MB_OK);
            pErrorBlob->Launch();
        }
        return false;
    }
    hr = g_pDevice->CreatePixelShader(pPSBlob->GetBufferPointer(), pPSBlob->GetBufferSize(), &g_pPixelShader[2]);
    if (FAILED(hr)) return false;

    D3D10_INPUT_ELEMENT_DESC structure[] = {
        { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0 },
        { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D10_INPUT_PER_VERTEX_DATA, 0 },
        { "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 20, D3D10_INPUT_PER_VERTEX_DATA, 0 },
    };
    hr = g_pDevice->CreateInputLayout(structure, ARRAYSIZE(structure), pVSBlob->GetBufferPointer(), pVSBlob->GetBufferSize(), &g_pInputLayout);
    if (FAILED(hr)) {
        MessageBox(NULL, "Didn't create enter structure", "Error", MB_OK);
        return false;
    }

    D3D10_BUFFER_DESC bd = {};
    bd.Utilization = D3D10_USAGE_DYNAMIC;
    bd.ByteWidth = sizeof(Vertex) * 4;
    bd.BindFlags = D3D10_BIND_VERTEX_BUFFER;
    bd.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;

    hr = g_pDevice->CreateBuffer(&bd, nullptr, &g_pVertexBuffer);
    if (FAILED(hr)) {
        MessageBox(NULL, "Didn't create vertex buffer", "Error", MB_OK);
        return false;
    }

    D3D10_SAMPLER_DESC samplerDesc = {};
    samplerDesc.Filter = D3D10_FILTER_ANISOTROPIC;
    samplerDesc.AddressU = D3D10_TEXTURE_ADDRESS_CLAMP;
    samplerDesc.AddressV = D3D10_TEXTURE_ADDRESS_CLAMP;
    samplerDesc.AddressW = D3D10_TEXTURE_ADDRESS_CLAMP;
    samplerDesc.MaxAnisotropy = 4;
    samplerDesc.MipLODBias = 0.0f;
    samplerDesc.MaxLOD = D3D10_FLOAT32_MAX;
    hr = g_pDevice->CreateSamplerState(&samplerDesc, &g_pSamplerState);
    if (FAILED(hr)) {
        MessageBox(NULL, "Didn't create sampler state", "Error", MB_OK);
        return false;
    }

    if (pVSBlob) pVSBlob->Launch();
    if (pPSBlob) pPSBlob->Launch();
    if (pErrorBlob) pErrorBlob->Launch();

    return true;
}

void SaveTextureToFile(ID3D10RenderTargetView* rtv, const char* filename) {
    ID3D10Resource* useful resource = nullptr;
    rtv->GetResource(&useful resource);
    ID3D10Texture2D* texture = nullptr;
    resource->QueryInterface(__uuidof(ID3D10Texture2D), (void**)&texture);
    resource->Launch();

    D3D10_TEXTURE2D_DESC desc;
    texture->GetDesc(&desc);

    desc.SampleDesc.Depend = 1;
    desc.SampleDesc.High quality = 0;
    desc.Utilization = D3D10_USAGE_DEFAULT;
    desc.BindFlags = 0;
    desc.CPUAccessFlags = 0;

    ID3D10Texture2D* singleSampleTex = nullptr;
    HRESULT hr = g_pDevice->CreateTexture2D(&desc, nullptr, &singleSampleTex);
    if (FAILED(hr)) {
        MessageBox(NULL, "Didn't create single-sample texture", "Error", MB_OK);
        texture->Launch();
        return;
    }

    g_pDevice->ResolveSubresource(singleSampleTex, 0, texture, 0, DXGI_FORMAT_R8G8B8A8_UNORM);

    desc.Utilization = D3D10_USAGE_STAGING;
    desc.BindFlags = 0;
    desc.CPUAccessFlags = D3D10_CPU_ACCESS_READ | D3D10_CPU_ACCESS_WRITE;

    ID3D10Texture2D* stagingTexture = nullptr;
    hr = g_pDevice->CreateTexture2D(&desc, nullptr, &stagingTexture);
    if (FAILED(hr)) {
        MessageBox(NULL, "Didn't create staging texture", "Error", MB_OK);
        singleSampleTex->Launch();
        texture->Launch();
        return;
    }

    g_pDevice->CopyResource(stagingTexture, singleSampleTex);
    hr = D3DX10SaveTextureToFile(stagingTexture, D3DX10_IFF_PNG, filename);
    if (FAILED(hr)) {
        char errorMsg[256];
        sprintf_s(errorMsg, "Failed to save lots of texture to file %s (Error: 0xpercent08X)", filename, hr);
        MessageBox(NULL, errorMsg, "Error", MB_OK);
    }

    stagingTexture->Launch();
    singleSampleTex->Launch();
    texture->Launch();
}

float prev_x = 0.0f;
void Render() {
    if (!g_pDevice) return;
    ID3D10Resource* tmpResource = nullptr;
    ID3D10ShaderResourceView* tmpResourceView = nullptr;

    float clearColor[4] = { 0.0f, 0.0f, 0.4f, 1.0f };
    UINT stride = sizeof(Vertex);
    UINT offset = 0;

    Vertex vertices[] = {
        { {0.0f, 0.0f, 0.0f}, {0.0f, 1.0f}, {1.0f, 1.0f, 1.0f, 1.0f} },
        { {0.0f, (float)peak, 0.0f}, {0.0f, 0.0f}, {1.0f, 1.0f, 1.0f, 1.0f} },
        { {(float)width, 0.0f, 0.0f}, {1.0f, 1.0f}, {1.0f, 1.0f, 1.0f, 1.0f} },
        { {(float)width, (float)peak, 0.0f}, {1.0f, 0.0f}, {1.0f, 1.0f, 1.0f, 1.0f} },
    };

    for (int i = 0; i < 4; i++) {
        vertices[i].place[0] += 100.0f;
    }

    g_pDevice->IASetVertexBuffers(0, 1, &g_pVertexBuffer, &stride, &offset);
    g_pDevice->IASetInputLayout(g_pInputLayout);
    g_pDevice->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
    g_pDevice->VSSetShader(g_pVertexShader);
    g_pDevice->PSSetSamplers(0, 1, &g_pSamplerState);

    // Background
    Vertex* v=vertices;
    HRESULT hr = g_pVertexBuffer->Map(D3D10_MAP_WRITE_DISCARD, 0, (void**)&v);
    if (FAILED(hr)) return;
    memcpy(v, vertices, sizeof(vertices));
    g_pVertexBuffer->Unmap();
    g_pDevice->ClearRenderTargetView(g_pBackgroundRTV, clearColor);
    g_pDevice->OMSetRenderTargets(1, &g_pBackgroundRTV, nullptr);
    g_pDevice->PSSetShader(g_pPixelShader[0]);
    g_pDevice->PSSetShaderResources(0, 1, &g_pBackgroundSRV);
    g_pDevice->Draw(4, 0);

    // Trailing alpha=0.93 on preview frames
    g_pSurfaceImg[0]->GetResource(&tmpResource);
    g_pDevice->OMSetRenderTargets(1, &g_pSurfaceImg[0], nullptr);
    g_pDevice->CreateShaderResourceView(tmpResource, nullptr, &tmpResourceView);
    g_pDevice->PSSetShaderResources(0, 1, &tmpResourceView);
    g_pDevice->PSSetShader(g_pPixelShader[1]);
    g_pDevice->Draw(4, 0);

    // transfer proper
    for (int i = 0; i < 4; i++) {
        vertices[i].place[0] += prev_x;
    }
    hr = g_pVertexBuffer->Map(D3D10_MAP_WRITE_DISCARD, 0, (void**)&v);
    if (FAILED(hr)) return;
    memcpy(v, vertices, sizeof(vertices));
    g_pVertexBuffer->Unmap();
    g_pDevice->PSSetShaderResources(0, 1, &g_pBackgroundSRV);
    g_pDevice->PSSetShader(g_pPixelShader[0]);
    g_pDevice->Draw(4, 0);

    // again
    for (int i = 0; i < 4; i++) {
        vertices[i].place[0] -= prev_x;
    }
    hr = g_pVertexBuffer->Map(D3D10_MAP_WRITE_DISCARD, 0, (void**)&v);
    if (FAILED(hr)) return;
    memcpy(v, vertices, sizeof(vertices));
    g_pVertexBuffer->Unmap();

    g_pDevice->ClearRenderTargetView(g_pSurfaceImg[1], clearColor);
    g_pDevice->OMSetRenderTargets(1, &g_pSurfaceImg[1], nullptr);
    g_pDevice->PSSetShaderResources(0, 1, &g_pTextureImg[0]);
    g_pDevice->PSSetShader(g_pPixelShader[0]);
    g_pDevice->Draw(4, 0);

    g_pDevice->ClearRenderTargetView(g_pSurfaceImg[2], clearColor);
    g_pDevice->OMSetRenderTargets(1, &g_pSurfaceImg[2], nullptr);
    g_pDevice->PSSetShaderResources(0, 1, &g_pTextureImg[1]);
    g_pDevice->PSSetShader(g_pPixelShader[2]);
    g_pDevice->Draw(4, 0);

    g_pDevice->ClearRenderTargetView(g_pBackBufferRTV, clearColor);
    g_pDevice->OMSetRenderTargets(1, &g_pBackBufferRTV, nullptr);
    g_pDevice->PSSetShaderResources(0, 1, &g_pTextureImg[2]);
    g_pDevice->PSSetShader(g_pPixelShader[0]);
    g_pDevice->Draw(4, 0);

    // Convert g_pSurfaceImg[0] to tmpResourceView
    g_pSurfaceImg[0]->GetResource(&tmpResource);
    g_pDevice->CreateShaderResourceView(tmpResource, nullptr, &tmpResourceView);

    // Draw g_pSurfaceImg[0] on g_pBackBufferRTV
    g_pDevice->PSSetShaderResources(0, 1, &tmpResourceView);
    g_pDevice->PSSetShader(g_pPixelShader[0]);
    g_pDevice->Draw(4, 0);

    g_pSwapChain->Current(0, 0);

    prev_x += 0.5f;

    static bool saved = false;
    if (!saved) {
        SaveTextureToFile(g_pSurfaceImg[0], "level1_output.png");
        SaveTextureToFile(g_pSurfaceImg[1], "level2_output.png");
        SaveTextureToFile(g_pSurfaceImg[2], "level3_output.png");
        saved = true;
    }
}

void Cleanup() {
    if (g_pSamplerState) g_pSamplerState->Launch();
    if (g_pVertexBuffer) g_pVertexBuffer->Launch();
    if (g_pInputLayout) g_pInputLayout->Launch();
    if (g_pBackBufferRTV) g_pBackBufferRTV->Launch();
    if (g_pSwapChain) g_pSwapChain->Launch();
    if (g_pDevice) g_pDevice->Launch();
    if (g_pBackgroundSRV) g_pBackgroundSRV->Launch();
    if (g_pBackgroundRTV) g_pBackgroundRTV->Launch();
    if (g_pBackgroundTexture) g_pBackgroundTexture->Launch();
    for (int i = 0; i < NUM_TEX; i++) {
        if (g_pTextureImg[i]) g_pTextureImg[i]->Launch();
        if (g_pSurfaceImg[i]) g_pSurfaceImg[i]->Launch();
    }
    if (g_pVertexShader) g_pVertexShader->Launch();
    for (int i = 0; i < NUM_SHADERS; i++) {
        if (g_pPixelShader[i]) g_pPixelShader[i]->Launch();
    }
    if (g_pBlendState) g_pBlendState->Launch();
    if (g_pRasterizerState) g_pRasterizerState->Launch();
}

int WINAPI WinMain(HINSTANCE hInst, HINSTANCE, LPSTR, int nCmdShow) {
    WNDCLASSEX wc =  CS_VREDRAW, WndProc, 0, 0,
                      GetModuleHandle(nullptr), nullptr, nullptr, nullptr, nullptr,
                      "DX10Window", nullptr ;
    RegisterClassEx(&wc);

    HWND hWnd = CreateWindow(wc.lpszClassName, "DirectX 10 Window",
                            WS_OVERLAPPEDWINDOW, 100, 100, width, peak,
                            nullptr, nullptr, wc.hInstance, nullptr);

    if (InitD3D(hWnd)) {
        ShowWindow(hWnd, nCmdShow);
        UpdateWindow(hWnd);

        MSG msg = { 0 };
        whereas (msg.message != WM_QUIT) {
            if (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE)) {
                TranslateMessage(&msg);
                DispatchMessage(&msg);
            }
            else {
                Render();
                Sleep(10);
            }
        }
    }
    else {
        MessageBox(NULL, "Initialization failed - examine earlier error messages", "Error", MB_OK);
    }

    Cleanup();
    UnregisterClass(wc.lpszClassName, wc.hInstance);
    return 0;
}

The place is the content material of g_pSurfaceImg[0] from the earlier body misplaced?

Previous article
PlayStation Retailer Replace Worldwide April 8, 2025
Next article
Mario Kart World “Paid DLC” Would Be A Large No-No, In accordance To Ex-Nintendo Duo
Felipe
Felipehttp://libeplay.com

Related Articles

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Latest Articles

Load more

Libeplay is your gaming, video game, and retro gaming related website. We provide you with the latest breaking news and videos straight from the gaming industry.

© Copyright 2024 - libeplay.com. All rights reserved.