Also, ich hab ne Partikel-Engine, die Partikel zeichnen soll.
Das Tut sie auch, nur werden die Partikel nicht zum Betrachter
hin ausgerichtet :(

Quellcode:
glLoadIdentity();
// Kamera rotieren u Translieren
glRotatef(rot_x,1.0f,0.0f,0.0f);
glRotatef(rot_y,0.0f,1.0f,0.0f);
glTranslatef(xpos,ypos,zpos);

// Nu werden alle Partikel gezeichnet:

glBegin(GL_QUADS);
for(int k=0;k<num_partikel;k++)
RenderPartikel(&partikel[k]);
glEnd();

void RenderPartikel(CPartikel* p)
{
glPushMatrix()

glRotatef(-rot_x,1.0f,0.0f,0.0f);
glRotatef(-rot_y,0.0f,1.0f,0.0f);
glTranslatef(p->x,p->y,p->z);

glVertex3f(-p->m_size, p->m_size,0.0f);
glVertex3f( p->m_size, p->m_size,0.0f);
glVertex3f( p->m_size,-p->m_size,0.0f);
glVertex3f(-p->m_size,-p->m_size,0.0f);

glPopMatrix();
}


Aber wenn ich das Mache, werden komischerweise alle Partikel auf einen Punkt gezeichnet :( ,obwohl ich die jeden Frame bewege! Ausgerichtet werden sie auch nicht. Wenn ich für RenderPartikel() was anderes benutze:

Quellcode:
void RenderPartikel(CPartikel* p)
{
glVertex3f(p->m_position.x-p->m_size,p->m_position.y+p->m_size,p->m_position.z);
    glVertex3f(p->m_position.x+p->m_size,p->m_position.y+p->m_size,p->m_position.z);
    glVertex3f(p->m_position.x+p->m_size,p->m_position.y-p->m_size,p->m_position.z);
    glVertex3f(p->m_position.x-p->m_size,p->m_position.y-p->m_size,p->m_position.z);
}

Funktioniert das ganz OK, aber es wird eben nicht ausgerichtet!!

thx, cu, MfG the_viking

(( My =]=H=O=M=E=> Page! ))
Coder bei Brainshock-Interactive und bei Z-Software
My ICQ: #160959446

Versuch mal folgendes:

Quellcode:
    float mat[16];
    glGetFloatv(GL_MODELVIEW_MATRIX, mat);

    CVector3 right(mat[0],mat[4],mat[8]);
    CVector3 up(mat[1],mat[5],mat[9]);


    right = right * p->m_size/2;
    up    = up    * p->m_size/2;

    glVertex3f(p->m_position.x+(-right[0] - up[0]),    p->m_position.y+(-right[1] - up[1]),     p->m_position.z+(-right[2] - up[2]));
    glVertex3f(p->m_position.x+(right[0] - up[0]),     p->m_position.y+(right[1] - up[1]),     p->m_position.z+(right[2] - up[2]));
    glVertex3f(p->m_position.x+(right[0] + up[0]),     p->m_position.y+(right[1] + up[1]),     p->m_position.z+(right[2] + up[2]));
    glVertex3f(p->m_position.x+(up[0] - right[0]),     p->m_position.y+(up[1] - right[1]),    p->m_position.z+(up[2] - right[2]));


CVector3 ist ne selbstgebastelte Vector-Klasse (ach, nee), aber das sollte nicht unbedingt die Schwierigkeit sein.

Der Horizont vieler Menschen ist ein Kreis mit Radius Null - und das nennen sie ihren Standpunkt.

Wenn ich richtig liege, dass
CVector::[0] == x
CVector::[1] == y
CVector::[2] == z

ist, könnte das funktionieren. (Mal gucken, ob ich da durchsteige, durch diesen Level-11 Mathekrams :) )

thx, cu, MfG the_viking

(( My =]=H=O=M=E=> Page! ))
Coder bei Brainshock-Interactive und bei Z-Software
My ICQ: #160959446

Es funktioniert.... NICHT!!!

Die Partikel sind keine Partikel mehr, sondern lange (unendliche) Streifen, die flackern !!!

thx, cu, MfG the_viking

(( My =]=H=O=M=E=> Page! ))
Coder bei Brainshock-Interactive und bei Z-Software
My ICQ: #160959446

Das hab ich gefunden: (Ist zwar für D3D, aber Umsetzen für OGL ist
nicht schwierig...)
[code]
// Get the current view matrix:
D3DMATRIX matView;
lpDevice->GetTransform(D3DTRANSFORMSTATE_VIEW, &matView);

D3DVECTOR Pos = Particles[i].Position;
D3DVECTOR TransPos; // Transformed position
// Apply the view matrix to the position vector:
TransPos.x = Pos.x * matView(0, 0) + Pos.y * matView(1, 0) + Pos.z * matView(2, 0) + matView(3, 0);
TransPos.y = Pos.x * matView(0, 1) + Pos.y * matView(1, 1) + Pos.z * matView(2, 1) + matView(3, 1);
TransPos.z = Pos.x * matView(0, 2) + Pos.y * matView(1, 2) + Pos.z * matView(2, 2) + matView(3, 2);

D3DLVERTEX Shape[4];
// upper left:
Shape[0] = D3DLVERTEX(
TransPos + D3DVECTOR(-0.5f*Particles[i].Size, 0.5f*Particles[i].Size, 0.0f),
ParticleColor, 0xffffffff, // color (with alpha) and specular color
0.0f, 0.0f); // texture coords
// upper right:
Shape[1] = D3DLVERTEX(
TransPos + D3DVECTOR(0.5f*Particles[i].Size, 0.5f*Particles[i].Size, 0.0f),
ParticleColor, 0xffffffff, 1.0f, 0.0f);
// lower left:
Shape[2] = D3DLVERTEX(
TransPos + D3DVECTOR(-0.5f*Particles[i].Size, -0.5f*Particles[i].Size, 0.0f),
ParticleColor, 0xffffffff, 0.0f, 1.0f);
// lower right:
Shape[3] = D3DLVERTEX(
TransPos + D3DVECTOR(0.5f*Particles[i].Size, -0.5f*Particles[i].Size, 0.0f),
ParticleColor, 0xffffffff, 1.0f, 1.0f);
[/code]

thx, cu, MfG the_viking

(( My =]=H=O=M=E=> Page! ))
Coder bei Brainshock-Interactive und bei Z-Software
My ICQ: #160959446

Hm... Jetzt seh ich die Partikel gar nicht mehr.. *rofl*

thx, cu, MfG the_viking

(( My =]=H=O=M=E=> Page! ))
Coder bei Brainshock-Interactive und bei Z-Software
My ICQ: #160959446

Also komischerweise funktioniert der oben gepostete Code bei mir ganz vollzüglich. Da ich es aber sehr persönlich nehme, wenn ich jemanden helfen möchte und nix dabei rum kommt schlag ich dir vor entweder dein Code-Fragment mal hier zu posten oder (falls es zu viel ist) mir zu schicken (E-Mail im Profil).

Der Horizont vieler Menschen ist ein Kreis mit Radius Null - und das nennen sie ihren Standpunkt.

Nja.. So lang isses nich:

Quellcode:
void CBaseSpriteParticleSystem::RenderParticle(CBaseParticle *p)
{
    glColor3f(1.0f,1.0f,1.0f);

    m_matrix.LoadView(); // Lädt die OGL GL_MODELVIEW_MATRIX in eine Matrix-Struktur

    Vector3D tp;
    Vector3D pos = p->m_position;
    tp.x = pos.x * m_matrix.Get(0,0) + pos.y * m_matrix.Get(1,0) + pos.z * m_matrix.Get(2,0) + m_matrix.Get(3,0);
    tp.y = pos.x * m_matrix.Get(0,1) + pos.y * m_matrix.Get(1,1) + pos.z * m_matrix.Get(2,1) + m_matrix.Get(3,1);
    tp.z = pos.x * m_matrix.Get(0,2) + pos.y * m_matrix.Get(1,2) + pos.z * m_matrix.Get(2,2) + m_matrix.Get(3,2);



    glVertex3f(tp.x - p->m_size,tp.y + p->m_size,tp.z);
    glVertex3f(tp.x + p->m_size,tp.y + p->m_size,tp.z);
    glVertex3f(tp.x + p->m_size,tp.y - p->m_size,tp.z);
    glVertex3f(tp.x - p->m_size,tp.y - p->m_size,tp.z);


}


BaseParticle:

Quellcode:
class CBaseParticle  
{
public:
    float m_size;
    bool m_dead;
    int m_time;
    int m_lifetime;
    Vector3D m_direction;
    Vector3D m_position;


    virtual int MoveMe();
    CBaseParticle();
    virtual ~CBaseParticle();
};


thx, cu, MfG the_viking

(( My =]=H=O=M=E=> Page! ))
Coder bei Brainshock-Interactive und bei Z-Software
My ICQ: #160959446

Ah: Ich glaub, wenn ich glTranslatef(was,weiss,ich) mache, funzt das sowieso nicht! (Hab ich ausprobiert, das ganze System damit zu verschieben: Kein Effekt)

thx, cu, MfG the_viking

(( My =]=H=O=M=E=> Page! ))
Coder bei Brainshock-Interactive und bei Z-Software
My ICQ: #160959446

the_viking: Der Fehler im Originalcode ist, daß du die Matrix innerhalb eines glBegin()/glEnd()-Block manipulierst. Das ist _nicht_ möglich - genauso wenig wie ein Texturwechsel (hatten wir das nicht vor kurzem mal? ;))
Zwischen glBegin() und glEnd() kannst du effektiv nur Vertexattribut-Befehle ausführen (glVertex, glTexCoord, glColor usw.) - RTFS

Übrigens ist es sowieso Irrsinn, für jedes Partikel einzeln die Matrizen zu ändern, der Overhead ist viel zu groß und du kannst Optimierungen wie Vertex Arrays später nicht verwenden.

Überhaupt strotzt der Code vor Ineffizienzien. Wenn du vorhast, mehrere Tausend Partikel zu rendern, mußt du deine Datenstrukturen effizienter auslegen. Primär heißt das, alles aus der Schleife herausverschieben, was nicht unbedingt in die Schleife rein muß.

Im Moment hast du:

Quellcode:
for(alle partikel) {
   hole view_matrix
   berechne rechts/hoch-vektor
   schicke vertices an GL
}


Viel besser wäre:

Quellcode:
hole view_matrix
berechne rechts/hoch-vektor
for(alle partikel)
   schicke vertices an GL


Ganz besonders, da die ganzen Matrixoperationen wie gesagt eher langsam sind, und der von dir verwendete Code funktioniert sowieso nicht (allein der Fakt, daß du _immer_ z == tp.z übergibst sollte dir zu denken geben).

Du kannst dann das Rendern des Partikels natürlich nicht mehr in eine Funktion packen, aber öhm... ist das wirklich notwendig in diesem Fall? Ich denke nein.

Mit anderen Worten, berechne irgendwie zwei Vektoren view_right und view_up, die nach rechts bzw. oben zeigen (vom Viewpoint aus gesehen).

Dann änderst du den Code einfach in (natürlich vereinfacht):

Quellcode:
... berechne v_right und v_up

glBegin(GL_QUADS);
for(alle particles) {
    glVertex3fv(particle_pos + v_right + v_up);
    glVertex3fv(particle_pos - v_right + v_up);
    glVertex3fv(particle_pos - v_right - v_up);
    glVertex3fv(particle_pos + v_right - v_up);
}
glEnd();


Sieht das nicht schon einiges effizienter und außerdem simpler aus?

cu,
Prefect

Widelands - Gemütliche Aufbaustrategie, Free Software
Noch ein Blog - Lerne, wie die Welt wirklich ist, aber vergiss niemals, wie sie sein sollte.

sollen wir dir vielleicht gleich deine engine proggen ?
die letzten 4 threads waren alle von dir...
vielleicht würde ich mir überlegen erst noch ein bisschen zu üben

..::Follow the rabbit ::..

.. Ich brauch halt die nötigen infos! Das, was diablo in 1nem Jahr geschafft hat , versuch ich halt in 2 Jahren zu schaffen *g*

Muss man nicht für jeden Partikel eigens berechnen, wie er richtig zur Kamera ausgerichtet ist?

( Thx, das du mir klargemacht hast, das man die Texturen in OGL nich zw. glBegin und glEnd switchen kann! New Code:

Quellcode:
glBegin(GL_TRIANGLES);

for(int n=0;n<num_faces;n++)
{
if(GetActTexture() != faces[n].textureID)
{
  SetActTexture(faces[n].textureID);
  glEnd();
  glBindTexture(GL_TEXTURE_2D,faces[n].textureID);
  glBegin(GL_TRIANGLES);
}
for(int m=0;m<3;m++)
{
  glTexCoord2f(faces[n].vertex[m].tu,faces[n].vertex[m].tv);
  glVertex3f(faces[n].vertex[m].x,faces[n].vertex[m].y,faces[n].vertex[m].z);
}
}

glEnd();

Das sollte hinhauen mit den Texturen, oder?
)

\E:
diablo_bths Engine hat noch keine Partikel-Engine, oder???
Ich code mal einen tollen Effekt, kompillier das und packes in ein Zipfile für euch zum Download *eindruckschindend*

\EE:
Das mit der Funktion in der Klasse hat einen Grund:
Meine PEngine sollte möglichst flexibel bleiben, weshalb
es das Grundsystem CBaseParticleSystem gibt. Baut man das ein, fliegen
GL_POINTS vom Ursprung in alle Richtungen mit verschiedener Geschwindigkeit.
Davon hab ich jetzt das CBaseSpriteParticleSystem abgeleitet. Darin fliegen dann Sprites (richtig ausgerichtet) in alle Richtungen [...].
Da könnte ich jetzt z.B. CSparkParticleSystem von ableiten, dafür bräuchte ich zwar keine neue Renderdunktion (Vielleicht doch, weil die Ja nen Schweif hinter sich herziehen (GL_TRIANGLE_STRIP oder GL_QUADS?) ), aber auf jedenfall ne neue Move Funktion, die Dann noch gravitation mit einbezieht.
Ich werden die CBaseParticle::MoveMe() Funktion jetzt wohl besser als virtuelle Funktion CBaseParticleSystem::MoveParticle(CBaseParticle* pt) einbauen, da (mir fällt gerade ein: MoveParticle(int index), das ist ja noch schneller!!) dann nicht soviele Calls ... doch nicht. Aber es wird übersichtlicher!

thx, cu, MfG the_viking

(( My =]=H=O=M=E=> Page! ))
Coder bei Brainshock-Interactive und bei Z-Software
My ICQ: #160959446

das ist gelinde gesagt _arschlahm_!
sortier nach der textur und benutz vertex arrays.

'KEINE PANIK' - aus der Triologie in fuenf Baenden von Douglas Adams

'FÜR DEINN FERD' - aus 'Gevatter Tod' von Terry Pratchett

wrt Klassenhierarchie: Nun, eine Klassenhierarche BaseParticleSystem -> SpriteParticleSystem wäre u.U. vertretbar. Aber eine Klassenhierarche BaseParticle -> ??? macht IMHO keinen Sinn, denn was für abgeleitete Klassen könntest du dir überhaupt vorstellen?

Das mit den Texturen funktioniert schon, ist aber ein böser Hack - siehe Trons Post.

cu,
Prefect

Widelands - Gemütliche Aufbaustrategie, Free Software
Noch ein Blog - Lerne, wie die Welt wirklich ist, aber vergiss niemals, wie sie sein sollte.

I hoab k.A. wie das in OGL mit IndexArray, VertexArrays und wasweißichfürarray geht. Kennt jemand gute OGL Bücher ? (Am besten Deutsch, Englisch ist vertretbar)

@Tron:
Ich hab in jedem OctreeNode ca. 5-20 Trias. Wenn ich die nun Sortiere, hab ich nachher trotzdem 20 oder mehr OTNs, die Verschiedene Sortierungen haben. (Oder ich setzte jedes Trias auf ein ToBeRendered List, sortiere die Liste und Zeichne dann alles.. Ma gucken ob ich das implementieren schaffe... )

thx, cu, MfG the_viking

(( My =]=H=O=M=E=> Page! ))
Coder bei Brainshock-Interactive und bei Z-Software
My ICQ: #160959446

@viking: kann dir den "OpenGL Programming Guide" empfehlen (red book) - da wird alles von Grund auf erklärt - auch das System, welches hinter dieser API steckt. (sind übrigens auch Pics aus q2 & q3 drinne als Beispiel für Texture-Mapping :) Einziger Nachteil: c.a. 60€ darfste schon hinlegen...

[edit]
das mit Vertex-Array is eigentlich ganz einfach:

Quellcode:
renderfunc()
{
  glEnableClientState( GL_VERTEX_ARRAY );
  glEnableClientState( GL_TEXTURE_COORD_ARRAY );
  glVertexPointer( 3, GL_FLOAT, 0, v_pointer );
  glTexCoordPointer( 2, GL_FLOAT, 0, tc_pointer );
  glDrawArrays( GL_POLYGON, 0, anz_vertices );
}


Wahh... 60€... N bissl sparen (n' english-wörterbuch hab ich noch..),

Also, wenn ich jetzt meine Partikel rendern will, hab ich , sagen wir, 3 Arrays:
Quellcode:
struct vertex
{
float x,y,z;
};

struct tex_coords
{
float u,v;
};

struct color_rgba
{
float r,g,b,a;
};

vertex m_v[100]; // Ich code das mal hart
tex_coords m_t[100]; // Bei Partikeln ja eigendlich nur 0.0f und 1.0f....
color_rgba m_c[100]; // Colors für die Partikels

renderfunc()
{
   glEnableClientState( GL_VERTEX_ARRAY );
   glEnableClientState( GL_TEXTURE_COORD_ARRAY );
   glEnableClientState( GL_COLOR_ARRAY );
   glVertexPointer( 3, GL_FLOAT, 0, m_v );
   glTexCoordPointer( 2, GL_FLOAT, 0, m_t );
   glColorPointer( 4, GL_FLOAT, 0, m_c);
   glDrawArrays( GL_TRIANGLES, 0, anz_vertices );
}

// Das wars? Ist ja ganz einfach!
// (Gibts auch ein glEnableServerState()? :) )




Nagut, versuchs mal zu implementieren...

thx, cu, MfG the_viking

(( My =]=H=O=M=E=> Page! ))
Coder bei Brainshock-Interactive und bei Z-Software
My ICQ: #160959446

glEnable() ist das entsprechende Gegenstück zu glEnableClientState() auf der Serverseite.

Ganz so einfach ist es allerdings nicht. Du kannst damit zwar die Partikel rendern, aber sie werden natürlich nicht entsprechend deiner Blickrichtung ausgerichtet.

Du mußt also zumindest das Vertex-Array in jedem Frame neu berechnen, was aber sowieso unvermeidbar ist, da sich die Partikel ja bewegen.

cu,
Prefect

Widelands - Gemütliche Aufbaustrategie, Free Software
Noch ein Blog - Lerne, wie die Welt wirklich ist, aber vergiss niemals, wie sie sein sollte.