From March Sciabica, "Here is the solution I coded up over the weekend. For improved

performance option, I added a flag to control whether the depth writing
pass is performed.

Since text is alpha-blended when rendering, it is placed in the
transparent bin and rendered back to front. Writing to the depth buffer
should therefore be unnecessary. Indeed, rendering something behind text
(or any blended object) after that object is drawn will give incorrect
results whether the depth buffer is written or not. I therefore think it
is safe to keep this option off by default. Users can turn it on for any
special needs they have.

I did not fix the existing backdrop implementations to work with the new
code since this new method of rendering intrinsically handles backdrops
correctly. Its results are more accurate than all of the existing
backdrop implementations. Its only downside is that it requires two
passes if depth buffer updates are desired, whereas DEPTH_RANGE and
POLYGON_OFFSET achieve their (less accurate) results in one pass. The
NO_DEPTH_BUFFER method also only uses one pass, but it disables depth
tests and not depth writes so will have serious problems if anything is
drawn in front of the text before OR after the text is drawn.

Given the better all-around behavior of the new method, I believe the
other backdrop implementations can be safely removed. Code that adjusts
the backdrop implementation will of course be broken if the member
functions are removed. For this reason I left them in, but set the new
rendering method as the default backdrop implementation. At the very
least I think the old backdrop implementations should be deprecated and
removed at a later date.
"

Note from Robert Osfield, testing this submission with osgtext I found that the
text would not render correctly when different text labels were overlapping
in deth and screen space.  I change _enableDepthWrites to default to true and
found the that which artifacts still occurred around the alpha blended edges
the artifacts where better than issue with occlusion of nearer pixels that was
happening with _enableDepthWrites set to false.I therefore set the
_enableDepthWrites to true as I feel it's the lesser of the two artefacts.

include/osgText/Text

@@ -62,6 +62,16 @@ public:
 
     
     
+    /**
+     * Turns off writing to the depth buffer when rendering text. This only affects text
+     * with no backdrop or text using the DELAYED_DEPTH_WRITES implementation, since
+     * the other backdrop implementations are really only useful for backwards
+     * compatibility and are not worth updating to utilize this flag.
+     */
+    bool setEnableDepthWrites() { return _enableDepthWrites; }
+
+    void setEnableDepthWrites(bool enable) { _enableDepthWrites = enable; }
+
     enum BackdropType
     {
         DROP_SHADOW_BOTTOM_RIGHT = 0,  // usually the type of shadow you see
@@ -146,7 +156,17 @@ public:
          * are significant on your particular hardware.) This mode is best for 
          * when quality is important and stencil buffer hardware acceleration 
          * is available.*/
-        STENCIL_BUFFER
+        STENCIL_BUFFER,
+
+        /* DELAYED_DEPTH_WRITES
+         * This mode renders all text with depth writes turned off, then
+         * again with depth writes on, but with the color buffer disabled.
+         * This should render text accurately for all graphics cards. The
+         * only downside is the additional pass to render to the depth
+         * buffer. But if you don't need the depth buffer updated for
+         * your, this extra pass can be disabled by calling
+         * enableDepthWrites(false).*/
+        DELAYED_DEPTH_WRITES
     };
 
     /**
@@ -378,12 +398,16 @@ protected:
 
     void drawImplementation(osg::State& state, const osg::Vec4& colorMultiplier) const;
     void drawForegroundText(osg::State& state, const GlyphQuads& glyphquad, const osg::Vec4& colorMultiplier) const;
+    void drawTextWithBackdrop(osg::State& state, const osg::Vec4& colorMultiplier) const;
     void renderOnlyForegroundText(osg::State& state, const osg::Vec4& colorMultiplier) const;
     void renderWithPolygonOffset(osg::State& state, const osg::Vec4& colorMultiplier) const;
     void renderWithNoDepthBuffer(osg::State& state, const osg::Vec4& colorMultiplier) const;
     void renderWithDepthRange(osg::State& state, const osg::Vec4& colorMultiplier) const;
     void renderWithStencilBuffer(osg::State& state, const osg::Vec4& colorMultiplier) const;
+    void renderWithDelayedDepthWrites(osg::State& state, const osg::Vec4& colorMultiplier) const;
     
+    bool _enableDepthWrites;
+
     BackdropType _backdropType;
     BackdropImplementation _backdropImplementation;