From Eric Wing, added support for outline/shadow and colour gradient effects.

include/osgText/Text

@@ -211,13 +211,124 @@ public:
     
     unsigned int getDrawMode() const { return _drawMode; }
 
+
+    enum BackdropType
+    {
+        DROP_SHADOW_BOTTOM_RIGHT = 0,  // usually the type of shadow you see
+        DROP_SHADOW_CENTER_RIGHT,
+        DROP_SHADOW_TOP_RIGHT,
+        DROP_SHADOW_BOTTOM_CENTER,
+        DROP_SHADOW_TOP_CENTER,
+        DROP_SHADOW_BOTTOM_LEFT,
+        DROP_SHADOW_CENTER_LEFT,
+        DROP_SHADOW_TOP_LEFT,
+        OUTLINE,
+        NONE
+    };
+
+    /**
+     * BackdropType gives you a background shadow text behind your regular 
+     * text. This helps give text extra contrast which can be useful when 
+     * placing text against noisy backgrounds. 
+     * The color of the background shadow text is specified by setBackdropColor().
+     * DROP_SHADOW_BOTTOM_RIGHT will draw backdrop text to the right and down of 
+     * the normal text. Other DROW_SHADOW_* modes do the same for their repective directions.
+     * OUTLINE will draw backdrop text so that it appears the text has an outline
+     * or border around the normal text. This mode is particularly useful against
+     * really noisy backgrounds that may put text on top of things that have 
+     * all types of colors which you don't have control over. 
+     * Some real world examples of this general technique in use that I know of 
+     * are Google Earth, Sid Meier's Pirates (2004 Remake), and Star Control 2 (PC 1993).
+     * The default is NONE.
+     */
+    void setBackdropType(BackdropType type);
+
+    BackdropType getBackdropType() const { return _backdropType; }
+
+    /** 
+     * Sets the amount text is offset to create the backdrop/shadow effect. 
+     * Set the value too high and for example, in OUTLINE mode you will get a "Brady Bunch"
+     * effect where you see duplicates of the text in a 3x3 grid.
+     * Set the value too small and you won't see anything.
+     * The values represent percentages. 1.0 means 100% so a value of 1.0
+     * in DROW_SHADOW_LEFT_CENTER mode would cause each glyph to be echoed
+     * next to it self. So the letter 'e' might look like 'ee'.
+     * Good values tend to be in the 0.03 to 0.10 range (but will be subject
+     * to your specific font and display characteristics).
+     * Note that the text bounding boxes are updated to include backdrop offsets.
+     * However, other metric information such as getCharacterHeight() are unaffected
+     * by this. This means that individual glyph spacing (kerning?) are unchanged 
+     * even when this mode is used.
+     * The default is 0.07 (7% offset).
+     */
+    void setBackdropOffset(float offset = 0.07f);
+    /**
+     * This overloaded version lets you specify the offset for the horizontal
+     * and vertical components separately.
+     */
+    void setBackdropOffset(float horizontal, float vertical);
+
+    float getBackdropHorizontalOffet() const { return _backdropHorizontalOffset; }
+
+    float getBackdropVerticalOffset() const { return _backdropVerticalOffset; }
+
+    /**
+     * This specifies the color of the backdrop text.
+     * The default is black.
+     */
+    void setBackdropColor(const osg::Vec4& color);
+
+    const osg::Vec4& getBackdropColor() const { return _backdropColor; }
+
+
+    enum ColorGradientMode
+    {
+        SOLID = 0, // a.k.a. ColorGradients off
+        PER_CHARACTER,
+        OVERALL
+    };
+
+    /**
+     * This sets different types of text coloring modes.
+     * When the coloring mode is not set to SOLID, the 
+     * colors specified in setColorGradientCorners() determine
+     * the colors for the text.
+     * When the gradient mode is OVERALL, the coloring scheme
+     * attempts to approximate the effect as if the entire text box/region
+     * were a single polygon and you had applied colors to each of the four
+     * corners with GL_SMOOTH enabled. In this mode, OpenGL interpolates
+     * the colors across the polygon, and this is what OVERALL tries to 
+     * emulate. This can be used to give nice embellishments on things 
+     * like logos and names.
+     * PER_CHARACTER is similar to OVERALL except that it applies the 
+     * color interpolation to the four corners of each character instead
+     * of across the overall text box.
+     * The default is SOLID (a.k.a. off).
+     */
+    void setColorGradientMode(ColorGradientMode mode);
+
+    ColorGradientMode getColorGradientMode() const { return _colorGradientMode; }
+
+    /**
+     * Used only for gradient mode, let's you specify the colors of the 4 corners.
+     * If ColorGradients are off, these values are ignored (and the value from setColor() 
+     * is the only one that is relevant.
+     */
+    void setColorGradientCorners(const osg::Vec4& topLeft, const osg::Vec4& bottomLeft, const osg::Vec4& bottomRight, const osg::Vec4& topRight);
+
+    const osg::Vec4& getColorGradientTopLeft() const { return _colorGradientTopLeft; }
+    const osg::Vec4& getColorGradientBottomLeft() const { return _colorGradientBottomLeft; }
+    const osg::Vec4& getColorGradientBottomRight() const { return _colorGradientBottomRight; }
+    const osg::Vec4& getColorGradientTopRight() const { return _colorGradientTopRight; }
+
+
     void setKerningType(KerningType kerningType) { _kerningType = kerningType; }
 
     KerningType getKerningType() const { return _kerningType; }
 
     /** Get the number of wrapped lines - only valid after computeGlyphRepresentation() has been called, returns 0 otherwise */
     unsigned int getLineCount() const { return _lineCount; }
-    
+
     /** Draw the text.*/
     virtual void drawImplementation(osg::State& state) const;
 
@@ -254,6 +365,7 @@ public:
         typedef std::vector<osg::Vec2> Coords2;
         typedef std::vector<osg::Vec3> Coords3;
         typedef std::vector<osg::Vec2> TexCoords;
+        typedef std::vector<osg::Vec4> ColorCoords;
 
         Glyphs                          _glyphs;
         Coords2                         _coords;
@@ -261,6 +373,9 @@ public:
         TexCoords                       _texcoords;
         LineNumbers                     _lineNumbers;
 
+        osg::buffered_object<Coords3>   _transformedBackdropCoords[8];
+        ColorCoords    _colorCoords;
+
         Glyphs getGlyphs() { return _glyphs; }
         const Glyphs getGlyphs() const { return _glyphs; }
 
@@ -272,11 +387,11 @@ public:
 
         TexCoords& getTexCoords() { return _texcoords; }
         const TexCoords& getTexCoords() const { return _texcoords; }
-        
+
         LineNumbers& getLineNumbers() { return _lineNumbers; }
         const LineNumbers& getLineNumbers() const { return _lineNumbers; }
     };
-    
+
     typedef std::map<osg::ref_ptr<osg::StateSet>,GlyphQuads> TextureGlyphQuadMap;
 
     /** Direct Access to GlyphQuads */
@@ -355,7 +470,27 @@ protected:
 
     void computePositions();
     void computePositions(unsigned int contextID) const;
+	
+    void computeBackdropPositions(unsigned int contextID) const;
+    void computeColorGradients() const;
+    void computeColorGradientsOverall() const;
+    void computeColorGradientsPerCharacter() const;
 
+    BackdropType _backdropType;
+    float _backdropHorizontalOffset;
+    float _backdropVerticalOffset;
+    osg::Vec4 _backdropColor;
+
+    ColorGradientMode _colorGradientMode;
+    osg::Vec4 _colorGradientTopLeft;
+    osg::Vec4 _colorGradientBottomLeft;
+    osg::Vec4 _colorGradientBottomRight;
+    osg::Vec4 _colorGradientTopRight;
+
+    // Helper functions for color interpolation
+    float bilinearInterpolate(float x1, float x2, float y1, float y2, float x, float y, float q11, float q12, float q21, float q22) const;
+    void convertHsvToRgb( float hsv[], float rgb[] ) const;
+    void convertRgbToHsv( float rgb[], float hsv[] ) const;
 };
 
 }