4. PowerVR

Das PowerVR OpenGL ES SDK stellt neben den benötigten Libraries und Header-Dateien auch Dokumentation, Beispiel-Code und Tools zur Verfügung, die es den Entwicklern ermöglicht, OpenGL Anwendungen für verschiedene Umgebungen zu entwickeln:
  • TI OMAP2 Family (Symbian, Windows Mobile 5.0 PPC)
  • ARM VP
  • Intel i2007G (Windows Mobile 5.0 PPC DELL X51v)
  • ...
Im Unterschied zu Vincent lassen sich kompilierte PowerVR Anwendungen leider nicht im Emulator ausführen. Dafür wird zumindest für den Dell Axim 51v keine weitere .dll benötigt da diese bereits dem Dell beiliegen.

PowerVR liegen einige nützliche Tools bei, wie z.B. die PowerVR Shell Klasse. Sie übernimmt die systemspezifische Initialisierung und vereinfacht zusätzlich das Schreiben von sauberem Code. Bei der Implementierung des Ply-File Viewers entschieden wir uns daher auch auf diese Klasse zuzurückzugreifen. Folgend ein paar relevante Code-Ausschnitte:

// Die PowerVR Shell Superklasse übernimmt alle systemspezifischen Initialisierungen

class PlyViewer : public PVRShell
{
public:

   // Funktionen zum Initialiseren und Schließen.

      virtual bool InitApplication();
   virtual bool InitView();
   virtual bool ReleaseView();
   virtual bool QuitApplication();

   // Die Loop Rendering Funktion. Hier kommt der Code zum zeichnen des Hasen rein

      virtual bool RenderScene();

   bool KeyBoard();
};

// Folgend die Funktion zum Zeichnen.

bool PlyViewer::RenderScene()
{
   int index0,index1,index2,i;
   tri *this_tri;
   GLfloat my_normal[4];

   // Der Aufruf der KeyBoard Funktion.

   KeyBoard();

   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

   glLightfv(GL_LIGHT0, GL_POSITION, light_position0);
   glLightfv(GL_LIGHT1, GL_POSITION, light_position1);

   glPushMatrix();

   glScalef(10.0,10.0,10.0);

   glRotatef(rotY, 0.0, 1.0, 0.0);
   glRotatef(rotX, 1.0, 0.0, 0.0);

   glMatrixMode(GL_MODELVIEW);

   glScalef(my_scal,my_scal,my_scal);
   glTranslatef(0.0,-0.1,0.0); // Hase in die Mitte??
   this_tri = all_tri;

   VERTTYPE redColor[] = {
   f2vt(1.0f),f2vt(0.0f),f2vt(0.0f),f2vt(1.0f),
   f2vt(1.0f),f2vt(0.0f),f2vt(0.0f),f2vt(1.0f),
   f2vt(1.0f),f2vt(0.0f),f2vt(0.0f),f2vt(1.0f)
   };

   glEnableClientState(GL_COLOR_ARRAY);
   glColorPointer(4,VERTTYPEENUM,0,redColor);

   GLfloat afVertices[3][3];

   // Hier werden die Dreiecke gezeichnet und Normalen berechnet.

   for(i = 0; i < num_of_tri; i++)
   {

      index0 = this_tri->a;
      index1 = this_tri->b;
      index2 = this_tri->c;

      userCalculateNormal(all_vert[index0].coor,
      all_vert[index1].coor,
      all_vert[index2].coor,
      my_normal);


      glNormal3f(my_normal[0],my_normal[1],my_normal[2]);


      afVertices[0][0] = f2vt(all_vert[index0].coor[0]);
      afVertices[0][1] = f2vt(all_vert[index0].coor[1]);
      afVertices[0][2] = f2vt(all_vert[index0].coor[2]);
      afVertices[1][0] = f2vt(all_vert[index1].coor[0]);
      afVertices[1][1] = f2vt(all_vert[index1].coor[1]);
      afVertices[1][2] = f2vt(all_vert[index1].coor[2]);
      afVertices[2][0] = f2vt(all_vert[index2].coor[0]);
      afVertices[2][1] = f2vt(all_vert[index2].coor[1]);
      afVertices[2][2] = f2vt(all_vert[index2].coor[2]);

      glEnableClientState(GL_VERTEX_ARRAY);
      glVertexPointer(3,VERTTYPEENUM,0,afVertices);
      glDrawArrays(GL_TRIANGLES, 0, 3);

      if(this_tri->next != NULL)
         this_tri = this_tri->next;

   }

   glPopMatrix();

   return true;
}

// Die KeyBoard Funktion wird im Main-Loop ausgeführt und
// reagiert auf bestimmte Tasten.

bool PlyViewer::KeyBoard()
{
   if (PVRShellIsKeyPressed(PVRShellKeyNameUP))
      rotX -= 10;
   else if (PVRShellIsKeyPressed(PVRShellKeyNameDOWN))
      rotX += 10;
   else if (PVRShellIsKeyPressed(PVRShellKeyNameLEFT))
      rotY -= 10;
   else if (PVRShellIsKeyPressed(PVRShellKeyNameRIGHT))
      rotY += 10;
   else if (PVRShellIsKeyPressed(PVRShellKeyNameACTION2))
   {
      my_scal /= 1.3;
   }
   else if (PVRShellIsKeyPressed(PVRShellKeyNameACTION1))
   {
      my_scal *= 1.3;
   }
   return true;
}



Ein Ply-File, welches aus einem Milka-Hasen entstand, diente als Testobjekt. Dieser Hase besteht aus insgesamt 453 Vertices. Der Viewer kann das Objekt in alle Richtungen drehen sowie rein- und rauszoomen. Die Interaktionen geschehen mit den Knöpfen unterhalb des Displays.






Insgesamt 1889 Vertices lassen den Hasen schon realistischer wirken, jedoch macht sich das größere Ply-File auch bemerkbar. Das Drehen und Zoomen ist nicht mehr flüssig wie zuvor.






Der RGB-hase besteht insgesamt aus 8171 Vertices: Nett anzuschauen, aber die Performance geht in den Keller. Der Viewer reagiert jetzt nur noch sehr verzögert auf Interaktionen mit der Tastatur.






Und schließlich 35947 Vertices. Zwischen den einzelnen Interaktionen kann man sich jetzt jedoch einen Kaffee holen gehen.