Changeset 825

Timestamp:

Dec 11, 2007 8:35:26 PM (16 years ago)

Author:

vrinside

Message:

Image Loader initialization

• Add BMP loader in Nv.cpp

Point Renderer code added..

• Put a data container and manage the containters with std::vector
• Renderer 1) scale factor part should be taken into account

Location:

trunk/vizservers/nanovis

Files:

• Makefile.in (modified) (3 diffs)
• Nv.cpp (modified) (6 diffs)
• PCASplit.cpp (modified) (2 diffs)
• PCASplit.h (modified) (1 diff)
• PointSet.cpp (added)
• PointSet.h (added)
• PointSetRenderer.cpp (added)
• PointSetRenderer.h (added)
• PointShader.cpp (modified) (1 diff)
• PointShader.h (modified) (2 diffs)
• Texture2D.cpp (modified) (1 diff)
• VolumeRenderer.cpp (modified) (2 diffs)
• nanovis.cpp (modified) (13 diffs)
• resources/particle2.bmp (added)

trunk/vizservers/nanovis/Makefile.in

@@ -41 +41 @@
                 NvEventLog.o NvParticleRenderer.o NvLIC.o NvZincBlendeReconstructor.o NvStdVertexShader.o \
                 ContourLineFilter.o HeightMap.o Grid.o \
-                PointShader.o PCASplit.o BucketSort.o \
+                PointShader.o PCASplit.o BucketSort.o PointSetRenderer.o \
                 bandmat.o cholesky.o evalue.o fft.o hholder.o jacobi.o myexcept.o newfft.o newmat1.o newmat2.o \
                 newmat3.o newmat4.o newmat5.o newmat6.o newmat7.o newmat8.o newmat9.o newmatex.o newmatnl.o \
                 newmatrm.o nm_misc.o solution.o sort.o svd.o submat.o \
+                Image.o ImageLoader.o ImageLoaderImpl.o BMPImageLoaderImpl.o ImageLoaderFactory.o \
                 R2string.o R2FilePath.o R2Fonts.o R2Object.o R2Geometry.o R2IndexBuffer.o R2VertexBuffer.o
 
@@ -152 +153 @@
 PCASplit.o: PCASplit.cpp PCASplit.h
 BucketSort.o: BucketSort.cpp BucketSort.h
+PointSetRenderer.o: PointSetRenderer.cpp PointSetRenderer.h
 bandmat.o: newmat11/bandmat.cpp
         $(CC) $(CFLAGS) -o $@ -c $<
@@ -203 +205 @@
         $(CC) $(CFLAGS) -o $@ -c $<
 
+Image.o: imgLoaders/Image.cpp
+        $(CC) $(CFLAGS) -o $@ -c $<
+ImageLoader.o: imgLoaders/ImageLoader.cpp
+        $(CC) $(CFLAGS) -o $@ -c $<
+ImageLoaderImpl.o: imgLoaders/ImageLoaderImpl.cpp
+        $(CC) $(CFLAGS) -o $@ -c $<
+BMPImageLoaderImpl.o: imgLoaders/BMPImageLoaderImpl.cpp
+        $(CC) $(CFLAGS) -o $@ -c $<
+ImageLoaderFactory.o: imgLoaders/ImageLoaderFactory.cpp
+        $(CC) $(CFLAGS) -o $@ -c $<
+
 nanovis.o: nanovis.cpp nanovis.h $(AUXSRC)

trunk/vizservers/nanovis/Nv.cpp

@@ -10 +10 @@
 #include <stdlib.h>
 #include <assert.h>
+#include <imgLoaders/BMPImageLoaderImpl.h>
+#include <imgLoaders/ImageLoaderFactory.h>
+#include "PointSetRenderer.h"
 
 extern void NvInitCG(); // in NvShader.cpp
@@ -15 +18 @@
 NvParticleRenderer* g_particleRenderer;
 NvColorTableRenderer* g_color_table_renderer;
+PointSetRenderer* g_pointset_renderer;
 VolumeRenderer* g_vol_render;
 R2Fonts* g_fonts;
 Grid* g_grid;
+
 
 //query opengl information
@@ -55 +60 @@
     fprintf(stdout, "Status: Using GLEW %s\n", glewGetString(GLEW_VERSION));
 }
+
+//init line integral convolution
+
 
 //init line integral convolution
@@ -121 +129 @@
 }
 
+void NvInitPointSetRenderer()
+{
+    g_pointset_renderer = new PointSetRenderer();
+}
+
 void NvInit(char* path)
 {
@@ -138 +151 @@
     // INSOO
     //g_color_table_renderer->setFonts(g_fonts);
+    //
+
+    ImageLoaderFactory::getInstance()->addLoaderImpl("bmp", new BMPImageLoaderImpl());
 
     g_grid = new Grid();
@@ -143 +159 @@
 
     NvInitVolumeRenderer();
+    NvInitPointSetRenderer();
     NvInitParticleRenderer();
    

trunk/vizservers/nanovis/PCASplit.cpp

@@ -122 +122 @@
 
         printf("Cluster created %d [in level %d]:total %d\n", count, level, cc);
+    fflush(stdout);
         
         int i = 0;
@@ -333 +334 @@
                                                 float(rand()) / RAND_MAX, float(rand()) / RAND_MAX, float(rand()) / RAND_MAX,
                                                 0.2);
+
+            printf("CLUSTER points : %d\n", node->data->numOfPoints_t);
+            fflush(stdout);
                                         
                                         points[i].position = node->data->centroid_t;

trunk/vizservers/nanovis/PCASplit.h

@@ -15 +15 @@
         Vector4 color;
         float size;
+    float value;
 public :
         Point() : size(1.0f) {}

trunk/vizservers/nanovis/PointShader.cpp

@@ -17 +17 @@
 
         }
+    else
+    {
+        printf("point shader loaded...\n");
+        fflush(stdout);
+    }
 
         this->loadVertexProgram(path, "main");

trunk/vizservers/nanovis/PointShader.h

@@ -27 +27 @@
         void setScale(float scale);
         void setNormalTexture(Texture3D* n);
+    void bind();
+    void unbind();
 };
 
@@ -39 +41 @@
 }
 
+inline void PointShader::bind()
+{
+    setParameters();
+
+    if (_cgVP)
+    {
+        cgGLBindProgram(_cgVP);
+        cgGLEnableProfile((CGprofile) CG_PROFILE_VP30);
+    }
+    if (_cgFP)
+    {
+        cgGLBindProgram(_cgFP);
+        cgGLEnableProfile((CGprofile) CG_PROFILE_FP30);
+    }
+}
+
+inline void PointShader::unbind()
+{
+    if (_cgVP)
+    {
+        cgGLDisableProfile((CGprofile)CG_PROFILE_VP30 );
+    }
+    
+    if (_cgFP)
+    {
+        cgGLDisableProfile((CGprofile)CG_PROFILE_FP30 );
+    }
+    
+    resetParameters();
+}
+
 #endif // __POINTSHADER_H__

trunk/vizservers/nanovis/Texture2D.cpp

@@ -94 +94 @@
           }
         }
+    else
+    {
+        int comp[5] = { -1, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_RGBA };
+                glTexImage2D(GL_TEXTURE_2D, 0, comp[n_components], width, height, 0, GL_RGBA, type, data);
+    }
 
         assert(glGetError()==0);

trunk/vizservers/nanovis/VolumeRenderer.cpp

@@ -112 +112 @@
 void VolumeRenderer::render_all_points()
 {
+/*
     double x0 = 0;
     double y0 = 0;
@@ -137 +138 @@
     glPopMatrix();
   }
+*/
 }
 

trunk/vizservers/nanovis/nanovis.cpp

@@ -29 +29 @@
 
 #include "Nv.h"
+#include "PointSetRenderer.h"
+#include "PointSet.h"
 
 #include "nanovis.h"
@@ -60 +62 @@
 
 extern VolumeRenderer* g_vol_render;
+extern PointSetRenderer* g_pointset_renderer;
 extern NvColorTableRenderer* g_color_table_renderer;
 extern Grid* g_grid;
@@ -149 +152 @@
 
 vector<HeightMap*> g_heightMap;
+vector<PointSet*> g_pointSet;
 
 // maps transfunc name to TransferFunction object
@@ -914 +918 @@
                 }
             }
+/*
+            else if (!strcmp(header, "<FET>"))
+            {
+                printf("FET loading...\n");
+                fflush(stdout);
+                std::stringstream fdata;
+                fdata.write(buf.bytes(),buf.size());
+                //err = load_volume_stream3(n, fdata);
+
+                if (err) {
+                    Tcl_AppendResult(interp, err.remark().c_str(), (char*)NULL);
+                    return TCL_ERROR;
+                }
+            }
+*/
             else
             {
@@ -1437 +1456 @@
         "\": should be data, outline, shading, or state", (char*)NULL);
     return TCL_ERROR;
+}
+
+int TestCmd _ANSI_ARGS_((ClientData cdata, Tcl_Interp *interp, int argc, CONST84 char *argv[]))
+{
+    std::ifstream fin;
+    fin.open("/home/nanohub/vrinside/nv/data/fet/graph-finfet.txt", std::ios::binary);
+                //std::stringstream fdata(std::ios_base::out|std::ios_base::in|std::ios_base::binary);
+
+    if (!fin) 
+    {
+        printf("file not found\n");
+        return TCL_OK;
+    }
+
+    float temp1, temp2, temp3;
+    float vmin, vmax;
+    int count;
+    char* start;
+
+    char line[128];
+    char temp[24];
+    float dx, dy, dz;
+    float x0, y0, z0;
+    do {
+        fin.getline(line,sizeof(line)-1);
+
+        // skip leading blanks
+        for (start=&line[0]; *start == ' ' || *start == '\t'; start++);
+
+        if (*start != '#') 
+        {  
+            sscanf(start, "%s%f%f%f", temp, &temp1, &temp2, &temp3);
+            if (!strcmp(temp, "size"))
+            {
+                dx = temp1;
+                dy = temp2;
+                dz = temp3;
+            }
+            else if (!strcmp(temp, "size"))
+            {
+                x0 = temp1;
+                y0 = temp2;
+                z0 = temp3;
+            }
+            else if (!strcmp(temp, "minmax"))
+            {
+                vmin = temp1;
+                vmax = temp2;
+            }
+            else if (!strcmp(temp, "count"))
+            {
+                count = temp1;
+            }
+            else if (!strcmp(temp, "</FET>"))
+            {
+                break;
+            }
+        }
+    } while (!fin.eof());
+
+    printf("data count %d \n", count);
+    fflush(stdout);
+
+    Vector4* data = new Vector4[count];
+    memset(data, 0, sizeof(Vector4) * count);
+    float min = 1e21, max = 1e-21;
+    for (int i = 0; i < count; ++i)
+    {
+        fin.getline(line,sizeof(line)-1);
+        sscanf(line, "%f%f%f%f", &data[i].x, &data[i].y, &data[i].z, &data[i].w);
+
+        if (data[i].w < min) min = data[i].w;
+        if (data[i].w > max) max = data[i].w;
+    }
+
+    float d = max - min;
+    for (int i = 0; i < count; ++i)
+    {
+        data[i].w = (data[i].w - min) / d;
+    }
+
+    PointSet* newPointSet = new PointSet();
+    newPointSet->initialize(data, count);
+    newPointSet->setVisible(true);
+    g_pointSet.push_back(newPointSet);
+    
+    return TCL_OK;
 }
 
@@ -2342 +2448 @@
                     return result.error(mesg);
                 }
+                break;
+            }
+        }
+    } while (!fin.eof());
+
+    // read data points
+    if (!fin.eof()) {
+        if (isrect) {
+            Rappture::Mesh1D xgrid(x0, x0+nx*dx, nx);
+            Rappture::Mesh1D ygrid(y0, y0+ny*dy, ny);
+            Rappture::Mesh1D zgrid(z0, z0+nz*dz, nz);
+            Rappture::FieldRect3D field(xgrid, ygrid, zgrid);
+
+            double dval[6];
+            int nread = 0;
+            int ix = 0;
+            int iy = 0;
+            int iz = 0;
+            while (!fin.eof() && nread < npts) {
+                fin.getline(line,sizeof(line)-1);
+                int n = sscanf(line, "%lg %lg %lg %lg %lg %lg", &dval[0], &dval[1], &dval[2], &dval[3], &dval[4], &dval[5]);
+
+                for (int p=0; p < n; p++) {
+                    int nindex = iz*nx*ny + iy*nx + ix;
+                    field.define(nindex, dval[p]);
+                    nread++;
+                    if (++iz >= nz) {
+                        iz = 0;
+                        if (++iy >= ny) {
+                            iy = 0;
+                            ++ix;
+                        }
+                    }
+                }
+            }
+
+            // make sure that we read all of the expected points
+            if (nread != nx*ny*nz) {
+                char mesg[256];
+                sprintf(mesg,"inconsistent data: expected %d points but found %d points", nx*ny*nz, nread);
+                result.error(mesg);
+                return result;
+            }
+
+            // figure out a good mesh spacing
+            int nsample = 30;
+            dx = field.rangeMax(Rappture::xaxis) - field.rangeMin(Rappture::xaxis);
+            dy = field.rangeMax(Rappture::yaxis) - field.rangeMin(Rappture::yaxis);
+            dz = field.rangeMax(Rappture::zaxis) - field.rangeMin(Rappture::zaxis);
+            double dmin = pow((dx*dy*dz)/(nsample*nsample*nsample), 0.333);
+
+            nx = (int)ceil(dx/dmin);
+            ny = (int)ceil(dy/dmin);
+            nz = (int)ceil(dz/dmin);
+
+#ifndef NV40
+            // must be an even power of 2 for older cards
+                nx = (int)pow(2.0, ceil(log10((double)nx)/log10(2.0)));
+                ny = (int)pow(2.0, ceil(log10((double)ny)/log10(2.0)));
+                nz = (int)pow(2.0, ceil(log10((double)nz)/log10(2.0)));
+#endif
+
+            float *data = new float[4*nx*ny*nz];
+
+            double vmin = field.valueMin();
+            double dv = field.valueMax() - field.valueMin();
+            if (dv == 0.0) { dv = 1.0; }
+
+            // generate the uniformly sampled data that we need for a volume
+            int ngen = 0;
+            double nzero_min = 0.0;
+            for (int iz=0; iz < nz; iz++) {
+                double zval = z0 + iz*dmin;
+                for (int iy=0; iy < ny; iy++) {
+                    double yval = y0 + iy*dmin;
+                    for (int ix=0; ix < nx; ix++) {
+                        double xval = x0 + ix*dmin;
+                        double v = field.value(xval,yval,zval);
+
+                        if (v != 0.0f && v < nzero_min)
+                        {
+                            nzero_min = v;
+                        }
+
+                        // scale all values [0-1], -1 => out of bounds
+                        v = (isnan(v)) ? -1.0 : (v - vmin)/dv;
+
+                        data[ngen] = v;
+                        ngen += 4;
+                    }
+                }
+            }
+
+            // Compute the gradient of this data.  BE CAREFUL: center
+            // calculation on each node to avoid skew in either direction.
+            ngen = 0;
+            for (int iz=0; iz < nz; iz++) {
+                for (int iy=0; iy < ny; iy++) {
+                    for (int ix=0; ix < nx; ix++) {
+                        // gradient in x-direction
+                        double valm1 = (ix == 0) ? 0.0 : data[ngen-4];
+                        double valp1 = (ix == nx-1) ? 0.0 : data[ngen+4];
+                        if (valm1 < 0 || valp1 < 0) {
+                            data[ngen+1] = 0.0;
+                        } else {
+                            data[ngen+1] = ((valp1-valm1) + 1) *  0.5; // assume dx=1
+                        }
+
+                        // gradient in y-direction
+                        valm1 = (iy == 0) ? 0.0 : data[ngen-4*nx];
+                        valp1 = (iy == ny-1) ? 0.0 : data[ngen+4*nx];
+                        if (valm1 < 0 || valp1 < 0) {
+                            data[ngen+2] = 0.0;
+                        } else {
+                            //data[ngen+2] = valp1-valm1; // assume dy=1
+                            data[ngen+2] = ((valp1-valm1) + 1) *  0.5; // assume dx=1
+                        }
+
+                        // gradient in z-direction
+                        valm1 = (iz == 0) ? 0.0 : data[ngen-4*nx*ny];
+                        valp1 = (iz == nz-1) ? 0.0 : data[ngen+4*nx*ny];
+                        if (valm1 < 0 || valp1 < 0) {
+                            data[ngen+3] = 0.0;
+                        } else {
+                            //data[ngen+3] = valp1-valm1; // assume dz=1
+                            data[ngen+3] = ((valp1-valm1) + 1) *  0.5; // assume dz=1
+                        }
+
+                        ngen += 4;
+                    }
+                }
+            }
+
+            load_volume(index, nx, ny, nz, 4, data,
+                field.valueMin(), field.valueMax(), nzero_min);
+
+            delete [] data;
+
+        } else {
+            Rappture::Mesh1D zgrid(z0, z0+nz*dz, nz);
+            Rappture::FieldPrism3D field(xymesh, zgrid);
+
+            double dval;
+            int nread = 0;
+            int ixy = 0;
+            int iz = 0;
+            while (!fin.eof() && nread < npts) {
+                if (!(fin >> dval).fail()) {
+                    int nid = nxy*iz + ixy;
+                    field.define(nid, dval);
+
+                    nread++;
+                    if (++iz >= nz) {
+                        iz = 0;
+                        ixy++;
+                    }
+                }
+            }
+
+            // make sure that we read all of the expected points
+            if (nread != nxy*nz) {
+                char mesg[256];
+                sprintf(mesg,"inconsistent data: expected %d points but found %d points", nxy*nz, nread);
+                return result.error(mesg);
+            }
+
+            // figure out a good mesh spacing
+            int nsample = 30;
+            x0 = field.rangeMin(Rappture::xaxis);
+            dx = field.rangeMax(Rappture::xaxis) - field.rangeMin(Rappture::xaxis);
+            y0 = field.rangeMin(Rappture::yaxis);
+            dy = field.rangeMax(Rappture::yaxis) - field.rangeMin(Rappture::yaxis);
+            z0 = field.rangeMin(Rappture::zaxis);
+            dz = field.rangeMax(Rappture::zaxis) - field.rangeMin(Rappture::zaxis);
+            double dmin = pow((dx*dy*dz)/(nsample*nsample*nsample), 0.333);
+
+            nx = (int)ceil(dx/dmin);
+            ny = (int)ceil(dy/dmin);
+            nz = (int)ceil(dz/dmin);
+#ifndef NV40
+            // must be an even power of 2 for older cards
+                nx = (int)pow(2.0, ceil(log10((double)nx)/log10(2.0)));
+                ny = (int)pow(2.0, ceil(log10((double)ny)/log10(2.0)));
+                nz = (int)pow(2.0, ceil(log10((double)nz)/log10(2.0)));
+#endif
+            float *data = new float[4*nx*ny*nz];
+
+            double vmin = field.valueMin();
+            double dv = field.valueMax() - field.valueMin();
+            if (dv == 0.0) { dv = 1.0; }
+
+            // generate the uniformly sampled data that we need for a volume
+            int ngen = 0;
+            double nzero_min = 0.0;
+            for (iz=0; iz < nz; iz++) {
+                double zval = z0 + iz*dmin;
+                for (int iy=0; iy < ny; iy++) {
+                    double yval = y0 + iy*dmin;
+                    for (int ix=0; ix < nx; ix++) {
+                        double xval = x0 + ix*dmin;
+                        double v = field.value(xval,yval,zval);
+
+                        if (v != 0.0f && v < nzero_min)
+                        {
+                            nzero_min = v;
+                        }
+                        // scale all values [0-1], -1 => out of bounds
+                        v = (isnan(v)) ? -1.0 : (v - vmin)/dv;
+                        data[ngen] = v;
+
+                        ngen += 4;
+                    }
+                }
+            }
+
+            // Compute the gradient of this data.  BE CAREFUL: center
+            // calculation on each node to avoid skew in either direction.
+            ngen = 0;
+            for (int iz=0; iz < nz; iz++) {
+                for (int iy=0; iy < ny; iy++) {
+                    for (int ix=0; ix < nx; ix++) {
+                        // gradient in x-direction
+                        double valm1 = (ix == 0) ? 0.0 : data[ngen-1];
+                        double valp1 = (ix == nx-1) ? 0.0 : data[ngen+1];
+                        if (valm1 < 0 || valp1 < 0) {
+                            data[ngen+1] = 0.0;
+                        } else {
+                            //data[ngen+1] = valp1-valm1; // assume dx=1
+                            data[ngen+1] = ((valp1-valm1) + 1) *  0.5; // assume dx=1
+                        }
+
+                        // gradient in y-direction
+                        valm1 = (iy == 0) ? 0.0 : data[ngen-4*nx];
+                        valp1 = (iy == ny-1) ? 0.0 : data[ngen+4*nx];
+                        if (valm1 < 0 || valp1 < 0) {
+                            data[ngen+2] = 0.0;
+                        } else {
+                            //data[ngen+2] = valp1-valm1; // assume dy=1
+                            data[ngen+2] = ((valp1-valm1) + 1) *  0.5; // assume dy=1
+                        }
+
+                        // gradient in z-direction
+                        valm1 = (iz == 0) ? 0.0 : data[ngen-4*nx*ny];
+                        valp1 = (iz == nz-1) ? 0.0 : data[ngen+4*nx*ny];
+                        if (valm1 < 0 || valp1 < 0) {
+                            data[ngen+3] = 0.0;
+                        } else {
+                            //data[ngen+3] = valp1-valm1; // assume dz=1
+                            data[ngen+3] = ((valp1-valm1) + 1) *  0.5; // assume dz=1
+                        }
+
+                        ngen += 4;
+                    }
+                }
+            }
+
+            load_volume(index, nx, ny, nz, 4, data,
+                field.valueMin(), field.valueMax(), nzero_min);
+
+            delete [] data;
+        }
+    } else {
+        return result.error("data not found in stream");
+    }
+
+    //
+    // Center this new volume on the origin.
+    //
+    float dx0 = -0.5;
+    float dy0 = -0.5*dy/dx;
+    float dz0 = -0.5*dz/dx;
+    volume[index]->move(Vector3(dx0, dy0, dz0));
+
+    return result;
+}
+
+Rappture::Outcome
+load_volume_stream3(int index, std::iostream& fin) 
+{
+    Rappture::Outcome result;
+
+    Rappture::MeshTri2D xymesh;
+    int dummy, nx, ny, nz, nxy, npts;
+    double x0, y0, z0, dx, dy, dz, ddx, ddy, ddz;
+    char line[128], type[128], *start;
+
+    int isrect = 1;
+
+    float temp1, temp2, temp3;
+    float vmin, vmax;
+    int count;
+
+    char temp[24];
+    do {
+        fin.getline(line,sizeof(line)-1);
+
+        // skip leading blanks
+        for (start=&line[0]; *start == ' ' || *start == '\t'; start++);
+
+        if (*start != '#') 
+        {  
+            sscanf(start, "%s%f%f%f", temp, &temp1, &temp2, &temp3);
+            if (!strcmp(temp, "size"))
+            {
+                dx = temp1;
+                dy = temp2;
+                dz = temp3;
+            }
+            else if (!strcmp(temp, "size"))
+            {
+                x0 = temp1;
+                y0 = temp2;
+                z0 = temp3;
+            }
+            else if (!strcmp(temp, "minmax"))
+            {
+                vmin = temp1;
+                vmax = temp2;
+            }
+            else if (!strcmp(temp, "count"))
+            {
+                count = temp1;
+            }
+            else if (!strcmp(temp, "<FET>"))
+            {
                 break;
             }
@@ -2891 +3322 @@
    g_vol_render = new VolumeRenderer();
 
-   
    /*
    //I added this to debug : Wei
@@ -2906 +3336 @@
    */
 
-
    //create an 2D plane renderer
    plane_render = new PlaneRenderer(g_context, win_width, win_height);
@@ -2921 +3350 @@
 
 
-void initTcl(){
+void initTcl()
+{
     interp = Tcl_CreateInterp();
     Tcl_MakeSafe(interp);
@@ -2966 +3396 @@
     // get screenshot
     Tcl_CreateCommand(interp, "screenshot", ScreenShotCmd,
+        (ClientData)NULL, (Tcl_CmdDeleteProc*)NULL);
+
+    Tcl_CreateCommand(interp, "test", TestCmd,
         (ClientData)NULL, (Tcl_CmdDeleteProc*)NULL);
 
@@ -3726 +4159 @@
         }
 
+        glPushMatrix();
         //now render things in the scene
         if (axis_on)
@@ -3746 +4180 @@
 
         perf->enable();
-        //g_vol_render->render_all();
-        g_vol_render->render_all_points();
+        g_vol_render->render_all();
+
         perf->disable();
 
@@ -3754 +4188 @@
             if (g_heightMap[ii]->isVisible())
                 g_heightMap[ii]->render();
+        }
+
+        glPopMatrix();
+
+        float mat[16];
+        glGetFloatv(GL_MODELVIEW_MATRIX, mat);
+
+        for (int i = 0; i < g_pointSet.size(); ++i)
+        {
+            if (g_pointSet[i]->isVisible())
+            {
+                g_pointset_renderer->render(g_pointSet[i]->getCluster(), mat, g_pointSet[i]->getSortLevel());
+            }
         }