diff --git a/core/java/android/util/MathUtils.java b/core/java/android/util/MathUtils.java
new file mode 100644
index 0000000..d8509a0
--- /dev/null
+++ b/core/java/android/util/MathUtils.java
@@ -0,0 +1,168 @@
+/*
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.util;
+
+import java.util.Random;
+
+/**
+ * A class that contains utility methods related to numbers.
+ * 
+ * @hide Pending API council approval
+ */
+public final class MathUtils {
+    private static final Random sRandom = new Random();
+    private static final float DEG_TO_RAD = 3.1415926f / 180.0f;
+    private static final float RAD_TO_DEG = 180.0f / 3.1415926f;
+
+    private MathUtils() {
+    }
+
+    public static float abs(float v) {
+        return v > 0 ? v : -v; 
+    }
+
+    public static int constrain(int amount, int low, int high) {
+        return amount < low ? low : (amount > high ? high : amount);
+    }
+
+    public static float constrain(float amount, float low, float high) {
+        return amount < low ? low : (amount > high ? high : amount);
+    }
+
+    public static float log(float a) {
+        return (float) Math.log(a);
+    }
+
+    public static float exp(float a) {
+        return (float) Math.exp(a);
+    }
+
+    public static float pow(float a, float b) {
+        return (float) Math.pow(a, b);
+    }
+
+    public static float max(float a, float b) {
+        return a > b ? a : b;
+    }
+
+    public static float max(int a, int b) {
+        return a > b ? a : b;
+    }
+
+    public static float max(float a, float b, float c) {
+        return a > b ? (a > c ? a : c) : (b > c ? b : c);
+    }
+
+    public static float max(int a, int b, int c) {
+        return a > b ? (a > c ? a : c) : (b > c ? b : c);
+    }
+
+    public static float min(float a, float b) {
+        return a < b ? a : b;
+    }
+
+    public static float min(int a, int b) {
+        return a < b ? a : b;
+    }
+
+    public static float min(float a, float b, float c) {
+        return a < b ? (a < c ? a : c) : (b < c ? b : c);
+    }
+
+    public static float min(int a, int b, int c) {
+        return a < b ? (a < c ? a : c) : (b < c ? b : c);
+    }
+
+    public static float dist(float x1, float y1, float x2, float y2) {
+        final float x = (x2 - x1);
+        final float y = (y2 - y1);
+        return (float) Math.sqrt(x * x + y * y);
+    }
+
+    public static float dist(float x1, float y1, float z1, float x2, float y2, float z2) {
+        final float x = (x2 - x1);
+        final float y = (y2 - y1);
+        final float z = (z2 - z1);
+        return (float) Math.sqrt(x * x + y * y + z * z);
+    }
+
+    public static float mag(float a, float b) {
+        return (float) Math.sqrt(a * a + b * b);
+    }
+
+    public static float mag(float a, float b, float c) {
+        return (float) Math.sqrt(a * a + b * b + c * c);
+    }
+
+    public static float sq(float v) {
+        return v * v;
+    }
+
+    public static float radians(float degrees) {
+        return degrees * DEG_TO_RAD;
+    }
+
+    public static float degress(float radians) {
+        return radians * RAD_TO_DEG;
+    }
+
+    public static float acos(float value) {
+        return (float) Math.acos(value);
+    }
+
+    public static float asin(float value) {
+        return (float) Math.asin(value);
+    }
+
+    public static float atan(float value) {
+        return (float) Math.atan(value);
+    }
+
+    public static float atan2(float a, float b) {
+        return (float) Math.atan2(a, b);
+    }
+
+    public static float tan(float angle) {
+        return (float) Math.tan(angle);
+    }    
+
+    public static float lerp(float start, float stop, float amount) {
+        return start + (stop - start) * amount;
+    }
+    
+    public static int random(int howbig) {
+        return (int) (sRandom.nextFloat() * howbig);
+    }
+
+    public static int random(int howsmall, int howbig) {
+        if (howsmall >= howbig) return howsmall;
+        return (int) (sRandom.nextFloat() * (howbig - howsmall) + howsmall);
+    }
+    
+    public static float random(float howbig) {
+        return sRandom.nextFloat() * howbig;
+    }
+
+    public static float random(float howsmall, float howbig) {
+        if (howsmall >= howbig) return howsmall;
+        return sRandom.nextFloat() * (howbig - howsmall) + howsmall;
+    }
+
+    public static void randomSeed(long seed) {
+        sRandom.setSeed(seed);
+    }
+}
diff --git a/graphics/java/android/graphics/Color.java b/graphics/java/android/graphics/Color.java
index 3fc391c..5cefaa3 100644
--- a/graphics/java/android/graphics/Color.java
+++ b/graphics/java/android/graphics/Color.java
@@ -16,6 +16,8 @@
 
 package android.graphics;
 
+import android.util.MathUtils;
+
 import java.util.HashMap;
 import java.util.Locale;
 
@@ -105,6 +107,92 @@
     }
 
     /**
+     * Returns the hue component of a color int.
+     * 
+     * @return A value between 0.0f and 1.0f
+     * 
+     * @hide Pending API council
+     */
+    public static float hue(int color) {
+        int r = (color >> 16) & 0xFF;
+        int g = (color >> 8) & 0xFF;
+        int b = color & 0xFF;
+
+        int V = Math.max(b, Math.max(r, g));
+        int temp = Math.min(b, Math.min(r, g));
+
+        float H;
+
+        if (V == temp) {
+            H = 0;
+        } else {
+            final float vtemp = (float) (V - temp);
+            final float cr = (V - r) / vtemp;
+            final float cg = (V - g) / vtemp;
+            final float cb = (V - b) / vtemp;
+
+            if (r == V) {
+                H = cb - cg;
+            } else if (g == V) {
+                H = 2 + cr - cb;
+            } else {
+                H = 4 + cg - cr;
+            }
+
+            H /= 6.f;
+            if (H < 0) {
+                H++;
+            }
+        }
+
+        return H;
+    }
+
+    /**
+     * Returns the saturation component of a color int.
+     * 
+     * @return A value between 0.0f and 1.0f
+     * 
+     * @hide Pending API council
+     */
+    public static float saturation(int color) {
+        int r = (color >> 16) & 0xFF;
+        int g = (color >> 8) & 0xFF;
+        int b = color & 0xFF;
+
+
+        int V = Math.max(b, Math.max(r, g));
+        int temp = Math.min(b, Math.min(r, g));
+
+        float S;
+
+        if (V == temp) {
+            S = 0;
+        } else {
+            S = (V - temp) / (float) V;
+        }
+
+        return S;
+    }
+
+    /**
+     * Returns the brightness component of a color int.
+     * 
+     * @return A value between 0.0f and 1.0f
+     * 
+     * @hide Pending API council
+     */
+    public static float brightness(int color) {
+        int r = (color >> 16) & 0xFF;
+        int g = (color >> 8) & 0xFF;
+        int b = color & 0xFF;
+
+        int V = Math.max(b, Math.max(r, g));
+
+        return (V / 255.f);
+    }
+
+    /**
      * Parse the color string, and return the corresponding color-int.
      * If the string cannot be parsed, throws an IllegalArgumentException
      * exception. Supported formats are:
@@ -134,6 +222,87 @@
     }
 
     /**
+     * Convert HSB components to an ARGB color. Alpha set to 0xFF.
+     *     hsv[0] is Hue [0 .. 1)
+     *     hsv[1] is Saturation [0...1]
+     *     hsv[2] is Value [0...1]
+     * If hsv values are out of range, they are pinned.
+     * @param hsb  3 element array which holds the input HSB components.
+     * @return the resulting argb color
+     * 
+     * @hide Pending API council
+     */
+    public static int HSBtoColor(float[] hsb) {
+        return HSBtoColor(hsb[0], hsb[1], hsb[2]);
+    }
+    
+    /**
+     * Convert HSB components to an ARGB color. Alpha set to 0xFF.
+     *     hsv[0] is Hue [0 .. 1)
+     *     hsv[1] is Saturation [0...1]
+     *     hsv[2] is Value [0...1]
+     * If hsv values are out of range, they are pinned.
+     * @param h Hue component
+     * @param s Saturation component
+     * @param b Brightness component
+     * @return the resulting argb color
+     * 
+     * @hide Pending API council
+     */
+    public static int HSBtoColor(float h, float s, float b) {
+        h = MathUtils.constrain(h, 0.0f, 1.0f);
+        s = MathUtils.constrain(s, 0.0f, 1.0f);
+        b = MathUtils.constrain(b, 0.0f, 1.0f);
+        
+        float red = 0.0f;
+        float green = 0.0f;
+        float blue = 0.0f;
+        
+        final float hf = (h - (int) h) * 6.0f;
+        final int ihf = (int) hf;
+        final float f = hf - ihf;
+        final float pv = b * (1.0f - s);
+        final float qv = b * (1.0f - s * f);
+        final float tv = b * (1.0f - s * (1.0f - f));
+
+        switch (ihf) {
+            case 0:         // Red is the dominant color
+                red = b;
+                green = tv;
+                blue = pv;
+                break;
+            case 1:         // Green is the dominant color
+                red = qv;
+                green = b;
+                blue = pv;
+                break;
+            case 2:
+                red = pv;
+                green = b;
+                blue = tv;
+                break;
+            case 3:         // Blue is the dominant color
+                red = pv;
+                green = qv;
+                blue = b;
+                break;
+            case 4:
+                red = tv;
+                green = pv;
+                blue = b;
+                break;
+            case 5:         // Red is the dominant color
+                red = b;
+                green = pv;
+                blue = qv;
+                break;
+        }
+
+        return 0xFF000000 | (((int) (red * 255.0f)) << 16) |
+                (((int) (green * 255.0f)) << 8) | ((int) (blue * 255.0f));
+    }
+
+    /**
      * Convert RGB components to HSV.
      *     hsv[0] is Hue [0 .. 360)
      *     hsv[1] is Saturation [0...1]
@@ -193,25 +362,24 @@
         return nativeHSVToColor(alpha, hsv);
     }
 
-    private static native void nativeRGBToHSV(int red, int greed, int blue,
-                                              float hsv[]);
+    private static native void nativeRGBToHSV(int red, int greed, int blue, float hsv[]); 
     private static native int nativeHSVToColor(int alpha, float hsv[]);
 
     private static final HashMap<String, Integer> sColorNameMap;
 
     static {
-        sColorNameMap = new HashMap();
-        sColorNameMap.put("black", Integer.valueOf(BLACK));
-        sColorNameMap.put("darkgray", Integer.valueOf(DKGRAY));
-        sColorNameMap.put("gray", Integer.valueOf(GRAY));
-        sColorNameMap.put("lightgray", Integer.valueOf(LTGRAY));
-        sColorNameMap.put("white", Integer.valueOf(WHITE));
-        sColorNameMap.put("red", Integer.valueOf(RED));
-        sColorNameMap.put("green", Integer.valueOf(GREEN));
-        sColorNameMap.put("blue", Integer.valueOf(BLUE));
-        sColorNameMap.put("yellow", Integer.valueOf(YELLOW));
-        sColorNameMap.put("cyan", Integer.valueOf(CYAN));
-        sColorNameMap.put("magenta", Integer.valueOf(MAGENTA));
+        sColorNameMap = new HashMap<String, Integer>();
+        sColorNameMap.put("black", BLACK);
+        sColorNameMap.put("darkgray", DKGRAY);
+        sColorNameMap.put("gray", GRAY);
+        sColorNameMap.put("lightgray", LTGRAY);
+        sColorNameMap.put("white", WHITE);
+        sColorNameMap.put("red", RED);
+        sColorNameMap.put("green", GREEN);
+        sColorNameMap.put("blue", BLUE);
+        sColorNameMap.put("yellow", YELLOW);
+        sColorNameMap.put("cyan", CYAN);
+        sColorNameMap.put("magenta", MAGENTA);
     }
 }
 
diff --git a/libs/rs/java/Grass/res/raw/grass.c b/libs/rs/java/Grass/res/raw/grass.c
index b1b89f0..3cedaba6 100644
--- a/libs/rs/java/Grass/res/raw/grass.c
+++ b/libs/rs/java/Grass/res/raw/grass.c
@@ -1,21 +1,19 @@
-/*
- * Copyright (C) 2008 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
- 
+// Copyright (C) 2009 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 #pragma version(1)
-#pragma stateVertex(default)
+#pragma stateVertex(PVBackground)
 #pragma stateFragment(PFBackground)
 #pragma stateFragmentStore(PFSBackground)
 
@@ -23,7 +21,8 @@
 #define WVGA_PORTRAIT_HEIGHT 762.0f
 
 #define RSID_STATE 0
-#define RSID_FRAMECOUNT 0
+#define RSID_FRAME_COUNT 0
+#define RSID_BLADES_COUNT 1
 
 #define RSID_SKY_TEXTURES 1
 #define RSID_SKY_TEXTURE_NIGHT 0
@@ -31,6 +30,21 @@
 #define RSID_SKY_TEXTURE_NOON 2
 #define RSID_SKY_TEXTURE_SUNSET 3
 
+#define RSID_BLADES 2
+#define BLADE_STRUCT_FIELDS_COUNT 12
+#define BLADE_STRUCT_DEGREE 0
+#define BLADE_STRUCT_SIZE 1
+#define BLADE_STRUCT_XPOS 2
+#define BLADE_STRUCT_YPOS 3
+#define BLADE_STRUCT_OFFSET 4
+#define BLADE_STRUCT_SCALE 5
+#define BLADE_STRUCT_LENGTHX 6
+#define BLADE_STRUCT_LENGTHY 7
+#define BLADE_STRUCT_HARDNESS 8
+#define BLADE_STRUCT_H 9
+#define BLADE_STRUCT_S 10
+#define BLADE_STRUCT_B 11
+
 #define MIDNIGHT 0.0f
 #define MORNING 0.375f
 #define AFTERNOON 0.6f
@@ -38,6 +52,8 @@
 
 #define SECONDS_IN_DAY 24.0f * 3600.0f
 
+#define PI 3.1415926f
+
 #define REAL_TIME 0
 
 float time(int frameCount) {
@@ -76,8 +92,78 @@
     drawRect(0.0f, 0.0f, WVGA_PORTRAIT_WIDTH, WVGA_PORTRAIT_HEIGHT, 0.0f);
 }
 
+void drawBlade(int index, float now) {
+    float h = loadF(RSID_BLADES, index + BLADE_STRUCT_H);
+    float s = loadF(RSID_BLADES, index + BLADE_STRUCT_S);
+    float b = loadF(RSID_BLADES, index + BLADE_STRUCT_B);
+
+    float newB = 1.0f;
+    if (now >= MIDNIGHT && now < MORNING) {
+        newB = now / MORNING;
+    }
+
+    if (now >= AFTERNOON && now < DUSK) {
+        newB = 1.0f - ((now - AFTERNOON) / (DUSK - AFTERNOON));
+    }
+
+    if (now >= DUSK) {
+        newB = 0.0f;
+    }
+
+    hsb(h, s, lerpf(0, b, newB), 1.0f);
+    
+    float scale = loadF(RSID_BLADES, index + BLADE_STRUCT_SCALE);
+    float degree = loadF(RSID_BLADES, index + BLADE_STRUCT_DEGREE);
+    float hardness = loadF(RSID_BLADES, index + BLADE_STRUCT_HARDNESS);
+
+    float targetDegree = 0.0f; // TODO Compute
+    degree += (targetDegree - degree) * 0.3f;
+    
+    float xpos = loadF(RSID_BLADES, index + BLADE_STRUCT_XPOS);
+    float ypos = loadF(RSID_BLADES, index + BLADE_STRUCT_YPOS);
+
+    float lengthX = loadF(RSID_BLADES, index + BLADE_STRUCT_LENGTHX);
+    float lengthY = loadF(RSID_BLADES, index + BLADE_STRUCT_LENGTHY);
+
+    float angle = PI / 2.0f;
+    
+    float currentX = xpos;
+    float currentY = ypos;
+    
+    int size = loadF(RSID_BLADES, index + BLADE_STRUCT_SIZE);
+    int i = size;
+
+    for ( ; i > 0; i--) {
+        float nextX = currentX - cosf(angle) * size * lengthX;
+        float nextY = currentY - sinf(angle) * size * lengthY;
+        angle += degree * hardness;
+
+        drawQuad(nextX + (i - 1) * scale, nextY, 0.0f,
+                 nextX - (i - 1) * scale, nextY, 0.0f,
+                 currentX - i * scale, currentY + 0.7f, 0.0f,
+                 currentX + i * scale, currentY + 0.7f, 0.0f);
+
+        currentX = nextX;
+        currentY = nextY;
+    }
+    
+    storeF(RSID_BLADES, index + BLADE_STRUCT_DEGREE, degree);
+}
+
+void drawBlades(float now) {
+    bindTexture(NAMED_PFBackground, 0, 0);    
+
+    int bladesCount = loadI32(RSID_STATE, RSID_BLADES_COUNT);
+    int count = bladesCount * BLADE_STRUCT_FIELDS_COUNT;
+
+    int i = 0;
+    for ( ; i < count; i += BLADE_STRUCT_FIELDS_COUNT) {
+        drawBlade(i, now);
+    }
+}
+
 int main(int launchID) {
-    int frameCount = loadI32(RSID_STATE, RSID_FRAMECOUNT);
+    int frameCount = loadI32(RSID_STATE, RSID_FRAME_COUNT);
     float now = time(frameCount);
     alpha(1.0f);
 
@@ -100,13 +186,15 @@
     }
     
     if (now >= DUSK) {
-        drawSunset();
-        alpha(norm(now, DUSK, 1.0f));
         drawNight();
+        alpha(1.0f - norm(now, DUSK, 1.0f));
+        drawSunset();
     }
+    
+    drawBlades(now);
 
     frameCount++;
-    storeI32(RSID_STATE, RSID_FRAMECOUNT, frameCount);
+    storeI32(RSID_STATE, RSID_FRAME_COUNT, frameCount);
 
     return 1;
 }
diff --git a/libs/rs/java/Grass/src/com/android/grass/rs/GrassRS.java b/libs/rs/java/Grass/src/com/android/grass/rs/GrassRS.java
index 70cb012..435b5ce 100644
--- a/libs/rs/java/Grass/src/com/android/grass/rs/GrassRS.java
+++ b/libs/rs/java/Grass/src/com/android/grass/rs/GrassRS.java
@@ -23,20 +23,45 @@
 import static android.renderscript.RenderScript.DepthFunc.*;
 import static android.renderscript.RenderScript.BlendSrcFunc;
 import static android.renderscript.RenderScript.BlendDstFunc;
-
 import android.renderscript.RenderScript;
 import android.renderscript.Element;
 import android.renderscript.Allocation;
+import android.renderscript.ProgramVertexAlloc;
+import static android.renderscript.Element.*;
+
+import static android.util.MathUtils.*;
 
 import java.util.TimeZone;
 
 class GrassRS {
     private static final int RSID_STATE = 0;
+    private static final int RSID_STATE_FRAMECOUNT = 0;
+    private static final int RSID_STATE_BLADES_COUNT = 1;
+
     private static final int RSID_SKY_TEXTURES = 1;
     private static final int SKY_TEXTURES_COUNT = 4;
-
+    
+    private static final int RSID_BLADES = 2;    
+    private static final int BLADES_COUNT = 100;
+    private static final int BLADE_STRUCT_FIELDS_COUNT = 12;
+    private static final int BLADE_STRUCT_DEGREE = 0;
+    private static final int BLADE_STRUCT_SIZE = 1;
+    private static final int BLADE_STRUCT_XPOS = 2;
+    private static final int BLADE_STRUCT_YPOS = 3;
+    private static final int BLADE_STRUCT_OFFSET = 4;
+    private static final int BLADE_STRUCT_SCALE = 5;
+    private static final int BLADE_STRUCT_LENGTHX = 6;
+    private static final int BLADE_STRUCT_LENGTHY = 7;
+    private static final int BLADE_STRUCT_HARDNESS = 8;
+    private static final int BLADE_STRUCT_H = 9;
+    private static final int BLADE_STRUCT_S = 10;
+    private static final int BLADE_STRUCT_B = 11;
+    
     private Resources mResources;
     private RenderScript mRS;
+    
+    private final int mWidth;
+    private final int mHeight;
 
     @SuppressWarnings({"FieldCanBeLocal"})
     private RenderScript.Script mScript;
@@ -46,6 +71,10 @@
     private RenderScript.ProgramFragment mPfBackground;
     @SuppressWarnings({"FieldCanBeLocal"})
     private RenderScript.ProgramFragmentStore mPfsBackground;
+    @SuppressWarnings({"FieldCanBeLocal"})
+    private RenderScript.ProgramVertex mPvBackground;    
+    @SuppressWarnings({"FieldCanBeLocal"})
+    private ProgramVertexAlloc mPvOrthoAlloc;
 
     @SuppressWarnings({"FieldCanBeLocal"})
     private Allocation mSkyTexturesIDs;
@@ -55,8 +84,12 @@
     private int[] mSkyBufferIDs;
     @SuppressWarnings({"FieldCanBeLocal"})
     private Allocation mState;
+    @SuppressWarnings({"FieldCanBeLocal"})
+    private Allocation mBlades;
 
-    public GrassRS() {
+    public GrassRS(int width, int height) {
+        mWidth = width;
+        mHeight = height;
     }
 
     public void init(RenderScript rs, Resources res) {
@@ -82,20 +115,46 @@
         loadSkyTextures();
         mScript.bindAllocation(mState, RSID_STATE);
         mScript.bindAllocation(mSkyTexturesIDs, RSID_SKY_TEXTURES);
+        mScript.bindAllocation(mBlades, RSID_BLADES);
 
         mRS.contextBindRootScript(mScript);
     }
 
     private void createScriptStructures() {
-        mState = Allocation.createSized(mRS, Element.USER_I32, 1);
-        mState.data(new int[1]);
+        final int[] data = new int[2];
+        mState = Allocation.createSized(mRS, USER_I32, data.length);
+        data[RSID_STATE_FRAMECOUNT] = 0;
+        data[RSID_STATE_BLADES_COUNT] = BLADES_COUNT;
+        mState.data(data);
+
+        final float[] blades = new float[BLADES_COUNT * BLADE_STRUCT_FIELDS_COUNT];
+        mBlades = Allocation.createSized(mRS, USER_FLOAT, blades.length);
+        for (int i = 0; i < blades.length; i+= BLADE_STRUCT_FIELDS_COUNT) {
+            createBlade(blades, i);
+        }
+        mBlades.data(blades);
+    }
+
+    private void createBlade(float[] blades, int index) {
+        //noinspection PointlessArithmeticExpression
+        blades[index + BLADE_STRUCT_DEGREE] = 0.0f;
+        blades[index + BLADE_STRUCT_SIZE] = random(4.0f) + 4.0f;
+        blades[index + BLADE_STRUCT_XPOS] = random(mWidth);
+        blades[index + BLADE_STRUCT_YPOS] = mHeight;
+        blades[index + BLADE_STRUCT_OFFSET] = random(0.2f) - 0.1f;
+        blades[index + BLADE_STRUCT_SCALE] = random(0.6f) + 0.2f;
+        blades[index + BLADE_STRUCT_LENGTHX] = random(4.5f) + 3.0f;
+        blades[index + BLADE_STRUCT_LENGTHY] = random(5.5f) + 2.0f;
+        blades[index + BLADE_STRUCT_HARDNESS] = random(1.0f) + 0.2f;
+        blades[index + BLADE_STRUCT_H] = (51.0f + random(5.0f)) / 255.0f;
+        blades[index + BLADE_STRUCT_S] = (200.0f + random(55.0f)) / 255.0f;
+        blades[index + BLADE_STRUCT_B] = (90.0f + random(165.0f)) / 255.0f;
     }
 
     private void loadSkyTextures() {
         mSkyBufferIDs = new int[SKY_TEXTURES_COUNT];
         mSkyTextures = new Allocation[SKY_TEXTURES_COUNT];
-        mSkyTexturesIDs = Allocation.createSized(
-                mRS, Element.USER_FLOAT, SKY_TEXTURES_COUNT);
+        mSkyTexturesIDs = Allocation.createSized(mRS, USER_FLOAT, SKY_TEXTURES_COUNT);
 
         final Allocation[] textures = mSkyTextures;
         textures[0] = loadTexture(R.drawable.night, "night");
@@ -149,5 +208,13 @@
     }
 
     private void createProgramVertex() {
+        mPvOrthoAlloc = new ProgramVertexAlloc(mRS);
+        mPvOrthoAlloc.setupOrthoWindow(mWidth, mHeight);
+
+        mRS.programVertexBegin(null, null);
+        mRS.programVertexSetTextureMatrixEnable(true);
+        mPvBackground = mRS.programVertexCreate();
+        mPvBackground.bindAllocation(0, mPvOrthoAlloc.mAlloc);
+        mPvBackground.setName("PVBackground");
     }
 }
diff --git a/libs/rs/java/Grass/src/com/android/grass/rs/GrassView.java b/libs/rs/java/Grass/src/com/android/grass/rs/GrassView.java
index a641e1e..44d5b08 100644
--- a/libs/rs/java/Grass/src/com/android/grass/rs/GrassView.java
+++ b/libs/rs/java/Grass/src/com/android/grass/rs/GrassView.java
@@ -30,7 +30,7 @@
         super.surfaceChanged(holder, format, w, h);
 
         RenderScript RS = createRenderScript();
-        GrassRS render = new GrassRS();
+        GrassRS render = new GrassRS(w, h);
         render.init(RS, getResources());
     }
 }
diff --git a/libs/rs/rsScriptC_Lib.cpp b/libs/rs/rsScriptC_Lib.cpp
index 21c9753..e4979ea 100644
--- a/libs/rs/rsScriptC_Lib.cpp
+++ b/libs/rs/rsScriptC_Lib.cpp
@@ -566,6 +566,59 @@
     glColor4f(r, g, b, a);
 }
 
+static void SC_hsb(float h, float s, float b, float a)
+{
+    float red = 0.0f;
+    float green = 0.0f;
+    float blue = 0.0f;
+    
+    float x = h;
+    float y = s;
+    float z = b;
+    
+    float hf = (x - (int) x) * 6.0f;
+    int ihf = (int) hf;
+    float f = hf - ihf;
+    float pv = z * (1.0f - y);
+    float qv = z * (1.0f - y * f);
+    float tv = z * (1.0f - y * (1.0f - f));
+    
+    switch (ihf) {
+        case 0:         // Red is the dominant color
+            red = z;
+            green = tv;
+            blue = pv;
+            break;
+        case 1:         // Green is the dominant color
+            red = qv;
+            green = z;
+            blue = pv;
+            break;
+        case 2:
+            red = pv;
+            green = z;
+            blue = tv;
+            break;
+        case 3:         // Blue is the dominant color
+            red = pv;
+            green = qv;
+            blue = z;
+            break;
+        case 4:
+            red = tv;
+            green = pv;
+            blue = z;
+            break;
+        case 5:         // Red is the dominant color
+            red = z;
+            green = pv;
+            blue = qv;
+            break;
+    }
+    
+    glColor4f(red, green, blue, a);
+}
+
 /*
 extern "C" void materialDiffuse(float r, float g, float b, float a)
 {
@@ -650,7 +703,7 @@
     { "atanf", (void *)&atanf,
         "float", "(float)" },
     { "atan2f", (void *)&atan2f,
-        "float", "(floatm float)" },
+        "float", "(float, float)" },
     { "fabsf", (void *)&fabsf,
         "float", "(float)" },
     { "randf", (void *)&SC_randf,
@@ -772,6 +825,8 @@
         "void", "(float, float, float, float)" },
     { "color", (void *)&SC_color,
         "void", "(float, float, float, float)" },
+    { "hsb", (void *)&SC_hsb,
+        "void", "(float, float, float, float)" },
 
     { "uploadToTexture", (void *)&SC_uploadToTexture,
         "void", "(int, int)" },