Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

Würfel aus Index und Vertex Buffer

Werbeanzeige

Jonathan_Klein

Community-Fossil

  • »Jonathan_Klein« ist der Autor dieses Themas

Beiträge: 3 820

  • Private Nachricht senden

1

07.05.2004, 12:57

Würfel aus Index und Vertex Buffer

Ich wollte als kleinen 3D Test einfach mal einen texturierten Würfel mit Hilfe von Index und Vertex Buffer erstellen. Aber es wird nix angezeigt! Ich hab schon Klassen geschrieben, die einen Zylinder oder einen Kegel mithilfe von Vertex Buffern erzeugen und anzeigen. Aber mit dem Indexbuffer und dem Würfel klappt es einfach nciht!
Wenn ich das Programm starte und im WIREFRAME Modus rendere, kann ich 3 Linien sehen. 2 laufen paralel auf der z-Achse (glaub ich) und eine auf der Y Achse (ziemlich sicher). So gehen so ungefähr vom Ursprung aus (also da wo eigentlichd er Würfel angezeigt werden sollte) und haben eine unendliche Länge (die beiden paralellen laufen in der Ferne zusammen). Hier mal der Quellcode:

Cube.h

Quellcode

 
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

#pragma once

#include "Global.h"
#include "CDirect3D.h"

#define D3DFVF_CUBEVERTEX (D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1)

struct CubeVertex
{
    tbVector3 vPosition;
    D3DCOLOR Color;
    tbVector2 vTexture;
};

class CCube
{
public:
    CCube();
    ~CCube();
    void Init(LPDIRECT3DDEVICE9 lpD3DDevice);
    void Render();
protected:
    LPDIRECT3DDEVICE9 m_lpD3DDevice;
    LPDIRECT3DVERTEXBUFFER9 m_lpVB;
    LPDIRECT3DINDEXBUFFER9 m_lpIB;
    LPDIRECT3DTEXTURE9 m_lpTexture;
};


Cube.cpp

Quellcode

 
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

#pragma once

#include "Cube.h"

CCube::CCube()
{
    m_lpD3DDevice=NULL;
    m_lpVB=NULL;
    m_lpIB=NULL;
}

CCube::~CCube()
{
    if(NULL!=m_lpIB)
    {
        m_lpIB->Release();
        m_lpIB=NULL;
    }
    if(NULL!=m_lpVB)
    {
        m_lpVB->Release();
        m_lpVB=NULL;
    }
    if(NULL!=m_lpTexture)
    {
        m_lpTexture->Release();
        m_lpTexture=NULL;
    }
}

void CCube::Init(LPDIRECT3DDEVICE9 lpD3DDevice)
{
    m_lpD3DDevice=lpD3DDevice;

    //Vertex Buffer erstellen und füllen
    if(FAILED(m_lpD3DDevice->CreateVertexBuffer(sizeof(CubeVertex)*8, 0, D3DFVF_CUBEVERTEX, D3DPOOL_MANAGED, &m_lpVB, NULL)))
    {
        Error("Fehler beim erstellen des Vertex Buffers!");
    }
    CubeVertex* Vertices;

    m_lpVB->Lock(0, 0, (void**)&Vertices, 0);
    
    //Direkt in den Vertex Buffer schreiben

    //Vertices für die Vorderseite:
    Vertices[0].vPosition=tbVector3(0.0f, 0.0f, 0.0f);
    Vertices[0].vTexture=tbVector2(0.0f, 0.0f);
    Vertices[0].Color=0xff0000ff;//Blau

    Vertices[1].vPosition=tbVector3(1.0f, 0.0f, 0.0f);
    Vertices[1].vTexture=tbVector2(1.0f, 0.0f);
    Vertices[1].Color=0xff00ff00;//Grün

    Vertices[2].vPosition=tbVector3(0.0f, -1.0f, 0.0f);
    Vertices[2].vTexture=tbVector2(0.0f, 1.0f);
    Vertices[2].Color=0xff0000ff;//Blau

    Vertices[3].vPosition=tbVector3(1.0f, -1.0f, 0.0f);
    Vertices[3].vTexture=tbVector2(1.0f, 1.0f);
    Vertices[3].Color=0xff0000ff;//Blau


    //Vertices für die Hinterseite
    Vertices[4].vPosition=tbVector3(0.0f, 0.0f, 1.0f);
    Vertices[4].vTexture=tbVector2(0.0f, 0.0f);
    Vertices[4].Color=0xff0000ff;//Blau

    Vertices[5].vPosition=tbVector3(1.0f, 0.0f, 1.0f);
    Vertices[5].vTexture=tbVector2(1.0f, 0.0f);
    Vertices[5].Color=0xff00ff00;//Grün

    Vertices[6].vPosition=tbVector3(0.0f, -1.0f, 1.0f);
    Vertices[6].vTexture=tbVector2(0.0f, 1.0f);
    Vertices[6].Color=0xff0000ff;//Blau

    Vertices[7].vPosition=tbVector3(1.0f, -1.0f, 1.0f);
    Vertices[7].vTexture=tbVector2(1.0f, 1.0f);
    Vertices[7].Color=0xff0000ff;//Blau

    m_lpVB->Unlock();


    //IndexBuffer erstellen und füllen
    if(FAILED(m_lpD3DDevice->CreateIndexBuffer(sizeof(unsigned short)*12, 0, D3DFMT_INDEX16, D3DPOOL_MANAGED, &m_lpIB, NULL)))
    {
        Error("Fehler beim erstellen des Index Buffers!");
    }
    unsigned short* Indices=NULL;
    m_lpIB->Lock(0, 0, (void**)&Indices, 0);

    unsigned short tIndices[]={0, 1, 2,//Vorderseite
                                1, 3, 2,

                                1, 5, 7,//rechte Seite
                                7, 3, 1};
    for(int i=0; i<(sizeof(tIndices)/sizeof(unsigned short)); i++)//Diese Schleife kopier tIndices in Indices
    {
        Indices[i]=tIndices[i];
    }

    m_lpIB->Unlock();

    //Die Textur laden
    if(FAILED(D3DXCreateTextureFromFileEx(m_lpD3DDevice, "baum.png", D3DX_DEFAULT, D3DX_DEFAULT, 1, 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_FILTER_POINT, D3DX_FILTER_POINT, 0, NULL, NULL, &m_lpTexture)))
    {
        Error("Textur konnte nicht geladen werden!");
    }
}

void CCube::Render()
{
    //Das VertexFormat festlegen
    if(FAILED(m_lpD3DDevice->SetFVF(D3DFVF_CUBEVERTEX)))
    {
        Error("SetFVF fehlgeschlagen!");
    }
    
    //VertexBuffer angeben:
    m_lpD3DDevice->SetStreamSource(0, m_lpVB, 0, sizeof(D3DFVF_CUBEVERTEX));

    m_lpD3DDevice->SetTexture(0, m_lpTexture);
    
    //IndexBuffer angeben:
    m_lpD3DDevice->SetIndices(m_lpIB);
    if(FAILED(m_lpD3DDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 8, 0, 4)))
    {
        Error("Fehler beim indizierten zeichnen!");
    }

    m_lpD3DDevice->SetTexture(0, NULL);
}