News

Die folgenden Bilder zeigen die Umsetzung des Culled Raster Surface Rendering in drei verschiedenen Detailgrads:

Detail 1

Detail 2

Detail 3

Hier der C++/OpenGL Code:

Header

#ifndef X_SurfaceH
#define X_SurfaceH

#include <math.h>
#include <stdio.h>

#define GLUT_DISABLE_ATEXIT_HACK
#include "glut.h"

#include "X_IO.h"
#include "X_Math.h"
#include "XGraphix.h"

class TSurface{
private:
   XIO   *io;
   float **mat;
   float scale;                              //global scale value
   int   nDepth, nWidth;                     //dimension of culled surface
   float *temp, *r, *phi;
   float **rasterx, **rastery, **rasterz;    //raster positions of culled surface
   float **u,**v;                            //texture coordinates
   unsigned int texID;
public:
   int dimX, dimZ;                          //dimension of matrix
   void PrepareCulledSurface(int n1,         //# of raster positions in depth
                             int n2,         //# of raster positions in width
                             float zNear,    //near clipping area
                             float zFar);    //far clipping area
   void RenderCulledSurface(float fovy,      //angle of frustum
                            float phiCam,    //view angle of camera
                            float xCam,      //x position of camera
                            float zCam);     //z position of camera
   float GetSurfaceHeight(float x, float z);

   TSurface(float s);
~TSurface(void);

};

#endif

Funktionen

#include "X_Surface.h"

//------------------------------------------------------------------------
TSurface::TSurface(float s){
//------------------------------------------------------------------------
   scale = s;

   io    = new XIO;
   io    = XIOReadMatrix(".\\data\\mesh\\surface.txt");   //holds just a matrix
   X_BuildTexture(".\\data\\bitmap\\Surface.bmp",texID); //a texture loader

   dimX = io->m.row;
   dimZ = io->m.col;

   mat = new float *[io->m.row];
   for (int i=0;i<io->m.row;i++){
      mat[i] = new float [io->m.col];
   }
   for (int i=0;i<io->m.row;i++){
      for (int j=0;j<io->m.col;j++){
         mat[i][j] = scale * io->m.mat[i][j];
      }
   }
}

//------------------------------------------------------------------------
TSurface::~TSurface(void){
//------------------------------------------------------------------------
   if (mat)     delete [] mat;
   if (temp)    delete [] temp;
   if (r)       delete [] r;
   if (phi)     delete [] phi;
   if (rasterx) delete [] rasterx;
   if (rastery) delete [] rastery;
   if (rasterz) delete [] rasterz;
   if (u)       delete [] u;
   if (v)       delete [] v;
}

//------------------------------------------------------------------------
void TSurface::PrepareCulledSurface(int n1,         //# of raster positions in depth
                                    int n2,         //# of raster positions in width
                                    float zNear,    //near clipping area
                                    float zFar){    //far clipping area
//------------------------------------------------------------------------
   nDepth = n1;
   nWidth = n2;

   temp = new float[nDepth];
   r    = new float[nDepth];
   phi = new float[nWidth];

   rasterx = new float*[nDepth];
   rastery = new float*[nDepth];
   rasterz = new float*[nDepth];
   u       = new float*[nDepth];
   v       = new float*[nDepth];
   for (int i=0;i<nDepth;i++){
      rasterx[i] = new float[nWidth];
      rastery[i] = new float[nWidth];
      rasterz[i] = new float[nWidth];
      u[i]       = new float[nWidth];
      v[i]       = new float[nWidth];
   }

   //Radius exponential distribution
   for (int i=0;i<nDepth;i++){
      temp[i] = 1.0 - exp((float)i/(float)nDepth);
   }
   for (int i=0;i<nDepth;i++){
      temp[i] /= temp[nDepth-1];
   }
   for (int i=0;i<nDepth;i++){
      r[i] = zNear + (temp[i] * (zFar - zNear));
   }
}

//------------------------------------------------------------------------
void TSurface::RenderCulledSurface(float fovy,      //angle of frustum
                                   float phiCam,    //view angle of camera
                                   float xCam,      //x position of camera
                                   float zCam){     //z position of camera
//------------------------------------------------------------------------
   float phi0, phi1;
   int   x,z;
   float v1[3],v2[3],norm[3];

   //Angle linear distribution
   phi0 = phiCam-fovy;
   phi1 = phiCam+fovy;

   for (int i=0;i<nWidth;i++){
      phi[i] = phi0 + ((float)i/(float)nWidth * (phi1 - phi0));
   }

   //Access the z-values with raster-positions
   for (int i=0;i<nDepth;i++){
      for (int j=0;j<nWidth;j++){
         x = XMARoundi(xCam + r[i]*sin(phi[j]*M_PI/180.0));
         z = XMARoundi(zCam + r[i]*cos(phi[j]*M_PI/180.0));

         u[i][j] = (float)x/(float)dimX*1.0;
         v[i][j] = (float)z/(float)dimZ*1.0;

         rasterx[i][j] = (float)x;
         rasterz[i][j] = (float)z;
         if      ((x >= dimX)   || (z >= dimZ)) rastery[i][j] = 0.0;
         else if ((x < 0)      || (z < 0))    rastery[i][j] = 0.0;
         else                                   rastery[i][j] = mat[x][z];
      }
   }

   glEnable(GL_TEXTURE_2D);
   glBindTexture(GL_TEXTURE_2D,texID);
   glPushMatrix();
   for (int i=0;i<nDepth-1;i++){
      glColor3f(1.3-(float)i/(float)nDepth,1.4-(float)i/(float)nDepth,1.0);
      glBegin(GL_TRIANGLE_STRIP);
      for (int j=0;j<nWidth-1;j++){
         v1[0] = (rasterx[i+1][j]-rasterx[i][j]);
         v1[1] = (rastery[i+1][j]-rastery[i][j]);
         v1[2] = (rasterz[i+1][j]-rasterz[i][j]);
         v2[0] = (rasterx[i][j+1]-rasterx[i][j]);
         v2[1] = (rastery[i][j+1]-rastery[i][j]);
         v2[2] = (rasterz[i][j+1]-rasterz[i][j]);
         XMACross(v1,v2,norm);

         glNormal3fv(norm);
         glTexCoord2f(u[i][j],v[i][j]);
         glVertex3f(scale*(xCam-rasterx[i] [j]) ,rastery[i] [j] ,scale*(zCam-rasterz[i] [j]));
         glTexCoord2f(u[i+1][j],v[i+1][j]);
         glVertex3f(scale*(xCam-rasterx[i+1][j]) ,rastery[i+1][j] ,scale*(zCam-rasterz[i+1][j]));
      }
      glEnd();
   }
   glPopMatrix();
   glDisable(GL_TEXTURE_2D);
}

//------------------------------------------------------------------------
float TSurface::GetSurfaceHeight(float x, float z){
//------------------------------------------------------------------------
   float y;
   int i,j;
   i = (int)x;
   j = (int)z;
   if ((i >= 0 && i < dimX) &&
       (j >= 0 && j < dimZ))
      y = mat[i][j];
   else
      y = 0.0;
   return y;
}