Changeset 2877 for trunk/packages

Timestamp:

Mar 23, 2012 1:31:05 AM (12 years ago)

Author:

ldelgass

Message:

Some minor refactoring, also add some more fine grained config.h defines
(e.g. replace NV40 define with feature defines). Add tests for some required
OpenGL extensions (should always check for extensions or base version before
calling entry points from the extension). Also, clamp diffuse and specular
values on input and warn when they are out of range.

Location:

trunk/packages/vizservers/nanovis

Files:

• CircularQueue.h (modified) (1 diff)
• Command.cpp (modified) (43 diffs)
• ContourLineFilter.h (modified) (1 diff)
• ConvexPolygon.cpp (modified) (6 diffs)
• ConvexPolygon.h (modified) (2 diffs)
• FlowCmd.cpp (modified) (29 diffs)
• GradientFilter.cpp (modified) (4 diffs)
• GradientFilter.h (modified) (1 diff)
• HeightMap.cpp (modified) (6 diffs)
• HeightMap.h (modified) (2 diffs)
• NvCamera.cpp (modified) (2 diffs)
• NvCamera.h (modified) (5 diffs)
• NvFlowVisRenderer.h (modified) (1 diff)
• NvRegularVolumeShader.cpp (modified) (2 diffs)
• NvShader.cpp (modified) (1 diff)
• NvZincBlendeReconstructor.h (modified) (2 diffs)
• NvZincBlendeVolumeShader.cpp (modified) (4 diffs)
• NvZincBlendeVolumeShader.h (modified) (1 diff)
• PerfQuery.cpp (modified) (1 diff)
• PerfQuery.h (modified) (2 diffs)
• R2/include/R2/R2FilePath.h (modified) (1 diff)
• R2/src/R2Fonts.cpp (modified) (1 diff)
• README (modified) (1 diff)
• Switch.h (modified) (2 diffs)
• Texture2D.cpp (modified) (2 diffs)
• Texture3D.cpp (modified) (2 diffs)
• Unirect.cpp (modified) (1 diff)
• Vector3.h (modified) (2 diffs)
• VelocityArrowsSlice.cpp (modified) (1 diff)
• Volume.cpp (modified) (5 diffs)
• Volume.h (modified) (20 diffs)
• VolumeInterpolator.cpp (modified) (5 diffs)
• VolumeInterpolator.h (modified) (3 diffs)
• VolumeRenderer.cpp (modified) (34 diffs)
• VolumeRenderer.h (modified) (5 diffs)
• ZincBlendeVolume.cpp (modified) (3 diffs)
• ZincBlendeVolume.h (modified) (1 diff)
• config.h (modified) (2 diffs)
• dxReader.cpp (modified) (12 diffs)
• dxReader.h (modified) (1 diff)
• dxReaderCommon.cpp (modified) (5 diffs)
• dxReaderCommon.h (modified) (1 diff)
• nanovis.cpp (modified) (98 diffs)
• nanovis.h (modified) (6 diffs)
• shaders/one_volume.cg (modified) (2 diffs)
• shaders/particlefp.cg (modified) (1 diff)
• shaders/velocity.cg (modified) (3 diffs)
• shaders/velocityslicevp.cg (modified) (1 diff)
• shaders/vertex_std.cg (modified) (2 diffs)
• vrmath/include/vrmath/vrBPlane.h (modified) (1 diff)
• vrmath/include/vrmath/vrLineSegment.h (modified) (1 diff)
• vrmath/include/vrmath/vrMatrix4x4f.h (modified) (5 diffs)
• vrmath/include/vrmath/vrPlane.h (modified) (1 diff)
• vrmath/include/vrmath/vrPlane2.h (modified) (2 diffs)

trunk/packages/vizservers/nanovis/CircularQueue.h

@@ -103 +103 @@
 * It is up to the caller to handle this case
 *
-* \param item_ return by reference the wanted item
 * \return whether operation was successful or not */
 template<typename Element, unsigned int Size>

trunk/packages/vizservers/nanovis/Command.cpp

@@ -259 +259 @@
     hmPtr = new HeightMap();
     hmPtr->setHeight(xMin, yMin, xMax, yMax, xNum, yNum, heights);
-    hmPtr->transferFunction(NanoVis::get_transfunc("default"));
+    hmPtr->transferFunction(NanoVis::getTransfunc("default"));
     hmPtr->setVisible(true);
     hmPtr->setLineContourVisible(true);
@@ -607 +607 @@
 }
 
-
 static int
 CameraPanOp(ClientData clientData, Tcl_Interp *interp, int objc, 
@@ -675 +674 @@
     int w, h;
 
-    w = NanoVis::win_width, h = NanoVis::win_height;
-    NanoVis::resize_offscreen_buffer(2048, 2048);
+    w = NanoVis::winWidth, h = NanoVis::winHeight;
+    NanoVis::resizeOffscreenBuffer(2048, 2048);
 #ifdef notdef
-    NanoVis::cam->set_screen_size(0, 0, NanoVis::win_width,NanoVis::win_height);
+    NanoVis::cam->set_screen_size(0, 0, NanoVis::winWidth, NanoVis::winHeight);
     NanoVis::cam->set_screen_size(30, 90, 2048 - 60, 2048 - 120);
 #endif
-    NanoVis::offscreen_buffer_capture();  //enable offscreen render
+    NanoVis::offscreenBufferCapture();  //enable offscreen render
     NanoVis::display();
-    NanoVis::read_screen();
+    NanoVis::readScreen();
 #ifdef notdef
     glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); 
 #endif
-    NanoVis::ppm_write("nv>image -bytes %d -type print");
-    NanoVis::resize_offscreen_buffer(w, h);
+    NanoVis::ppmWrite("nv>image -bytes %d -type print");
+    NanoVis::resizeOffscreenBuffer(w, h);
     return TCL_OK;
 }
@@ -719 +718 @@
     std::vector<Volume *>::iterator iter;
     for (iter = ivol.begin(); iter != ivol.end(); iter++) {
-        (*iter)->move_cutplane(axis, relval);
+        (*iter)->moveCutplane(axis, relval);
     }
     return TCL_OK;
@@ -748 +747 @@
         std::vector<Volume *>::iterator iter;
         for (iter = ivol.begin(); iter != ivol.end(); iter++) {
-            (*iter)->enable_cutplane(axis);
+            (*iter)->enableCutplane(axis);
         }
     } else {
         std::vector<Volume *>::iterator iter;
         for (iter = ivol.begin(); iter != ivol.end(); iter++) {
-            (*iter)->disable_cutplane(axis);
+            (*iter)->disableCutplane(axis);
         }
     }
@@ -818 +817 @@
     name = Tcl_GetString(objv[1]);
     TransferFunction *tf;
-    tf = NanoVis::get_transfunc(name);
+    tf = NanoVis::getTransfunc(name);
     if (tf == NULL) {
         Tcl_AppendResult(interp, "unknown transfer function \"", name, "\"",
@@ -829 +828 @@
         return TCL_ERROR;
     }
-    if (Volume::update_pending) {
-        NanoVis::SetVolumeRanges();
-    }
-    NanoVis::render_legend(tf, Volume::valueMin, Volume::valueMax, w, h, name);
+    if (Volume::updatePending) {
+        NanoVis::setVolumeRanges();
+    }
+    NanoVis::renderLegend(tf, Volume::valueMin, Volume::valueMax, w, h, name);
     return TCL_OK;
 }
@@ -860 +859 @@
         return TCL_ERROR;
     }
-    NanoVis::resize_offscreen_buffer(w, h);
+    NanoVis::resizeOffscreenBuffer(w, h);
     return TCL_OK;
 }
@@ -964 +963 @@
         }
         // find or create this transfer function
-        NanoVis::DefineTransferFunction(Tcl_GetString(objv[2]), nslots, data);
+        NanoVis::defineTransferFunction(Tcl_GetString(objv[2]), nslots, data);
     } else {
         Tcl_AppendResult(interp, "bad option \"", string,
@@ -1010 +1009 @@
     }
     VolumeInterpolator* interpolator;
-    interpolator = NanoVis::vol_renderer->getVolumeInterpolator();
+    interpolator = NanoVis::volRenderer->getVolumeInterpolator();
     interpolator->start();
-    if (interpolator->is_started()) {
+    if (interpolator->isStarted()) {
         const char *fileName = (objc < 5) ? NULL : Tcl_GetString(objv[4]);
         for (int frame_num = 0; frame_num < total; ++frame_num) {
@@ -1022 +1021 @@
             interpolator->update(fraction);
 
-            NanoVis::offscreen_buffer_capture();  //enable offscreen render
+            NanoVis::offscreenBufferCapture();  //enable offscreen render
 
             NanoVis::display();
-            NanoVis::read_screen();
+            NanoVis::readScreen();
 
             glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
 
-            NanoVis::bmp_write_to_file(frame_num, fileName);
+            NanoVis::bmpWriteToFile(frame_num, fileName);
         }
     }
@@ -1039 +1038 @@
                        Tcl_Obj *const *objv)
 {
-    NanoVis::vol_renderer->clearAnimatedVolumeInfo();
+    NanoVis::volRenderer->clearAnimatedVolumeInfo();
     return TCL_OK;
 }
@@ -1047 +1046 @@
                        Tcl_Obj *const *objv)
 {
-    NanoVis::vol_renderer->startVolumeAnimation();
+    NanoVis::volRenderer->startVolumeAnimation();
     return TCL_OK;
 }
@@ -1055 +1054 @@
                       Tcl_Obj *const *objv)
 {
-    NanoVis::vol_renderer->stopVolumeAnimation();
+    NanoVis::volRenderer->stopVolumeAnimation();
     return TCL_OK;
 }
@@ -1074 +1073 @@
         Volume *volPtr;
         volPtr = (Volume *)Tcl_GetHashValue(hPtr);
-        NanoVis::vol_renderer->addAnimatedVolume(volPtr);
+        NanoVis::volRenderer->addAnimatedVolume(volPtr);
     }
     return TCL_OK;
@@ -1190 +1189 @@
     //
     if (volPtr != NULL) {
-        //volPtr->n_slices(512-n);
-        //volPtr->n_slices(256-n);
-        volPtr->disable_cutplane(0);
-        volPtr->disable_cutplane(1);
-        volPtr->disable_cutplane(2);
-        volPtr->transferFunction(NanoVis::get_transfunc("default"));
+        //volPtr->numSlices(512-n);
+        //volPtr->numSlices(256-n);
+        volPtr->disableCutplane(0);
+        volPtr->disableCutplane(1);
+        volPtr->disableCutplane(2);
+        volPtr->transferFunction(NanoVis::getTransfunc("default"));
         volPtr->visible(true);
 
@@ -1201 +1200 @@
         ssize_t nWritten;
 
-        if (Volume::update_pending) {
-            NanoVis::SetVolumeRanges();
+        if (Volume::updatePending) {
+            NanoVis::setVolumeRanges();
         }
 
@@ -1229 +1228 @@
     std::vector<Volume *>::iterator iter;
     for (iter = ivol.begin(); iter != ivol.end(); iter++) {
-        (*iter)->data_enabled(state);
+        (*iter)->dataEnabled(state);
     }
     return TCL_OK;
@@ -1274 +1273 @@
             return TCL_ERROR;
         }
-        NanoVis::remove_volume(volPtr);
-    }
-    NanoVis::EventuallyRedraw();
+        NanoVis::removeVolume(volPtr);
+    }
+    NanoVis::eventuallyRedraw();
     return TCL_OK;
 }
@@ -1345 +1344 @@
     std::vector<Volume *>::iterator iter;
     for (iter = ivol.begin(); iter != ivol.end(); iter++) {
-        (*iter)->set_outline_color(rgb);
+        (*iter)->setOutlineColor(rgb);
     }
     return TCL_OK;
@@ -1399 +1398 @@
         return TCL_ERROR;
     }
-
+    if (diffuse < 0.0f || diffuse > 1.0f) {
+        WARN("Invalid diffuse coefficient requested: %g, should be [0,1]", diffuse);
+    }
     std::vector<Volume *> ivol;
     if (GetVolumes(interp, objc - 4, objv + 4, &ivol) != TCL_OK) {
@@ -1446 +1447 @@
     std::vector<Volume *>::iterator iter;
     for (iter = ivol.begin(); iter != ivol.end(); iter++) {
-        (*iter)->opacity_scale(opacity);
+        (*iter)->opacityScale(opacity);
     }
     return TCL_OK;
@@ -1458 +1459 @@
     if (GetFloatFromObj(interp, objv[3], &specular) != TCL_OK) {
         return TCL_ERROR;
+    }
+    if (specular < 0.0f || specular > 128.0f) {
+        WARN("Invalid specular exponent requested: %g, should be [0,128]", specular);
     }
     std::vector<Volume *> ivol;
@@ -1476 +1480 @@
     TransferFunction *tfPtr;
     const char *name = Tcl_GetString(objv[3]);
-    tfPtr = NanoVis::get_transfunc(name);
+    tfPtr = NanoVis::getTransfunc(name);
     if (tfPtr == NULL) {
         Tcl_AppendResult(interp, "transfer function \"", name,
@@ -1493 +1497 @@
 #ifdef USE_POINTSET_RENDERER
         // TBD..
- //        if ((*iter)->pointsetIndex != -1) {
-//             NanoVis::pointSet[(*iter)->pointsetIndex]->updateColor(tf->getData(), 256);
-//         }
+        if ((*iter)->pointsetIndex != -1) {
+            NanoVis::pointSet[(*iter)->pointsetIndex]->updateColor(tfPtr->getData(), 256);
+        }
 #endif
     }
@@ -1544 +1548 @@
         label = Tcl_GetString(objv[4]);
         for (iter = ivol.begin(); iter != ivol.end(); iter++) {
-            (*iter)->set_label(axis, label);
+            (*iter)->setLabel(axis, label);
         }
     } else {
@@ -1584 +1588 @@
         Volume *volPtr;
         volPtr = (Volume *)Tcl_GetHashValue(hPtr);
-        volPtr->data_enabled(false);
+        volPtr->dataEnabled(false);
         volPtr->visible(false);
     }
@@ -1680 +1684 @@
     hmPtr->setHeight(data.xMin(), data.yMin(), data.xMax(), data.yMax(), 
                      data.xNum(), data.yNum(), data.transferValues());
-    hmPtr->transferFunction(NanoVis::get_transfunc("default"));
+    hmPtr->transferFunction(NanoVis::getTransfunc("default"));
     hmPtr->setVisible(true);
     hmPtr->setLineContourVisible(true);
-    NanoVis::EventuallyRedraw();
+    NanoVis::eventuallyRedraw();
     return TCL_OK;
 }
@@ -1703 +1707 @@
         (*iter)->setVisible(visible);
     }
-    NanoVis::EventuallyRedraw();
+    NanoVis::eventuallyRedraw();
     return TCL_OK;
 }
@@ -1744 +1748 @@
         (*iter)->setLineContourColor(rgb);
     }
-    NanoVis::EventuallyRedraw();
+    NanoVis::eventuallyRedraw();
     return TCL_OK;
 }
@@ -1764 +1768 @@
         (*iter)->setLineContourVisible(visible);
     }
-    NanoVis::EventuallyRedraw();
+    NanoVis::eventuallyRedraw();
     return TCL_OK;
 }
@@ -1797 +1801 @@
     }
     NanoVis::renderContext->setCullMode(mode);
-    NanoVis::EventuallyRedraw();
+    NanoVis::eventuallyRedraw();
     return TCL_OK;
 }
@@ -1823 +1827 @@
     Tcl_SetHashValue(hPtr, hmPtr);
     Tcl_SetStringObj(Tcl_GetObjResult(interp), tag, -1);;
-    NanoVis::EventuallyRedraw();
+    NanoVis::eventuallyRedraw();
     TRACE("Number of heightmaps=%d\n", NanoVis::heightmapTable.numEntries);
     return TCL_OK;
@@ -1850 +1854 @@
         return TCL_ERROR;
     }
-    if (HeightMap::update_pending) {
-        NanoVis::SetHeightmapRanges();
-    }
-    NanoVis::render_legend(tfPtr, HeightMap::valueMin, HeightMap::valueMax, 
-                w, h, tag);
+    if (HeightMap::updatePending) {
+        NanoVis::setHeightmapRanges();
+    }
+    NanoVis::renderLegend(tfPtr, HeightMap::valueMin, HeightMap::valueMax, 
+                          w, h, tag);
     return TCL_OK;
 }
@@ -1867 +1871 @@
     }
     NanoVis::renderContext->setPolygonMode(mode);
-    NanoVis::EventuallyRedraw();
+    NanoVis::eventuallyRedraw();
     return TCL_OK;
 }
@@ -1880 +1884 @@
     }
     NanoVis::renderContext->setShadingModel(model);
-    NanoVis::EventuallyRedraw();
+    NanoVis::eventuallyRedraw();
     return TCL_OK;
 }
@@ -1898 +1902 @@
     // GEORGE
 
-    NanoVis::render_2d_contour(heightmap, image_width, image_height);
-    NanoVis::EventuallyRedraw();
+    NanoVis::render2dContour(heightmap, image_width, image_height);
+    NanoVis::eventuallyRedraw();
     return TCL_OK;
 }
@@ -1929 +1933 @@
     float maxy = 3.5f;
     hmPtr->setHeight(minx, miny, maxx, maxy, 20, 20, data);
-    hmPtr->transferFunction(NanoVis::get_transfunc("default"));
+    hmPtr->transferFunction(NanoVis::getTransfunc("default"));
     hmPtr->setVisible(true);
     hmPtr->setLineContourVisible(true);
@@ -1945 +1949 @@
     int image_height = 512;
 
-    NanoVis::render_2d_contour(hmPtr, image_width, image_height);
+    NanoVis::render2dContour(hmPtr, image_width, image_height);
 
     return TCL_OK;
@@ -1957 +1961 @@
     name = Tcl_GetString(objv[2]);
     TransferFunction *tfPtr;
-    tfPtr = NanoVis::get_transfunc(name);
+    tfPtr = NanoVis::getTransfunc(name);
     if (tfPtr == NULL) {
         Tcl_AppendResult(interp, "transfer function \"", name,
@@ -1971 +1975 @@
         (*iter)->transferFunction(tfPtr);
     }
-    NanoVis::EventuallyRedraw();
+    NanoVis::eventuallyRedraw();
     return TCL_OK;
 }
@@ -1992 +1996 @@
         (*iter)->opacity(opacity);
     }
-    NanoVis::EventuallyRedraw();
+    NanoVis::eventuallyRedraw();
     return TCL_OK;
 }
@@ -2142 +2146 @@
             return TCL_ERROR;
         }
-        NanoVis::axis_on = visible;
+        NanoVis::axisOn = visible;
     } else {
         Tcl_AppendResult(interp, "bad axis option \"", string,

trunk/packages/vizservers/nanovis/ContourLineFilter.h

@@ -16 +16 @@
     {
     public:
-        float _value;
-        std::list<Vector3> _points;
-
         ContourLine(float value);
 
         /**
-         * @brief
-         * @ret Returns the number of points
+         * @return Returns the number of points
          */
         int createLine(int width, int height, Vector3 *vertices, bool top);
         int createLine(int width, int height, Vector4 *vertices, bool top);
+
+        float _value;
+        std::list<Vector3> _points;
 
     private:

trunk/packages/vizservers/nanovis/ConvexPolygon.cpp

@@ -100 +100 @@
 
 void
-ConvexPolygon::clip(Plane& clipPlane, bool copy_to_texcoord)
+ConvexPolygon::clip(Plane& clipPlane, bool copyToTexcoord)
 {
     if (vertices.size() == 0) {
@@ -123 +123 @@
     Vector4 plane = clipPlane.get_coeffs();
 
-    bool prevRetained = is_retained(vertices[0], plane);
+    bool prevRetained = isRetained(vertices[0], plane);
     if (prevRetained) 
         clippedVerts.push_back(vertices[0]);
 
     for (unsigned int i = 1; i < vertices.size(); i++) {
-        bool retained = is_retained(vertices[i], plane);
+        bool retained = isRetained(vertices[i], plane);
         if (retained != prevRetained) {
             bool found = findIntersection(vertices[i - 1], vertices[i], 
@@ -141 +141 @@
     }
 
-    bool retained = is_retained(vertices[0], plane);
+    bool retained = isRetained(vertices[0], plane);
     if (retained != prevRetained) {
         bool found = findIntersection(vertices[vertices.size() - 1], 
@@ -154 +154 @@
                     clippedVerts.end());
 
-    if (copy_to_texcoord)
-        copy_vertices_to_texcoords();
-}
-
-void
-ConvexPolygon::copy_vertices_to_texcoords()
+    if (copyToTexcoord)
+        copyVerticesToTexcoords();
+}
+
+void
+ConvexPolygon::copyVerticesToTexcoords()
 {
     if (texcoords.size() > 0)
@@ -170 +170 @@
 
 void
-ConvexPolygon::Emit(bool use_texture)
+ConvexPolygon::emit(bool useTexture)
 {
     if (vertices.size() >= 3) {
         for (unsigned int i = 0; i < vertices.size(); i++) {
-            if (use_texture) {
+            if (useTexture) {
                 glTexCoord4fv((float *)&(texcoords[i]));
                 //glTexCoord4fv((float *)&(vertices[i]));
@@ -184 +184 @@
 
 void 
-ConvexPolygon::Emit(bool use_texture, const Vector3& shift, const Vector3& scale) 
+ConvexPolygon::emit(bool useTexture, const Vector3& shift, const Vector3& scale) 
 {
     if (vertices.size() >= 3) {
         for (unsigned int i = 0; i < vertices.size(); i++) {
-            if (use_texture) {
+            if (useTexture) {
                 glTexCoord4fv((float *)&(vertices[i]));
             }

trunk/packages/vizservers/nanovis/ConvexPolygon.h

@@ -29 +29 @@
 {
 public:
-    VertexVector vertices;
-    TexVector texcoords;
-    int volume_id;      //which volume this polygon slice belongs to
-
     ConvexPolygon()
     {}
@@ -43 +39 @@
 
     // Clips the polygon, retaining the portion where ax + by + cz + d >= 0
-    void clip(Plane& clipPlane, bool copy_to_texcoords);
+    void clip(Plane& clipPlane, bool copyToTexcoords);
 
-    void Emit(bool use_texture);
+    void emit(bool useTexture);
 
-    void Emit(bool use_texture, const Vector3& shift, const Vector3& scale);
+    void emit(bool useTexture, const Vector3& shift, const Vector3& scale);
 
-    void copy_vertices_to_texcoords();
+    void copyVerticesToTexcoords();
 
-    void set_id(int v_id)
+    void setId(int id)
     { 
-        volume_id = v_id; 
+        volumeId = id; 
     }
 
-    void append_vertex(const Vector4& vert)
+    void appendVertex(const Vector4& vert)
     {
         vertices.push_back(vert);
     }
 
-    void insert_vertex(unsigned int index, const Vector4& vert)
+    void insertVertex(unsigned int index, const Vector4& vert)
     {
-        assert(index<vertices.size());
+        assert(index < vertices.size());
         vertices.insert(vertices.begin() + index, vert);
     }
 
-    bool is_retained(const Vector4& point, const Vector4& plane)
+    bool isRetained(const Vector4& point, const Vector4& plane)
     {
         return ((point * plane) >= 0);  
     }
+
+    VertexVector vertices;
+    TexVector texcoords;
+    int volumeId;       //which volume this polygon slice belongs to
 };
 

trunk/packages/vizservers/nanovis/FlowCmd.cpp

@@ -34 +34 @@
 #include "Unirect.h"
 #include "VelocityArrowsSlice.h"
+#include "Volume.h"
 
 #define RELPOS 0
@@ -294 +295 @@
     memset(&_sv, 0, sizeof(FlowValues));
     _sv.sliceVisible = 1;
-    _sv.tfPtr = NanoVis::get_transfunc("default");
+    _sv.tfPtr = NanoVis::getTransfunc("default");
 
     Tcl_InitHashTable(&_particlesTable, TCL_STRING_KEYS);
@@ -317 +318 @@
     }
     if (_volPtr != NULL) {
-        NanoVis::remove_volume(_volPtr);
+        NanoVis::removeVolume(_volPtr);
         _volPtr = NULL;
     }
@@ -530 +531 @@
     if (_volPtr != NULL) {
         TRACE("from ScaleVectorField volId=%s\n", _volPtr->name());
-        NanoVis::remove_volume(_volPtr);
+        NanoVis::removeVolume(_volPtr);
         _volPtr = NULL;
     }
@@ -575 +576 @@
         NanoVis::licRenderer->
             setVectorField(_volPtr->id, loc,
-                           1.0f / _volPtr->aspect_ratio_width,
-                           1.0f / _volPtr->aspect_ratio_height,
-                           1.0f / _volPtr->aspect_ratio_depth,
+                           1.0f / _volPtr->aspectRatioWidth,
+                           1.0f / _volPtr->aspectRatioHeight,
+                           1.0f / _volPtr->aspectRatioDepth,
                            _volPtr->wAxis.max());
         SetCurrentPosition();
@@ -589 +590 @@
                         //*(volPtr->get_location()),
                         1.0f,
-                        _volPtr->aspect_ratio_height / _volPtr->aspect_ratio_width,
-                        _volPtr->aspect_ratio_depth / _volPtr->aspect_ratio_width
+                        _volPtr->aspectRatioHeight / _volPtr->aspectRatioWidth,
+                        _volPtr->aspectRatioDepth / _volPtr->aspectRatioWidth
                         //,volPtr->wAxis.max()
                         );
@@ -657 +658 @@
     Volume *volPtr;
 
-    volPtr = NanoVis::load_volume(_name, _dataPtr->xNum(), _dataPtr->yNum(), 
-                                  _dataPtr->zNum(), 4, data, 
-                                  NanoVis::magMin, NanoVis::magMax, 0);
+    volPtr = NanoVis::loadVolume(_name, _dataPtr->xNum(), _dataPtr->yNum(), 
+                                 _dataPtr->zNum(), 4, data, 
+                                 NanoVis::magMin, NanoVis::magMax, 0);
     volPtr->xAxis.SetRange(_dataPtr->xMin(), _dataPtr->xMax());
     volPtr->yAxis.SetRange(_dataPtr->yMin(), _dataPtr->yMax());
@@ -672 +673 @@
           NanoVis::magMin, NanoVis::magMax);
     volPtr->setPhysicalBBox(physicalMin, physicalMax);
-    //volPtr->set_n_slice(256 - _volIndex);
-    // volPtr->set_n_slice(512- _volIndex);
-    //volPtr->n_slices(256-n);
+    //volPtr->numSlices(256 - _volIndex);
+    //volPtr->numSlices(512 - _volIndex);
+    //volPtr->numSlices(256 - n);
     // TBD..
     /* Don't set the slice number until we're are about to render the
        volume. */
-    volPtr->disable_cutplane(0);
-    volPtr->disable_cutplane(1);
-    volPtr->disable_cutplane(2);
+    volPtr->disableCutplane(0);
+    volPtr->disableCutplane(1);
+    volPtr->disableCutplane(2);
 
     /* Initialize the volume with the previously configured values. */
     volPtr->transferFunction(_sv.tfPtr);
-    volPtr->data_enabled(_sv.showVolume);
+    volPtr->dataEnabled(_sv.showVolume);
     volPtr->outline(_sv.showOutline);
-    volPtr->opacity_scale(_sv.opacity);
+    volPtr->opacityScale(_sv.opacity);
     volPtr->specular(_sv.specular);
     volPtr->diffuse(_sv.diffuse);
@@ -695 +696 @@
     float dz0 = -0.5*volPtr->depth/volPtr->width;
     volPtr->location(Vector3(dx0, dy0, dz0));
-    Volume::update_pending = true;
+    Volume::updatePending = true;
     return volPtr;
 }
@@ -765 +766 @@
     }
     flowPtr->data(dataPtr);
-    NanoVis::EventuallyRedraw(NanoVis::MAP_FLOWS);
+    NanoVis::eventuallyRedraw(NanoVis::MAP_FLOWS);
     return TCL_OK;
 }
@@ -857 +858 @@
         assert(nWritten == (ssize_t)strlen(info));
     }
-    NanoVis::EventuallyRedraw(NanoVis::MAP_FLOWS);
+    NanoVis::eventuallyRedraw(NanoVis::MAP_FLOWS);
     return TCL_OK;
 }
@@ -1331 +1332 @@
     TransferFunction **funcPtrPtr = (TransferFunction **)(record + offset);
     TransferFunction *funcPtr;
-    funcPtr = NanoVis::get_transfunc(Tcl_GetString(objPtr));
+    funcPtr = NanoVis::getTransfunc(Tcl_GetString(objPtr));
     if (funcPtr == NULL) {
         Tcl_AppendResult(interp, "transfer function \"", Tcl_GetString(objPtr),
@@ -1350 +1351 @@
         return TCL_ERROR;
     }
-    NanoVis::EventuallyRedraw(NanoVis::MAP_FLOWS);
+    NanoVis::eventuallyRedraw(NanoVis::MAP_FLOWS);
     return TCL_OK;
 }
@@ -1372 +1373 @@
     }
     particlesPtr->Configure();
-    NanoVis::EventuallyRedraw();
+    NanoVis::eventuallyRedraw();
     Tcl_SetObjResult(interp, objv[3]);
     return TCL_OK;
@@ -1391 +1392 @@
     }
     particlesPtr->Configure();
-    NanoVis::EventuallyRedraw(NanoVis::MAP_FLOWS);
+    NanoVis::eventuallyRedraw(NanoVis::MAP_FLOWS);
     return TCL_OK;
 }
@@ -1408 +1409 @@
         }
     }
-    NanoVis::EventuallyRedraw();
+    NanoVis::eventuallyRedraw();
     return TCL_OK;
 }
@@ -1486 +1487 @@
         return TCL_ERROR;
     }
-    NanoVis::EventuallyRedraw();
+    NanoVis::eventuallyRedraw();
     Tcl_SetObjResult(interp, objv[3]);
     return TCL_OK;
@@ -1504 +1505 @@
         }
     }
-    NanoVis::EventuallyRedraw();
+    NanoVis::eventuallyRedraw();
     return TCL_OK;
 }
@@ -1541 +1542 @@
         return TCL_ERROR;
     }
-    NanoVis::EventuallyRedraw();
+    NanoVis::eventuallyRedraw();
     return TCL_OK;
 }
@@ -1613 +1614 @@
         NanoVis::MapFlows();
     }
-    NanoVis::render_legend(tf, NanoVis::magMin, NanoVis::magMax, w, h, label);
+    NanoVis::renderLegend(tf, NanoVis::magMin, NanoVis::magMax, w, h, label);
     return TCL_OK;
 }
@@ -1681 +1682 @@
     }
     Tcl_SetObjResult(interp, objv[2]);
-    NanoVis::EventuallyRedraw();
+    NanoVis::eventuallyRedraw();
     return TCL_OK;
 }
@@ -1699 +1700 @@
         Tcl_DeleteCommand(interp, flowPtr->name());
     }
-    NanoVis::EventuallyRedraw(NanoVis::MAP_FLOWS);
+    NanoVis::eventuallyRedraw(NanoVis::MAP_FLOWS);
     return TCL_OK;
 }
@@ -1746 +1747 @@
         NanoVis::AdvectFlows();
     }
-    NanoVis::EventuallyRedraw();
+    NanoVis::eventuallyRedraw();
     return TCL_OK;
 }
@@ -1777 +1778 @@
         NanoVis::MapFlows();
     }
-    NanoVis::EventuallyRedraw();
+    NanoVis::eventuallyRedraw();
     NanoVis::licRenderer->convolve();
     NanoVis::AdvectFlows();
@@ -1880 +1881 @@
     values.frameRate = 25.0f;                // Default frame rate 25 fps
     values.bitRate = 6000000;                // Default video bit rate.
-    values.width = NanoVis::win_width;
-    values.height = NanoVis::win_height;
+    values.width = NanoVis::winWidth;
+    values.height = NanoVis::winHeight;
     values.nFrames = 100;
     values.format = Rappture::AVTranslate::MPEG1;
@@ -1907 +1908 @@
     // Save the old dimensions of the offscreen buffer.
     int oldWidth, oldHeight;
-    oldWidth = NanoVis::win_width;
-    oldHeight = NanoVis::win_height;
+    oldWidth = NanoVis::winWidth;
+    oldHeight = NanoVis::winHeight;
 
     TRACE("FLOW started\n");
@@ -1926 +1927 @@
     if ((values.width != oldWidth) || (values.height != oldHeight)) {
         // Resize to the requested size.
-        NanoVis::resize_offscreen_buffer(values.width, values.height);
+        NanoVis::resizeOffscreenBuffer(values.width, values.height);
     }
     // Now compute the line padding for the offscreen buffer.
@@ -1946 +1947 @@
         }
         NanoVis::AdvectFlows();
-        NanoVis::offscreen_buffer_capture();
+        NanoVis::offscreenBufferCapture();
         NanoVis::display();
-        NanoVis::read_screen();
+        NanoVis::readScreen();
         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
-        movie.append(context, NanoVis::screen_buffer, pad);
+        movie.append(context, NanoVis::screenBuffer, pad);
     }
     movie.done(context);
@@ -1971 +1972 @@
     }
     if ((values.width != oldWidth) || (values.height != oldHeight)) {
-        NanoVis::resize_offscreen_buffer(oldWidth, oldHeight);
+        NanoVis::resizeOffscreenBuffer(oldWidth, oldHeight);
     }
     NanoVis::ResetFlows();

trunk/packages/vizservers/nanovis/GradientFilter.cpp

@@ -15 +15 @@
 
 static int g_numOfSlices[3] = { 256, 256, 256 };
-static void *g_volData = 0;
+static void *g_volData = NULL;
 static float g_sliceDists[3];
 
@@ -23 +23 @@
 #define MAX(a,b) ((a) > (b) ? (a) : (b))
 #define MIN(a,b) ((a) < (b) ? (a) : (b))
-#define EPS 1e-5f
+#define EPS 1e-6f
 
 #ifdef notused
@@ -145 +145 @@
 }
 
-void computeGradients(float *gradients, void* volData, int *sizes, DataType dataType)
+void computeGradients(float *gradients, void *volData, int *sizes, 
+                      float *spacing, DataType dataType)
 {
     ::g_volData = volData;
@@ -152 +153 @@
     g_numOfSlices[2] = sizes[2];
 
-    g_sliceDists[0] = 1.0f / sizes[0];
-    g_sliceDists[1] = 1.0f / sizes[1];
-    g_sliceDists[2] = 1.0f / sizes[2];
+    g_sliceDists[0] = spacing[0];
+    g_sliceDists[1] = spacing[1];
+    g_sliceDists[2] = spacing[2];
 
     int i, j, k, dir, di, vdi, idz, idy, idx;

trunk/packages/vizservers/nanovis/GradientFilter.h

@@ -9 +9 @@
 } DataType;
 
-extern void computeGradients(float *gradients, void *volData, int *sizes, DataType dataType);
+extern void computeGradients(float *gradients, void *volData,
+                             int *sizes, float *spacing, DataType dataType);
 
 extern void filterGradients(float *gradients, int *sizes);

trunk/packages/vizservers/nanovis/HeightMap.cpp

@@ -19 +19 @@
 #include "RenderContext.h"
 
-bool HeightMap::update_pending = false;
+bool HeightMap::updatePending = false;
 double HeightMap::valueMin = 0.0;
 double HeightMap::valueMax = 1.0;
@@ -260 +260 @@
 
 void 
-HeightMap::setHeight(int xCount, int yCount, Vector3* heights)
+HeightMap::setHeight(int xCount, int yCount, Vector3 *heights)
 {
     _vertexCount = xCount * yCount;
     reset();
-    
-    _heights = (float *)heights; 
+
+    _heights = (float *)heights;
     float min, max;
     min = heights[0].y, max = heights[0].y;
@@ -287 +287 @@
     zAxis.SetRange(0.0, 1.0);
     wAxis.SetRange(min, max);
-    update_pending = true;
-    
+    updatePending = true;
+
     _centerPoint.set(_scale.x * 0.5, _scale.z * 0.5 + min, _scale.y * 0.5);
 
@@ -334 +334 @@
 void 
 HeightMap::setHeight(float xMin, float yMin, float xMax, float yMax, 
-                     int xNum, int yNum, float* heights)
+                     int xNum, int yNum, float *heights)
 {
     _vertexCount = xNum * yNum;
@@ -376 +376 @@
     _scale.x = _scale.y = _scale.z = 1.0;
 
-    update_pending = true;
+    updatePending = true;
 
     _centerPoint.set(0.5, 0.5, 0.5);
@@ -420 +420 @@
 }
 
-Vector3* 
+Vector3 *
 HeightMap::createHeightVertices(float xMin, float yMin, float xMax, 
-                                float yMax, int xNum, int yNum, float* height)
+                                float yMax, int xNum, int yNum, float *height)
 {
     Vector3* vertices = new Vector3[xNum * yNum];

trunk/packages/vizservers/nanovis/HeightMap.h

@@ -20 +20 @@
 
 /**
- *@class HeightMap
  *@brief Create a surface from height map and line contour of the generated surface
  */
@@ -123 +122 @@
 
     AxisRange xAxis, yAxis, zAxis, wAxis;
-    static bool update_pending;
+    static bool updatePending;
     static double valueMin, valueMax;
 

trunk/packages/vizservers/nanovis/NvCamera.cpp

@@ -19 +19 @@
 #include <GL/glew.h>
 #include <GL/glu.h>
+
+#include <vrmath/vrQuaternion.h>
+#include <vrmath/vrRotation.h>
+#include <vrmath/vrMatrix4x4f.h>
 
 #include "NvCamera.h"
@@ -61 +65 @@
     glLoadIdentity();
 
+#ifndef OLD_CAMERA
+    glTranslatef(-_location.x, -_location.y, -_location.z);
+    glMultMatrixf((const GLfloat *)_cameraMatrix.get());
+#else
+
     gluLookAt(_location.x, _location.y, _location.z,
               _target.x, _target.y, _target.z,
               0., 1., 0.);
 
-    glRotated(_angle.x, 1., 0., 0.);
-    glRotated(_angle.y, 0., 1., 0.);
-    glRotated(_angle.z, 0., 0., 1.);
+    if (_angle.x != 0.0f)
+        glRotated(_angle.x, 1., 0., 0.);
+    if (_angle.y != 0.0f)
+        glRotated(_angle.y, 0., 1., 0.);
+    if (_angle.z != 0.0f)
+        glRotated(_angle.z, 0., 0., 1.);
+#endif
 }
+
+void NvCamera::rotate(double *quat)
+{
+    vrQuaternion q(quat[0], quat[1], quat[2], quat[3]);
+    vrRotation rot;
+    rot.set(q);
+    _cameraMatrix.makeRotation(rot);
+    _cameraMatrix.transpose();
+    _angle.set(0, 0, 0);
+    TRACE("Set rotation to quat: %g %g %g %g\n",
+          quat[0], quat[1], quat[2], quat[3]);
+}
+
+void NvCamera::rotate(float angle_x, float angle_y, float angle_z)
+{
+#ifdef OLD_CAMERA
+    _angle = Vector3(angle_x, angle_y, angle_z);
+#else
+    angle_x = -angle_x;
+    angle_y = angle_y - 180.;
+    _angle = Vector3(angle_x, angle_y, angle_z);
+
+    _cameraMatrix.makeRotation(1, 0, 0, deg2rad(_angle.x));
+    vrMatrix4x4f mat;
+    mat.makeRotation(0, 1, 0, deg2rad(_angle.y));
+    _cameraMatrix.multiply(mat);
+    mat.makeRotation(0, 0, 1, deg2rad(_angle.z));
+    _cameraMatrix.multiply(mat);
+    //_cameraMatrix.transpose();
+#endif
+    TRACE("Set rotation to angles: %g %g %g\n",
+          _angle.x, _angle.y, _angle.z);
+}
+
+void NvCamera::rotate(const Vector3& angle)
+{ 
+#ifdef OLD_CAMERA
+    _angle = angle;
+#else
+    _angle.x = -angle.x;
+    _angle.y = angle.y - 180.;
+    _angle.z = angle.z;
+
+    _cameraMatrix.makeRotation(1, 0, 0, deg2rad(_angle.x));
+    vrMatrix4x4f mat;
+    mat.makeRotation(0, 1, 0, deg2rad(_angle.y));
+    _cameraMatrix.multiply(mat);
+    mat.makeRotation(0, 0, 1, deg2rad(_angle.z));
+    _cameraMatrix.multiply(mat);
+    //_cameraMatrix.transpose();
+#endif
+    TRACE("Set rotation to angles: %g %g %g\n",
+          _angle.x, _angle.y, _angle.z);
+}

trunk/packages/vizservers/nanovis/NvCamera.h

@@ -17 +17 @@
 #define CAMERA_H
 
+#include <vrmath/vrMatrix4x4f.h>
+
+#include "config.h"
 #include "Vector3.h"
 
@@ -29 +32 @@
     ~NvCamera()
     {}
-
 
     //move location of camera
@@ -93 +95 @@
     }
 
-    void rotate(float angle_x, float angle_y, float angle_z)
-    { 
-        _angle = Vector3(angle_x, angle_y, angle_z);
-    }
+    void rotate(double *quat);
 
-    void rotate(const Vector3& angle)
-    { 
-        _angle = angle;
-    }
+    void rotate(float angle_x, float angle_y, float angle_z);
+
+    void rotate(const Vector3& angle);
 
     Vector3 rotate() const
@@ -117 +115 @@
 
     /**
-     * \brief make the camera setting active, this has to be
+     * \brief Make the camera setting active, this has to be
      * called before drawing things
      */
@@ -133 +131 @@
     /// rotation angles of camera along x, y, z
     Vector3 _angle;
+
+    vrMatrix4x4f _cameraMatrix;
+
     /// screen width
     int _width;

trunk/packages/vizservers/nanovis/NvFlowVisRenderer.h

@@ -51 +51 @@
     /** 
      * @brief Specify the axis of the index plane
-     * @param index the index of the array of injection planes
      */
     void setPlaneAxis(const std::string& vfName, const std::string& name, int axis);
 
     /**
-     * @param pos : Specify the position of slice
+     * @param pos Specify the position of slice
      */
     void setPlanePos(const std::string& vfName, const std::string& name, float pos);

trunk/packages/vizservers/nanovis/NvRegularVolumeShader.cpp

@@ -40 +40 @@
     if (!sliceMode) {
         cgGLSetParameter4f(_render_param_one_volume_param,
-            volume->n_slices(),
-            volume->opacity_scale(),
+            volume->numSlices(),
+            volume->opacityScale(),
             volume->diffuse(),
             volume->specular());
@@ -47 +47 @@
         cgGLSetParameter4f(_render_param_one_volume_param,
             0.,
-            volume->opacity_scale(),
+            volume->opacityScale(),
             volume->diffuse(),
             volume->specular());

trunk/packages/vizservers/nanovis/NvShader.cpp

@@ -99 +99 @@
 void NvShader::setErrorCallback(NvCgCallbackFunction callback)
 {
-    TRACE("NvShader error callback: %p\n", callback);
+    TRACE("NvShader setting error callback to: %p\n", callback);
     cgSetErrorCallback(callback);
 }

trunk/packages/vizservers/nanovis/NvZincBlendeReconstructor.h

@@ -37 +37 @@
     /**
      * @brief Load Zinc blende binary volume data and create ZincBlendeVolume with the file
-     * @param data Zinc blende binary volume data, which data is generated by NEMO-3D and transferred from nanoscale
+     * @param stream Zinc blende binary volume data, which data is generated by NEMO-3D and transferred from nanoscale
      */
     ZincBlendeVolume *loadFromStream(std::istream& stream);
@@ -71 +71 @@
     /**
      * @brief Get a line from file. It is used for reading header because header is written in ascii.
-     * @param fp A file pointer of data file
      */
     void getLine(std::istream& stream);

trunk/packages/vizservers/nanovis/NvZincBlendeVolumeShader.cpp

@@ -26 +26 @@
     _mviParam = cgGetNamedParameter(_cgFP, "modelViewInv");
     _renderParam = cgGetNamedParameter(_cgFP, "renderParameters");
-    _option_one_volume_param = cgGetNamedParameter(_cgFP, "options");
+    _optionOneVolumeParam = cgGetNamedParameter(_cgFP, "options");
 }
 
@@ -35 +35 @@
     cgGLSetTextureParameter(_tfParam, tfID);
     cgGLSetParameter4f(_cellSizeParam,
-                       vol->cell_size.x,
-                       vol->cell_size.y,
-                       vol->cell_size.z, 0.);
+                       vol->cellSize.x,
+                       vol->cellSize.y,
+                       vol->cellSize.z, 0.);
 
     if (!sliceMode) {
         cgGLSetParameter4f(_renderParam,
-                           vol->n_slices(),
-                           vol->opacity_scale(),
+                           vol->numSlices(),
+                           vol->opacityScale(),
                            vol->diffuse(), 
                            vol->specular());
@@ -48 +48 @@
         cgGLSetParameter4f(_renderParam,
                            0.,
-                           vol->opacity_scale(),
+                           vol->opacityScale(),
                            vol->diffuse(),
                            vol->specular());
     }
 
-    cgGLSetParameter4f(_option_one_volume_param,
+    cgGLSetParameter4f(_optionOneVolumeParam,
                        0.0f,
                        volume->isosurface(),
@@ -59 +59 @@
                        0.0f);
 
-    cgGLSetTextureParameter(_volumeAParam, vol->zincblende_tex[0]->id());
-    cgGLSetTextureParameter(_volumeBParam, vol->zincblende_tex[1]->id());
+    cgGLSetTextureParameter(_volumeAParam, vol->zincblendeTex[0]->id());
+    cgGLSetTextureParameter(_volumeBParam, vol->zincblendeTex[1]->id());
     cgGLEnableTextureParameter(_volumeAParam);
     cgGLEnableTextureParameter(_volumeBParam);

trunk/packages/vizservers/nanovis/NvZincBlendeVolumeShader.h

@@ -26 +26 @@
     CGparameter _mviParam;
     CGparameter _renderParam;
-    CGparameter _option_one_volume_param;
+    CGparameter _optionOneVolumeParam;
 };
 

trunk/packages/vizservers/nanovis/PerfQuery.cpp

@@ -14 +14 @@
  * ======================================================================
  */
+#include <assert.h>
 
-#include <assert.h>
 #include "PerfQuery.h"
 
-
-PerfQuery::PerfQuery(){
-  glGenQueriesARB(1, &id);
-  pixel = 0;
+PerfQuery::PerfQuery()
+{
+    glGenQueriesARB(1, &id);
+    pixel = 0;
 }
 
-PerfQuery::~PerfQuery(){
-  glDeleteQueriesARB(1, &id);
+PerfQuery::~PerfQuery()
+{
+    glDeleteQueriesARB(1, &id);
 }
 
 //There can only be one active query at any given moment
-void PerfQuery::enable(){
-  glBeginQueryARB(GL_SAMPLES_PASSED_ARB, id);
+void PerfQuery::enable()
+{
+    glBeginQueryARB(GL_SAMPLES_PASSED_ARB, id);
 }
 
-void PerfQuery::disable(){
-  glEndQueryARB(GL_SAMPLES_PASSED_ARB);
+void PerfQuery::disable()
+{
+    glEndQueryARB(GL_SAMPLES_PASSED_ARB);
 
-  GLuint count;
-  glGetQueryObjectuivARB(id, GL_QUERY_RESULT_ARB, &count);
+    GLuint count;
+    glGetQueryObjectuivARB(id, GL_QUERY_RESULT_ARB, &count);
 
-  //accumulate pixel count count
-  pixel+=count;
+    //accumulate pixel count count
+    pixel += count;
 }
-

trunk/packages/vizservers/nanovis/PerfQuery.h

@@ -16 +16 @@
  * ======================================================================
  */
-#ifndef _PERFQUERY_H_
-#define _PERFQUERY_H_
+#ifndef PERFQUERY_H
+#define PERFQUERY_H
 
 #include <stdio.h>
@@ -25 +25 @@
 #include "Trace.h"
 
-//check if occlusion query is supported
-inline bool check_query_support()
-{
-    int bitsSupported = -1;
-    glGetQueryivARB(GL_SAMPLES_PASSED_ARB, GL_QUERY_COUNTER_BITS_ARB, 
-                    &bitsSupported);
-    if (bitsSupported == 0) {
-        TRACE("occlusion query not supported!\n");
-        return false;
-    } else {
-        TRACE("Occlusion query with %d bits supported\n", bitsSupported);
-        return true;
-    }
-}
-
 class PerfQuery
 {
 public:
-    GLuint id;
-    int pixel;
-    
     PerfQuery();
     ~PerfQuery();
-    
+
     void enable();      //start counting how many pixels are rendered
     void disable();     //stop counting
 
     void reset()
-    { 
-        pixel = 0; 
+    {
+        pixel = 0; 
     }
 
-    int get_pixel_count()
+    int getPixelCount()
     {
-        return pixel;           //return current pixel count
+        return pixel;           //return current pixel count
     }
+
+    static bool checkQuerySupport();
+
+    GLuint id;
+    int pixel;
 };
 
+//check if occlusion query is supported
+inline bool PerfQuery::checkQuerySupport()
+{
+    if (!GLEW_ARB_occlusion_query) {
+        TRACE("ARB_occlusion_query extension not supported\n");
+        return false;
+    }
+    int bitsSupported = -1;
+    glGetQueryivARB(GL_SAMPLES_PASSED_ARB, GL_QUERY_COUNTER_BITS_ARB, 
+                    &bitsSupported);
+    if (bitsSupported == 0) {
+        TRACE("occlusion query not supported!\n");
+        return false;
+    } else {
+        TRACE("Occlusion query with %d bits supported\n", bitsSupported);
+        return true;
+    }
+}
 #endif
 

trunk/packages/vizservers/nanovis/R2/include/R2/R2FilePath.h

@@ -21 +21 @@
     /**
      * @brief set default data paths
-     * @param filePath all default paths separated by colon(:)
+     * @param path all default paths separated by colon(:)
      */
     bool setPath(const char *path);

trunk/packages/vizservers/nanovis/R2/src/R2Fonts.cpp

@@ -166 +166 @@
                          sizeof(unsigned int));
 
-            // read dimensions for each charactor in 256-char ASCII chart
+            // read dimensions for each character in 256-char ASCII chart
             for (int i = 0; i < 256; ++i) {
                 unsigned int uiSize = 0;

trunk/packages/vizservers/nanovis/README

@@ -32 +32 @@
      Nvidia CG Toolkit for GPU (Graphics Processing Unit) programming.
        (See http://developer.nvidia.com/object/cg_toolkit.html)
-     The OpenGL Wrangler Library for OpenGL extension management.
+     The OpenGL Wrangler Library (>= 1.1.0) for OpenGL extension management.
        (See http://glew.sourceforge.net/)
      OpenGL Utility Toolkit (GLUT). Freeglut is an opensource GLUT replacement.

trunk/packages/vizservers/nanovis/Switch.h

@@ -38 +38 @@
 
 typedef int (SwitchParseProc)(ClientData clientData, Tcl_Interp *interp, 
-        const char *switchName, Tcl_Obj *valueObjPtr, char *record, int offset,
-        int flags);
+                              const char *switchName, Tcl_Obj *valueObjPtr,
+                              char *record, int offset,
+                              int flags);
+
 typedef void (SwitchFreeProc)(char *record, int offset, int flags);
 
@@ -122 +124 @@
 
 extern int ParseSwitches(Tcl_Interp *interp, SwitchSpec *specPtr, 
-        int objc, Tcl_Obj *const *objv, void *rec, int flags);
+                         int objc, Tcl_Obj *const *objv,
+                         void *rec, int flags);
 
 extern void FreeSwitches(SwitchSpec *specs, void *rec, int flags);

trunk/packages/vizservers/nanovis/Texture2D.cpp

@@ -72 +72 @@
 void Texture2D::update(void *data)
 {
+    static GLuint floatFormats[] = { -1, GL_LUMINANCE32F_ARB, GL_LUMINANCE_ALPHA32F_ARB, GL_RGB32F_ARB, GL_RGBA32F_ARB };
+    static GLuint halfFloatFormats[] = { -1, GL_LUMINANCE16F_ARB, GL_LUMINANCE_ALPHA16F_ARB, GL_RGB16F_ARB, GL_RGBA16F_ARB };
+    static GLuint basicFormats[] = { -1, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_RGBA };
+
     glBindTexture(GL_TEXTURE_2D, _id);
 
@@ -83 +87 @@
 
     //to do: add handling to more formats
-#ifdef NV40
+    GLuint *targetFormats;
+#ifdef HAVE_FLOAT_TEXTURES
     if (_type == GL_FLOAT) {
-        GLuint targetFormat[5] = { -1, GL_LUMINANCE16F_ARB, GL_LUMINANCE_ALPHA16F_ARB, GL_RGB16F_ARB, GL_RGBA16F_ARB };
-        GLuint format[5] = { -1, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_RGBA };
-        glTexImage2D(GL_TEXTURE_2D, 0, targetFormat[_numComponents], _width, _height, 0, 
-                     format[_numComponents], _type, data);
+# ifdef USE_HALF_FLOAT
+        targetFormats = halfFloatFormats;
+# else
+        targetFormats = floatFormats;
+# endif
     } else {
 #endif
-        GLuint format[5] = { -1, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_RGBA };
-        glTexImage2D(GL_TEXTURE_2D, 0, format[_numComponents], _width, _height, 0, 
-                     format[_numComponents], _type, data);
-#ifdef NV40
+        targetFormats = basicFormats;
+#ifdef HAVE_FLOAT_TEXTURES
     }
 #endif
+
+    glTexImage2D(GL_TEXTURE_2D, 0, targetFormats[_numComponents],
+                 _width, _height, 0, 
+                 basicFormats[_numComponents], _type, data);
+
     assert(glGetError() == 0);
 }

trunk/packages/vizservers/nanovis/Texture3D.cpp

@@ -88 +88 @@
 void Texture3D::update(void *data)
 {
+    static GLuint floatFormats[] = { -1, GL_LUMINANCE32F_ARB, GL_LUMINANCE_ALPHA32F_ARB, GL_RGB32F_ARB, GL_RGBA32F_ARB };
+    static GLuint halfFloatFormats[] = { -1, GL_LUMINANCE16F_ARB, GL_LUMINANCE_ALPHA16F_ARB, GL_RGB16F_ARB, GL_RGBA16F_ARB };
+    static GLuint basicFormats[] = { -1, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_RGBA };
+
     glBindTexture(GL_TEXTURE_3D, _id);
 
-    //load texture with 16 bit half floating point precision if card is 6 series NV40
-    //half float with linear interpolation is only supported by 6 series and up cards
-    //If NV40 not defined, data is quantized to 8-bit from 32-bit.
     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 
@@ -103 +104 @@
 
     //to do: add handling to more formats
-#ifdef NV40
+    GLuint *targetFormats;
+#ifdef HAVE_FLOAT_TEXTURES
     if (_type == GL_FLOAT) {
-        GLuint targetFormat[5] = { -1, GL_LUMINANCE16F_ARB, GL_LUMINANCE_ALPHA16F_ARB, GL_RGB16F_ARB, GL_RGBA16F_ARB };
-        GLuint format[5] = { -1, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_RGBA };
-        glTexImage3D(GL_TEXTURE_3D, 0, targetFormat[_numComponents],
-                     _width, _height, _depth, 0, 
-                     format[_numComponents], _type, data);
+# ifdef USE_HALF_FLOAT
+        targetFormats = halfFloatFormats;
+# else
+        targetFormats = floatFormats;
+# endif
     } else {
 #endif
-        GLuint format[5] = { -1, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_RGBA };
-        glTexImage3D(GL_TEXTURE_3D, 0, format[_numComponents],
-                     _width, _height, _depth, 0, 
-                     format[_numComponents], _type, data);
-#ifdef NV40
+        targetFormats = basicFormats;
+#ifdef HAVE_FLOAT_TEXTURES
     }
 #endif
+
+    glTexImage3D(GL_TEXTURE_3D, 0, targetFormats[_numComponents],
+                 _width, _height, _depth, 0, 
+                 basicFormats[_numComponents], _type, data);
 
     assert(glGetError()==0);

trunk/packages/vizservers/nanovis/Unirect.cpp

@@ -675 +675 @@
     _yNum = (size_t)ceil(dy/dmin);
     _zNum = (size_t)ceil(dz/dmin);
-    
-#ifndef NV40
+
+#ifndef HAVE_NPOT_TEXTURES
     // must be an even power of 2 for older cards
     _xNum = (int)pow(2.0, ceil(log10((double)_xNum)/log10(2.0)));

trunk/packages/vizservers/nanovis/Vector3.h

@@ -44 +44 @@
     {
         TRACE("(x:%f, y:%f, z:%f)\n", x, y, z);
+    }
+
+    Vector3 operator -() const
+    {
+        return Vector3(-x, -y, -z);
     }
 
@@ -99 +104 @@
     {
         float len = length();
-        return Vector3(x / len, y / len, z / len);
+        if (len > 1.0e-6) {
+            return Vector3(x / len, y / len, z / len);
+        } else {
+            return *this;
+        }
     }
 

trunk/packages/vizservers/nanovis/VelocityArrowsSlice.cpp

@@ -318 +318 @@
 
         //cgSetParameter1f(_mvTanHalfFOVParam, -tan(_fov * 0.5) * _screenHeight * 0.5);
-        cgSetParameter1f(_mvTanHalfFOVParam, tan(30. * 0.5) * NanoVis::win_height * 0.5);
+        cgSetParameter1f(_mvTanHalfFOVParam, tan(30. * 0.5) * NanoVis::winHeight * 0.5);
 
         cgGLSetStateMatrixParameter(_mvpParticleParam,

trunk/packages/vizservers/nanovis/Volume.cpp

@@ -20 +20 @@
 #include "Trace.h"
 
-bool Volume::update_pending = false;
+bool Volume::updatePending = false;
 double Volume::valueMin = 0.0;
 double Volume::valueMax = 1.0;
@@ -27 +27 @@
                int w, int h, int d, float s, 
                int n, float *data,
-               double v0, double v1, double nz_min) :
-    aspect_ratio_width(1),
-    aspect_ratio_height(1),
-    aspect_ratio_depth(1),
+               double v0, double v1, double nonZeroMin) :
+    aspectRatioWidth(1),
+    aspectRatioHeight(1),
+    aspectRatioDepth(1),
     id(0),
     width(w),
@@ -38 +38 @@
     pointsetIndex(-1),
     _tfPtr(NULL),
-    _specular(6.),              // default value
-    _diffuse(3.),               // default value
-    _opacity_scale(10.),        // default value
+    _specular(6.),
+    _diffuse(3.),
+    _opacityScale(10.),
     _name(NULL),
     _data(NULL),
-    _n_components(n),
-    _nonzero_min(nz_min),
+    _numComponents(n),
+    _nonZeroMin(nonZeroMin),
     _tex(NULL),
     _location(x, y, z),
-    _n_slices(512),             // default value
+    _numSlices(512),
     _enabled(true),
-    _data_enabled(true),        // default value
-    _outline_enabled(true),     // default value
-    _outline_color(1., 1., 1.), // default value
-    _volume_type(CUBIC),        // default is a cubic volume
-    _iso_surface(0)
+    _dataEnabled(true),
+    _outlineEnabled(true),
+    _outlineColor(1., 1., 1.),
+    _volumeType(CUBIC),
+    _isosurface(0)
 {
     _tex = new Texture3D(w, h, d, GL_FLOAT, GL_LINEAR, n);
-    int fcount = width * height * depth * _n_components;
+    int fcount = width * height * depth * _numComponents;
     _data = new float[fcount];
     if (data != NULL) {
@@ -64 +64 @@
     } else {
         TRACE("data is null\n");
-        memset(_data, 0, sizeof(width * height * depth * _n_components * 
+        memset(_data, 0, sizeof(width * height * depth * _numComponents * 
                                 sizeof(float)));
         _tex->initialize(_data);
@@ -74 +74 @@
 
     // VOLUME
-    aspect_ratio_width  = s * _tex->aspectRatioWidth();
-    aspect_ratio_height = s * _tex->aspectRatioHeight();
-    aspect_ratio_depth =  s * _tex->aspectRatioDepth();
+    aspectRatioWidth  = s * _tex->aspectRatioWidth();
+    aspectRatioHeight = s * _tex->aspectRatioHeight();
+    aspectRatioDepth =  s * _tex->aspectRatioDepth();
 
     //Add cut planes. We create 3 default cut planes facing x, y, z directions.
     //The default location of cut plane is in the middle of the data.
     _plane.clear();
-    add_cutplane(1, 0.5f);
-    add_cutplane(2, 0.5f);
-    add_cutplane(3, 0.5f);
+    addCutplane(1, 0.5f);
+    addCutplane(2, 0.5f);
+    addCutplane(3, 0.5f);
 
     //initialize the labels  

trunk/packages/vizservers/nanovis/Volume.h

@@ -55 +55 @@
     Volume(float x, float y, float z,
            int width, int height, int depth, 
-           float size, int n_component,
+           float size, int numComponents,
            float *data,
            double vmin, double vmax, 
-           double nonzero_min);
+           double nonZeroMin);
 
     virtual ~Volume();
@@ -84 +84 @@
     int isosurface() const
     {
-        return _iso_surface;
+        return _isosurface;
     }
 
     void isosurface(int iso)
     {
-        _iso_surface = iso;
-    }
-
-    int n_components() const
-    {
-        return _n_components;
-    }
-
-    double nonzero_min() const
-    {
-        return _nonzero_min;
-    }
-
-    double range_nzero_min() const
-    {
-        return _nonzero_min;
-    }
-
-    int volume_type() const
-    {
-        return _volume_type;
+        _isosurface = iso;
+    }
+
+    int numComponents() const
+    {
+        return _numComponents;
+    }
+
+    double nonZeroMin() const
+    {
+        return _nonZeroMin;
+    }
+
+    int volumeType() const
+    {
+        return _volumeType;
     }
 
@@ -122 +117 @@
     }
     
-    int n_slices() const
-    {
-        return _n_slices;
-    }
-
-    void n_slices(int n)
-    {
-        _n_slices = n;
+    int numSlices() const
+    {
+        return _numSlices;
+    }
+
+    void numSlices(int n)
+    {
+        _numSlices = n;
     }
 
     /// set the drawing size of volume 
-    void set_size(float s);
+    void setSize(float s);
 
     // methods related to cutplanes
     /// add a plane and returns its index
-    int add_cutplane(int orientation, float location);
-
-    void enable_cutplane(int index);
-
-    void disable_cutplane(int index);
-
-    void move_cutplane(int index, float location);
-
-    CutPlane *get_cutplane(int index);
+    int addCutplane(int orientation, float location);
+
+    void enableCutplane(int index);
+
+    void disableCutplane(int index);
+
+    void moveCutplane(int index, float location);
+
+    CutPlane *getCutplane(int index);
 
     /// returns the number of cutplanes in the volume
-    int get_cutplane_count();
+    int getCutplaneCount();
 
     /// check if a cutplane is enabled
-    bool cutplane_is_enabled(int index) const;
+    bool isCutplaneEnabled(int index) const;
 
     // methods related to shading. These parameters are per volume 
+
+    /// Get specular exponent
     float specular() const
     {
@@ -159 +156 @@
     }
 
+    /// Set specular exponent [0,128]
     void specular(float value)
     {
+        if (value < 0.0f) value = 0.0f;
+        if (value > 128.0f) value = 128.0f;
         _specular = value;
     }
 
+    /// Get diffuse coefficient
     float diffuse() const
     {
@@ -169 +170 @@
     }
 
+    /// Set diffuse coefficient [0,1]
     void diffuse(float value)
     {
+        if (value < 0.0f) value = 0.0f;
+        if (value > 1.0f) value = 1.0f;
         _diffuse = value;
     }
 
-    float opacity_scale() const
-    {
-        return _opacity_scale;
-    }
-
-    void opacity_scale(float value)
-    {
-        _opacity_scale = value;
-    }
-
-    void data_enabled(bool value)
-    {
-        _data_enabled = value;
-    }
-
-    bool data_enabled() const
-    {
-        return _data_enabled;
+    float opacityScale() const
+    {
+        return _opacityScale;
+    }
+
+    void opacityScale(float value)
+    {
+        _opacityScale = value;
+    }
+
+    void dataEnabled(bool value)
+    {
+        _dataEnabled = value;
+    }
+
+    bool dataEnabled() const
+    {
+        return _dataEnabled;
     }
 
     void outline(bool value)
     {
-        _outline_enabled = value; 
+        _outlineEnabled = value; 
     }
 
     bool outline()
     {
-        return _outline_enabled;
+        return _outlineEnabled;
     }
 
@@ -214 +218 @@
     }
 
-    void set_outline_color(float *rgb);
-
-    void get_outline_color(float *rgb);
-    
+    void setOutlineColor(float *rgb);
+
+    void getOutlineColor(float *rgb);
+
     /// change the label displayed on an axis
-    void set_label(int axis, const char *txt);
+    void setLabel(int axis, const char *txt);
 
     void setPhysicalBBox(const Vector3& min, const Vector3& max);
@@ -237 +241 @@
     }
 
-    float aspect_ratio_width;
-    float aspect_ratio_height;
-    float aspect_ratio_depth;
+    float aspectRatioWidth;
+    float aspectRatioHeight;
+    float aspectRatioDepth;
 
     GLuint id;          ///< OpenGL textue identifier (==_tex->id)
@@ -264 +268 @@
     std::string label[3]; ///< the labels along each axis 0:x, 1:y, 2:z
 
-    static bool update_pending;
+    static bool updatePending;
     static double valueMin, valueMax;
 
@@ -281 +285 @@
      * the object is to appear like plastic
      */
-    float _opacity_scale;
+    float _opacityScale;
 
     const char *_name;
-    Vector3 _physical_min;
-    Vector3 _physical_max;
+    Vector3 _physicalMin;
+    Vector3 _physicalMax;
     float *_data;
 
-    int _n_components;
-
-    double _nonzero_min;
+    int _numComponents;
+
+    double _nonZeroMin;
 
     std::vector<CutPlane> _plane; ///< cut planes
@@ -302 +306 @@
      * the better quality, lower speed.
      */
-    int _n_slices;
+    int _numSlices;
     bool _enabled; 
-    bool _data_enabled;         ///< show/hide cloud of volume data
-    bool _outline_enabled;      ///< show/hide outline around volume
-    Color _outline_color;       ///< color for outline around volume
-    int _volume_type;           ///< cubic or zincblende
-    int _iso_surface;
+    bool _dataEnabled;          ///< show/hide cloud of volume data
+    bool _outlineEnabled;       ///< show/hide outline around volume
+    Color _outlineColor;        ///< color for outline around volume
+    int _volumeType;            ///< cubic or zincblende
+    int _isosurface;
 };
 
 inline int
-Volume::add_cutplane(int orientation, float location)
+Volume::addCutplane(int orientation, float location)
 {
     _plane.push_back(CutPlane(orientation, location));
@@ -319 +323 @@
 
 inline void 
-Volume::enable_cutplane(int index)
+Volume::enableCutplane(int index)
 { 
     //assert(index < plane.size());
@@ -325 +329 @@
 }
 inline void 
-Volume::disable_cutplane(int index)
+Volume::disableCutplane(int index)
 {
     //assert(index < plane.size());
@@ -332 +336 @@
 
 inline void 
-Volume::move_cutplane(int index, float location)
+Volume::moveCutplane(int index, float location)
 {
     //assert(index < plane.size());
@@ -339 +343 @@
 
 inline CutPlane * 
-Volume::get_cutplane(int index)
+Volume::getCutplane(int index)
 {
     //assert(index < plane.size());
@@ -346 +350 @@
 
 inline int 
-Volume::get_cutplane_count()
+Volume::getCutplaneCount()
 {
     return _plane.size();
@@ -352 +356 @@
 
 inline bool 
-Volume::cutplane_is_enabled(int index) const
+Volume::isCutplaneEnabled(int index) const
 {
     //assert(index < plane.size());
@@ -359 +363 @@
 
 inline void 
-Volume::set_size(float s) 
+Volume::setSize(float s) 
 { 
     size = s; 
-    aspect_ratio_width  = s * _tex->aspectRatioWidth();
-    aspect_ratio_height = s * _tex->aspectRatioHeight();
-    aspect_ratio_depth  = s * _tex->aspectRatioDepth();
-}
-
-inline void 
-Volume::set_outline_color(float *rgb) 
-{
-    _outline_color = Color(rgb[0], rgb[1], rgb[2]);
-}
-
-inline void 
-Volume::get_outline_color(float *rgb) 
-{
-    _outline_color.getRGB(rgb);
-}
-
-inline void 
-Volume::set_label(int axis, const char* txt)
+    aspectRatioWidth  = s * _tex->aspectRatioWidth();
+    aspectRatioHeight = s * _tex->aspectRatioHeight();
+    aspectRatioDepth  = s * _tex->aspectRatioDepth();
+}
+
+inline void 
+Volume::setOutlineColor(float *rgb) 
+{
+    _outlineColor = Color(rgb[0], rgb[1], rgb[2]);
+}
+
+inline void 
+Volume::getOutlineColor(float *rgb) 
+{
+    _outlineColor.getRGB(rgb);
+}
+
+inline void 
+Volume::setLabel(int axis, const char* txt)
 {
     label[axis] = txt;
@@ -388 +392 @@
 Volume::setPhysicalBBox(const Vector3& min, const Vector3& max)
 {
-    _physical_min = min;
-    _physical_max = max;
+    _physicalMin = min;
+    _physicalMax = max;
 
     /*
-    aspect_ratio_width = size * 1;
-    aspect_ratio_height = size * (max.y - min.y) / (max.x - min.x);
-    aspect_ratio_depth = size* (max.z - min.z) / (max.x - min.x);
+    aspectRatioWidth = size * 1;
+    aspectRatioHeight = size * (max.y - min.y) / (max.x - min.x);
+    aspectRatioDepth = size* (max.z - min.z) / (max.x - min.x);
 
     location.x = -0.5;
-    location.y = -0.5* aspect_ratio_height;
-    location.z = -0.5* aspect_ratio_depth;
+    location.y = -0.5* aspectRatioHeight;
+    location.z = -0.5* aspectRatioDepth;
     */
 }
@@ -405 +409 @@
 Volume::getPhysicalBBoxMin() const
 {
-    return _physical_min;
+    return _physicalMin;
 }
 
@@ -411 +415 @@
 Volume::getPhysicalBBoxMax() const
 {
-    return _physical_max;
+    return _physicalMax;
 }
 

trunk/packages/vizservers/nanovis/VolumeInterpolator.cpp

@@ -18 +18 @@
     _numBytes(0), 
     _dataCount(0), 
-    _n_components(0), 
+    _numComponents(0), 
     _referenceOfVolume(0)
 {
@@ -34 +34 @@
     struct timeval clock;
     gettimeofday(&clock, NULL);
-    _start_time = clock.tv_sec + clock.tv_usec/1000000.0;
+    _startTime = clock.tv_sec + clock.tv_usec/1000000.0;
     TRACE("End Start - VolumeInterpolator\n");
 }
@@ -68 +68 @@
             *((Vector3*)(result + 1)) = normal;
 
-            result += _n_components;
-            data1 += _n_components;
-            data2 += _n_components;
+            result += _numComponents;
+            data1 += _numComponents;
+            data2 += _numComponents;
         }
 
@@ -125 +125 @@
             _volumes[0]->height != refPtr->height ||   
             _volumes[0]->depth != refPtr->depth || 
-            _volumes[0]->n_components() != refPtr->n_components()) {
+            _volumes[0]->numComponents() != refPtr->numComponents()) {
             TRACE("The volume should be the same width, height, number of components\n");
             return;
@@ -131 +131 @@
     } else {
         _dataCount = refPtr->width * refPtr->height * refPtr->depth;
-        _n_components = refPtr->n_components();
-        _numBytes = _dataCount * _n_components * sizeof(float);
+        _numComponents = refPtr->numComponents();
+        _numBytes = _dataCount * _numComponents * sizeof(float);
         Vector3 loc = refPtr->location();
         _volume = new Volume(loc.x, loc.y, loc.z,
                              refPtr->width, refPtr->height, refPtr->depth, 
                              refPtr->size,
-                             refPtr->n_components(), 
+                             refPtr->numComponents(), 
                              refPtr->data(), 
                              refPtr->wAxis.min(), 
                              refPtr->wAxis.max(), 
-                             refPtr->nonzero_min());
+                             refPtr->nonZeroMin());
         /*
         _referenceOfVolume = refPtr->dataID();
         */
-        _volume->n_slices(256-1);
-        _volume->disable_cutplane(0);
-        _volume->disable_cutplane(1);
-        _volume->disable_cutplane(2);
+        _volume->numSlices(256-1);
+        _volume->disableCutplane(0);
+        _volume->disableCutplane(1);
+        _volume->disableCutplane(2);
         _volume->visible(true);
-        _volume->data_enabled(true);
+        _volume->dataEnabled(true);
         _volume->specular(refPtr->specular());
         _volume->diffuse(refPtr->diffuse());
-        _volume->opacity_scale(refPtr->opacity_scale());
+        _volume->opacityScale(refPtr->opacityScale());
         _volume->isosurface(0);
         TRACE("VOL : location %f %f %f\n\tid : %s\n", loc.x, loc.y, loc.z, 

trunk/packages/vizservers/nanovis/VolumeInterpolator.h

@@ -24 +24 @@
     void computeKeys(float fraction, int count, float *interp, int *key1, int *key2);
 
-    bool is_started() const;
+    bool isStarted() const;
 
     double getInterval() const;
@@ -43 +43 @@
     unsigned int _numBytes;
     unsigned int _dataCount;
-    unsigned int _n_components;
+    unsigned int _numComponents;
     unsigned int _referenceOfVolume;
-    double _start_time;
+    double _startTime;
 };
 
-inline bool VolumeInterpolator::is_started() const
+inline bool VolumeInterpolator::isStarted() const
 {
     return _started;
@@ -55 +55 @@
 inline double VolumeInterpolator::getStartTime() const
 {
-    return _start_time;
+    return _startTime;
 }
 

trunk/packages/vizservers/nanovis/VolumeRenderer.cpp

@@ -40 +40 @@
 
 VolumeRenderer::VolumeRenderer() :
-    slice_mode(false),
-    volume_mode(true)
-{
-    init_shaders();
+    _sliceMode(false),
+    _volumeMode(true)
+{
+    initShaders();
 
     const char *path = R2FilePath::getInstance()->getPath("Font.bmp");
@@ -50 +50 @@
         assert(path != NULL);
     }
-    init_font(path);
+    initFont(path);
     delete [] path;
     _volumeInterpolator = new VolumeInterpolator();
@@ -64 +64 @@
 
 //initialize the volume shaders
-void VolumeRenderer::init_shaders()
+void VolumeRenderer::initShaders()
 {
     //standard vertex program
@@ -85 +85 @@
 struct SortElement {
     float z;
-    int volume_id;
-    int slice_id;
+    int volumeId;
+    int sliceId;
 
     SortElement(float _z, int _v, int _s) :
-        z(_z), volume_id(_v), slice_id(_s)
+        z(_z),
+        volumeId(_v),
+        sliceId(_s)
     {}
 };
 
-int slice_sort(const void* a, const void* b)
+static int sliceSort(const void *a, const void *b)
 {
     if ((*((SortElement*)a)).z > (*((SortElement*)b)).z)
@@ -102 +104 @@
 
 void 
-VolumeRenderer::render_all()
+VolumeRenderer::renderAll()
 {
     size_t total_rendered_slices = 0;
 
-    if (_volumeInterpolator->is_started()) {
+    if (_volumeInterpolator->isStarted()) {
 #ifdef notdef
         ani_vol = _volumeInterpolator->getVolume();
@@ -130 +132 @@
         // at all.
         volumes.push_back(volPtr);
-        volPtr->n_slices(256 - volumes.size());
+        volPtr->numSlices(256 - volumes.size());
     }
 
@@ -144 +146 @@
         actual_slices[i] = 0;
 
-        int n_slices = volPtr->n_slices();
+        int n_slices = volPtr->numSlices();
         if (volPtr->isosurface()) {
             // double the number of slices
@@ -174 +176 @@
         //get modelview matrix with no translation
         glPushMatrix();
-        glScalef(volPtr->aspect_ratio_width, 
-                 volPtr->aspect_ratio_height, 
-                 volPtr->aspect_ratio_depth);
+        glScalef(volPtr->aspectRatioWidth, 
+                 volPtr->aspectRatioHeight, 
+                 volPtr->aspectRatioDepth);
 
         glEnable(GL_DEPTH_TEST);
@@ -191 +193 @@
         glPushMatrix();
         glTranslatef(shift_4d.x, shift_4d.y, shift_4d.z);
-        glScalef(volPtr->aspect_ratio_width, 
-                 volPtr->aspect_ratio_height, 
-                 volPtr->aspect_ratio_depth);
+        glScalef(volPtr->aspectRatioWidth, 
+                 volPtr->aspectRatioHeight, 
+                 volPtr->aspectRatioDepth);
         GLfloat mv_trans[16];
         glGetFloatv(GL_MODELVIEW_MATRIX, mv_trans);
@@ -204 +206 @@
         if (volPtr->outline()) {
             float olcolor[3];
-            volPtr->get_outline_color(olcolor);
-            draw_bounding_box(x0, y0, z0, x0+1, y0+1, z0+1,
+            volPtr->getOutlineColor(olcolor);
+            drawBoundingBox(x0, y0, z0, x0+1, y0+1, z0+1,
                 (double)olcolor[0], (double)olcolor[1], (double)olcolor[2],
                 1.5);
@@ -223 +225 @@
             volume_planes[j].transform(model_view_no_trans);
         }
-        get_near_far_z(mv_no_trans, zNear, zFar);
+        getNearFarZ(mv_no_trans, zNear, zFar);
 
         //compute actual rendering slices
@@ -229 +231 @@
         size_t n_actual_slices;
 
-        if (volPtr->data_enabled()) {
+        if (volPtr->dataEnabled()) {
             n_actual_slices = (int)(fabs(zNear-zFar)/z_step + 1);
             polys[i] = new ConvexPolygon*[n_actual_slices];
@@ -249 +251 @@
 
         ConvexPolygon static_poly;
-        for (int j = 0; j < volPtr->get_cutplane_count(); j++) {
-            if (!volPtr->cutplane_is_enabled(j)) {
+        for (int j = 0; j < volPtr->getCutplaneCount(); j++) {
+            if (!volPtr->isCutplaneEnabled(j)) {
                 continue;
             }
-            float offset = volPtr->get_cutplane(j)->offset;
-            int axis = volPtr->get_cutplane(j)->orient;
+            float offset = volPtr->getCutplane(j)->offset;
+            int axis = volPtr->getCutplane(j)->orient;
             
             if (axis == 3) {
@@ -284 +286 @@
             p->vertices.clear();
 
-            p->append_vertex(vert1);
-            p->append_vertex(vert2);
-            p->append_vertex(vert3);
-            p->append_vertex(vert4);
+            p->appendVertex(vert1);
+            p->appendVertex(vert2);
+            p->appendVertex(vert3);
+            p->appendVertex(vert4);
 
             for (size_t k = 0; k < 6; k++) {
@@ -297 +299 @@
 
             glPushMatrix();
-            glScalef(volPtr->aspect_ratio_width,
-                     volPtr->aspect_ratio_height,
-                     volPtr->aspect_ratio_depth);
-
-            activate_volume_shader(volPtr, true);
+            glScalef(volPtr->aspectRatioWidth,
+                     volPtr->aspectRatioHeight,
+                     volPtr->aspectRatioDepth);
+
+            activateVolumeShader(volPtr, true);
             glPopMatrix();
 
@@ -308 +310 @@
 
             glBegin(GL_POLYGON);
-            p->Emit(true); 
+            p->emit(true); 
             glEnd();
             glDisable(GL_DEPTH_TEST);
 
-            deactivate_volume_shader();
+            deactivateVolumeShader();
         } //done cutplanes
 
@@ -334 +336 @@
 
             poly->vertices.clear();
-            poly->set_id(i);
+            poly->setId(i);
 
             //Setting Z-coordinate 
@@ -342 +344 @@
             vert4.z = slice_z;
 
-            poly->append_vertex(vert1);
-            poly->append_vertex(vert2);
-            poly->append_vertex(vert3);
-            poly->append_vertex(vert4);
+            poly->appendVertex(vert1);
+            poly->appendVertex(vert2);
+            poly->appendVertex(vert3);
+            poly->appendVertex(vert4);
 
             for (size_t k = 0; k < 6; k++) {
@@ -377 +379 @@
 
     //sort them
-    qsort(slices, total_rendered_slices, sizeof(SortElement), slice_sort);
+    qsort(slices, total_rendered_slices, sizeof(SortElement), sliceSort);
 
     //Now we are ready to render all the slices from back to front
@@ -386 +388 @@
         Volume *volPtr = NULL;
 
-        int volume_index = slices[i].volume_id;
-        int slice_index = slices[i].slice_id;
+        int volume_index = slices[i].volumeId;
+        int slice_index = slices[i].sliceId;
         ConvexPolygon *cur = polys[volume_index][slice_index];
 
@@ -393 +395 @@
 
         glPushMatrix();
-        glScalef(volPtr->aspect_ratio_width, volPtr->aspect_ratio_height, 
-                 volPtr->aspect_ratio_depth);
+        glScalef(volPtr->aspectRatioWidth,
+                 volPtr->aspectRatioHeight, 
+                 volPtr->aspectRatioDepth);
 
 #ifdef notdef
@@ -400 +403 @@
                volPtr->name(), volPtr, slice_index, volume_index);
 #endif
-        activate_volume_shader(volPtr, false);
+        activateVolumeShader(volPtr, false);
         glPopMatrix();
 
         glBegin(GL_POLYGON);
-        cur->Emit(true);
+        cur->emit(true);
         glEnd();
 
-        deactivate_volume_shader();
+        deactivateVolumeShader();
     }
 
@@ -428 +431 @@
 
 void 
-VolumeRenderer::draw_bounding_box(float x0, float y0, float z0, 
-                                  float x1, float y1, float z1,
-                                  float r, float g, float b, 
-                                  float line_width)
+VolumeRenderer::drawBoundingBox(float x0, float y0, float z0, 
+                                float x1, float y1, float z1,
+                                float r, float g, float b, 
+                                float line_width)
 {
     glPushMatrix();
@@ -547 +550 @@
 
 void 
-VolumeRenderer::activate_volume_shader(Volume* volPtr, bool slice_mode)
+VolumeRenderer::activateVolumeShader(Volume* volPtr, bool sliceMode)
 {
     //vertex shader
     _stdVertexShader->bind();
     TransferFunction *tfPtr  = volPtr->transferFunction();
-    if (volPtr->volume_type() == Volume::CUBIC) {
-        _regularVolumeShader->bind(tfPtr->id(), volPtr, slice_mode);
-    } else if (volPtr->volume_type() == Volume::ZINCBLENDE) {
-        _zincBlendeShader->bind(tfPtr->id(), volPtr, slice_mode);
-    }
-}
-void VolumeRenderer::deactivate_volume_shader()
+    if (volPtr->volumeType() == Volume::CUBIC) {
+        _regularVolumeShader->bind(tfPtr->id(), volPtr, sliceMode);
+    } else if (volPtr->volumeType() == Volume::ZINCBLENDE) {
+        _zincBlendeShader->bind(tfPtr->id(), volPtr, sliceMode);
+    }
+}
+
+void VolumeRenderer::deactivateVolumeShader()
 {
     _stdVertexShader->unbind();
@@ -565 +569 @@
 }
 
-void VolumeRenderer::get_near_far_z(const Mat4x4& mv, double& zNear, double& zFar)
+void VolumeRenderer::getNearFarZ(const Mat4x4& mv, double& zNear, double& zFar)
 {
     double x0 = 0;
@@ -602 +606 @@
 
 bool 
-VolumeRenderer::init_font(const char *filename) 
+VolumeRenderer::initFont(const char *filename) 
 {
     FILE *f;
@@ -731 +735 @@
 
     //create opengl texture 
-    glGenTextures(1, &font_texture);
-    glBindTexture(GL_TEXTURE_2D, font_texture);
+    glGenTextures(1, &_fontTexture);
+    glBindTexture(GL_TEXTURE_2D, _fontTexture);
     //glTexImage2D(GL_TEXTURE_2D, 0, 3, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data_with_alpha);
@@ -741 +745 @@
     free(data_with_alpha);
 
-    build_font();
+    buildFont();
     return (glGetError()==0);
 
@@ -750 +754 @@
 
 void 
-VolumeRenderer::draw_label(Volume* vol)
+VolumeRenderer::drawLabel(Volume* vol)
 {
     //glEnable(GL_TEXTURE_2D);
@@ -762 +766 @@
     glPushMatrix();
 
-    glTranslatef(.5*vol->aspect_ratio_width, vol->aspect_ratio_height,
-                 -0.1*vol->aspect_ratio_depth);
+    glTranslatef(.5 * vol->aspectRatioWidth,
+                 vol->aspectRatioHeight,
+                 -0.1 * vol->aspectRatioDepth);
     glRotatef(180, 0, 0, 1);
     glRotatef(90, 1, 0, 0);
@@ -777 +782 @@
     length = vol->label[1].size();
     glPushMatrix();
-    glTranslatef(vol->aspect_ratio_width, 0.5*vol->aspect_ratio_height, -0.1*vol->aspect_ratio_depth);
+    glTranslatef(vol->aspectRatioWidth,
+                 0.5*vol->aspectRatioHeight,
+                 -0.1*vol->aspectRatioDepth);
     glRotatef(90, 0, 1, 0);
     glRotatef(90, 0, 0, 1);
@@ -791 +798 @@
     length = vol->label[2].size();
     glPushMatrix();
-    glTranslatef(0., 1.*vol->aspect_ratio_height, 0.5*vol->aspect_ratio_depth);
+    glTranslatef(0.,
+                 1. * vol->aspectRatioHeight,
+                 0.5 * vol->aspectRatioDepth);
     glRotatef(90, 0, 1, 0);
 
@@ -805 +814 @@
 
 void 
-VolumeRenderer::build_font() 
+VolumeRenderer::buildFont() 
 {
     GLfloat cx, cy;         /* the character coordinates in our texture */
-    font_base = glGenLists(256);
-    glBindTexture(GL_TEXTURE_2D, font_texture);
+    _fontBase = glGenLists(256);
+    glBindTexture(GL_TEXTURE_2D, _fontTexture);
     for (int loop = 0; loop < 256; loop++) {
         cx = (float) (loop % 16) / 16.0f;
         cy = (float) (loop / 16) / 16.0f;
-        glNewList(font_base + loop, GL_COMPILE);
+        glNewList(_fontBase + loop, GL_COMPILE);
         glBegin(GL_QUADS);
         glTexCoord2f(cx, 1 - cy - 0.0625f);
@@ -835 +844 @@
         set = 1;
     }
-    glBindTexture(GL_TEXTURE_2D, font_texture);
-    glListBase(font_base - 32 + (128 * set));
+    glBindTexture(GL_TEXTURE_2D, _fontTexture);
+    glListBase(_fontBase - 32 + (128 * set));
     glCallLists(strlen(string), GL_BYTE, string);
 }

trunk/packages/vizservers/nanovis/VolumeRenderer.h

@@ -35 +35 @@
 
     /// render all enabled volumes
-    void render_all();
+    void renderAll();
 
     void specular(float val);
@@ -42 +42 @@
 
     /// control independently
-    void set_slice_mode(bool val)
+    void setSliceMode(bool val)
     {
-        slice_mode = val;
+        _sliceMode = val;
     }
 
-    void set_volume_mode(bool val)
+    void setVolumeMode(bool val)
     {
-        volume_mode = val;
+        _volumeMode = val;
     }
 
     /// switch_cutplane_mode
-    void switch_slice_mode()
+    void switchSliceMode()
     {
-        slice_mode = (!slice_mode);
+        _sliceMode = (!_sliceMode);
     }
 
-    void switch_volume_mode()
+    void switchVolumeMode()
     {
-        volume_mode = (!volume_mode);
+        _volumeMode = (!_volumeMode);
     }
 
@@ -91 +91 @@
 
 private:
-    void init_shaders();
+    void initShaders();
 
-    void activate_volume_shader(Volume *vol, bool slice_mode);
+    void activateVolumeShader(Volume *vol, bool slice_mode);
 
-    void deactivate_volume_shader();
+    void deactivateVolumeShader();
 
-     void draw_bounding_box(float x0, float y0, float z0,
-                            float x1, float y1, float z1,
-                            float r, float g, float b, float line_width);
+    void drawBoundingBox(float x0, float y0, float z0,
+                         float x1, float y1, float z1,
+                         float r, float g, float b, float line_width);
 
-    void get_near_far_z(const Mat4x4& mv, double& zNear, double& zFar);
+    void getNearFarZ(const Mat4x4& mv, double& zNear, double& zFar);
 
-    bool init_font(const char *filename);
+    bool initFont(const char *filename);
 
     /// there are two sets of font in the texture. 0, 1
@@ -109 +109 @@
 
     /// draw label using bitmap texture
-    void draw_label(Volume *vol);
+    void drawLabel(Volume *vol);
 
     /// Register the location of each alphabet in
-    void build_font();
+    void buildFont();
 
     VolumeInterpolator *_volumeInterpolator;
 
-    bool slice_mode;  ///< enable cut planes
-    bool volume_mode; ///< enable full volume rendering
+    bool _sliceMode;  ///< enable cut planes
+    bool _volumeMode; ///< enable full volume rendering
 
     /** 
@@ -146 +146 @@
 
     //standard vertex shader parameters
-    CGprogram m_vert_std_vprog;
-    CGparameter m_mvp_vert_std_param;
-    CGparameter m_mvi_vert_std_param;
-    GLuint font_base;           // The base of the font display list.
-    GLuint font_texture;        //the id of the font texture
+    CGprogram _vertStdVprog;
+    CGparameter _mvpVertStdParam;
+    CGparameter _mviVertStdParam;
+    GLuint _fontBase;      ///< The base of the font display list.
+    GLuint _fontTexture;   ///< The id of the font texture
 };
 

trunk/packages/vizservers/nanovis/ZincBlendeVolume.cpp

@@ -24 +24 @@
                                    float *dataVolumeA, float *dataVolumeB,
                                    double v0, double v1, double non_zeromin,
-                                   const Vector3& cellSize) :
+                                   const Vector3& cellSz) :
     Volume(x, y, z, w, h, d, s, n, dataVolumeA, v0, v1, non_zeromin),
-    cell_size(cellSize)
+    cellSize(cellSz)
 {
     //label it as zincblende
-    _volume_type = ZINCBLENDE;
+    _volumeType = ZINCBLENDE;
 
     //store member tex initialize in Volume() as zincblende_tex[0]
     assert(_tex);
-    zincblende_tex[0] = _tex;
+    zincblendeTex[0] = _tex;
 
     //now add another tex as zincblende_tex[1]
@@ -40 +40 @@
     secondTex->initialize(dataVolumeB);
 
-    zincblende_tex[1] = secondTex;
+    zincblendeTex[1] = secondTex;
 }
 
@@ -48 +48 @@
     //if (zincblende_tex[0])
     //  delete zincblende_tex[0];
-    if (zincblende_tex[1])
-        delete zincblende_tex[1];
+    if (zincblendeTex[1])
+        delete zincblendeTex[1];
 }

trunk/packages/vizservers/nanovis/ZincBlendeVolume.h

@@ -30 +30 @@
     virtual ~ZincBlendeVolume();
 
-    Texture3D *zincblende_tex[2];       //the textures of two cubic volumes
-    Vector3 cell_size;  //the cell size in texture space
+    Texture3D *zincblendeTex[2]; //the textures of two cubic volumes
+    Vector3 cellSize;   //the cell size in texture space
 };
 

trunk/packages/vizservers/nanovis/config.h

@@ -18 +18 @@
 #define CONFIG_H__
 
-#define NV40                            /* Uncomment if using 6 series
-                                         * card. By default we assume older
-                                         * card the 5xxx series */
+/*
+ * GeForce 6 series and above cards support non-power-of-two texture
+ * dimensions.  If using a 5 series card, disable this define
+ */
+#define HAVE_NPOT_TEXTURES
+
+/*
+ * GeForce 6 series and above cards support 16- or 32-bit float filtering 
+ * and blending.  If using a 5 series card, disable this define
+ */
+#define HAVE_FLOAT_TEXTURES
+
+/*
+ * GeForce 8 series cards support 32-bit float filtering and blending.
+ * If using a 6 or 7 series card, enable this define to use 16-bit float
+ * textures and blending
+ */
+#define USE_HALF_FLOAT
+
 #define XINETD                          /* Enable render server. */
 //#define EVENTLOG                      /* Enable event logging. */
 //#define DO_RLE                        /* Do run length compression. */
 
+#define KEEPSTATS               1
+
 /*
  * Controls if debug trace logging is enabled
  */
-//#define WANT_TRACE
+#define WANT_TRACE
+
+//#define OLD_CAMERA
 
 /* 
@@ -39 +59 @@
 
 /* 
- * The following define controls whether new load_volume_stream or
- * load_volume_stream2 are used to load DX data.  The difference is that
- * load_volume_stream2 doesn't do any interpolation of the points to a coarser
- * mesh.  Right now, we're using load_volume_stream2 to make isosurfaces
- * work correctly.  
-
+ * The following define controls whether the new or old load_volume_stream 
+ * implementation is used to load DX data. The difference is that the old
+ * implementation doesn't do any interpolation of the points to a coarser
+ * mesh.  Setting ISO_TEST to 1 will cause the old implementation to be
+ * used, which makes isosurfaces work correctly (FIXME: is this still 
+ * true?)
+ *
  * [In the future, we'll use the OpenDX library reader and determine at
  * runtime if mesh decimation is required]
  */
 #define ISO_TEST                0
+
+/*
+ * Determines if Sobel filter is applied to gradients when loading a 
+ * volume
+ */
+#define FILTER_GRADIENTS        1
 
 /* 

trunk/packages/vizservers/nanovis/dxReader.cpp

@@ -35 +35 @@
 #include "dxReaderCommon.h"
 
+#include "config.h"
 #include "nanovis.h"
 #include "Unirect.h"
@@ -265 +266 @@
         dz = nz;
 
-        volPtr = NanoVis::load_volume(tag, nx, ny, nz, 4, data,
-                                      vmin, vmax, nzero_min);
+        volPtr = NanoVis::loadVolume(tag, nx, ny, nz, 4, data,
+                                     vmin, vmax, nzero_min);
         volPtr->xAxis.SetRange(x0, x0 + (nx * dx));
         volPtr->yAxis.SetRange(y0, y0 + (ny * dy));
         volPtr->zAxis.SetRange(z0, z0 + (nz * dz)); 
         volPtr->wAxis.SetRange(vmin, vmax);
-        volPtr->update_pending = true;
+        volPtr->updatePending = true;
         delete [] data;
     } else {
@@ -319 +320 @@
         ny = (int)ceil(dy/dmin);
         nz = (int)ceil(dz/dmin);
-#ifndef NV40
+#ifndef HAVE_NPOT_TEXTURES
         // must be an even power of 2 for older cards
         nx = (int)pow(2.0, ceil(log10((double)nx)/log10(2.0)));
@@ -358 +359 @@
         computeSimpleGradient(data, nx, ny, nz);
 
-        volPtr = NanoVis::load_volume(tag, nx, ny, nz, 4, data,
-                                      field.valueMin(), field.valueMax(),
-                                      nzero_min);
+        volPtr = NanoVis::loadVolume(tag, nx, ny, nz, 4, data,
+                                     field.valueMin(), field.valueMax(),
+                                     nzero_min);
         volPtr->xAxis.SetRange(field.rangeMin(Rappture::xaxis),
                                field.rangeMax(Rappture::xaxis));
@@ -368 +369 @@
                                field.rangeMax(Rappture::zaxis));
         volPtr->wAxis.SetRange(field.valueMin(), field.valueMax());
-        volPtr->update_pending = true;
+        volPtr->updatePending = true;
         delete [] data;
     }
@@ -590 +591 @@
         nz = (int)ceil(dz/dmin);
 
-#ifndef NV40
+#ifndef HAVE_NPOT_TEXTURES
         // must be an even power of 2 for older cards
         nx = (int)pow(2.0, ceil(log10((double)nx)/log10(2.0)));
@@ -597 +598 @@
 #endif
 
-//#define _SOBEL_
-#ifdef _SOBEL_
+#ifdef FILTER_GRADIENTS
         const int step = 1;
         float *cdata = new float[nx*ny*nz * step];
@@ -668 +668 @@
               field.valueMin(), field.valueMax(), nzero_min);
 
-        volPtr = NanoVis::load_volume(tag, nx, ny, nz, 4, data,
-                                      field.valueMin(), field.valueMax(),
-                                      nzero_min);
+        volPtr = NanoVis::loadVolume(tag, nx, ny, nz, 4, data,
+                                     field.valueMin(), field.valueMax(),
+                                     nzero_min);
         volPtr->xAxis.SetRange(field.rangeMin(Rappture::xaxis),
                                field.rangeMax(Rappture::xaxis));
@@ -678 +678 @@
                                field.rangeMax(Rappture::zaxis));
         volPtr->wAxis.SetRange(field.valueMin(), field.valueMax());
-        volPtr->update_pending = true;
+        volPtr->updatePending = true;
         // TBD..
 #if 0 && defined(USE_POINTSET_RENDERER)
@@ -735 +735 @@
         ny = (int)ceil(dy/dmin);
         nz = (int)ceil(dz/dmin);
-#ifndef NV40
+#ifndef HAVE_NPOT_TEXTURES
         // must be an even power of 2 for older cards
         nx = (int)pow(2.0, ceil(log10((double)nx)/log10(2.0)));
@@ -774 +774 @@
         computeSimpleGradient(data, nx, ny, nz);
 
-        volPtr = NanoVis::load_volume(tag, nx, ny, nz, 4, data,
-                                      field.valueMin(), field.valueMax(),
-                                      nzero_min);
+        volPtr = NanoVis::loadVolume(tag, nx, ny, nz, 4, data,
+                                     field.valueMin(), field.valueMax(),
+                                     nzero_min);
         volPtr->xAxis.SetRange(field.rangeMin(Rappture::xaxis),
                                field.rangeMax(Rappture::xaxis));
@@ -784 +784 @@
                                field.rangeMax(Rappture::zaxis));
         volPtr->wAxis.SetRange(field.valueMin(), field.valueMax());
-        volPtr->update_pending = true;
+        volPtr->updatePending = true;
         // TBD..
 #if 0 && defined(USE_POINTSET_RENDERER)

trunk/packages/vizservers/nanovis/dxReader.h

@@ -14 +14 @@
                    std::iostream& fin);
 
-extern Volume *
-load_volume_stream2(Rappture::Outcome& status, const char *tag, 
-                    std::iostream& fin);
-
 #endif

trunk/packages/vizservers/nanovis/dxReaderCommon.cpp

@@ -16 +16 @@
     for (sindex = 0; sindex < size; ++sindex) {
         data[ngen++] = scalar[sindex];
-        data[ngen++] = g[sindex].x;
-        data[ngen++] = g[sindex].y;
-        data[ngen++] = g[sindex].z;
+        data[ngen++] = 1.0 - g[sindex].x;
+        data[ngen++] = 1.0 - g[sindex].y;
+        data[ngen++] = 1.0 - g[sindex].z;
     }
     return data;
@@ -29 +29 @@
     if (v != 0.0f) {
         for (int i = 0; i < count; ++i) {
-            fdata[i] = fdata[i] / v;
+            if (fdata[i] != -1.0) {
+                fdata[i] = (fdata[i] - min)/ v;
+            }
         }
     }
 }
 
+/**
+ * \brief Compute Sobel filtered gradients for a 3D volume
+ *
+ * This technique is fairly expensive in terms of memory and
+ * running time due to the filter extent.
+ */
 float *
-computeGradient(float *fdata, int width, int height, int depth,
+computeGradient(float *fdata,
+                int width, int height, int depth,
+                float dx, float dy, float dz,
                 float min, float max)
 {
@@ -43 +53 @@
                                            sizeof(float));
     int sizes[3] = { width, height, depth };
-    computeGradients(tempGradients, fdata, sizes, DATRAW_FLOAT);
+    float spacing[3] = { dx, dy, dz };
+    computeGradients(tempGradients, fdata, sizes, spacing, DATRAW_FLOAT);
     filterGradients(tempGradients, sizes);
     quantizeGradients(tempGradients, gradients, sizes, DATRAW_FLOAT);
@@ -53 +64 @@
 }
 
+/**
+ * \brief Compute gradients for a 3D volume with cubic cells
+ * 
+ * The gradients are estimated using the central difference
+ * method.  This function assumes the data are normalized
+ * to [0,1] with missing data/NaNs represented by a negative
+ * value.
+ *
+ * \param data Data array with X the fastest running. There
+ * should be 4 floats allocated for each node, with the 
+ * first float containing the scalar value.  The subsequent
+ * 3 floats will be filled with the x,y,z components of the
+ * gradient vector
+ * \param nx The number of nodes in the X direction
+ * \param ny The number of nodes in the Y direction
+ * \param nz The number of nodes in the Z direction
+ * \param dx The spacing (cell length) in the X direction
+ * \param dy The spacing (cell length) in the Y direction
+ * \param dz The spacing (cell length) in the Z direction
+ */
 void
-computeSimpleGradient(float *data, int nx, int ny, int nz)
+computeSimpleGradient(float *data, int nx, int ny, int nz,
+                      float dx, float dy, float dz)
 {
+    bool clampToEdge = true;
+    double borderVal = 0.0;
+
+#define BORDER ((clampToEdge ? data[ngen] : borderVal))
+
     // Compute the gradient of this data.  BE CAREFUL: center
     // calculation on each node to avoid skew in either direction.
@@ -63 +100 @@
             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];
+                double valm1 = (ix == 0) ? BORDER : data[ngen - 4];
+                double valp1 = (ix == nx-1) ? BORDER : data[ngen + 4];
                 if (valm1 < 0.0 || valp1 < 0.0) {
                     data[ngen+1] = 0.0;
                 } else {
-                    data[ngen+1] = valp1-valm1; // assume dx=1
-                    //data[ngen+1] = ((valp1-valm1) + 1.0) * 0.5; // assume dx=1 (ISO)
-                }
+                    data[ngen+1] = -(valp1-valm1)/(2. * dx);
+                 }
 
                 // gradient in y-direction
-                valm1 = (iy == 0) ? 0.0 : data[ngen - 4*nx];
-                valp1 = (iy == ny-1) ? 0.0 : data[ngen + 4*nx];
+                valm1 = (iy == 0) ? BORDER : data[ngen - 4*nx];
+                valp1 = (iy == ny-1) ? BORDER : data[ngen + 4*nx];
                 if (valm1 < 0.0 || valp1 < 0.0) {
                     data[ngen+2] = 0.0;
                 } else {
-                    data[ngen+2] = valp1-valm1; // assume dy=1
-                    //data[ngen+2] = ((valp1-valm1) + 1.0) * 0.5; // assume dy=1 (ISO)
+                    data[ngen+2] = -(valp1-valm1)/(2. * dy);
                 }
 
                 // 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];
+                valm1 = (iz == 0) ? BORDER : data[ngen - 4*nx*ny];
+                valp1 = (iz == nz-1) ? BORDER : data[ngen + 4*nx*ny];
                 if (valm1 < 0.0 || valp1 < 0.0) {
                     data[ngen+3] = 0.0;
                 } else {
-                    data[ngen+3] = valp1-valm1; // assume dz=1
-                    //data[ngen+3] = ((valp1-valm1) + 1.0) * 0.5; // assume dz=1 (ISO)
+                    data[ngen+3] = -(valp1-valm1)/(2. * dz);
                 }
-
+                // Normalize and scale/bias to [0,1] range
+                // The volume shader will expand to [-1,1]
+                double len = sqrt(data[ngen+1]*data[ngen+1] +
+                                  data[ngen+2]*data[ngen+2] +
+                                  data[ngen+3]*data[ngen+3]);
+                if (len < 1.0e-6) {
+                    data[ngen+1] = 0.0;
+                    data[ngen+2] = 0.0;
+                    data[ngen+3] = 0.0;
+                } else {
+                    data[ngen+1] = (data[ngen+1]/len + 1.0) * 0.5;
+                    data[ngen+2] = (data[ngen+2]/len + 1.0) * 0.5;
+                    data[ngen+3] = (data[ngen+3]/len + 1.0) * 0.5;
+                }
                 ngen += 4;
             }
         }
     }
+
+#undef BORDER
 }

trunk/packages/vizservers/nanovis/dxReaderCommon.h

@@ -10 +10 @@
 
 extern float *
-computeGradient(float *fdata, int width, int height, int depth,
+computeGradient(float *fdata,
+                int width, int height, int depth,
+                float dx, float dy, float dz,
                 float min, float max);
 
 extern void
-computeSimpleGradient(float *data, int nx, int ny, int nz);
+computeSimpleGradient(float *data, int nx, int ny, int nz,
+                      float dx = 1.0f, float dy = 1.0f, float dz = 1.0f);
 
 #endif

trunk/packages/vizservers/nanovis/nanovis.cpp

@@ -56 +56 @@
 #include <GL/glut.h>
 
+#include "config.h"
 #include "nanovis.h"
 #include "define.h"
@@ -96 +97 @@
 };
 
-#define KEEPSTATS       1
-
 #define CVT2SECS(x)  ((double)(x).tv_sec) + ((double)(x).tv_usec * 1.0e-6)
 
@@ -120 +119 @@
 Tcl_HashTable NanoVis::volumeTable;
 Tcl_HashTable NanoVis::heightmapTable;
-VolumeRenderer *NanoVis::vol_renderer = NULL;
+VolumeRenderer *NanoVis::volRenderer = NULL;
 #ifdef USE_POINTSET_RENDERER
-PointSetRenderer *NanoVis::pointset_renderer = NULL;
+PointSetRenderer *NanoVis::pointSetRenderer = NULL;
 std::vector<PointSet *> NanoVis::pointSet;
 #endif
 
-PlaneRenderer *NanoVis::plane_renderer = NULL;
+PlaneRenderer *NanoVis::planeRenderer = NULL;
 #if PLANE_CMD
 // pointers to 2D planes, currently handle up 10
@@ -132 +131 @@
 #endif
 Texture2D *NanoVis::legendTexture = NULL;
-NvColorTableRenderer *NanoVis::color_table_renderer = NULL;
+NvColorTableRenderer *NanoVis::colorTableRenderer = NULL;
 
 NvFlowVisRenderer *NanoVis::flowVisRenderer = NULL;
@@ -145 +144 @@
 FILE *NanoVis::recfile = NULL;
 
-bool NanoVis::axis_on = true;
-bool NanoVis::config_pending = false;
-bool NanoVis::debug_flag = false;
+bool NanoVis::axisOn = true;
+bool NanoVis::debugFlag = false;
 
 Tcl_Interp *NanoVis::interp;
@@ -153 +151 @@
 
 //frame buffer for final rendering
-GLuint NanoVis::_final_color_tex = 0;
-GLuint NanoVis::_final_depth_rb = 0;
-GLuint NanoVis::_final_fbo = 0;
-int NanoVis::render_window = 0;       /* GLUT handle for the render window */
-int NanoVis::win_width = NPIX;        /* Width of the render window */
-int NanoVis::win_height = NPIX;       /* Height of the render window */
-
-unsigned char* NanoVis::screen_buffer = NULL;
+GLuint NanoVis::_finalColorTex = 0;
+GLuint NanoVis::_finalDepthRb = 0;
+GLuint NanoVis::_finalFbo = 0;
+int NanoVis::renderWindow = 0;       /* GLUT handle for the render window */
+int NanoVis::winWidth = NPIX;        /* Width of the render window */
+int NanoVis::winHeight = NPIX;       /* Height of the render window */
+
+unsigned char* NanoVis::screenBuffer = NULL;
 
 unsigned int NanoVis::flags = 0;
@@ -179 +177 @@
 
 /* FIXME: This variable is always true. */
-bool volume_mode = true; 
+static bool volumeMode = true; 
 
 // in Command.cpp
 extern Tcl_Interp *initTcl();
-
-float vert[NMESH*NMESH*3];              //particle positions in main memory
-float slice_vector[NMESH*NMESH*4];      //per slice vectors in main memory
 
 // maps transfunc name to TransferFunction object
@@ -205 +200 @@
 
 // Default camera location.
-const float def_eye_x = -0.0f;
-const float def_eye_y = -0.0f;
+const float def_eye_x = 0.0f;
+const float def_eye_y = 0.0f;
 const float def_eye_z = -2.5f;
 
@@ -221 +216 @@
 // Image based flow visualization slice location
 // FLOW
-float NanoVis::lic_slice_x = 0.5f;
-float NanoVis::lic_slice_y = 0.5f;
-float NanoVis::lic_slice_z = 0.5f;
-int NanoVis::lic_axis = 2; // z axis
-
-#define RM_VOLUME 1
-#define RM_POINT 2
-
-int renderMode = RM_VOLUME;
-
-void removeAllData()
+float NanoVis::_licSliceX = 0.5f;
+float NanoVis::_licSliceY = 0.5f;
+float NanoVis::_licSliceZ = 0.5f;
+int NanoVis::_licAxis = 2; // z axis
+
+static void
+removeAllData()
 {
     //
@@ -237 +228 @@
 
 void 
-NanoVis::EventuallyRedraw(unsigned int flag)
+NanoVis::eventuallyRedraw(unsigned int flag)
 {
     if (flag) {
@@ -251 +242 @@
 
 static int
-WriteStats(const char *who, int code) 
+writeStats(const char *who, int code) 
 {
     double start, finish;
@@ -351 +342 @@
 
 static void
-DoExit(int code)
-{
-    TRACE("in DoExit\n");
+doExit(int code)
+{
+    TRACE("in doExit\n");
     removeAllData();
 
@@ -367 +358 @@
 
 #if KEEPSTATS
-    WriteStats("nanovis", code);
+    writeStats("nanovis", code);
 #endif
     closelog();
@@ -374 +365 @@
 
 static int
-ExecuteCommand(Tcl_Interp *interp, Tcl_DString *dsPtr) 
+executeCommand(Tcl_Interp *interp, Tcl_DString *dsPtr) 
 {
     struct timeval tv;
@@ -397 +388 @@
     stats.cmdTime += finish - start;
     stats.nCommands++;
-    TRACE("leaving ExecuteCommand status=%d\n", result);
+    TRACE("leaving executeCommand status=%d\n", result);
     return result;
 }
@@ -428 +419 @@
 }
 
-/* Load a 3D volume
- * index:       the index into the volume array, which stores pointers 
- *              to 3D volume instances
- * data:        pointer to an array of floats.
- * n_component: the number of scalars for each space point. All component 
- *              scalars for a point are placed consequtively in data array
- *              width, height and depth: number of points in each dimension
+/** \brief Load a 3D volume
+ *
+ * \param n_component the number of scalars for each space point. All component 
+ * scalars for a point are placed consequtively in data array
+ * width, height and depth: number of points in each dimension
+ * \param data pointer to an array of floats.
  */
 Volume *
-NanoVis::load_volume(const char *name, int width, int height, int depth, 
-                     int n_component, float* data, double vmin, double vmax, 
-                     double nzero_min)
+NanoVis::loadVolume(const char *name, int width, int height, int depth, 
+                    int n_component, float *data, double vmin, double vmax, 
+                    double nzero_min)
 {
     Tcl_HashEntry *hPtr;
@@ -447 +437 @@
         WARN("volume \"%s\" already exists", name);
         volPtr = (Volume *)Tcl_GetHashValue(hPtr);
-        remove_volume(volPtr);
+        removeVolume(volPtr);
     }
     int isNew;
@@ -461 +451 @@
 // Gets a colormap 1D texture by name.
 TransferFunction*
-NanoVis::get_transfunc(const char *name) 
+NanoVis::getTransfunc(const char *name) 
 {
     Tcl_HashEntry *hPtr;
@@ -474 +464 @@
 // Creates of updates a colormap 1D texture by name.
 TransferFunction*
-NanoVis::DefineTransferFunction(const char *name, size_t n, float *data)
+NanoVis::defineTransferFunction(const char *name, size_t n, float *data)
 {
     int isNew;
@@ -497 +487 @@
 
 int
-NanoVis::render_legend(TransferFunction *tf, double min, double max,
-                       int width, int height, const char* volArg)
-{
-    TRACE("in render_legend\n");
-
-    int old_width = win_width;
-    int old_height = win_height;
-
-    plane_renderer->set_screen_size(width, height);
-    resize_offscreen_buffer(width, height);
+NanoVis::renderLegend(TransferFunction *tf, double min, double max,
+                      int width, int height, const char* volArg)
+{
+    TRACE("in renderLegend\n");
+
+    int old_width = winWidth;
+    int old_height = winHeight;
+
+    planeRenderer->set_screen_size(width, height);
+    resizeOffscreenBuffer(width, height);
 
     // generate data for the legend
@@ -514 +504 @@
     }
     legendTexture = new Texture2D(256, 2, GL_FLOAT, GL_LINEAR, 1, data);
-    int index = plane_renderer->add_plane(legendTexture, tf);
-    plane_renderer->set_active_plane(index);
-
-    offscreen_buffer_capture();
+    int index = planeRenderer->add_plane(legendTexture, tf);
+    planeRenderer->set_active_plane(index);
+
+    offscreenBufferCapture();
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //clear screen
-    plane_renderer->render();
+    planeRenderer->render();
 
     // INSOO
-    glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, screen_buffer);
-    //glReadPixels(0, 0, width, height, GL_BGR, GL_UNSIGNED_BYTE, screen_buffer); // INSOO's
+    glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, screenBuffer);
+    //glReadPixels(0, 0, width, height, GL_BGR, GL_UNSIGNED_BYTE, screenBuffer); // INSOO's
 
     {
@@ -531 +521 @@
         TRACE("ppm legend image");
         sprintf(prefix, "nv>legend %s %g %g", volArg, min, max);
-        ppm_write(prefix);
+        ppmWrite(prefix);
         nWritten = write(1, "\n", 1);
         assert(nWritten == 1);
     }
-    plane_renderer->remove_plane(index);
-    resize_offscreen_buffer(old_width, old_height);
-
-    TRACE("leaving render_legend\n");
+    planeRenderer->remove_plane(index);
+    resizeOffscreenBuffer(old_width, old_height);
+
+    TRACE("leaving renderLegend\n");
     delete legendTexture;
     return TCL_OK;
@@ -545 +535 @@
 //initialize frame buffer objects for offscreen rendering
 void
-NanoVis::init_offscreen_buffer()
-{
-    TRACE("in init_offscreen_buffer\n");
+NanoVis::initOffscreenBuffer()
+{
+    TRACE("in initOffscreenBuffer\n");
     // Initialize a fbo for final display.
-    glGenFramebuffersEXT(1, &_final_fbo);
-
-    glGenTextures(1, &_final_color_tex);
-    glBindTexture(GL_TEXTURE_2D, _final_color_tex);
+    glGenFramebuffersEXT(1, &_finalFbo);
+
+    glGenTextures(1, &_finalColorTex);
+    glBindTexture(GL_TEXTURE_2D, _finalColorTex);
 
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-#ifdef NV40
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F_ARB, win_width, win_height, 0,
+#if defined(HAVE_FLOAT_TEXTURES) && defined(USE_HALF_FLOAT)
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F_ARB, winWidth, winHeight, 0,
+                 GL_RGB, GL_INT, NULL);
+#elif defined(HAVE_FLOAT_TEXTURES)
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F_ARB, winWidth, winHeight, 0,
                  GL_RGB, GL_INT, NULL);
 #else
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, win_width, win_height, 0,
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, winWidth, winHeight, 0,
                  GL_RGB, GL_INT, NULL);
 #endif
-    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _final_fbo);
-    glGenRenderbuffersEXT(1, &_final_depth_rb);
-    glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, _final_depth_rb);
+    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _finalFbo);
+    glGenRenderbuffersEXT(1, &_finalDepthRb);
+    glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, _finalDepthRb);
     glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, 
-                             win_width, win_height);
+                             winWidth, winHeight);
     glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
-                              GL_TEXTURE_2D, _final_color_tex, 0);
+                              GL_TEXTURE_2D, _finalColorTex, 0);
     glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,
-                                 GL_RENDERBUFFER_EXT, _final_depth_rb);
+                                 GL_RENDERBUFFER_EXT, _finalDepthRb);
 
     GLenum status;
     if (!CheckFBO(&status)) {
-        PrintFBOStatus(status, "final_fbo");
-            DoExit(3);
+        PrintFBOStatus(status, "finalFbo");
+        doExit(3);
     }
 
@@ -583 +576 @@
 
     //assert(glGetError()==0);
-    TRACE("leaving init_offscreen_buffer\n");
+    TRACE("leaving initOffscreenBuffer\n");
 }
 
 //resize the offscreen buffer 
 void 
-NanoVis::resize_offscreen_buffer(int w, int h)
-{
-    TRACE("in resize_offscreen_buffer(%d, %d)\n", w, h);
-    if ((w == win_width) && (h == win_height)) {
+NanoVis::resizeOffscreenBuffer(int w, int h)
+{
+    TRACE("in resizeOffscreenBuffer(%d, %d)\n", w, h);
+    if ((w == winWidth) && (h == winHeight)) {
         return;
     }
-    win_width = w;
-    win_height = h;
+    winWidth = w;
+    winHeight = h;
 
     if (fonts) {
         fonts->resize(w, h);
     }
-    TRACE("screen_buffer size: %d %d\n", w, h);
-
-    if (screen_buffer != NULL) {
-        delete [] screen_buffer;
-        screen_buffer = NULL;
-    }
-
-    screen_buffer = new unsigned char[4*win_width*win_height];
-    assert(screen_buffer != NULL);
+    TRACE("screenBuffer size: %d %d\n", w, h);
+
+    if (screenBuffer != NULL) {
+        delete [] screenBuffer;
+        screenBuffer = NULL;
+    }
+
+    screenBuffer = new unsigned char[4*winWidth*winHeight];
+    assert(screenBuffer != NULL);
     
     //delete the current render buffer resources
-    glDeleteTextures(1, &_final_color_tex);
-    glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, _final_depth_rb);
-    glDeleteRenderbuffersEXT(1, &_final_depth_rb);
+    glDeleteTextures(1, &_finalColorTex);
+    glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, _finalDepthRb);
+    glDeleteRenderbuffersEXT(1, &_finalDepthRb);
 
     TRACE("before deleteframebuffers\n");
-    glDeleteFramebuffersEXT(1, &_final_fbo);
+    glDeleteFramebuffersEXT(1, &_finalFbo);
 
     TRACE("reinitialize FBO\n");
     //Reinitialize final fbo for final display
-    glGenFramebuffersEXT(1, &_final_fbo);
-
-    glGenTextures(1, &_final_color_tex);
-    glBindTexture(GL_TEXTURE_2D, _final_color_tex);
+    glGenFramebuffersEXT(1, &_finalFbo);
+
+    glGenTextures(1, &_finalColorTex);
+    glBindTexture(GL_TEXTURE_2D, _finalColorTex);
 
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-#ifdef NV40
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F_ARB, win_width, win_height, 0,
+#if defined(HAVE_FLOAT_TEXTURES) && defined(USE_HALF_FLOAT)
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F_ARB, winWidth, winHeight, 0,
+                 GL_RGB, GL_INT, NULL);
+#elif defined(HAVE_FLOAT_TEXTURES)
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F_ARB, winWidth, winHeight, 0,
                  GL_RGB, GL_INT, NULL);
 #else
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, win_width, win_height, 0,
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, winWidth, winHeight, 0,
                  GL_RGB, GL_INT, NULL);
 #endif
     TRACE("before bindframebuffer\n");
-    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _final_fbo);
+    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _finalFbo);
     TRACE("after bindframebuffer\n");
-    glGenRenderbuffersEXT(1, &_final_depth_rb);
-    glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, _final_depth_rb);
+    glGenRenderbuffersEXT(1, &_finalDepthRb);
+    glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, _finalDepthRb);
     glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, 
-                             win_width, win_height);
+                             winWidth, winHeight);
     glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
-                              GL_TEXTURE_2D, _final_color_tex, 0);
+                              GL_TEXTURE_2D, _finalColorTex, 0);
     glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,
-                                 GL_RENDERBUFFER_EXT, _final_depth_rb);
+                                 GL_RENDERBUFFER_EXT, _finalDepthRb);
 
     GLenum status;
     if (!CheckFBO(&status)) {
-        PrintFBOStatus(status, "final_fbo");
-        DoExit(3);
+        PrintFBOStatus(status, "finalFbo");
+        doExit(3);
     }
 
@@ -655 +651 @@
     TRACE("change camera\n");
     //change the camera setting
-    cam->set_screen_size(0, 0, win_width, win_height);
-    plane_renderer->set_screen_size(win_width, win_height);
-
-    TRACE("leaving resize_offscreen_buffer(%d, %d)\n", w, h);
+    cam->set_screen_size(0, 0, winWidth, winHeight);
+    planeRenderer->set_screen_size(winWidth, winHeight);
+
+    TRACE("leaving resizeOffscreenBuffer(%d, %d)\n", w, h);
 }
 
@@ -668 +664 @@
  *      to turn it back on.
  */
-void 
-make_test_2D_data()
+static void 
+makeTest2DData()
 {
     int w = 300;
@@ -693 +689 @@
 }
 
-void CgErrorCallback(void)
+static
+void cgErrorCallback(void)
 {
     if (!NvShader::printErrorInfo()) {
         TRACE("Cg error, exiting...\n");
-        DoExit(-1);
+        doExit(-1);
     }
 }
@@ -712 +709 @@
     if (path == NULL) {
         ERROR("No path defined for shaders or resources\n");
-        DoExit(1);
+        doExit(1);
     }
     GLenum err = glewInit();
     if (GLEW_OK != err) {
-        ERROR("%s\n", glewGetErrorString(err));
-        getchar();
-        //assert(false);
+        ERROR("Can't init GLEW: %s\n", glewGetErrorString(err));
+        doExit(1);
     }
     TRACE("Using GLEW %s\n", glewGetString(GLEW_VERSION));
+
+    if (!GLEW_EXT_framebuffer_object) {
+        ERROR("EXT_framebuffer_oject extension is required to run nanovis\n");
+        doExit(1);
+    }
+#ifdef HAVE_NPOT_TEXTURES
+    if (!GLEW_ARB_texture_non_power_of_two) {
+        ERROR("GLEW_ARB_texture_non_power_of_two extension is required to run nanovis\n");
+        doExit(1);
+    }
+#endif
+#ifdef HAVE_FLOAT_TEXTURES
+    if (!GLEW_ARB_texture_float ||
+        !GLEW_ARB_color_buffer_float) {
+        ERROR("ARB_texture_float and ARB_color_buffer_float extensions are required to run nanovis\n");
+        doExit(1);
+    }
+#endif
 
     if (!R2FilePath::getInstance()->setPath(path)) {
         ERROR("can't set file path to %s\n", path);
-        DoExit(1);
+        doExit(1);
     }
 
@@ -732 +746 @@
 
     NvShader::initCg();
-    NvShader::setErrorCallback(CgErrorCallback);
+    NvShader::setErrorCallback(cgErrorCallback);
 
     fonts = new R2Fonts();
@@ -738 +752 @@
     fonts->setFont("verdana");
 
-    color_table_renderer = new NvColorTableRenderer();
-    color_table_renderer->setFonts(fonts);
+    colorTableRenderer = new NvColorTableRenderer();
+    colorTableRenderer->setFonts(fonts);
 
     flowVisRenderer = new NvFlowVisRenderer(NMESH, NMESH);
@@ -745 +759 @@
     NanoVis::velocityArrowsSlice = new VelocityArrowsSlice;
 
-    licRenderer = new NvLIC(NMESH, NPIX, NPIX, lic_axis, 
-                            Vector3(lic_slice_x, lic_slice_y, lic_slice_z), 
+    licRenderer = new NvLIC(NMESH, NPIX, NPIX, _licAxis, 
+                            Vector3(_licSliceX, _licSliceY, _licSliceZ), 
                             NvShader::getCgContext());
 
@@ -753 +767 @@
 
 #ifdef USE_POINTSET_RENDERER
-    pointset_renderer = new PointSetRenderer();
+    pointSetRenderer = new PointSetRenderer();
 #endif
 }
@@ -763 +777 @@
     TRACE("in initGL\n");
     //buffer to store data read from the screen
-    if (screen_buffer) {
-        delete[] screen_buffer;
-        screen_buffer = NULL;
-    }
-    screen_buffer = new unsigned char[4*win_width*win_height];
-    assert(screen_buffer != NULL);
+    if (screenBuffer) {
+        delete[] screenBuffer;
+        screenBuffer = NULL;
+    }
+    screenBuffer = new unsigned char[4*winWidth*winHeight];
+    assert(screenBuffer != NULL);
 
     //create the camera with default setting
-    cam = new NvCamera(0, 0, win_width, win_height,
+    cam = new NvCamera(0, 0, winWidth, winHeight,
                        def_eye_x, def_eye_y, def_eye_z,          /* location. */
                        def_target_x, def_target_y, def_target_z, /* target. */
@@ -781 +795 @@
 
     glClearColor(0,0,0,1);
-    //glClearColor(0.7,0.7,0.7,1);
     glClear(GL_COLOR_BUFFER_BIT);
 
@@ -801 +814 @@
 
     //check if performance query is supported
-    if(check_query_support()){
+    if (PerfQuery::checkQuerySupport()) {
         //create queries to count number of rendered pixels
         perf = new PerfQuery();
     }
 
-    init_offscreen_buffer();    //frame buffer object for offscreen rendering
+    initOffscreenBuffer();    //frame buffer object for offscreen rendering
 
     //create volume renderer and add volumes to it
-    vol_renderer = new VolumeRenderer();
+    volRenderer = new VolumeRenderer();
 
     // create
@@ -815 +828 @@
 
     //create a 2D plane renderer
-    plane_renderer = new PlaneRenderer(win_width, win_height);
+    planeRenderer = new PlaneRenderer(winWidth, winHeight);
 #if PROTOTYPE
     make_test_2D_data();
-    plane_renderer->add_plane(plane[0], get_transfunc("default"));
+    planeRenderer->add_plane(plane[0], getTransfunc("default"));
 #endif
 
@@ -828 +841 @@
 #if DO_RLE
 char rle[512*512*3];
-int rle_size;
+int rleSize;
 
 short offsets[512*512*3];
-int offsets_size;
-
-void 
-do_rle()
-{
-    int len = NanoVis::win_width*NanoVis::win_height*3;
-    rle_size = 0;
-    offsets_size = 0;
-
-    int i=0;
-    while(i<len){
-        if (NanoVis::screen_buffer[i] == 0) {
+int offsetsSize;
+
+static void 
+doRle()
+{
+    int len = NanoVis::winWidth*NanoVis::winHeight*3;
+    rleSize = 0;
+    offsetsSize = 0;
+
+    int i = 0;
+    while (i < len) {
+        if (NanoVis::screenBuffer[i] == 0) {
             int pos = i+1;
-            while ( (pos<len) && (NanoVis::screen_buffer[pos] == 0)) {
+            while ( (pos < len) && (NanoVis::screenBuffer[pos] == 0)) {
                 pos++;
             }
-            offsets[offsets_size++] = -(pos - i);
+            offsets[offsetsSize++] = -(pos - i);
             i = pos;
         }
@@ -853 +866 @@
         else {
             int pos;
-            for (pos = i; (pos<len) && (NanoVis::screen_buffer[pos] != 0);pos++){
-                rle[rle_size++] = NanoVis::screen_buffer[pos];
+            for (pos = i; (pos < len) && (NanoVis::screenBuffer[pos] != 0); pos++){
+                rle[rleSize++] = NanoVis::screenBuffer[pos];
             }
-            offsets[offsets_size++] = (pos - i);
+            offsets[offsetsSize++] = (pos - i);
             i = pos;
         }
@@ -867 +880 @@
 // Writes an integer value into the header data structure at pos
 static inline void
-bmp_header_add_int(unsigned char* header, int& pos, int data)
+bmpHeaderAddInt(unsigned char* header, int& pos, int data)
 {
 #ifdef WORDS_BIGENDIAN
@@ -885 +898 @@
 // FOR DEBUGGING
 void
-NanoVis::bmp_write_to_file(int frame_number, const char *directory_name)
+NanoVis::bmpWriteToFile(int frame_number, const char *directory_name)
 {
     unsigned char header[SIZEOF_BMP_HEADER];
@@ -895 +908 @@
     // on each scan line.  If need be, we add padding to each line.
     int pad = 0;
-    if ((3*win_width) % 4 > 0) {
-        pad = 4 - ((3*win_width) % 4);
+    if ((3*winWidth) % 4 > 0) {
+        pad = 4 - ((3*winWidth) % 4);
     }
 
     // file size in bytes
-    int fsize = (3*win_width+pad)*win_height + SIZEOF_BMP_HEADER;
-    bmp_header_add_int(header, pos, fsize);
+    int fsize = (3*winWidth+pad)*winHeight + SIZEOF_BMP_HEADER;
+    bmpHeaderAddInt(header, pos, fsize);
 
     // reserved value (must be 0)
-    bmp_header_add_int(header, pos, 0);
+    bmpHeaderAddInt(header, pos, 0);
 
     // offset in bytes to start of bitmap data
-    bmp_header_add_int(header, pos, SIZEOF_BMP_HEADER);
+    bmpHeaderAddInt(header, pos, SIZEOF_BMP_HEADER);
 
     // size of the BITMAPINFOHEADER
-    bmp_header_add_int(header, pos, 40);
+    bmpHeaderAddInt(header, pos, 40);
 
     // width of the image in pixels
-    bmp_header_add_int(header, pos, win_width);
+    bmpHeaderAddInt(header, pos, winWidth);
 
     // height of the image in pixels
-    bmp_header_add_int(header, pos, win_height);
+    bmpHeaderAddInt(header, pos, winHeight);
 
     // 1 plane + (24 bits/pixel << 16)
-    bmp_header_add_int(header, pos, 1572865);
+    bmpHeaderAddInt(header, pos, 1572865);
 
     // no compression
     // size of image for compression
-    bmp_header_add_int(header, pos, 0);
-    bmp_header_add_int(header, pos, 0);
+    bmpHeaderAddInt(header, pos, 0);
+    bmpHeaderAddInt(header, pos, 0);
 
     // x pixels per meter
     // y pixels per meter
-    bmp_header_add_int(header, pos, 0);
-    bmp_header_add_int(header, pos, 0);
+    bmpHeaderAddInt(header, pos, 0);
+    bmpHeaderAddInt(header, pos, 0);
 
     // number of colors used (0 = compute from bits/pixel)
     // number of important colors (0 = all colors important)
-    bmp_header_add_int(header, pos, 0);
-    bmp_header_add_int(header, pos, 0);
+    bmpHeaderAddInt(header, pos, 0);
+    bmpHeaderAddInt(header, pos, 0);
 
     // BE CAREFUL: BMP format wants BGR ordering for screen data
-    unsigned char* scr = screen_buffer;
-    for (int row=0; row < win_height; row++) {
-        for (int col=0; col < win_width; col++) {
+    unsigned char* scr = screenBuffer;
+    for (int row=0; row < winHeight; row++) {
+        for (int col=0; col < winWidth; col++) {
             unsigned char tmp = scr[2];
             scr[2] = scr[0];  // B
@@ -970 +983 @@
         ERROR("can't write header: short write\n");
     }
-    if (fwrite(screen_buffer, (3*win_width+pad)*win_height, 1, f) != 1) {
+    if (fwrite(screenBuffer, (3*winWidth+pad)*winHeight, 1, f) != 1) {
         ERROR("can't write data: short write\n");
     }
@@ -977 +990 @@
 
 void
-NanoVis::bmp_write(const char *prefix)
+NanoVis::bmpWrite(const char *prefix)
 {
     unsigned char header[SIZEOF_BMP_HEADER];
@@ -986 +999 @@
     // on each scan line.  If need be, we add padding to each line.
     int pad = 0;
-    if ((3*win_width) % 4 > 0) {
-        pad = 4 - ((3*win_width) % 4);
+    if ((3*winWidth) % 4 > 0) {
+        pad = 4 - ((3*winWidth) % 4);
     }
     pad = 0;
-    int fsize = (3*win_width+pad)*win_height + sizeof(header);
+    int fsize = (3*winWidth+pad)*winHeight + sizeof(header);
 
     char string[200];
@@ -1000 +1013 @@
 
     // file size in bytes
-    bmp_header_add_int(header, pos, fsize);
+    bmpHeaderAddInt(header, pos, fsize);
 
     // reserved value (must be 0)
-    bmp_header_add_int(header, pos, 0);
+    bmpHeaderAddInt(header, pos, 0);
 
     // offset in bytes to start of bitmap data
-    bmp_header_add_int(header, pos, SIZEOF_BMP_HEADER);
+    bmpHeaderAddInt(header, pos, SIZEOF_BMP_HEADER);
 
     // size of the BITMAPINFOHEADER
-    bmp_header_add_int(header, pos, 40);
+    bmpHeaderAddInt(header, pos, 40);
 
     // width of the image in pixels
-    bmp_header_add_int(header, pos, win_width);
+    bmpHeaderAddInt(header, pos, winWidth);
 
     // height of the image in pixels
-    bmp_header_add_int(header, pos, win_height);
+    bmpHeaderAddInt(header, pos, winHeight);
 
     // 1 plane + (24 bits/pixel << 16)
-    bmp_header_add_int(header, pos, 1572865);
+    bmpHeaderAddInt(header, pos, 1572865);
 
     // no compression
     // size of image for compression
-    bmp_header_add_int(header, pos, 0);
-    bmp_header_add_int(header, pos, 0);
+    bmpHeaderAddInt(header, pos, 0);
+    bmpHeaderAddInt(header, pos, 0);
 
     // x pixels per meter
     // y pixels per meter
-    bmp_header_add_int(header, pos, 0);
-    bmp_header_add_int(header, pos, 0);
+    bmpHeaderAddInt(header, pos, 0);
+    bmpHeaderAddInt(header, pos, 0);
 
     // number of colors used (0 = compute from bits/pixel)
     // number of important colors (0 = all colors important)
-    bmp_header_add_int(header, pos, 0);
-    bmp_header_add_int(header, pos, 0);
+    bmpHeaderAddInt(header, pos, 0);
+    bmpHeaderAddInt(header, pos, 0);
 
     // BE CAREFUL: BMP format wants BGR ordering for screen data
-    unsigned char* scr = screen_buffer;
-    for (int row=0; row < win_height; row++) {
-        for (int col=0; col < win_width; col++) {
+    unsigned char* scr = screenBuffer;
+    for (int row=0; row < winHeight; row++) {
+        for (int col=0; col < winWidth; col++) {
             unsigned char tmp = scr[2];
             scr[2] = scr[0];  // B
@@ -1049 +1062 @@
     nWritten = write(1, header, SIZEOF_BMP_HEADER);
     assert(nWritten == SIZEOF_BMP_HEADER);
-    nWritten = write(1, screen_buffer, (3*win_width+pad)*win_height);
-    assert(nWritten == (3*win_width+pad)*win_height);
+    nWritten = write(1, screenBuffer, (3*winWidth+pad)*winHeight);
+    assert(nWritten == (3*winWidth+pad)*winHeight);
     stats.nFrames++;
-    stats.nBytes += (3*win_width+pad)*win_height;
+    stats.nBytes += (3*winWidth+pad)*winHeight;
 }
 
 /*
- * ppm_write --
+ * ppmWrite --
  *
  *  Writes the screen image as PPM binary data to the nanovisviewer
@@ -1074 +1087 @@
  */
 void
-NanoVis::ppm_write(const char *prefix)
+NanoVis::ppmWrite(const char *prefix)
 {
 #define PPM_MAXVAL 255
     char header[200];
 
-    TRACE("Enter ppm_write (%dx%d)\n", win_width, win_height);
+    TRACE("Enter ppmWrite (%dx%d)\n", winWidth, winHeight);
     // Generate the PPM binary file header
-    sprintf(header, "P6 %d %d %d\n", win_width, win_height, PPM_MAXVAL);
+    sprintf(header, "P6 %d %d %d\n", winWidth, winHeight, PPM_MAXVAL);
 
     size_t header_length = strlen(header);
-    size_t data_length = win_width * win_height * 3;
+    size_t data_length = winWidth * winHeight * 3;
 
     char command[200];
@@ -1090 +1103 @@
             (unsigned long)header_length + data_length);
 
-    size_t wordsPerRow = (win_width * 24 + 31) / 32;
+    size_t wordsPerRow = (winWidth * 24 + 31) / 32;
     size_t bytesPerRow = wordsPerRow * 4;
-    size_t rowLength = win_width * 3;
-    size_t nRecs = win_height + 2;
+    size_t rowLength = winWidth * 3;
+    size_t nRecs = winHeight + 2;
 
     struct iovec *iov;
@@ -1107 +1120 @@
     // Image data.
     int y;
-    unsigned char *srcRowPtr = screen_buffer;
-    for (y = win_height + 1; y >= 2; y--) {
+    unsigned char *srcRowPtr = screenBuffer;
+    for (y = winHeight + 1; y >= 2; y--) {
         iov[y].iov_base = srcRowPtr;
         iov[y].iov_len = rowLength;
@@ -1118 +1131 @@
     free(iov);
     stats.nFrames++;
-    stats.nBytes += (bytesPerRow * win_height);
-    TRACE("Leaving ppm_write (%dx%d)\n", win_width, win_height);
+    stats.nBytes += (bytesPerRow * winHeight);
+    TRACE("Leaving ppmWrite (%dx%d)\n", winWidth, winHeight);
 }
 
@@ -1129 +1142 @@
 
       // Generate the PPM binary file header
-      sprintf(header, "P6 %d %d %d\n", win_width, win_height, PPM_MAXVAL);
+      sprintf(header, "P6 %d %d %d\n", winWidth, winHeight, PPM_MAXVAL);
 
       size_t header_length = strlen(header);
-      size_t data_length = win_width * win_height * 3;
+      size_t data_length = winWidth * winHeight * 3;
 
       char command[200];
@@ -1139 +1152 @@
     */
 
-    //    size_t wordsPerRow = (win_width * 24 + 31) / 32;
+    //    size_t wordsPerRow = (winWidth * 24 + 31) / 32;
     //    size_t bytesPerRow = wordsPerRow * 4;
-    //    size_t rowLength = win_width * 3;
+    //    size_t rowLength = winWidth * 3;
     size_t nRecs = 2;
 
@@ -1160 +1173 @@
     delete [] iov;
     // stats.nFrames++;
-    // stats.nBytes += (bytesPerRow * win_height);
+    // stats.nBytes += (bytesPerRow * winHeight);
 }
 
@@ -1169 +1182 @@
 {
     TRACE("in idle()\n");
-    glutSetWindow(render_window);
+    glutSetWindow(renderWindow);
 
 #ifdef XINETD
-    xinetd_listen();
+    xinetdListen();
 #else
     glutPostRedisplay();
@@ -1180 +1193 @@
 
 void 
-NanoVis::display_offscreen_buffer()
+NanoVis::displayOffscreenBuffer()
 {
     TRACE("in display_offscreen_buffer\n");
     glEnable(GL_TEXTURE_2D);
     glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
-    glBindTexture(GL_TEXTURE_2D, _final_color_tex);
-
-    glViewport(0, 0, win_width, win_height);
+    glBindTexture(GL_TEXTURE_2D, _finalColorTex);
+
+    glViewport(0, 0, winWidth, winHeight);
     glMatrixMode(GL_PROJECTION);
     glLoadIdentity();
-    gluOrtho2D(0, win_width, 0, win_height);
+    gluOrtho2D(0, winWidth, 0, winHeight);
     glMatrixMode(GL_MODELVIEW);
     glLoadIdentity();
@@ -1198 +1211 @@
     {
         glTexCoord2f(0, 0); glVertex2f(0, 0);
-        glTexCoord2f(1, 0); glVertex2f(win_width, 0);
-        glTexCoord2f(1, 1); glVertex2f(win_width, win_height);
-        glTexCoord2f(0, 1); glVertex2f(0, win_height);
+        glTexCoord2f(1, 0); glVertex2f(winWidth, 0);
+        glTexCoord2f(1, 1); glVertex2f(winWidth, winHeight);
+        glTexCoord2f(0, 1); glVertex2f(0, winHeight);
     }
     glEnd();
@@ -1208 +1221 @@
 #if 0
 //oddeven sort on GPU
-void
+static void
 sortstep()
 {
@@ -1287 +1300 @@
 #endif
 
-void 
-draw_3d_axis()
+static void 
+draw3dAxis()
 {
     glDisable(GL_TEXTURE_2D);
@@ -1379 +1392 @@
 void NanoVis::update()
 {
-    if (vol_renderer->_volumeInterpolator->is_started()) {
+    if (volRenderer->_volumeInterpolator->isStarted()) {
         struct timeval clock;
         gettimeofday(&clock, NULL);
@@ -1385 +1398 @@
 
         elapsed_time = clock.tv_sec + clock.tv_usec/1000000.0 -
-            vol_renderer->_volumeInterpolator->getStartTime();
+            volRenderer->_volumeInterpolator->getStartTime();
 
         TRACE("%lf %lf\n", elapsed_time, 
-               vol_renderer->_volumeInterpolator->getInterval());
+               volRenderer->_volumeInterpolator->getInterval());
         float fraction;
         float f;
 
-        f = fmod((float) elapsed_time, (float)vol_renderer->_volumeInterpolator->getInterval());
+        f = fmod((float) elapsed_time, (float)volRenderer->_volumeInterpolator->getInterval());
         if (f == 0.0) {
             fraction = 0.0f;
         } else {
-            fraction = f / vol_renderer->_volumeInterpolator->getInterval();
+            fraction = f / volRenderer->_volumeInterpolator->getInterval();
         }
         TRACE("fraction : %f\n", fraction);
-        vol_renderer->_volumeInterpolator->update(fraction);
+        volRenderer->_volumeInterpolator->update(fraction);
     }
 }
 
 void
-NanoVis::SetVolumeRanges()
+NanoVis::setVolumeRanges()
 {
     double xMin, xMax, yMin, yMax, zMin, zMax, wMin, wMax;
@@ -1454 +1467 @@
         Volume::valueMax = wMax;
     }
-    Volume::update_pending = false;
+    Volume::updatePending = false;
     TRACE("leaving SetVolumeRanges\n");
 }
 
 void
-NanoVis::SetHeightmapRanges()
+NanoVis::setHeightmapRanges()
 {
     double xMin, xMax, yMin, yMax, zMin, zMax, wMin, wMax;
 
-    TRACE("in SetHeightmapRanges\n");
+    TRACE("in setHeightmapRanges\n");
     xMin = yMin = zMin = wMin = DBL_MAX;
     xMax = yMax = zMax = wMax = -DBL_MAX;
@@ -1515 +1528 @@
         hmPtr->MapToGrid(grid);
     }
-    HeightMap::update_pending = false;
-    TRACE("leaving SetHeightmapRanges\n");
+    HeightMap::updatePending = false;
+    TRACE("leaving setHeightmapRanges\n");
 }
 
@@ -1537 +1550 @@
     }
     //assert(glGetError()==0);
-    if (HeightMap::update_pending) {
-        SetHeightmapRanges();
-    }
-    if (Volume::update_pending) {
-        SetVolumeRanges();
+    if (HeightMap::updatePending) {
+        setHeightmapRanges();
+    }
+    if (Volume::updatePending) {
+        setVolumeRanges();
     }
     TRACE("in display: glClear\n");
@@ -1547 +1560 @@
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //clear screen
 
-    if (volume_mode) {
-        TRACE("in display: volume_mode\n");
+    if (volumeMode) {
+        TRACE("in display: volumeMode\n");
         //3D rendering mode
         // TBD..
@@ -1588 +1601 @@
 
         //now render things in the scene
-        if (axis_on) {
-            draw_3d_axis();
+        if (axisOn) {
+            draw3dAxis();
         }
         if (grid->isVisible()) {
@@ -1617 +1630 @@
 
         //perf->enable();
-        vol_renderer->render_all();
+        volRenderer->renderAll();
         //perf->disable();
 
@@ -1637 +1650 @@
         //2D rendering mode
         perf->enable();
-        plane_renderer->render();
+        planeRenderer->render();
         perf->disable();
     }
@@ -1678 +1691 @@
 
 void
-NanoVis::update_rot(int delta_x, int delta_y)
+NanoVis::updateRot(int delta_x, int delta_y)
 {
     Vector3 angle;
@@ -1700 +1713 @@
 
 void 
-NanoVis::update_trans(int delta_x, int delta_y, int delta_z)
+NanoVis::updateTrans(int delta_x, int delta_y, int delta_z)
 {
     cam->x(cam->x() + delta_x * 0.03);
@@ -1707 +1720 @@
 }
 
+#ifdef notdef
+static
 void addVectorField(const char* filename, const char* vf_name, 
                     const char* plane_name1, const char* plane_name2, 
@@ -1719 +1734 @@
         Volume *volPtr = NanoVis::volume[n];
         if (volPtr != NULL) {
-            volPtr->set_n_slice(256-n);
-            // volPtr->set_n_slice(512-n);
-            volPtr->disable_cutplane(0);
-            volPtr->disable_cutplane(1);
-            volPtr->disable_cutplane(2);
-            volPtr->transferFunction(NanoVis::get_transfunc("default"));
+            volPtr->numSlices(256-n);
+            // volPtr->numSlices(512-n);
+            volPtr->disableCutplane(0);
+            volPtr->disableCutplane(1);
+            volPtr->disableCutplane(2);
+            volPtr->transferFunction(NanoVis::getTransfunc("default"));
 
             float dx0 = -0.5;
@@ -1733 +1748 @@
             volPtr->data(false);
             NanoVis::flowVisRenderer->addVectorField(vf_name, volPtr, 
-                *(volPtr->get_location()),
+                volPtr->location(),
                 1.0f,
                 volPtr->height / (float)volPtr->width,
@@ -1759 +1774 @@
                 setVectorField(volPtr->id,
                                *(volPtr->get_location()),
-                               1.0f / volPtr->aspect_ratio_width,
-                               1.0f / volPtr->aspect_ratio_height,
-                               1.0f / volPtr->aspect_ratio_depth,
+                               1.0f / volPtr->aspectRatioWidth,
+                               1.0f / volPtr->aspectRatioHeight,
+                               1.0f / volPtr->aspectRatioDepth,
                                volPtr->wAxis.max());
         }
@@ -1767 +1782 @@
     //NanoVis::initParticle();
 }
+#endif
 
 void 
@@ -1772 +1788 @@
 {
 #ifdef EVENTLOG
-    if(log){
+    if (log) {
         float param[3];
         param[0] = cam->x();
@@ -1807 +1823 @@
                 "}\n"
             };
+            Tcl_Eval(interp, cmd);
 #ifdef notdef
             NanoVis::flowVisRenderer->active(false);
@@ -1818 +1835 @@
             char cmd[] = {
                 "flow create flow1\n"
-                "flow1 data file /home/iwoo/projects/nanovis/rappture/packages/vizservers/nanovis/data/flowvis_dx_files/jwire/J-wire-vec.dx 3\n"
+                "flow1 data file data/flowvis_dx_files/jwire/J-wire-vec.dx 3\n"
                 "flow1 particles add plane1 -color { 0 0 1 1 }\n"
                 "flow1 particles add plane2 -color { 0 1 1 1 }\n"
@@ -1824 +1841 @@
             Tcl_Eval(interp, cmd);
 #ifdef notdef
-            addVectorField("/home/iwoo/projects/nanovis/rappture/packages/vizservers/nanovis/data/flowvis_dx_files/jwire/J-wire-vec.dx",
+            addVectorField("data/flowvis_dx_files/jwire/J-wire-vec.dx",
                            "vf_name2", "plane_name1", "plane_name2", Vector4(0, 0, 1, 1), Vector4(0, 1, 1, 1));
 #endif
@@ -1833 +1850 @@
             char cmd[] = {
                 "flow create flow2\n"
-                "flow2 data file /home/iwoo/projects/nanovis/rappture/packages/vizservers/nanovis/data/flowvis_dx_files/3DWireLeakage/SiO2/SiO2.dx 3\n"
+                "flow2 data file data/flowvis_dx_files/3DWireLeakage/SiO2/SiO2.dx 3\n"
                 "flow2 particles add plane1 -color { 1 0 0 1 }\n"
                 "flow2 particles add plane2 -color { 1 1 0 1 }\n"
@@ -1839 +1856 @@
             Tcl_Eval(interp, cmd);
             TRACE("add vector field\n");
-            addVectorField("/home/iwoo/projects/nanovis/rappture/packages/vizservers/nanovis/data/flowvis_dx_files/3DWireLeakage/SiO2/SiO2.dx",
+#ifdef notdef
+            addVectorField("data/flowvis_dx_files/3DWireLeakage/SiO2/SiO2.dx",
                            "vf_name1", "plane_name1", "plane_name2", Vector4(1, 0, 0, 1), Vector4(1, 1, 0, 1));
+#endif
         }
         break;
@@ -1994 +2013 @@
         left_last_y = y;
 
-        update_rot(-delta_y, -delta_x);
+        updateRot(-delta_y, -delta_x);
     } else if (right_down) {
         //TRACE("right mouse motion (%d,%d)\n", x, y);
@@ -2001 +2020 @@
         right_last_y = y;
 
-        update_trans(0, 0, delta_x);
+        updateTrans(0, 0, delta_x);
     }
 
@@ -2046 +2065 @@
 
 void 
-NanoVis::xinetd_listen(void)
+NanoVis::xinetdListen(void)
 {
     NanoVis::flags &= ~REDRAW_PENDING;
 
-    TRACE("Enter xinetd_listen\n");
+    TRACE("Enter xinetdListen\n");
 
     int flags = fcntl(0, F_GETFL, 0);
@@ -2071 +2090 @@
         //  here.
         //
-        TRACE("in xinetd_listen: EOF=%d\n", feof(NanoVis::stdin));
+        TRACE("in xinetdListen: EOF=%d\n", feof(NanoVis::stdin));
         while (!feof(NanoVis::stdin)) {
             int c = fgetc(NanoVis::stdin);
@@ -2079 +2098 @@
                     break;
                 }
-                DoExit(100);
+                doExit(100);
             }
             ch = (char)c;
@@ -2097 +2116 @@
             // back to original flags during command evaluation...
             fcntl(0, F_SETFL, flags & ~O_NONBLOCK);
-            status = ExecuteCommand(interp, &cmdbuffer);
+            status = executeCommand(interp, &cmdbuffer);
             // non-blocking for next read -- we might not get anything
             fcntl(0, F_SETFL, flags | O_NONBLOCK);
@@ -2128 +2147 @@
     }
     if (feof(NanoVis::stdin)) {
-        DoExit(90);
+        doExit(90);
     }
 
     NanoVis::update();
 
-    NanoVis::offscreen_buffer_capture();  //enable offscreen render
+    NanoVis::offscreenBufferCapture();  //enable offscreen render
 
     NanoVis::display();
@@ -2139 +2158 @@
     // INSOO
 #ifdef XINETD
-    NanoVis::read_screen();
+    NanoVis::readScreen();
     glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
 #else
-    NanoVis::display_offscreen_buffer(); //display the final rendering on screen
-    NanoVis::read_screen();
+    NanoVis::displayOffscreenBuffer(); //display the final rendering on screen
+    NanoVis::readScreen();
     glutSwapBuffers();
 #endif
 
     if (feof(NanoVis::stdin)) {
-        DoExit(90);
+        doExit(90);
     }
 #if DO_RLE
@@ -2158 +2177 @@
     write(1, rle, rle_size);    //unsigned byte
 #else
-    NanoVis::ppm_write("\nnv>image -type image -bytes");
+    NanoVis::ppmWrite("\nnv>image -type image -bytes");
 #endif
     TRACE("Leaving xinetd_listen OK\n");
@@ -2187 +2206 @@
     glutInit(&argc, argv);
     glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);
-    glutInitWindowSize(NanoVis::win_width, NanoVis::win_height);
+    glutInitWindowSize(NanoVis::winWidth, NanoVis::winHeight);
     glutInitWindowPosition(10, 10);
-    NanoVis::render_window = glutCreateWindow("nanovis");
+    NanoVis::renderWindow = glutCreateWindow("nanovis");
     glutIdleFunc(NanoVis::idle);
 
@@ -2200 +2219 @@
 #else
     glutDisplayFunc(NanoVis::display);
-    glutReshapeFunc(NanoVis::resize_offscreen_buffer);
+    glutReshapeFunc(NanoVis::resizeOffscreenBuffer);
 #endif
 
@@ -2236 +2255 @@
         case 3:
         case 'd':
-            NanoVis::debug_flag = true;
+            NanoVis::debugFlag = true;
             break;
         case 0:
@@ -2320 +2339 @@
     Tcl_DStringInit(&NanoVis::cmdbuffer);
     NanoVis::interp = initTcl();
-    NanoVis::resize_offscreen_buffer(NanoVis::win_width, NanoVis::win_height);
+    NanoVis::resizeOffscreenBuffer(NanoVis::winWidth, NanoVis::winHeight);
 
     glutMainLoop();
-    DoExit(80);
+    doExit(80);
 }
 
 int
-NanoVis::render_2d_contour(HeightMap* heightmap, int width, int height)
-{
-    int old_width = win_width;
-    int old_height = win_height;
-
-    resize_offscreen_buffer(width, height);
+NanoVis::render2dContour(HeightMap* heightmap, int width, int height)
+{
+    int old_width = winWidth;
+    int old_height = winHeight;
+
+    resizeOffscreenBuffer(width, height);
 
     /*
-      plane_renderer->set_screen_size(width, height);
+      planeRenderer->set_screen_size(width, height);
 
       // generate data for the legend
@@ -2343 +2362 @@
       }
       plane[0] = new Texture2D(256, 2, GL_FLOAT, GL_LINEAR, 1, data);
-      int index = plane_renderer->add_plane(plane[0], tf);
-      plane_renderer->set_active_plane(index);
-
-      offscreen_buffer_capture();
+      int index = planeRenderer->add_plane(plane[0], tf);
+      planeRenderer->set_active_plane(index);
+
+      offscreenBufferCapture();
       glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //clear screen
 
-      //plane_renderer->render();
+      //planeRenderer->render();
       // INSOO : is going to implement here for the topview of the heightmap
       heightmap->render(renderContext);
@@ -2364 +2383 @@
     //char prefix[200];
     //sprintf(prefix, "nv>height_top_view %s %g %g", volArg, min, max);
-    //ppm_write(prefix);
+    //ppmWrite(prefix);
     //write(1, "\n", 1);
-    //plane_renderer->remove_plane(index);
+    //planeRenderer->remove_plane(index);
 
     // CURRENT
-    offscreen_buffer_capture();
+    offscreenBufferCapture();
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //clear screen
     //glEnable(GL_TEXTURE_2D);
@@ -2375 +2394 @@
     //heightmap->render_topview(renderContext, width, height);
     //NanoVis::display();
-    if (HeightMap::update_pending) {
-        SetHeightmapRanges();
+    if (HeightMap::updatePending) {
+        setHeightmapRanges();
     }
 
@@ -2383 +2402 @@
     heightmap->render_topview(renderContext, width, height);
 
-    NanoVis::read_screen();
+    NanoVis::readScreen();
     glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
 
     // INSOO TEST CODE
-    bmp_write_to_file(1, "/tmp");
-
-    resize_offscreen_buffer(old_width, old_height);
+    bmpWriteToFile(1, "/tmp");
+
+    resizeOffscreenBuffer(old_width, old_height);
 
     return TCL_OK;
@@ -2395 +2414 @@
 
 void 
-NanoVis::remove_volume(Volume *volPtr)
+NanoVis::removeVolume(Volume *volPtr)
 {
     Tcl_HashEntry *hPtr;

trunk/packages/vizservers/nanovis/nanovis.h

@@ -73 +73 @@
 
     static void init(const char *path);
-    static void xinetd_listen();
+    static void xinetdListen();
     static void initGL();
-    static void init_offscreen_buffer();
-    static void resize_offscreen_buffer(int w, int h);
+    static void initOffscreenBuffer();
+    static void resizeOffscreenBuffer(int w, int h);
     static void resize(int w, int h);
     static void render();
@@ -82 +82 @@
     static void idle();
     static void update();
-    static void display_offscreen_buffer();
+    static void displayOffscreenBuffer();
     static void pan(float dx, float dy);
     static void zoom(float z);
 
-    static void EventuallyRedraw(unsigned int flag = 0);
-
-    static void SetVolumeRanges();
-    static void SetHeightmapRanges();
-
-    static void init_lic();
+    static void eventuallyRedraw(unsigned int flag = 0);
+
+    static void setVolumeRanges();
+    static void setHeightmapRanges();
+
     static void initParticle();
 
-    static void ppm_write(const char *prefix);
+    static void ppmWrite(const char *prefix);
     static void sendDataToClient(const char *command, const char *data,
                                  size_t dlen);
-    static void bmp_write(const char *prefix);
-    static void bmp_write_to_file(int frame_number, const char* directory_name);
+    static void bmpWrite(const char *prefix);
+    static void bmpWriteToFile(int frame_number, const char* directory_name);
  
-    static TransferFunction *get_transfunc(const char *name);
-    static TransferFunction *DefineTransferFunction(const char *name, 
+    static TransferFunction *getTransfunc(const char *name);
+    static TransferFunction *defineTransferFunction(const char *name, 
                                                     size_t n, float *data);
 
-    static int render_2d_contour(HeightMap *heightmap, int width, int height);
-
-    static int render_legend(TransferFunction *tf, double min, double max, 
-                             int width, int height, const char *volArg);
-
-    static Volume *load_volume(const char *tag, int width, int height, 
-                               int depth, int n, float* data, double vmin, double vmax, 
-                               double nzero_min);
-    static void remove_volume(Volume *volPtr);
+    static int render2dContour(HeightMap *heightmap, int width, int height);
+
+    static int renderLegend(TransferFunction *tf, double min, double max, 
+                            int width, int height, const char *volArg);
+
+    static Volume *loadVolume(const char *tag, int width, int height, int depth,
+                              int n, float* data, double vmin, double vmax, 
+                              double nonZeroMin);
+
+    static void removeVolume(Volume *volPtr);
 
 #ifndef XINETD
@@ -118 +118 @@
     static void mouse(int button, int state, int x, int y);
     static void motion(int x, int y);
-    static void update_rot(int delta_x, int delta_y);
-    static void update_trans(int delta_x, int delta_y, int delta_z);
-#endif
-
-    static void read_screen()
+    static void updateRot(int delta_x, int delta_y);
+    static void updateTrans(int delta_x, int delta_y, int delta_z);
+#endif
+
+    static void readScreen()
     {
-        glReadPixels(0, 0, win_width, win_height, GL_RGB, GL_UNSIGNED_BYTE, 
-                     screen_buffer);
+        glReadPixels(0, 0, winWidth, winHeight, GL_RGB, GL_UNSIGNED_BYTE, 
+                     screenBuffer);
     }
-    static void offscreen_buffer_capture()
+    static void offscreenBufferCapture()
     {
-        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _final_fbo);
+        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _finalFbo);
     }
 
@@ -148 +148 @@
 
     static unsigned int flags;
-    static bool debug_flag;
-    static bool axis_on;
-    static bool config_pending; // Indicates if the limits need to be recomputed.
-    static int win_width;       //size of the render window
-    static int win_height;      //size of the render window
-    static int render_window;
-    static unsigned char *screen_buffer;
+    static bool debugFlag;
+    static bool axisOn;
+    static int winWidth;        //size of the render window
+    static int winHeight;       //size of the render window
+    static int renderWindow;
+    static unsigned char *screenBuffer;
     static Grid *grid;
     static R2Fonts *fonts;
@@ -169 +168 @@
     static float xOrigin, yOrigin, zOrigin;
 
-    static VolumeRenderer *vol_renderer;
+    static VolumeRenderer *volRenderer;
     static NvFlowVisRenderer *flowVisRenderer;
     static VelocityArrowsSlice *velocityArrowsSlice;
     static NvLIC *licRenderer;
-    static PlaneRenderer *plane_renderer;
+    static PlaneRenderer *planeRenderer;
 #if PLANE_CMD
     static Texture2D *plane[]; ///< Pointers to 2D planes
 #endif
 #ifdef USE_POINTSET_RENDERER
-    static PointSetRenderer *pointset_renderer;
+    static PointSetRenderer *pointSetRenderer;
     static std::vector<PointSet *> pointSet;
 #endif
@@ -184 +183 @@
     static Tcl_HashTable tfTable;
     static Texture2D *legendTexture;
-    static NvColorTableRenderer *color_table_renderer;
+    static NvColorTableRenderer *colorTableRenderer;
 
     static std::vector<HeightMap *> heightMap;
     static Tcl_HashTable heightmapTable;
 
-    static float lic_slice_x;
-    static float lic_slice_y;
-    static float lic_slice_z;
-    static int lic_axis;        /* 0:x, 1:y, 2:z */
-
     static Tcl_Interp *interp;
     static Tcl_DString cmdbuffer;
 
 private:
+    static float _licSliceX;
+    static float _licSliceY;
+    static float _licSliceZ;
+    static int _licAxis;     /* 0:x, 1:y, 2:z */
+
     //frame buffer for final rendering
-    static GLuint _final_fbo, _final_color_tex, _final_depth_rb;
+    static GLuint _finalFbo, _finalColorTex, _finalDepthRb;
 };
 

trunk/packages/vizservers/nanovis/shaders/one_volume.cg

@@ -16 +16 @@
 /*
  * render one volume 
+ *
+ * renderParameters:
+ *   x: number of slices
+ *   y: opacity scale (1-21)
+ *   z: diffuse coefficient
+ *   w: specular exponent
+ * options:
+ *   y = isosurface flag (opacity scaling on/off)
  */
 PixelOut main(v2f IN,
               uniform sampler3D volume,
               uniform sampler1D tf,
-              //uniform sampler1D tf_cutplane,
               uniform float4x4 modelViewInv,
               uniform float4x4 modelView,
@@ -35 +42 @@
     if (renderParameters.x < 0.5) {
         //If single slice render, only flat shading, completely opaque.
-        //color = tex1D(tf_cutplane, sample.x);
         color.w = 1;
-        //color.w = renderParameters.y*color.w/renderParameters.x;
     } else {
         //regular volume rendering, we do PHONG SHADING 
-        //lighting parameters 
+        //lighting parameters
+#if 1
         float3 normal;
-        if (length(sample.yzw) > 0.0) {
-            // INSOO (iso)
-            //normal = sample.yzw * 2.0 - 1.0; //(iso)
-            //normal = normalize(normal);
-            normal = normalize(sample.yzw);
+        float diffuse, specular;
+        if (dot(sample.yzw, sample.yzw) < 5.0e-5) {
+            diffuse = 0;
+            specular = 0;
+        } else {
+            normal = normalize(sample.yzw * 2.0 - 1.0);
+            float3 light_vector = normalize(IN.Light);
+            float3 eye_vector = normalize(IN.EyeVector);
+            float3 half_vector = normalize(eye_vector+light_vector);
+
+            //lighting computation
+#ifndef LIGHT_TWO_SIDE
+            float normal_dot_light = max(dot(normal, light_vector), 0);
+            float normal_dot_half = max(dot(normal, half_vector), 0);
+#else
+            float normal_dot_light = dot(normal, light_vector);
+            if (normal_dot_light < 0.0) {
+                normal_dot_light = dot(-normal, light_vector);
+            }
+            float normal_dot_half = dot(normal, half_vector);
+            if (normal_dot_half < 0.0) {
+                normal_dot_half = dot(-normal, half_vector);
+            }
+#endif
+            diffuse = normal_dot_light * renderParameters.z;
+            //specular = pow(normal_dot_half, renderParameters.w)*(1-ambient-diffuse);
+            if (diffuse > 1.0e-6) 
+                specular = pow(normal_dot_half, 90.)*0.3;
+            else
+                specular = 0.0;
         }
-
-        float3 light_vector = normalize(IN.Light);
-        float3 eye_vector = normalize(IN.EyeVector);
-        float3 half_vector = normalize(eye_vector+light_vector);
-
-        //lighting computation
-        float normal_dot_light = max(dot(normal, light_vector), 0);
-        float normal_dot_half = max(dot(normal, half_vector), 0);
-
-        // INSOO (iso)
-        //float normal_dot_light = abs(dot(normal, light_vector));
-        //float normal_dot_half = abs(dot(normal, half_vector));
-
-        float ambient = 0.8;
-
-        float diffuse = normal_dot_light * renderParameters.z;
-
-        float specular = pow(normal_dot_half, renderParameters.w)*(1-ambient-diffuse);
+        float ambient = max(.2, 1.0 - renderParameters.z);
 
         float lighting = ambient + diffuse + specular;
-        color.xyz = color.xyz * lighting;
+        color.xyz = color.xyz * ambient + color.xyz * diffuse + float3(specular);
+#else
+        if (dot(sample.yzw, sample.yzw) < 5.0e-5) {
+            color.xyz = float3(0);
+        } else {
+            color.xyz = normalize(sample.yzw);
+        }
+#endif
 
         if (options.y < 0.5) {
             //opacity is modulated by the number of total slices
             //to avoid very opaque volume when number of slices is high
-            color.w = renderParameters.y*color.w/renderParameters.x;
+            // renderParameters.x = number of slices
+            // renderParameters.y = opacity scale (1-21)
+            color.w = color.w * 0.2 * renderParameters.y/renderParameters.x;
 
             // INSOO (iso)
             //opacity is modulated by the number of total slices
-            //color.w = renderParameters.y*color.w/renderParameters.x * 0.2;
+            //color.w = color.w * renderParameters.y/renderParameters.x * 0.2;
         }
     }
 
-  OUT.Color = color;
+  OUT.Color = min(max(color, 0.0), 1.0);
 
   return OUT;

trunk/packages/vizservers/nanovis/shaders/particlefp.cg

@@ -1 +1 @@
 /* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-#include "particlemacro.h"
 #include "particle_common.cg"
 

trunk/packages/vizservers/nanovis/shaders/velocity.cg

@@ -21 +21 @@
 
 // Velocity change operations.
-#include "velocityOps.cg"
+//#include "velocityOps.cg"
 
 // Uniform parameters influencing velocity.
@@ -32 +32 @@
 {
     float3 gravity = float3(0, -.01, 0);
-        
+
     float3 acceleration = gravity;
 
@@ -73 +73 @@
     float3 velocity = (float3)texRECT(_VelocityTexture, _TexCoord);
     float3 position = (float3)texRECT(_PositionTexture, _TexCoord);
-        
+
     return float4(advanceVelocity(velocity, position, _TimeStep), 0);
 }

trunk/packages/vizservers/nanovis/shaders/velocityslicevp.cg

@@ -50 +50 @@
     float4 posEye =  mul(modelview, posin);
     //pointSize = tanHalfFOV / -posEye.z / 5;
-    pointSize = tanHalfFOV / -posEye.z / 10; //j-wire
-    //pointSize = 10 / -posEye.z;
+    //pointSize = tanHalfFOV / -posEye.z / 10; //j-wire
+    pointSize = 20; //0 / -posEye.z;
 
     posout = mul(mvp, vec);

trunk/packages/vizservers/nanovis/shaders/vertex_std.cg

@@ -20 +20 @@
     v2f OUT;
 
+    // IN.Position is in eye coords
+    float4 objPos = mul(modelViewInv, IN.Position);
+    float4 eyePosObjSpace = mul(modelViewInv, float4(0,0,0,1));
+
     //clip space vertex position
-    OUT.HPosition = mul(modelViewProjMatrix, mul(modelViewInv, IN.Position));
+    //OUT.HPosition = mul(modelViewProjMatrix, mul(modelViewInv, IN.Position));
+    OUT.HPosition = mul(modelViewProjMatrix, objPos);
 
     //eye space texture coordinates
@@ -27 +32 @@
 
     //world space eye position
-    OUT.EyeVector = normalize(-IN.Position.xyz);
+    //OUT.EyeVector = normalize(-IN.Position.xyz);
+    OUT.EyeVector = normalize(eyePosObjSpace - objPos);
 
     //world space light postion
-    OUT.Light = normalize(float3(1,1,1)-IN.Position.xyz);
+    //OUT.Light = normalize(float3(1,1,1)-IN.Position.xyz);
+    OUT.Light = normalize(mul(modelViewInv, float4(1,1,1,1))-objPos);
 
     return OUT;

trunk/packages/vizservers/nanovis/vrmath/include/vrmath/vrBPlane.h

@@ -1 +1 @@
 /* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/** \class vrPlane vrPlane <R2/math/vrPlane.h>
- *  \brief plane
+/** \class vrBPlane vrBPlane.h <vrmath/vrBPlane.h>
  *  \author Insoo Woo(iwoo@purdue.edu), Sung-Ye Kim (inside@purdue.edu)
  *  \author PhD research assistants in PURPL at Purdue University  

trunk/packages/vizservers/nanovis/vrmath/include/vrmath/vrLineSegment.h

@@ -1 +1 @@
 /* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/** \class vrPlane vrPlane <R2/math/vrPlane.h>
- *  \brief plane
+/** \class vrLineSegment vrLineSegment.h <vrmath/vrLineSegment.h>
  *  \author Insoo Woo(iwoo@purdue.edu), Sung-Ye Kim (inside@purdue.edu)
  *  \author PhD research assistants in PURPL at Purdue University  

trunk/packages/vizservers/nanovis/vrmath/include/vrmath/vrMatrix4x4f.h

@@ -24 +24 @@
     /**
      * @brief make a translation matrix
-     * @param translation translation
      */
     void makeTranslation(const vrVector3f& translation);
@@ -30 +29 @@
     /**
      * @brief make a translation matrix
-     * @param x x position
      */
     void makeTranslation(float x, float y, float z);
@@ -36 +34 @@
     /**
      * @brief make a rotation matrix
-     * @param rotation rotation
      */
     void makeRotation(const vrRotation& rotation);
@@ -42 +39 @@
     /**
      * @brief Make a rotation matrix
-     * @param rotation rotation
      */
     void makeRotation(float x, float y, float z, float angle);
@@ -50 +46 @@
     /**
      * @brief make a scale matrix
-     * @param scale scale
      */
     void makeScale(const vrVector3f& scale);

trunk/packages/vizservers/nanovis/vrmath/include/vrmath/vrPlane.h

@@ -1 +1 @@
 /* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/** \class vrPlane vrPlane <R2/math/vrPlane.h>
- *  \brief plane
+/** \class vrPlane vrPlane.h <vrmath/vrPlane.h>
  *  \author Insoo Woo(iwoo@purdue.edu), Sung-Ye Kim (inside@purdue.edu)
  *  \author PhD research assistants in PURPL at Purdue University  

trunk/packages/vizservers/nanovis/vrmath/include/vrmath/vrPlane2.h

@@ -1 +1 @@
 /* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/** \class vrPlane vrPlane <vrmath/vrPlane.h>
- *  \brief plane
+/** \class vrPlane2 vrPlane2.h <vrmath/vrPlane2.h>
  *  \author Insoo Woo(iwoo@purdue.edu), Sung-Ye Kim (inside@purdue.edu)
  *  \author PhD research assistants in PURPL at Purdue University  
@@ -17 +16 @@
 public:
     void makePts(const vrVector3f& pt1, const vrVector3f& pt2, const vrVector3f& pt3);
+
     void makeNormalPt(const vrVector3f& norm, const vrVector3f& pos);
+
     bool intersect(const vrLineSegment &seg, float &d) const;
+
     float distance(const vrVector3f& point) const;
+
     vrVector3f crossPoint(const vrVector3f& point) const;