Du bist nicht angemeldet.

Werbeanzeige

1

17.09.2013, 18:29

[Directx 11] Render Frame: nur weißer Bildschirm (kein Viereck)

Hallo,
endlich habe ich mich so weit durch die MS Dokumentation gekämpft, dass ich ein Bild rendern könnte. Ich bekomme auch beim Erstellen, sowie bei der Ausführung, keine Fehler.
Allerdings öffnet sich nur ein weißes Fenster, anstatt dass ein Viereck gerendert wird.
Kann mir da jemand helfen? ?(

Src:

wasdPipeline.cpp

C-/C++-Quelltext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
#include "wasdPipeline.h"
#include "Declarations.h"
#include "..\shared\Structs.h"
#include <D3D11.h>
#include <D3D10.h>
#include <D3DX11.h>
#include <vector>
#include <fstream>
#include "wasdDevice.h"

using namespace wasd;
using namespace std;

wasdPipeline::wasdPipeline(wasdDevice* device, vector<Vertex> vertices)
{
    setUpBuffers(vertices, device);
    setUpShaders(device);
    createInputLayout(device);
}

wasdPipeline::~wasdPipeline()
{
    VertexBuffer->Release();
    VertexBuffer = 0;
    IndexBuffer->Release();
    IndexBuffer = 0;
    pVS->Release();
    pPS->Release();
    VS->Release();
}

void wasdPipeline::createInputLayout(wasdDevice* device)
{
    D3D11_INPUT_ELEMENT_DESC layout[] = 
    {
        {"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0},
        {"COLOR", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0},
    };
    device->CreateInputLayout(layout, 2, VS, &pLayout);
}

void wasdPipeline::setUpShaders(wasdDevice* device)
{
    ifstream pshader("pixelshader.cso", std::ios::in | std::ios::binary | std::ios::ate);
    if(!pshader)
    {
        MessageBox(NULL, L"Shaderdatei fehlt", L"Error", MB_ICONERROR | MB_OK);
        exit(0);
    }

    size_t fileSizeP = pshader.tellg();
    pshader.seekg(0, std::ios::beg);
    char* dataP = new char[fileSizeP];
    pshader.read(dataP, fileSizeP);
    pshader.close();

    D3D10CreateBlob(sizeof(dataP), &PS);
    delete[] dataP;

    ifstream shader("vertexshader.cso", std::ios::in | std::ios::binary | std::ios::ate);
    if(!shader)
    {
        MessageBox(NULL, L"Shaderdatei fehlt", L"Error", MB_ICONERROR | MB_OK);
        exit(0);
    }

    size_t fileSize = shader.tellg();
    shader.seekg(0, std::ios::beg);
    char* data = new char[fileSize];
    shader.read(data, fileSize);
    shader.close();

    D3D10CreateBlob(sizeof(data), &VS);
    delete[] data;

    device->CreateVertexAndPixelShader(VS, PS, &pVS, &pPS);
}

void wasdPipeline::setUpBuffers(vector<Vertex> vertices, wasdDevice* device)
{
    D3D11_BUFFER_DESC VertexBufferDesc, IndexBufferDesc;
    D3D11_SUBRESOURCE_DATA vertexData, IndexData;
    unsigned long* indices;

    Vertex* ver = new Vertex[vertices.size()];
    indices = new unsigned long[vertices.size()];
    for(int i = 0; i < vertices.size(); i++)
    {
        indices[i] = i;
        ver[i] = vertices[i];
    }

    VertexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
    VertexBufferDesc.ByteWidth = sizeof(Vertex) * vertices.size();
    VertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    VertexBufferDesc.CPUAccessFlags = 0;
    VertexBufferDesc.MiscFlags = 0;

    vertexData.pSysMem = ver;
    vertexData.SysMemPitch = 0;
    vertexData.SysMemSlicePitch = 0;

    device->CreateBuffer(&VertexBufferDesc, &vertexData, &VertexBuffer);

    IndexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
    IndexBufferDesc.ByteWidth = sizeof(unsigned long) * vertices.size();
    IndexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
    IndexBufferDesc.CPUAccessFlags = 0;
    IndexBufferDesc.MiscFlags = 0;

    IndexData.pSysMem = indices;
    device->CreateBuffer(&IndexBufferDesc, &IndexData, &IndexBuffer);

    delete[] ver;
    ver = 0;
    delete[] indices;
    indices = 0;

    UINT stride = sizeof(VertexBuffer);
    UINT offset = 0;
    device->IASetVertexBuffers(1, &VertexBuffer, &stride, &offset, D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
    device->IASetIndexBuffer(IndexBuffer, DXGI_FORMAT_R32_TYPELESS);
}

void wasdPipeline::RenderFrame(wasdDevice* device, UINT vertexCount)
{
    device->RenderFrame(vertexCount);
}


wasdDevice.cpp

C-/C++-Quelltext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
#include "wasdDevice.h"
#include "..\shared\Structs.h"
#include "Declarations.h"
#include <iostream>

using namespace wasd;

wasdDevice::wasdDevice(HWND hWnd, bool fullscreen, int width, int height)
{
    delta = 0;
    fps = 0;
    last = 0;
    aktuell = 0;

    ZeroMemory(&scd, sizeof(DXGI_SWAP_CHAIN_DESC));

    scd.BufferCount = 1;
    scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
    scd.OutputWindow = hWnd;
    scd.SampleDesc.Count = 4;
    if(fullscreen)
    {
        scd.Windowed = FALSE;
    }
    else
    {
        scd.Windowed = TRUE;  
    }

    D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_REFERENCE, NULL, NULL, NULL, NULL, D3D11_SDK_VERSION, &scd, &swapchain, &dev, NULL, &devcon);

    //Adresse des Backbuffers bekommen
    ID3D11Texture2D* pBackBuffer;
    swapchain->GetBuffer(0, _uuidof(ID3D11Texture2D), (LPVOID*) &pBackBuffer);

    //bufferadresse benutzen um Render-Taget zu setzen
    dev->CreateRenderTargetView(pBackBuffer, NULL, &backbuffer);
    pBackBuffer->Release();

    //Backbuffer als Rendertarget setzen
    devcon->OMSetRenderTargets(1, &backbuffer, NULL);

    //Viewport setzen
    D3D11_VIEWPORT viewport;
    ZeroMemory(&viewport, sizeof(D3D11_VIEWPORT));

    viewport.TopLeftX = 0;
    viewport.TopLeftY = 0;
    viewport.Width = (float) width;
    viewport.Height = (float) height;

    devcon->RSSetViewports(1, &viewport);

    std::cout<<"Initialisierung des wasdDevice erfolgreich"<<std::endl;

    last = GetCurrentTime();
}

wasdDevice::~wasdDevice()
{
    swapchain->Release();
    dev->Release();
    devcon->Release();
    backbuffer->Release();
}

void wasdDevice::computeDelta()
{
    aktuell = GetTickCount();
    delta = last - aktuell;
    last = aktuell;
    fps = 1000/delta;
}

DWORD wasdDevice::getDelta()
{
    return delta;
}

DWORD wasdDevice::getFPS()
{
    return fps;
}

void wasdDevice::IASetVertexBuffers(int numBuffers, ID3D11Buffer** buffer, UINT* strides, UINT* offsets, D3D_PRIMITIVE_TOPOLOGY tp)
{
    devcon->IASetVertexBuffers(0, numBuffers, buffer, strides, offsets);
    devcon->IASetPrimitiveTopology(tp);
}

void wasdDevice::IASetIndexBuffer(ID3D11Buffer* buffer, DXGI_FORMAT format)
{
    devcon->IASetIndexBuffer(buffer, format, 0);
}

void wasdDevice::CreateBuffer(D3D11_BUFFER_DESC* desc, D3D11_SUBRESOURCE_DATA* data, ID3D11Buffer** vertexBuffer)
{
    dev->CreateBuffer(desc, data, vertexBuffer);
}

void wasdDevice::RenderFrame(UINT vertexCount)
{
    //computeDelta();
    float color[4] = {1.0, 0 , 0 , 0};
    //devcon->ClearRenderTargetView(NULL, color);
    devcon->DrawIndexed(vertexCount, 0, 0);
    
}

void wasdDevice::CreateInputLayout(D3D11_INPUT_ELEMENT_DESC* ied, UINT numElements, ID3D10Blob* VS, ID3D11InputLayout** pLayout)
{
    dev->CreateInputLayout(ied, numElements, VS->GetBufferPointer(), VS->GetBufferSize(), pLayout);
    devcon->IASetInputLayout(*pLayout);
}

void wasdDevice::MapAndUnmap(ID3D11Buffer** VertexBuffer, Vertex vertices[])
{
    D3D11_MAPPED_SUBRESOURCE ms;
    devcon->Map(*VertexBuffer, NULL, D3D11_MAP_WRITE_DISCARD, NULL, &ms);
    memcpy(ms.pData, vertices, sizeof(vertices));
    devcon->Unmap(*VertexBuffer, NULL);
}

void wasdDevice::CreateVertexAndPixelShader(ID3D10Blob* VS, ID3D10Blob* PS, ID3D11VertexShader** pVS, ID3D11PixelShader** pPS)
{
    dev->CreateVertexShader(VS->GetBufferPointer(), VS->GetBufferSize(), NULL, pVS);
    dev->CreatePixelShader(PS->GetBufferPointer(), PS->GetBufferSize(), NULL, pPS);

    devcon->VSSetShader(*pVS, 0, 0);
    devcon->PSSetShader(*pPS, 0, 0);
}

void wasdDevice::present()
{
    swapchain->Present(0, 0);
}

David Scherfgen

Administrator

Beiträge: 10 216

Wohnort: Hildesheim

Beruf: Wissenschaftlicher Mitarbeiter

  • Private Nachricht senden

2

17.09.2013, 18:39

Der Teil, wo du das Fenster erzeugst, fehlt ...

3

17.09.2013, 18:41

Oh natürlich...

wasdGraphics.cpp

C-/C++-Quelltext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
#include "wasdGraphics.h"
#include <string>
#include <stdio.h>
#include "Declarations.h"
#include <iostream>
#include "..\shared\Structs.h"
#include "wasdDevice.h"
#include <SDL.h>
#include <SDL_syswm.h>
#include <stdlib.h>
#include "wasdPipeline.h"


using namespace wasd;

wasdGraphics::wasdGraphics(GraphicsInput i, std::vector<Vertex> vertices)
{
    if(i.initializeGraphics)
    {
        width = i.width;
        height = i.height;
        //SDL initialisieren
        SDL_Init(SDL_INIT_VIDEO);
        //Erzeugung der SDL_Surface
        if(i.fullscreen)
        {
            screen = SDL_CreateWindow(i.title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, i.width, i.height, SDL_WINDOW_FULLSCREEN | SDL_WINDOW_SHOWN);
        }
        else
        {
            screen = SDL_CreateWindow(i.title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, i.width, i.height, SDL_WINDOW_SHOWN);
        }
        if(!screen)
        {
            MessageBox(NULL, L"Erstellung des SDLWindows fehlgeschlagen", L"Error", MB_ICONERROR | MB_OK);
            exit(0);
        }
        else
        {
            std::cout<<"Initialisierung der SDLSurface erfolgreich\n";
        }
        wchar_t wtext[200];
        std::mbstowcs(wtext, i.title, strlen(i.title)+1);
        hWnd = FindWindow(NULL, wtext);

        //wasdDevice erzeugen
        device = new wasdDevice(hWnd, i.fullscreen, i.width, i.height);
        if(!device)
        {
            MessageBox(NULL, L"Erstellung des wasdDevices fehlgeschlagen", L"Error", MB_ICONERROR | MB_OK);
            exit(0);
        }

        //wasdPipeline erzeugen
        pipeline = new wasdPipeline(device, vertices);
        if(!pipeline)
        {
            MessageBox(NULL, L"Erstellung der wasdPipeline fehlgeschlagen", L"Error", MB_ICONERROR | MB_OK);
            exit(0);
        }
    }
}

wasdGraphics::~wasdGraphics()
{
    delete device;

    SDL_Quit();
}

HWND wasdGraphics::getHWND() {return hWnd;}

void wasdGraphics::RenderFrame(std::vector<Vertex> vertices)
{
    pipeline->RenderFrame(device, vertices.size());
    device->present();
}

David Scherfgen

Administrator

Beiträge: 10 216

Wohnort: Hildesheim

Beruf: Wissenschaftlicher Mitarbeiter

  • Private Nachricht senden

4

17.09.2013, 19:17

Ich habe mir jetzt deinen Code nicht wirklich angeschaut (ich habe auch keine Erfahrung mit DirectX >= 10), aber vielleicht gibt es ein Problem, weil du ein SDL-Fenster benutzt.
Probier es mal mit einem eigenen Fenster, das du mit CreateWindow erzeugst.

5

17.09.2013, 19:24

Das kann nicht das Problem sein, da ich in einer früheren Version der Engine keine Probleme hatte, das Fenster Farbig zu machen (mit devcon->ClearRenderView()).
Dort gab es keine Probleme mit dem SDL-Fenster.

David Scherfgen

Administrator

Beiträge: 10 216

Wohnort: Hildesheim

Beruf: Wissenschaftlicher Mitarbeiter

  • Private Nachricht senden

6

17.09.2013, 19:41

Na gut, dann ist es wohl was anderes.
Es fehlt übrigens auch noch der Code, wo du die Vertices für das Viereck initialisierst.
Und deine Shader fehlen auch ;)

Tobiking

1x Rätselkönig

  • Private Nachricht senden

7

17.09.2013, 19:47

Ich bekomme auch beim Erstellen, sowie bei der Ausführung, keine Fehler.

Woher weißt du, dass du während der Ausführung keine Fehler bekommst? In dem Code überprüfst du nicht einen einzigen Rückgabewert. Der erste sinnvolle Schritt bei der Fehlersuche ist zu überprüfen ob Shader, Buffer etc. auch erfolgreich erzeugt werden.

Legend

Alter Hase

Beiträge: 740

Beruf: Softwareentwickler

  • Private Nachricht senden

8

17.09.2013, 19:55

Auch immer sehr empfehlenswert: Übergib bei D3D11CreateDeviceAndSwapChain das Flag D3D11_CREATE_DEVICE_DEBUG und guck mit Debugview oder halt in dem Output-Fenster vom Visual Studio-Debugger, ob nicht dann doch Fehler auftauchen.
"Wir müssen uns auf unsere Kernkompetenzen konzentrieren!" - "Juhu, wir machen eine Farm auf!"

Netzwerkbibliothek von mir, C#, LGPL: https://sourceforge.net/projects/statetransmitt/

9

17.09.2013, 20:46

Kann man D3D10 und D3D11 zusammen verwenden?

Legend

Alter Hase

Beiträge: 740

Beruf: Softwareentwickler

  • Private Nachricht senden

10

17.09.2013, 21:36

Meinst du wegen den D3D10Blob? Ich glaub die Blobs gibt es in D3D11 gar nicht mehr, da man sie aber nicht direkt an D3D11 übergibt, sind die unproblematisch.
"Wir müssen uns auf unsere Kernkompetenzen konzentrieren!" - "Juhu, wir machen eine Farm auf!"

Netzwerkbibliothek von mir, C#, LGPL: https://sourceforge.net/projects/statetransmitt/

Werbeanzeige