ZFX
ZFX Neu
Home
Community
Neueste Posts
Chat
FAQ
IOTW
Tutorials
Bücher
zfxCON
ZFXCE
Mathlib
ASSIMP
NES
Wir über uns
Impressum
Regeln
Suchen
Mitgliederliste
Membername:
Passwort:
Besucher:
4440703
Jetzt (Chat):
22 (0)
Mitglieder:
5239
Themen:
24223
Nachrichten:
234554
Neuestes Mitglied:
-insane-

ZFX
Coding-Foren
OpenGL API + SDL
Re: OpenGL Loader der das Assimp ai Format darstellen kann
Normal
AutorThema
Lowtraxx Offline
ZFX'ler


Registriert seit:
24.05.2002

Deutschland
OpenGL Loader der das Assimp ai Format darstellen kannNach oben.
Hi,

wollte fragen, ob schon jemand sowas implementiert, bzw irgendwo in the wild gesehen hat.

Danke und Grüße

low
05.11.2008, 01:18:31 Uhr
ToshSoft New Media, Webdesign and more...
rave3d Offline
ZFX'ler


Registriert seit:
29.10.2005

Bayern
279915923 matthias.gubisch@gmx.de
Re: OpenGL Loader der das Assimp ai Format darstellen kannNach oben.
Hallo

Assimp ai ist kein eigenes Format sondern nur eine Datenstrucktur aus der du dir die Daten die du brauchst hohlen kannst

Assimp ist eine Bibliotek die verschieden Formate laden kann und sie in dieser Datenstrucktur zur weiterverarbeitung zur Verfuegung stellt

Gruesse
Matthias
05.11.2008, 08:33:49 Uhr
Aramis Offline
ZFX'ler


Registriert seit:
14.03.2007

Baden-Württemberg
406712329
Re: OpenGL Loader der das Assimp ai Format darstellen kannNach oben.
"ai"-Format Irgendwie werden unsere aiXXX-Datenstrukturen langsam aber sicher ein Schlagwort. Den Begriff hab ich jetzt schon in mindestens 3 Foren gesehen.

Es ist so wie rave es gesagt hat. Wenn du geduldig bist gibt's aber evtl. einen kleinen Lichtblick: Ich sitze momentan an einem Rewrite unseres Viewers, der dann auch Linux und somit OpenGL unterstützen wird. Ich bin noch nicht sonderlich weit, aber ich plane den OpenGL-Renderingteil codemäßig zu separieren und ihn somit ohne Mehraufwand auch für andere Programme nutzbar zu machen.

Gruß,
Alex
05.11.2008, 10:04:47 Uhr
Lowtraxx Offline
ZFX'ler


Registriert seit:
24.05.2002

Deutschland
Re: OpenGL Loader der das Assimp ai Format darstellen kannNach oben.
Das wäre super. Ich schreibe momentan meine Bakkalaureatsarbeit über Headtracking mit der WiiMote, jedoch nicht mit den üblichen targests, sondern so, das man quasi modelle eines beliebigen formats laden kann, und diese dann darstellen und mithilfe der infrarotbrille betrachten kann. Bisher hab ich das mit dem VTK realisiert, dieser ist jedoch ziemlich bloated und schlecht dokumentiert... Dann bin ich gestern über assimp gestolpert. Mein Problem ist, das mein core zwar fertig ist, aber ich mit Modelling und Model-loading nicht wirklich vertraut bin. Deshalb hab ich gehofft, das mir hier vielleicht jemand weiterhelfen kann. Leider ist mein Abgabetermin für den praktischen Teil bereits in zwei Wochen, also werd ich vorerst wohl beim VTK stecken bleiben. Bin aber trotzdem dankbar für jede Hilfe (Tutorials zu dem Thema o.ä)

Danke und Grüße
05.11.2008, 10:20:01 Uhr
ToshSoft New Media, Webdesign and more...
rave3d Offline
ZFX'ler


Registriert seit:
29.10.2005

Bayern
279915923 matthias.gubisch@gmx.de
Re: OpenGL Loader der das Assimp ai Format darstellen kannNach oben.
Importieren tut ja Assimp fuer dich
du musst dir eigentlich nur aus der bereitgestellten Datenstucktur deine Vertex und Index Buffer bzw eine Materialen/Shader erstellen

05.11.2008, 10:47:49 Uhr
Lowtraxx Offline
ZFX'ler


Registriert seit:
24.05.2002

Deutschland
Re: OpenGL Loader der das Assimp ai Format darstellen kannNach oben.
1. Habe jetzt folgenden Quellcode, um die meshes auszulesen:

Code:
for(unsigned int i = 0; i < m_pAIScene->mNumMeshes; i++) {
        for(unsigned int j = 0; j < m_pAIScene->mMeshes[i]->mNumFaces; j++) {
            if(m_pAIScene->mMeshes[i]->mFaces[j].mNumIndices == 3) {
                glBegin(GL_TRIANGLES);
                    glVertex3f(m_pAIScene->mMeshes[i]->mVertices[m_pAIScene->mMeshes[i]->mFaces[j].mIndices[0]].x / 200, 
                        m_pAIScene->mMeshes[i]->mVertices[m_pAIScene->mMeshes[i]->mFaces[j].mIndices[0]].y / 200,
                        m_pAIScene->mMeshes[i]->mVertices[m_pAIScene->mMeshes[i]->mFaces[j].mIndices[0]].z / 200);
                    glVertex3f(m_pAIScene->mMeshes[i]->mVertices[m_pAIScene->mMeshes[i]->mFaces[j].mIndices[1]].x / 200, 
                        m_pAIScene->mMeshes[i]->mVertices[m_pAIScene->mMeshes[i]->mFaces[j].mIndices[1]].y / 200,
                        m_pAIScene->mMeshes[i]->mVertices[m_pAIScene->mMeshes[i]->mFaces[j].mIndices[1]].z / 200);
                    glVertex3f(m_pAIScene->mMeshes[i]->mVertices[m_pAIScene->mMeshes[i]->mFaces[j].mIndices[2]].x / 200, 
                        m_pAIScene->mMeshes[i]->mVertices[m_pAIScene->mMeshes[i]->mFaces[j].mIndices[2]].y / 200,
                        m_pAIScene->mMeshes[i]->mVertices[m_pAIScene->mMeshes[i]->mFaces[j].mIndices[2]].z / 200);
                glEnd();
            } else {
                glBegin(GL_POLYGON);
                    for(unsigned int k = 0; k < m_pAIScene->mMeshes[i]->mFaces[j].mNumIndices; k++) {    
                        glVertex3f(m_pAIScene->mMeshes[i]->mVertices[m_pAIScene->mMeshes[i]->mFaces[j].mIndices[k]].x / 200, 
                            m_pAIScene->mMeshes[i]->mVertices[m_pAIScene->mMeshes[i]->mFaces[j].mIndices[k]].y / 200,
                            m_pAIScene->mMeshes[i]->mVertices[m_pAIScene->mMeshes[i]->mFaces[j].mIndices[k]].z / 200);
                    }
                glEnd();
            }
        }
    }


Kann mir jetzt jemand auf die sprünge helfen wie ich farben und texturen richtig dazubringe.

2. Kann ich dem meshbrei irgendwie noch ne beleuchtung zuweisen, momentan sehen meine modelle nämlich nur wie schatten aus

DankeDankeDanke und sorry für die Fragerei, aber ich hab aus der doku schon soviel rausgelesen wie ich kann
05.11.2008, 15:26:59 Uhr
ToshSoft New Media, Webdesign and more...
rave3d Offline
ZFX'ler


Registriert seit:
29.10.2005

Bayern
279915923 matthias.gubisch@gmx.de
Re: OpenGL Loader der das Assimp ai Format darstellen kannNach oben.
Also Farben gleich Materialien oder?

wenn ich mich nicht irre gibt es in aiScene auch ein Array vom Typ aiMaterial und jeder mesh sollte eigententlich den Index iwo enthalten haben wo in diesem Array sein Material steht.

Bei den Texturen sollte dir Aramis besser helfen koennen als ich

Hmm entweder du definierst dir selber eine Lichtquelle fuer deine Scene oder manche Formate unterstuetzen lichtquellen und wenn die mit abgespeichert wurden dann sollte der Loader die auslesen und ebenfalls in der Datenstruktur parken
Sofern das schon fertig ist bin da grad nicht auf dem aktuellen Stand. Aber sonst musst du dich selber um deine Beleuchtung kuemmern
05.11.2008, 15:41:18 Uhr
Schrompf Offline
ZFX'ler


Registriert seit:
04.04.2006

Sachsen
Re: OpenGL Loader der das Assimp ai Format darstellen kannNach oben.
Für Beleuchtung brauchst Du zumindest noch Normalen pro Vertex. Falls Deine Modelldateien keine enthalten, kannst Du einen Assimp-Post Processing Step benutzen, um Dir welche erzeugen zu lassen. Allgemein ist sind Texturierung, Beleuchtung und andere Anzeigeeffekte kein Thema von Assimp, sondern obliegen Dir als OpenGL-Programmierer. Assimp stellt Dir die Texturkoordinaten, Normalen, Tangenten und was Du sonst noch brauchst, aber die Beleuchtungsberechnung musst Du dann schon selbst machen. Bei OpenGL ohne Shader gibt es da ja ein Rudel simple Funktionen namens glLight() und so weiter. Ich kenne die exakten Namen nicht, aber der Teil von OpenGL ist so dermaßen alt, dass es dazu viel Doku im Netz geben sollte.

Die Benutzung wäre dann wie oben, nur dass Du *vor* dem glVertex-Aufruf noch glNormal3f() und glTexCoord2f() aufrufen musst. Und ich empfehle der Lesbarkeit wegen, die gängigen Zeiger in Hilfsvariablen rauszuziehen Etwa so:

Code:
const aiMesh* mesh = m_pAIScene->mMeshes[i];
for( unsigned int j = 0; j < mesh->mNumFaces; j++)
{
  const aiFace& face = mesh->mFaces[j];
  if( face.mNumIndices != 3)
    continue;

  unsigned int p1 = face.mIndices[0];
  glNormal3f( mesh->mNormals[p1].x, mesh->mNormals[p1].y, mesh->mNormals[p1].z);
  glVertex3f( mesh->mVertices[p1].x, mesh->mVertices[p1].y, mesh->mVertices[p1].z);

  // weiter mit den anderen Punkten...
}


Den Teil für Polygone kannst Du knicken, wenn Du beim Laden zusätzlich aiProcess_Triangulate angibst. Dann werden alle Mehr-Als-Drei-Ecke auf Dreiecke aufgeteilt und gut. Es gibt einen anderen Step, der auch Linien und Punkte (also Faces mit mNumIndices < 3) beim Laden entfernt, so dass Du Dir sogar das if oben ersparen kannst.

Nebenbei: momentan zeichnest Du nur die Meshes isoliert. Theoretisch gibt es aber eine Node-Struktur, wobei jeder Node Meshes haben kann. Die Nodes geben die relative Positionierung der Meshes untereinander an. Wenn Du die nicht beachtest, sieht die dadurch entstehende Szene evtl. seltsam aus... Allgemein wird das hier jetzt aber eher ein OpenGL-Einführungskurs als tatsächliche Hilfe zu Assimp, deswegen hör ich hier erstmal auf.

Bye, Thomas
05.11.2008, 17:12:35 Uhr
Dreamworlds Development
Aramis Offline
ZFX'ler


Registriert seit:
14.03.2007

Baden-Württemberg
406712329
Re: OpenGL Loader der das Assimp ai Format darstellen kannNach oben.
Da es offenbar der Quell aller Verwirrung zu sein scheint, hier nochmal ausführlich die Struktur unseres Material & Farbsystems.

Code:
aiMaterial
{
   liste von keys die verschiedene eigenschaften repräsentieren
   sie sind vollständig optional und können über Hilfsfunktionen
   wie aiGetMaterialFloat() ausgelesen werden. Der Witz dran:
   Nur die wenigsten werden alle Eigenschaften unterstützen.
   Diese können aber einfach ignoriert werden.
   

   Texturen werden auch über Keys angegeben - es gibt 8 verschiedene
   Typen davon: diffuse, specular, ambient, emissive, normal, height,
   opacity, shininess. Das was die meisten als Textur bezeichnen
   würden ist für uns eine diffuse Textur.

   Der Texturkey enthält den Pfad zur Textur - oder einen String
   der Form \"*\". In diesem Fall ist die Textur im 
   Modellfile enthalten gewesen und Assimp hat sie gleich geladen
   weil es ja sonst keine Möglichkeit gäbe an sie dranzukommen.
    Ist dann ein Index in das mTexture array der aiScene.
}

aiMesh
{
   [sonstige vertexkomponenten wie position, normale, uv ...]

   vertexfarben   - optional. Bis zu 4, ihre exakte Verwendung
   hängt vom Programm ab. Angedacht ist es so dass zumindest
   der erste Farbkanal per-vertex mit dem Ergebnis der
   diffusen Beleuchtungsgleichung multipliziert wird.

   material index - gibt an welches Material für das Zeichnen
   des Meshes zu verwenden ist.
}

aiTexture
{
   Eingebettete Texturen existieren in 2 Varianten:
   Entweder liefert Assimp direkt die Farbdaten als RGBA8
   Array. Oder aber es ist eine komprimierte Textur
   z.B. im PNG-Format. Assimp hat keinen Texturdecoder integriert 
  (wie z.B. DevIL) und das ist auch gut so denn es
  wäre eine riesige Abhängigkeit.
}

aiScene
{
   Liste der Materialien
   Liste aller Meshes

   [sonstiges]

   Liste aller Texturen
}


Ich hoffe damit etwas Klarheit bei allen zu schaffen.

Gruß,
Alex

2 Mal gendert, zuletzt am 05.11.2008, 18:00:06 Uhr von Aramis.
05.11.2008, 17:45:45 Uhr
Lowtraxx Offline
ZFX'ler


Registriert seit:
24.05.2002

Deutschland
Re: OpenGL Loader der das Assimp ai Format darstellen kannNach oben.
Hi, ich hab da nochmal ne Frage

Code:
for(unsigned int j = 0; j < mesh->mNumFaces; j++) {
            for(unsigned int m = 0; m < AI_MAX_NUMBER_OF_COLOR_SETS; m++) {
                if(mesh->mColors[m] != NULL) {
                    glColor4f(mesh->mColors[m]->r, mesh->mColors[m]->b, 
                        mesh->mColors[m]->g, mesh->mColors[m]->a);
                }
            }


Ich dachte so hol ich mir die farben aus dem Modell und mappe sie gleich auf den Opengl call. Aber als N00b schein ich da irgendwas falsch zu machen. Kann mir jemand sagen wie ich an die Farben des jew. Modells komme und Opengl sage es soll den entspechenden Polygon in der Farbe zeichnen?

thx und grüße

Oli
05.01.2009, 14:29:51 Uhr
ToshSoft New Media, Webdesign and more...
Aramis Offline
ZFX'ler


Registriert seit:
14.03.2007

Baden-Württemberg
406712329
Re: OpenGL Loader der das Assimp ai Format darstellen kannNach oben.
Hi,

wie man in OpenGL Polygone farbug kriegt, ist mir entfallen. glColor4f hört sich aber eigentlich ziemlich richtig an

Die Farben sind pro Vertex angegeben, d.h. der Vertex an Position aiMesh::mVertices[n] hat die Farbe aiMesh::mColors[0][n]. Die erste '0' deshalb weil ein Mesh mehrere Farbkanäle haben kann (z.B. für Vertexfarben + prebaked Occlusion). Was sie genau bedeuten ist in Assimp nicht genau spezifiziert, du kannst aber davon ausgehen dass der erste Kanal, aiMesh::mColors[0], stets die eigentlichen Vertexfarben - falls vorhanden - enthält.

Code:
for (alle faces n)
   for (alle indices m in dem face)
      VertexPosition( mesh->mVertices[m] )
      if (mesh->mColors[0])
         VertexFarbe (mesh->mColors[0][m])


Gruß,
Alex
05.01.2009, 15:09:21 Uhr
Lowtraxx Offline
ZFX'ler


Registriert seit:
24.05.2002

Deutschland
Re: OpenGL Loader der das Assimp ai Format darstellen kannNach oben.
Hi,

Danke für den Tip. Mein neues Problem ist, das
Code:
mesh->mColors[0]
immer 0 ist. Ich weiss aber sicher, das die Modelle die ich zu laden versuche Farben besitzen. Auch die Modelle im Assimp/Test Ordner zeigen keine Farben. Hat vielleicht jemand ne Idee was ich falsch mache?

Meine Funktion zum zeichnen sieht folgendermassen aus:

Code:
void WH_GLWidget::DrawNode(aiNode *node) {
    for(unsigned int i = 0; i < node->mNumMeshes; i++) {
        const aiMesh* mesh = m_pAIScene->mMeshes[node->mMeshes[i]];
        for(unsigned int j = 0; j < mesh->mNumFaces; j++) {

            for(unsigned int l = 0; l < m_pAIScene->mMaterials[mesh->mMaterialIndex]->mNumProperties; l++)
                ; // glMaterialfv(GL_FRONT, ...);

            const aiFace& face = mesh->mFaces[j];
            if(face.mNumIndices != 3)
                continue;

            unsigned int p1 = face.mIndices[0];
            unsigned int p2 = face.mIndices[1];
            unsigned int p3 = face.mIndices[2];

            glBegin(GL_TRIANGLES);
            // Point 1
            glNormal3f(mesh->mNormals[p1].x, 
                mesh->mNormals[p1].y,
                mesh->mNormals[p1].z);
            glVertex3f(mesh->mVertices[p1].x, 
                mesh->mVertices[p1].y,
                mesh->mVertices[p1].z);
            if(mesh->mColors[0]) {
                glColor4f(mesh->mColors[0][p1].r, mesh->mColors[0][p1].b, 
                    mesh->mColors[0][p1].g, mesh->mColors[0][p1].a);
            }

            // Point 2
            glNormal3f(mesh->mNormals[p2].x, 
                mesh->mNormals[p2].y,
                mesh->mNormals[p2].z);
            glVertex3f(mesh->mVertices[p2].x, 
                mesh->mVertices[p2].y,
                mesh->mVertices[p2].z);
            if(mesh->mColors[0]) {
                glColor4f(mesh->mColors[0][p2].r, mesh->mColors[0][p2].b, 
                    mesh->mColors[0][p2].g, mesh->mColors[0][p2].a);
            }

            // Point 3
            glNormal3f(mesh->mNormals[p3].x, 
                mesh->mNormals[p3].y,
                mesh->mNormals[p3].z);
            glVertex3f(mesh->mVertices[p3].x, 
                mesh->mVertices[p3].y,
                mesh->mVertices[p3].z);
            if(mesh->mColors[0]) {
                glColor4f(mesh->mColors[0][p3].r, mesh->mColors[0][p3].b, 
                    mesh->mColors[0][p3].g, mesh->mColors[0][p3].a);
            }
            glEnd();
        }
    }

    for(unsigned int i = 0; i < node->mNumChildren; i++)
        DrawNode(node->mChildren[i]);
}


Vielen Dank für die Hilfe
05.01.2009, 15:51:12 Uhr
ToshSoft New Media, Webdesign and more...
Aramis Offline
ZFX'ler


Registriert seit:
14.03.2007

Baden-Württemberg
406712329
Re: OpenGL Loader der das Assimp ai Format darstellen kannNach oben.
Hi,

Der Zeichencode ist aufjedenfall schonmal korrekt. Tatsache ist, es gibt nur sehr wenige Modelle, die überhaupt per-Vertex-Farben besitzen! Im Assimp-Test Ordner (ausgehend von der aktuellen SVN-Version) gibt es irgendwo im LWO-Ordner ein Modell das welche besitzt (hat irgendwas mit 'vertex colors' im Namen). AssimpView zeigt sie auch an - wenn das Modell bei dir aussieht als hätte ein Kleinkind sich an LightWave's Vertexpaint vergriffen, hast du alles richtig gemacht

Wenn keine Vertexfarben da sind, ist die Farbe im Normalfall in dem dem Mesh zugehörigen Material abgelegt:

Code:
scene->mMaterials[mesh->mMaterialIndex]


Über aiMaterial::Get() kommst du an die einzelnen Materialeigenschaften dran.

Gruß,
Alex

PS: Welche Assimp-Version benutzt du? Falls es die Beta ist, kann ich dir nur nahelegen mal die Revision 258 auszuprobieren. Zumindest ist sie auch hier im Einsatz, und es scheint ganz gut zu klappen

1 Mal gendert, zuletzt am 05.01.2009, 17:37:01 Uhr von Aramis.
05.01.2009, 17:30:19 Uhr
Normal


ZFX Community Software, Version 0.9.1
Copyright 2002-2003 by Steffen Engel