Changeset 3630

Timestamp:

Apr 16, 2013 12:52:20 AM (11 years ago)

Author:

ldelgass

Message:

Nanovis refactoring to fix problems with scaling and multiple results.
Do rendering in world space to properly place and scale multiple data sets.
Also fix flows to reduce resets of animations. More work toward removing
Cg dependency. Fix panning to convert viewport coords to world coords.

Location:

trunk/packages/vizservers/nanovis

Files:

• Axis.h (modified) (1 diff)
• Camera.cpp (modified) (9 diffs)
• Camera.h (modified) (4 diffs)
• ColorTableShader.cpp (modified) (1 diff)
• Command.cpp (modified) (8 diffs)
• Flow.cpp (modified) (9 diffs)
• Flow.h (modified) (7 diffs)
• FlowBox.cpp (modified) (2 diffs)
• FlowBox.h (modified) (1 diff)
• FlowCmd.cpp (modified) (13 diffs)
• FlowParticles.cpp (modified) (5 diffs)
• FlowParticles.h (modified) (2 diffs)
• FlowTypes.h (modified) (2 diffs)
• Grid.cpp (modified) (2 diffs)
• Grid.h (modified) (2 diffs)
• HeightMap.cpp (modified) (2 diffs)
• HeightMap.h (modified) (1 diff)
• LIC.cpp (modified) (16 diffs)
• LIC.h (modified) (6 diffs)
• Makefile.in (modified) (3 diffs)
• OrientationIndicator.cpp (modified) (6 diffs)
• OrientationIndicator.h (modified) (3 diffs)
• ParticleAdvectionShader.cpp (modified) (3 diffs)
• ParticleAdvectionShader.h (modified) (1 diff)
• ParticleRenderer.cpp (modified) (16 diffs)
• ParticleRenderer.h (modified) (9 diffs)
• PointShader.cpp (modified) (2 diffs)
• RegularVolumeShader.cpp (modified) (1 diff)
• RenderVertexArray.h (modified) (1 diff)
• Shader.cpp (modified) (5 diffs)
• Shader.h (modified) (23 diffs)
• StdVertexShader.cpp (modified) (2 diffs)
• StdVertexShader.h (modified) (2 diffs)
• Unirect.h (modified) (3 diffs)
• VelocityArrowsSlice.cpp (modified) (12 diffs)
• VelocityArrowsSlice.h (modified) (6 diffs)
• Volume.cpp (modified) (5 diffs)
• Volume.h (modified) (13 diffs)
• VolumeInterpolator.cpp (modified) (6 diffs)
• VolumeInterpolator.h (modified) (1 diff)
• VolumeRenderer.cpp (modified) (19 diffs)
• VolumeRenderer.h (modified) (2 diffs)
• VtkReader.cpp (modified) (1 diff)
• ZincBlendeReconstructor.cpp (modified) (2 diffs)
• ZincBlendeVolume.cpp (modified) (2 diffs)
• ZincBlendeVolume.h (modified) (1 diff)
• ZincBlendeVolumeShader.cpp (modified) (1 diff)
• dxReader.cpp (modified) (1 diff)
• graphics/Makefile.in (modified) (1 diff)
• imgLoaders/Makefile.in (modified) (1 diff)
• nanovis.cpp (modified) (30 diffs)
• nanovis.h (modified) (8 diffs)
• nanovisServer.cpp (modified) (3 diffs)
• newmat11/Makefile.in (modified) (1 diff)
• protocol-nanovis.txt (modified) (1 diff)
• shaders/common.cg (modified) (1 diff)
• shaders/copy_texcoord.cg (modified) (1 diff)
• shaders/cutplane_fp.cg (modified) (1 diff)
• shaders/cutplane_vp.cg (modified) (1 diff)
• shaders/heightcolor.cg (modified) (1 diff)
• shaders/moveparticles.cg (modified) (1 diff)
• shaders/one_plane.cg (modified) (1 diff)
• shaders/one_volume.cg (modified) (2 diffs)
• shaders/particle_common.cg (modified) (1 diff)
• shaders/particlefp.cg (modified) (1 diff)
• shaders/particlevp.cg (modified) (1 diff)
• shaders/passthrough.cg (modified) (1 diff)
• shaders/passthru.cg (modified) (1 diff)
• shaders/pointsvp.cg (modified) (3 diffs)
• shaders/queryvelocity.cg (modified) (1 diff)
• shaders/render_vel.cg (modified) (1 diff)
• shaders/renderparticle.cg (modified) (2 diffs)
• shaders/update_pos.cg (modified) (3 diffs)
• shaders/update_pos_vel.cg (modified) (1 diff)
• shaders/update_vel.cg (modified) (1 diff)
• shaders/velocityslicefp.cg (modified) (1 diff)
• shaders/velocityslicevp.cg (modified) (1 diff)
• shaders/vertex_std.cg (modified) (3 diffs)
• shaders/volqd_volume.cg (modified) (3 diffs)
• shaders/zincblende_volume.cg (modified) (4 diffs)
• util/Fonts.h (modified) (1 diff)
• util/Makefile.in (modified) (1 diff)
• vrmath/Makefile.in (modified) (1 diff)
• vrmath/Matrix4x4d.cpp (modified) (3 diffs)
• vrmath/include/vrmath/BBox.h (modified) (1 diff)

trunk/packages/vizservers/nanovis/Axis.h

@@ -399 +399 @@
                                  * the data. */
 
-    double _range;              /**< Range of values on axis (max_ - min_) */
+    double _range;              /**< Range of values on axis (_max - _min) */
     double _scale;              /**< Scale factor for axis (1.0/_range) */
 

trunk/packages/vizservers/nanovis/Camera.cpp

@@ -18 +18 @@
 #include <vrmath/Vector3f.h>
 #include <vrmath/Vector4f.h>
+#include <vrmath/BBox.h>
 
 #include "nanovis.h"
@@ -36 +37 @@
 }
 
-Camera::Camera(int startx, int starty, int w, int h,
-               float loc_x, float loc_y, float loc_z) :
-    _location(loc_x, loc_y, loc_z),
+Camera::Camera(int x, int y, int width, int height) :
+    _updir(Y_POS),
+    _zoomRatio(1),
+    _position(0, 0, 2.5),
+    _focalPoint(0, 0, 0),
+    _mvDirty(true),
     _fov(30.0),
     _near(0.1),
-    _far(50.0),
-    _width(w),
-    _height(h),
-    _startX(startx),
-    _startY(starty)
-{
+    _far(50.0)
+{
+    _viewport[0] = x;
+    _viewport[1] = y;
+    _viewport[2] = width;
+    _viewport[3] = height;
+    _pan[0] = 0;
+    _pan[1] = 0;
 }
 
 void
-Camera::getUpDirMatrix(Matrix4x4d& upMat)
-{
-    switch (NanoVis::updir) {
-    case NanoVis::X_POS: {
-        upMat.makeRotation(0, 0, 1, deg2rad(90));
+Camera::pan(float x, float y, bool absolute)
+{
+    y = -y;
+    if (absolute) {
+        double panAbs[2];
+        panAbs[0] = x;
+        panAbs[1] = y;
+        x -= _pan[0];
+        y -= _pan[1];
+        _pan[0] = panAbs[0];
+        _pan[1] = panAbs[1];
+    } else {
+        _pan[0] += x;
+        _pan[1] += y;
+    }
+
+    if (x != 0.0 || y != 0.0) {
+        Vector3f worldFocalPoint;
+        worldToWindowCoords(_focalPoint.x, _focalPoint.y, _focalPoint.z, 
+                            worldFocalPoint);
+        float focalDepth = worldFocalPoint.z;
+
+        Vector3f newPickPoint, oldPickPoint, motionVector;
+        windowToWorldCoords((x * 2. + 1.) * (float)_viewport[2] / 2.0,
+                            (y * 2. + 1.) * (float)_viewport[3] / 2.0,
+                            focalDepth, 
+                            newPickPoint);
+
+        windowToWorldCoords((float)_viewport[2] / 2.0,
+                            (float)_viewport[3] / 2.0,
+                            focalDepth, 
+                            oldPickPoint);
+
+        // Camera motion is reversed
+        motionVector = oldPickPoint - newPickPoint;
+
+        _focalPoint += motionVector;
+        _position += motionVector;
+
+        _mvDirty = true;
+    }
+}
+
+void
+Camera::zoom(float z, bool absolute)
+{
+    if (absolute) {
+        // Compute relative zoom
+        float zAbs = z;
+        z *= 1.0/_zoomRatio;
+        _zoomRatio = zAbs;
+    } else {
+        _zoomRatio *= z;
+    }
+    float distance = getDistance() / z;
+    Vector3f dir = getViewPlaneNormal();
+    dir = dir.scale(distance);
+    _position = _focalPoint + dir;
+    _mvDirty = true;
+}
+
+const Matrix4x4d&
+Camera::getUpDirMatrix() const
+{
+    return _updirMatrix;
+}
+
+void
+Camera::setUpDirMatrix(AxisDirection dir)
+{
+    _updir = dir;
+
+    switch (_updir) {
+    case X_POS: {
+        _updirMatrix.makeRotation(0, 0, 1, deg2rad(90));
         Matrix4x4d tmp;
         tmp.makeRotation(1, 0, 0, deg2rad(90));
-        upMat.multiply(tmp);
-    }
-        break;
-    case NanoVis::Y_POS:
-        upMat.makeIdentity();
-        break;
-    case NanoVis::Z_POS: {
-        upMat.makeRotation(1, 0, 0, deg2rad(-90));
+        _updirMatrix.multiply(tmp);
+    }
+        break;
+    case Y_POS:
+        _updirMatrix.makeIdentity();
+        break;
+    case Z_POS: {
+        _updirMatrix.makeRotation(1, 0, 0, deg2rad(-90));
         Matrix4x4d tmp;
         tmp.makeRotation(0, 0, 1, deg2rad(-90));
-        upMat.multiply(tmp);
-    }
-        break;
-    case NanoVis::X_NEG:
-        upMat.makeRotation(0, 0, 1, deg2rad(-90));
-        break;
-    case NanoVis::Y_NEG: {
-        upMat.makeRotation(0, 0, 1, deg2rad(180));
+        _updirMatrix.multiply(tmp);
+    }
+        break;
+    case X_NEG:
+        _updirMatrix.makeRotation(0, 0, 1, deg2rad(-90));
+        break;
+    case Y_NEG: {
+        _updirMatrix.makeRotation(0, 0, 1, deg2rad(180));
         Matrix4x4d tmp;
         tmp.makeRotation(0, 1, 0, deg2rad(-90));
-        upMat.multiply(tmp);
-    }
-        break;
-    case NanoVis::Z_NEG:
-        upMat.makeRotation(1, 0, 0, deg2rad(90));
+        _updirMatrix.multiply(tmp);
+    }
+        break;
+    case Z_NEG:
+        _updirMatrix.makeRotation(1, 0, 0, deg2rad(90));
         break;
     }
@@ -97 +173 @@
 
     if (resetOrientation) {
-        _cameraMatrix.makeIdentity();
-    }
-
-    Vector3f center(bboxMin + bboxMax);
-    center.scale(0.5);
-
-    Matrix4x4d mat, upMat;
-    getUpDirMatrix(upMat);
-    mat.makeTranslation(-center);
-    mat.multiply(_cameraMatrix, mat);
-    mat.multiply(upMat);
-
-    Vector3f emin(FLT_MAX, FLT_MAX, FLT_MAX), emax(-FLT_MAX, -FLT_MAX, -FLT_MAX);
-
-    // Transform bounds by camera matrix
-    Vector4f bboxEye[8];
-    bboxEye[0] = Vector4f(bboxMin.x, bboxMin.y, bboxMin.z, 1);
-    bboxEye[1] = Vector4f(bboxMax.x, bboxMin.y, bboxMin.z, 1);
-    bboxEye[2] = Vector4f(bboxMin.x, bboxMax.y, bboxMin.z, 1);
-    bboxEye[3] = Vector4f(bboxMin.x, bboxMin.y, bboxMax.z, 1);
-    bboxEye[4] = Vector4f(bboxMax.x, bboxMax.y, bboxMin.z, 1);
-    bboxEye[5] = Vector4f(bboxMax.x, bboxMin.y, bboxMax.z, 1);
-    bboxEye[6] = Vector4f(bboxMin.x, bboxMax.y, bboxMax.z, 1);
-    bboxEye[7] = Vector4f(bboxMax.x, bboxMax.y, bboxMax.z, 1);
-
-    for (int i = 0; i < 8; i++) {
-        Vector4f eyeVert = mat.transform(bboxEye[i]);
-        if (eyeVert.x < emin.x) emin.x = eyeVert.x;
-        if (eyeVert.x > emax.x) emax.x = eyeVert.x;
-        if (eyeVert.y < emin.y) emin.y = eyeVert.y;
-        if (eyeVert.y > emax.y) emax.y = eyeVert.y;
-        if (eyeVert.z < emin.z) emin.z = eyeVert.z;
-        if (eyeVert.z > emax.z) emax.z = eyeVert.z;
-    }
+        _rotationMatrix.makeIdentity();
+    }
+
+    BBox bbox(bboxMin, bboxMax);
+    Vector3f center = bbox.getCenter();
+    _focalPoint.set(center.x, center.y, center.z);
+
+    Matrix4x4d mat;
+    mat.makeTranslation(-_focalPoint);
+    mat.multiply(_updirMatrix, mat); // premult
+    mat.multiply(_rotationMatrix, mat); // premult
+
+    bbox.transform(bbox, mat);
+
+    Vector3f emin = bbox.min;
+    Vector3f emax = bbox.max;
 
     TRACE("Eye bounds: (%g,%g,%g) - (%g,%g,%g)",
@@ -146 +204 @@
 
     // Deal with vertical aspect window
-    double winAspect = (double)(_width - _startX)/(double)(_height - _startY);
+    double winAspect = (double)_viewport[2]/(double)_viewport[3];
     double sceneAspect = 1.0;;
     if (bheight > 0.0)
@@ -161 +219 @@
     _far = _near + bdepth;
 
-    _location.set(center.x, center.y, center.z + distance);
+    Vector3f viewPlaneNormal(0, 0, 1);
+    mat.transpose();
+    viewPlaneNormal = mat.transformVec(viewPlaneNormal);
+    _position = _focalPoint + viewPlaneNormal * distance;
 
     TRACE("win aspect: %g scene aspect: %g", winAspect, sceneAspect);
+    TRACE("vpn: %g, %g, %g", viewPlaneNormal.x, viewPlaneNormal.y, viewPlaneNormal.z);
     TRACE("c: %g,%g,%g, d: %g", center.x, center.y, center.z, distance);
+    TRACE("pos: %g, %g, %g", _position.x, _position.y, _position.z);
     TRACE("near: %g, far: %g", _near, _far);
+
+    _zoomRatio = 1.0;
+    _pan[0] = 0;
+    _pan[1] = 0;
+    _mvDirty = true;
 
     initialize();
@@ -171 +239 @@
 }
 
+/**
+ * \brief Reset near and far planes based on given world space
+ * bounding box
+ *
+ * This method is based on VTK's renderer class implementation
+ * The idea is to plug the bounding box corners into the view 
+ * plane equation to find the min and max distance of the scene
+ * to the view plane.
+ */
 void
 Camera::resetClippingRange(const Vector3f& bboxMin, const Vector3f& bboxMax)
 {
-    Vector3f emin(bboxMin.x, bboxMin.y, bboxMin.z), emax(bboxMax.x, bboxMax.y, bboxMax.z);
-
-    Vector3f center(emin + emax);
-    center.scale(0.5);
-
-    // Compute the radius of the enclosing sphere,
-    // which is half the bounding box diagonal
-    Vector3f diagonal(emax - emin);
-    double radius = diagonal.length() * 0.5;
-
-    // If we have just a single point, pick a radius of 1.0
-    radius = (radius == 0) ? 1.0 : radius;
-
-    TRACE("c: %g,%g,%g, r: %g cam z: %g", center.x, center.y, center.z, radius, _location.z);
-
-    _near = _location.z - radius;
-    _far = _location.z + radius;
-
-    if (_near < 0.0) {
-        _near = 0.001;
-    }
-    if (_far < 0.0) {
-        _far = 1.0;
-    }
+    BBox bbox(bboxMin, bboxMax);
+
+    // Set up view plane equation at camera position
+    Vector3f vpn = getViewPlaneNormal();
+    double a, b, c, d, dist;
+    a = -vpn.x;
+    b = -vpn.y;
+    c = -vpn.z;
+    d = -(a*_position.x + b*_position.y + c*_position.z);
+
+    // Now compute distance of bounding box corners to view plane
+
+    // Set starting limits
+    _near = a * bbox.min.x + b * bbox.min.y + c * bbox.min.z + d;
+    _far = 1e-18;
+
+    // Iterate over the 8 bbox corners
+    for (int k = 0; k < 2; k++) {
+        for (int j = 0; j < 2; j++) {
+            for (int i = 0; i < 2; i++) {
+                dist =
+                    (a * ((i == 0) ? bbox.min.x : bbox.max.x)) +
+                    (b * ((j == 0) ? bbox.min.y : bbox.max.y)) +
+                    (c * ((k == 0) ? bbox.min.z : bbox.max.z)) + d;
+                _near = (dist < _near) ? dist : _near;
+                _far =  (dist > _far)  ? dist : _far;
+            }
+        }
+    }
+
+    // Check for near plane behind the camera
+    if (_near < 0) {
+        _near = 0;
+    }
+
+    // Extend the bounds a bit 
+    _near = 0.99 * _near - (_far - _near) * 0.5;
+    _far  = 1.01 * _far  + (_far - _near) * 0.5;
+
+    // Ensure near is closer than far
+    _near = (_near >= _far) ? (0.01 * _far) : _near;
+
+    // Limit clip range to make best use of z buffer precision
+    if (_near < .001 * _far)
+        _near = .001 * _far;
 
     TRACE("Resetting camera clipping range to: near: %g, far: %g", _near, _far);
@@ -204 +302 @@
     glLoadIdentity();
     gluPerspective(_fov, 
-                   (GLdouble)(_width - _startX)/(GLdouble)(_height - _startY), 
+                   (GLdouble)_viewport[2]/(GLdouble)_viewport[3], 
                    _near, _far);
     glMatrixMode(GL_MODELVIEW);
@@ -217 +315 @@
     print();
 
-    glViewport(_startX, _startY, _width, _height);
+    glViewport(_viewport[0], _viewport[1], _viewport[2], _viewport[3]);
     glMatrixMode(GL_PROJECTION);
     glLoadIdentity();
     gluPerspective(_fov, 
-                   (GLdouble)(_width - _startX)/(GLdouble)(_height - _startY), 
+                   (GLdouble)_viewport[2]/(GLdouble)_viewport[3], 
                    _near, _far);
 
     glMatrixMode(GL_MODELVIEW);
+
+    computeModelViewMatrix();
+    glLoadMatrixd((const GLdouble *)_modelViewMatrix.get());
+}
+
+void Camera::windowToWorldCoords(double x, double y, double z, Vector3f& objPos)
+{
+    Matrix4x4d proj;
+    getProjectionMatrix(proj);
+    GLdouble outX, outY, outZ;
+    gluUnProject(x, y, z,
+                 (GLdouble *)getModelViewMatrix().get(),
+                 (GLdouble *)proj.get(),
+                 (GLint *)_viewport,
+                 &outX, &outY, &outZ);
+    objPos.set(outX, outY, outZ);
+}
+
+void Camera::worldToWindowCoords(double x, double y, double z, Vector3f& winPos)
+{
+    Matrix4x4d proj;
+    getProjectionMatrix(proj);
+    GLdouble outX, outY, outZ;
+    gluProject(x, y, z,
+               (GLdouble *)getModelViewMatrix().get(),
+               (GLdouble *)proj.get(),
+               (GLint *)_viewport,
+               &outX, &outY, &outZ);
+    winPos.set(outX, outY, outZ);
+}
+
+void Camera::computeModelViewMatrix()
+{
+    if (_mvDirty) {
+        _modelViewMatrix.makeTranslation(0, 0, -getDistance());
+        _modelViewMatrix.multiply(_rotationMatrix);
+        _modelViewMatrix.multiply(_updirMatrix);
+        Matrix4x4d mat;
+        mat.makeTranslation(-_focalPoint);
+        _modelViewMatrix.multiply(mat);
+        _mvDirty = false;
+    }
+}
+
+void Camera::getProjectionMatrix(Matrix4x4d& mat)
+{
+    glMatrixMode(GL_PROJECTION);
+    glPushMatrix();
     glLoadIdentity();
-
-    glTranslatef(-_location.x, -_location.y, -_location.z);
-    glMultMatrixd((const GLdouble *)_cameraMatrix.get());
-}
-
-void Camera::rotate(double *quat)
+    gluPerspective(_fov, 
+                   (GLdouble)_viewport[2]/(GLdouble)_viewport[3], 
+                   _near, _far);
+    glGetDoublev(GL_PROJECTION_MATRIX, (GLdouble *)mat.get());
+    glPopMatrix();
+    glMatrixMode(GL_MODELVIEW);
+}
+
+void Camera::orient(double *quat)
 {
     Quaternion q(quat[0], quat[1], quat[2], quat[3]);
     Rotation rot;
     rot.set(q);
-    _cameraMatrix.makeRotation(rot);
-    _cameraMatrix.transpose();
+    _rotationMatrix.makeRotation(rot);
+    _rotationMatrix.transpose();
+    _mvDirty = true;
+    computeModelViewMatrix();
+
+    Vector3f viewPlaneNormal(0, 0, 1);
+    Matrix4x4d mat = getModelViewMatrix();
+    mat.transpose();
+    viewPlaneNormal = mat.transformVec(viewPlaneNormal);
+    TRACE("vpn: %g %g %g", viewPlaneNormal.x, viewPlaneNormal.y, viewPlaneNormal.z);
+    _position = _focalPoint + viewPlaneNormal * getDistance();
+
     TRACE("Set rotation to quat: %g %g %g %g",
           quat[0], quat[1], quat[2], quat[3]);
 }
 
-void Camera::rotate(float angleX, float angleY, float angleZ)
+void Camera::orient(float angleX, float angleY, float angleZ)
 {
     angleX = -angleX;
     angleY = angleY - 180.;
 
-    _cameraMatrix.makeRotation(1, 0, 0, deg2rad(angleX));
+    _rotationMatrix.makeRotation(1, 0, 0, deg2rad(angleX));
     Matrix4x4d mat;
     mat.makeRotation(0, 1, 0, deg2rad(angleY));
-    _cameraMatrix.multiply(mat);
+    _rotationMatrix.multiply(mat);
     mat.makeRotation(0, 0, 1, deg2rad(angleZ));
-    _cameraMatrix.multiply(mat);
-    //_cameraMatrix.transpose();
+    _rotationMatrix.multiply(mat);
+    _mvDirty = true;
+    computeModelViewMatrix();
+
+    Vector3f viewPlaneNormal(0, 0, 1);
+    mat = getModelViewMatrix();
+    mat.transpose();
+    viewPlaneNormal = mat.transformVec(viewPlaneNormal);
+    TRACE("vpn: %g %g %g", viewPlaneNormal.x, viewPlaneNormal.y, viewPlaneNormal.z);
+    _position = _focalPoint + viewPlaneNormal * getDistance();
 
     TRACE("Set rotation to angles: %g %g %g",
@@ -261 +428 @@
 void Camera::print() const
 {
-    TRACE("x: %d y: %d w: %d h: %d", _startX, _startY, _width, _height);
-    TRACE("loc: %g %g %g",
-          _location.x, _location.y, _location.z);
-    TRACE("Camera matrix: ");
-    _cameraMatrix.print();
+    TRACE("x: %d y: %d w: %d h: %d",
+          _viewport[0], _viewport[1], _viewport[2], _viewport[3]);
     TRACE("fov: %g near: %g far: %g", _fov, _near, _far);
-}
+    TRACE("fp: %g, %g, %g",
+          _focalPoint.x, _focalPoint.y, _focalPoint.z);
+    TRACE("pos: %g, %g, %g",
+          _position.x, _position.y, _position.z);
+    TRACE("Rotation matrix: ");
+    _rotationMatrix.print();
+    TRACE("Modelview matrix: ");
+    _modelViewMatrix.print();
+}

trunk/packages/vizservers/nanovis/Camera.h

@@ -19 +19 @@
 {
 public:
-    Camera(int startx, int starty, int w, int h,
-             float loc_x, float loc_y, float loc_z);
+    enum AxisDirection {
+        X_POS = 1,
+        Y_POS = 2,
+        Z_POS = 3,
+        X_NEG = -1,
+        Y_NEG = -2,
+        Z_NEG = -3
+    };
+
+    Camera(int x, int y, int width, int height);
 
     ~Camera()
     {}
 
-    //move location of camera
-    void x(float loc_x)
+    void setUpdir(AxisDirection dir)
     {
-        _location.x = loc_x;
+         setUpDirMatrix(dir);
+        _mvDirty = true;
     }
 
-    float x() const
+    void setPosition(const vrmath::Vector3f& pos)
     {
-        return _location.x;
+        _position = pos;
+        _mvDirty = true;
     }
 
-    void y(float loc_y)
+    const vrmath::Vector3f& getPosition() const
     {
-        _location.y = loc_y;
+        return _position;
     }
 
-    float y() const
+    const vrmath::Vector3f& getFocalPoint() const
     {
-        return _location.y;
+        return _focalPoint;
     }
 
-    void z(float loc_z)
+    float getDistance() const
     {
-        _location.z = loc_z;
+        return vrmath::Vector3f(_focalPoint - _position).length();
     }
 
-    float z() const
+    vrmath::Vector3f getDirectionOfProjection() const
     {
-        return _location.z;
+        vrmath::Vector3f dir = _focalPoint - _position;
+        dir = dir.normalize();
+        return dir;
     }
 
-    void rotate(double *quat);
+    vrmath::Vector3f getViewPlaneNormal() const
+    {
+        vrmath::Vector3f dir = _position - _focalPoint;
+        dir = dir.normalize();
+        return dir;
+    }
 
-    void rotate(float angle_x, float angle_y, float angle_z);
+    void pan(float x, float y, bool absolute = true);
 
-    void fov(float fov)
+    void zoom(float z, bool absolute = true);
+
+    void orient(double *quat);
+
+    void orient(float angleX, float angleY, float angleZ);
+
+    void setFov(float fov)
     {
         _fov = fov;
     }
 
-    float fov() const
+    float getFov() const
     {
         return _fov;
@@ -74 +96 @@
                bool resetOrientation = false);
 
-    void setClippingRange(float near, float far)
-    {
-        _near = near;
-        _far = far;
-    }
-
     void resetClippingRange(const vrmath::Vector3f& bboxMin,
                             const vrmath::Vector3f& bboxMax);
 
-    void setScreenSize(int sx, int sy, int w, int h)
+    void setViewport(int x, int y, int width, int height)
     {
-        _width = w;
-        _height = h;
-        _startX = sx;
-        _startY = sy;
+        _viewport[0] = x;
+        _viewport[1] = y;
+        _viewport[2] = width;
+        _viewport[3] = height;
     }
 
@@ -99 +115 @@
     void print() const;
 
+    vrmath::Matrix4x4d& getModelViewMatrix()
+    {
+        computeModelViewMatrix();
+        return _modelViewMatrix;
+    }
+
+    void getProjectionMatrix(vrmath::Matrix4x4d& mat);
+
+    const vrmath::Matrix4x4d& getUpDirMatrix() const;
+
+    void windowToWorldCoords(double x, double y, double z, vrmath::Vector3f& objPos);
+
+    void worldToWindowCoords(double x, double y, double z, vrmath::Vector3f& winPos);
+
 private:
-    void getUpDirMatrix(vrmath::Matrix4x4d& upMat);
+    void computeModelViewMatrix();
 
-    /// Location of the camera in the scene
-    vrmath::Vector3f _location;
-    /// Camera view matrix (orientation only, no translation)
-    vrmath::Matrix4x4d _cameraMatrix;
+    void setUpDirMatrix(AxisDirection dir);
+
+    AxisDirection _updir;
+
+    double _zoomRatio;
+    float _pan[2];
+    /// Position of the camera in the scene
+    vrmath::Vector3f _position;
+    vrmath::Vector3f _focalPoint;
+
+    /// Model transform for z-up scene
+    vrmath::Matrix4x4d _updirMatrix;
+    /// Camera orientation
+    vrmath::Matrix4x4d _rotationMatrix;
+    /// Full camera matrix
+    bool _mvDirty;
+    vrmath::Matrix4x4d _modelViewMatrix;
+
     /// Field of view (vertical angle in degrees)
     float _fov;
@@ -111 +155 @@
     float _near, _far;
 
-    /// screen width
-    int _width;
-    /// screen height
-    int _height;
-    int _startX;
-    int _startY;
-};
+    // x, y, width, height
+    int _viewport[4];
+ };
 
 }

trunk/packages/vizservers/nanovis/ColorTableShader.cpp

@@ -19 +19 @@
 void ColorTableShader::init()
 {
-    loadFragmentProgram("one_plane.cg", "main"); 
+    loadFragmentProgram("one_plane.cg"); 
 }
 

trunk/packages/vizservers/nanovis/Command.cpp

@@ -568 +568 @@
         return TCL_ERROR;
     }
-    NanoVis::cam->rotate(phi, theta, psi);
-    return TCL_OK;
+    //NanoVis::orientCamera(phi, theta, psi);
+    //return TCL_OK;
+    Tcl_AppendResult(interp, "The 'camera angle' command is deprecated, use 'camera orient'", (char*)NULL);
+    return TCL_ERROR;
 }
 
@@ -583 +585 @@
         return TCL_ERROR;
     }
-    NanoVis::cam->rotate(quat);
+    NanoVis::orientCamera(quat);
     return TCL_OK;
 }
@@ -596 +598 @@
         return TCL_ERROR;
     }
-    NanoVis::pan(x, y);
+    NanoVis::panCamera(x, y);
     return TCL_OK;
 }
@@ -604 +606 @@
                  Tcl_Obj *const *objv)
 {
-    float x, y, z;
-    if ((GetFloatFromObj(interp, objv[2], &x) != TCL_OK) ||
-        (GetFloatFromObj(interp, objv[3], &y) != TCL_OK) ||
-        (GetFloatFromObj(interp, objv[4], &z) != TCL_OK)) {
-        return TCL_ERROR;
-    }
-    NanoVis::cam->x(x);
-    NanoVis::cam->y(y);
-    NanoVis::cam->z(z);
+    Vector3f pos;
+    if ((GetFloatFromObj(interp, objv[2], &pos.x) != TCL_OK) ||
+        (GetFloatFromObj(interp, objv[3], &pos.y) != TCL_OK) ||
+        (GetFloatFromObj(interp, objv[4], &pos.z) != TCL_OK)) {
+        return TCL_ERROR;
+    }
+
+    NanoVis::setCameraPosition(pos);
     return TCL_OK;
 }
@@ -643 +644 @@
         return TCL_ERROR;
     }
-    NanoVis::zoom(z);
+    NanoVis::zoomCamera(z);
     return TCL_OK;
 }
@@ -725 +726 @@
     std::vector<Volume *>::iterator iter;
     for (iter = ivol.begin(); iter != ivol.end(); iter++) {
-        (*iter)->moveCutplane(axis, relval);
-    }
-    return TCL_OK;
-}
-
-/*
- * cutplane state $bool $axis vol,,,
- */
+        (*iter)->setCutplanePosition(axis, relval);
+    }
+    return TCL_OK;
+}
+
 static int
 CutplaneStateOp(ClientData clientData, Tcl_Interp *interp, int objc,
@@ -1123 +1121 @@
         return TCL_ERROR;
     }
-    NanoVis::updir = (axis+1)*sign;
+    NanoVis::setCameraUpdir(Camera::AxisDirection((axis+1)*sign));
     return TCL_OK;
 }
@@ -1264 +1262 @@
         }
         TRACE("finish loading");
-
-        Vector3f scale = volume->getPhysicalScaling();
-        Vector3f loc(scale);
-        loc *= -0.5;
-        volume->location(loc);
 
         NanoVis::VolumeHashmap::iterator itr = NanoVis::volumeTable.find(tag);

trunk/packages/vizservers/nanovis/Flow.cpp

@@ -10 +10 @@
  */
 
+#include <float.h>
+
 #include <tcl.h>
 
+#include <vrmath/BBox.h>
 #include <vrmath/Vector3f.h>
 
@@ -31 +34 @@
 using namespace vrmath;
 
+bool Flow::updatePending = false;
+double Flow::magMin = DBL_MAX;
+double Flow::magMax = -DBL_MAX;
+
 Flow::Flow(Tcl_Interp *interp, const char *name) :
     _interp(interp),
@@ -81 +88 @@
         return;
 
-#if 0  // Using volume bounds instead of these
+    BBox allBounds;
     if (isDataLoaded()) {
-        Vector3f umin, umax;
-        Rappture::Unirect3d *unirect = data();
-        unirect->getWorldSpaceBounds(umin, umax);
-        if (min.x > umin.x) {
-            min.x = umin.x;
-        }
-        if (max.x < umax.x) {
-            max.x = umax.x;
-        }
-        if (min.y > umin.y) {
-            min.y = umin.y;
-        }
-        if (max.y < umax.y) {
-            max.y = umax.y;
-        }
-        if (min.z > umin.z) {
-            min.z = umin.z;
-        }
-        if (max.z < umax.z) {
-            max.z = umax.z;
-        }
-    }
-#endif
+        BBox bbox;
+        data()->getBounds(bbox.min, bbox.max);
+        allBounds.extend(bbox);
+    }
     for (BoxHashmap::iterator itr = _boxTable.begin();
          itr != _boxTable.end(); ++itr) {
         FlowBox *box = itr->second;
         if (!onlyVisible || box->visible()) {
-            Vector3f fbmin, fbmax;
-            box->getWorldSpaceBounds(fbmin, fbmax,
-                                     getVolume());
-            if (min.x > fbmin.x) {
-                min.x = fbmin.x;
-            }
-            if (max.x < fbmax.x) {
-                max.x = fbmax.x;
-            }
-            if (min.y > fbmin.y) {
-                min.y = fbmin.y;
-            }
-            if (max.y < fbmax.y) {
-                max.y = fbmax.y;
-            }
-            if (min.z > fbmin.z) {
-                min.z = fbmin.z;
-            }
-            if (max.z < fbmax.z) {
-                max.z = fbmax.z;
-            }
-        }
-    }
+            BBox bbox;
+            box->getBounds(bbox.min, bbox.max);
+            allBounds.extend(bbox);
+        }
+    }
+    min = allBounds.min;
+    max = allBounds.max;
 }
 
@@ -143 +115 @@
     switch (position->axis) {
     case AXIS_X:  
-        return (position->value - NanoVis::xMin) / 
-            (NanoVis::xMax - NanoVis::xMin); 
+        return (position->value - _data->xMin()) / 
+            (_data->xMax() - _data->xMin()); 
     case AXIS_Y:  
-        return (position->value - NanoVis::yMin) / 
-            (NanoVis::yMax - NanoVis::yMin); 
+        return (position->value - _data->yMin()) / 
+            (_data->yMax() - _data->yMin()); 
     case AXIS_Z:  
-        return (position->value - NanoVis::zMin) / 
-            (NanoVis::zMax - NanoVis::zMin); 
+        return (position->value - _data->zMin()) / 
+            (_data->zMax() - _data->zMin()); 
     }
     return 0.0;
-}
-
-float
-Flow::getRelativePosition() 
-{
-    return getRelativePosition(&_sv.slicePos);
 }
 
@@ -295 +261 @@
 
 bool
+Flow::configure()
+{
+    bool needReset = false;
+
+    if (_volume != NULL) {
+        _volume->transferFunction(_sv.transferFunction);
+        _volume->dataEnabled(_sv.showVolume);
+        _volume->twoSidedLighting(_sv.twoSidedLighting);
+        _volume->outline(_sv.showOutline);
+        _volume->opacityScale(_sv.opacity);
+        _volume->ambient(_sv.ambient);
+        _volume->diffuse(_sv.diffuse);
+        _volume->specularLevel(_sv.specular);
+        _volume->specularExponent(_sv.specularExp);
+    }
+
+    float slicePos = getRelativePosition(&_sv.slicePos);
+
+    // FIXME: LIC and arrows should be per-flow
+    if (NanoVis::licRenderer != NULL) {
+        if (NanoVis::licRenderer->getSliceAxis() != _sv.slicePos.axis) {
+            needReset = true;
+            NanoVis::licRenderer->setSliceAxis(_sv.slicePos.axis);
+        }
+        if (NanoVis::licRenderer->getSlicePosition() != slicePos) {
+            needReset = true;
+            NanoVis::licRenderer->setSlicePosition(slicePos);
+        }
+        NanoVis::licRenderer->visible(_sv.sliceVisible);
+    }
+    if (NanoVis::velocityArrowsSlice != NULL) {
+        NanoVis::velocityArrowsSlice->setSliceAxis(_sv.slicePos.axis);
+        NanoVis::velocityArrowsSlice->setSlicePosition(slicePos);
+        NanoVis::velocityArrowsSlice->visible(_sv.showArrows);
+    }
+
+    return needReset;
+}
+
+bool
 Flow::scaleVectorField()
 {
+    float *vdata = getScaledVector();
     if (_volume != NULL) {
-        TRACE("Removing existing volume: %s", _volume->name());
-        NanoVis::removeVolume(_volume);
-        _volume = NULL;
-    }
-    float *vdata = getScaledVector();
-    if (vdata == NULL) {
-        return false;
-    }
-    Volume *volume = makeVolume(vdata);
+        TRACE("Updating existing volume: %s", _volume->name());
+        _volume->setData(vdata, magMin, magMax, 0);
+    } else {
+        _volume = makeVolume(vdata);
+        if (_volume == NULL) {
+            return false;
+        }
+    }
     delete [] vdata;
-    if (volume == NULL) {
-        return false;
-    }
-    _volume = volume;
-
-    Vector3f scale = volume->getPhysicalScaling();
-    Vector3f location = _volume->location();
-
+    // FIXME: LIC and arrows should be per-flow
     if (NanoVis::licRenderer != NULL) {
-        NanoVis::licRenderer->
-            setVectorField(_volume->textureID(),
-                           location,
-                           scale.x,
-                           scale.y,
-                           scale.z,
-                           _volume->wAxis.max());
-        setCurrentPosition();
-        setAxis();
-        setActive();
-    }
-
+        NanoVis::licRenderer->setVectorField(_volume);
+        NanoVis::licRenderer->setSliceAxis(_sv.slicePos.axis);
+        NanoVis::licRenderer->setSlicePosition(getRelativePosition(&_sv.slicePos));
+        NanoVis::licRenderer->visible(_sv.sliceVisible);
+    }
     if (NanoVis::velocityArrowsSlice != NULL) {
-        NanoVis::velocityArrowsSlice->
-            setVectorField(_volume->textureID(),
-                           location,
-                           scale.x,
-                           scale.y,
-                           scale.z,
-                           _volume->wAxis.max());
-        NanoVis::velocityArrowsSlice->axis(_sv.slicePos.axis);
-        NanoVis::velocityArrowsSlice->slicePos(_sv.slicePos.value);
-        NanoVis::velocityArrowsSlice->enabled(_sv.showArrows);
-    }
-
-    for (ParticlesHashmap::iterator itr = _particlesTable.begin();
-         itr != _particlesTable.end(); ++itr) {
-        itr->second->setVectorField(_volume,
-                                    location,
-                                    scale.x,
-                                    scale.y,
-                                    scale.z,
-                                    _volume->wAxis.max());
+        NanoVis::velocityArrowsSlice->setVectorField(_volume);
+        NanoVis::velocityArrowsSlice->setSliceAxis(_sv.slicePos.axis);
+        NanoVis::velocityArrowsSlice->setSlicePosition(getRelativePosition(&_sv.slicePos));
+        NanoVis::velocityArrowsSlice->visible(_sv.showArrows);
+    }
+    for (ParticlesHashmap::iterator itr = _particlesTable.begin();
+         itr != _particlesTable.end(); ++itr) {
+        itr->second->setVectorField(_volume);
     }
     return true;
@@ -371 +351 @@
     size_t n = _data->nValues() / _data->nComponents() * 4;
     float *data = new float[n];
-    if (data == NULL) {
-        return NULL;
-    }
     memset(data, 0, sizeof(float) * n);
     float *dest = data;
@@ -385 +362 @@
                 vz = values[2];
                 vm = sqrt(vx*vx + vy*vy + vz*vz);
-                dest[0] = vm / NanoVis::magMax;
-                dest[1] = vx /(2.0*NanoVis::magMax) + 0.5;
-                dest[2] = vy /(2.0*NanoVis::magMax) + 0.5;
-                dest[3] = vz /(2.0*NanoVis::magMax) + 0.5;
+                dest[0] = vm / magMax;
+                dest[1] = vx /(2.0 * magMax) + 0.5;
+                dest[2] = vy /(2.0 * magMax) + 0.5;
+                dest[3] = vz /(2.0 * magMax) + 0.5;
                 values += 3;
                 dest += 4;
@@ -406 +383 @@
                             _data->zNum(),
                             4, data, 
-                            NanoVis::magMin, NanoVis::magMax, 0);
+                            magMin, magMax, 0);
     volume->xAxis.setRange(_data->xMin(), _data->xMax());
     volume->yAxis.setRange(_data->yMin(), _data->yMax());
     volume->zAxis.setRange(_data->zMin(), _data->zMax());
 
-    TRACE("min=%g %g %g max=%g %g %g mag=%g %g",
-          NanoVis::xMin, NanoVis::yMin, NanoVis::zMin,
-          NanoVis::xMax, NanoVis::yMax, NanoVis::zMax,
-          NanoVis::magMin, NanoVis::magMax);
+    TRACE("mag=%g %g", magMin, magMax);
 
     volume->disableCutplane(0);
@@ -430 +404 @@
     volume->specularLevel(_sv.specular);
     volume->specularExponent(_sv.specularExp);
-    volume->visible(_sv.showVolume);
-
-    Vector3f volScaling = volume->getPhysicalScaling();
-    Vector3f loc(volScaling);
-    loc *= -0.5;
-    volume->location(loc);
 
     Volume::updatePending = true;

trunk/packages/vizservers/nanovis/Flow.h

@@ -25 +25 @@
 #include "FlowBox.h"
 #include "LIC.h"
+#include "VelocityArrowsSlice.h"
 #include "Unirect.h"
 #include "Volume.h"
@@ -50 +51 @@
 {
 public:
-    enum SliceAxis { AXIS_X, AXIS_Y, AXIS_Z };
-
     Flow(Tcl_Interp *interp, const char *name);
 
@@ -84 +83 @@
     void getBoxNames(std::vector<std::string>& names);
 
-    float *getScaledVector();
-
-    Volume *makeVolume(float *data);
-
     bool scaleVectorField();
 
@@ -117 +112 @@
         _data = data;
     }
+
+    FlowSliceAxis getAxis()
+    {
+        return _sv.slicePos.axis;
+    }
+
+    TransferFunction *getTransferFunction()
+    {
+        return _sv.transferFunction;
+    }
 #if 0
-    void activateSlice()
-    {
-        /* Must set axis before offset or position goes to wrong axis. */
-        NanoVis::licRenderer->setAxis(_sv.slicePos.axis);
-        NanoVis::licRenderer->setOffset(_sv.slicePos.value);
-        NanoVis::licRenderer->active(true);
-    }
-
-    void deactivateSlice()
-    {
-        NanoVis::licRenderer->active(false);
+    void setAxis(FlowSliceAxis axis)
+    {
+        _sv.slicePos.axis = axis;
+        if (NanoVis::licRenderer != NULL) {
+            NanoVis::licRenderer->setSliceAxis(_sv.slicePos.axis);
+        }
+        if (NanoVis::velocityArrowsSlice != NULL) {
+            NanoVis::velocityArrowsSlice->setSliceAxis(_sv.slicePos.axis);
+        }
+    }
+
+    void setCurrentPosition(float position)
+    {
+        _sv.slicePos.value = position;
+        if (NanoVis::licRenderer != NULL) {
+            NanoVis::licRenderer->setSlicePosition(_sv.slicePos.value);
+        }
+        if (NanoVis::velocityArrowsSlice != NULL) {
+            NanoVis::velocityArrowsSlice->setSlicePosition(_sv.slicePos.value);
+        }
+    }
+
+    void setLICActive(bool state)
+    {
+        _sv.sliceVisible = state;
+        if (NanoVis::licRenderer != NULL) {
+            NanoVis::licRenderer->setVectorField(_volume);
+            NanoVis::licRenderer->setSliceAxis(_sv.slicePos.axis);
+            NanoVis::licRenderer->setSlicePosition(_sv.slicePos.value);
+            NanoVis::licRenderer->visible(state);
+        }
+    }
+
+    void setArrowsActive(bool state)
+        _sv.showArrows = state;
+        if (NanoVis::velocityArrowsSlice != NULL) {
+            NanoVis::velocityArrowsSlice->setVectorField(_volume);
+            NanoVis::velocityArrowsSlice->setSliceAxis(_sv.slicePos.axis);
+            NanoVis::velocityArrowsSlice->setSlicePosition(_sv.slicePos.value);
+            NanoVis::velocityArrowsSlice->visible(_sv.showArrows);
+        }
     }
 #endif
-    SliceAxis getAxis()
-    {
-        return (SliceAxis)_sv.slicePos.axis;
-    }
-
-    TransferFunction *getTransferFunction()
-    {
-        return _sv.transferFunction;
-    }
-
-    float getRelativePosition();
-
-    void setAxis()
-    {
-        NanoVis::licRenderer->setAxis(_sv.slicePos.axis);
-    }
-
-    void setAxis(Flow::SliceAxis axis)
-    {
-        _sv.slicePos.axis = axis;
-        NanoVis::licRenderer->setAxis(_sv.slicePos.axis);
-    }
-
-    void setCurrentPosition(float position)
-    {
-        _sv.slicePos.value = position;
-        NanoVis::licRenderer->setOffset(_sv.slicePos.value);
-    }
-
-    void setCurrentPosition()
-    {
-        NanoVis::licRenderer->setOffset(_sv.slicePos.value);
-    }
-
-    void setActive(bool state)
-    {
-        _sv.sliceVisible = state;
-        NanoVis::licRenderer->active(state);
-    }
-
-    void setActive()
-    {
-        NanoVis::licRenderer->active(_sv.sliceVisible);
-    }
-
     const Volume *getVolume() const
     {
@@ -190 +180 @@
     }
 
+    bool configure();
+
     Tcl_Command getCommandToken()
     {
@@ -195 +187 @@
     }
 
-    static float getRelativePosition(FlowPosition *pos);
+    float getRelativePosition(FlowPosition *pos);
+
+    static bool updatePending;
+    static double magMin, magMax;
 
 private:
@@ -203 +198 @@
     typedef std::tr1::unordered_map<BoxId, FlowBox *> BoxHashmap;
 
-    void configure();
+    float *getScaledVector();
+
+    Volume *makeVolume(float *data);
 
     void renderBoxes();

trunk/packages/vizservers/nanovis/FlowBox.cpp

@@ -45 +45 @@
 
 void
-FlowBox::getWorldSpaceBounds(Vector3f& bboxMin,
-                             Vector3f& bboxMax,
-                             const Volume *vol) const
+FlowBox::getBounds(Vector3f& bboxMin,
+                   Vector3f& bboxMax) const
 {
-    bboxMin.set(FLT_MAX, FLT_MAX, FLT_MAX);
-    bboxMax.set(-FLT_MAX, -FLT_MAX, -FLT_MAX);
-
-    Vector3f origin = vol->location();
-    Vector3f scale = vol->getPhysicalScaling();
-
-    Matrix4x4d mat;
-    mat.makeTranslation(origin);
-    Matrix4x4d mat2;
-    mat2.makeScale(scale);
-
-    mat.multiply(mat2);
-
-    Vector3f min, max;
-    min.x = vol->xAxis.min();
-    min.y = vol->yAxis.min();
-    min.z = vol->zAxis.min();
-    max.x = vol->xAxis.max();
-    max.y = vol->yAxis.max();
-    max.z = vol->zAxis.max();
-
-    float x0, y0, z0, x1, y1, z1;
-    x0 = y0 = z0 = 0.0f;
-    x1 = y1 = z1 = 0.0f;
-    if (max.x > min.x) {
-        x0 = (_sv.corner1.x - min.x) / (max.x - min.x);
-        x1 = (_sv.corner2.x - min.x) / (max.x - min.x);
-    }
-    if (max.y > min.y) {
-        y0 = (_sv.corner1.y - min.y) / (max.y - min.y);
-        y1 = (_sv.corner2.y - min.y) / (max.y - min.y);
-    }
-    if (max.z > min.z) {
-        z0 = (_sv.corner1.z - min.z) / (max.z - min.z);
-        z1 = (_sv.corner2.z - min.z) / (max.z - min.z);
-    }
-
-    TRACE("Box model bounds: (%g,%g,%g) - (%g,%g,%g)",
-          x0, y0, z0, x1, y1, z1);
-
-    Vector3f modelMin(x0, y0, z0);
-    Vector3f modelMax(x1, y1, z1);
-
-    Vector4f bvert[8];
-    bvert[0] = Vector4f(modelMin.x, modelMin.y, modelMin.z, 1);
-    bvert[1] = Vector4f(modelMax.x, modelMin.y, modelMin.z, 1);
-    bvert[2] = Vector4f(modelMin.x, modelMax.y, modelMin.z, 1);
-    bvert[3] = Vector4f(modelMin.x, modelMin.y, modelMax.z, 1);
-    bvert[4] = Vector4f(modelMax.x, modelMax.y, modelMin.z, 1);
-    bvert[5] = Vector4f(modelMax.x, modelMin.y, modelMax.z, 1);
-    bvert[6] = Vector4f(modelMin.x, modelMax.y, modelMax.z, 1);
-    bvert[7] = Vector4f(modelMax.x, modelMax.y, modelMax.z, 1);
-
-    for (int i = 0; i < 8; i++) {
-        Vector4f worldVert = mat.transform(bvert[i]);
-        if (worldVert.x < bboxMin.x) bboxMin.x = worldVert.x;
-        if (worldVert.x > bboxMax.x) bboxMax.x = worldVert.x;
-        if (worldVert.y < bboxMin.y) bboxMin.y = worldVert.y;
-        if (worldVert.y > bboxMax.y) bboxMax.y = worldVert.y;
-        if (worldVert.z < bboxMin.z) bboxMin.z = worldVert.z;
-        if (worldVert.z > bboxMax.z) bboxMax.z = worldVert.z;
-    }
-
-    TRACE("Box world bounds: (%g,%g,%g) - (%g,%g,%g)",
-          bboxMin.x, bboxMin.y, bboxMin.z,
-          bboxMax.x, bboxMax.y, bboxMax.z);
+    bboxMin.set(_sv.corner1.x, _sv.corner1.y, _sv.corner1.z);
+    bboxMax.set(_sv.corner2.x, _sv.corner2.y, _sv.corner2.z);
 }
 
@@ -131 +66 @@
     glPushMatrix();
 
-    Vector3f origin = vol->location();
-    glTranslatef(origin.x, origin.y, origin.z);
-
-    Vector3f scale = vol->getPhysicalScaling();
-    glScalef(scale.x, scale.y, scale.z);
-
-    Vector3f min, max;
-    min.x = vol->xAxis.min();
-    min.y = vol->yAxis.min();
-    min.z = vol->zAxis.min();
-    max.x = vol->xAxis.max();
-    max.y = vol->yAxis.max();
-    max.z = vol->zAxis.max();
-
-    TRACE("box is %g,%g %g,%g %g,%g",
+    TRACE("box bounds %g,%g %g,%g %g,%g",
           _sv.corner1.x, _sv.corner2.x,
           _sv.corner1.y, _sv.corner2.y,
           _sv.corner1.z, _sv.corner2.z);
-    TRACE("world is %g,%g %g,%g %g,%g",
-          min.x, max.x, min.y, max.y, min.z, max.z);
 
     float x0, y0, z0, x1, y1, z1;
-    x0 = y0 = z0 = 0.0f;
-    x1 = y1 = z1 = 0.0f;
-    if (max.x > min.x) {
-        x0 = (_sv.corner1.x - min.x) / (max.x - min.x);
-        x1 = (_sv.corner2.x - min.x) / (max.x - min.x);
-    }
-    if (max.y > min.y) {
-        y0 = (_sv.corner1.y - min.y) / (max.y - min.y);
-        y1 = (_sv.corner2.y - min.y) / (max.y - min.y);
-    }
-    if (max.z > min.z) {
-        z0 = (_sv.corner1.z - min.z) / (max.z - min.z);
-        z1 = (_sv.corner2.z - min.z) / (max.z - min.z);
-    }
-    TRACE("box bounds: %g,%g %g,%g %g,%g",
-          x0, x1, y0, y1, z0, z1);
+
+    x0 = _sv.corner1.x;
+    x1 = _sv.corner2.x;
+    y0 = _sv.corner1.y;
+    y1 = _sv.corner2.y;
+    z0 = _sv.corner1.z;
+    z1 = _sv.corner2.z;
 
     glColor4d(_sv.color.r, _sv.color.g, _sv.color.b, _sv.color.a);

trunk/packages/vizservers/nanovis/FlowBox.h

@@ -63 +63 @@
     }
 
-    void getWorldSpaceBounds(vrmath::Vector3f& min,
-                             vrmath::Vector3f& max,
-                             const Volume *volume) const;
+    void getBounds(vrmath::Vector3f& min,
+                   vrmath::Vector3f& max) const;
 
 private:

trunk/packages/vizservers/nanovis/FlowCmd.cpp

@@ -104 +104 @@
 
 Rappture::SwitchSpec FlowParticles::_switches[] = {
-    {Rappture::SWITCH_CUSTOM, "-axis", "string",
+    {Rappture::SWITCH_CUSTOM, "-axis", "axis",
      offsetof(FlowParticlesValues, position.axis), 0, 0, &axisSwitch},
     {Rappture::SWITCH_CUSTOM, "-color", "{r g b a}",
@@ -197 +197 @@
     }
     flow->data(dataPtr);
-    NanoVis::eventuallyRedraw(NanoVis::MAP_FLOWS);
+    Flow::updatePending = true;
+    NanoVis::eventuallyRedraw();
     return TCL_OK;
 }
@@ -266 +267 @@
         dataPtr->convert(u2dPtr);
         delete u2dPtr;
+#if 0
+    } else if ((length > 14) && (strncmp(bytes, "# vtk DataFile", 14) == 0)) {
+        TRACE("VTK loading...");
+        std::stringstream fdata;
+        fdata.write(bytes, length);
+        if (length <= 0) {
+            ERROR("data buffer is empty");
+            abort();
+        }
+        Rappture::Outcome context;
+        volume = load_vtk_volume_stream(context, tag, fdata);
+        if (volume == NULL) {
+            Tcl_AppendResult(interp, context.remark(), (char*)NULL);
+            return TCL_ERROR;
+        }
+#endif
     } else {
         TRACE("header is %.14s", buf.bytes());
@@ -307 +324 @@
 #endif
     }
-    NanoVis::eventuallyRedraw(NanoVis::MAP_FLOWS);
+    Flow::updatePending = true;
+    NanoVis::eventuallyRedraw();
     return TCL_OK;
 }
@@ -353 +371 @@
     const char *string = Tcl_GetString(objPtr);
     if (string[1] == '\0') {
-        Flow::SliceAxis *axisPtr = (Flow::SliceAxis *)(record + offset);
+        FlowSliceAxis *axisPtr = (FlowSliceAxis *)(record + offset);
         char c;
         c = tolower((unsigned char)string[0]);
         if (c == 'x') {
-            *axisPtr = Flow::AXIS_X;
+            *axisPtr = AXIS_X;
             return TCL_OK;
         } else if (c == 'y') {
-            *axisPtr = Flow::AXIS_Y;
+            *axisPtr = AXIS_Y;
             return TCL_OK;
         } else if (c == 'z') {
-            *axisPtr = Flow::AXIS_Z;
+            *axisPtr = AXIS_Z;
             return TCL_OK;
         }
@@ -564 +582 @@
         return TCL_ERROR;
     }
-    NanoVis::eventuallyRedraw(NanoVis::MAP_FLOWS);
+    if (flow->configure()) {
+        Flow::updatePending = true;
+    }
+    NanoVis::eventuallyRedraw();
     return TCL_OK;
 }
@@ -587 +608 @@
     }
     particles->configure();
+    Flow::updatePending = true;
     NanoVis::eventuallyRedraw();
     Tcl_SetObjResult(interp, objv[3]);
@@ -608 +630 @@
         return TCL_ERROR;
     }
-    particles->configure();
-    NanoVis::eventuallyRedraw(NanoVis::MAP_FLOWS);
+    if (particles->configure()) {
+        Flow::updatePending = true;
+    }
+    NanoVis::eventuallyRedraw();
     return TCL_OK;
 }
@@ -815 +839 @@
         return TCL_ERROR;
     }
-    if (NanoVis::flags & NanoVis::MAP_FLOWS) {
+    if (Flow::updatePending) {
         NanoVis::mapFlows();
     }
-    NanoVis::renderLegend(tf, NanoVis::magMin, NanoVis::magMax, w, h, label);
+    NanoVis::renderLegend(tf, Flow::magMin, Flow::magMax, w, h, label);
     return TCL_OK;
 }
@@ -905 +929 @@
         }
     }
-    NanoVis::eventuallyRedraw(NanoVis::MAP_FLOWS);
+    Flow::updatePending = true;
+    NanoVis::eventuallyRedraw();
     return TCL_OK;
 }
@@ -939 +964 @@
     }
     NanoVis::resetFlows();
-    if (NanoVis::flags & NanoVis::MAP_FLOWS) {
+    if (Flow::updatePending) {
         NanoVis::mapFlows();
     }
-    NanoVis::advectFlows();
     for (int i = 0; i < nSteps; i++) {
-        if (NanoVis::licRenderer->active()) {
-            NanoVis::licRenderer->convolve();
-        }
+        NanoVis::licRenderer->convolve();
         NanoVis::advectFlows();
     }
@@ -974 +996 @@
 {
     assert(NanoVis::licRenderer != NULL);
-    if (NanoVis::flags & NanoVis::MAP_FLOWS) {
+    if (Flow::updatePending) {
         NanoVis::mapFlows();
     }
-    NanoVis::eventuallyRedraw();
     NanoVis::licRenderer->convolve();
     NanoVis::advectFlows();
+    NanoVis::eventuallyRedraw();
     return TCL_OK;
 }
@@ -1101 +1123 @@
             break;
         }
-        if (NanoVis::licRenderer->active()) {
-            NanoVis::licRenderer->convolve();
-        }
+
+        NanoVis::licRenderer->convolve();
         NanoVis::advectFlows();
 

trunk/packages/vizservers/nanovis/FlowParticles.cpp

@@ -28 +28 @@
     _sv.position.value = 0.0f;
     _sv.position.flags = RELPOS;
-    _sv.position.axis = 0; // X_AXIS
+    _sv.position.axis = AXIS_Z;
     _sv.color.r = _sv.color.g = _sv.color.b = _sv.color.a = 1.0f;
     _sv.isHidden = false;
@@ -44 +44 @@
 }
 
+float
+FlowParticles::getRelativePosition(FlowPosition *position)
+{
+    if (position->flags == RELPOS) {
+        return position->value;
+    }
+    switch (position->axis) {
+    case AXIS_X:  
+        return (position->value - _volume->xAxis.min()) / 
+            (_volume->xAxis.max() - _volume->xAxis.min()); 
+    case AXIS_Y:  
+        return (position->value - _volume->yAxis.min()) / 
+            (_volume->yAxis.max() - _volume->yAxis.min()); 
+    case AXIS_Z:  
+        return (position->value - _volume->zAxis.min()) / 
+            (_volume->zAxis.max() - _volume->zAxis.min()); 
+    }
+    return 0.0;
+}
+
 void
 FlowParticles::render() 
@@ -49 +69 @@
     TRACE("Particles '%s' axis: %d pos: %g rel pos: %g",
           _name.c_str(), _sv.position.axis, _sv.position.value,
-          Flow::getRelativePosition(&_sv.position));
+          getRelativePosition(&_sv.position));
 
-    _renderer->setPos(Flow::getRelativePosition(&_sv.position));
+    _renderer->setPos(getRelativePosition(&_sv.position));
     _renderer->setAxis(_sv.position.axis);
     assert(_renderer->active());
@@ -57 +77 @@
 }
 
-void 
+bool
 FlowParticles::configure() 
 {
-    _renderer->setPos(Flow::getRelativePosition(&_sv.position));
+    bool needReset = false;
+
     _renderer->setColor(Color4f(_sv.color.r,
                                 _sv.color.g,
@@ -66 +87 @@
                                 _sv.color.a));
     _renderer->particleSize(_sv.particleSize);
-    _renderer->setAxis(_sv.position.axis);
+    if (_renderer->getAxis() != _sv.position.axis) {
+        needReset = true;
+        _renderer->setAxis(_sv.position.axis);
+    }
+    float pos = getRelativePosition(&_sv.position);
+    if (_renderer->getPos() != pos) {
+        needReset = true;
+        _renderer->setPos(pos);
+    }
     _renderer->active(!_sv.isHidden);
+
+    return needReset;
 }

trunk/packages/vizservers/nanovis/FlowParticles.h

@@ -77 +77 @@
     }
 
-    void setVectorField(Volume *volume, const vrmath::Vector3f& location,
-                        float scaleX, float scaleY, float scaleZ,
-                        float max)
+    void setVectorField(Volume *volume)
     {
-        _renderer->
-            setVectorField(volume->textureID(),
-                           location,
-                           scaleX,
-                           scaleY,
-                           scaleZ,
-                           max);
+        _volume = volume;
+        _renderer->setVectorField(volume);
     }
 
-    void configure();
+    float getRelativePosition(FlowPosition *position);
+
+    bool configure();
 
 private:
@@ -99 +94 @@
     std::string _name;
     nv::ParticleRenderer *_renderer;        ///< Particle renderer
+    Volume *_volume;
     FlowParticlesValues _sv;
 

trunk/packages/vizservers/nanovis/FlowTypes.h

@@ -14 +14 @@
 namespace nv {
 
+enum FlowSliceAxis {
+    AXIS_X,
+    AXIS_Y,
+    AXIS_Z
+};
+
 struct FlowColor {
     float r, g, b, a;
@@ -25 +31 @@
     float value;
     unsigned int flags;
-    int axis;
+    FlowSliceAxis axis;
 };
 

trunk/packages/vizservers/nanovis/Grid.cpp

@@ -38 +38 @@
 }
 
+void Grid::getBounds(vrmath::Vector3f& bboxMin, vrmath::Vector3f& bboxMax) const
+{
+    bboxMin.set(xAxis.min(), yAxis.min(), zAxis.min());
+    bboxMax.set(xAxis.min() + xAxis.range(),
+                yAxis.min() + yAxis.range(),
+                zAxis.min() + zAxis.range());
+}
+
 void Grid::render()
 {
@@ -55 +63 @@
     glPushMatrix();
 
-    double xDataRange = xAxis.dataMax() - xAxis.dataMin();
-    double yDataRange = yAxis.dataMax() - yAxis.dataMin();
-    double zDataRange = zAxis.dataMax() - zAxis.dataMin();
-
-    double paspectX = 1.0f;
-    double paspectY = yDataRange / xDataRange;
-    double paspectZ = zDataRange / xDataRange;
- 
-    double xscale = xAxis.range() / xDataRange;
-    double yscale = yAxis.range() / xDataRange;
-    double zscale = zAxis.range() / xDataRange;
-
-    double xoffset = (xAxis.min() - xAxis.dataMin()) * xAxis.scale();
-    double yoffset = (yAxis.min() - yAxis.dataMin()) * yAxis.scale();
-    double zoffset = (zAxis.min() - zAxis.dataMin()) * zAxis.scale();
-
-    TRACE("Axis ranges: %g %g %g", xAxis.range(), yAxis.range(), zAxis.range());
-    TRACE("Axis scales: %g %g %g", xAxis.scale(), yAxis.scale(), zAxis.scale());
-    TRACE("Axis min/max: %g,%g %g,%g %g,%g",
-          xAxis.min(), xAxis.max(), 
-          yAxis.min(), yAxis.max(),
-          zAxis.min(), zAxis.max());
-    TRACE("Axis vmin/vmax: %g,%g %g,%g %g,%g",
-          xAxis.dataMin(), xAxis.dataMax(), 
-          yAxis.dataMin(), yAxis.dataMax(),
-          zAxis.dataMin(), zAxis.dataMax());
-    TRACE("paspect: %g %g %g", paspectX, paspectY, paspectZ);
-    TRACE("scale: %g %g %g", xscale, yscale, zscale);
-
-    glTranslatef(-0.5f * paspectX, -0.5f * paspectY, -0.5f * paspectZ);
-    glScalef(xscale, yscale, zscale);
-    glTranslatef(xoffset, yoffset, zoffset);
+    glTranslatef(xAxis.min(), yAxis.min(), zAxis.min());
+    glScalef(xAxis.range(), yAxis.range(), zAxis.range());
 
     glLineWidth(2.0f);

trunk/packages/vizservers/nanovis/Grid.h

@@ -7 +7 @@
 #define NV_GRID_H
 
+#include <vrmath/Vector3f.h>
 #include <vrmath/Color4f.h>
 
@@ -49 +50 @@
     void setFont(nv::util::Fonts *font);
 
+    void getBounds(vrmath::Vector3f& bboxMin,
+                   vrmath::Vector3f& bboxMax) const;
+
     Axis xAxis;
     Axis yAxis;

trunk/packages/vizservers/nanovis/HeightMap.cpp

@@ -40 +40 @@
 {
     _shader = new Shader();
-    _shader->loadFragmentProgram("heightcolor.cg", "main");
+    _shader->loadFragmentProgram("heightcolor.cg");
 }
 
@@ -490 +490 @@
 
 void
-HeightMap::getWorldSpaceBounds(Vector3f& bboxMin,
-                               Vector3f& bboxMax) const
-{
-    bboxMin.set(FLT_MAX, FLT_MAX, FLT_MAX);
-    bboxMax.set(-FLT_MAX, -FLT_MAX, -FLT_MAX);
-
-    
-}
+HeightMap::getBounds(Vector3f& bboxMin,
+                     Vector3f& bboxMax) const
+{
+    bboxMin.set(xAxis.min(), yAxis.min(), zAxis.min());
+    bboxMax.set(xAxis.max(), yAxis.max(), zAxis.max());
+}

trunk/packages/vizservers/nanovis/HeightMap.h

@@ -113 +113 @@
     }
 
-    void getWorldSpaceBounds(vrmath::Vector3f& bboxMin, vrmath::Vector3f& bboxMax) const;
+    void getBounds(vrmath::Vector3f& bboxMin, vrmath::Vector3f& bboxMax) const;
 
     AxisRange xAxis, yAxis, zAxis, wAxis;

trunk/packages/vizservers/nanovis/LIC.cpp

@@ -24 +24 @@
 using namespace vrmath;
 
-LIC::LIC(int size, int width, int height, int axis, 
+LIC::LIC(FlowSliceAxis axis, 
          float offset) :
-    _width(width),
-    _height(height),
-    _size(size),
+    _width(NPIX),
+    _height(NPIX),
+    _size(NMESH),
     _scale(1.0f, 1.0f, 1.0f),
     _origin(0, 0, 0),
@@ -41 +41 @@
     _disListID(0),
     _vectorFieldId(0),
-    _activate(false)
-{
-    _sliceVector = new float[_size*_size*4];
+    _visible(false)
+{
+    _sliceVector = new float[_size * _size * 4];
     memset(_sliceVector, 0, sizeof(float) * _size * _size * 4);
 
@@ -104 +104 @@
 
     _renderVelShader = new Shader();
-    _renderVelShader->loadFragmentProgram("render_vel.cg", "main");
+    _renderVelShader->loadFragmentProgram("render_vel.cg");
 
     makePatterns();
@@ -178 +178 @@
 }
 
-void LIC::makeMagnitudes()
+void
+LIC::makeMagnitudes()
 {
     GLubyte mag[NMESH][NMESH][4];
@@ -246 +247 @@
 
     switch (_axis) {
-    case 0:
+    case AXIS_X:
         _renderVelShader->setFPParameter3f("projection_vector", 0., 1., 1.);
         break;
-    case 1:
+    case AXIS_Y:
         _renderVelShader->setFPParameter3f("projection_vector", 1., 0., 1.);
         break;
     default:
-    case 2:
+    case AXIS_Z:
         _renderVelShader->setFPParameter3f("projection_vector", 1., 1., 0.);
         break;
@@ -261 +262 @@
     {
         switch (_axis) {
-        case 0:
+        case AXIS_X:
             glTexCoord3f(_offset, 0., 0.); glVertex2f(0.,    0.);
             glTexCoord3f(_offset, 1., 0.); glVertex2f(_size, 0.);
@@ -267 +268 @@
             glTexCoord3f(_offset, 0., 1.); glVertex2f(0.,    _size);
             break;
-        case 1:
+        case AXIS_Y:
             glTexCoord3f(0., _offset, 0.); glVertex2f(0.,    0.);
             glTexCoord3f(1., _offset, 0.); glVertex2f(_size, 0.);
@@ -273 +274 @@
             glTexCoord3f(0., _offset, 1.); glVertex2f(0.,    _size);
             break;
-        case 2:
+        case AXIS_Z:
             glTexCoord3f(0., 0., _offset); glVertex2f(0.,    0.);
             glTexCoord3f(1., 0., _offset); glVertex2f(_size, 0.);
@@ -428 +429 @@
 LIC::render()
 {
-    if (_vectorFieldId == 0) {
+    if (_vectorFieldId == 0 || !_visible) {
         return;
     }
@@ -451 +452 @@
     glBegin(GL_QUADS);
     switch (_axis) {
-    case 0:
+    case AXIS_X:
         glNormal3f(1, 0, 0);
         glTexCoord2f(0, 0); glVertex3f(_offset, 0, 0);
@@ -458 +459 @@
         glTexCoord2f(0, 1); glVertex3f(_offset, 0, 1);
         break;
-    case 1:
+    case AXIS_Y:
         glNormal3f(0, 1, 0);
         glTexCoord2f(0, 0); glVertex3f(0, _offset, 0);
@@ -465 +466 @@
         glTexCoord2f(0, 1); glVertex3f(0, _offset, 1);
         break;
-    case 2:
+    case AXIS_Z:
         glNormal3f(0, 0, 1);
         glTexCoord2f(0, 0); glVertex3f(0, 0, _offset);
@@ -483 +484 @@
 
 void 
-LIC::setVectorField(unsigned int texID, const Vector3f& origin, 
-                      float scaleX, float scaleY, float scaleZ, float max)
-{
-    TRACE("LIC: vector field is assigned [%d]", texID);
-    _vectorFieldId = texID;
-    _origin = origin;
-    _scale = Vector3f(scaleX, scaleY, scaleZ);
-    _max = max;
+LIC::setVectorField(Volume *volume)
+{
+    TRACE("LIC: vector field is assigned [%d]", volume->textureID());
+
+    _vectorFieldId = volume->textureID();
+    Vector3f bmin, bmax;
+    volume->getBounds(bmin, bmax);
+    _origin = bmin;
+    _scale.set(bmax.x-bmin.x, bmax.y-bmin.y, bmax.z-bmin.z);
+    _max = volume->wAxis.max();
 
     makePatterns();
@@ -507 +510 @@
     //TRACE("(xi yi) = (%d %d), ", xi, yi);
    switch (_axis) {
-   case 0:
+   case AXIS_X:
        vx = _sliceVector[4 * (xi+yi*_size)+2];
        vy = _sliceVector[4 * (xi+yi*_size)+1];
        break;
-   case 1:
+   case AXIS_Y:
        vx = _sliceVector[4 * (xi+yi*_size)];
        vy = _sliceVector[4 * (xi+yi*_size)+2];
        break;
-   case 2:
+   case AXIS_Z:
    default:
        vx = _sliceVector[4 * (xi+yi*_size)];
@@ -537 +540 @@
 
 void 
-LIC::setOffset(float offset)
+LIC::setSlicePosition(float offset)
 {
     _offset = offset;
@@ -543 +546 @@
 }
 
-void LIC::setAxis(int axis)
+void LIC::setSliceAxis(FlowSliceAxis axis)
 {
     _axis = axis;

trunk/packages/vizservers/nanovis/LIC.h

@@ -13 +13 @@
 #include <vrmath/Vector3f.h>
 
+#include "FlowTypes.h"
 #include "Volume.h"
 #include "Shader.h"
@@ -21 +22 @@
 { 
 public:
-    LIC(int size, int width, int height, int axis, float offset);
+    LIC(FlowSliceAxis axis = AXIS_Z, float offset = 0.f);
     ~LIC();
 
@@ -30 +31 @@
     void render();
 
-    void makePatterns();
+    void setSlicePosition(float pos);
 
-    void makeMagnitudes();
-
-    void getVelocity(float x, float y, float *px, float *py);
-
-    void getSlice();
-
-    void setOffset(float offset);
+    float getSlicePosition() const
+    {
+        return _offset;
+    }
 
     /** 
      * @brief Specify the perpendicular axis
-     *
-     * 0 : x axis<br>
-     * 1 : y axis<br>
-     * 2 : z axis<br>
      */
-    void setAxis(int axis);
+    void setSliceAxis(FlowSliceAxis axis);
 
-    void setVectorField(unsigned int texID, const vrmath::Vector3f& origin,
-                        float scaleX, float scaleY, float scaleZ, float max);
+    FlowSliceAxis getSliceAxis() const
+    {
+        return _axis;
+    }
+
+    void setVectorField(Volume *volume);
 
     void reset();
@@ -56 +54 @@
     void visible(bool state)
     {
-        _isHidden = !state;
+        _visible = state;
     }
 
     bool visible() const
     {
-        return (!_isHidden);
-    }
-
-    void active(bool state)
-    {
-        _activate = state;
-    }
-
-    bool active() const
-    {
-        return _activate;
+        return _visible;
     }
 
 private:
+    void getVelocity(float x, float y, float *px, float *py);
+
+    void getSlice();
+
+    void makePatterns();
+
+    void makeMagnitudes();
+
     /**
      * @brief the normal vector of the LIC plane, 
@@ -89 +85 @@
                                    plane to fit the actual dimensions */
     vrmath::Vector3f _origin;
-    float _offset;            ///< [0,1] offset of slice plane
-    int _axis;                ///< Axis normal to slice plane
+    float _offset;              ///< [0,1] offset of slice plane
+    FlowSliceAxis _axis;        ///< Axis normal to slice plane
 
     //some convolve variables. They can pretty much stay fixed
@@ -114 +110 @@
      * flag for rendering
      */
-    bool _activate;
-    bool _isHidden;                     // Indicates if LIC plane is displayed.
+    bool _visible;                      // Indicates if LIC plane is displayed.
 };
 

trunk/packages/vizservers/nanovis/Makefile.in

@@ -287 +287 @@
 ContourLineFilter.o: ContourLineFilter.cpp ContourLineFilter.h
 ConvexPolygon.o: ConvexPolygon.cpp ConvexPolygon.h $(VRMATH_DIR)/include/vrmath/Vector4f.h $(VRMATH_DIR)/include/vrmath/Matrix4x4d.h Plane.h
-Flow.o: Flow.cpp Flow.h FlowCmd.h FlowTypes.h FlowBox.h FlowParticles.h Switch.h Trace.h
+Flow.o: Flow.cpp Flow.h FlowCmd.h FlowTypes.h FlowBox.h FlowParticles.h LIC.h VelocityArrowsSlice.h Switch.h Unirect.h Volume.h TransferFunction.h Trace.h
 FlowBox.o: FlowBox.cpp FlowBox.h FlowTypes.h Switch.h Trace.h Volume.h $(VRMATH_DIR)/include/vrmath/Vector3f.h $(VRMATH_DIR)/include/vrmath/Vector4f.h $(VRMATH_DIR)/include/vrmath/Matrix4x4d.h
 FlowCmd.o: FlowCmd.cpp FlowCmd.h FlowParticles.h FlowBox.h FlowTypes.h Command.h PPMWriter.h Switch.h Trace.h TransferFunction.h nanovis.h CmdProc.h LIC.h Unirect.h Volume.h VelocityArrowsSlice.h $(VRMATH_DIR)/include/vrmath/Vector3f.h
@@ -313 +313 @@
 RenderVertexArray.o: RenderVertexArray.cpp RenderVertexArray.h
 Shader.o: Shader.cpp Shader.h
+ShaderGL.o: ShaderGL.cpp ShaderGL.h
 StdVertexShader.o: StdVertexShader.cpp StdVertexShader.h Shader.h
 Switch.o: Switch.cpp Switch.h
@@ -321 +322 @@
 TransferFunction.o: TransferFunction.cpp
 Unirect.o: Unirect.cpp Unirect.h Command.h Trace.h
-VelocityArrowsSlice.o: VelocityArrowsSlice.cpp VelocityArrowsSlice.h
+VelocityArrowsSlice.o: VelocityArrowsSlice.cpp VelocityArrowsSlice.h nanovis.h Camera.h Volume.h Shader.h 
 Volume.o: Volume.cpp Volume.h config.h define.h
 VolumeInterpolator.o: VolumeInterpolator.cpp VolumeInterpolator.h Volume.h

trunk/packages/vizservers/nanovis/OrientationIndicator.cpp

@@ -10 +10 @@
 #include <GL/glu.h>
 
+#include <vrmath/Vector3f.h>
+
 #include "OrientationIndicator.h"
 
+using namespace vrmath;
 using namespace nv;
 
@@ -18 +21 @@
     _visible(true),
     _lineWidth(1.f),
-    _quadric(gluNewQuadric())
+    _quadric(gluNewQuadric()),
+    _position(0,0,0),
+    _scale(1,1,1)
 {
 }
@@ -37 +42 @@
         return;
 
+    glMatrixMode(GL_MODELVIEW);
+    glPushMatrix();
+    glTranslatef(_position.x, _position.y, _position.z);
+    float scale = _scale.x;
+    if (scale == 0 || _scale.y < scale) scale = _scale.y;
+    if (scale == 0 || _scale.z < scale) scale = _scale.z;
+    glScalef(scale, scale, scale);
+
     glPushAttrib(GL_ENABLE_BIT | GL_LINE_BIT);
 
@@ -48 +61 @@
         glLineWidth(_lineWidth);
         glDisable(GL_LIGHTING);
-        glColor3f(1, 0, 0);
-        glBegin(GL_LINES);
-        glVertex3f(0, 0, 0);
-        glVertex3f(0.5f, 0, 0);
-        glEnd();
-        glColor3f(0, 1, 0);
-        glBegin(GL_LINES);
-        glVertex3f(0, 0, 0);
-        glVertex3f(0, 0.5f, 0);
-        glEnd();
-        glColor3f(0, 0, 1);
-        glBegin(GL_LINES);
-        glVertex3f(0, 0, 0);
-        glVertex3f(0, 0, 0.5f);
-        glEnd();
+        if (_scale.x > 0) {
+            glColor3f(1, 0, 0);
+            glBegin(GL_LINES);
+            glVertex3f(0, 0, 0);
+            glVertex3f(0.5f, 0, 0);
+            glEnd();
+        }
+        if (_scale.y > 0) {
+            glColor3f(0, 1, 0);
+            glBegin(GL_LINES);
+            glVertex3f(0, 0, 0);
+            glVertex3f(0, 0.5f, 0);
+            glEnd();
+        }
+        if (_scale.z > 0) {
+            glColor3f(0, 0, 1);
+            glBegin(GL_LINES);
+            glVertex3f(0, 0, 0);
+            glVertex3f(0, 0, 0.5f);
+            glEnd();
+        }
     }
         break;
@@ -72 +91 @@
         glEnable(GL_LIGHTING);
         glEnable(GL_LIGHT0);
+        glEnable(GL_NORMALIZE);
 
         // X
-        glColor3f(1, 0, 0);
-        glPushMatrix();
-        glRotatef(90, 0, 1, 0);
-        gluCylinder(qobj, 0.01, 0.01, 0.3, segments, 1);
-        glPopMatrix();
+        if (_scale.x > 0) {
+            glColor3f(1, 0, 0);
+            glPushMatrix();
+            glRotatef(90, 0, 1, 0);
+            gluCylinder(qobj, 0.01, 0.01, 0.3, segments, 1);
+            glPopMatrix();
 
-        glPushMatrix();
-        glTranslatef(0.3, 0., 0.);
-        glRotatef(90, 0, 1, 0);
-        gluCylinder(qobj, 0.02, 0.0, 0.06, segments, 1);
-        glPopMatrix();
+            glPushMatrix();
+            glTranslatef(0.3, 0., 0.);
+            glRotatef(90, 0, 1, 0);
+            gluCylinder(qobj, 0.02, 0.0, 0.06, segments, 1);
+            glPopMatrix();
+        }
 
         // Y
-        glColor3f(0, 1, 0);
-        glPushMatrix();
-        glRotatef(-90, 1, 0, 0);
-        gluCylinder(qobj, 0.01, 0.01, 0.3, segments, 1);
-        glPopMatrix();
+        if (_scale.y > 0) {
+            glColor3f(0, 1, 0);
+            glPushMatrix();
+            glRotatef(-90, 1, 0, 0);
+            gluCylinder(qobj, 0.01, 0.01, 0.3, segments, 1);
+            glPopMatrix();
 
-        glPushMatrix();
-        glTranslatef(0., 0.3, 0.);
-        glRotatef(-90, 1, 0, 0);
-        gluCylinder(qobj, 0.02, 0.0, 0.06, segments, 1);
-        glPopMatrix();
+            glPushMatrix();
+            glTranslatef(0., 0.3, 0.);
+            glRotatef(-90, 1, 0, 0);
+            gluCylinder(qobj, 0.02, 0.0, 0.06, segments, 1);
+            glPopMatrix();
+        }
 
         // Z
-        glColor3f(0, 0, 1);
-        glPushMatrix();
-        gluCylinder(qobj, 0.01, 0.01, 0.3, segments, 1);
-        glPopMatrix();
+        if (_scale.z > 0) {
+            glColor3f(0, 0, 1);
+            glPushMatrix();
+            gluCylinder(qobj, 0.01, 0.01, 0.3, segments, 1);
+            glPopMatrix();
 
-        glPushMatrix();
-        glTranslatef(0., 0., 0.3);
-        gluCylinder(qobj, 0.02, 0.0, 0.06, segments, 1);
-        glPopMatrix();
+            glPushMatrix();
+            glTranslatef(0., 0., 0.3);
+            gluCylinder(qobj, 0.02, 0.0, 0.06, segments, 1);
+            glPopMatrix();
+        }
     }
         break;
@@ -116 +142 @@
     
     glPopAttrib();
+    glPopMatrix();
 }

trunk/packages/vizservers/nanovis/OrientationIndicator.h

@@ -7 +7 @@
 #ifndef NV_ORIENTATION_INDICATOR_H
 #define NV_ORIENTATION_INDICATOR_H
+
+#include <vrmath/Vector3f.h>
 
 namespace nv {
@@ -35 +37 @@
     }
 
+    void setPosition(const vrmath::Vector3f& pos)
+    {
+        _position = pos;
+    }
+
+    void setScale(const vrmath::Vector3f& scale)
+    {
+        _scale = scale;
+    }
+
 private:
     Representation _rep;
@@ -40 +52 @@
     float _lineWidth;
     void *_quadric;
+
+    vrmath::Vector3f _position;
+    vrmath::Vector3f _scale;
 };
 

trunk/packages/vizservers/nanovis/ParticleAdvectionShader.cpp

@@ -12 +12 @@
     _scale(1.0f, 1.0f, 1.0f), 
     _max(1.0f), 
-    _timeStep(0.0005f),
-    _mode(1)
+    _timeStep(0.0005f)
 {
     init();
@@ -24 +23 @@
 void ParticleAdvectionShader::init()
 {
-    loadFragmentProgram("update_pos.cg", "main");
+    loadFragmentProgram("update_pos.cg");
 }
 
 void 
-ParticleAdvectionShader::bind(unsigned int texID, unsigned int initPosTexID)
+ParticleAdvectionShader::bind(unsigned int texID, unsigned int initPosTexID, bool init)
 {
     setFPTextureParameter("pos_tex", texID);
@@ -35 +34 @@
 
     setFPParameter1f("timestep", _timeStep);
-    setFPParameter1f("max", _max);
-    setFPParameter1f("mode", _mode);
+    setFPParameter1f("max", init ? 0 : _max);
     setFPParameter3f("scale", _scale.x, _scale.y, _scale.z);
 

trunk/packages/vizservers/nanovis/ParticleAdvectionShader.h

@@ -20 +20 @@
     virtual ~ParticleAdvectionShader();
 
-    virtual void bind(unsigned int texID, unsigned int initPosTexID);
+    virtual void bind(unsigned int texID, unsigned int initPosTexID, bool init);
 
     virtual void unbind();

trunk/packages/vizservers/nanovis/ParticleRenderer.cpp

@@ -13 +13 @@
 #include <GL/glew.h>
 
+#include <vrmath/Vector3f.h>
 #include <vrmath/Color4f.h>
 
 #include "ParticleRenderer.h"
+#include "Volume.h"
 #include "define.h"
 #include "Trace.h"
 
+using namespace vrmath;
 using namespace nv;
-
-ParticleAdvectionShader *ParticleRenderer::_advectionShader = NULL;
-ParticleAdvectionShaderInstance shaderInstance;
 
 ParticleRenderer::ParticleRenderer(int w, int h) :
@@ -37 +37 @@
     _activate(false),
     _slicePos(0.0),
-    _sliceAxis(0),
+    _sliceAxis(AXIS_Z),
     _color(0.2, 0.2, 1.0, 1.0),
     _psysWidth(w),
@@ -43 +43 @@
 {
     _data = new Particle[w * h];
-    memset(_data, 0, sizeof(Particle) * w * h);
 
     _vertexArray = new RenderVertexArray(_psysWidth * _psysHeight, 3, GL_FLOAT);
@@ -104 +103 @@
 #endif
 
-    if (_advectionShader == NULL) {
-        _advectionShader = new ParticleAdvectionShader();
-    }
+    _advectionShader = new ParticleAdvectionShader();
 }
 
@@ -121 +118 @@
     glDeleteFramebuffersEXT(2, _psysFbo);
 
+    delete _advectionShader;
     delete _vertexArray;
     delete [] _data;
@@ -128 +126 @@
 ParticleRenderer::initializeDataArray()
 {
-    size_t n = _psysWidth * _psysHeight * 4;
-    memset(_data, 0, sizeof(float)* n);
-
-    int index;
-    bool particle;
-    float *p = (float *)_data;
+    TRACE("Enter axis: %d pos: %g", _sliceAxis, _slicePos);
+
+    memset(_data, 0, sizeof(Particle) * _psysWidth * _psysHeight);
+ 
+    bool hasParticle;
     for (int i = 0; i < _psysWidth; i++) {
         for (int j = 0; j < _psysHeight; j++) {
-            index = i + _psysHeight*j;
-            particle = (rand() % 256) > 150;
-            if (particle) {
+            Particle *p = &_data[i + _psysHeight*j];
+            hasParticle = (rand() % 256) > 150;
+             if (hasParticle) {
                 //assign any location (x,y,z) in range [0,1]
                 switch (_sliceAxis) {
-                case 0:
-                    p[4*index]   = _slicePos;
-                    p[4*index+1] = j/float(_psysHeight);
-                    p[4*index+2] = i/float(_psysWidth);
+                case AXIS_X:
+                    p->x = _slicePos;
+                    p->y = j/float(_psysHeight);
+                    p->z = i/float(_psysWidth);
                     break;
-                case 1:
-                    p[4*index]   = j/float(_psysHeight);
-                    p[4*index+1] = _slicePos;
-                    p[4*index+2] = i/float(_psysWidth);
+                case AXIS_Y:
+                    p->x = j/float(_psysHeight);
+                    p->y = _slicePos;
+                    p->z = i/float(_psysWidth);
                     break;
-                case 2:
-                    p[4*index]   = j/float(_psysHeight);
-                    p[4*index+1] = i/float(_psysWidth);
-                    p[4*index+2] = _slicePos;
+                case AXIS_Z:
+                    p->x = j/float(_psysHeight);
+                    p->y = i/float(_psysWidth);
+                    p->z = _slicePos;
                     break;
                 default:
-                    p[4*index]   = 0;
-                    p[4*index+1] = 0;
-                    p[4*index+2] = 0;
-                    p[4*index+3] = 0;
+                    ERROR("Unknown axis");
                 }
-
                 //shorter life span, quicker iterations
-                p[4*index+3] = rand() / ((float) RAND_MAX) * 0.5  + 0.5f; 
-            } else {
-                p[4*index]   = 0;
-                p[4*index+1] = 0;
-                p[4*index+2] = 0;
-                p[4*index+3] = 0;
+                p->life = rand() / ((float) RAND_MAX) * 0.5  + 0.5f; 
             }
         }
@@ -178 +166 @@
 ParticleRenderer::initialize()
 {
+    TRACE("Enter");
+
     initializeDataArray();
 
@@ -192 +182 @@
     _flip = true;
     _reborn = false;
+    _psysFrame = 0;
 
     glBindTexture(GL_TEXTURE_RECTANGLE_ARB, _initPosTex);
@@ -226 +217 @@
 ParticleRenderer::advect()
 {
+    TRACE("Enter");
+
     if (_reborn) 
         reset();
@@ -256 +249 @@
     glPushMatrix();
     glLoadIdentity();
-    //gluOrtho2D(0, _psysWidth, 0, _psysHeight);
     glOrtho(0, _psysWidth, 0, _psysHeight, -10.0f, 10.0f);
     glMatrixMode(GL_MODELVIEW);
@@ -262 +254 @@
     glLoadIdentity();
 
-    _advectionShader->bind(_psysTex[tex], _initPosTex);
+    _advectionShader->bind(_psysTex[tex], _initPosTex, _psysFrame == 0);
 
     draw_quad(_psysWidth, _psysHeight, _psysWidth, _psysHeight);
@@ -282 +274 @@
     _psysFrame++;
     if (_psysFrame == _maxLife) {
-        _psysFrame = 0;
-        // _reborn = true;
+        //_psysFrame = 0;
+        //_reborn = true;
     }
     glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboOrig);
@@ -294 +286 @@
 {
     _vertexArray->read(_psysWidth, _psysHeight);
-
-    //_vertexArray->loadData(vert);     //does not work??
-    //assert(glGetError()==0);
 }
 
@@ -302 +291 @@
 ParticleRenderer::render()
 {
+    if (_psysFrame == 0) {
+        TRACE("Initializing vertex array");
+        advect();
+    }
+
     glPushAttrib(GL_ENABLE_BIT);
     glDisable(GL_TEXTURE_2D);
@@ -328 +322 @@
 
 void 
-ParticleRenderer::setVectorField(unsigned int texID, const vrmath::Vector3f& origin, 
-                                 float scaleX, float scaleY, float scaleZ, 
-                                 float max)
-{
-    _origin = origin;
-    _scale.set(scaleX, scaleY, scaleZ);
+ParticleRenderer::setVectorField(Volume *volume)
+{
+    Vector3f bmin, bmax;
+    volume->getBounds(bmin, bmax);
+    _origin = bmin;
+    Vector3f scale(bmax.x-bmin.x, bmax.y-bmin.y, bmax.z-bmin.z);
+    _scale.set(scale.x, scale.y, scale.z);
     _advectionShader->setScale(_scale);
-    _advectionShader->setVelocityVolume(texID, max);
-}
-
-void
-ParticleRenderer::setAxis(int axis)
-{
-    _sliceAxis = axis;
-    initializeDataArray();
+    _advectionShader->setVelocityVolume(volume->textureID(),
+                                        volume->wAxis.max());
+}
+
+void
+ParticleRenderer::setAxis(FlowSliceAxis axis)
+{
+    if (axis != _sliceAxis) {
+        _sliceAxis = axis;
+        initialize();
+    }
 }
 
@@ -348 +346 @@
 ParticleRenderer::setPos(float pos)
 {
-    _slicePos = pos;
-    initializeDataArray();
-}
+    if (pos != _slicePos) {
+        _slicePos = pos;
+        initialize();
+    }
+}

trunk/packages/vizservers/nanovis/ParticleRenderer.h

@@ -14 +14 @@
 #include <vrmath/Color4f.h>
 
+#include "FlowTypes.h"
+#include "Volume.h"
 #include "ParticleAdvectionShader.h"
 #include "RenderVertexArray.h"
@@ -23 +25 @@
     float y;
     float z;
-    float aux;
+    float life;
 
     Particle()
@@ -29 +31 @@
 
     Particle(float _x, float _y, float _z, float _life) :
-        x(_x), y(_y), z(_z), aux(_life)
+        x(_x),
+        y(_y),
+        z(_z),
+        life(_life)
     {}
 };
@@ -40 +45 @@
     ~ParticleRenderer();
 
-    void setVectorField(unsigned int texID, const vrmath::Vector3f& origin,
-                        float scaleX, float scaleY, float scaleZ, float max);
+    void setVectorField(Volume *volume);
 
     void initialize();
 
     void advect();
-
-    void updateVertexBuffer();
 
     void reset();
@@ -68 +70 @@
     }
 
-    void setAxis(int axis);
+    void setAxis(FlowSliceAxis axis);
+
+    FlowSliceAxis getAxis() const
+    {
+        return _sliceAxis;
+    }
 
     void setPos(float pos);
 
-    void initializeDataArray();
+    float getPos() const
+    {
+        return _slicePos;
+    }
 
     void particleSize(float size)
@@ -84 +94 @@
     }
 
-   static ParticleAdvectionShader *_advectionShader;
+private:
+    void initializeDataArray();
 
-private:
+    void updateVertexBuffer();
+
+    ParticleAdvectionShader *_advectionShader;
+
     /// frame buffer objects: two are defined, flip them as input output every step
     GLuint _psysFbo[2];
@@ -96 +110 @@
 
     /// Count the frame number of particle system iteration
-    int _psysFrame;
+    unsigned int _psysFrame;
 
     /// Reinitiate particles
@@ -120 +134 @@
 
     float _slicePos;
-    int _sliceAxis;
+    FlowSliceAxis _sliceAxis;
 
     vrmath::Color4f _color;
@@ -129 +143 @@
 };
 
-class ParticleAdvectionShaderInstance
-{
-public :
-    ParticleAdvectionShaderInstance()
-    {}
-
-    ~ParticleAdvectionShaderInstance()
-    {
-        if (ParticleRenderer::_advectionShader) {
-            delete ParticleRenderer::_advectionShader;
-        }
-    }
-};
-
 }
 

trunk/packages/vizservers/nanovis/PointShader.cpp

@@ -13 +13 @@
     _normal(NULL)
 {
-    loadVertexProgram("pointsvp.cg", "main");
+    loadVertexProgram("pointsvp.cg");
 }
 
@@ -22 +22 @@
 void PointShader::bind()
 {
-    setGLStateMatrixVPParameter("modelview", MODELVIEW_MATRIX, MATRIX_IDENTITY);
-    setGLStateMatrixVPParameter("projection", PROJECTION_MATRIX, MATRIX_IDENTITY);
+    setGLStateMatrixVPParameter("modelView", MODELVIEW_MATRIX, MATRIX_IDENTITY);
+    setGLStateMatrixVPParameter("modelViewProj", MODELVIEW_PROJECTION_MATRIX, MATRIX_IDENTITY);
 
     setVPParameter1f("atten", 1.0f);

trunk/packages/vizservers/nanovis/RegularVolumeShader.cpp

@@ -19 +19 @@
 void RegularVolumeShader::init()
 {
-    loadFragmentProgram("one_volume.cg", "main");
+    loadFragmentProgram("one_volume.cg");
 }
 
 void RegularVolumeShader::bind(unsigned int tfID, Volume *volume,
-                                 int sliceMode, float sampleRatio)
+                               int sliceMode, float sampleRatio)
 {
     //regular cubic volume
-    setGLStateMatrixFPParameter("modelViewInv", MODELVIEW_MATRIX,
-                                MATRIX_INVERSE);
-    setGLStateMatrixFPParameter("modelView", MODELVIEW_MATRIX,
-                                MATRIX_IDENTITY);
-
     setFPTextureParameter("volume", volume->textureID());
     setFPTextureParameter("tf", tfID);

trunk/packages/vizservers/nanovis/RenderVertexArray.h

@@ -23 +23 @@
     void loadData(void *data);  // load vertex data from memory
 
-    void read(/*GLenum buffer,*/ int w, int h);   // read vertex data from
-                                                  // frame buffer
+    void read(int w, int h);   // read vertex data from frame buffer
+
     void setPointer(GLuint index);
 

trunk/packages/vizservers/nanovis/Shader.cpp

@@ -22 +22 @@
 CGcontext Shader::_cgContext = NULL;
 
-void Shader::initCg(CGprofile defaultVertexProfile,
-                    CGprofile defaultFragmentProfile)
+void Shader::init()
 {
-    _defaultVertexProfile = defaultVertexProfile;
-    _defaultFragmentProfile = defaultFragmentProfile;
     _cgContext = cgCreateContext();
 }
 
-void Shader::exitCg()
+void Shader::exit()
 {
     setErrorCallback(NULL);
@@ -94 +91 @@
 }
 
-void Shader::loadVertexProgram(const char *fileName, const char *entryPoint)
+void Shader::loadVertexProgram(const char *fileName)
 {
     if (_cgVP != NULL) {
@@ -100 +97 @@
     }
     _cgVP = loadCgSourceProgram(_cgContext, fileName,
-                                _vertexProfile, entryPoint);
+                                _vertexProfile, "main");
     _vpFile = fileName;
 }
 
-void Shader::loadFragmentProgram(const char *fileName, const char *entryPoint)
+void Shader::loadFragmentProgram(const char *fileName)
 {
     if (_cgFP != NULL) {
@@ -110 +107 @@
     }
     _cgFP = loadCgSourceProgram(_cgContext, fileName,
-                                _fragmentProfile, entryPoint);
+                                _fragmentProfile, "main");
     _fpFile = fileName;
 }
@@ -127 +124 @@
 }
 
-void Shader::setErrorCallback(CgCallbackFunction callback)
+void Shader::setErrorCallback(ShaderCallbackFunction callback)
 {
     TRACE("Shader setting error callback to: %p", callback);

trunk/packages/vizservers/nanovis/Shader.h

@@ -31 +31 @@
     };
 
-    typedef void CgCallbackFunction(void);
+    typedef void (*ShaderCallbackFunction)(void);
 
     Shader();
@@ -38 +38 @@
 
     /**
-     * @brief create a Cg vertex program and load it
-     * @param fileName the name of Cg program file
-     * @param entryPoint a entry point of the Cg program
+     * \brief Load and compile a vertex shader
+     * \param fileName the name of the shader source file
      */
-    void loadVertexProgram(const char *fileName, const char *entryPoint);
+    void loadVertexProgram(const char *fileName);
 
     /**
-     * @brief create a Cg fragment program and load it
-     * @param fileName the name of Cg program file
-     * @param entryPoint a entry point of the Cg program
+     * \brief Load and compile a fragment shader
+     * \param fileName the name of the shader source file
      */
-    void loadFragmentProgram(const char *fileName, const char *entryPoint);
-
-    CGparameter getNamedParameterFromFP(const char *paramName)
-    {
-        if (_cgFP) {
-            return cgGetNamedParameter(_cgFP, paramName);
-        }
-        ERROR("Unknown fragment program parameter: %s", paramName);
-        return 0;
-    }
-
-    CGparameter getNamedParameterFromVP(const char *paramName)
-    {
-        if (_cgVP) {
-            return cgGetNamedParameter(_cgVP, paramName);
-        }
-        ERROR("Unknown vertex program parameter: %s", paramName);
-        return 0;
-    }
+    void loadFragmentProgram(const char *fileName);
 
     void setVPParameter1f(const char *name, float val)
     {
-        CGparameter param = getVPParam(name);
+        Parameter param = getVPParam(name);
         if (param == NULL)
             return;
@@ -79 +59 @@
     void setFPParameter1f(const char *name, float val)
     {
-        CGparameter param = getFPParam(name);
+        Parameter param = getFPParam(name);
         if (param == NULL)
             return;
@@ -87 +67 @@
     void setVPParameter2f(const char *name, float val1, float val2)
     {
-        CGparameter param = getVPParam(name);
+        Parameter param = getVPParam(name);
         if (param == NULL)
             return;
@@ -95 +75 @@
     void setFPParameter2f(const char *name, float val1, float val2)
     {
-        CGparameter param = getFPParam(name);
+        Parameter param = getFPParam(name);
         if (param == NULL)
             return;
@@ -103 +83 @@
     void setVPParameter3f(const char *name, float val1, float val2, float val3)
     {
-        CGparameter param = getVPParam(name);
+        Parameter param = getVPParam(name);
         if (param == NULL)
             return;
@@ -111 +91 @@
     void setFPParameter3f(const char *name, float val1, float val2, float val3)
     {
-        CGparameter param = getFPParam(name);
+        Parameter param = getFPParam(name);
         if (param == NULL)
             return;
@@ -119 +99 @@
     void setVPParameter4f(const char *name, float val1, float val2, float val3, float val4)
     {
-        CGparameter param = getVPParam(name);
+        Parameter param = getVPParam(name);
         if (param == NULL)
             return;
@@ -127 +107 @@
     void setFPParameter4f(const char *name, float val1, float val2, float val3, float val4)
     {
-        CGparameter param = getFPParam(name);
+        Parameter param = getFPParam(name);
         if (param == NULL)
             return;
@@ -135 +115 @@
     void setVPMatrixParameterf(const char *name, float *mat)
     {
-        CGparameter param = getVPParam(name);
+        Parameter param = getVPParam(name);
         if (param == NULL)
             return;
@@ -143 +123 @@
     void setFPMatrixParameterf(const char *name, float *mat)
     {
-        CGparameter param = getFPParam(name);
+        Parameter param = getFPParam(name);
         if (param == NULL)
             return;
@@ -151 +131 @@
     void setVPTextureParameter(const char *name, GLuint texobj, bool enable = true)
     {
-        CGparameter param = getVPParam(name);
+        Parameter param = getVPParam(name);
         if (param == NULL)
             return;
@@ -161 +141 @@
     void setFPTextureParameter(const char *name, GLuint texobj, bool enable = true)
     {
-        CGparameter param = getFPParam(name);
+        Parameter param = getFPParam(name);
         if (param == NULL)
             return;
@@ -171 +151 @@
     void enableVPTextureParameter(const char *name)
     {
-        CGparameter param = getVPParam(name);
+        Parameter param = getVPParam(name);
         if (param == NULL)
             return;
@@ -179 +159 @@
     void enaableFPTextureParameter(const char *name)
     {
-        CGparameter param = getFPParam(name);
+        Parameter param = getFPParam(name);
         if (param == NULL)
             return;
@@ -187 +167 @@
     void disableVPTextureParameter(const char *name)
     {
-        CGparameter param = getVPParam(name);
+        Parameter param = getVPParam(name);
         if (param == NULL)
             return;
@@ -195 +175 @@
     void disableFPTextureParameter(const char *name)
     {
-        CGparameter param = getFPParam(name);
+        Parameter param = getFPParam(name);
         if (param == NULL)
             return;
@@ -204 +184 @@
                                      GLMatrixType type = MATRIX_IDENTITY)
     {
-        CGparameter param = getVPParam(name);
+        Parameter param = getVPParam(name);
         if (param == NULL)
             return;
@@ -213 +193 @@
                                      GLMatrixType type = MATRIX_IDENTITY)
     {
-        CGparameter param = getFPParam(name);
+        Parameter param = getFPParam(name);
         if (param == NULL)
             return;
@@ -239 +219 @@
     }
 
-    void enableVertexProfile()
-    {
-        cgGLEnableProfile(_vertexProfile);
-    }
-
-    void disableVertexProfile()
-    {
-        cgGLDisableProfile(_vertexProfile);
-    }
-
-    void enableFragmentProfile()
-    {
-        cgGLEnableProfile(_fragmentProfile);
-    }
-
-    void disableFragmentProfile()
-    {
-        cgGLDisableProfile(_fragmentProfile);
-    }
-
-    static void initCg(CGprofile defaultVertexProfile = CG_PROFILE_VP40,
-                       CGprofile defaultFragmentProfile = CG_PROFILE_FP40);
-
-    static void exitCg();
+    static void init();
+
+    static void exit();
 
     static bool printErrorInfo();
 
-    static void setErrorCallback(CgCallbackFunction callback);
-
-    static CGcontext getCgContext()
-    {
-        return _cgContext;
-    }
-
-protected:
-    typedef std::tr1::unordered_map<std::string, CGparameter> ParameterHashmap;
-
-    CGprogram getVP()
-    {
-        return _cgVP;
-    }
-
-    CGprogram getFP()
-    {
-        return _cgFP;
-    }
-
-    CGparameter getVPParam(const char *name)
-    {
-        CGparameter param;
+    static void setErrorCallback(ShaderCallbackFunction callback);
+
+private:
+    typedef CGparameter Parameter;
+    typedef std::tr1::unordered_map<std::string, Parameter> ParameterHashmap;
+
+    Parameter getNamedParameterFromFP(const char *paramName)
+    {
+        if (_cgFP) {
+            return cgGetNamedParameter(_cgFP, paramName);
+        }
+        ERROR("Unknown fragment program parameter: %s", paramName);
+        return 0;
+    }
+
+    Parameter getNamedParameterFromVP(const char *paramName)
+    {
+        if (_cgVP) {
+            return cgGetNamedParameter(_cgVP, paramName);
+        }
+        ERROR("Unknown vertex program parameter: %s", paramName);
+        return 0;
+    }
+
+    Parameter getVPParam(const char *name)
+    {
+        Parameter param;
         ParameterHashmap::iterator itr = _vpParams.find(name);
         if (itr == _vpParams.end()) {
@@ -302 +265 @@
     }
 
-    CGparameter getFPParam(const char *name)
-    {
-        CGparameter param;
+    Parameter getFPParam(const char *name)
+    {
+        Parameter param;
         ParameterHashmap::iterator itr = _fpParams.find(name);
         if (itr == _fpParams.end()) {
@@ -318 +281 @@
     }
 
+
     void resetPrograms();
+
+
+    CGprogram getVP()
+    {
+        return _cgVP;
+    }
+
+    CGprogram getFP()
+    {
+        return _cgFP;
+    }
+
+    void enableVertexProfile()
+    {
+        cgGLEnableProfile(_vertexProfile);
+    }
+
+    void disableVertexProfile()
+    {
+        cgGLDisableProfile(_vertexProfile);
+    }
+
+    void enableFragmentProfile()
+    {
+        cgGLEnableProfile(_fragmentProfile);
+    }
+
+    void disableFragmentProfile()
+    {
+        cgGLDisableProfile(_fragmentProfile);
+    }
+
+    static CGcontext getCgContext()
+    {
+        return _cgContext;
+    }
+
+    std::string _vpFile;
+    std::string _fpFile;
+
+    ParameterHashmap _vpParams;
+    ParameterHashmap _fpParams;
 
     CGprofile _vertexProfile;
     CGprofile _fragmentProfile;
-    std::string _vpFile;
+
     CGprogram _cgVP;
-    std::string _fpFile;
     CGprogram _cgFP;
-    ParameterHashmap _vpParams;
-    ParameterHashmap _fpParams;
 
     static CGprofile _defaultVertexProfile;
@@ -333 +336 @@
     static CGcontext _cgContext;
 
-private:
     static CGprogram
     loadCgSourceProgram(CGcontext context, const char *filename, 

trunk/packages/vizservers/nanovis/StdVertexShader.cpp

@@ -4 +4 @@
  *
  */
+#include <vrmath/Vector4f.h>
+
 #include "StdVertexShader.h"
 
+using namespace vrmath;
 using namespace nv;
 
@@ -19 +22 @@
 void StdVertexShader::init()
 {
-    loadVertexProgram("vertex_std.cg", "main");
+    loadVertexProgram("vertex_std.cg");
 }
 
-void StdVertexShader::bind(float *mvp, float *mvInv)
+void StdVertexShader::bind(const Vector4f& objPlaneS,
+                           const Vector4f& objPlaneT,
+                           const Vector4f& objPlaneR,
+                           float *mvp, float *mvInv)
 {
     if (mvp != NULL) {
         setVPMatrixParameterf("modelViewProjMatrix", mvp);
     } else {
-        setGLStateMatrixVPParameter("modelViewProjMatrix", MODELVIEW_PROJECTION_MATRIX);
+        setGLStateMatrixVPParameter("modelViewProjMatrix",
+                                    MODELVIEW_PROJECTION_MATRIX);
     }
     if (mvInv != NULL) {
         setVPMatrixParameterf("modelViewInv", mvInv);
     } else {
-        setGLStateMatrixVPParameter("modelViewInv", MODELVIEW_MATRIX, MATRIX_INVERSE);
+        setGLStateMatrixVPParameter("modelViewInv",
+                                    MODELVIEW_MATRIX, MATRIX_INVERSE);
     }
+
+    setVPParameter4f("light0Position", 1, 1, 1, 1);
+    setVPParameter4f("objPlaneS",
+                     objPlaneS.x, objPlaneS.y, objPlaneS.z, objPlaneS.w);
+    setVPParameter4f("objPlaneT",
+                     objPlaneT.x, objPlaneT.y, objPlaneT.z, objPlaneT.w);
+    setVPParameter4f("objPlaneR",
+                     objPlaneR.x, objPlaneR.y, objPlaneR.z, objPlaneR.w);
 
     Shader::bind();

trunk/packages/vizservers/nanovis/StdVertexShader.h

@@ -6 +6 @@
 #ifndef NV_STD_VERTEX_SHADER_H
 #define NV_STD_VERTEX_SHADER_H
+
+#include <vrmath/Vector4f.h>
 
 #include "Shader.h"
@@ -18 +20 @@
     virtual ~StdVertexShader();
 
-    virtual void bind(float *mvp = NULL, float *mvInv = NULL);
+    virtual void bind(const vrmath::Vector4f& objPlaneS,
+                      const vrmath::Vector4f& objPlaneT,
+                      const vrmath::Vector4f& objPlaneR,
+                      float *mvp = NULL, float *mvInv = NULL);
 
     virtual void unbind()

trunk/packages/vizservers/nanovis/Unirect.h

@@ -13 +13 @@
 
 #include <rappture.h>
+
+#include <vrmath/Vector3f.h>
 
 #include "Trace.h"
@@ -197 +199 @@
     }
 
+    void getBounds(vrmath::Vector3f& bboxMin,
+                   vrmath::Vector3f& bboxMax) const
+    {
+        bboxMin.set(_xMin, _yMin, _zMin);
+        bboxMax.set(_xMax, _yMax, _zMax);
+    }
+
     const float *SaveValues()
     {
@@ -352 +361 @@
     }
 
+    void getBounds(vrmath::Vector3f& bboxMin,
+                   vrmath::Vector3f& bboxMax) const
+    {
+        bboxMin.set(_xMin, _yMin, 0);
+        bboxMax.set(_xMax, _yMax, 0);
+    }
+
     float *transferValues()
     {

trunk/packages/vizservers/nanovis/VelocityArrowsSlice.cpp

@@ -19 +19 @@
 #include "nanovis.h"
 #include "VelocityArrowsSlice.h"
+#include "Volume.h"
 #include "Shader.h"
 #include "Camera.h"
@@ -38 +39 @@
 VelocityArrowsSlice::VelocityArrowsSlice() :
     _vectorFieldGraphicsID(0),
-    _vfXscale(0),
-    _vfYscale(0),
-    _vfZscale(0),
     _slicePos(0.5f),
-    _axis(2),
+    _axis(AXIS_Z),
     _fbo(0),
     _tex(0),
@@ -57 +55 @@
     _maxVelocityScale(1, 1, 1),
     _arrowColor(1, 1, 0),
-    _enabled(false),
+    _visible(false),
     _dirty(true),
     _vertexBufferGraphicsID(0),
@@ -63 +61 @@
     _renderMode(LINES)
 {
-    axis(2);
-
-    _queryVelocityFP.loadFragmentProgram("queryvelocity.cg", "main");
-
-    _particleShader.loadVertexProgram("velocityslicevp.cg", "vpmain");
-    _particleShader.loadFragmentProgram("velocityslicefp.cg", "fpmain");
+    setSliceAxis(AXIS_Z);
+
+    _queryVelocityFP.loadFragmentProgram("queryvelocity.cg");
+
+    _particleShader.loadVertexProgram("velocityslicevp.cg");
+    _particleShader.loadFragmentProgram("velocityslicefp.cg");
 
     createRenderTarget();
@@ -175 +173 @@
 }
 
-void VelocityArrowsSlice::axis(int axis)
+void VelocityArrowsSlice::setSliceAxis(FlowSliceAxis axis)
 {
     _axis = axis;
     switch (_axis) {
-    case 0:
+    case AXIS_X:
         _projectionVector.x = 0;
         _projectionVector.y = 1;
         _projectionVector.z = 1;
         break;
-    case 1 :
+    case AXIS_Y:
         _projectionVector.x = 1;
         _projectionVector.y = 0;
         _projectionVector.z = 1;
         break;
-    case 2:
+    case AXIS_Z:
         _projectionVector.x = 1;
         _projectionVector.y = 1;
@@ -200 +198 @@
 void VelocityArrowsSlice::queryVelocity()
 {
-    if (!_enabled) return;
-
     glPushAttrib(GL_VIEWPORT_BIT | GL_ENABLE_BIT);
     int fboOrig;
@@ -301 +297 @@
 void VelocityArrowsSlice::render()
 {
-    if (!_enabled)
+    if (!_visible)
         return;
 
@@ -310 +306 @@
     }
 
-    TRACE("_vf: %g %g %g", _vfXscale,_vfYscale, _vfZscale);
+    TRACE("_scale: %g %g %g", _scale.x, _scale.y, _scale.z);
     TRACE("_maxVelocityScale: %g %g %g",
           _maxVelocityScale.x, _maxVelocityScale.y, _maxVelocityScale.z);
@@ -319 +315 @@
     glPushMatrix();
 
-    glScalef(_vfXscale,_vfYscale, _vfZscale);
-    glTranslatef(-0.5f, -0.5f, -0.5f);
+    glTranslatef(_origin.x, _origin.y, _origin.z);
+    glScalef(_scale.x, _scale.y, _scale.z);
 
     if (_renderMode == LINES) {
@@ -422 +418 @@
         _particleShader.setFPTextureParameter("arrows", _arrowsTex->id());
         _particleShader.setVPParameter1f("tanHalfFOV",
-                                         tan(NanoVis::getCamera()->fov() * 0.5) * NanoVis::winHeight * 0.5);
+                                         tan(NanoVis::getCamera()->getFov() * 0.5) * NanoVis::winHeight * 0.5);
         _particleShader.setGLStateMatrixVPParameter("modelview",
                                                     Shader::MODELVIEW_MATRIX,
@@ -457 +453 @@
 
 void 
-VelocityArrowsSlice::setVectorField(unsigned int vfGraphicsID, const Vector3f& origin,
-                                    float xScale, float yScale, float zScale, float max)
-{
-    _vectorFieldGraphicsID = vfGraphicsID;
-    _vfXscale = xScale;
-    _vfYscale = yScale;
-    _vfZscale = zScale;
+VelocityArrowsSlice::setVectorField(Volume *volume)
+{
+    _vectorFieldGraphicsID = volume->textureID();
+    Vector3f bmin, bmax;
+    volume->getBounds(bmin, bmax);
+    _origin = bmin;
+    _scale.set(bmax.x-bmin.x, bmax.y-bmin.y, bmax.z-bmin.z);
 
     _dirty = true;
@@ -470 +466 @@
 void VelocityArrowsSlice::computeSamplingTicks()
 {
-    if (_vfXscale < _vfYscale) {
-        if (_vfXscale < _vfZscale || _vfZscale == 0.0) {
-            // vfXscale
+    if (_scale.x < _scale.y) {
+        if (_scale.x < _scale.z || _scale.z == 0.0) {
+            // _scale.x
             _tickCountX = _tickCountForMinSizeAxis;
 
-            float step = _vfXscale / (_tickCountX + 1);
-
-            _tickCountY = (int)(_vfYscale/step);
-            _tickCountZ = (int)(_vfZscale/step);
+            float step = _scale.x / (_tickCountX + 1);
+            _tickCountY = (int)(_scale.y/step);
+            _tickCountZ = (int)(_scale.z/step);
         } else {
-            // vfZscale
+            // _scale.z
             _tickCountZ = _tickCountForMinSizeAxis;
 
-            float step = _vfZscale / (_tickCountZ + 1);
-            _tickCountX = (int)(_vfXscale/step);
-            _tickCountY = (int)(_vfYscale/step);
+            float step = _scale.z / (_tickCountZ + 1);
+            _tickCountX = (int)(_scale.x/step);
+            _tickCountY = (int)(_scale.y/step);
         }
     } else {
-        if (_vfYscale < _vfZscale || _vfZscale == 0.0) {
-            // _vfYscale
+        if (_scale.y < _scale.z || _scale.z == 0.0) {
+            // _scale.y
             _tickCountY = _tickCountForMinSizeAxis;
 
-            float step = _vfYscale / (_tickCountY + 1);
-            _tickCountX = (int)(_vfXscale/step);
-            _tickCountZ = (int)(_vfZscale/step);
+            float step = _scale.y / (_tickCountY + 1);
+            _tickCountX = (int)(_scale.x/step);
+            _tickCountZ = (int)(_scale.z/step);
         } else {
-            // vfZscale
+            // _scale.z
             _tickCountZ = _tickCountForMinSizeAxis;
 
-            float step = _vfZscale / (_tickCountZ + 1);
-            _tickCountX = (int)(_vfXscale/step);
-            _tickCountY = (int)(_vfYscale/step);
+            float step = _scale.z / (_tickCountZ + 1);
+            _tickCountX = (int)(_scale.x/step);
+            _tickCountY = (int)(_scale.y/step);
         }
     }

trunk/packages/vizservers/nanovis/VelocityArrowsSlice.h

@@ -11 +11 @@
 #include <vrmath/Vector3f.h>
 
+#include "FlowTypes.h"
+#include "Volume.h"
 #include "Texture2D.h"
 #include "Shader.h"
@@ -28 +30 @@
     ~VelocityArrowsSlice();
 
-    void setVectorField(unsigned int vfGraphicsID, const vrmath::Vector3f& origin,
-                        float xScale, float yScale, float zScale, float max);
+    void setVectorField(Volume *volume);
 
-    void axis(int axis);
+    void setSliceAxis(FlowSliceAxis axis);
 
-    int axis() const
+    int getSliceAxis() const
     {
         return _axis;
     }
 
-    void slicePos(float pos)
+    void setSlicePosition(float pos)
     {
         _slicePos = pos;
@@ -44 +45 @@
     }
 
-    float slicePos() const
+    float getSlicePosition() const
     {
         return _slicePos;
     }
 
-    void queryVelocity();
-
     void render();
 
-    void enabled(bool enabled)
+    void visible(bool visible)
     {
-        _enabled = enabled;
+        _visible = visible;
     }
 
-    bool enabled() const
+    bool visible() const
     {
-        return _enabled;
+        return _visible;
     }
 
@@ -90 +89 @@
 
 private:
+    void queryVelocity();
+
     void createRenderTarget();
 
@@ -95 +96 @@
 
     unsigned int _vectorFieldGraphicsID;
-    float _vfXscale;
-    float _vfYscale;
-    float _vfZscale;
+    vrmath::Vector3f _origin;
+    vrmath::Vector3f _scale;
+
     float _slicePos;
-    int _axis;
+    FlowSliceAxis _axis;
 
     unsigned int _fbo;
@@ -124 +125 @@
     vrmath::Vector3f _arrowColor;
 
-    bool _enabled;
+    bool _visible;
     bool _dirty;
     bool _dirtySamplingPosition;

trunk/packages/vizservers/nanovis/Volume.cpp

@@ -31 +31 @@
 double Volume::valueMax = 1.0;
 
-Volume::Volume(float x, float y, float z,
-               int w, int h, int d,
+Volume::Volume(int w, int h, int d,
                int n, float *data,
                double v0, double v1, double nonZeroMin) :
@@ -50 +49 @@
     _nonZeroMin(nonZeroMin),
     _tex(NULL),
-    _location(x, y, z),
+    _position(0,0,0),
+    _scale(1,1,1),
     _numSlices(512),
     _enabled(true),
@@ -65 +65 @@
     int fcount = _width * _height * _depth * _numComponents;
     _data = new float[fcount];
-    if (data != NULL) {
-        TRACE("data is copied");
-        memcpy(_data, data, fcount * sizeof(float));
-        _tex->initialize(_data);
-    } else {
-        TRACE("data is null");
-        memset(_data, 0, sizeof(_width * _height * _depth * _numComponents * 
-                                sizeof(float)));
-        _tex->initialize(_data);
-    }
+    memcpy(_data, data, fcount * sizeof(float));
+    _tex->initialize(_data);
 
     _id = _tex->id();
@@ -83 +75 @@
     //The default location of cut plane is in the middle of the data.
     _plane.clear();
-    addCutplane(1, 0.5f);
-    addCutplane(2, 0.5f);
-    addCutplane(3, 0.5f);
+    addCutplane(CutPlane::X_AXIS, 0.5f);
+    addCutplane(CutPlane::Y_AXIS, 0.5f);
+    addCutplane(CutPlane::Z_AXIS, 0.5f);
 
     TRACE("Leave");
@@ -98 +90 @@
 }
 
-void Volume::getWorldSpaceBounds(Vector3f& bboxMin, Vector3f& bboxMax) const
+void Volume::setData(float *data, double v0, double v1, double nonZeroMin)
 {
-    Vector3f scale = getPhysicalScaling();
+    int fcount = _width * _height * _depth * _numComponents;
+    memcpy(_data, data, fcount * sizeof(float));
+    _tex->update(_data);
+    wAxis.setRange(v0, v1);
+    _nonZeroMin = nonZeroMin;
+    updatePending = true;
+}
 
-    Matrix4x4d mat;
-    mat.makeTranslation(_location);
-    Matrix4x4d mat2;
-    mat2.makeScale(scale);
-
-    mat.multiply(mat2);
-
-    bboxMin.set(FLT_MAX, FLT_MAX, FLT_MAX);
-    bboxMax.set(-FLT_MAX, -FLT_MAX, -FLT_MAX);
-
-    Vector3f modelMin(0, 0, 0);
-    Vector3f modelMax(1, 1, 1);
-
-    Vector4f bvert[8];
-    bvert[0] = Vector4f(modelMin.x, modelMin.y, modelMin.z, 1);
-    bvert[1] = Vector4f(modelMax.x, modelMin.y, modelMin.z, 1);
-    bvert[2] = Vector4f(modelMin.x, modelMax.y, modelMin.z, 1);
-    bvert[3] = Vector4f(modelMin.x, modelMin.y, modelMax.z, 1);
-    bvert[4] = Vector4f(modelMax.x, modelMax.y, modelMin.z, 1);
-    bvert[5] = Vector4f(modelMax.x, modelMin.y, modelMax.z, 1);
-    bvert[6] = Vector4f(modelMin.x, modelMax.y, modelMax.z, 1);
-    bvert[7] = Vector4f(modelMax.x, modelMax.y, modelMax.z, 1);
-
-    for (int i = 0; i < 8; i++) {
-        Vector4f worldVert = mat.transform(bvert[i]);
-        if (worldVert.x < bboxMin.x) bboxMin.x = worldVert.x;
-        if (worldVert.x > bboxMax.x) bboxMax.x = worldVert.x;
-        if (worldVert.y < bboxMin.y) bboxMin.y = worldVert.y;
-        if (worldVert.y > bboxMax.y) bboxMax.y = worldVert.y;
-        if (worldVert.z < bboxMin.z) bboxMin.z = worldVert.z;
-        if (worldVert.z > bboxMax.z) bboxMax.z = worldVert.z;
-    }
+void Volume::getBounds(Vector3f& bboxMin, Vector3f& bboxMax) const
+{
+    bboxMin.set(xAxis.min(), yAxis.min(), zAxis.min());
+    bboxMax.set(xAxis.max(), yAxis.max(), zAxis.max());
 }

trunk/packages/vizservers/nanovis/Volume.h

@@ -21 +21 @@
 namespace nv {
 
-struct CutPlane {
-    /// orientation - 1: xy slice, 2: yz slice, 3: xz slice
-    int orient;
-    float offset;       ///< normalized offset [0,1] in the volume
-    bool enabled;
-
-    CutPlane(int _orient, float _offset) :
+class CutPlane {
+public:
+    enum Axis {
+        X_AXIS = 1,
+        Y_AXIS = 2,
+        Z_AXIS = 3
+    };
+
+    CutPlane(Axis _orient, float _offset) :
         orient(_orient),
         offset(_offset),
@@ -33 +35 @@
     {
     }
+
+    Axis orient;
+    float offset;       ///< normalized offset [0,1] in the volume
+    bool enabled;
 };
 
@@ -52 +58 @@
      * each axis.  Sample spacing may differ between X, Y and Z
      *
-     * \param x X location
-     * \param y Y location
-     * \param z Z location
      * \param width Number of samples in X
      * \param height Number of samples in Y
@@ -64 +67 @@
      * \param nonZeroMin Scalar minimum which is greater than zero
      */
-    Volume(float x, float y, float z,
-           int width, int height, int depth, 
+    Volume(int width, int height, int depth, 
            int numComponents,
            float *data,
@@ -98 +100 @@
     }
 
-    void location(const vrmath::Vector3f& loc)
-    { 
-        _location = loc; 
-    }
-
-    vrmath::Vector3f location() const
-    {
-        return _location;
-    }
-
     int isosurface() const
     {
@@ -132 +124 @@
         return _volumeType;
     }
+
+    void setData(float *data, double v0, double v1, double nonZeroMin);
 
     const float *data() const
@@ -155 +149 @@
     // methods related to cutplanes
     /// add a plane and returns its index
-    int addCutplane(int orientation, float location);
+    int addCutplane(CutPlane::Axis orientation, float location);
 
     void enableCutplane(int index);
@@ -161 +155 @@
     void disableCutplane(int index);
 
-    void moveCutplane(int index, float location);
+    void setCutplanePosition(int index, float location);
 
     CutPlane *getCutplane(int index);
@@ -282 +276 @@
 
     void getOutlineColor(float *rgb);
-
-    vrmath::Vector3f getPhysicalScaling() const
-    {
-        vrmath::Vector3f scale;
-        scale.x = 1;
-        scale.y = yAxis.length() / xAxis.length();
-        scale.z = zAxis.length() / xAxis.length();
-        return scale;
-    }
-
-    void getWorldSpaceBounds(vrmath::Vector3f& bboxMin,
-                             vrmath::Vector3f& bboxMax) const;
+    
+    void setPosition(const vrmath::Vector3f& pos)
+    { 
+        _position = pos;
+    }
+
+    const vrmath::Vector3f& getPosition() const
+    {
+        return _position;
+    }
+
+    void setScale(const vrmath::Vector3f& scale)
+    { 
+        _scale = scale;
+    }
+
+    const vrmath::Vector3f& getScale() const
+    {
+        return _scale;
+    }
+
+    void getBounds(vrmath::Vector3f& bboxMin,
+                   vrmath::Vector3f& bboxMax) const;
  
     double sampleDistanceX() const
@@ -370 +375 @@
     /**
      * The scale multiplied to the opacity assigned by the 
-     * transfer function. Rule of thumb: higher opacity_scale
-     * the object is to appear like plastic
+     * transfer function.
      */
     float _opacityScale;
@@ -387 +391 @@
     Texture3D *_tex;            ///< OpenGL texture storing the volume
 
-    vrmath::Vector3f _location;
+    vrmath::Vector3f _position;
+    vrmath::Vector3f _scale;
 
     /**
@@ -403 +408 @@
 
 inline int
-Volume::addCutplane(int orientation, float location)
+Volume::addCutplane(CutPlane::Axis orientation, float location)
 {
     _plane.push_back(CutPlane(orientation, location));
@@ -424 +429 @@
 
 inline void 
-Volume::moveCutplane(int index, float location)
+Volume::setCutplanePosition(int index, float position)
 {
     //assert(index < plane.size());
-    _plane[index].offset = location;
+    _plane[index].offset = position;
 }
 

trunk/packages/vizservers/nanovis/VolumeInterpolator.cpp

@@ -32 +32 @@
 void VolumeInterpolator::start()
 {
-    if (_volumes.size() > 0) {
+    if (!_volumes.empty()) {
         TRACE("Volume Interpolation Started");
         _started = true;
@@ -128 +128 @@
 VolumeInterpolator::addVolume(Volume *volume)
 {
-    if (_volumes.size() != 0) {
+    if (!_volumes.empty()) {
         if (_volumes[0]->width() != volume->width() || 
             _volumes[0]->height() != volume->height() ||   
@@ -140 +140 @@
         _numComponents = volume->numComponents();
         _numBytes = _dataCount * _numComponents * sizeof(float);
-        Vector3f loc = volume->location();
-        _volume = new Volume(loc.x, loc.y, loc.z,
-                             volume->width(),
+        _volume = new Volume(volume->width(),
                              volume->height(),
                              volume->depth(), 
@@ -151 +149 @@
                              volume->nonZeroMin());
 
-        _volume->numSlices(256-1);
+        _volume->setPosition(volume->getPosition());
+        _volume->setScale(volume->getScale());
         _volume->disableCutplane(0);
         _volume->disableCutplane(1);
@@ -163 +162 @@
         _volume->opacityScale(volume->opacityScale());
         _volume->isosurface(0);
-        TRACE("VOL : location %f %f %f\n\tid : %s", loc.x, loc.y, loc.z, 
-               volume->name());
     }
-    _volumes.push_back(_volume);
-    TRACE("a Volume[%s] is added to VolumeInterpolator", volume->name());
+    _volumes.push_back(volume);
+    TRACE("Volume \"%s\" is added to VolumeInterpolator", volume->name());
 }
 
@@ -173 +170 @@
 {
     return _volume;
-    //return _volumes[0];
 }

trunk/packages/vizservers/nanovis/VolumeInterpolator.h

@@ -40 +40 @@
 private:
     Volume *_volume;
-
-    std::vector<Volume*> _volumes;
+    std::vector<Volume *> _volumes;
 
     double _interval;

trunk/packages/vizservers/nanovis/VolumeRenderer.cpp

@@ -22 +22 @@
 
 #include <vrmath/Vector3f.h>
+#include <vrmath/Vector4f.h>
 #include <vrmath/Matrix4x4d.h>
+#include <vrmath/BBox.h>
 
 #include "nanovis.h"
@@ -54 +56 @@
 {
     _cutplaneShader = new Shader();
-    _cutplaneShader->loadVertexProgram("cutplane_vp.cg", "main");
-    _cutplaneShader->loadFragmentProgram("cutplane_fp.cg", "main");
+    _cutplaneShader->loadVertexProgram("cutplane_vp.cg");
+    _cutplaneShader->loadFragmentProgram("cutplane_fp.cg");
 
     //standard vertex program
@@ -67 +69 @@
     //A sim has S, P, D, SS orbitals. thus a full rendering requires 4 zincblende orbital volumes. 
     //A zincblende orbital volume is decomposed into 2 "interlocking" cubic 4-component volumes and passed to the shader. 
-    //We render each orbital with a independent transfer functions then blend the result.
+    //We render each orbital with independent transfer functions then blend the result.
     //
     //The engine is already capable of rendering multiple volumes and combine them. Thus, we just invoke this shader on
@@ -130 +132 @@
     size_t *actual_slices = new size_t[volumes.size()];
     float *z_steps = new float[volumes.size()];
+    float *sampleRatios = new float[volumes.size()];
+    Vector4f *objPlaneS = new Vector4f[volumes.size()];
+    Vector4f *objPlaneT = new Vector4f[volumes.size()];
+    Vector4f *objPlaneR = new Vector4f[volumes.size()];
 
     TRACE("start loop %d", volumes.size());
@@ -143 +149 @@
         }
 
-        //volume start location
-        Vector3f volPos = volume->location();
-        Vector3f volScaling = volume->getPhysicalScaling();
+        // Get any additional transforms on Volume
+        Vector3f volPos = volume->getPosition();
+        Vector3f volScale = volume->getScale();
+        // Get world coords of volume bbox
+        double x0 = volume->xAxis.min();
+        double y0 = volume->yAxis.min();
+        double z0 = volume->zAxis.min();
+        double x1 = volume->xAxis.max();
+        double y1 = volume->yAxis.max();
+        double z1 = volume->zAxis.max();
+        Vector3f worldMin(x0, y0, z0);
+        Vector3f worldMax(x1, y1, z1);
+
+        float edgeLengthX = volume->xAxis.length();
+        float edgeLengthY = volume->yAxis.length();
+        float edgeLengthZ = volume->zAxis.length();
+        // Texgen planes
+        objPlaneS[i].set(1./edgeLengthX, 0, 0, -volume->xAxis.min()/edgeLengthX);
+        objPlaneT[i].set(0, 1./edgeLengthY, 0, -volume->yAxis.min()/edgeLengthY);
+        objPlaneR[i].set(0, 0, 1./edgeLengthZ, -volume->zAxis.min()/edgeLengthZ);
+
+        Matrix4x4d model_view_no_trans, model_view_trans;
+        Matrix4x4d model_view_no_trans_inverse, model_view_trans_inverse;
+
+        //initialize volume plane with world coordinates
+        nv::Plane volume_planes[6];
+        volume_planes[0].setCoeffs( 1,  0,  0, -x0);
+        volume_planes[1].setCoeffs(-1,  0,  0,  x1);
+        volume_planes[2].setCoeffs( 0,  1,  0, -y0);
+        volume_planes[3].setCoeffs( 0, -1,  0,  y1);
+        volume_planes[4].setCoeffs( 0,  0,  1, -z0);
+        volume_planes[5].setCoeffs( 0,  0, -1,  z1);
 
         TRACE("VOL POS: %g %g %g",
               volPos.x, volPos.y, volPos.z);
         TRACE("VOL SCALE: %g %g %g",
-              volScaling.x, volScaling.y, volScaling.z);
-
-        double x0 = 0;
-        double y0 = 0;
-        double z0 = 0;
-
-        Matrix4x4d model_view_no_trans, model_view_trans;
-        Matrix4x4d model_view_no_trans_inverse, model_view_trans_inverse;
-
-        //initialize volume plane with world coordinates
-        nv::Plane volume_planes[6];
-        volume_planes[0].setCoeffs( 1,  0,  0, -x0);
-        volume_planes[1].setCoeffs(-1,  0,  0,  x0+1);
-        volume_planes[2].setCoeffs( 0,  1,  0, -y0);
-        volume_planes[3].setCoeffs( 0, -1,  0,  y0+1);
-        volume_planes[4].setCoeffs( 0,  0,  1, -z0);
-        volume_planes[5].setCoeffs( 0,  0, -1,  z0+1);
+              volScale.x, volScale.y, volScale.z);
 
         //get modelview matrix with no translation
         glPushMatrix();
-        glScalef(volScaling.x, volScaling.y, volScaling.z);
+        glScalef(volScale.x, volScale.y, volScale.z);
 
         glEnable(GL_DEPTH_TEST);
@@ -185 +204 @@
         glPushMatrix();
         glTranslatef(volPos.x, volPos.y, volPos.z);
-        glScalef(volScaling.x, volScaling.y, volScaling.z);
+        glScalef(volScale.x, volScale.y, volScale.z);
 
         GLdouble mv_trans[16];
@@ -200 +219 @@
             float olcolor[3];
             volume->getOutlineColor(olcolor);
-            drawBoundingBox(x0, y0, z0, x0+1, y0+1, z0+1,
-                (double)olcolor[0], (double)olcolor[1], (double)olcolor[2],
-                1.5);
+            drawBoundingBox(x0, y0, z0, x1, y1, z1,
+                            olcolor[0], olcolor[1], olcolor[2],
+                            1.5);
         }
         glPopMatrix();
@@ -212 +231 @@
             volume_planes[j].transform(model_view_no_trans);
         }
-        double eyeMinX, eyeMaxX, eyeMinY, eyeMaxY, zNear, zFar;
-        getEyeSpaceBounds(model_view_no_trans, 
-                          eyeMinX, eyeMaxX,
-                          eyeMinY, eyeMaxY,
-                          zNear, zFar);
+        Vector3f eyeMin, eyeMax;
+        double zNear, zFar;
+        getEyeSpaceBounds(worldMin, worldMax,
+                          model_view_no_trans, 
+                          eyeMin, eyeMax);
+        zNear = eyeMax.z;
+        zFar = eyeMin.z;
 
         //compute actual rendering slices
@@ -236 +257 @@
 
         TRACE("near: %g far: %g eye space bounds: (%g,%g)-(%g,%g) z_step: %g slices: %d",
-              zNear, zFar, eyeMinX, eyeMaxX, eyeMinY, eyeMaxY, z_step, n_actual_slices);
+              zNear, zFar, eyeMin.x, eyeMax.x, eyeMin.y, eyeMax.y, z_step, n_actual_slices);
+
+        // Compute opacity correction sample ratios
+        float defDist = z_step == 0.0f ? 1.0 : z_step;
+        float sampleDistX = (volume->width() > 1) ? edgeLengthX / (volume->width()-1) : defDist;
+        float sampleDistY = (volume->height() > 1) ? edgeLengthY / (volume->height()-1) : defDist;
+        float sampleDistZ = (volume->depth() > 1) ? edgeLengthZ / (volume->depth()-1) : defDist;
+        sampleDistX *= volScale.x;
+        sampleDistY *= volScale.y;
+        sampleDistZ *= volScale.z;
+        BBox voxelIn, voxelOut;
+        voxelIn.min.set(0,0,0);
+        voxelIn.max.set(sampleDistX, sampleDistY, sampleDistZ);
+        getEyeSpaceBounds(voxelIn.min, voxelIn.max, model_view_no_trans, voxelOut.min, voxelOut.max);
+        sampleRatios[i] = z_step / (voxelOut.max.z - voxelOut.min.z);
 
         Vector4f vert1, vert2, vert3, vert4;
@@ -249 +284 @@
                 continue;
             }
+            Vector4f texcoord1, texcoord2, texcoord3, texcoord4;
             float offset = volume->getCutplane(j)->offset;
             int axis = volume->getCutplane(j)->orient;
 
             switch (axis) {
-            case 1:
-                vert1 = Vector4f(offset, 0, 0, 1);
-                vert2 = Vector4f(offset, 1, 0, 1);
-                vert3 = Vector4f(offset, 1, 1, 1);
-                vert4 = Vector4f(offset, 0, 1, 1);
+            case CutPlane::X_AXIS: // YZ plane
+                vert1 = Vector4f(x0 + offset * (x1 - x0), y0, z0, 1);
+                vert2 = Vector4f(x0 + offset * (x1 - x0), y1, z0, 1);
+                vert3 = Vector4f(x0 + offset * (x1 - x0), y1, z1, 1);
+                vert4 = Vector4f(x0 + offset * (x1 - x0), y0, z1, 1);
+                texcoord1 = Vector4f(offset, 0, 0, 1);
+                texcoord2 = Vector4f(offset, 1, 0, 1);
+                texcoord3 = Vector4f(offset, 1, 1, 1);
+                texcoord4 = Vector4f(offset, 0, 1, 1);
                 break;
-            case 2:
-                vert1 = Vector4f(0, offset, 0, 1);
-                vert2 = Vector4f(1, offset, 0, 1);
-                vert3 = Vector4f(1, offset, 1, 1);
-                vert4 = Vector4f(0, offset, 1, 1);
+            case CutPlane::Y_AXIS: // XZ plane
+                vert1 = Vector4f(x0, y0 + offset * (y1 - y0), z0, 1);
+                vert2 = Vector4f(x1, y0 + offset * (y1 - y0), z0, 1);
+                vert3 = Vector4f(x1, y0 + offset * (y1 - y0), z1, 1);
+                vert4 = Vector4f(x0, y0 + offset * (y1 - y0), z1, 1);
+                texcoord1 = Vector4f(0, offset, 0, 1);
+                texcoord2 = Vector4f(1, offset, 0, 1);
+                texcoord3 = Vector4f(1, offset, 1, 1);
+                texcoord4 = Vector4f(0, offset, 1, 1);
                 break;
-            case 3:
+            case CutPlane::Z_AXIS: // XY plane
             default:
-                vert1 = Vector4f(0, 0, offset, 1);
-                vert2 = Vector4f(1, 0, offset, 1);
-                vert3 = Vector4f(1, 1, offset, 1);
-                vert4 = Vector4f(0, 1, offset, 1);
+                vert1 = Vector4f(x0, y0, z0 + offset * (z1 - z0), 1);
+                vert2 = Vector4f(x1, y0, z0 + offset * (z1 - z0), 1);
+                vert3 = Vector4f(x1, y1, z0 + offset * (z1 - z0), 1);
+                vert4 = Vector4f(x0, y1, z0 + offset * (z1 - z0), 1);
+                texcoord1 = Vector4f(0, 0, offset, 1);
+                texcoord2 = Vector4f(1, 0, offset, 1);
+                texcoord3 = Vector4f(1, 1, offset, 1);
+                texcoord4 = Vector4f(0, 1, offset, 1);
                 break;
             }
-
-            Vector4f texcoord1 = vert1;
-            Vector4f texcoord2 = vert2;
-            Vector4f texcoord3 = vert3;
-            Vector4f texcoord4 = vert4;
 
             _cutplaneShader->bind();
@@ -285 +328 @@
             glPushMatrix();
             glTranslatef(volPos.x, volPos.y, volPos.z);
-            glScalef(volScaling.x, volScaling.y, volScaling.z);
+            glScalef(volScale.x, volScale.y, volScale.z);
             _cutplaneShader->setGLStateMatrixVPParameter("modelViewProjMatrix",
                                                          Shader::MODELVIEW_PROJECTION_MATRIX);
@@ -314 +357 @@
         // Initialize view-aligned quads with eye space bounds of
         // volume
-        vert1 = Vector4f(eyeMinX, eyeMinY, -0.5, 1);
-        vert2 = Vector4f(eyeMaxX, eyeMinY, -0.5, 1);
-        vert3 = Vector4f(eyeMaxX, eyeMaxY, -0.5, 1);
-        vert4 = Vector4f(eyeMinX, eyeMaxY, -0.5, 1);
+        vert1 = Vector4f(eyeMin.x, eyeMin.y, zFar, 1);
+        vert2 = Vector4f(eyeMax.x, eyeMin.y, zFar, 1);
+        vert3 = Vector4f(eyeMax.x, eyeMax.y, zFar, 1);
+        vert4 = Vector4f(eyeMin.x, eyeMax.y, zFar, 1);
 
         size_t counter = 0;
@@ -345 +388 @@
 
             for (size_t k = 0; k < 6; k++) {
-                if (!poly->clip(volume_planes[k], true))
+                if (!poly->clip(volume_planes[k], false))
                     break;
             }
@@ -384 +427 @@
 
     for (size_t i = 0; i < total_rendered_slices; i++) {
-        Volume *volume = NULL;
-
-        int volume_index = slices[i].volumeId;
-        int slice_index = slices[i].sliceId;
-        ConvexPolygon *currentSlice = polys[volume_index][slice_index];
-        float z_step = z_steps[volume_index];
-
-        volume = volumes[volume_index];
-
-        Vector3f volScaling = volume->getPhysicalScaling();
+        int volIdx = slices[i].volumeId;
+        int sliceIdx = slices[i].sliceId;
+        ConvexPolygon *currentSlice = polys[volIdx][sliceIdx];
+
+        Volume *volume = volumes[volIdx];
+        Vector3f volPos = volume->getPosition();
+        Vector3f volScale = volume->getScale();
 
         glPushMatrix();
-        glScalef(volScaling.x, volScaling.y, volScaling.z);
-
-        // FIXME: compute view-dependent volume sample distance
-        double avgSampleDistance = 1.0 / pow(volume->width() * volScaling.x * 
-                                             volume->height() * volScaling.y * 
-                                             volume->depth() * volScaling.z, 1.0/3.0);
-        float sampleRatio = z_step / avgSampleDistance;
+        glTranslatef(volPos.x, volPos.y, volPos.z);
+        glScalef(volScale.x, volScale.y, volScale.z);
 
 #ifdef notdef
-        TRACE("shading slice: volume %s addr=%x slice=%d, volume=%d z_step=%g avgSD=%g", 
-              volume->name(), volume, slice_index, volume_index, z_step, avgSampleDistance);
+        float z_step = z_steps[volIdx];
+        TRACE("shading slice: volume %s addr=%x slice=%d, volume=%d z_step=%g sampleRatio=%g", 
+              volume->name(), volume, sliceIdx, volIdx, z_step, sampleRatios[volIdx]);
 #endif
-        activateVolumeShader(volume, false, sampleRatio);
+        activateVolumeShader(volume, objPlaneS[volIdx], objPlaneT[volIdx], objPlaneR[volIdx], false, sampleRatios[volIdx]);
         glPopMatrix();
 
         glBegin(GL_POLYGON);
-        currentSlice->emit(true);
+        currentSlice->emit(false);
         glEnd();
 
@@ -432 +468 @@
     delete[] actual_slices;
     delete[] z_steps;
+    delete[] objPlaneS;
+    delete[] objPlaneT;
+    delete[] objPlaneR;
+    delete[] sampleRatios;
     free(slices);
 }
@@ -439 +479 @@
                                 float x1, float y1, float z1,
                                 float r, float g, float b, 
-                                float line_width)
+                                float lineWidth)
 {
     glPushAttrib(GL_ENABLE_BIT);
@@ -451 +491 @@
 
     glColor4d(r, g, b, 1.0);
-    glLineWidth(line_width);
+    glLineWidth(lineWidth);
 
     glBegin(GL_LINE_LOOP);
@@ -494 +534 @@
 
 void 
-VolumeRenderer::activateVolumeShader(Volume *volume, bool sliceMode,
+VolumeRenderer::activateVolumeShader(Volume *volume,
+                                     Vector4f& objPlaneS,
+                                     Vector4f& objPlaneT,
+                                     Vector4f& objPlaneR,
+                                     bool sliceMode,
                                      float sampleRatio)
 {
     //vertex shader
-    _stdVertexShader->bind();
+    _stdVertexShader->bind(objPlaneS, objPlaneT, objPlaneR);
     TransferFunction *transferFunc  = volume->transferFunction();
     if (volume->volumeType() == Volume::CUBIC) {
@@ -514 +558 @@
 }
 
-void VolumeRenderer::getEyeSpaceBounds(const Matrix4x4d& mv,
-                                       double& xMin, double& xMax,
-                                       double& yMin, double& yMax,
-                                       double& zNear, double& zFar)
-{
-    double x0 = 0;
-    double y0 = 0;
-    double z0 = 0;
-    double x1 = 1;
-    double y1 = 1;
-    double z1 = 1;
-
-    double zMin, zMax;
-    xMin = DBL_MAX;
-    xMax = -DBL_MAX;
-    yMin = DBL_MAX;
-    yMax = -DBL_MAX;
-    zMin = DBL_MAX;
-    zMax = -DBL_MAX;
-
-    double vertex[8][4];
-
-    vertex[0][0]=x0; vertex[0][1]=y0; vertex[0][2]=z0; vertex[0][3]=1.0;
-    vertex[1][0]=x1; vertex[1][1]=y0; vertex[1][2]=z0; vertex[1][3]=1.0;
-    vertex[2][0]=x0; vertex[2][1]=y1; vertex[2][2]=z0; vertex[2][3]=1.0;
-    vertex[3][0]=x0; vertex[3][1]=y0; vertex[3][2]=z1; vertex[3][3]=1.0;
-    vertex[4][0]=x1; vertex[4][1]=y1; vertex[4][2]=z0; vertex[4][3]=1.0;
-    vertex[5][0]=x1; vertex[5][1]=y0; vertex[5][2]=z1; vertex[5][3]=1.0;
-    vertex[6][0]=x0; vertex[6][1]=y1; vertex[6][2]=z1; vertex[6][3]=1.0;
-    vertex[7][0]=x1; vertex[7][1]=y1; vertex[7][2]=z1; vertex[7][3]=1.0;
-
-    for (int i = 0; i < 8; i++) {
-        Vector4f eyeVert = mv.transform(Vector4f(vertex[i][0],
-                                                 vertex[i][1],
-                                                 vertex[i][2],
-                                                 vertex[i][3]));
-        if (eyeVert.x < xMin) xMin = eyeVert.x;
-        if (eyeVert.x > xMax) xMax = eyeVert.x;
-        if (eyeVert.y < yMin) yMin = eyeVert.y;
-        if (eyeVert.y > yMax) yMax = eyeVert.y;
-        if (eyeVert.z < zMin) zMin = eyeVert.z;
-        if (eyeVert.z > zMax) zMax = eyeVert.z;
-    }
-
-    zNear = zMax;
-    zFar = zMin;
-}
+void VolumeRenderer::getEyeSpaceBounds(const Vector3f& worldMin,
+                                       const Vector3f& worldMax,
+                                       const Matrix4x4d& modelViewMatrix,
+                                       Vector3f& eyeMin, Vector3f& eyeMax)
+{
+    BBox bbox(worldMin, worldMax);
+
+    bbox.transform(bbox, modelViewMatrix);
+
+    eyeMin = bbox.min;
+    eyeMax = bbox.max;
+}

trunk/packages/vizservers/nanovis/VolumeRenderer.h

@@ -9 +9 @@
 #define NV_VOLUME_RENDERER_H
 
+#include <vrmath/Vector3f.h>
+#include <vrmath/Vector4f.h>
 #include <vrmath/Matrix4x4d.h>
 
@@ -61 +63 @@
     void initShaders();
 
-    void activateVolumeShader(Volume *vol, bool sliceMode, float sampleRatio);
+    void activateVolumeShader(Volume *vol, 
+                              vrmath::Vector4f& objPlaneS,
+                              vrmath::Vector4f& objPlaneT,
+                              vrmath::Vector4f& objPlaneR,
+                              bool sliceMode, float sampleRatio);
 
     void deactivateVolumeShader();
 
-    void drawBoundingBox(float x0, float y0, float z0,
-                         float x1, float y1, float z1,
-                         float r, float g, float b, float line_width);
+    static void drawBoundingBox(float x0, float y0, float z0,
+                                float x1, float y1, float z1,
+                                float r, float g, float b, float line_width);
 
-    void getEyeSpaceBounds(const vrmath::Matrix4x4d& mv,
-                           double& xMin, double& xMax,
-                           double& yMin, double& yMax,
-                           double& zNear, double& zFar);
+    static void getEyeSpaceBounds(const vrmath::Vector3f& worldMin,
+                                  const vrmath::Vector3f& worldMax,
+                                  const vrmath::Matrix4x4d& mv,
+                                  vrmath::Vector3f& eyeMin,
+                                  vrmath::Vector3f& eyeMax);
 
     VolumeInterpolator *_volumeInterpolator;

trunk/packages/vizservers/nanovis/VtkReader.cpp

@@ -488 +488 @@
     delete [] data;
 
-    //
-    // Center this new volume on the origin.
-    //
-    float dx0 = -0.5;
-    float dy0 = -0.5*ly/lx;
-    float dz0 = -0.5*lz/lx;
-    if (volume) {
-        volume->location(vrmath::Vector3f(dx0, dy0, dz0));
-        TRACE("Set volume location to %g %g %g", dx0, dy0, dz0);
-    }
     return volume;
 }

trunk/packages/vizservers/nanovis/ZincBlendeReconstructor.cpp

@@ -264 +264 @@
     cellSize.z = 0.25 / depth;
 
-    zincBlendeVolume = new ZincBlendeVolume(origin.x, origin.y, origin.z,
-                                            width, height, depth, 4,
+    zincBlendeVolume = new ZincBlendeVolume(width, height, depth, 4,
                                             fourAnionVolume, fourCationVolume,
                                             vmin, vmax, nzero_min, cellSize);
+
+    zincBlendeVolume->xAxis.setRange(origin.x, origin.x + delta.x * (width-1));
+    zincBlendeVolume->yAxis.setRange(origin.y, origin.y + delta.y * (height-1));
+    zincBlendeVolume->zAxis.setRange(origin.z, origin.z + delta.z * (depth-1));
 
     return zincBlendeVolume;
@@ -342 +345 @@
     cellSize.z = 0.25 / depth;
 
-    zincBlendeVolume = new ZincBlendeVolume(origin.x, origin.y, origin.z,
-                                            width, height, depth, 4,
+    zincBlendeVolume = new ZincBlendeVolume(width, height, depth, 4,
                                             fourAnionVolume, fourCationVolume,
                                             vmin, vmax, nzero_min, cellSize);
+
+    zincBlendeVolume->xAxis.setRange(origin.x, origin.x + delta.x * (width-1));
+    zincBlendeVolume->yAxis.setRange(origin.y, origin.y + delta.y * (height-1));
+    zincBlendeVolume->zAxis.setRange(origin.z, origin.z + delta.z * (depth-1));
 
     return zincBlendeVolume;

trunk/packages/vizservers/nanovis/ZincBlendeVolume.cpp

@@ -24 +24 @@
 using namespace vrmath;
 
-ZincBlendeVolume::ZincBlendeVolume(float x, float y, float z,
-                                   int w, int h, int d, int n, 
+ZincBlendeVolume::ZincBlendeVolume(int w, int h, int d, int n, 
                                    float *dataVolumeA, float *dataVolumeB,
                                    double v0, double v1, double non_zeromin,
                                    const Vector3f& cellSz) :
-    Volume(x, y, z, w, h, d, n, dataVolumeA, v0, v1, non_zeromin),
+    Volume(w, h, d, n, dataVolumeA, v0, v1, non_zeromin),
     cellSize(cellSz)
 {
@@ -49 +48 @@
 ZincBlendeVolume::~ZincBlendeVolume()
 { 
-    // This data will be deleted in a destrutor of Volume class
-    //if (zincblende_tex[0])
-    //  delete zincblende_tex[0];
+    // First texture will be deleted in ~Volume()
     if (zincblendeTex[1])
         delete zincblendeTex[1];

trunk/packages/vizservers/nanovis/ZincBlendeVolume.h

@@ -21 +21 @@
 {
 public:
-    ZincBlendeVolume(float x, float y, float z, 
-                     int width, int height, int depth, int numComponents, 
+    ZincBlendeVolume(int width, int height, int depth, int numComponents, 
                      float *dataVolumeA, float *dataVolumeB,
-                     double vmin, double vmax, double non_zeromin, const vrmath::Vector3f& cellSize);
+                     double vmin, double vmax, double non_zeromin,
+                     const vrmath::Vector3f& cellSize);
 
     virtual ~ZincBlendeVolume();

trunk/packages/vizservers/nanovis/ZincBlendeVolumeShader.cpp

@@ -21 +21 @@
 void ZincBlendeVolumeShader::init()
 {
-    loadFragmentProgram("zincblende_volume.cg", "main");
+    loadFragmentProgram("zincblende_volume.cg");
 }
 

trunk/packages/vizservers/nanovis/dxReader.cpp

@@ -488 +488 @@
     delete [] data;
 
-    //
-    // Center this new volume on the origin.
-    //
-    float dx0 = -0.5;
-    float dy0 = -0.5*ly/lx;
-    float dz0 = -0.5*lz/lx;
-    if (volume) {
-        volume->location(vrmath::Vector3f(dx0, dy0, dz0));
-        TRACE("Set volume location to %g %g %g", dx0, dy0, dz0);
-    }
     return volume;
 }

trunk/packages/vizservers/nanovis/graphics/Makefile.in

@@ -59 +59 @@
 
 clean:
-        $(RM) $(NVGRAPHICSLIB) $(OBJS)
+        $(RM) *.a *.o
 
 distclean: clean

trunk/packages/vizservers/nanovis/imgLoaders/Makefile.in

@@ -59 +59 @@
 
 clean:
-        $(RM) $(IMGLIB) $(OBJS)
+        $(RM) *.a *.o
 
 distclean: clean

trunk/packages/vizservers/nanovis/nanovis.cpp

@@ -24 +24 @@
 
 #include <graphics/RenderContext.h>
+#include <vrmath/BBox.h>
 #include <vrmath/Vector3f.h>
 
@@ -64 +65 @@
 Tcl_Interp *NanoVis::interp = NULL;
 
-unsigned int NanoVis::flags = 0;
+bool NanoVis::redrawPending = false;
 bool NanoVis::debugFlag = false;
 
@@ -73 +74 @@
 Texture2D *NanoVis::legendTexture = NULL;
 Fonts *NanoVis::fonts;
-int NanoVis::updir = Y_POS;
-Camera *NanoVis::cam = NULL;
+Camera *NanoVis::_camera = NULL;
 RenderContext *NanoVis::renderContext = NULL;
 
@@ -82 +82 @@
 NanoVis::HeightMapHashmap NanoVis::heightMapTable;
 
-double NanoVis::magMin = DBL_MAX;
-double NanoVis::magMax = -DBL_MAX;
-float NanoVis::xMin = FLT_MAX;
-float NanoVis::xMax = -FLT_MAX;
-float NanoVis::yMin = FLT_MAX;
-float NanoVis::yMax = -FLT_MAX;
-float NanoVis::zMin = FLT_MAX;
-float NanoVis::zMax = -FLT_MAX;
-float NanoVis::wMin = FLT_MAX;
-float NanoVis::wMax = -FLT_MAX;
-Vector3f NanoVis::sceneMin, NanoVis::sceneMax;
+BBox NanoVis::sceneBounds;
 
 VolumeRenderer *NanoVis::volRenderer = NULL;
@@ -101 +91 @@
 Grid *NanoVis::grid = NULL;
 
-// Image based flow visualization slice location
-// FLOW
-float NanoVis::_licSlice = 0.5f;
-int NanoVis::_licAxis = 2; // z axis
-
 //frame buffer for final rendering
 GLuint NanoVis::_finalFbo = 0;
@@ -111 +96 @@
 GLuint NanoVis::_finalDepthRb = 0;
 
-// Default camera location.
-float def_eye_x = 0.0f;
-float def_eye_y = 0.0f;
-float def_eye_z = 2.5f;
-
 void
 NanoVis::removeAllData()
 {
     TRACE("Enter");
+
     if (grid != NULL) {
         TRACE("Deleting grid");
         delete grid;
     }
-    if (cam != NULL) {
-        TRACE("Deleting cam");
-        delete cam;
+    if (_camera != NULL) {
+        TRACE("Deleting camera");
+        delete _camera;
     }
     if (volRenderer != NULL) {
@@ -167 +148 @@
 
 void 
-NanoVis::eventuallyRedraw(unsigned int flag)
-{
-    if (flag) {
-        flags |= flag;
-    }
-    if ((flags & REDRAW_PENDING) == 0) {
+NanoVis::eventuallyRedraw()
+{
+    if (!redrawPending) {
         glutPostRedisplay();
-        flags |= REDRAW_PENDING;
-    }
-}
-
-void
-NanoVis::pan(float dx, float dy)
-{
-    /* Move the camera and its target by equal amounts along the x and y
-     * axes. */
-    TRACE("pan: x=%f, y=%f", dx, dy);
-
-    cam->x(def_eye_x - dx);
-    cam->y(def_eye_y + dy);
-    TRACE("set eye to %f %f", cam->x(), cam->y());
-}
-
-void
-NanoVis::zoom(float z)
-{
-    /* Move the camera and its target by equal amounts along the x and y
-     * axes. */
-    TRACE("zoom: z=%f", z);
-
-    cam->z(def_eye_z / z);
+        redrawPending = true;
+    }
+}
+
+void
+NanoVis::panCamera(float dx, float dy)
+{
+    _camera->pan(dx, dy);
 
     collectBounds();
-    cam->resetClippingRange(sceneMin, sceneMax);
-
-    TRACE("set cam z to %f", cam->z());
+    _camera->resetClippingRange(sceneBounds.min, sceneBounds.max);
+}
+
+void
+NanoVis::zoomCamera(float z)
+{
+    _camera->zoom(z);
+
+    collectBounds();
+    _camera->resetClippingRange(sceneBounds.min, sceneBounds.max);
+}
+
+void
+NanoVis::orientCamera(double *quat)
+{
+    _camera->orient(quat);
+
+    collectBounds();
+    _camera->resetClippingRange(sceneBounds.min, sceneBounds.max);
+}
+
+void
+NanoVis::setCameraPosition(Vector3f pos)
+{
+    _camera->setPosition(pos);
+
+    collectBounds();
+    _camera->resetClippingRange(sceneBounds.min, sceneBounds.max);
+}
+
+void
+NanoVis::setCameraUpdir(Camera::AxisDirection dir)
+{
+    _camera->setUpdir(dir);
+
+    collectBounds();
+    _camera->resetClippingRange(sceneBounds.min, sceneBounds.max);
 }
 
@@ -211 +207 @@
 
     collectBounds();
-    cam->reset(sceneMin, sceneMax, resetOrientation);
-
-    def_eye_x = cam->x();
-    def_eye_y = cam->y();
-    def_eye_z = cam->z();
+    _camera->reset(sceneBounds.min, sceneBounds.max, resetOrientation);
 }
 
@@ -244 +236 @@
     }
 
-    Volume *volume = new Volume(0.f, 0.f, 0.f,
-                                width, height, depth,
+    Volume *volume = new Volume(width, height, depth,
                                 numComponents,
                                 data, vmin, vmax, nonZeroMin);
@@ -451 +442 @@
     TRACE("change camera");
     //change the camera setting
-    cam->setScreenSize(0, 0, winWidth, winHeight);
+    _camera->setViewport(0, 0, winWidth, winHeight);
     planeRenderer->setScreenSize(winWidth, winHeight);
 
     TRACE("Leave (%d, %d)", w, h);
     return true;
-}
-
-static
-void cgErrorCallback(void)
-{
-    if (!Shader::printErrorInfo()) {
-        TRACE("Cg error, exiting...");
-        exit(1);
-    }
 }
 
@@ -536 +518 @@
     ImageLoaderFactory::getInstance()->addLoaderImpl("bmp", new BMPImageLoaderImpl());
 
-    Shader::initCg();
-    Shader::setErrorCallback(cgErrorCallback);
-
-    fonts = new Fonts();
-    fonts->addFont("verdana", "verdana.fnt");
-    fonts->setFont("verdana");
-
-    velocityArrowsSlice = new VelocityArrowsSlice;
-    licRenderer = new LIC(NMESH, NPIX, NPIX, _licAxis, _licSlice);
-
-    grid = new Grid();
-    grid->setFont(fonts);
     return true;
 }
@@ -564 +534 @@
 
     //create the camera with default setting
-    cam = new Camera(0, 0, winWidth, winHeight,
-                     def_eye_x, def_eye_y, def_eye_z);
+    _camera = new Camera(0, 0, winWidth, winHeight);
 
     glEnable(GL_TEXTURE_2D);
@@ -577 +546 @@
     GLfloat mat_shininess[] = {30.0};
     GLfloat white_light[] = {1.0, 1.0, 1.0, 1.0};
-    GLfloat green_light[] = {0.1, 0.5, 0.1, 1.0};
 
     glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
@@ -583 +551 @@
     glLightfv(GL_LIGHT0, GL_DIFFUSE, white_light);
     glLightfv(GL_LIGHT0, GL_SPECULAR, white_light);
-    glLightfv(GL_LIGHT1, GL_DIFFUSE, green_light);
+    glLightfv(GL_LIGHT1, GL_DIFFUSE, white_light);
     glLightfv(GL_LIGHT1, GL_SPECULAR, white_light);
 
@@ -591 +559 @@
     }
 
+    fonts = new Fonts();
+    fonts->addFont("verdana", "verdana.fnt");
+    fonts->setFont("verdana");
+
+    renderContext = new RenderContext();
+
     volRenderer = new VolumeRenderer();
 
-    renderContext = new RenderContext();
-
     planeRenderer = new PlaneRenderer(winWidth, winHeight);
 
+    velocityArrowsSlice = new VelocityArrowsSlice();
+
+    licRenderer = new LIC();
+
     orientationIndicator = new OrientationIndicator();
+
+    grid = new Grid();
+    grid->setFont(fonts);
 
     //assert(glGetError()==0);
@@ -635 +614 @@
 NanoVis::setVolumeRanges()
 {
-    double xMin, xMax, yMin, yMax, zMin, zMax, wMin, wMax;
-
     TRACE("Enter");
-    xMin = yMin = zMin = wMin = DBL_MAX;
-    xMax = yMax = zMax = wMax = -DBL_MAX;
+
+    double valueMin = DBL_MAX, valueMax = -DBL_MAX;
     VolumeHashmap::iterator itr;
     for (itr = volumeTable.begin();
          itr != volumeTable.end(); ++itr) {
         Volume *volume = itr->second;
-        if (xMin > volume->xAxis.min()) {
-            xMin = volume->xAxis.min();
-        }
-        if (xMax < volume->xAxis.max()) {
-            xMax = volume->xAxis.max();
-        }
-        if (yMin > volume->yAxis.min()) {
-            yMin = volume->yAxis.min();
-        }
-        if (yMax < volume->yAxis.max()) {
-            yMax = volume->yAxis.max();
-        }
-        if (zMin > volume->zAxis.min()) {
-            zMin = volume->zAxis.min();
-        }
-        if (zMax < volume->zAxis.max()) {
-            zMax = volume->zAxis.max();
-        }
-        if (wMin > volume->wAxis.min()) {
-            wMin = volume->wAxis.min();
-        }
-        if (wMax < volume->wAxis.max()) {
-            wMax = volume->wAxis.max();
-        }
-    }
-    if ((xMin < DBL_MAX) && (xMax > -DBL_MAX)) {
-        grid->xAxis.setScale(xMin, xMax);
-    }
-    if ((yMin < DBL_MAX) && (yMax > -DBL_MAX)) {
-        grid->yAxis.setScale(yMin, yMax);
-    }
-    if ((zMin < DBL_MAX) && (zMax > -DBL_MAX)) {
-        grid->zAxis.setScale(zMin, zMax);
-    }
-    if ((wMin < DBL_MAX) && (wMax > -DBL_MAX)) {
-        Volume::valueMin = wMin;
-        Volume::valueMax = wMax;
+        if (valueMin > volume->wAxis.min()) {
+            valueMin = volume->wAxis.min();
+        }
+        if (valueMax < volume->wAxis.max()) {
+            valueMax = volume->wAxis.max();
+        }
+    }
+    if ((valueMin < DBL_MAX) && (valueMax > -DBL_MAX)) {
+        Volume::valueMin = valueMin;
+        Volume::valueMax = valueMax;
     }
     Volume::updatePending = false;
@@ -689 +639 @@
 NanoVis::setHeightmapRanges()
 {
-    double xMin, xMax, yMin, yMax, zMin, zMax, wMin, wMax;
-
     TRACE("Enter");
-    xMin = yMin = zMin = wMin = DBL_MAX;
-    xMax = yMax = zMax = wMax = -DBL_MAX;
+
+    double valueMin = DBL_MAX, valueMax = -DBL_MAX;
     HeightMapHashmap::iterator itr;
     for (itr = heightMapTable.begin();
          itr != heightMapTable.end(); ++itr) {
         HeightMap *heightMap = itr->second;
-        if (xMin > heightMap->xAxis.min()) {
-            xMin = heightMap->xAxis.min();
-        }
-        if (xMax < heightMap->xAxis.max()) {
-            xMax = heightMap->xAxis.max();
-        }
-        if (yMin > heightMap->yAxis.min()) {
-            yMin = heightMap->yAxis.min();
-        }
-        if (yMax < heightMap->yAxis.max()) {
-            yMax = heightMap->yAxis.max();
-        }
-        if (zMin > heightMap->zAxis.min()) {
-            zMin = heightMap->zAxis.min();
-        }
-        if (zMax < heightMap->zAxis.max()) {
-            zMax = heightMap->zAxis.max();
-        }
-        if (wMin > heightMap->wAxis.min()) {
-            wMin = heightMap->wAxis.min();
-        }
-        if (wMax < heightMap->wAxis.max()) {
-            wMax = heightMap->wAxis.max();
-        }
-    }
-    if ((xMin < DBL_MAX) && (xMax > -DBL_MAX)) {
-        grid->xAxis.setScale(xMin, xMax);
-    }
-    if ((yMin < DBL_MAX) && (yMax > -DBL_MAX)) {
-        grid->yAxis.setScale(yMin, yMax);
-    }
-    if ((zMin < DBL_MAX) && (zMax > -DBL_MAX)) {
-        grid->zAxis.setScale(zMin, zMax);
-    }
-    if ((wMin < DBL_MAX) && (wMax > -DBL_MAX)) {
-        HeightMap::valueMin = grid->yAxis.min();
-        HeightMap::valueMax = grid->yAxis.max();
+        if (valueMin > heightMap->wAxis.min()) {
+            valueMin = heightMap->wAxis.min();
+        }
+        if (valueMax < heightMap->wAxis.max()) {
+            valueMax = heightMap->wAxis.max();
+        }
+    }
+    if ((valueMin < DBL_MAX) && (valueMax > -DBL_MAX)) {
+        HeightMap::valueMin = valueMin;
+        HeightMap::valueMax = valueMax;
     }
     for (HeightMapHashmap::iterator itr = heightMapTable.begin();
@@ -747 +668 @@
 NanoVis::collectBounds(bool onlyVisible)
 {
-    if (flags & MAP_FLOWS) {
+    if (Flow::updatePending) {
         mapFlows();
-        grid->xAxis.setScale(xMin, xMax);
-        grid->yAxis.setScale(yMin, yMax);
-        grid->zAxis.setScale(zMin, zMax);
-    }
-
-    sceneMin.set(FLT_MAX, FLT_MAX, FLT_MAX);
-    sceneMax.set(-FLT_MAX, -FLT_MAX, -FLT_MAX);
+    }
+
+    sceneBounds.makeEmpty();
 
     for (VolumeHashmap::iterator itr = volumeTable.begin();
@@ -764 +681 @@
             continue;
 
-        Vector3f bmin, bmax;
-        volume->getWorldSpaceBounds(bmin, bmax);
-        if (bmin.x > bmax.x)
-            continue;
-
-        if (sceneMin.x > bmin.x) {
-            sceneMin.x = bmin.x;
-        }
-        if (sceneMax.x < bmax.x) {
-            sceneMax.x = bmax.x;
-        }
-        if (sceneMin.y > bmin.y) {
-            sceneMin.y = bmin.y;
-        }
-        if (sceneMax.y < bmax.y) {
-            sceneMax.y = bmax.y;
-        }
-        if (sceneMin.z > bmin.z) {
-            sceneMin.z = bmin.z;
-        }
-        if (sceneMax.z < bmax.z) {
-            sceneMax.z = bmax.z;
-        }
+        BBox bbox;
+        volume->getBounds(bbox.min, bbox.max);
+        sceneBounds.extend(bbox);
     }
 
@@ -796 +693 @@
             continue;
 
-        Vector3f bmin, bmax;
-        heightMap->getWorldSpaceBounds(bmin, bmax);
-        if (bmin.x > bmax.x)
-            continue;
-
-        if (sceneMin.x > bmin.x) {
-            sceneMin.x = bmin.x;
-        }
-        if (sceneMax.x < bmax.x) {
-            sceneMax.x = bmax.x;
-        }
-        if (sceneMin.y > bmin.y) {
-            sceneMin.y = bmin.y;
-        }
-        if (sceneMax.y < bmax.y) {
-            sceneMax.y = bmax.y;
-        }
-        if (sceneMin.z > bmin.z) {
-            sceneMin.z = bmin.z;
-        }
-        if (sceneMax.z < bmax.z) {
-            sceneMax.z = bmax.z;
-        }
-    }
-
-    Vector3f flowMin, flowMax;
-    getFlowBounds(flowMin, flowMax, onlyVisible);
-    if (flowMin.x < flowMax.x) {
-        if (sceneMin.x > flowMin.x) {
-            sceneMin.x = flowMin.x;
-        }
-        if (sceneMax.x < flowMax.x) {
-            sceneMax.x = flowMax.x;
-        }
-        if (sceneMin.y > flowMin.y) {
-            sceneMin.y = flowMin.y;
-        }
-        if (sceneMax.y < flowMax.y) {
-            sceneMax.y = flowMax.y;
-        }
-        if (sceneMin.z > flowMin.z) {
-            sceneMin.z = flowMin.z;
-        }
-        if (sceneMax.z < flowMax.z) {
-            sceneMax.z = flowMax.z;
-        }
-    }
-
-    // TODO: Get Grid bounds
-
-    if (sceneMin.x > sceneMax.x) {
-        sceneMin.set(-0.5, -0.5, -0.5);
-        sceneMax.set( 0.5,  0.5,  0.5);
+        BBox bbox;
+        heightMap->getBounds(bbox.min, bbox.max);
+        sceneBounds.extend(bbox);
+    }
+
+    {
+        BBox bbox;
+        getFlowBounds(bbox.min, bbox.max, onlyVisible);
+        sceneBounds.extend(bbox);
+    }
+
+    if (!sceneBounds.isEmptyX()) {
+        grid->xAxis.setScale(sceneBounds.min.x, sceneBounds.max.x);
+    }
+    if (!sceneBounds.isEmptyY()) {
+        grid->yAxis.setScale(sceneBounds.min.y, sceneBounds.max.y);
+    }
+    if (!sceneBounds.isEmptyZ()) {
+        grid->zAxis.setScale(sceneBounds.min.z, sceneBounds.max.z);
+    }
+
+    if (!onlyVisible || grid->isVisible()) {
+        BBox bbox;
+        grid->getBounds(bbox.min, bbox.max);
+        sceneBounds.extend(bbox);
+    }
+
+    if (sceneBounds.isEmpty()) {
+        sceneBounds.min.set(-0.5, -0.5, -0.5);
+        sceneBounds.max.set( 0.5,  0.5,  0.5);
     }
 
     TRACE("Scene bounds: (%g,%g,%g) - (%g,%g,%g)",
-          sceneMin.x, sceneMin.y, sceneMin.z,
-          sceneMax.x, sceneMax.y, sceneMax.z);
+          sceneBounds.min.x, sceneBounds.min.y, sceneBounds.min.z,
+          sceneBounds.max.x, sceneBounds.max.y, sceneBounds.max.z);
 }
 
@@ -933 +807 @@
     TRACE("Enter");
 
-    flags &= ~MAP_FLOWS;
-
     /* 
      * Step 1. Get the overall min and max magnitudes of all the 
      *         flow vectors.
      */
-    magMin = DBL_MAX, magMax = -DBL_MAX;
+    Flow::magMin = DBL_MAX;
+    Flow::magMax = -DBL_MAX;
 
     for (FlowHashmap::iterator itr = flowTable.begin();
@@ -951 +824 @@
         min = data->magMin();
         max = data->magMax();
-        if (min < magMin) {
-            magMin = min;
+        if (min < Flow::magMin) {
+            Flow::magMin = min;
         } 
-        if (max > magMax) {
-            magMax = max;
-        }
-        if (data->xMin() < xMin) {
-            xMin = data->xMin();
-        }
-        if (data->yMin() < yMin) {
-            yMin = data->yMin();
-        }
-        if (data->zMin() < zMin) {
-            zMin = data->zMin();
-        }
-        if (data->xMax() > xMax) {
-            xMax = data->xMax();
-        }
-        if (data->yMax() > yMax) {
-            yMax = data->yMax();
-        }
-        if (data->zMax() > zMax) {
-            zMax = data->zMax();
-        }
-    }
-
-    TRACE("magMin=%g magMax=%g", NanoVis::magMin, NanoVis::magMax);
+        if (max > Flow::magMax) {
+            Flow::magMax = max;
+        }
+    }
+
+    TRACE("magMin=%g magMax=%g", Flow::magMin, Flow::magMax);
 
     /* 
@@ -994 +849 @@
             return false;
         }
-        // FIXME: This doesn't work when there is more than one flow.
-        licRenderer->setOffset(flow->getRelativePosition());
-        velocityArrowsSlice->slicePos(flow->getRelativePosition());
-    }
-    advectFlows();
+    }
+
+    Flow::updatePending = false;
     return true;
 }
@@ -1009 +862 @@
     TRACE("Enter");
 
-    min.set(FLT_MAX, FLT_MAX, FLT_MAX);
-    max.set(-FLT_MAX, -FLT_MAX, -FLT_MAX);
-
+    BBox allBounds;
     for (FlowHashmap::iterator itr = flowTable.begin();
          itr != flowTable.end(); ++itr) {
-        itr->second->getBounds(min, max, onlyVisible);
-    }
+        BBox bbox;
+        itr->second->getBounds(bbox.min, bbox.max, onlyVisible);
+        allBounds.extend(bbox);
+    }
+
+    min = allBounds.min;
+    max = allBounds.max;
 }
 
@@ -1028 +884 @@
         }
     }
-    flags &= ~REDRAW_PENDING;
 }
 
@@ -1034 +889 @@
 NanoVis::resetFlows()
 {
-    if (licRenderer->active()) {
-        NanoVis::licRenderer->reset();
-    }
+    NanoVis::licRenderer->reset();
     for (FlowHashmap::iterator itr = flowTable.begin();
          itr != flowTable.end(); ++itr) {
         Flow *flow = itr->second;
-        if (flow->isDataLoaded() && flow->visible()) {
+        if (flow->isDataLoaded()) {
             flow->resetParticles();
         }
@@ -1049 +902 @@
 NanoVis::advectFlows()
 {
+    TRACE("Enter");
     for (FlowHashmap::iterator itr = flowTable.begin();
          itr != flowTable.end(); ++itr) {
         Flow *flow = itr->second;
-        if (flow->isDataLoaded() && flow->visible()) {
+        if (flow->isDataLoaded()) {
             flow->advect();
         }
@@ -1063 +917 @@
     TRACE("Enter");
 
-    if (flags & MAP_FLOWS) {
-#ifdef notdef
-        xMin = yMin = zMin = wMin = FLT_MAX, magMin = DBL_MAX;
-        xMax = yMax = zMax = wMax = -FLT_MAX, magMax = -DBL_MAX;
-#endif
+    if (Flow::updatePending) {
         mapFlows();
-        grid->xAxis.setScale(xMin, xMax);
-        grid->yAxis.setScale(yMin, yMax);
-        grid->zAxis.setScale(zMin, zMax);
-    }
-    //assert(glGetError()==0);
+    }
     if (HeightMap::updatePending) {
         setHeightmapRanges();
@@ -1081 +927 @@
     }
 
-    //start final rendering
+    collectBounds();
+
+    // Start final rendering
 
     // Need to reset fbo since it may have been changed to default (0)
@@ -1092 +940 @@
     glEnable(GL_COLOR_MATERIAL);
 
-    //camera setting activated
-    cam->initialize();
-
-    //set up the orientation of items in the scene.
-    glPushMatrix();
-
-    switch (updir) {
-    case X_POS:
-        glRotatef(90, 0, 0, 1);
-        glRotatef(90, 1, 0, 0);
-        break;
-    case Y_POS:
-        // this is the default
-        break;
-    case Z_POS:
-        glRotatef(-90, 1, 0, 0);
-        glRotatef(-90, 0, 0, 1);
-        break;
-    case X_NEG:
-        glRotatef(-90, 0, 0, 1);
-        break;
-    case Y_NEG:
-        glRotatef(180, 0, 0, 1);
-        glRotatef(-90, 0, 1, 0);
-        break;
-    case Z_NEG:
-        glRotatef(90, 1, 0, 0);
-        break;
-    }
-
-    //now render things in the scene
-
+    // Emit modelview and projection matrices
+    _camera->initialize();
+
+    // Now render things in the scene
+
+    orientationIndicator->setPosition(sceneBounds.getCenter());
+    orientationIndicator->setScale(sceneBounds.getSize());
     orientationIndicator->render();
+
     grid->render();
-    if ((licRenderer != NULL) && (licRenderer->active())) {
-        licRenderer->render();
-    }
-    if ((velocityArrowsSlice != NULL) && (velocityArrowsSlice->enabled())) {
-        velocityArrowsSlice->render();
-    }
+
+    licRenderer->render();
+
+    velocityArrowsSlice->render();
+
     renderFlows();
+
     volRenderer->renderAll();
 
-    HeightMapHashmap::iterator itr;
-    for (itr = heightMapTable.begin();
+    for (HeightMapHashmap::iterator itr = heightMapTable.begin();
          itr != heightMapTable.end(); ++itr) {
-        HeightMap *heightMap = itr->second;
-        if (heightMap->isVisible()) {
-            heightMap->render(renderContext);
-        }
-    }
-    glPopMatrix();
+        itr->second->render(renderContext);
+     }
 
     CHECK_FRAMEBUFFER_STATUS();
     TRACE("Leave");
-}
+    redrawPending = false;
+}

trunk/packages/vizservers/nanovis/nanovis.h

@@ -31 +31 @@
 #include <tr1/unordered_map>
 
+#include <vrmath/BBox.h>
 #include <vrmath/Vector3f.h>
 
 #include "config.h"
+#include "Camera.h"
+#include "FlowTypes.h"
 #include "md5.h"
 
@@ -48 +51 @@
 }
 
-class Camera;
 class Flow;
 class Grid;
@@ -64 +66 @@
 {
 public:
-    enum AxisDirections { 
-        X_POS = 1,
-        Y_POS = 2,
-        Z_POS = 3,
-        X_NEG = -1,
-        Y_NEG = -2,
-        Z_NEG = -3
-    };
-
-    enum NanoVisFlags { 
-        REDRAW_PENDING = (1 << 0), 
-        MAP_FLOWS = (1 << 1)
-    };
-
     typedef std::string TransferFunctionId;
     typedef std::string VolumeId;
@@ -98 +86 @@
     static const Camera *getCamera()
     {
-        return cam;
+        return _camera;
     }
-    static void pan(float dx, float dy);
-    static void zoom(float z);
+    static void panCamera(float dx, float dy);
+    static void zoomCamera(float z);
+    static void orientCamera(double *quat);
+    static void setCameraPosition(vrmath::Vector3f pos);
+    static void setCameraUpdir(Camera::AxisDirection dir);
     static void resetCamera(bool resetOrientation = false);
 
-    static void eventuallyRedraw(unsigned int flag = 0);
-
-    static void setVolumeRanges();
-    static void setHeightmapRanges();
+    static void eventuallyRedraw();
  
     static TransferFunction *getTransferFunction(const TransferFunctionId& id);
@@ -133 +121 @@
     }
 
+    static void setVolumeRanges();
+    static void setHeightmapRanges();
+    static bool mapFlows();
+
     static Flow *getFlow(const char *name);
     static Flow *createFlow(Tcl_Interp *interp, const char *name);
     static void deleteFlows(Tcl_Interp *interp);
     static void deleteFlow(const char *name);
-    static bool mapFlows();
     static void getFlowBounds(vrmath::Vector3f& min,
                               vrmath::Vector3f& max,
@@ -148 +139 @@
     static Tcl_Interp *interp;
 
-    static unsigned int flags;
+    static bool redrawPending;
     static bool debugFlag;
 
     static int winWidth;        ///< Width of the render window
     static int winHeight;       ///< Height of the render window
-    static int renderWindow;    //< GLUT handle for the render window
+    static int renderWindow;    ///< GLUT handle for the render window
     static unsigned char *screenBuffer;
     static Texture2D *legendTexture;
     static util::Fonts *fonts;
-    static int updir;
-    static Camera *cam;
     static graphics::RenderContext *renderContext;
 
@@ -166 +155 @@
     static HeightMapHashmap heightMapTable;
 
-    static double magMin, magMax;
-    static float xMin, xMax, yMin, yMax, zMin, zMax, wMin, wMax;
-    static vrmath::Vector3f sceneMin, sceneMax;
+    static vrmath::BBox sceneBounds;
 
     static VolumeRenderer *volRenderer;
@@ -180 +167 @@
     static void collectBounds(bool onlyVisible = false);
 
-    static float _licSlice;  ///< Slice position [0,1]
-    static int _licAxis;     ///< Slice axis: 0:x, 1:y, 2:z
+    static Camera *_camera;
 
     //frame buffer for final rendering

trunk/packages/vizservers/nanovis/nanovisServer.cpp

@@ -352 +352 @@
     NanoVis::removeAllData();
 
-    Shader::exitCg();
+    Shader::exit();
 
     //close log file
@@ -434 +434 @@
 
 static
-void cgErrorCallback(void)
+void shaderErrorCallback(void)
 {
     if (!Shader::printErrorInfo()) {
-        TRACE("Cg error, exiting...");
+        TRACE("Shader error, exiting...");
         exitService(1);
     }
@@ -579 +579 @@
     }
 
+    Shader::init();
     // Override callback with one that cleans up server on exit
-    Shader::setErrorCallback(cgErrorCallback);
+    Shader::setErrorCallback(shaderErrorCallback);
 
     if (!NanoVis::initGL()) {

trunk/packages/vizservers/nanovis/newmat11/Makefile.in

@@ -73 +73 @@
 
 clean:
-        $(RM) $(MATLIB) $(OBJS)
+        $(RM) *.a *.o