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!

Bildschirm bleibt schwarz!

Werbeanzeige

Rone2006

Frischling

  • »Rone2006« ist der Autor dieses Themas

Beiträge: 2

Wohnort: Bremen

  • Private Nachricht senden

1

10.06.2007, 18:22

Bildschirm bleibt schwarz!

Hallo,

ich grüße euch.
Ich arbeite erst seit kurzem mit DirectX, und hab ein Problem.
Das Problem ist, das mein Cube einfach nich gezeichnet wird. Hardcoded funktioniert es, doch
nun bin ich dabei eine kleine Engine zu schreiben, doch der Bildschirm bleibt schwarz...
Ich bin schon seit Stunden am Debuggen, aber kann den Fehler einfach nicht finden.
Vieleicht habe ich ja was grundlegendes verpeilt...

Ich bin schon am verzweifeln...kann mir vieleicht jemand einen Tipp geben?
Hier mal teile meines codes:

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

void CMesh::CreateCube()                    
{
    CSurface* surf = new CSurface();

    // Vertices hinzufügen

    surf->AddVertex(-1, 1,-1);
    surf->AddVertex(-1, 1, 1);
    surf->AddVertex( 1, 1, 1);
    surf->AddVertex( 1, 1,-1);
    surf->AddVertex(-1,-1,-1);
    surf->AddVertex(-1,-1, 1);
    surf->AddVertex( 1,-1, 1);
    surf->AddVertex( 1,-1,-1);

    // Indices hinzufügen

    surf->AddTriangle(0,3,7); surf->AddTriangle(0,7,4); // Vorderseite

    surf->AddTriangle(2,1,5); surf->AddTriangle(2,5,6); // Hinterseite

    surf->AddTriangle(1,0,4); surf->AddTriangle(1,4,5); // Linke Seite

    surf->AddTriangle(3,2,6); surf->AddTriangle(3,6,7); // Rechte Seite

    surf->AddTriangle(0,1,2); surf->AddTriangle(0,2,3); // Oberseite

    surf->AddTriangle(6,5,4); surf->AddTriangle(6,4,7); // Unterseite



    this->AddSurface(surf);

}



int CSurface::AddVertex(float x, float y, float z, float u , float v , float w )
{

    CVertex1* tmpVertices = new CVertex1[nVertexCount+1];

    if ( m_pVertices != NULL)
        memcpy( (void*)tmpVertices, (void*)m_pVertices, nVertexCount*sizeof(CVertex1));

    tmpVertices[nVertexCount].pos      = D3DXVECTOR3(x,y,z);
    tmpVertices[nVertexCount].normal   = D3DXVECTOR3(0.0,0.0,0.0);
    tmpVertices[nVertexCount].tex0     = D3DXVECTOR3(u,v,0.0);
    tmpVertices[nVertexCount].diffuse  = 0xFFFFFFFF;
    tmpVertices[nVertexCount].specular = 0xFFFFFFFF;
    nVertexCount++;

    if ( m_pVertices != NULL)
        delete[] m_pVertices;


    m_pVertices = tmpVertices;
    return nVertexCount;

}


int CSurface::AddTriangle(int v0, int v1, int v2)
{
    unsigned short* tmpIndices = new unsigned short[nIndexCount+3];
    
    if ( m_pIndices != NULL )
        memcpy( (void*)tmpIndices, (void*)m_pIndices, nIndexCount*sizeof(unsigned short));

    tmpIndices[nIndexCount] = v0;
    tmpIndices[nIndexCount+1] = v1;
    tmpIndices[nIndexCount+2] = v2;
    nIndexCount+=3;
    
    if ( m_pIndices != NULL )
        delete[] m_pIndices;

    m_pIndices = tmpIndices;
    return nIndexCount/3;

}


HRESULT CCamera::Update()
{
    
    m_pDevice->SetRenderState(D3DRS_ZENABLE,TRUE);
    m_pDevice->SetRenderState(D3DRS_LIGHTING,FALSE);
    m_pDevice->SetRenderState(D3DRS_FOGENABLE, FALSE);

    m_pDevice->SetViewport(&m_ViewPort);

    // Sichtkegel definieren

    D3DXMatrixPerspectiveFovLH(&m_mProj,
                               D3DX_PI/4,
                               (float)m_ViewPort.Width / (float)m_ViewPort.Height,
                               range_near,
                               range_far );
    
    m_pDevice->SetTransform(D3DTS_PROJECTION,&m_mProj);

    // Transform vectors based on camera's rotation matrix

    D3DXVECTOR3 vWorldUp, vWorldAhead;
    D3DXVECTOR3 vLocalUp    = D3DXVECTOR3(0,1,0);
    D3DXVECTOR3 vLocalAhead = D3DXVECTOR3(0,0,1);
    D3DXVec3TransformCoord( &vWorldUp, &vLocalUp, &mRotation );
    D3DXVec3TransformCoord( &vWorldAhead, &vLocalAhead, &mRotation );

    // Update the lookAt position based on the eye position 

    m_vLookAt = m_vPos + vWorldAhead;

    // Update the view matrix

    D3DXMatrixLookAtLH( &m_mView, &m_vPos, &m_vLookAt, &vWorldUp );
    
    m_pDevice->SetTransform(D3DTS_VIEW,&m_mView);

    return 0;

}

void CSurface::Render()
{

    HRESULT     hResult;


    // Vertex-Format setzen

        m_pDevice->SetFVF( D3DFVF_VERTEX1);
    
    // rendern

    
    hResult = m_pDevice->DrawIndexedPrimitiveUP(D3DPT_TRIANGLELIST,       
                            0,                       
                            nIndexCount,              
                            nIndexCount/3,         
                            m_pIndices,              
                            D3DFMT_INDEX16,          
                            m_pVertices,            
                            sizeof(CVertex1));       
    

    

}

DarioFrodo

Treue Seele

Beiträge: 349

Wohnort: Kerkau, 100km nördlich von Magdeburg

Beruf: Selbstständig

  • Private Nachricht senden

2

10.06.2007, 19:17

Allo Rone2006,

sieht für mich funktionell aus dein Code.
Also, wenn du den Cube in der Render Funktion direkt zeichnst (Als Indiced Primitiv) dann geht es?
Hast du mal beim debuggen überprüft, ob m_pVertices und m_pIndices die richtigen Vertices und Indices haben?

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13

int i = 0;
for(i = 0; i < nIndexCount/3; i++)
{
       Log.WriteToLog("Vertex: %d  x: %f y: %f z: %f", i, m_pVertices[i].x, m_pVertices[i].y, m_pVertices[i].z);
       //Oder alternativ, wenn es eine Konsolenanwendung ist, geht auch

       printf("Vertex: %d  x: %f y: %f z: %f", i m_pVertices[i].x, m_pVertices[i].y, m_pVertices[i].z);
}
for(i = 0; i < nIndexCount; i++)
{
       Log.WriteToLog("Index: %d  %d", i, m_pIndices[i]);
      //oder

       printf("Index: %d  %d", i, m_pIndices[i]);
}

Wenn das nicht geht, würde ich empfehlen das in eine Log Datei zu schreiben. Ein Log-System sollte deine Engine auf jeden Fall haben.

PS: Dein Code scheint mir stark Speicherfragmentierend. Vielleicht solltets du nicht so oft, immer größeren Speicher reservieren, sondern von Anfang an gleich mehr?
Erst wenn der letzte Fluss vergiftet,
der letzte Baum gefällt,
der letzte Fisch gefangen,
dann werdet ihr merken, dass man Geld nicht essen kann

Man verkauft die Erde nicht, auf der die Menschen wandeln.

- Indianerweisheiten

Ich bin auch ein einhornimmond ;)

Rone2006

Frischling

  • »Rone2006« ist der Autor dieses Themas

Beiträge: 2

Wohnort: Bremen

  • Private Nachricht senden

3

10.06.2007, 20:06

Hi,
ja das werde ich machen. Ich nehm erstmal das Log_System aus der Tribase Engine ;)
Wenns dann nicht geht, mach ich nochmal ein kleines Testprogramm...

Zitat


PS: Dein Code scheint mir stark Speicherfragmentierend. Vielleicht solltets du nicht so oft, immer größeren Speicher reservieren, sondern von Anfang an gleich mehr?

Hmm, bei den Primitives(Cube, Sphere usw.) werde ich das noch anders machen, aber generell soll halt die Möglichkeit bestehen einfach Dreiecke hinzuzufügen, ohne sich um Speicherreservierung kümmern zu müssen...

DarioFrodo

Treue Seele

Beiträge: 349

Wohnort: Kerkau, 100km nördlich von Magdeburg

Beruf: Selbstständig

  • Private Nachricht senden

4

10.06.2007, 20:31

Zitat

aber generell soll halt die Möglichkeit bestehen einfach Dreiecke hinzuzufügen, ohne sich um Speicherreservierung kümmern zu müssen...


Es kann ja ruhig intern geschehen, aber vielleicht sollte die Surface Klasse schon von Anfang an eine gewisse Speichermenge automtisch reservieren, oder man gibt beim Init eine Mögliche Anzahl von Vertices an.


C-/C++-Quelltext

 
1
2

CSurface TestSur;
TestSur.Init(200, 800); //Am Anfang Speicher für 200 Vertices und 800 Inidices reservieren.
Erst wenn der letzte Fluss vergiftet,
der letzte Baum gefällt,
der letzte Fisch gefangen,
dann werdet ihr merken, dass man Geld nicht essen kann

Man verkauft die Erde nicht, auf der die Menschen wandeln.

- Indianerweisheiten

Ich bin auch ein einhornimmond ;)

Werbeanzeige