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!

Fehler beim Assimp Loader

  • 1
  • 2

Werbeanzeige

Male

Treue Seele

Beiträge: 166

  • Private Nachricht senden

11

29.12.2010, 18:58

Vllt liegt es auch daran das du nichts siehst, weil du das Model auf 0, 0, -20 setzt, vielleicht solltes du es auf 0, 0, 20 setzen. Ich weiß jetzt zwar nicht wie du deine Kameramatrix setzt, aber wenn die auf der Einheitsmatrix gesetzt ist, dann kannst du nichts sehen.

Mfg Male

Patrick Egli

Treue Seele

  • »Patrick Egli« ist der Autor dieses Themas

Beiträge: 161

Wohnort: Rainstrasse 38

  • Private Nachricht senden

12

29.12.2010, 19:39

Zitat

Kann es sein, dass BeginScene() und EndScene() in der Renderfunktion fehlen oder habe ich die übersehen?

Nein, BeginScene() und EndScene() habe ich natürlich nicht vergessen. Ich habe sie nur nicht gepostet.

Zitat

Vllt liegt es auch daran das du nichts siehst, weil du das Model auf 0, 0, -20 setzt, vielleicht solltes du es auf 0, 0, 20 setzen. Ich weiß jetzt zwar nicht wie du deine Kameramatrix setzt, aber wenn die auf der Einheitsmatrix gesetzt ist, dann kannst du nichts sehen.

Nein die Position sollte bei (0, 0, -20) kein Problem darstellen. Zudem habe ich eine verschiebbare Kamera erzeugt, die ich mit den Maustasten bewegen kann.

Was ist bei meinem Code falsch?

Jonathan_Klein

Community-Fossil

Beiträge: 3 820

  • Private Nachricht senden

13

30.12.2010, 11:12

Versuch erstmal irgendwas mit Vertex/Indexbuffer zu rendern. Ein Dreieck. Ganz ohne Assimp. Sobald das läuft, weißt du schonmal, dass diene Buffer gehen und kannst sie mit Daten aus Assimp füllen. Wenn dann was dargestellt wird, kannst du dich um Materialien kümmern.
Ahja, und benutze evtl. ein sehr einfaches Modell zum Testen. Dann kannst du die Vertexdaten beim Debuggen dir anschauen und abschätzen, ob sie richtig geladen wurden.
Lieber dumm fragen, als dumm bleiben!

Patrick Egli

Treue Seele

  • »Patrick Egli« ist der Autor dieses Themas

Beiträge: 161

Wohnort: Rainstrasse 38

  • Private Nachricht senden

14

30.12.2010, 11:47

Es, ist so, dass ich bereits einen funktionierenden AssimpLoader habe, doch der hat noch keine do-while Schleife, welche alle Nodes des ganzen Modelles lädt.

Hier ist der Code, des funktionierenden Loaders:

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

bool CLoader::CreateMeshFromAssimp(aiMesh * quellMesh)
{
    HRESULT hResult;

    m_NumVertices = quellMesh->mNumVertices;

    D3DXMATRIX mWorld;

    D3DXMatrixTranslation(&mWorld, 0.0f, 0.0f, 0.0f);
    g_pD3DDevice->SetTransform(D3DTS_WORLD, &mWorld);

    // VerexBuffer erzeugen
    if(FAILED(hResult = g_pD3DDevice->CreateVertexBuffer((quellMesh->mNumVertices * sizeof(Vertex)),
                                                         D3DUSAGE_WRITEONLY,
                                                         VertexFVF,
                                                         D3DPOOL_MANAGED,
                                                         &vertices,
                                                         NULL)))
    {
        MessageBox(NULL, "Fehler beim erzeugen des VertexBuffers vom Mesh", "Fehler aufgetreten",
                   MB_OK | MB_ICONEXCLAMATION);
    }

    Vertex * vertex;

    vertices->Lock(0, 0, (VOID**)&vertex, 0);

    for(size_t a= 0; a < quellMesh->mNumVertices; ++a)
    {
        vertex->posx = quellMesh->mVertices[a].x;
        vertex->posy = quellMesh->mVertices[a].y;
        vertex->posz = quellMesh->mVertices[a].z;

        if(quellMesh->HasNormals())
        {
            vertex->normalx = quellMesh->mNormals[a].x;
            vertex->normaly = quellMesh->mNormals[a].y;
            vertex->normalz = quellMesh->mNormals[a].z;
        }

        if(quellMesh->HasTextureCoords(0))
        {
            vertex->tu = quellMesh->mTextureCoords[0][a].x;
            vertex->tv = quellMesh->mTextureCoords[0][a].y;
        }

        vertex++;
    }

    vertices->Unlock();

    m_NumFaces = quellMesh->mNumFaces;

    // IndexBuffer erzeugen
    if(FAILED(hResult = g_pD3DDevice->CreateIndexBuffer((quellMesh->mNumFaces * 3 * sizeof(unsigned int)),
                                                        D3DUSAGE_WRITEONLY,
                                                        D3DFMT_INDEX32,
                                                        D3DPOOL_MANAGED,
                                                        &indices,
                                                        NULL)))
    {
        MessageBox(NULL, "Fehler beim Erzeugen des IndexBuffers", "Fehler aufgetreten",
                   MB_OK | MB_ICONEXCLAMATION);
    }

    unsigned int * index;
    
    indices->Lock(0, 0, (VOID**)&index, 0);

    for(size_t a = 0; a < quellMesh->mNumFaces; ++a)
    {
        *index++ = quellMesh->mFaces[a].mIndices[0];
        *index++ = quellMesh->mFaces[a].mIndices[1];
        *index++ = quellMesh->mFaces[a].mIndices[2];
    }

    indices->Unlock();

    m_MaterialIndex = quellMesh->mMaterialIndex;

    return true;
}


Ich denke, das Problem beim neuen Loader liegt an den Zeigern auf die Vertex-Struktur und auf unsigned int. Denn wenn ein Modell mehrere Nodes hat, dann erzeugt es mir mehrere Male neuen Speicher mit new.

Hier der Code:

C-/C++-Quelltext

 
1
2

Vertex * vertex;
    unsigned int * index;


C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

do
    {
// ......

vertex = new Vertex[rawMeshes[meshID[0]]->mNumVertices]; // Hier

        for(UINT j = 0; j < rawMeshes[meshID[0]]->mNumVertices; ++j)
        {
// ...

}

index = new unsigned int[rawMeshes[meshID[0]]->mNumFaces * 3]; // und hier

        for(UINT j = 0; j < rawMeshes[meshID[0]]->mNumFaces; ++j)
        {
// ...

}
    } while(i < sceneroot->mNumChildren);


Oder ist das eine falsche Vermutung?

Patrick Egli

Treue Seele

  • »Patrick Egli« ist der Autor dieses Themas

Beiträge: 161

Wohnort: Rainstrasse 38

  • Private Nachricht senden

15

02.01.2011, 15:49

Ich habe meinen Code nun etwas abgeändert, doch es wird immer noch kein Model mit mehreren Meshes gerendert.

Hier ist der Code:

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

bool CLoader::CreateAssimpMesh(const aiScene * Scene)
{
    D3DVERTEXELEMENT9 simple_decl[] =
    {
      {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
      {0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0},
      {0, 24, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
      D3DDECL_END()
    };

    aiMesh ** rawMeshes = Scene->mMeshes;
    aiMaterial ** materials = Scene->mMaterials;

    UINT * meshID;
    UINT * materialID;

    aiNode * sceneroot = Scene->mRootNode;
    aiNode ** children = sceneroot->mChildren;
    aiNode * child;

    Vertex * vertex;
    unsigned int * index;

    UINT i = 0;
    bool rootnode = true;

    D3DXMATRIX mWorld;

    D3DXMatrixTranslation(&mWorld, 0.0f, 0.0f, 0.0f);
    g_pD3DDevice->SetTransform(D3DTS_WORLD, &mWorld);

    while(i < sceneroot->mNumChildren)
    {
        if(rootnode)
        {
            child = sceneroot;
            rootnode = false;
        }
        else
        {
            child = children[i];
            ++i;
        }
        if(child->mNumMeshes > 1)
        {
            MessageBoxA(NULL, "Error: a node in the scene graph consist of multiple meshes.\nLoading will continue, but with possible errors!", "Error parsing file!", 
                        MB_ICONHAND | MB_OK);
        }
        if(!(child->mNumMeshes > 0))
        {
            continue;
        }

        meshID = child->mMeshes;

        vertex = new Vertex[rawMeshes[meshID[0]]->mNumVertices];

        for(UINT j = 0; j < rawMeshes[meshID[0]]->mNumVertices; ++j)
        {
            vertex[j].posx = rawMeshes[meshID[0]]->mVertices[j].x;
            vertex[j].posy = rawMeshes[meshID[0]]->mVertices[j].y;
            vertex[j].posz = rawMeshes[meshID[0]]->mVertices[j].z;

            if(rawMeshes[meshID[0]]->HasNormals())
            {
                vertex[j].normalx = rawMeshes[meshID[0]]->mNormals[j].x;
                vertex[j].normaly = rawMeshes[meshID[0]]->mNormals[j].y;
                vertex[j].normalz = rawMeshes[meshID[0]]->mNormals[j].z;
            }

            if(rawMeshes[meshID[0]]->HasTextureCoords(0))
            {
                vertex[j].tu = rawMeshes[meshID[0]]->mTextureCoords[0][j].x;
                vertex[j].tv = rawMeshes[meshID[0]]->mTextureCoords[0][j].y;
            }
        }

        m_NumVertices = rawMeshes[meshID[0]]->mNumVertices;
        m_NumFaces = rawMeshes[meshID[0]]->mNumFaces;

        D3DXCreateMesh(m_NumFaces, m_NumVertices, D3DXMESH_WRITEONLY, simple_decl, g_pD3DDevice, &m_pMesh);

        VOID * pVoid;

        m_pMesh->LockVertexBuffer(0, (VOID**)&pVoid);
        memcpy(pVoid, vertex, sizeof(Vertex));
        m_pMesh->UnlockVertexBuffer();

        index = new unsigned int[rawMeshes[meshID[0]]->mNumFaces * 3];

        for(UINT j = 0; j < rawMeshes[meshID[0]]->mNumFaces; ++j)
        {
            if(rawMeshes[meshID[0]]->mFaces[j].mNumIndices != 3)
            {
                MessageBoxA(NULL, "Error: not all faces are triangulated!", "Triangulation error", 
                            MB_ICONHAND | MB_OK);
                                                            
                return false;
            }

            index[j*3+0] = rawMeshes[meshID[0]]->mFaces[j].mIndices[0];
            index[j*3+1] = rawMeshes[meshID[0]]->mFaces[j].mIndices[1];
            index[j*3+2] = rawMeshes[meshID[0]]->mFaces[j].mIndices[2];
        }

        m_pMesh->LockIndexBuffer(0, (VOID**)&pVoid);
        memcpy(pVoid, index, 3*sizeof(unsigned int));
        m_pMesh->UnlockIndexBuffer();
    }
}


Hier der Aufruf der Funktion CreateAssimpMesh in der Funktion CreateScene:

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

bool CLoader::CreateScene(string & Filename)
{
    Assimp::Importer importer;

    m_pModel = importer.ReadFile( Filename, 
        aiProcess_CalcTangentSpace  |
        aiProcess_Triangulate |
        aiProcess_MakeLeftHanded |
        aiProcess_JoinIdenticalVertices |
        aiProcess_SortByPType |
        aiProcess_CalcTangentSpace |
        aiProcess_JoinIdenticalVertices |
        aiProcess_GenSmoothNormals |
        aiProcess_LimitBoneWeights |
        aiProcess_RemoveRedundantMaterials |
        aiProcess_OptimizeMeshes);

    aiNode * nd = m_pModel->mRootNode;

    if(m_pModel->HasMeshes())
    {
        CreateAssimpMesh(m_pModel);
    }

    return true;
}


Kann mir jemand sagen, was ich hier falsch programmiert habe? Nach längerem Suchen habe ich immer noch keine Lösung gefunden.

LG Patrick

Werbeanzeige

  • 1
  • 2

Ähnliche Themen