Changeset 3683

Timestamp:

Jun 12, 2013, 2:51:11 AM (11 years ago)

Author:

ldelgass

Message:

Improvements to 3D shapes in vtkvis. Add preliminary, experimental grouping.

Location:

trunk/packages/vizservers/vtkvis

Files:

• Arrow.cpp (modified) (3 diffs)
• Arrow.h (modified) (2 diffs)
• Box.cpp (modified) (2 diffs)
• Box.h (modified) (1 diff)
• Cone.cpp (modified) (3 diffs)
• Cone.h (modified) (1 diff)
• Cylinder.cpp (modified) (2 diffs)
• Disk.cpp (modified) (4 diffs)
• Disk.h (modified) (1 diff)
• GraphicsObject.h (modified) (2 diffs)
• Group.cpp (modified) (2 diffs)
• Group.h (modified) (1 diff)
• Polygon.cpp (modified) (3 diffs)
• Polygon.h (modified) (1 diff)
• RenderServer.h (modified) (1 diff)
• Renderer.cpp (modified) (6 diffs)
• Renderer.h (modified) (12 diffs)
• RendererCmd.cpp (modified) (62 diffs)
• RendererGraphicsObjs.cpp (modified) (17 diffs)
• RendererGraphicsObjs.h (modified) (4 diffs)
• Sphere.cpp (modified) (2 diffs)
• Sphere.h (modified) (2 diffs)
• protocol.txt (modified) (21 diffs)

trunk/packages/vizservers/vtkvis/Arrow.cpp

@@ -9 +9 @@
 #include <vtkActor.h>
 #include <vtkArrowSource.h>
+#include <vtkPolyDataNormals.h>
+#include <vtkReverseSense.h>
 
 #include "Arrow.h"
@@ -37 +39 @@
     }
 
+    vtkSmartPointer<vtkPolyDataNormals> normalFilter = vtkSmartPointer<vtkPolyDataNormals>::New();
+    normalFilter->SetInputConnection(_arrow->GetOutputPort());
+    normalFilter->AutoOrientNormalsOff();
+
     _pdMapper->SetInputConnection(_arrow->GetOutputPort());
 
@@ -44 +50 @@
     _pdMapper->Update();
 }
+
+void Arrow::flipNormals(bool state)
+{
+    if (_arrow == NULL || _pdMapper == NULL)
+        return;
+
+    if (state) {
+        vtkSmartPointer<vtkReverseSense> filter = vtkSmartPointer<vtkReverseSense>::New();
+        filter->ReverseCellsOn();
+        filter->ReverseNormalsOn();
+        filter->SetInputConnection(_arrow->GetOutputPort());
+
+        _pdMapper->SetInputConnection(filter->GetOutputPort());
+    } else {
+        _pdMapper->SetInputConnection(_arrow->GetOutputPort());
+    }
+}

trunk/packages/vizservers/vtkvis/Arrow.h

@@ -58 +58 @@
     }
 
+    /**
+     * \brief Invert head/tail of arrow
+     */
     void setInvert(bool state)
     {
@@ -64 +67 @@
         }
     }
+
+    void flipNormals(bool state);
 
 private:

trunk/packages/vizservers/vtkvis/Box.cpp

@@ -15 +15 @@
 #include <vtkTransform.h>
 #include <vtkCubeSource.h>
+#include <vtkReverseSense.h>
 
 #include "Box.h"
@@ -50 +51 @@
     _pdMapper->Update();
 }
+
+void Box::flipNormals(bool state)
+{
+    if (_box == NULL || _pdMapper == NULL)
+        return;
+
+    if (state) {
+        vtkSmartPointer<vtkReverseSense> filter = vtkSmartPointer<vtkReverseSense>::New();
+        filter->ReverseCellsOn();
+        filter->ReverseNormalsOn();
+        filter->SetInputConnection(_box->GetOutputPort());
+
+        _pdMapper->SetInputConnection(filter->GetOutputPort());
+    } else {
+        _pdMapper->SetInputConnection(_box->GetOutputPort());
+    }
+}

trunk/packages/vizservers/vtkvis/Box.h

@@ -44 +44 @@
     }
 
+    void flipNormals(bool state);
+
 private:
     virtual void update();

trunk/packages/vizservers/vtkvis/Cone.cpp

@@ -9 +9 @@
 #include <vtkActor.h>
 #include <vtkConeSource.h>
+#include <vtkPolyDataNormals.h>
+#include <vtkReverseSense.h>
 
 #include "Cone.h"
@@ -37 +39 @@
     }
 
+    vtkSmartPointer<vtkPolyDataNormals> normalFilter = vtkSmartPointer<vtkPolyDataNormals>::New();
+    normalFilter->SetInputConnection(_cone->GetOutputPort());
+    normalFilter->AutoOrientNormalsOff();
+
     _pdMapper->SetInputConnection(_cone->GetOutputPort());
 
@@ -44 +50 @@
     _pdMapper->Update();
 }
+
+void Cone::flipNormals(bool state)
+{
+    if (_cone == NULL || _pdMapper == NULL)
+        return;
+
+    if (state) {
+        vtkSmartPointer<vtkReverseSense> filter = vtkSmartPointer<vtkReverseSense>::New();
+        filter->ReverseCellsOn();
+        filter->ReverseNormalsOn();
+        filter->SetInputConnection(_cone->GetOutputPort());
+
+        _pdMapper->SetInputConnection(filter->GetOutputPort());
+    } else {
+        _pdMapper->SetInputConnection(_cone->GetOutputPort());
+    }
+}

trunk/packages/vizservers/vtkvis/Cone.h

@@ -77 +77 @@
     }
 
+    void flipNormals(bool state);
+
 private:
     virtual void update();

trunk/packages/vizservers/vtkvis/Cylinder.cpp

@@ -53 +53 @@
     if (state) {
         vtkSmartPointer<vtkReverseSense> filter = vtkSmartPointer<vtkReverseSense>::New();
+        filter->ReverseCellsOn();
+        filter->ReverseNormalsOn();
         filter->SetInputConnection(_cylinder->GetOutputPort());
 
@@ -59 +61 @@
         _pdMapper->SetInputConnection(_cylinder->GetOutputPort());
     }
+    _pdMapper->Update();
 }

trunk/packages/vizservers/vtkvis/Disk.cpp

@@ -10 +10 @@
 #include <vtkDiskSource.h>
 #include <vtkPolyDataNormals.h>
+#include <vtkReverseSense.h>
 
 #include "Disk.h"
@@ -17 +18 @@
 
 Disk::Disk() :
-    Shape(),
-    _flipNormals(false)
+    Shape()
 {
 }
@@ -42 +42 @@
     normalFilter->SetInputConnection(_disk->GetOutputPort());
     normalFilter->AutoOrientNormalsOff();
-    normalFilter->SetFlipNormals(_flipNormals ? 1 : 0);
 
     _pdMapper->SetInputConnection(normalFilter->GetOutputPort());
@@ -54 +53 @@
 void Disk::flipNormals(bool state)
 {
-    if (_flipNormals != state) {
-        _flipNormals = state;
-        update();
+    if (_disk == NULL || _pdMapper == NULL)
+        return;
+
+    if (state) {
+        vtkSmartPointer<vtkReverseSense> filter = vtkSmartPointer<vtkReverseSense>::New();
+        filter->ReverseCellsOn();
+        filter->ReverseNormalsOn();
+        filter->SetInputConnection(_disk->GetOutputPort());
+
+        _pdMapper->SetInputConnection(filter->GetOutputPort());
+    } else {
+        _pdMapper->SetInputConnection(_disk->GetOutputPort());
     }
+    _pdMapper->Update();
 }

trunk/packages/vizservers/vtkvis/Disk.h

@@ -56 +56 @@
     virtual void update();
 
-    bool _flipNormals;
     vtkSmartPointer<vtkDiskSource> _disk;
 };

trunk/packages/vizservers/vtkvis/GraphicsObject.h

@@ -41 +41 @@
         CULL_BACK,
         CULL_FRONT_AND_BACK
+    };
+    enum ShadingModel {
+        SHADE_FLAT = VTK_FLAT,
+        SHADE_GOURAUD = VTK_GOURAUD,
+        SHADE_PHONG = VTK_PHONG
     };
 
@@ -701 +706 @@
                 } else if (vtkVolume::SafeDownCast(prop) != NULL) {
                     vtkVolume::SafeDownCast(prop)->GetProperty()->SetShade((state ? 1 : 0));
+                }
+            }
+        }
+    }
+
+    /**
+     * \brief Set shading interpolation model of the prop
+     */
+    virtual void setShadingModel(ShadingModel state)
+    {
+        if (getActor() != NULL) {
+            getActor()->GetProperty()->SetInterpolation(state);
+        } else if (getAssembly() != NULL) {
+            vtkProp3DCollection *props = getAssembly()->GetParts();
+            vtkProp3D *prop;
+            props->InitTraversal();
+            while ((prop = props->GetNextProp3D()) != NULL) {
+                if (vtkActor::SafeDownCast(prop) != NULL) {
+                    vtkActor::SafeDownCast(prop)->GetProperty()->SetInterpolation(state);
                 }
             }

trunk/packages/vizservers/vtkvis/Group.cpp

@@ -54 +54 @@
 }
 
-void Group::removeChild(const NodeId& name)
+GraphicsObject *Group::removeChild(const NodeId& name)
 {
     NodeHashmap::iterator itr = _nodes.find(name);
     if (itr == _nodes.end()) {
         ERROR("Node not found: '%s'", name.c_str());
-        return;
+        return NULL;
     }
     GraphicsObject *obj = itr->second;
@@ -66 +66 @@
     }
     _nodes.erase(itr);
+    return obj;
 }
 

trunk/packages/vizservers/vtkvis/Group.h

@@ -54 +54 @@
     }
 
-    void removeChild(const NodeId& name);
+    GraphicsObject *removeChild(const NodeId& name);
 
 private:

trunk/packages/vizservers/vtkvis/Polygon.cpp

@@ -9 +9 @@
 #include <vtkActor.h>
 #include <vtkRegularPolygonSource.h>
+#include <vtkPolyDataNormals.h>
+#include <vtkReverseSense.h>
 
 #include "Polygon.h"
@@ -37 +39 @@
     }
 
+    vtkSmartPointer<vtkPolyDataNormals> normalFilter = vtkSmartPointer<vtkPolyDataNormals>::New();
+    normalFilter->SetInputConnection(_polygon->GetOutputPort());
+    normalFilter->AutoOrientNormalsOff();
+
     _pdMapper->SetInputConnection(_polygon->GetOutputPort());
 
@@ -44 +50 @@
     _pdMapper->Update();
 }
+
+void Polygon::flipNormals(bool state)
+{
+    if (_polygon == NULL || _pdMapper == NULL)
+        return;
+
+    if (state) {
+        vtkSmartPointer<vtkReverseSense> filter = vtkSmartPointer<vtkReverseSense>::New();
+        filter->ReverseCellsOn();
+        filter->ReverseNormalsOn();
+        filter->SetInputConnection(_polygon->GetOutputPort());
+
+        _pdMapper->SetInputConnection(filter->GetOutputPort());
+    } else {
+        _pdMapper->SetInputConnection(_polygon->GetOutputPort());
+    }
+    _pdMapper->Update();
+}
+

trunk/packages/vizservers/vtkvis/Polygon.h

@@ -63 +63 @@
     }
 
+    void flipNormals(bool state);
+
 private:
     virtual void update();

trunk/packages/vizservers/vtkvis/RenderServer.h

@@ -16 +16 @@
 class Renderer;
 
-#define VTKVIS_VERSION_STRING "1.3"
+#define VTKVIS_VERSION_STRING "1.4"
 
 #define MSECS_ELAPSED(t1, t2) \

trunk/packages/vizservers/vtkvis/Renderer.cpp

@@ -20 +20 @@
 #include <vtkCamera.h>
 #include <vtkLight.h>
+#include <vtkLightCollection.h>
 #include <vtkCoordinate.h>
 #include <vtkTransform.h>
@@ -124 +125 @@
     //_renderer->SetAmbient(.2, .2, .2);
 
+    _renderer->AutomaticLightCreationOff();
+
     vtkSmartPointer<vtkLight> headlight = vtkSmartPointer<vtkLight>::New();
     headlight->SetLightTypeToHeadlight();
@@ -130 +133 @@
     //headlight->SetAmbientColor(1, 1, 1);
     _renderer->AddLight(headlight);
+
     vtkSmartPointer<vtkLight> skylight = vtkSmartPointer<vtkLight>::New();
     skylight->SetLightTypeToCameraLight();
@@ -138 +142 @@
     //skylight->SetAmbientColor(1, 1, 1);
     _renderer->AddLight(skylight);
+
     _renderer->LightFollowCameraOn();
     _renderWindow = vtkSmartPointer<vtkRenderWindow>::New();
@@ -3177 +3182 @@
     mergeGraphicsObjectBounds<Disk>(bounds, onlyVisible);
     mergeGraphicsObjectBounds<Glyphs>(bounds, onlyVisible);
+    mergeGraphicsObjectBounds<Group>(bounds, onlyVisible);
     mergeGraphicsObjectBounds<HeightMap>(bounds, onlyVisible);
     mergeGraphicsObjectBounds<LIC>(bounds, onlyVisible);
@@ -3818 +3824 @@
 }
 
+int Renderer::addLight(float pos[3])
+{
+    vtkSmartPointer<vtkLight> light = vtkSmartPointer<vtkLight>::New();
+    light->SetLightTypeToCameraLight();
+    light->SetPosition(pos[0], pos[1], pos[2]);
+    light->SetFocalPoint(0, 0, 0);
+    light->PositionalOff();
+    _renderer->AddLight(light);
+    _needsRedraw = true;
+    return (_renderer->GetLights()->GetNumberOfItems()-1);
+}
+
+vtkLight *Renderer::getLight(int lightIdx)
+{
+    vtkLightCollection *lights = _renderer->GetLights();
+    if (lights->GetNumberOfItems() < lightIdx+1)
+        return NULL;
+    lights->InitTraversal();
+    vtkLight *light = NULL;
+    int i = 0;
+    do {
+        light = lights->GetNextItem();
+    } while (i++ < lightIdx);
+    return light;
+}
+
+void Renderer::setLightSwitch(int lightIdx, bool state)
+{
+    vtkLight *light = getLight(lightIdx);
+    if (light == NULL) {
+        ERROR("Unknown light %d", lightIdx);
+        return;
+    }
+    light->SetSwitch((state ? 1 : 0));
+    _needsRedraw = true;
+}
+
 /**
  * \brief Initialize the camera zoom region to include the bounding volume given

trunk/packages/vizservers/vtkvis/Renderer.h

@@ -174 +174 @@
     int getWindowHeight() const;
 
+    // Lights
+
+    int addLight(float pos[3]);
+
+    vtkLight *getLight(int lightIdx);
+
+    void setLightSwitch(int lightIdx, bool state);
+
     // Camera controls
 
@@ -448 +456 @@
     // Generic GraphicsObject methods
 
+    GraphicsObject *getGenericGraphicsObject(const DataSetId& id);
+
     template<class T>
     T *getGraphicsObject(const DataSetId& id);
@@ -499 +509 @@
 
     template<class T>
+    void setGraphicsObjectOrigin(const DataSetId& id, double origin[3]);
+
+    template<class T>
     void setGraphicsObjectPosition(const DataSetId& id, double pos[3]);
 
@@ -519 +532 @@
 
     template<class T>
+    void setGraphicsObjectCullFace(const DataSetId& id, GraphicsObject::CullFace state);
+
+    template<class T>
+    void setGraphicsObjectCulling(const DataSetId& id, bool state);
+
+    template<class T>
     void setGraphicsObjectEdgeVisibility(const DataSetId& id, bool state);
 
@@ -534 +553 @@
 
     template<class T>
+    void setGraphicsObjectShadingModel(const DataSetId& id, GraphicsObject::ShadingModel state);
+
+    template<class T>
     void setGraphicsObjectSpecular(const DataSetId& id, double coeff, double power);
 
@@ -548 +570 @@
     void setGraphicsObjectWireframe(const DataSetId& id, bool state);
 
+    // For Shapes:
+
+    template<class T>
+    void setGraphicsObjectFlipNormals(const DataSetId& id, bool state);
+
     // Arcs
 
-    bool addArc(const DataSetId& id, double pt1[3], double pt2[3]);
+    bool addArc(const DataSetId& id, double center[3], double pt1[3], double pt2[3]);
 
     void setArcResolution(const DataSetId& id, int res);
@@ -556 +583 @@
     // Arrows
 
-    bool addArrow(const DataSetId& id, double tipRadius, double shaftRadius, double tipLength);
+    bool addArrow(const DataSetId& id, double tipRadius, double shaftRadius, double tipLength, bool flipNormals = false);
 
     void setArrowResolution(const DataSetId& id, int resTip, int resShaft);
 
+    // Boxes
+
+    bool addBox(const DataSetId& id, double xLen, double yLen, double zLen, bool flipNormals = false);
+
     // Cones
 
-    bool addCone(const DataSetId& id, double radius, double height, bool cap);
+    bool addCone(const DataSetId& id, double radius, double height, bool cap, bool flipNormals = false);
 
     void setConeResolution(const DataSetId& id, int res);
@@ -628 +659 @@
     // Cylinders
 
-    bool addCylinder(const DataSetId& id, double radius, double height, bool cap);
+    bool addCylinder(const DataSetId& id, double radius, double height, bool cap, bool flipNormals = false);
+
+    void setCylinderCapping(const DataSetId& id, bool state);
 
     void setCylinderResolution(const DataSetId& id, int res);
@@ -634 +667 @@
     // Disks
 
-    bool addDisk(const DataSetId& id, double innerRadius, double outerRadius);
+    bool addDisk(const DataSetId& id, double innerRadius, double outerRadius, bool flipNormals = false);
 
     void setDiskResolution(const DataSetId& id, int resRadial, int resCircum);
@@ -660 +693 @@
     void setGlyphsScaleFactor(const DataSetId& id, double scale);
 
+    // Groups
+
+    bool addGroup(const DataSetId& id, const std::vector<Group::NodeId>& nodeList);
+
+    void addChildrenToGroup(const DataSetId& id, const std::vector<Group::NodeId>& nodeList);
+
+    void removeChildrenFromGroup(const DataSetId& id, const std::vector<Group::NodeId>& nodeList);
+
     // Height maps
 
@@ -732 +773 @@
     // N-sided Regular Polygons
 
-    bool addPolygon(const DataSetId& id, int numSides);
+    bool addPolygon(const DataSetId& id, int numSides, double center[3], double normal[3], double radius);
 
     // PolyData meshes
@@ -755 +796 @@
     // Spheres
 
-    void setSphereSection(const DataSetId& id, double thetaStart, double thetaEnd,
+    bool addSphere(const DataSetId& id, double center[3], double radius, bool flipNormals = false);
+
+    void setSphereSection(const DataSetId& id,
+                          double thetaStart, double thetaEnd,
                           double phiStart, double phiEnd);
 

trunk/packages/vizservers/vtkvis/RendererCmd.cpp

@@ -131 +131 @@
          Tcl_Obj *const *objv)
 {
-    double pt1[3];
-    double pt2[3];
-    if (Tcl_GetDoubleFromObj(interp, objv[2], &pt1[0]) != TCL_OK ||
-        Tcl_GetDoubleFromObj(interp, objv[3], &pt1[1]) != TCL_OK ||
-        Tcl_GetDoubleFromObj(interp, objv[4], &pt1[2]) != TCL_OK ||
-        Tcl_GetDoubleFromObj(interp, objv[5], &pt2[0]) != TCL_OK ||
-        Tcl_GetDoubleFromObj(interp, objv[6], &pt2[1]) != TCL_OK ||
-        Tcl_GetDoubleFromObj(interp, objv[7], &pt2[2]) != TCL_OK) {
-        return TCL_ERROR;
-    }
-    const char *name = Tcl_GetString(objv[8]);
-    if (!g_renderer->addArc(name, pt1, pt2)) {
+    double center[3], pt1[3], pt2[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &center[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &center[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &center[2]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[5], &pt1[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[6], &pt1[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[7], &pt1[2]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[8], &pt2[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[9], &pt2[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[10], &pt2[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    const char *name = Tcl_GetString(objv[11]);
+    if (!g_renderer->addArc(name, center, pt1, pt2)) {
         Tcl_AppendResult(interp, "Failed to create arc", (char*)NULL);
         return TCL_ERROR;
@@ -236 +238 @@
 
 static int
+ArcOriginOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+            Tcl_Obj *const *objv)
+{
+    double origin[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &origin[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &origin[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &origin[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setGraphicsObjectOrigin<Arc>(name, origin);
+    } else {
+        g_renderer->setGraphicsObjectOrigin<Arc>("all", origin);
+    }
+    return TCL_OK;
+}
+
+static int
 ArcPositionOp(ClientData clientData, Tcl_Interp *interp, int objc, 
               Tcl_Obj *const *objv)
@@ -308 +329 @@
 
 static Rappture::CmdSpec arcOps[] = {
-    {"add",       1, ArcAddOp, 9, 9, "x1 y1 z1 x2 y2 z2 name"},
+    {"add",       1, ArcAddOp, 12, 12, "centerX centerY centerZ x1 y1 z1 x2 y2 z2 name"},
     {"color",     1, ArcColorOp, 5, 6, "r g b ?name?"},
     {"delete",    1, ArcDeleteOp, 2, 3, "?name?"},
@@ -314 +335 @@
     {"linewidth", 5, ArcLineWidthOp, 3, 4, "width ?name?"},
     {"opacity",   2, ArcOpacityOp, 3, 4, "value ?name?"},
-    {"orient",    2, ArcOrientOp, 6, 7, "qw qx qy qz ?name?"},
+    {"orient",    4, ArcOrientOp, 6, 7, "qw qx qy qz ?name?"},
+    {"origin",    4, ArcOriginOp, 5, 6, "x y z ?name?"},
     {"pos",       2, ArcPositionOp, 5, 6, "x y z ?name?"},
     {"resolution",1, ArcResolutionOp, 3, 4, "res ?name?"},
@@ -387 +409 @@
 
 static int
+ArrowCullingOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+               Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectCulling<Arrow>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectCulling<Arrow>("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
 ArrowEdgeVisibilityOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                       Tcl_Obj *const *objv)
@@ -399 +438 @@
     } else {
         g_renderer->setGraphicsObjectEdgeVisibility<Arrow>("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+ArrowFlipNormalsOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                   Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectFlipNormals<Arrow>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectFlipNormals<Arrow>("all", state);
     }
     return TCL_OK;
@@ -519 +575 @@
 
 static int
+ArrowOriginOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+              Tcl_Obj *const *objv)
+{
+    double origin[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &origin[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &origin[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &origin[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setGraphicsObjectOrigin<Arrow>(name, origin);
+    } else {
+        g_renderer->setGraphicsObjectOrigin<Arrow>("all", origin);
+    }
+    return TCL_OK;
+}
+
+static int
 ArrowPositionOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                 Tcl_Obj *const *objv)
@@ -575 +650 @@
 
 static int
+ArrowShadingOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+               Tcl_Obj *const *objv)
+{
+    GraphicsObject::ShadingModel shadeModel;
+    const char *str = Tcl_GetString(objv[2]);
+    if (str[0] == 'f' && strcmp(str, "flat") == 0) {
+        shadeModel = GraphicsObject::SHADE_FLAT;
+    } else if (str[0] == 's' && strcmp(str, "smooth") == 0) {
+        shadeModel = GraphicsObject::SHADE_GOURAUD;
+    } else {
+         Tcl_AppendResult(interp, "bad shading option \"", str,
+                         "\": should be one of: 'flat', 'smooth'", (char*)NULL);
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectShadingModel<Arrow>(name, shadeModel);
+    } else {
+        g_renderer->setGraphicsObjectShadingModel<Arrow>("all", shadeModel);
+    }
+    return TCL_OK;
+}
+
+static int
 ArrowVisibleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                Tcl_Obj *const *objv)
@@ -610 +709 @@
 static Rappture::CmdSpec arrowOps[] = {
     {"add",       1, ArrowAddOp, 6, 6, "tipRadius shaftRadius tipLength name"},
-    {"color",     1, ArrowColorOp, 5, 6, "r g b ?name?"},
+    {"color",     2, ArrowColorOp, 5, 6, "r g b ?name?"},
+    {"culling",   2, ArrowCullingOp, 3, 4, "bool ?name?"},
     {"delete",    1, ArrowDeleteOp, 2, 3, "?name?"},
     {"edges",     1, ArrowEdgeVisibilityOp, 3, 4, "bool ?name?"},
+    {"flipnorms", 1, ArrowFlipNormalsOp, 3, 4, "bool ?name?"},
     {"lighting",  3, ArrowLightingOp, 3, 4, "bool ?name?"},
     {"linecolor", 5, ArrowLineColorOp, 5, 6, "r g b ?name?"},
@@ -618 +719 @@
     {"material",  1, ArrowMaterialOp, 6, 7, "ambientCoeff diffuseCoeff specularCoeff specularPower ?name?"},
     {"opacity",   2, ArrowOpacityOp, 3, 4, "value ?name?"},
-    {"orient",    2, ArrowOrientOp, 6, 7, "qw qx qy qz ?name?"},
+    {"orient",    4, ArrowOrientOp, 6, 7, "qw qx qy qz ?name?"},
+    {"origin",    4, ArrowOriginOp, 5, 6, "x y z ?name?"},
     {"pos",       2, ArrowPositionOp, 5, 6, "x y z ?name?"},
     {"resolution",1, ArrowResolutionOp, 4, 5, "tipRes shaftRes ?name?"},
-    {"scale",     1, ArrowScaleOp, 5, 6, "sx sy sz ?name?"},
+    {"scale",     2, ArrowScaleOp, 5, 6, "sx sy sz ?name?"},
+    {"shading",   2, ArrowShadingOp, 3, 4, "val ?name?"},
     {"visible",   1, ArrowVisibleOp, 3, 4, "bool ?name?"},
     {"wireframe", 1, ArrowWireframeOp, 3, 4, "bool ?name?"}
@@ -1603 +1706 @@
          Tcl_Obj *const *objv)
 {
-    const char *name = Tcl_GetString(objv[2]);
-    if (!g_renderer->addGraphicsObject<Box>(name)) {
+    double xLen, yLen, zLen;
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &xLen) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &yLen) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &zLen) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    const char *name = Tcl_GetString(objv[5]);
+    if (!g_renderer->addBox(name, xLen, yLen, zLen)) {
         Tcl_AppendResult(interp, "Failed to create box", (char*)NULL);
         return TCL_ERROR;
@@ -1644 +1753 @@
 
 static int
+BoxCullingOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+             Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectCulling<Box>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectCulling<Box>("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
 BoxEdgeVisibilityOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                     Tcl_Obj *const *objv)
@@ -1656 +1782 @@
     } else {
         g_renderer->setGraphicsObjectEdgeVisibility<Box>("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+BoxFlipNormalsOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                 Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectFlipNormals<Box>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectFlipNormals<Box>("all", state);
     }
     return TCL_OK;
@@ -1776 +1919 @@
 
 static int
+BoxOriginOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+            Tcl_Obj *const *objv)
+{
+    double origin[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &origin[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &origin[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &origin[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setGraphicsObjectOrigin<Box>(name, origin);
+    } else {
+        g_renderer->setGraphicsObjectOrigin<Box>("all", origin);
+    }
+    return TCL_OK;
+}
+
+static int
 BoxPositionOp(ClientData clientData, Tcl_Interp *interp, int objc, 
               Tcl_Obj *const *objv)
@@ -1814 +1976 @@
 
 static int
+BoxShadingOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+             Tcl_Obj *const *objv)
+{
+    GraphicsObject::ShadingModel shadeModel;
+    const char *str = Tcl_GetString(objv[2]);
+    if (str[0] == 'f' && strcmp(str, "flat") == 0) {
+        shadeModel = GraphicsObject::SHADE_FLAT;
+    } else if (str[0] == 's' && strcmp(str, "smooth") == 0) {
+        shadeModel = GraphicsObject::SHADE_GOURAUD;
+    } else {
+         Tcl_AppendResult(interp, "bad shading option \"", str,
+                         "\": should be one of: 'flat', 'smooth'", (char*)NULL);
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectShadingModel<Box>(name, shadeModel);
+    } else {
+        g_renderer->setGraphicsObjectShadingModel<Box>("all", shadeModel);
+    }
+    return TCL_OK;
+}
+
+static int
 BoxVisibleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
              Tcl_Obj *const *objv)
@@ -1848 +2034 @@
 
 static Rappture::CmdSpec boxOps[] = {
-    {"add",       1, BoxAddOp, 3, 3, "name"},
-    {"color",     1, BoxColorOp, 5, 6, "r g b ?name?"},
+    {"add",       1, BoxAddOp, 6, 6, "xLen yLen zLen name"},
+    {"color",     2, BoxColorOp, 5, 6, "r g b ?name?"},
+    {"culling",   2, BoxCullingOp, 3, 4, "bool ?name?"},
     {"delete",    1, BoxDeleteOp, 2, 3, "?name?"},
     {"edges",     1, BoxEdgeVisibilityOp, 3, 4, "bool ?name?"},
+    {"flipnorms", 1, BoxFlipNormalsOp, 3, 4, "bool ?name?"},
     {"lighting",  3, BoxLightingOp, 3, 4, "bool ?name?"},
     {"linecolor", 5, BoxLineColorOp, 5, 6, "r g b ?name?"},
@@ -1857 +2045 @@
     {"material",  1, BoxMaterialOp, 6, 7, "ambientCoeff diffuseCoeff specularCoeff specularPower ?name?"},
     {"opacity",   2, BoxOpacityOp, 3, 4, "value ?name?"},
-    {"orient",    2, BoxOrientOp, 6, 7, "qw qx qy qz ?name?"},
+    {"orient",    4, BoxOrientOp, 6, 7, "qw qx qy qz ?name?"},
+    {"origin",    4, BoxOriginOp, 5, 6, "x y z ?name?"},
     {"pos",       2, BoxPositionOp, 5, 6, "x y z ?name?"},
-    {"scale",     1, BoxScaleOp, 5, 6, "sx sy sz ?name?"},
+    {"scale",     2, BoxScaleOp, 5, 6, "sx sy sz ?name?"},
+    {"shading",   2, BoxShadingOp, 3, 4, "val ?name?"},
     {"visible",   1, BoxVisibleOp, 3, 4, "bool ?name?"},
     {"wireframe", 1, BoxWireframeOp, 3, 4, "bool ?name?"}
@@ -2388 +2578 @@
 
 static int
+ConeCullingOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+              Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectCulling<Cone>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectCulling<Cone>("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
 ConeEdgeVisibilityOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                      Tcl_Obj *const *objv)
@@ -2400 +2607 @@
     } else {
         g_renderer->setGraphicsObjectEdgeVisibility<Cone>("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+ConeFlipNormalsOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                 Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectFlipNormals<Cone>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectFlipNormals<Cone>("all", state);
     }
     return TCL_OK;
@@ -2520 +2744 @@
 
 static int
+ConeOriginOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+             Tcl_Obj *const *objv)
+{
+    double origin[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &origin[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &origin[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &origin[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setGraphicsObjectOrigin<Cone>(name, origin);
+    } else {
+        g_renderer->setGraphicsObjectOrigin<Cone>("all", origin);
+    }
+    return TCL_OK;
+}
+
+static int
 ConePositionOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                Tcl_Obj *const *objv)
@@ -2575 +2818 @@
 
 static int
+ConeShadingOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+              Tcl_Obj *const *objv)
+{
+    GraphicsObject::ShadingModel shadeModel;
+    const char *str = Tcl_GetString(objv[2]);
+    if (str[0] == 'f' && strcmp(str, "flat") == 0) {
+        shadeModel = GraphicsObject::SHADE_FLAT;
+    } else if (str[0] == 's' && strcmp(str, "smooth") == 0) {
+        shadeModel = GraphicsObject::SHADE_GOURAUD;
+    } else {
+         Tcl_AppendResult(interp, "bad shading option \"", str,
+                         "\": should be one of: 'flat', 'smooth'", (char*)NULL);
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectShadingModel<Cone>(name, shadeModel);
+    } else {
+        g_renderer->setGraphicsObjectShadingModel<Cone>("all", shadeModel);
+    }
+    return TCL_OK;
+}
+
+static int
 ConeVisibleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
               Tcl_Obj *const *objv)
@@ -2610 +2877 @@
 static Rappture::CmdSpec coneOps[] = {
     {"add",       1, ConeAddOp, 6, 6, "radius height cap name"},
-    {"color",     1, ConeColorOp, 5, 6, "r g b ?name?"},
+    {"color",     2, ConeColorOp, 5, 6, "r g b ?name?"},
+    {"culling",   2, ConeCullingOp, 3, 4, "bool ?name?"},
     {"delete",    1, ConeDeleteOp, 2, 3, "?name?"},
     {"edges",     1, ConeEdgeVisibilityOp, 3, 4, "bool ?name?"},
+    {"flipnorms", 1, ConeFlipNormalsOp, 3, 4, "bool ?name?"},
     {"lighting",  3, ConeLightingOp, 3, 4, "bool ?name?"},
     {"linecolor", 5, ConeLineColorOp, 5, 6, "r g b ?name?"},
@@ -2618 +2887 @@
     {"material",  1, ConeMaterialOp, 6, 7, "ambientCoeff diffuseCoeff specularCoeff specularPower ?name?"},
     {"opacity",   2, ConeOpacityOp, 3, 4, "value ?name?"},
-    {"orient",    2, ConeOrientOp, 6, 7, "qw qx qy qz ?name?"},
+    {"orient",    4, ConeOrientOp, 6, 7, "qw qx qy qz ?name?"},
+    {"origin",    4, ConeOriginOp, 5, 6, "x y z ?name?"},
     {"pos",       2, ConePositionOp, 5, 6, "x y z ?name?"},
     {"resolution",1, ConeResolutionOp, 3, 4, "res ?name?"},
-    {"scale",     1, ConeScaleOp, 5, 6, "sx sy sz ?name?"},
+    {"scale",     2, ConeScaleOp, 5, 6, "sx sy sz ?name?"},
+    {"shading",   2, ConeShadingOp, 3, 4, "val ?name?"},
     {"visible",   1, ConeVisibleOp, 3, 4, "bool ?name?"},
     {"wireframe", 1, ConeWireframeOp, 3, 4, "bool ?name?"}
@@ -3934 +4205 @@
 
 static int
+CylinderCullingOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                  Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectCulling<Cylinder>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectCulling<Cylinder>("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
 CylinderEdgeVisibilityOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                          Tcl_Obj *const *objv)
@@ -3946 +4234 @@
     } else {
         g_renderer->setGraphicsObjectEdgeVisibility<Cylinder>("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+CylinderFlipNormalsOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                 Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectFlipNormals<Cylinder>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectFlipNormals<Cylinder>("all", state);
     }
     return TCL_OK;
@@ -4066 +4371 @@
 
 static int
+CylinderOriginOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                 Tcl_Obj *const *objv)
+{
+    double origin[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &origin[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &origin[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &origin[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setGraphicsObjectOrigin<Cylinder>(name, origin);
+    } else {
+        g_renderer->setGraphicsObjectOrigin<Cylinder>("all", origin);
+    }
+    return TCL_OK;
+}
+
+static int
 CylinderPositionOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                    Tcl_Obj *const *objv)
@@ -4121 +4445 @@
 
 static int
+CylinderShadingOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                  Tcl_Obj *const *objv)
+{
+    GraphicsObject::ShadingModel shadeModel;
+    const char *str = Tcl_GetString(objv[2]);
+    if (str[0] == 'f' && strcmp(str, "flat") == 0) {
+        shadeModel = GraphicsObject::SHADE_FLAT;
+    } else if (str[0] == 's' && strcmp(str, "smooth") == 0) {
+        shadeModel = GraphicsObject::SHADE_GOURAUD;
+    } else {
+         Tcl_AppendResult(interp, "bad shading option \"", str,
+                         "\": should be one of: 'flat', 'smooth'", (char*)NULL);
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectShadingModel<Cylinder>(name, shadeModel);
+    } else {
+        g_renderer->setGraphicsObjectShadingModel<Cylinder>("all", shadeModel);
+    }
+    return TCL_OK;
+}
+
+static int
 CylinderVisibleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                   Tcl_Obj *const *objv)
@@ -4155 +4503 @@
 
 static Rappture::CmdSpec cylinderOps[] = {
-    {"add",       1, CylinderAddOp, 6, 6, " radius height cap name"},
-    {"color",     1, CylinderColorOp, 5, 6, "r g b ?name?"},
+    {"add",       1, CylinderAddOp, 6, 6, "radius height cap name"},
+    {"color",     2, CylinderColorOp, 5, 6, "r g b ?name?"},
+    {"culling",   2, CylinderCullingOp, 3, 4, "bool ?name?"},
     {"delete",    1, CylinderDeleteOp, 2, 3, "?name?"},
     {"edges",     1, CylinderEdgeVisibilityOp, 3, 4, "bool ?name?"},
+    {"flipnorms", 1, CylinderFlipNormalsOp, 3, 4, "bool ?name?"},
     {"lighting",  3, CylinderLightingOp, 3, 4, "bool ?name?"},
     {"linecolor", 5, CylinderLineColorOp, 5, 6, "r g b ?name?"},
@@ -4164 +4514 @@
     {"material",  1, CylinderMaterialOp, 6, 7, "ambientCoeff diffuseCoeff specularCoeff specularPower ?name?"},
     {"opacity",   2, CylinderOpacityOp, 3, 4, "value ?name?"},
-    {"orient",    2, CylinderOrientOp, 6, 7, "qw qx qy qz ?name?"},
+    {"orient",    4, CylinderOrientOp, 6, 7, "qw qx qy qz ?name?"},
+    {"origin",    4, CylinderOriginOp, 5, 6, "x y z ?name?"},
     {"pos",       2, CylinderPositionOp, 5, 6, "x y z ?name?"},
     {"resolution",1, CylinderResolutionOp, 3, 4, "res ?name?"},
-    {"scale",     1, CylinderScaleOp, 5, 6, "sx sy sz ?name?"},
+    {"scale",     2, CylinderScaleOp, 5, 6, "sx sy sz ?name?"},
+    {"shading",   2, CylinderShadingOp, 3, 4, "val ?name?"},
     {"visible",   1, CylinderVisibleOp, 3, 4, "bool ?name?"},
     {"wireframe", 1, CylinderWireframeOp, 3, 4, "bool ?name?"}
@@ -4668 +5020 @@
 
 static int
+DiskCullingOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+              Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectCulling<Disk>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectCulling<Disk>("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
 DiskEdgeVisibilityOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                      Tcl_Obj *const *objv)
@@ -4680 +5049 @@
     } else {
         g_renderer->setGraphicsObjectEdgeVisibility<Disk>("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+DiskFlipNormalsOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                 Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectFlipNormals<Disk>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectFlipNormals<Disk>("all", state);
     }
     return TCL_OK;
@@ -4800 +5186 @@
 
 static int
+DiskOriginOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+             Tcl_Obj *const *objv)
+{
+    double origin[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &origin[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &origin[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &origin[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setGraphicsObjectOrigin<Disk>(name, origin);
+    } else {
+        g_renderer->setGraphicsObjectOrigin<Disk>("all", origin);
+    }
+    return TCL_OK;
+}
+
+static int
 DiskPositionOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                Tcl_Obj *const *objv)
@@ -4856 +5261 @@
 
 static int
+DiskShadingOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+              Tcl_Obj *const *objv)
+{
+    GraphicsObject::ShadingModel shadeModel;
+    const char *str = Tcl_GetString(objv[2]);
+    if (str[0] == 'f' && strcmp(str, "flat") == 0) {
+        shadeModel = GraphicsObject::SHADE_FLAT;
+    } else if (str[0] == 's' && strcmp(str, "smooth") == 0) {
+        shadeModel = GraphicsObject::SHADE_GOURAUD;
+    } else {
+         Tcl_AppendResult(interp, "bad shading option \"", str,
+                         "\": should be one of: 'flat', 'smooth'", (char*)NULL);
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectShadingModel<Disk>(name, shadeModel);
+    } else {
+        g_renderer->setGraphicsObjectShadingModel<Disk>("all", shadeModel);
+    }
+    return TCL_OK;
+}
+
+static int
 DiskVisibleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
               Tcl_Obj *const *objv)
@@ -4891 +5320 @@
 static Rappture::CmdSpec diskOps[] = {
     {"add",       1, DiskAddOp, 5, 5, "innerRadius outerRadius name"},
-    {"color",     1, DiskColorOp, 5, 6, "r g b ?name?"},
+    {"color",     2, DiskColorOp, 5, 6, "r g b ?name?"},
+    {"culling",   2, DiskCullingOp, 3, 4, "bool ?name?"},
     {"delete",    1, DiskDeleteOp, 2, 3, "?name?"},
     {"edges",     1, DiskEdgeVisibilityOp, 3, 4, "bool ?name?"},
+    {"flipnorms", 1, DiskFlipNormalsOp, 3, 4, "bool ?name?"},
     {"lighting",  3, DiskLightingOp, 3, 4, "bool ?name?"},
     {"linecolor", 5, DiskLineColorOp, 5, 6, "r g b ?name?"},
@@ -4899 +5330 @@
     {"material",  1, DiskMaterialOp, 6, 7, "ambientCoeff diffuseCoeff specularCoeff specularPower ?name?"},
     {"opacity",   2, DiskOpacityOp, 3, 4, "value ?name?"},
-    {"orient",    2, DiskOrientOp, 6, 7, "qw qx qy qz ?name?"},
+    {"orient",    4, DiskOrientOp, 6, 7, "qw qx qy qz ?name?"},
+    {"origin",    4, DiskOriginOp, 5, 6, "x y z ?name?"},
     {"pos",       2, DiskPositionOp, 5, 6, "x y z ?name?"},
     {"resolution",1, DiskResolutionOp, 4, 5, "resRadial resCircum ?name?"},
-    {"scale",     1, DiskScaleOp, 5, 6, "sx sy sz ?name?"},
+    {"scale",     2, DiskScaleOp, 5, 6, "sx sy sz ?name?"},
+    {"shading",   2, DiskShadingOp, 3, 4, "val ?name?"},
     {"visible",   1, DiskVisibleOp, 3, 4, "bool ?name?"},
     {"wireframe", 1, DiskWireframeOp, 3, 4, "bool ?name?"}
@@ -5407 +5840 @@
 
     proc = Rappture::GetOpFromObj(interp, nGlyphsOps, glyphsOps,
+                                  Rappture::CMDSPEC_ARG1, objc, objv, 0);
+    if (proc == NULL) {
+        return TCL_ERROR;
+    }
+    return (*proc) (clientData, interp, objc, objv);
+}
+
+static int
+GroupAddOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+           Tcl_Obj *const *objv)
+{
+    int numNodes;
+    Tcl_Obj **nodes = NULL;
+    if (Tcl_ListObjGetElements(interp, objv[2], &numNodes, &nodes) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    std::vector<Group::NodeId> nodeList;
+    for (int i = 0; i < numNodes; i++) {
+        nodeList.push_back(Tcl_GetString(nodes[i]));
+    }
+    const char *name = Tcl_GetString(objv[3]);
+    if (!g_renderer->addGroup(name, nodeList)) {
+        Tcl_AppendResult(interp, "Failed to create group", (char*)NULL);
+        return TCL_ERROR;
+    }
+    return TCL_OK;
+}
+
+static int
+GroupDeleteOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+              Tcl_Obj *const *objv)
+{
+    if (objc == 3) {
+        const char *name = Tcl_GetString(objv[2]);
+        g_renderer->deleteGraphicsObject<Group>(name);
+    } else {
+        g_renderer->deleteGraphicsObject<Group>("all");
+    }
+    return TCL_OK;
+}
+
+static int
+GroupOrientOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+              Tcl_Obj *const *objv)
+{
+    double quat[4];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &quat[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &quat[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &quat[2]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[5], &quat[3]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 7) {
+        const char *name = Tcl_GetString(objv[6]);
+        g_renderer->setGraphicsObjectOrientation<Group>(name, quat);
+    } else {
+        g_renderer->setGraphicsObjectOrientation<Group>("all", quat);
+    }
+    return TCL_OK;
+}
+
+static int
+GroupOriginOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+              Tcl_Obj *const *objv)
+{
+    double origin[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &origin[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &origin[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &origin[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setGraphicsObjectOrigin<Group>(name, origin);
+    } else {
+        g_renderer->setGraphicsObjectOrigin<Group>("all", origin);
+    }
+    return TCL_OK;
+}
+
+static int
+GroupPositionOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                Tcl_Obj *const *objv)
+{
+    double pos[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &pos[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &pos[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &pos[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setGraphicsObjectPosition<Group>(name, pos);
+    } else {
+        g_renderer->setGraphicsObjectPosition<Group>("all", pos);
+    }
+    return TCL_OK;
+}
+
+static int
+GroupRemoveChildOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                   Tcl_Obj *const *objv)
+{
+    int numNodes;
+    Tcl_Obj **nodes = NULL;
+    if (Tcl_ListObjGetElements(interp, objv[2], &numNodes, &nodes) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    std::vector<Group::NodeId> nodeList;
+    for (int i = 0; i < numNodes; i++) {
+        nodeList.push_back(Tcl_GetString(nodes[i]));
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->removeChildrenFromGroup(name, nodeList);
+    } else {
+        g_renderer->removeChildrenFromGroup("all", nodeList);
+    }
+    return TCL_OK;
+}
+
+static int
+GroupScaleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+             Tcl_Obj *const *objv)
+{
+    double scale[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &scale[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &scale[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &scale[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setGraphicsObjectScale<Group>(name, scale);
+    } else {
+        g_renderer->setGraphicsObjectScale<Group>("all", scale);
+    }
+    return TCL_OK;
+}
+
+static int
+GroupVisibleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+               Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectVisibility<Group>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectVisibility<Group>("all", state);
+    }
+    return TCL_OK;
+}
+
+static Rappture::CmdSpec groupOps[] = {
+    {"add",       1, GroupAddOp, 4, 4, "nodeList groupName"},
+    {"delete",    1, GroupDeleteOp, 2, 3, "?name?"},
+    {"orient",    4, GroupOrientOp, 6, 7, "qw qx qy qz ?name?"},
+    {"origin",    4, GroupOriginOp, 5, 6, "x y z ?name?"},
+    {"pos",       1, GroupPositionOp, 5, 6, "x y z ?name?"},
+    {"remove",    1, GroupRemoveChildOp, 3, 4, "nodeList ?name?"},
+    {"scale",     2, GroupScaleOp, 5, 6, "sx sy sz ?name?"},
+    {"visible",   1, GroupVisibleOp, 3, 4, "bool ?name?"},
+};
+static int nGroupOps = NumCmdSpecs(groupOps);
+
+static int
+GroupCmd(ClientData clientData, Tcl_Interp *interp, int objc, 
+         Tcl_Obj *const *objv)
+{
+    Tcl_ObjCmdProc *proc;
+
+    proc = Rappture::GetOpFromObj(interp, nGroupOps, groupOps,
                                   Rappture::CMDSPEC_ARG1, objc, objv, 0);
     if (proc == NULL) {
@@ -6553 +7162 @@
 
 static int
+LineOriginOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+             Tcl_Obj *const *objv)
+{
+    double origin[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &origin[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &origin[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &origin[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setGraphicsObjectOrigin<Line>(name, origin);
+    } else {
+        g_renderer->setGraphicsObjectOrigin<Line>("all", origin);
+    }
+    return TCL_OK;
+}
+
+static int
 LinePositionOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                Tcl_Obj *const *objv)
@@ -6614 +7242 @@
     {"linewidth", 5, LineLineWidthOp, 3, 4, "width ?name?"},
     {"opacity",   2, LineOpacityOp, 3, 4, "value ?name?"},
-    {"orient",    2, LineOrientOp, 6, 7, "qw qx qy qz ?name?"},
+    {"orient",    4, LineOrientOp, 6, 7, "qw qx qy qz ?name?"},
+    {"origin",    4, LineOriginOp, 5, 6, "x y z ?name?"},
     {"pos",       2, LinePositionOp, 5, 6, "x y z ?name?"},
     {"scale",     2, LineScaleOp, 5, 6, "sx sy sz ?name?"},
@@ -7392 +8021 @@
 
 static int
-PolyDataDeleteOp(ClientData clientData, Tcl_Interp *interp, int objc, 
-                 Tcl_Obj *const *objv)
-{
-    if (objc == 3) {
-        const char *name = Tcl_GetString(objv[2]);
-        g_renderer->deleteGraphicsObject<PolyData>(name);
-    } else {
-        g_renderer->deleteGraphicsObject<PolyData>("all");
-    }
-    return TCL_OK;
-}
-
-static int
 PolyDataColorOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                 Tcl_Obj *const *objv)
@@ -7419 +8035 @@
     } else {
         g_renderer->setGraphicsObjectColor<PolyData>("all", color);
+    }
+    return TCL_OK;
+}
+
+static int
+PolyDataCullingOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                  Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectCulling<PolyData>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectCulling<PolyData>("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+PolyDataDeleteOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                 Tcl_Obj *const *objv)
+{
+    if (objc == 3) {
+        const char *name = Tcl_GetString(objv[2]);
+        g_renderer->deleteGraphicsObject<PolyData>(name);
+    } else {
+        g_renderer->deleteGraphicsObject<PolyData>("all");
     }
     return TCL_OK;
@@ -7556 +8202 @@
 
 static int
+PolyDataOriginOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                 Tcl_Obj *const *objv)
+{
+    double origin[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &origin[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &origin[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &origin[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setGraphicsObjectOrigin<PolyData>(name, origin);
+    } else {
+        g_renderer->setGraphicsObjectOrigin<PolyData>("all", origin);
+    }
+    return TCL_OK;
+}
+
+static int
 PolyDataPointSizeOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                     Tcl_Obj *const *objv)
@@ -7611 +8276 @@
 
 static int
+PolyDataShadingOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                  Tcl_Obj *const *objv)
+{
+    GraphicsObject::ShadingModel shadeModel;
+    const char *str = Tcl_GetString(objv[2]);
+    if (str[0] == 'f' && strcmp(str, "flat") == 0) {
+        shadeModel = GraphicsObject::SHADE_FLAT;
+    } else if (str[0] == 's' && strcmp(str, "smooth") == 0) {
+        shadeModel = GraphicsObject::SHADE_GOURAUD;
+    } else {
+         Tcl_AppendResult(interp, "bad shading option \"", str,
+                         "\": should be one of: 'flat', 'smooth'", (char*)NULL);
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectShadingModel<PolyData>(name, shadeModel);
+    } else {
+        g_renderer->setGraphicsObjectShadingModel<PolyData>("all", shadeModel);
+    }
+    return TCL_OK;
+}
+
+static int
 PolyDataVisibleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                   Tcl_Obj *const *objv)
@@ -7648 +8337 @@
     {"cloudstyle",2, PolyDataCloudStyleOp, 3, 4, "style ?dataSetName?"},
     {"color",     2, PolyDataColorOp, 5, 6, "r g b ?dataSetName?"},
+    {"culling",   2, PolyDataCullingOp, 3, 4, "bool ?name?"},
     {"delete",    1, PolyDataDeleteOp, 2, 3, "?dataSetName?"},
     {"edges",     1, PolyDataEdgeVisibilityOp, 3, 4, "bool ?dataSetName?"},
@@ -7655 +8345 @@
     {"material",  1, PolyDataMaterialOp, 6, 7, "ambientCoeff diffuseCoeff specularCoeff specularPower ?dataSetName?"},
     {"opacity",   2, PolyDataOpacityOp, 3, 4, "value ?dataSetName?"},
-    {"orient",    2, PolyDataOrientOp, 6, 7, "qw qx qy qz ?dataSetName?"},
+    {"orient",    4, PolyDataOrientOp, 6, 7, "qw qx qy qz ?dataSetName?"},
+    {"origin",    4, PolyDataOriginOp, 5, 6, "x y z ?name?"},
     {"pos",       2, PolyDataPositionOp, 5, 6, "x y z ?dataSetName?"},
     {"ptsize",    2, PolyDataPointSizeOp, 3, 4, "size ?dataSetName?"},
-    {"scale",     1, PolyDataScaleOp, 5, 6, "sx sy sz ?dataSetName?"},
+    {"scale",     2, PolyDataScaleOp, 5, 6, "sx sy sz ?dataSetName?"},
+    {"shading",   2, PolyDataShadingOp, 3, 4, "val ?name?"},
     {"visible",   1, PolyDataVisibleOp, 3, 4, "bool ?dataSetName?"},
     {"wireframe", 1, PolyDataWireframeOp, 3, 4, "bool ?dataSetName?"}
@@ -7683 +8375 @@
 {
     int numSides;
-    if (Tcl_GetIntFromObj(interp, objv[2], &numSides) != TCL_OK) {
-        return TCL_ERROR;
-    }
-    const char *name = Tcl_GetString(objv[3]);
-    if (!g_renderer->addPolygon(name, numSides)) {
+    double center[3], normal[3], radius;
+    if (Tcl_GetIntFromObj(interp, objv[2], &numSides) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &center[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &center[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[5], &center[2]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[6], &normal[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[7], &normal[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[8], &normal[2]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[9], &radius) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    const char *name = Tcl_GetString(objv[10]);
+    if (!g_renderer->addPolygon(name, numSides, center, normal, radius)) {
         Tcl_AppendResult(interp, "Failed to create polygon", (char*)NULL);
         return TCL_ERROR;
@@ -7727 +8427 @@
 
 static int
+PolygonCullingOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                 Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectCulling<Polygon>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectCulling<Polygon>("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
 PolygonEdgeVisibilityOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                         Tcl_Obj *const *objv)
@@ -7739 +8456 @@
     } else {
         g_renderer->setGraphicsObjectEdgeVisibility<Polygon>("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+PolygonFlipNormalsOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                 Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectFlipNormals<Polygon>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectFlipNormals<Polygon>("all", state);
     }
     return TCL_OK;
@@ -7859 +8593 @@
 
 static int
+PolygonOriginOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                Tcl_Obj *const *objv)
+{
+    double origin[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &origin[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &origin[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &origin[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setGraphicsObjectOrigin<Polygon>(name, origin);
+    } else {
+        g_renderer->setGraphicsObjectOrigin<Polygon>("all", origin);
+    }
+    return TCL_OK;
+}
+
+static int
 PolygonPositionOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                   Tcl_Obj *const *objv)
@@ -7897 +8650 @@
 
 static int
+PolygonShadingOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                 Tcl_Obj *const *objv)
+{
+    GraphicsObject::ShadingModel shadeModel;
+    const char *str = Tcl_GetString(objv[2]);
+    if (str[0] == 'f' && strcmp(str, "flat") == 0) {
+        shadeModel = GraphicsObject::SHADE_FLAT;
+    } else if (str[0] == 's' && strcmp(str, "smooth") == 0) {
+        shadeModel = GraphicsObject::SHADE_GOURAUD;
+    } else {
+         Tcl_AppendResult(interp, "bad shading option \"", str,
+                         "\": should be one of: 'flat', 'smooth'", (char*)NULL);
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectShadingModel<Polygon>(name, shadeModel);
+    } else {
+        g_renderer->setGraphicsObjectShadingModel<Polygon>("all", shadeModel);
+    }
+    return TCL_OK;
+}
+
+static int
 PolygonVisibleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                  Tcl_Obj *const *objv)
@@ -7931 +8708 @@
 
 static Rappture::CmdSpec polygonOps[] = {
-    {"add",       1, PolygonAddOp, 4, 4, "numSides name"},
+    {"add",       1, PolygonAddOp, 11, 11, "numSides centerX centerY centerZ normalX normalY normalZ radius name"},
     {"color",     1, PolygonColorOp, 5, 6, "r g b ?name?"},
+    {"culling",   2, PolygonCullingOp, 3, 4, "bool ?name?"},
     {"delete",    1, PolygonDeleteOp, 2, 3, "?name?"},
     {"edges",     1, PolygonEdgeVisibilityOp, 3, 4, "bool ?name?"},
+    {"flipnorms", 1, PolygonFlipNormalsOp, 3, 4, "bool ?name?"},
     {"lighting",  3, PolygonLightingOp, 3, 4, "bool ?name?"},
     {"linecolor", 5, PolygonLineColorOp, 5, 6, "r g b ?name?"},
@@ -7940 +8719 @@
     {"material",  1, PolygonMaterialOp, 6, 7, "ambientCoeff diffuseCoeff specularCoeff specularPower ?name?"},
     {"opacity",   2, PolygonOpacityOp, 3, 4, "value ?name?"},
-    {"orient",    2, PolygonOrientOp, 6, 7, "qw qx qy qz ?name?"},
+    {"orient",    4, PolygonOrientOp, 6, 7, "qw qx qy qz ?name?"},
+    {"origin",    4, PolygonOriginOp, 5, 6, "x y z ?name?"},
     {"pos",       2, PolygonPositionOp, 5, 6, "x y z ?name?"},
-    {"scale",     1, PolygonScaleOp, 5, 6, "sx sy sz ?name?"},
+    {"scale",     2, PolygonScaleOp, 5, 6, "sx sy sz ?name?"},
+    {"shading",   2, PolygonShadingOp, 3, 4, "val ?name?"},
     {"visible",   1, PolygonVisibleOp, 3, 4, "bool ?name?"},
     {"wireframe", 1, PolygonWireframeOp, 3, 4, "bool ?name?"}
@@ -8382 +9163 @@
 
 static int
+RendererLightsOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                 Tcl_Obj *const *objv)
+{
+    int idx;
+    bool state;
+    if (Tcl_GetIntFromObj(interp, objv[2], &idx) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (GetBooleanFromObj(interp, objv[3], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    g_renderer->setLightSwitch(idx, state);
+    return TCL_OK;
+}
+
+static int
 RendererTwoSidedLightingOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                            Tcl_Obj *const *objv)
@@ -8404 +9201 @@
     {"clipplane",  1, RendererClipPlaneOp, 5, 5, "axis ratio direction"},
     {"depthpeel",  1, RendererDepthPeelingOp, 3, 3, "bool"},
-    {"light2side", 1, RendererTwoSidedLightingOp, 3, 3, "bool"},
+    {"light2side", 6, RendererTwoSidedLightingOp, 3, 3, "bool"},
+    {"lights",     6, RendererLightsOp, 4, 4, "idx bool"}, 
     {"render",     1, RendererRenderOp, 2, 2, ""}
 };
@@ -8478 +9276 @@
             Tcl_Obj *const *objv)
 {
-    const char *name = Tcl_GetString(objv[2]);
-    if (!g_renderer->addGraphicsObject<Sphere>(name)) {
+    double center[3], radius;
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &center[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &center[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &center[2]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[5], &radius) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    const char *name = Tcl_GetString(objv[6]);
+    if (!g_renderer->addSphere(name, center, radius)) {
         Tcl_AppendResult(interp, "Failed to create sphere", (char*)NULL);
         return TCL_ERROR;
@@ -8519 +9324 @@
 
 static int
+SphereCullingOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectCulling<Sphere>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectCulling<Sphere>("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
 SphereEdgeVisibilityOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                        Tcl_Obj *const *objv)
@@ -8531 +9353 @@
     } else {
         g_renderer->setGraphicsObjectEdgeVisibility<Sphere>("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+SphereFlipNormalsOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                 Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectFlipNormals<Sphere>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectFlipNormals<Sphere>("all", state);
     }
     return TCL_OK;
@@ -8651 +9490 @@
 
 static int
+SphereOriginOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+               Tcl_Obj *const *objv)
+{
+    double origin[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &origin[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &origin[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &origin[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setGraphicsObjectOrigin<Sphere>(name, origin);
+    } else {
+        g_renderer->setGraphicsObjectOrigin<Sphere>("all", origin);
+    }
+    return TCL_OK;
+}
+
+static int
 SpherePositionOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                  Tcl_Obj *const *objv)
@@ -8727 +9585 @@
 
 static int
+SphereShadingOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                Tcl_Obj *const *objv)
+{
+    GraphicsObject::ShadingModel shadeModel;
+    const char *str = Tcl_GetString(objv[2]);
+    if (str[0] == 'f' && strcmp(str, "flat") == 0) {
+        shadeModel = GraphicsObject::SHADE_FLAT;
+    } else if (str[0] == 's' && strcmp(str, "smooth") == 0) {
+        shadeModel = GraphicsObject::SHADE_GOURAUD;
+    } else {
+         Tcl_AppendResult(interp, "bad shading option \"", str,
+                         "\": should be one of: 'flat', 'smooth'", (char*)NULL);
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectShadingModel<Sphere>(name, shadeModel);
+    } else {
+        g_renderer->setGraphicsObjectShadingModel<Sphere>("all", shadeModel);
+    }
+    return TCL_OK;
+}
+
+static int
 SphereVisibleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                 Tcl_Obj *const *objv)
@@ -8761 +9643 @@
 
 static Rappture::CmdSpec sphereOps[] = {
-    {"add",       1, SphereAddOp, 3, 3, "name"},
-    {"color",     1, SphereColorOp, 5, 6, "r g b ?name?"},
+    {"add",       1, SphereAddOp, 7, 7, "centerX centerY centerZ radius name"},
+    {"color",     2, SphereColorOp, 5, 6, "r g b ?name?"},
+    {"culling",   2, SphereCullingOp, 3, 4, "bool ?name?"},
     {"delete",    1, SphereDeleteOp, 2, 3, "?name?"},
     {"edges",     1, SphereEdgeVisibilityOp, 3, 4, "bool ?name?"},
+    {"flipnorms", 1, SphereFlipNormalsOp, 3, 4, "bool ?name?"},
     {"lighting",  3, SphereLightingOp, 3, 4, "bool ?name?"},
     {"linecolor", 5, SphereLineColorOp, 5, 6, "r g b ?name?"},
@@ -8770 +9654 @@
     {"material",  1, SphereMaterialOp, 6, 7, "ambientCoeff diffuseCoeff specularCoeff specularPower ?name?"},
     {"opacity",   2, SphereOpacityOp, 3, 4, "value ?name?"},
-    {"orient",    2, SphereOrientOp, 6, 7, "qw qx qy qz ?name?"},
+    {"orient",    4, SphereOrientOp, 6, 7, "qw qx qy qz ?name?"},
+    {"origin",    4, SphereOriginOp, 5, 6, "x y z ?name?"},
     {"pos",       2, SpherePositionOp, 5, 6, "x y z ?name?"},
     {"resolution",1, SphereResolutionOp, 4, 5, "thetaRes phiRes ?name?"},
     {"scale",     2, SphereScaleOp, 5, 6, "sx sy sz ?name?"},
     {"section",   2, SphereSectionOp, 6, 7, "thetaStart thetaEnd phiStart phiEnd ?name?"},
+    {"shading",   2, SphereShadingOp, 3, 4, "val ?name?"},
     {"visible",   1, SphereVisibleOp, 3, 4, "bool ?name?"},
     {"wireframe", 1, SphereWireframeOp, 3, 4, "bool ?name?"}
@@ -10389 +11275 @@
     Tcl_CreateObjCommand(interp, "disk",        DiskCmd,        clientData, NULL);
     Tcl_CreateObjCommand(interp, "glyphs",      GlyphsCmd,      clientData, NULL);
+    Tcl_CreateObjCommand(interp, "group",       GroupCmd,       clientData, NULL);
     Tcl_CreateObjCommand(interp, "heightmap",   HeightMapCmd,   clientData, NULL);
     Tcl_CreateObjCommand(interp, "imgflush",    ImageFlushCmd,  clientData, NULL);
@@ -10427 +11314 @@
     Tcl_DeleteCommand(interp, "disk");
     Tcl_DeleteCommand(interp, "glyphs");
+    Tcl_DeleteCommand(interp, "group");
     Tcl_DeleteCommand(interp, "heightmap");
     Tcl_DeleteCommand(interp, "imgflush");

trunk/packages/vizservers/vtkvis/RendererGraphicsObjs.cpp

@@ -165 +165 @@
 
 template <>
+void Renderer::deleteGraphicsObject<Group>(const DataSetId& id)
+{
+    GroupHashmap& hashmap = getGraphicsObjectHashmap<Group>();
+    GroupHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = hashmap.begin();
+        doAll = true;
+    } else {
+        itr = hashmap.find(id);
+    }
+    if (itr == hashmap.end()) {
+        ERROR("Group not found: %s", id.c_str());
+        return;
+    }
+
+    TRACE("Deleting Group: %s", id.c_str());
+
+    do {
+        Group *gobj = itr->second;
+        if (gobj->getProp())
+            _renderer->RemoveViewProp(gobj->getProp());
+        if (gobj->getOverlayProp())
+            _renderer->RemoveViewProp(gobj->getOverlayProp());
+
+        std::vector<GraphicsObject *> children;
+        gobj->getChildren(children);
+
+        // Un-grouping children
+        for (std::vector<GraphicsObject *>::iterator citr = children.begin();
+             citr != children.end(); ++citr) {
+            if ((*citr)->getProp())
+                _renderer->AddViewProp((*citr)->getProp());
+            if ((*citr)->getOverlayProp())
+                _renderer->AddViewProp((*citr)->getOverlayProp());
+        }
+
+        delete gobj;
+
+        itr = hashmap.erase(itr);
+    } while (doAll && itr != hashmap.end());
+
+    sceneBoundsChanged();
+    _needsRedraw = true;
+}
+
+template <>
 bool Renderer::addGraphicsObject<Box>(const DataSetId& id)
 {
@@ -262 +311 @@
 using namespace VtkVis;
 
+GraphicsObject *
+Renderer::getGenericGraphicsObject(const DataSetId& id)
+{
+    GraphicsObject *gobj = NULL;
+
+    if ((gobj = getGraphicsObject<Arc>(id)) != NULL) {
+        return gobj;
+    }
+    if ((gobj = getGraphicsObject<Arrow>(id)) != NULL) {
+        return gobj;
+    }
+    if ((gobj = getGraphicsObject<Box>(id)) != NULL) {
+        return gobj;
+    }
+    if ((gobj = getGraphicsObject<Cone>(id)) != NULL) {
+        return gobj;
+    }
+    if ((gobj = getGraphicsObject<Cylinder>(id)) != NULL) {
+        return gobj;
+    }
+    if ((gobj = getGraphicsObject<Disk>(id)) != NULL) {
+        return gobj;
+    }
+    if ((gobj = getGraphicsObject<Line>(id)) != NULL) {
+        return gobj;
+    }
+    if ((gobj = getGraphicsObject<Polygon>(id)) != NULL) {
+        return gobj;
+    }
+    if ((gobj = getGraphicsObject<Sphere>(id)) != NULL) {
+        return gobj;
+    }
+    //
+    if ((gobj = getGraphicsObject<Contour2D>(id)) != NULL) {
+        return gobj;
+    }
+    if ((gobj = getGraphicsObject<Contour3D>(id)) != NULL) {
+        return gobj;
+    }
+    if ((gobj = getGraphicsObject<Cutplane>(id)) != NULL) {
+        return gobj;
+    }
+    if ((gobj = getGraphicsObject<Glyphs>(id)) != NULL) {
+        return gobj;
+    }
+    if ((gobj = getGraphicsObject<HeightMap>(id)) != NULL) {
+        return gobj;
+    }
+    if ((gobj = getGraphicsObject<LIC>(id)) != NULL) {
+        return gobj;
+    }
+    if ((gobj = getGraphicsObject<Molecule>(id)) != NULL) {
+        return gobj;
+    }
+    if ((gobj = getGraphicsObject<Outline>(id)) != NULL) {
+        return gobj;
+    }
+    if ((gobj = getGraphicsObject<PolyData>(id)) != NULL) {
+        return gobj;
+    }
+    if ((gobj = getGraphicsObject<PseudoColor>(id)) != NULL) {
+        return gobj;
+    }
+    if ((gobj = getGraphicsObject<Streamlines>(id)) != NULL) {
+        return gobj;
+    }
+    if ((gobj = getGraphicsObject<Volume>(id)) != NULL) {
+        return gobj;
+    }
+    if ((gobj = getGraphicsObject<Warp>(id)) != NULL) {
+        return gobj;
+    }
+    //
+    if ((gobj = getGraphicsObject<Group>(id)) != NULL) {
+        return gobj;
+    }
+
+    return NULL;
+}
+
 /**
  * \brief Create a new Arc and associate it with an ID
  */
-bool Renderer::addArc(const DataSetId& id, double pt1[3], double pt2[3])
+bool Renderer::addArc(const DataSetId& id, double center[3],
+                      double pt1[3], double pt2[3])
 {
     Arc *gobj;
@@ -288 +418 @@
     }
 
+    gobj->setCenter(center);
     gobj->setEndPoints(pt1, pt2);
 
@@ -330 +461 @@
  * \brief Create a new Arrow and associate it with an ID
  */
-bool Renderer::addArrow(const DataSetId& id, double tipRadius, double shaftRadius, double tipLength)
+bool Renderer::addArrow(const DataSetId& id, double tipRadius,
+                        double shaftRadius, double tipLength,
+                        bool flipNormals)
 {
     Arrow *gobj;
@@ -355 +488 @@
     gobj->setRadii(tipRadius, shaftRadius);
     gobj->setTipLength(tipLength);
+    if (flipNormals)
+        gobj->flipNormals(flipNormals);
 
     getGraphicsObjectHashmap<Arrow>()[id] = gobj;
@@ -394 +529 @@
 
 /**
+ * \brief Create a new Box and associate it with an ID
+ */
+bool Renderer::addBox(const DataSetId& id,
+                      double xLen, double yLen, double zLen,
+                      bool flipNormals)
+{
+    Box *gobj;
+    if ((gobj = getGraphicsObject<Box>(id)) != NULL) {
+        WARN("Replacing existing %s %s", gobj->getClassName(), id.c_str());
+        deleteGraphicsObject<Box>(id);
+    }
+
+    gobj = new Box();
+ 
+    gobj->setDataSet(NULL, this);
+
+    if (gobj->getProp() == NULL &&
+        gobj->getOverlayProp() == NULL) {
+        delete gobj;
+        return false;
+    } else {
+        if (gobj->getProp())
+            _renderer->AddViewProp(gobj->getProp());
+        if (gobj->getOverlayProp())
+            _renderer->AddViewProp(gobj->getOverlayProp());
+    }
+
+    gobj->setSize(xLen, yLen, zLen);
+    if (flipNormals)
+        gobj->flipNormals(flipNormals);
+
+    getGraphicsObjectHashmap<Box>()[id] = gobj;
+
+    sceneBoundsChanged();
+    _needsRedraw = true;
+    return true;
+}
+
+/**
  * \brief Create a new Cone and associate it with an ID
  */
-bool Renderer::addCone(const DataSetId& id, double radius, double height, bool cap)
+bool Renderer::addCone(const DataSetId& id, double radius, double height,
+                       bool cap, bool flipNormals)
 {
     Cone *gobj;
@@ -422 +597 @@
     gobj->setHeight(height);
     gobj->setCapping(cap);
+    if (flipNormals)
+        gobj->flipNormals(flipNormals);
 
     getGraphicsObjectHashmap<Cone>()[id] = gobj;
@@ -1100 +1277 @@
  * \brief Create a new Cylinder and associate it with an ID
  */
-bool Renderer::addCylinder(const DataSetId& id, double radius, double height, bool cap)
+bool Renderer::addCylinder(const DataSetId& id, double radius, double height,
+                           bool cap, bool flipNormals)
 {
     Cylinder *gobj;
@@ -1126 +1304 @@
     gobj->setHeight(height);
     gobj->setCapping(cap);
+    if (flipNormals)
+        gobj->flipNormals(flipNormals);
 
     getGraphicsObjectHashmap<Cylinder>()[id] = gobj;
@@ -1135 +1315 @@
 
 /**
- * \brief Set Cylinder resolution
- */
-void Renderer::setCylinderResolution(const DataSetId& id, int res)
+ * \brief Set Cylinder capping
+ */
+void Renderer::setCylinderCapping(const DataSetId& id, bool state)
 {
     CylinderHashmap::iterator itr;
@@ -1157 +1337 @@
 
     do {
+        itr->second->setCapping(state);
+    } while (doAll && ++itr != _cylinders.end());
+
+    sceneBoundsChanged();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set Cylinder resolution
+ */
+void Renderer::setCylinderResolution(const DataSetId& id, int res)
+{
+    CylinderHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _cylinders.begin();
+        if (itr == _cylinders.end())
+            return;
+        doAll = true;
+    } else {
+        itr = _cylinders.find(id);
+    }
+    if (itr == _cylinders.end()) {
+        ERROR("Cylinder not found: %s", id.c_str());
+        return;
+    }
+
+    do {
         itr->second->setResolution(res);
     } while (doAll && ++itr != _cylinders.end());
@@ -1167 +1377 @@
  * \brief Create a new Disk and associate it with an ID
  */
-bool Renderer::addDisk(const DataSetId& id, double innerRadius, double outerRadius)
+bool Renderer::addDisk(const DataSetId& id,
+                       double innerRadius,
+                       double outerRadius,
+                       bool flipNormals)
 {
     Disk *gobj;
@@ -1191 +1404 @@
 
     gobj->setRadii(innerRadius, outerRadius);
+    if (flipNormals)
+        gobj->flipNormals(flipNormals);
 
     getGraphicsObjectHashmap<Disk>()[id] = gobj;
@@ -1462 +1677 @@
 }
 
+bool Renderer::addGroup(const DataSetId& id, const std::vector<Group::NodeId>& nodeList)
+{
+    if (id.compare("all") == 0) {
+        addChildrenToGroup(id, nodeList);
+        return true;
+    }
+
+    Group *gobj;
+    if ((gobj = getGraphicsObject<Group>(id)) != NULL) {
+        // Group exists, so add nodes to it
+        addChildrenToGroup(id, nodeList);
+        return true;
+    }
+
+    gobj = new Group();
+ 
+    gobj->setDataSet(NULL, this);
+
+    if (gobj->getProp() == NULL &&
+        gobj->getOverlayProp() == NULL) {
+        delete gobj;
+        return false;
+    } else {
+        if (gobj->getProp())
+            _renderer->AddViewProp(gobj->getProp());
+        if (gobj->getOverlayProp())
+            _renderer->AddViewProp(gobj->getOverlayProp());
+    }
+
+    for (std::vector<Group::NodeId>::const_iterator itr = nodeList.begin();
+         itr != nodeList.end(); ++itr) {
+        GraphicsObject *node = getGenericGraphicsObject(*itr);
+        if (node != NULL) {
+            if (node->getProp())
+                _renderer->RemoveViewProp(node->getProp());
+            if (node->getOverlayProp())
+                _renderer->RemoveViewProp(node->getOverlayProp());
+            gobj->addChild(*itr, node);
+        } else {
+            ERROR("Can't find node: %s", itr->c_str());
+        }
+    }
+
+    getGraphicsObjectHashmap<Group>()[id] = gobj;
+
+    sceneBoundsChanged();
+    _needsRedraw = true;
+    return true; 
+}
+
+void Renderer::addChildrenToGroup(const DataSetId& id, const std::vector<Group::NodeId>& nodeList)
+{
+    GroupHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _groups.begin();
+        if (itr == _groups.end())
+            return;
+        doAll = true;
+    } else {
+        itr = _groups.find(id);
+    }
+
+    if (itr == _groups.end()) {
+        ERROR("Group not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        for (std::vector<Group::NodeId>::const_iterator citr = nodeList.begin();
+             citr != nodeList.end(); ++citr) {
+            GraphicsObject *node = getGenericGraphicsObject(*citr);
+            if (node != NULL) {
+                if (node->getProp())
+                    _renderer->RemoveViewProp(node->getProp());
+                if (node->getOverlayProp())
+                    _renderer->RemoveViewProp(node->getOverlayProp());
+                itr->second->addChild(*citr, node);
+            } else {
+                ERROR("Can't find node: %s", citr->c_str());
+            }
+        }
+     } while (doAll && ++itr != _groups.end());
+
+    sceneBoundsChanged();
+    _needsRedraw = true;
+}
+
+void Renderer::removeChildrenFromGroup(const DataSetId& id, const std::vector<Group::NodeId>& nodeList)
+{
+    GroupHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _groups.begin();
+        if (itr == _groups.end())
+            return;
+        doAll = true;
+    } else {
+        itr = _groups.find(id);
+    }
+
+    if (itr == _groups.end()) {
+        ERROR("Group not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        for (std::vector<Group::NodeId>::const_iterator citr = nodeList.begin();
+             citr != nodeList.end(); ++citr) {
+            GraphicsObject *node = getGenericGraphicsObject(*citr);
+            if (node != NULL) {
+                if (node->getProp())
+                    _renderer->AddViewProp(node->getProp());
+                if (node->getOverlayProp())
+                    _renderer->AddViewProp(node->getOverlayProp());
+                assert(node == itr->second->removeChild(*citr));
+            } else {
+                ERROR("Can't find node: %s", citr->c_str());
+            }
+        }
+     } while (doAll && ++itr != _groups.end());
+
+    sceneBoundsChanged();
+    _needsRedraw = true;
+}
+
 /**
  * \brief Create a new HeightMap and associate it with the named DataSet
@@ -2286 +2631 @@
  * \brief Create a new n-sided regular Polygon and associate it with an ID
  */
-bool Renderer::addPolygon(const DataSetId& id, int numSides)
+bool Renderer::addPolygon(const DataSetId& id, int numSides,
+                          double center[3], double normal[3], double radius)
 {
     Polygon *gobj;
@@ -2310 +2656 @@
 
     gobj->setNumberOfSides(numSides);
+    gobj->setCenter(center);
+    gobj->setNormal(normal);
+    gobj->setRadius(radius);
 
     getGraphicsObjectHashmap<Polygon>()[id] = gobj;
@@ -2439 +2788 @@
 
     _needsRedraw = true;
+}
+
+/**
+ * \brief Create a new Sphere and associate it with an ID
+ */
+bool Renderer::addSphere(const DataSetId& id, double center[3], double radius, bool flipNormals)
+{
+    Sphere *gobj;
+    if ((gobj = getGraphicsObject<Sphere>(id)) != NULL) {
+        WARN("Replacing existing %s %s", gobj->getClassName(), id.c_str());
+        deleteGraphicsObject<Sphere>(id);
+    }
+
+    gobj = new Sphere();
+ 
+    gobj->setDataSet(NULL, this);
+
+    if (gobj->getProp() == NULL &&
+        gobj->getOverlayProp() == NULL) {
+        delete gobj;
+        return false;
+    } else {
+        if (gobj->getProp())
+            _renderer->AddViewProp(gobj->getProp());
+        if (gobj->getOverlayProp())
+            _renderer->AddViewProp(gobj->getOverlayProp());
+    }
+
+    gobj->setCenter(center);
+    gobj->setRadius(radius);
+    if (flipNormals)
+        gobj->flipNormals(flipNormals);
+
+    getGraphicsObjectHashmap<Sphere>()[id] = gobj;
+
+    sceneBoundsChanged();
+    _needsRedraw = true;
+    return true;
 }
 

trunk/packages/vizservers/vtkvis/RendererGraphicsObjs.h

@@ -277 +277 @@
 
 /**
+ * \brief Set the prop origin (center of rotation)
+ */
+template<class T>
+void Renderer::setGraphicsObjectOrigin(const DataSetId& id, double origin[3])
+{
+    std::tr1::unordered_map<DataSetId, T *>& hashmap = 
+        getGraphicsObjectHashmap<T>();
+    typename std::tr1::unordered_map<DataSetId, T *>::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = hashmap.begin();
+        if (itr == hashmap.end())
+            return;
+        doAll = true;
+    } else {
+        itr = hashmap.find(id);
+    }
+    if (itr == hashmap.end()) {
+        GO_ERROR(T, "not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setOrigin(origin);
+    } while (doAll && ++itr != hashmap.end());
+
+    sceneBoundsChanged();
+    _needsRedraw = true;
+}
+
+/**
  * \brief Set the prop position in world coords
  */
@@ -479 +512 @@
 
 /**
+ * \brief Set cull face for graphics object
+ */
+template<class T>
+void Renderer::setGraphicsObjectCullFace(const DataSetId& id,
+                                         GraphicsObject::CullFace state)
+{
+    std::tr1::unordered_map<DataSetId, T *>& hashmap = 
+        getGraphicsObjectHashmap<T>();
+    typename std::tr1::unordered_map<DataSetId, T *>::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = hashmap.begin();
+        if (itr == hashmap.end())
+            return;
+        doAll = true;
+    } else {
+        itr = hashmap.find(id);
+    }
+
+    if (itr == hashmap.end()) {
+        GO_ERROR(T, "not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setCullFace(state);
+    } while (doAll && ++itr != hashmap.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set face culling for graphics object
+ */
+template<class T>
+void Renderer::setGraphicsObjectCulling(const DataSetId& id, bool state)
+{
+    std::tr1::unordered_map<DataSetId, T *>& hashmap = 
+        getGraphicsObjectHashmap<T>();
+    typename std::tr1::unordered_map<DataSetId, T *>::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = hashmap.begin();
+        if (itr == hashmap.end())
+            return;
+        doAll = true;
+    } else {
+        itr = hashmap.find(id);
+    }
+
+    if (itr == hashmap.end()) {
+        GO_ERROR(T, "not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setCulling(state);
+    } while (doAll && ++itr != hashmap.end());
+
+    _needsRedraw = true;
+}
+
+/**
  * \brief Turn on/off edges for the given DataSet
  */
@@ -580 +680 @@
 
 /**
+ * \brief Flip normals and front/back faces of the shape geometry
+ */
+template<class T>
+void Renderer::setGraphicsObjectFlipNormals(const DataSetId& id, bool state)
+{
+    std::tr1::unordered_map<DataSetId, T *>& hashmap = 
+        getGraphicsObjectHashmap<T>();
+    typename std::tr1::unordered_map<DataSetId, T *>::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = hashmap.begin();
+        if (itr == hashmap.end())
+            return;
+        doAll = true;
+    } else {
+        itr = hashmap.find(id);
+    }
+    if (itr == hashmap.end()) {
+        GO_ERROR(T, "not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->flipNormals(state);
+    } while (doAll && ++itr != hashmap.end());
+
+    _needsRedraw = true;
+}
+
+/**
  * \brief Set ambient lighting/shading coefficient for the specified DataSet
  */
@@ -638 +770 @@
     do {
         itr->second->setDiffuse(coeff);
+    } while (doAll && ++itr != hashmap.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the shading of the object (flat or smooth)
+ *
+ * Currently Phong shading is not implemented
+ */
+template<class T>
+void Renderer::setGraphicsObjectShadingModel(const DataSetId& id,
+                                             GraphicsObject::ShadingModel state)
+{
+    std::tr1::unordered_map<DataSetId, T *>& hashmap = 
+        getGraphicsObjectHashmap<T>();
+    typename std::tr1::unordered_map<DataSetId, T *>::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = hashmap.begin();
+        if (itr == hashmap.end())
+            return;
+        doAll = true;
+    } else {
+        itr = hashmap.find(id);
+    }
+    if (itr == hashmap.end()) {
+        GO_ERROR(T, "not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setShadingModel(state);
     } while (doAll && ++itr != hashmap.end());
 

trunk/packages/vizservers/vtkvis/Sphere.cpp

@@ -15 +15 @@
 #include <vtkTransform.h>
 #include <vtkSphereSource.h>
+#include <vtkReverseSense.h>
 
 #include "Sphere.h"
@@ -50 +51 @@
     _pdMapper->Update();
 }
+
+void Sphere::flipNormals(bool state)
+{
+    if (_sphere == NULL || _pdMapper == NULL)
+        return;
+
+    if (state) {
+        vtkSmartPointer<vtkReverseSense> filter = vtkSmartPointer<vtkReverseSense>::New();
+        filter->ReverseCellsOn();
+        filter->ReverseNormalsOn();
+        filter->SetInputConnection(_sphere->GetOutputPort());
+
+        _pdMapper->SetInputConnection(filter->GetOutputPort());
+    } else {
+        _pdMapper->SetInputConnection(_sphere->GetOutputPort());
+    }
+}

trunk/packages/vizservers/vtkvis/Sphere.h

@@ -77 +77 @@
     }
 
+    void setCenter(double center[3])
+    {
+        if (_sphere != NULL)
+            _sphere->SetCenter(center);
+    }
+
     void setRadius(double radius)
     {
@@ -82 +88 @@
             _sphere->SetRadius(radius);
     }
+
+    void flipNormals(bool state);
 
 private:

trunk/packages/vizservers/vtkvis/protocol.txt

@@ -248 +248 @@
          Toggle use of two-sided lighting (controls if backfaces are lit with a
          flipped normal)
+renderer lights <lightNum> <bool>
+         Toggle lights on/off.  Light 0 is the headlight, light 1 the skylight
 renderer render
          Force a new image to be rendered - use for advancing animation
@@ -256 +258 @@
 == Graphics objects ==
 
-arc add <pt1X> <pt1Y> <pt1Z> <pt2X> <pt2Y> <pt2Z> <name>
+arc add <centerX> <centerY> <centerZ> <pt1X> <pt1Y> <pt1Z> <pt2X> <pt2Y> <pt2Z> <name>
 arc color <r> <g> <b> <?name?>
 arc delete <?name?>
@@ -263 +265 @@
 arc opacity <val> <?name?>
 arc orient <qw> <qx> <qy> <qz> <?name?>
+arc origin <x> <y> <z> <?name?>
 arc pos <x> <y> <z> <?name?>
 arc resolution <res> <?name?>
@@ -271 +274 @@
       Arrow will have base at 0,0,0 and tip at 1, 0, 0
 arrow color <r> <g> <b> <?name?>
+arrow culling <bool> <?name?>
 arrow delete <?name?>
 arrow edges <bool> <?name?>
+arrow flipnorm <bool> <?name?>
 arrow lighting <bool> <?name?>
 arrow linecolor <r> <g> <b> <?name?>
@@ -279 +284 @@
 arrow opacity <val> <?name?>
 arrow orient <qw> <qx> <qy> <qz> <?name?>
+arrow origin <x> <y> <z> <?name?>
 arrow pos <x> <y> <z> <?name?>
 arrow resolution <tipRes> <shaftRes> <?name?>
 arrow scale <sx> <sy> <sz> <?name?>
+arrow shading <val> <?name?>
+      val = flat|smooth
 arrow visible <bool> <?name?>
 arrow wireframe <bool> <?name?>
 
-box add <name>
+box add <xLen> <yLen> <zLen> <name>
 box color <r> <g> <b> <?name?>
+box culling <bool> <?name?>
 box delete <?name?>
 box edges <bool> <?name?>
+box flipnorm <bool> <?name?>
 box lighting <bool> <?name?>
 box linecolor <r> <g> <b> <?name?>
@@ -295 +305 @@
 box opacity <val> <?name?>
 box orient <qw> <qx> <qy> <qz> <?name?>
+box origin <x> <y> <z> <?name?>
 box pos <x> <y> <z> <?name?>
 box scale <sx> <sy> <sz> <?name?>
+box shading <val> <?name?>
+    val = flat|smooth
 box visible <bool> <?name?>
 box wireframe <bool> <?name?>
@@ -303 +316 @@
      <cap> = boolean flag for cap disks
 cone color <r> <g> <b> <?name?>
+cone culling <bool> <?name?>
 cone delete <?name?>
 cone edges <bool> <?name?>
+cone flipnorm <bool> <?name?>
 cone lighting <bool> <?name?>
 cone linecolor <r> <g> <b> <?name?>
@@ -311 +326 @@
 cone opacity <val> <?name?>
 cone orient <qw> <qx> <qy> <qz> <?name?>
+cone origin <x> <y> <z> <?name?>
 cone pos <x> <y> <z> <?name?>
 cone resolution <res> <?name?>
 cone scale <sx> <sy> <sz> <?name?>
+cone shading <val> <?name?>
+     val = flat|smooth
 cone visible <bool> <?name?>
 cone wireframe <bool> <?name?>
@@ -409 +427 @@
          <cap> = boolean flag for cap disks
 cylinder color <r> <g> <b> <?name?>
+cylinder culling <bool> <?name?>
 cylinder delete <?name?>
 cylinder edges <bool> <?name?>
+cylinder flipnorm <bool> <?name?>
 cylinder lighting <bool> <?name?>
 cylinder linecolor <r> <g> <b> <?name?>
@@ -417 +437 @@
 cylinder opacity <val> <?name?>
 cylinder orient <qw> <qx> <qy> <qz> <?name?>
+cylinder origin <x> <y> <z> <?name?>
 cylinder pos <x> <y> <z> <?name?>
 cylinder resolution <res> <?name?>
 cylinder scale <sx> <sy> <sz> <?name?>
+cylinder shading <val> <?name?>
+         val = flat|smooth
 cylinder visible <bool> <?name?>
 cylinder wireframe <bool> <?name?>
@@ -425 +448 @@
 disk add <innerRadius> <outerRadius> <name>
 disk color <r> <g> <b> <?name?>
+disk culling <bool> <?name?>
 disk delete <?name?>
 disk edges <bool> <?name?>
+disk flipnorm <bool> <?name?>
 disk lighting <bool> <?name?>
 disk linecolor <r> <g> <b> <?name?>
@@ -433 +458 @@
 disk opacity <val> <?name?>
 disk orient <qw> <qx> <qy> <qz> <?name?>
+disk origin <x> <y> <z> <?name?>
 disk pos <x> <y> <z> <?name?>
 disk resolution <resRadial> <resCircum> <?name?>
 disk scale <sx> <sy> <sz> <?name?>
+disk shading <val> <?name?>
+     val = flat|smooth
 disk visible <bool> <?name?>
 disk wireframe <bool> <?name?>
@@ -471 +499 @@
 glyphs visible <bool> <?datasetName?>
 glyphs wireframe <bool> <?datasetName?>
+
+group add <nodeList> <name>
+group delete <?name?>
+group orient <qw> <qx> <qy> <qz> <?name?>
+group origin <x> <y> <z> <?name?>
+group pos <x> <y> <z> <?name?>
+group remove <nodeList> <name>
+group scale <sx> <sy> <sz> <?name?>
+group visible <bool> <?name?>
 
 heightmap add numcontours <n> <heightScale> <?dataSetName?>
@@ -548 +585 @@
 line opacity <val> <?name?>
 line orient <qw> <qx> <qy> <qz> <?name?>
+line origin <x> <y> <z> <?name?>
 line pos <x> <y> <z> <?name?>
 line scale <sx> <sy> <sz> <?name?>
@@ -610 +648 @@
          <style> = mesh | points
 polydata color <r> <g> <b> <?datasetName?>
+polydata culling <bool> <?name?>
 polydata delete <?datasetName?>
 polydata edges <bool> <?datasetName?>
@@ -618 +657 @@
 polydata opacity <val> <?datasetName?>
 polydata orient <qw> <qx> <qy> <qz> <?dataSetName?>
+polydata origin <x> <y> <z> <?name?>
 polydata pos <x> <y> <z> <?dataSetName?>
 polydata ptsize <size> <?dataSetName?>
 polydata scale <sx> <sy> <sz> <?dataSetName?>
+polydata shading <val> <?name?>
+         val = flat|smooth
 polydata visible <bool> <?datasetName?>
 polydata wireframe <bool> <?datasetName?>
 
-polygon add <numSides> <name>
+polygon add <numSides> <centerX> <centerY> <centerZ> <normX> <normY> <normZ> <radius> <name>
 polygon color <r> <g> <b> <?name?>
+polygon culling <bool> <?name?>
 polygon delete <?name?>
 polygon edges <bool> <?name?>
+polygon flipnorm <bool> <?name?>
 polygon lighting <bool> <?name?>
 polygon linecolor <r> <g> <b> <?name?>
@@ -634 +678 @@
 polygon opacity <val> <?name?>
 polygon orient <qw> <qx> <qy> <qz> <?name?>
+polygon origin <x> <y> <z> <?name?>
 polygon pos <x> <y> <z> <?name?>
 polygon scale <sx> <sy> <sz> <?name?>
+polygon shading <val> <?name?>
+        val = flat|smooth
 polygon visible <bool> <?name?>
 polygon wireframe <bool> <?name?>
@@ -668 +715 @@
 pseudocolor wireframe <bool> <?datasetName?>
 
-sphere add <name>
+sphere add <centerX> <centerY> <centerZ> <radius> <name>
 sphere color <r> <g> <b> <?name?>
+sphere culling <bool> <?name?>
 sphere delete <?name?>
 sphere edges <bool> <?name?>
+sphere flipnorm <bool> <?name?>
 sphere lighting <bool> <?name?>
 sphere linecolor <r> <g> <b> <?name?>
@@ -678 +727 @@
 sphere opacity <val> <?name?>
 sphere orient <qw> <qx> <qy> <qz> <?name?>
+sphere origin <x> <y> <z> <?name?>
 sphere pos <x> <y> <z> <?name?>
 sphere resolution <thetaRes> <phiRes> <?name?>
@@ -683 +733 @@
 sphere section <thetaStart> <thetaEnd> <phiStart> <phiEnd> <?name?>
        Angles are in degrees
+sphere shading <val> <?name?>
+       val = flat|smooth
 sphere visible <bool> <?name?>
 sphere wireframe <bool> <?name?>
@@ -785 +837 @@
 warp pos <x> <y> <z> <?dataSetName?>
 warp preinterp <bool> <?dataSetName?>
-     ontrols if VTK's InterpolateScalarsBeforeMapping option is set.
+     Controls if VTK's InterpolateScalarsBeforeMapping option is set.
      Setting this on will give more correct colors, as the interpolation
      is done on texture coordinates that lookup into a 1D texture instead