Changeset 3023 for branches

Timestamp:

Jun 5, 2012 12:08:41 PM (12 years ago)

Author:

ldelgass

Message:

Protocol, control for two-sided lighting in volume shader. Cutplane rendering
changes -- don't need to clip cutplanes, use simplified cutplane shader instead of switch in main volume shader. Still need to fix cutplanes of zincblende
volumes.

Location:

branches/nanovis2

Files:

• gui/scripts/nanovisviewer.tcl (modified) (6 diffs)
• packages/vizservers/nanovis/Command.cpp (modified) (2 diffs)
• packages/vizservers/nanovis/ConvexPolygon.cpp (modified) (5 diffs)
• packages/vizservers/nanovis/ConvexPolygon.h (modified) (2 diffs)
• packages/vizservers/nanovis/Makefile.in (modified) (1 diff)
• packages/vizservers/nanovis/NvRegularVolumeShader.cpp (modified) (1 diff)
• packages/vizservers/nanovis/Vector3.h (modified) (3 diffs)
• packages/vizservers/nanovis/Vector4.h (modified) (2 diffs)
• packages/vizservers/nanovis/Volume.cpp (modified) (1 diff)
• packages/vizservers/nanovis/Volume.h (modified) (2 diffs)
• packages/vizservers/nanovis/VolumeRenderer.cpp (modified) (11 diffs)
• packages/vizservers/nanovis/VolumeRenderer.h (modified) (1 diff)
• packages/vizservers/nanovis/shaders/cutplane_fp.cg (added)
• packages/vizservers/nanovis/shaders/cutplane_vp.cg (added)
• packages/vizservers/nanovis/shaders/one_volume.cg (modified) (2 diffs)
• packages/vizservers/nanovis/shaders/zincblende_volume.cg (modified) (1 diff)

branches/nanovis2/gui/scripts/nanovisviewer.tcl

@@ -927 +927 @@
     PanCamera
     SendCmd "camera zoom $_view(zoom)"
+    FixSettings light2side
     FixSettings light
     FixSettings transp
@@ -1219 +1220 @@
                 SendCmd "volume shading specularLevel $specularLevel"
                 SendCmd "volume shading specularExp $specularExp"
+            }
+        }
+        light2side {
+            if {[isconnected]} {
+                set val $_settings($this-light2side)
+                SendCmd "volume shading light2side $val"
             }
         }
@@ -1744 +1751 @@
 itcl::body Rappture::NanovisViewer::BuildVolumeTab {} {
     foreach { key value } {
+        light2side      0
         light           40
         transp          50
@@ -1765 +1773 @@
     label $inner.shading -text "Shading:" -font $fg
 
+    checkbutton $inner.light2side -text "Two-sided lighting" -font $fg \
+        -variable [itcl::scope _settings($this-light2side)] \
+        -command [itcl::code $this FixSettings light2side]
+
     label $inner.dim -text "Glow" -font $fg
     ::scale $inner.light -from 0 -to 100 -orient horizontal \
@@ -1796 +1808 @@
         0,0 $inner.vol -columnspan 4 -anchor w -pady 2 \
         1,0 $inner.shading -columnspan 4 -anchor w -pady {10 2} \
-        2,0 $inner.dim -anchor e -pady 2 \
-        2,1 $inner.light -columnspan 2 -pady 2 -fill x \
-        2,3 $inner.bright -anchor w -pady 2 \
-        3,0 $inner.fog -anchor e -pady 2 \
-        3,1 $inner.transp -columnspan 2 -pady 2 -fill x \
-        3,3 $inner.plastic -anchor w -pady 2 \
-        4,0 $inner.thin -anchor e -pady 2 \
-        4,1 $inner.thickness -columnspan 2 -pady 2 -fill x\
-        4,3 $inner.thick -anchor w -pady 2
+        2,0 $inner.light2side -columnspan 4 -anchor w -pady 2 \
+        3,0 $inner.dim -anchor e -pady 2 \
+        3,1 $inner.light -columnspan 2 -pady 2 -fill x \
+        3,3 $inner.bright -anchor w -pady 2 \
+        4,0 $inner.fog -anchor e -pady 2 \
+        4,1 $inner.transp -columnspan 2 -pady 2 -fill x \
+        4,3 $inner.plastic -anchor w -pady 2 \
+        5,0 $inner.thin -anchor e -pady 2 \
+        5,1 $inner.thickness -columnspan 2 -pady 2 -fill x\
+        5,3 $inner.thick -anchor w -pady 2
 
 #        4,0 $inner.clear -anchor e -pady 2 \
@@ -1812 +1825 @@
 
     blt::table configure $inner c0 c1 c3 r* -resize none
-    blt::table configure $inner r5 -resize expand
+    blt::table configure $inner r6 -resize expand
 }
 

branches/nanovis2/packages/vizservers/nanovis/Command.cpp

@@ -1378 +1378 @@
 
 static int
+VolumeShadingLight2SideOp(ClientData clientData, Tcl_Interp *interp, int objc,
+                          Tcl_Obj *const *objv)
+{
+    bool twoSidedLighting;
+    if (GetBooleanFromObj(interp, objv[3], &twoSidedLighting) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    std::vector<Volume *> ivol;
+    if (GetVolumes(interp, objc - 4, objv + 4, &ivol) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    std::vector<Volume *>::iterator iter;
+    for (iter = ivol.begin(); iter != ivol.end(); iter++) {
+        (*iter)->twoSidedLighting(twoSidedLighting);
+    }
+    return TCL_OK;
+}
+
+static int
 VolumeShadingOpacityOp(ClientData clientData, Tcl_Interp *interp, int objc,
                        Tcl_Obj *const *objv)
@@ -1477 +1496 @@
     {"diffuse",       1, VolumeShadingDiffuseOp,     4, 0, "value ?indices?",},
     {"isosurface",    1, VolumeShadingIsosurfaceOp,  4, 0, "bool ?indices?",},
+    {"light2side",    1, VolumeShadingLight2SideOp,  4, 0, "bool ?indices?",},
     {"opacity",       1, VolumeShadingOpacityOp,     4, 0, "value ?indices?",},
     {"specularExp",   9, VolumeShadingSpecularExpOp, 4, 0, "value ?indices?",},

branches/nanovis2/packages/vizservers/nanovis/ConvexPolygon.cpp

@@ -26 +26 @@
 }
 
-// Finds the intersection of the line through 
-// p1 and p2 with the given plane, putting the
-// result in intersect.
-//
-// If the line lies in the plane, an arbitrary 
-// point on the line is returned.
-//
-// http://astronomy.swin.edu.au/pbourke/geometry/planeline/
-bool 
-findIntersection(const Vector4& pt1, const Vector4& pt2, const Vector4& plane, Vector4& ret)
-{
-    float a = plane.x;
-    float b = plane.y;
-    float c = plane.z;
-    float d = plane.w;
-
-    Vector4 p1 = pt1;
-    p1.perspectiveDivide();
-    float x1 = p1.x;
-    float y1 = p1.y;
-    float z1 = p1.z;
-
-    Vector4 p2 = pt2;
-    p2.perspectiveDivide();
-    float x2 = p2.x;
-    float y2 = p2.y;
-    float z2 = p2.z;
-
-    float uDenom = a * (x1 - x2) + b * (y1 - y2) + c * (z1 - z2);
-    float uNumer = a * x1 + b * y1 + c * z1 + d;
-
-    if (uDenom == 0){ 
-        //plane parallel to line
-        ERROR("Unexpected code path: ConvexPolygon.cpp\n");
-        if (uNumer == 0){
-            ret = p1;
-            return true;
-        }
-        return false;
-    }
-
-    float u = uNumer / uDenom;
-    ret.x = x1 + u * (x2 - x1);
-    ret.y = y1 + u * (y2 - y1);
-    ret.z = z1 + u * (z2 - z1);
-    ret.w = 1;
-    return true;
-}
-
 void
 ConvexPolygon::transform(const Mat4x4& mat)
@@ -99 +50 @@
 }
 
-void
+#define SIGN_DIFFERS(x, y) \
+    ( ((x) < 0.0 && (y) > 0.0) || ((x) > 0.0 && (y) < 0.0) )
+
+bool
 ConvexPolygon::clip(Plane& clipPlane, bool copyToTexcoord)
 {
     if (vertices.size() == 0) {
-        //ERROR("ConvexPolygon: polygon has no vertices\n");  
-        return;
+        ERROR("polygon has no vertices\n");
+        return false;
     }
-    
+
     VertexVector clippedVerts;
     clippedVerts.reserve(2 * vertices.size());
@@ -112 +66 @@
     // The algorithm is as follows: for each vertex
     // in the current poly, check to see which 
-    // half space it is in: clipped or retained.
+    // half space it is in: clipped (outside) or inside.
     // If the previous vertex was in the other
-    // half space, find the intersect of that edge
-    // with the clip plane and add that intersect
+    // half space, find the intersection of that edge
+    // with the clip plane and add that intersection
     // point to the new list of vertices.  If the 
-    // current vertex is in the retained half-space,
+    // current vertex is in the inside half-space,
     // add it to the new list as well.
 
-    Vector4 intersect;
     Vector4 plane = clipPlane.getCoeffs();
 
-    bool prevRetained = isRetained(vertices[0], plane);
-    if (prevRetained) 
-        clippedVerts.push_back(vertices[0]);
-
-    for (unsigned int i = 1; i < vertices.size(); i++) {
-        bool retained = isRetained(vertices[i], plane);
-        if (retained != prevRetained) {
-            bool found = findIntersection(vertices[i - 1], vertices[i], 
-                                          plane, intersect);
-            assert(found);
-            clippedVerts.push_back(intersect);
+    // This implementation is based on the Mesa 3D library (MIT license)
+    int v1 = 0;
+    // dot product >= 0 on/inside half-space, < 0 outside half-space
+    float dot1 = vertices[v1] * plane;
+    for (unsigned int i = 1; i <= vertices.size(); i++) {
+        int v2 = (i == vertices.size()) ? 0 : i;
+        float dot2 = vertices[v2] * plane;
+        if (dot1 >= 0.0) {
+            // on/inside
+            clippedVerts.push_back(vertices[v1]);
         }
-        if (retained) {
-            clippedVerts.push_back(vertices[i]);
+        if (SIGN_DIFFERS(dot1, dot2)) {
+            if (dot1 < 0.0) {
+                // outside -> inside
+                double t = dot1 / (dot1 - dot2);
+                clippedVerts.push_back(vlerp(vertices[v1], vertices[v2], t));
+            } else {
+                // inside -> outside
+                double t = dot2 / (dot2 - dot1);
+                clippedVerts.push_back(vlerp(vertices[v2], vertices[v1], t));
+            }
         }
-        prevRetained = retained;
-    }
-
-    bool retained = isRetained(vertices[0], plane);
-    if (retained != prevRetained) {
-        bool found = findIntersection(vertices[vertices.size() - 1], 
-                                      vertices[0], plane, intersect);
-        assert(found);
-        clippedVerts.push_back(intersect);
+        dot1 = dot2;
+        v1 = v2;
     }
 
     vertices.clear();
-    vertices.insert(vertices.begin(), 
-                    clippedVerts.begin(),
-                    clippedVerts.end());
 
-    if (copyToTexcoord)
-        copyVerticesToTexcoords();
+    if (clippedVerts.size() < 3) {
+        texcoords.clear();
+        return false;
+    } else {
+        vertices.insert(vertices.begin(), 
+                        clippedVerts.begin(),
+                        clippedVerts.end());
+
+        if (copyToTexcoord)
+            copyVerticesToTexcoords();
+
+        return true;
+    }
 }
+
+#undef SIGN_DIFFERS
 
 void
@@ -180 +143 @@
             glVertex4fv((float *)&(vertices[i]));
         }
-    } 
+    } else {
+        WARN("No polygons to render\n");
+    }
 }
 
@@ -199 +164 @@
             glVertex4fv((float *)(&tmp));
         }
+    } else {
+        WARN("No polygons to render\n");
     }
 }

branches/nanovis2/packages/vizservers/nanovis/ConvexPolygon.h

@@ -39 +39 @@
 
     // Clips the polygon, retaining the portion where ax + by + cz + d >= 0
-    void clip(Plane& clipPlane, bool copyToTexcoords);
+    bool clip(Plane& clipPlane, bool copyToTexcoords);
 
     void emit(bool useTexture);
@@ -63 +63 @@
     }
 
-    bool isRetained(const Vector4& point, const Vector4& plane)
-    {
-        return ((point * plane) >= 0);  
-    }
-
     VertexVector vertices;
     TexVector texcoords;

branches/nanovis2/packages/vizservers/nanovis/Makefile.in

@@ -155 +155 @@
 shaders         = \
                 $(srcdir)/shaders/common.cg \
+                $(srcdir)/shaders/cutplane_fp.cg \
+                $(srcdir)/shaders/cutplane_vp.cg \
                 $(srcdir)/shaders/heightcolor.cg \
                 $(srcdir)/shaders/one_plane.cg \

branches/nanovis2/packages/vizservers/nanovis/NvRegularVolumeShader.cpp

@@ -39 +39 @@
                      volume->isosurface(),
                      volume->opacityScale(),
-                     0.0f);
+                     (volume->twoSidedLighting() ? 1.0f : 0.0f));
 
     NvShader:: bind();

branches/nanovis2/packages/vizservers/nanovis/Vector3.h

@@ -26 +26 @@
 {
 public:
-    float x, y, z;
-
     Vector3()
     {}
@@ -177 +175 @@
     }
 
+    float x, y, z;
+
 private:
     float radians(float degree) const
@@ -186 +186 @@
 typedef std::vector<Vector3> Vector3Array;
 
+/**
+ * \brief Linear interpolation of 2 vectors
+ */
+inline Vector3 vlerp(const Vector3& v1, const Vector3& v2, double t)
+{
+    return Vector3(v1.x * (1.0-t) + v2.x * t,
+                   v1.y * (1.0-t) + v2.y * t,
+                   v1.z * (1.0-t) + v2.z * t);
+}
+
 #endif

branches/nanovis2/packages/vizservers/nanovis/Vector4.h

@@ -24 +24 @@
 {
 public:
-    float x, y, z, w;
-
     Vector4()
     {}
@@ -79 +77 @@
         return Vector4(x / op2, y / op2, z / op2, w / op2);
     }
+
+    float x, y, z, w;
 };
 
 typedef std::vector<Vector4> Vector4Array;
 
+/**
+ * \brief Linear interpolation of 2 points
+ */
+inline Vector4 vlerp(const Vector4& v1, const Vector4& v2, double t)
+{
+    return Vector4(v1.x * (1.0-t) + v2.x * t,
+                   v1.y * (1.0-t) + v2.y * t,
+                   v1.z * (1.0-t) + v2.z * t,
+                   v1.w * (1.0-t) + v2.w * t);
+}
+
+/**
+ * \brief Finds the intersection of a line through 
+ * p1 and p2 with the given plane.
+ *
+ * If the line lies in the plane, an arbitrary 
+ * point on the line is returned.
+ *
+ * Reference:
+ * http://astronomy.swin.edu.au/pbourke/geometry/planeline/
+ *
+ * \param[in] pt1 First point
+ * \param[in] pt2 Second point
+ * \param[in] plane Plane equation coefficients
+ * \param[out] ret Point of intersection if a solution was found
+ * \return Bool indicating if an intersection was found
+ */
+inline bool 
+planeLineIntersection(const Vector4& pt1, const Vector4& pt2,
+                      const Vector4& plane, Vector4& ret)
+{
+    float a = plane.x;
+    float b = plane.y;
+    float c = plane.z;
+    float d = plane.w;
+
+    Vector4 p1 = pt1;
+    float x1 = p1.x;
+    float y1 = p1.y;
+    float z1 = p1.z;
+
+    Vector4 p2 = pt2;
+    float x2 = p2.x;
+    float y2 = p2.y;
+    float z2 = p2.z;
+
+    float uDenom = a * (x1 - x2) + b * (y1 - y2) + c * (z1 - z2);
+    float uNumer = a * x1 + b * y1 + c * z1 + d;
+
+    if (uDenom == 0.0f) {
+        // Plane parallel to line
+        if (uNumer == 0.0f) {
+            // Line within plane
+            ret = p1;
+            return true;
+        }
+        // No solution
+        TRACE("No intersection between line and plane\n");
+        return false;
+    }
+
+    float u = uNumer / uDenom;
+    ret.x = x1 + u * (x2 - x1);
+    ret.y = y1 + u * (y2 - y1);
+    ret.z = z1 + u * (z2 - z1);
+    ret.w = 1;
+    return true;
+}
+
 #endif

branches/nanovis2/packages/vizservers/nanovis/Volume.cpp

@@ -37 +37 @@
     _specular(0.3f),
     _specularExp(90.0f),
+    _lightTwoSide(false),
     _opacityScale(0.5f),
     _name(NULL),

branches/nanovis2/packages/vizservers/nanovis/Volume.h

@@ -236 +236 @@
     }
 
+    bool twoSidedLighting() const
+    {
+        return _lightTwoSide;
+    }
+
+    void twoSidedLighting(bool value)
+    {
+        _lightTwoSide = value;
+    }
+
     float opacityScale() const
     {
@@ -360 +370 @@
     float _specular;     ///< Specular level material coefficient
     float _specularExp;  ///< Specular exponent
+    bool _lightTwoSide;  ///< Two-sided lighting flag
+
     /**
      * The scale multiplied to the opacity assigned by the 

branches/nanovis2/packages/vizservers/nanovis/VolumeRenderer.cpp

@@ -38 +38 @@
 VolumeRenderer::~VolumeRenderer()
 {
+    delete _cutplaneShader;
     delete _zincBlendeShader;
     delete _regularVolumeShader;
@@ -47 +48 @@
 void VolumeRenderer::initShaders()
 {
+    _cutplaneShader = new NvShader();
+    _cutplaneShader->loadVertexProgram("cutplane_vp.cg", "main");
+    _cutplaneShader->loadFragmentProgram("cutplane_fp.cg", "main");
+
     //standard vertex program
     _stdVertexShader = new NvStdVertexShader();
@@ -102 +107 @@
     for (hPtr = Tcl_FirstHashEntry(&NanoVis::volumeTable, &iter); hPtr != NULL;
          hPtr = Tcl_NextHashEntry(&iter)) {
-        Volume* volPtr;
+        Volume *volPtr;
         volPtr = (Volume *)Tcl_GetHashValue(hPtr);
         if (!volPtr->visible()) {
@@ -226 +231 @@
         actual_slices[i] = n_actual_slices;
 
-        // These are object coordinates
-        Vector4 vert1 = (Vector4(-10, -10, -0.5, 1));
-        Vector4 vert2 = (Vector4(-10, +10, -0.5, 1));
-        Vector4 vert3 = (Vector4(+10, +10, -0.5, 1));
-        Vector4 vert4 = (Vector4(+10, -10, -0.5, 1));
+        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);
+
+        Vector4 vert1, vert2, vert3, vert4;
 
         // Render cutplanes first with depth test enabled.  They will mark the
@@ -237 +241 @@
         // vice versa.
 
-        ConvexPolygon static_poly;
         for (int j = 0; j < volPtr->getCutplaneCount(); j++) {
             if (!volPtr->isCutplaneEnabled(j)) {
@@ -244 +247 @@
             float offset = volPtr->getCutplane(j)->offset;
             int axis = volPtr->getCutplane(j)->orient;
-            
-            if (axis == 3) {
-                vert1 = Vector4(-10, -10, offset, 1);
-                vert2 = Vector4(-10, +10, offset, 1);
-                vert3 = Vector4(+10, +10, offset, 1);
-                vert4 = Vector4(+10, -10, offset, 1);
-                //continue;
-            } else if (axis == 1) {
-                vert1 = Vector4(offset, -10, -10, 1);
-                vert2 = Vector4(offset, +10, -10, 1);
-                vert3 = Vector4(offset, +10, +10, 1);
-                vert4 = Vector4(offset, -10, +10, 1);
-                //continue;
-            } else if (axis == 2) {
-                vert1 = Vector4(-10, offset, -10, 1);
-                vert2 = Vector4(+10, offset, -10, 1);
-                vert3 = Vector4(+10, offset, +10, 1);
-                vert4 = Vector4(-10, offset, +10, 1);
-                //continue;
+
+            switch (axis) {
+            case 1:
+                vert1 = Vector4(offset, 0, 0, 1);
+                vert2 = Vector4(offset, 1, 0, 1);
+                vert3 = Vector4(offset, 1, 1, 1);
+                vert4 = Vector4(offset, 0, 1, 1);
+                break;
+            case 2:
+                vert1 = Vector4(0, offset, 0, 1);
+                vert2 = Vector4(1, offset, 0, 1);
+                vert3 = Vector4(1, offset, 1, 1);
+                vert4 = Vector4(0, offset, 1, 1);
+                break;
+            case 3:
+            default:
+                vert1 = Vector4(0, 0, offset, 1);
+                vert2 = Vector4(1, 0, offset, 1);
+                vert3 = Vector4(1, 1, offset, 1);
+                vert4 = Vector4(0, 1, offset, 1);
+                break;
             }
 
-            vert1 = model_view_no_trans.transform(vert1);
-            vert2 = model_view_no_trans.transform(vert2);
-            vert3 = model_view_no_trans.transform(vert3);
-            vert4 = model_view_no_trans.transform(vert4);
-
-            ConvexPolygon *p = &static_poly;
-            p->vertices.clear();
-
-            p->appendVertex(vert1);
-            p->appendVertex(vert2);
-            p->appendVertex(vert3);
-            p->appendVertex(vert4);
-
-            for (size_t k = 0; k < 6; k++) {
-                p->clip(volume_planes[k], true);
-            }
-
-            p->transform(model_view_no_trans_inverse);
-            p->transform(model_view_trans);
+            Vector4 texcoord1 = vert1;
+            Vector4 texcoord2 = vert2;
+            Vector4 texcoord3 = vert3;
+            Vector4 texcoord4 = vert4;
+
+            _cutplaneShader->bind();
+            _cutplaneShader->setFPTextureParameter("volume", volPtr->textureID());
+            _cutplaneShader->setFPTextureParameter("tf", volPtr->transferFunction()->id());
 
             glPushMatrix();
+            glTranslatef(volPos.x, volPos.y, volPos.z);
             glScalef(volScaling.x, volScaling.y, volScaling.z);
-
-            activateVolumeShader(volPtr, true, 0.0f);
+            _cutplaneShader->setGLStateMatrixVPParameter("modelViewProjMatrix",
+                                                         NvShader::MODELVIEW_PROJECTION_MATRIX);
             glPopMatrix();
 
@@ -294 +289 @@
             glDisable(GL_BLEND);
 
-            glBegin(GL_POLYGON);
-            p->emit(true); 
+            glBegin(GL_QUADS);
+            glTexCoord3f(texcoord1.x, texcoord1.y, texcoord1.z);
+            glVertex3f(vert1.x, vert1.y, vert1.z);
+            glTexCoord3f(texcoord2.x, texcoord2.y, texcoord2.z);
+            glVertex3f(vert2.x, vert2.y, vert2.z);
+            glTexCoord3f(texcoord3.x, texcoord3.y, texcoord3.z);
+            glVertex3f(vert3.x, vert3.y, vert3.z);
+            glTexCoord3f(texcoord4.x, texcoord4.y, texcoord4.z);
+            glVertex3f(vert4.x, vert4.y, vert4.z);
             glEnd();
+
             glDisable(GL_DEPTH_TEST);
-
-            deactivateVolumeShader();
+            _cutplaneShader->disableFPTextureParameter("tf");
+            _cutplaneShader->disableFPTextureParameter("volume");
+            _cutplaneShader->unbind();
         } //done cutplanes
 
-        //Now do volume rendering
+        // Now prepare proxy geometry slices
 
         // Initialize view-aligned quads with eye space bounds of
         // volume
-        vert1 = (Vector4(eyeMinX, eyeMinY, -0.5, 1));
-        vert2 = (Vector4(eyeMaxX, eyeMinY, -0.5, 1));
-        vert3 = (Vector4(eyeMaxX, eyeMaxY, -0.5, 1));
-        vert4 = (Vector4(eyeMinX, eyeMaxY, -0.5, 1));
+        vert1 = Vector4(eyeMinX, eyeMinY, -0.5, 1);
+        vert2 = Vector4(eyeMaxX, eyeMinY, -0.5, 1);
+        vert3 = Vector4(eyeMaxX, eyeMaxY, -0.5, 1);
+        vert4 = Vector4(eyeMinX, eyeMaxY, -0.5, 1);
 
         size_t counter = 0;
 
-        //transform slices and store them
+        // Transform slices and store them
         float slice_z;
         for (size_t j = 0; j < n_actual_slices; j++) {
@@ -337 +341 @@
 
             for (size_t k = 0; k < 6; k++) {
-                poly->clip(volume_planes[k], true);
+                if (!poly->clip(volume_planes[k], true))
+                    break;
             }
 
-            poly->transform(model_view_no_trans_inverse);
-            poly->transform(model_view_trans);
-
-            if (poly->vertices.size() >= 3)
+            if (poly->vertices.size() >= 3) {
+                poly->transform(model_view_no_trans_inverse);
+                poly->transform(model_view_trans);
                 total_rendered_slices++;
+            }
         }
     } //iterate all volumes
@@ -379 +384 @@
         int volume_index = slices[i].volumeId;
         int slice_index = slices[i].sliceId;
-        ConvexPolygon *cur = polys[volume_index][slice_index];
+        ConvexPolygon *currentSlice = polys[volume_index][slice_index];
         float z_step = z_steps[volume_index];
 
@@ -396 +401 @@
 
 #ifdef notdef
-        TRACE("shading slice: volume %s addr=%x slice=%d, volume=%d\n", 
-               volPtr->name(), volPtr, slice_index, volume_index);
+        TRACE("shading slice: volume %s addr=%x slice=%d, volume=%d z_step=%g avgSD=%g\n", 
+              volPtr->name(), volPtr, slice_index, volume_index, z_step, avgSampleDistance);
 #endif
         activateVolumeShader(volPtr, false, sampleRatio);
@@ -403 +408 @@
 
         glBegin(GL_POLYGON);
-        cur->emit(true);
+        currentSlice->emit(true);
         glEnd();
 

branches/nanovis2/packages/vizservers/nanovis/VolumeRenderer.h

@@ -81 +81 @@
     VolumeInterpolator *_volumeInterpolator;
 
-    /** 
-     * shader for rendering a single cubic volume
+    /**
+     * Shader for single slice cutplane render
+     */
+    NvShader *_cutplaneShader;
+
+    /**
+     * Shader for rendering a single cubic volume
      */
     NvRegularVolumeShader *_regularVolumeShader;

branches/nanovis2/packages/vizservers/nanovis/shaders/one_volume.cg

@@ -28 +28 @@
  *   y: isosurface flag (opacity scaling on/off)
  *   z: opacity scale
+ *   w: two-sided lighting
  */
 PixelOut main(v2f IN,
@@ -63 +64 @@
             //lighting computation
 #ifndef LIGHT_TWO_SIDE
-            float normal_dot_light = max(dot(normal, light_vector), 0);
-            float normal_dot_half = max(dot(normal, half_vector), 0);
+            float normal_dot_light = dot(normal, light_vector);
+            float normal_dot_half = dot(normal, half_vector);
+            if (renderParams.w > 0.5) {
+                normal_dot_light = abs(normal_dot_light);
+                normal_dot_half = abs(normal_dot_half);
+            } else {
+                normal_dot_light = max(normal_dot_light, 0);
+                normal_dot_half = max(normal_dot_half, 0);
+            }
 #else
             float normal_dot_light = abs(dot(normal, light_vector));

branches/nanovis2/packages/vizservers/nanovis/shaders/zincblende_volume.cg

@@ -60 +60 @@
     */
 
-    //sample transfor function texture
+    //sample transfer function texture
     float4 color = f4tex1D(tf, sample);