Warning: session_start(): open(/var/lib/php/sessions/sess_bd1ad789ea7974e6428319329946cf81, O_RDWR) failed: No such file or directory (2) in /var/www/web1319/html/cwx/phpwebed/config.inc.php on line 1

Warning: session_start(): Cannot send session cache limiter - headers already sent (output started at /var/www/web1319/html/cwx/phpwebed/config.inc.php:1) in /var/www/web1319/html/cwx/phpwebed/config.inc.php on line 1
codeworx.org - OpenGL Tutorial 44 - 3D-Linseneffekt mit Occlusion und Frustum Culling

www.codeworx.org/opengl-tutorials/Tutorial 44: 3D-Linseneffekt mit Occlusion und Frustum Culling

Willkommen zu diesem 44. Nehe-Tut. Es wird gezeigt wie sich ein sehr realistisch wirkender Linseneffekt (sieht man öfter in 3D-Weltraumspielen oder Ego-Shootern, wenn der Spieler in Lichtquellen guckt.) mit OpenGL und einem (nagut zwei ;) Sichtbarkeitstest erzeugen läßt. Diese Effekte haben oft eins gemeinsam, sie scheinen um die Bildmitte zu rotieren, also nur um eine einzige Achse. Man könnte auf die Idee kommen die Z-Koordinate ganz zu vernachläßigen, wird aber bei dem Test, ob die Kamera gerade in eine Lichtquelle guckt ein ziemliches Problem bekommen... Mit einem "echten" 3D-Linseneffekt läßt sich das umgehen. Die glCamera-Klasse muss dazu erweitert werden. Zuerst müssen Funktionen geschrieben werden, die prüfen ob sich ein bestimmter Punkt oder eine Kugel im Sichtbereich der Kamera befindet. Dann müssen noch einige Texturen für den Effekt an sich geladen werden.

Ich muss vorher noch mitteilen das in der Kameraklasse noch ein Bug (in SetPrespective) steckt, der mit dem unteren Code verbessert werden muss:

void glCamera::SetPrespective()
{
   GLfloat Matrix[16];
   glVector v;
   // Going To Use glRotate To Calculate Our Direction Vector
   glRotatef(m_HeadingDegrees, 0.0f, 1.0f, 0.0f);
   glRotatef(m_PitchDegrees, 1.0f, 0.0f, 0.0f);
   // Get The Resulting Matrix From OpenGL It Will Have Our
   // Direction Vector In The 3rd Row
   glGetFloatv(GL_MODELVIEW_MATRIX, Matrix);
   // Get The Direction Vector From The Matrix. Element 10 Must
   // Be Inverted!
   m_DirectionVector.i = Matrix[8];
   m_DirectionVector.j = Matrix[9];
   m_DirectionVector.k = -Matrix[10];
   // Ok Erase The Results Of The Last Computation
   glLoadIdentity();
   // Rotate The Scene To Get The Right Orientation
   glRotatef(m_PitchDegrees, 1.0f, 0.0f, 0.0f);
   glRotatef(m_HeadingDegrees, 0.0f, 1.0f, 0.0f);
   // Scale The Direction By Our Speed
   v = m_DirectionVector;
   v *= m_ForwardVelocity;
   // Increment Our Position By The Vector
   m_Position.x += v.i;
   m_Position.y += v.j;
   m_Position.z += v.k;
   // Translate To Our New Position
   glTranslatef(-m_Position.x, -m_Position.y, -m_Position.z);
}

Jetzt aber an die eigentliche Arbeit. Es werden 4 verschiedene Texturen geladen, Big Glow, Streaks, Glow und Halo. Diese sollen sich beim Blick ins Licht, auf verschiedenen Bahnen und entgegen der Kameradrehung um die Bildmitte bewegen. Big Glow stellt die eigentliche "Lichtquelle" dar, die Beleuchtungsfunktionen von OpenGL kommen nicht zu Einsatz (da wäre auch (noch) nichts zum Beleuchten da :). Die anderen Texturen vervollständigen das Ganze.


Big Glow

Streaks
  .

Glow

Halo

Ein Linseneffekt macht nur dann wirklich Sinn, wenn er zu sehen ist sobald der Betrachter in die Lichtquelle guckt, danach aber wieder verschwindet. Dazu muss das Sichtvolumen der Kamera berechnet werden um zu prüfen ob das Licht momentan zu sehen ist oder nicht. UpdateFrustrum() errechnet das aus 6 Ebenen bestehende Sichtvolumen aus der Projection- und der Modelview Matrix, die man direkt von OpenGL abfragen kann. Neuere 3D-Grafikkarten, die die viel besprochenen OpenGL-Extensions unterstützen, bieten eine Alternative. Dort lassen sich beliebige Punkte unkomplizierter auf ihre Sichtbarkeit prüfen mit Hilfe von GL_HP_occlusion_test oder GL_NV_occlusion_query. In diesem Tutorial wird der altmodische, aber auch auf alter Hardware noch funktionierende Weg beschrieben.

void glCamera::UpdateFrustum()
{
   GLfloatclip[16];
   GLfloatproj[16];
   GLfloatmodl[16];
   GLfloatt;
   // Get The Current PROJECTION Matrix From OpenGL
   glGetFloatv( GL_PROJECTION_MATRIX, proj );
   // Get The Current MODELVIEW Matrix From OpenGL
   glGetFloatv( GL_MODELVIEW_MATRIX, modl );
   // Combine The Two Matrices (Multiply Projection By Modelview)
   clip[ 0] = modl[ 0] * proj[ 0] + modl[ 1] * proj[ 4] + modl[ 2] * proj[ 8] +    modl[ 3] * proj[12];
   clip[ 1] = modl[ 0] * proj[ 1] + modl[ 1] * proj[ 5] + modl[ 2] * proj[ 9] +    modl[ 3] * proj[13];
   clip[ 2] = modl[ 0] * proj[ 2] + modl[ 1] * proj[ 6] + modl[ 2] * proj[10] +    modl[ 3] * proj[14];
   clip[ 3] = modl[ 0] * proj[ 3] + modl[ 1] * proj[ 7] + modl[ 2] * proj[11] +    modl[ 3] * proj[15];
   clip[ 4] = modl[ 4] * proj[ 0] + modl[ 5] * proj[ 4] + modl[ 6] * proj[ 8]    + modl[ 7] * proj[12];
   clip[ 5] = modl[ 4] * proj[ 1] + modl[ 5] * proj[ 5] + modl[ 6] * proj[ 9] +    modl[ 7] * proj[13];
   clip[ 6] = modl[ 4] * proj[ 2] + modl[ 5] * proj[ 6] + modl[ 6] * proj[10] +    modl[ 7] * proj[14];
   clip[ 7] = modl[ 4] * proj[ 3] + modl[ 5] * proj[ 7] + modl[ 6] * proj[11] +    modl[ 7] * proj[15];
   clip[ 8] = modl[ 8] * proj[ 0] + modl[ 9] * proj[ 4] + modl[10] * proj[ 8]    + modl[11] * proj[12];
   clip[ 9] = modl[ 8] * proj[ 1] + modl[ 9] * proj[ 5] + modl[10] * proj[ 9] +    modl[11] * proj[13];
   clip[10] = modl[ 8] * proj[ 2] + modl[ 9] * proj[ 6] + modl[10] * proj[10] +    modl[11] * proj[14];
   clip[11] = modl[ 8] * proj[ 3] + modl[ 9] * proj[ 7] + modl[10] * proj[11] +    modl[11] * proj[15];
   clip[12] = modl[12] * proj[ 0] + modl[13] * proj[ 4] + modl[14] * proj[ 8]    + modl[15] * proj[12];
   clip[13] = modl[12] * proj[ 1] + modl[13] * proj[ 5] + modl[14] * proj[ 9] +    modl[15] * proj[13];
   clip[14] = modl[12] * proj[ 2] + modl[13] * proj[ 6] + modl[14] * proj[10] +    modl[15] * proj[14];
   clip[15] = modl[12] * proj[ 3] + modl[13] * proj[ 7] + modl[14] * proj[11] +    modl[15] * proj[15];
   // Extract The Numbers For The RIGHT Plane
   m_Frustum[0][0] = clip[ 3] - clip[ 0];
   m_Frustum[0][1] = clip[ 7] - clip[ 4];
   m_Frustum[0][2] = clip[11] - clip[ 8];
   m_Frustum[0][3] = clip[15] - clip[12];
   // Normalize The Result
   t = GLfloat(sqrt( m_Frustum[0][0] * m_Frustum[0][0] + m_Frustum[0][1] * m_Frustum[0][1]    
   + m_Frustum[0][2] * m_Frustum[0][2] ));

   m_Frustum[0][0] /= t;
   m_Frustum[0][1] /= t;
   m_Frustum[0][2] /= t;
   m_Frustum[0][3] /= t;
   // Extract The Numbers For The LEFT Plane
   m_Frustum[1][0] = clip[ 3] + clip[ 0];
   m_Frustum[1][1] = clip[ 7] + clip[ 4];
   m_Frustum[1][2] = clip[11] + clip[ 8];
   m_Frustum[1][3] = clip[15] + clip[12];
   // Normalize The Result
   t = GLfloat(sqrt( m_Frustum[1][0] * m_Frustum[1][0] + m_Frustum[1][1] * m_Frustum[1][1]    
   + m_Frustum[1][2] * m_Frustum[1][2] ));
   m_Frustum[1][0] /= t;
   m_Frustum[1][1] /= t;
   m_Frustum[1][2] /= t;
   m_Frustum[1][3] /= t;
   // Extract The BOTTOM Plane
   m_Frustum[2][0] = clip[ 3] + clip[ 1];
   m_Frustum[2][1] = clip[ 7] + clip[ 5];
   m_Frustum[2][2] = clip[11] + clip[ 9];
   m_Frustum[2][3] = clip[15] + clip[13];
   // Normalize The Result
   t = GLfloat(sqrt( m_Frustum[2][0] * m_Frustum[2][0] + m_Frustum[2][1] * m_Frustum[2][1]    
   + m_Frustum[2][2] * m_Frustum[2][2] ));
   m_Frustum[2][0] /= t;
   m_Frustum[2][1] /= t;
   m_Frustum[2][2] /= t;
   m_Frustum[2][3] /= t;
   // Extract The TOP Plane
   m_Frustum[3][0] = clip[ 3] - clip[ 1];
   m_Frustum[3][1] = clip[ 7] - clip[ 5];
   m_Frustum[3][2] = clip[11] - clip[ 9];
   m_Frustum[3][3] = clip[15] - clip[13];
   // Normalize The Result
   t = GLfloat(sqrt( m_Frustum[3][0] * m_Frustum[3][0] + m_Frustum[3][1] * m_Frustum[3][1]   
   + m_Frustum[3][2] * m_Frustum[3][2] ));
   m_Frustum[3][0] /= t;
   m_Frustum[3][1] /= t;
   m_Frustum[3][2] /= t;
   m_Frustum[3][3] /= t;
   // Extract The FAR Plane
   m_Frustum[4][0] = clip[ 3] - clip[ 2];
   m_Frustum[4][1] = clip[ 7] - clip[ 6];
   m_Frustum[4][2] = clip[11] - clip[10];
   m_Frustum[4][3] = clip[15] - clip[14];
   // Normalize The Result
   t = GLfloat(sqrt( m_Frustum[4][0] * m_Frustum[4][0] + m_Frustum[4][1] * m_Frustum[4][1]   
   + m_Frustum[4][2] * m_Frustum[4][2] ));
   m_Frustum[4][0] /= t;
   m_Frustum[4][1] /= t;
   m_Frustum[4][2] /= t;
   m_Frustum[4][3] /= t;
   // Extract The NEAR Plane
   m_Frustum[5][0] = clip[ 3] + clip[ 2];
   m_Frustum[5][1] = clip[ 7] + clip[ 6];
   m_Frustum[5][2] = clip[11] + clip[10];
   m_Frustum[5][3] = clip[15] + clip[14];
   // Normalize The Result
   t = GLfloat(sqrt( m_Frustum[5][0] * m_Frustum[5][0] + m_Frustum[5][1] * m_Frustum[5][1]   
   + m_Frustum[5][2] * m_Frustum[5][2] ));
   m_Frustum[5][0] /= t;
   m_Frustum[5][1] /= t;
   m_Frustum[5][2] /= t;
   m_Frustum[5][3] /= t;
}

Bei diesem Biest von Funktion kann man sich gut vorstellen, warum solche Berechnungen auch als OpenGL-Extensions implemetiert werden. Obwohl die Mathematik dahinter nicht allzu kompliziert ist, umfasst die Funktion 190 Operationen, leider auch sehr zeitraubende Divisionen und 6 Wurzeln. Rausoptimieren lassen sich noch einige Multiplikationen, wenn die Projection Matrix nicht durch Rotation oder Translation verändert wird. Da die Funktion nach jeder Bewegung des Betrachters neu berechnet werden muss, lohnt sich das:

void glCamera::UpdateFrustumFaster()
{
   GLfloat clip[16];
   GLfloat proj[16];
   GLfloat modl[16];
   GLfloat t;
   // Get The Current PROJECTION Matrix From OpenGL
   glGetFloatv( GL_PROJECTION_MATRIX, proj );
   // Get The Current MODELVIEW Matrix From OpenGL
   glGetFloatv( GL_MODELVIEW_MATRIX, modl );
   // Combine The Two Matrices (Multiply Projection By Modelview) 
   // But Keep In Mind This Function Will Only Work If You Do NOT
   // Rotate Or Translate Your Projection Matrix
   clip[ 0] = modl[ 0] * proj[ 0];
   clip[ 1] = modl[ 1] * proj[ 5];
   clip[ 2] = modl[ 2] * proj[10] + modl[ 3] * proj[14];
   clip[ 3] = modl[ 2] * proj[11];
   clip[ 4] = modl[ 4] * proj[ 0];
   clip[ 5] = modl[ 5] * proj[ 5];
   clip[ 6] = modl[ 6] * proj[10] + modl[ 7] * proj[14];
   clip[ 7] = modl[ 6] * proj[11];
   clip[ 8] = modl[ 8] * proj[ 0];
   clip[ 9] = modl[ 9] * proj[ 5];
   clip[10] = modl[10] * proj[10] + modl[11] * proj[14];
   clip[11] = modl[10] * proj[11];
   clip[12] = modl[12] * proj[ 0];
   clip[13] = modl[13] * proj[ 5];
   clip[14] = modl[14] * proj[10] + modl[15] * proj[14];
   clip[15] = modl[14] * proj[11];
   // Extract The Numbers For The RIGHT Plane
   m_Frustum[0][0] = clip[ 3] - clip[ 0];
   m_Frustum[0][1] = clip[ 7] - clip[ 4];
   m_Frustum[0][2] = clip[11] - clip[ 8];
   m_Frustum[0][3] = clip[15] - clip[12];
   // Normalize The Result
   t = GLfloat(sqrt( m_Frustum[0][0] * m_Frustum[0][0] + m_Frustum[0][1] * m_Frustum[0][1]   
   + m_Frustum[0][2] * m_Frustum[0][2] ));
   m_Frustum[0][0] /= t;
   m_Frustum[0][1] /= t;
   m_Frustum[0][2] /= t;
   m_Frustum[0][3] /= t;
   // Extract The Numbers For The LEFT Plane
   m_Frustum[1][0] = clip[ 3] + clip[ 0];
   m_Frustum[1][1] = clip[ 7] + clip[ 4];
   m_Frustum[1][2] = clip[11] + clip[ 8];
   m_Frustum[1][3] = clip[15] + clip[12];
   // Normalize The Result
   t = GLfloat(sqrt( m_Frustum[1][0] * m_Frustum[1][0] + m_Frustum[1][1] * m_Frustum[1][1]  
   + m_Frustum[1][2] * m_Frustum[1][2] ));
   m_Frustum[1][0] /= t;
   m_Frustum[1][1] /= t;
   m_Frustum[1][2] /= t;
   m_Frustum[1][3] /= t;
   // Extract The BOTTOM Plane
   m_Frustum[2][0] = clip[ 3] + clip[ 1];
   m_Frustum[2][1] = clip[ 7] + clip[ 5];
   m_Frustum[2][2] = clip[11] + clip[ 9];
   m_Frustum[2][3] = clip[15] + clip[13];
   // Normalize The Result
   t = GLfloat(sqrt( m_Frustum[2][0] * m_Frustum[2][0] + m_Frustum[2][1] * m_Frustum[2][1]   
   + m_Frustum[2][2] * m_Frustum[2][2] ));
   m_Frustum[2][0] /= t;
   m_Frustum[2][1] /= t;
   m_Frustum[2][2] /= t;
   m_Frustum[2][3] /= t;
   // Extract The TOP Plane
   m_Frustum[3][0] = clip[ 3] - clip[ 1];
   m_Frustum[3][1] = clip[ 7] - clip[ 5];
   m_Frustum[3][2] = clip[11] - clip[ 9];
   m_Frustum[3][3] = clip[15] - clip[13];
   // Normalize The Result
   t = GLfloat(sqrt( m_Frustum[3][0] * m_Frustum[3][0] + m_Frustum[3][1] * m_Frustum[3][1]   
   + m_Frustum[3][2] * m_Frustum[3][2] ));
   m_Frustum[3][0] /= t;
   m_Frustum[3][1] /= t;
   m_Frustum[3][2] /= t;
   m_Frustum[3][3] /= t;
   // Extract The FAR Plane
   m_Frustum[4][0] = clip[ 3] - clip[ 2];
   m_Frustum[4][1] = clip[ 7] - clip[ 6];
   m_Frustum[4][2] = clip[11] - clip[10];
   m_Frustum[4][3] = clip[15] - clip[14];
   // Normalize The Result
   t = GLfloat(sqrt( m_Frustum[4][0] * m_Frustum[4][0] + m_Frustum[4][1] * m_Frustum[4][1]   
   + m_Frustum[4][2] * m_Frustum[4][2] ));
   m_Frustum[4][0] /= t;
   m_Frustum[4][1] /= t;
   m_Frustum[4][2] /= t;
   m_Frustum[4][3] /= t;
   // Extract The NEAR Plane
   m_Frustum[5][0] = clip[ 3] + clip[ 2];
   m_Frustum[5][1] = clip[ 7] + clip[ 6];
   m_Frustum[5][2] = clip[11] + clip[10];
   m_Frustum[5][3] = clip[15] + clip[14];
   // Normalize The Result
   t = GLfloat(sqrt( m_Frustum[5][0] * m_Frustum[5][0] + m_Frustum[5][1] * m_Frustum[5][1]  
   + m_Frustum[5][2] * m_Frustum[5][2] ));
   m_Frustum[5][0] /= t;
   m_Frustum[5][1] /= t;
   m_Frustum[5][2] /= t;
   m_Frustum[5][3] /= t;
}

Immernoch recht umfangreich, aber es sind jetzt nur noch 102 Operationen. Es wurden überflüßige Multiplikationen entfernt, deren Ergebnis unter der obrigen Bedingung normalerweise 0 ist.

Mit der unteren Funktion läßt sich jetzt sehr einfach berechnen, ob ein bestimmter Punkt momentan sichtbar ist, was gerade bei großen 3D-Szenen (Spiele!) mit sehr vielen Polygonen ungemeine Vorteile bietet. Es ist dort sinnvoll, weil noch bevor OpenGL mit unnötigen Daten überschwemmt wird, geprüft werden kann ob die zugehörigen Polygone überhaupt sichtbar sind.
In der glCamera-Klasse befindet sich noch eine weitere Funktion "SphereInFrustum()" die eine Kugel auf Sichtbarkeit prüft. Diese sollte sich ohne größere Erläuterungen (bei Bedarf) nutzen lassen.

BOOL glCamera::PointInFrustum(glPoint p)
{
   int i;
   // The Idea Behind This Algorithum Is That If The Point
   // Is Inside All 6 Clipping Planes Then It Is Inside Our
   // Viewing Volume So We Can Return True.

   for(i = 0; i < 6; i++)
   {
      if(m_Frustum[i][0] * p.x + m_Frustum[i][1] * p.y + m_Frustum[i][2] 
         * p.z + m_Frustum[i][3] <= 0)
      {
         return(FALSE);
      }
   }

   return(TRUE);
}

Bis jetzt wird nur abgefragt ob ein Punkt "potentiell" sichtbar ist, also im Sichtvolumen liegt. Wichtig ist auch, ob er nicht durch ein anderes Objekt verdeckt wird. OpenGL erledigt diesen Teil der Arbeit durch die Projektion eines beliebigen 3D-Punktes auf die Sichtebene des Betrachters. Dabei muss im Z-Buffer (also dem Teil des Grafikspeichers, der Tiefeninformationen enthält) geprüft werden ob sich vor dem Licht (das den Linseneffekt ja erzeugen soll) schon irgendetwas befindet.

// ########## New Stuff by rIO.Spinning Kids ##########
bool glCamera::IsOccluded(glPoint p)
{
   GLint viewport[4];// Space For Viewport Data
   GLdouble mvmatrix[16], projmatrix[16];// Space For Transform Matrix
   GLdouble winx, winy, winz;// Space For Returned Projected Coords
   GLdouble flareZ;// Here We Will Store The Transformed Flare Z
   GLfloat bufferZ;// Here We Will Store The Read Z From The Buffer
   glGetIntegerv (GL_VIEWPORT, viewport);// Get Actual Viewport
   glGetDoublev (GL_MODELVIEW_MATRIX, mvmatrix);// Get Actual Model View Matrix
   glGetDoublev (GL_PROJECTION_MATRIX, projmatrix);// Get Actual Projection Matrix
   // This Asks OGL To Guess The 2D Position Of A 3D Point Inside The Viewport
   gluProject(p.x, p.y, p.z, mvmatrix, projmatrix, viewport, &winx, &winy,    &winz);
   flareZ = winz;
   // We Read Back One Pixel From The Depth Buffer (Exactly Where Our Flare Should Be Drawn)
   glReadPixels(winx, winy,1,1,GL_DEPTH_COMPONENT, GL_FLOAT, &bufferZ);
   // If The Buffer Z Is Lower Than Our Flare Guessed Z Then Don't Draw
   // This Means There Is Something In Front Of Our Flare
   if (bufferZ < flareZ)
      return true;

   else
      return false;
}

Ein anderes Problem ist die eigentliche Darstellung des Effektes. Man könnte auf die Idee kommen, die Texturen auf Vierecke im Raum zu mappen, allerdings würde sich der Effekt dadurch merklich verzerren, sobald man etwas seitlicher ins Licht guckt. Viel geeigneter sind Sprites, also 2D-Grafiken die flach auf der Sichtebene liegen und somit keine Z-Koordinate besitzen (Ein noch besserer Weg wären sogenannte Point Sprites, die allerdings auch "nur" als OpenGL-Extension zu haben sind, dort muss nur ein einziger Punkt übergeben werden und die Texturkoordinaten fallen weg, aber es muss diesmal ohne Extensions gehen). Damit die 4 Grafiken ständig in die Kamera zeigen, müssen die Kamerarotationen (X und Y) beim Zeichnen umgekehrt werden. Das klappt gut solange der Betrachter vor der Lichtquelle steht. Sollte er aber an der Lichtquelle vorbei gehen, funktioniert der Trick nicht mehr. Die schnellste Lösung ist, die Lichtquelle in Z-Richtung mit der Kamera mitzuverschieben. Dadurch erscheint die Lichtquelle sehr weit entfernt, was einen sonnenähnlichen Effekt erzeugt. Die dazu benötigten Vektoren und Punkte werden hier berechnet.

   GLfloat Length = 0.0f;
   // Draw The Flare Only If The Light Source Is In Our Line Of Sight
   if(SphereInFrustum(m_LightSourcePos, 1.0f) == TRUE)
   {
      vLightSourceToCamera = m_Position - m_LightSourcePos;
      // Lets Compute The Vector That Points To

      // The Camera From The Light Source.
      Length = vLightSourceToCamera.Magnitude();
      // Save The Length We Will Need It In A Minute
      ptIntersect = m_DirectionVector * Length;
      // Now Lets Find A Point Along The Cameras Direction

      // Vector That We Can Use As An Intersection Point
      // Lets Translate Down This Vector The Same Distance
      // That The Camera Is. Away From The Light Source.
      ptIntersect += m_Position;
      // Lets Compute The Vector That Points To The Intersect
      vLightSourceToIntersect = ptIntersect - m_LightSourcePos;


      // Point From The Light Source
      Length = vLightSourceToIntersect.Magnitude();
      // Save The Length We Will Need It Later

      vLightSourceToIntersect.Normalize();
      // Normalize The Vector So Its Unit Length


Zuerst muss der Abstand von Lichtquelle und Kamera ermittelt werden (vLightSourceToCamera). Als nächstes wird der Schnittpunkt entlang des Richtungsvektors der Kamera berechnet. Dabei muss der Abstand zwischen Schnittpunkt und Kamera genauso groß sein, wie der zwischen Lichtquelle und Kamera. Es wird nun noch der Vektor berechnet, an dem sich die Lage der einzelnen Grafiken orientiert (vLightSourceToIntersect). Die untere Skizze stellt das nocheinmal anschaulich dar:

Das war der schwierige Teil, jetzt müssen die Grafiken des Effekts nur noch wie auf einer Perlenschnur am Vektor platziert und ausgegeben werden.

   glEnable(GL_BLEND);
   glBlendFunc(GL_SRC_ALPHA, GL_ONE);
   glDisable(GL_DEPTH_TEST);
   glEnable(GL_TEXTURE_2D);
   // ########## New Stuff by rIO.Spinning Kids ##########
   if (!IsOccluded(m_LightSourcePos))// Check If The Center Of The Flare Is Occluded
   {
      // Render The Large Hazy Glow
      RenderBigGlow(0.60f, 0.60f, 0.8f, 1.0f, m_LightSourcePos, 16.0f);
      // Render The Streaks
      RenderStreaks(0.60f, 0.60f, 0.8f, 1.0f, m_LightSourcePos, 16.0f);
      // Render The Small Glow
      RenderGlow(0.8f, 0.8f, 1.0f, 0.5f, m_LightSourcePos, 3.5f);
      pt = vLightSourceToIntersect * (Length * 0.1f);// Lets Compute A Point That Is 20%
      pt += m_LightSourcePos;// Away From The Light Source In The
      // Direction Of The Intersection Point
      RenderGlow(0.9f, 0.6f, 0.4f, 0.5f, pt, 0.6f);// Render The Small Glow
      pt = vLightSourceToIntersect * (Length * 0.15f);// Lets Compute A Point That Is 30%
      pt += m_LightSourcePos;// Away From The Light Source In The
      // Direction Of The Intersection Point
      RenderHalo(0.8f, 0.5f, 0.6f, 0.5f, pt, 1.7f);// Render The Halo
      pt = vLightSourceToIntersect * (Length * 0.175f);// Lets Compute A Point That Is 35%
      pt += m_LightSourcePos;// Away From The Light Source In The
      // Direction Of The Intersection Point
      RenderHalo(0.9f, 0.2f, 0.1f, 0.5f, pt, 0.83f);// Render The Halo
      pt = vLightSourceToIntersect * (Length * 0.285f);// Lets Compute A Point That Is 57%
      pt += m_LightSourcePos;// Away From The Light Source In The
      // Direction Of The Intersection Point
      RenderHalo(0.7f, 0.7f, 0.4f, 0.5f, pt, 1.6f);// Render The Halo
      pt = vLightSourceToIntersect * (Length * 0.2755f);// Lets Compute A Point That Is 55.1%
      pt += m_LightSourcePos;// Away From The Light Source In The
      // Direction Of The Intersection Point
      RenderGlow(0.9f, 0.9f, 0.2f, 0.5f, pt, 0.8f);// Render The Small Glow
      pt = vLightSourceToIntersect * (Length * 0.4775f);// Lets Compute A Point That Is 95.5%
      pt += m_LightSourcePos;// Away From The Light Source In The
      // Direction Of The Intersection Point
      RenderGlow(0.93f, 0.82f, 0.73f, 0.5f, pt, 1.0f);// Render The Small Glow
      pt = vLightSourceToIntersect * (Length * 0.49f);// Lets Compute A Point That Is 98%
      pt += m_LightSourcePos;// Away From The Light Source In The
      // Direction Of The Intersection Point
      RenderHalo(0.7f, 0.6f, 0.5f, 0.5f, pt, 1.4f);// Render The Halo
      pt = vLightSourceToIntersect * (Length * 0.65f);// Lets Compute A Point That Is 130%
      pt += m_LightSourcePos;// Away From The Light Source In The
      // Direction Of The Intersection Point
      RenderGlow(0.7f, 0.8f, 0.3f, 0.5f, pt, 1.8f);// Render The Small Glow
      pt = vLightSourceToIntersect * (Length * 0.63f);// Lets Compute A Point That Is 126%
      pt += m_LightSourcePos;// Away From The Light Source In The
      // Direction Of The Intersection Point
      RenderGlow(0.4f, 0.3f, 0.2f, 0.5f, pt, 1.4f);// Render The Small Glow
      pt = vLightSourceToIntersect * (Length * 0.8f);// Lets Compute A Point That Is 160%
      pt += m_LightSourcePos;// Away From The Light Source In The
      // Direction Of The Intersection Point
      RenderHalo(0.7f, 0.5f, 0.5f, 0.5f, pt, 1.4f);// Render The Halo
      pt = vLightSourceToIntersect * (Length * 0.7825f);// Lets Compute A Point That Is 156.5%
      pt += m_LightSourcePos;// Away From The Light Source In The
      // Direction Of The Intersection Point
      RenderGlow(0.8f, 0.5f, 0.1f, 0.5f, pt, 0.6f);// Render The Small Glow
      pt = vLightSourceToIntersect * (Length * 1.0f);// Lets Compute A Point That Is 200%
      pt += m_LightSourcePos;// Away From The Light Source In The
      // Direction Of The Intersection Point
      RenderHalo(0.5f, 0.5f, 0.7f, 0.5f, pt, 1.7f);// Render The Halo
      pt = vLightSourceToIntersect * (Length * 0.975f);// Lets Compute A Point That Is 195%
      pt += m_LightSourcePos;// Away From The Light Source In The
      // Direction Of The Intersection Point
      RenderGlow(0.4f, 0.1f, 0.9f, 0.5f, pt, 2.0f);// Render The Small Glow
   }
   glDisable(GL_BLEND );
   glEnable(GL_DEPTH_TEST);
   glDisable(GL_TEXTURE_2D);

Jetzt noch die eigentlichen Ausgabefunktionen der einzelnen Objekte:

void glCamera::RenderHalo(GLfloat r, GLfloat g, GLfloat b, GLfloat a, glPoint p, GLfloat scale)
{
   glPoint q[4];
   // Basically We Are Just Going To Make A 2D Box
   // From Four Points We Don't Need A Z Coord Because
   // We Are Rotating The Camera By The Inverse So The 
   // Texture Mapped Quads Will Always Face Us.
   q[0].x = (p.x - scale);// Set The x Coordinate -scale Units From The Center    Point.
   q[0].y = (p.y - scale);// Set The y Coordinate -scale Units From The Center    Point.
   q[1].x = (p.x - scale);// Set The x Coordinate -scale Units From The Center    Point.
   q[1].y = (p.y + scale);// Set The y Coordinate scale Units From The Center Point.
   q[2].x = (p.x + scale);// Set The x Coordinate scale Units From The Center Point.
   q[2].y = (p.y - scale);// Set The y Coordinate -scale Units From The Center    Point.
   q[3].x = (p.x + scale);// Set The x Coordinate scale Units From The Center Point.
   q[3].y = (p.y + scale);// Set The y Coordinate scale Units From The Center Point.
   glPushMatrix();// Save The Model View Matrix
   glTranslatef(p.x, p.y, p.z);// Translate To Our Point
   glRotatef(-m_HeadingDegrees, 0.0f, 1.0f, 0.0f);
   glRotatef(-m_PitchDegrees, 1.0f, 0.0f, 0.0f);
   glBindTexture(GL_TEXTURE_2D, m_HaloTexture);// Bind To The Big Glow Texture
   glColor4f(r, g, b, a);// Set The Color Since The Texture Is A Gray Scale
   glBegin(GL_TRIANGLE_STRIP);// Draw The Big Glow On A Triangle Strip
   glTexCoord2f(0.0f, 0.0f);
   glVertex2f(q[0].x, q[0].y);
   glTexCoord2f(0.0f, 1.0f);
   glVertex2f(q[1].x, q[1].y);
   glTexCoord2f(1.0f, 0.0f);
   glVertex2f(q[2].x, q[2].y);
   glTexCoord2f(1.0f, 1.0f);
   glVertex2f(q[3].x, q[3].y);
   glEnd();
   glPopMatrix();// Restore The Model View Matrix
}
void glCamera::RenderGlow(GLfloat r, GLfloat g, GLfloat b, GLfloat a, glPoint p, GLfloat scale)
{
   glPoint q[4];
   // Basically We Are Just Going To Make A 2D Box
   // From Four Points We Don't Need A Z Coord Because
   // We Are Rotating The Camera By The Inverse So The 
   // Texture Mapped Quads Will Always Face Us.
   q[0].x = (p.x - scale);// Set The x Coordinate -scale Units From The Center    Point.
   q[0].y = (p.y - scale);// Set The y Coordinate -scale Units From The Center    Point.
   q[1].x = (p.x - scale);// Set The x Coordinate -scale Units From The Center    Point.
   q[1].y = (p.y + scale);// Set The y Coordinate scale Units From The Center Point.
   q[2].x = (p.x + scale);// Set The x Coordinate scale Units From The Center Point.
   q[2].y = (p.y - scale);// Set The y Coordinate -scale Units From The Center    Point.
   q[3].x = (p.x + scale);// Set The x Coordinate scale Units From The Center Point.
   q[3].y = (p.y + scale);// Set The y Coordinate scale Units From The Center Point.
   glPushMatrix();// Save The Model View Matrix
   glTranslatef(p.x, p.y, p.z);// Translate To Our Point
   glRotatef(-m_HeadingDegrees, 0.0f, 1.0f, 0.0f);
   glRotatef(-m_PitchDegrees, 1.0f, 0.0f, 0.0f);
   glBindTexture(GL_TEXTURE_2D, m_GlowTexture);// Bind To The Big Glow Texture
   glColor4f(r, g, b, a);// Set The Color Since The Texture Is A Gray Scale
   glBegin(GL_TRIANGLE_STRIP);// Draw The Big Glow On A Triangle Strip
   glTexCoord2f(0.0f, 0.0f);
   glVertex2f(q[0].x, q[0].y);
   glTexCoord2f(0.0f, 1.0f);
   glVertex2f(q[1].x, q[1].y);
   glTexCoord2f(1.0f, 0.0f);
   glVertex2f(q[2].x, q[2].y);
   glTexCoord2f(1.0f, 1.0f);
   glVertex2f(q[3].x, q[3].y);
   glEnd();
   glPopMatrix();// Restore The Model View Matrix
}
void glCamera::RenderBigGlow(GLfloat r, GLfloat g, GLfloat b, GLfloat a, glPoint p, GLfloat scale)
{
   glPoint q[4];
   // Basically We Are Just Going To Make A 2D Box
   // From Four Points We Don't Need A Z Coord Because
   // We Are Rotating The Camera By The Inverse So The 
   // Texture Mapped Quads Will Always Face Us.
   q[0].x = (p.x - scale);// Set The x Coordinate -scale Units From The Center    Point.
   q[0].y = (p.y - scale);// Set The y Coordinate -scale Units From The Center    Point.
   q[1].x = (p.x - scale);// Set The x Coordinate -scale Units From The Center    Point.
   q[1].y = (p.y + scale);// Set The y Coordinate scale Units From The Center Point.
   q[2].x = (p.x + scale);// Set The x Coordinate scale Units From The Center Point.
   q[2].y = (p.y - scale);// Set The y Coordinate -scale Units From The Center    Point.
   q[3].x = (p.x + scale);// Set The x Coordinate scale Units From The Center Point.
   q[3].y = (p.y + scale);// Set The y Coordinate scale Units From The Center Point.
   glPushMatrix();// Save The Model View Matrix
   glTranslatef(p.x, p.y, p.z);// Translate To Our Point
   glRotatef(-m_HeadingDegrees, 0.0f, 1.0f, 0.0f);
   glRotatef(-m_PitchDegrees, 1.0f, 0.0f, 0.0f);
   glBindTexture(GL_TEXTURE_2D, m_BigGlowTexture);// Bind To The Big Glow Texture

   glColor4f(r, g, b, a);// Set The Color Since The Texture Is A Gray Scale
   glBegin(GL_TRIANGLE_STRIP);// Draw The Big Glow On A Triangle Strip
   glTexCoord2f(0.0f, 0.0f);
   glVertex2f(q[0].x, q[0].y);
   glTexCoord2f(0.0f, 1.0f);
   glVertex2f(q[1].x, q[1].y);
   glTexCoord2f(1.0f, 0.0f);
   glVertex2f(q[2].x, q[2].y);
   glTexCoord2f(1.0f, 1.0f);
   glVertex2f(q[3].x, q[3].y);
   glEnd();
   glPopMatrix();// Restore The Model View Matrix
}
void glCamera::RenderStreaks(GLfloat r, GLfloat g, GLfloat b, GLfloat a, glPoint p, GLfloat scale)
{
   glPoint q[4];
   // Basically We Are Just Going To Make A 2D Box
   // From Four Points We Don't Need A Z Coord Because
   // We Are Rotating The Camera By The Inverse So The 
   // Texture Mapped Quads Will Always Face Us.
   q[0].x = (p.x - scale);// Set The x Coordinate -scale Units From The Center    Point.
   q[0].y = (p.y - scale);// Set The y Coordinate -scale Units From The Center    Point.
   q[1].x = (p.x - scale);// Set The x Coordinate -scale Units From The Center    Point.
   q[1].y = (p.y + scale);// Set The y Coordinate scale Units From The Center Point.
   q[2].x = (p.x + scale);// Set The x Coordinate scale Units From The Center Point.
   q[2].y = (p.y - scale);// Set The y Coordinate -scale Units From The Center    Point.
   q[3].x = (p.x + scale);// Set The x Coordinate scale Units From The Center Point.
   q[3].y = (p.y + scale);// Set The y Coordinate scale Units From The Center Point.
   glPushMatrix();// Save The Model View Matrix
   glTranslatef(p.x, p.y, p.z);// Translate To Our Point
   glRotatef(-m_HeadingDegrees, 0.0f, 1.0f, 0.0f);
   glRotatef(-m_PitchDegrees, 1.0f, 0.0f, 0.0f);
   glBindTexture(GL_TEXTURE_2D, m_StreakTexture);// Bind To The Big Glow Texture
   glColor4f(r, g, b, a);// Set The Color Since The Texture Is A Gray Scale
   glBegin(GL_TRIANGLE_STRIP);// Draw The Big Glow On A Triangle Strip
   glTexCoord2f(0.0f, 0.0f);
   glVertex2f(q[0].x, q[0].y);
   glTexCoord2f(0.0f, 1.0f);
   glVertex2f(q[1].x, q[1].y);
   glTexCoord2f(1.0f, 0.0f);
   glVertex2f(q[2].x, q[2].y);
   glTexCoord2f(1.0f, 1.0f);
   glVertex2f(q[3].x, q[3].y);
   glEnd();
   glPopMatrix();// Restore The Model View Matrix
}

Mit den W,A,S,D-Knöpfen kann die Kamera geschwänkt werden. Mit 1 und 2 werden zusätzliche Informationen angezeigt. Z bewegt die Kamera konstant nach vorne, C nach hinten und X stoppt jedgliche Bewegung.

Das wars schonwieder. Fragen, Wünsche, Kommentare sind wie immer willkommen. Ich bin natürlich nicht der erste der sich mit Linseneffekten auseinandergesetzt hat, unten finden sich ein paar sicher nützliche Links zum Thema. Vielen Dank an: Dave Steere, Cameron Tidwell, Bert Sammons und Brannon Martindale.

Hoffentlich hats Spaß gemacht, bis zum nächsten Tutorial.

http://www.gamedev.net/reference/articles/article874.asp
http://www.gamedev.net/reference/articles/article813.asp
http://www.opengl.org/developers/code/mjktips/lensflare/
http://www.markmorley.com/opengl/frustumculling.html
http://oss.sgi.com/projects/ogl-sample/registry/HP/occlusion_test.txt
http://oss.sgi.com/projects/ogl-sample/registry/NV/occlusion_query.txt

- Cheers

Vic Hollis

Jeff Molofee (NeHe) http://nehe.gamedev.net

Die Source Codes und Ausführbaren Dateien zu den Kursen liegen auf der Neon Helium Website

Übersetzt und leicht modifiziert von Hans-Jakob Schwer 22.01.2k4, www.codeworx.org

 
 

Warning: Unknown: open(/var/lib/php/sessions/sess_bd1ad789ea7974e6428319329946cf81, O_RDWR) failed: No such file or directory (2) in Unknown on line 0

Warning: Unknown: Failed to write session data (files). Please verify that the current setting of session.save_path is correct (/var/lib/php/sessions) in Unknown on line 0