summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--core/java/android/util/MathUtils.java168
-rw-r--r--graphics/java/android/graphics/Color.java196
-rw-r--r--libs/rs/java/Grass/res/raw/grass.c132
-rw-r--r--libs/rs/java/Grass/src/com/android/grass/rs/GrassRS.java81
-rw-r--r--libs/rs/java/Grass/src/com/android/grass/rs/GrassView.java2
-rw-r--r--libs/rs/rsScriptC_Lib.cpp57
6 files changed, 591 insertions, 45 deletions
diff --git a/core/java/android/util/MathUtils.java b/core/java/android/util/MathUtils.java
new file mode 100644
index 000000000000..d8509a025486
--- /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 3fc391c42b64..5cefaa3b72c6 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 @@ public class Color {
}
/**
+ * 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 @@ public class Color {
}
/**
+ * 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 @@ public class Color {
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 b1b89f06ed67..3cedaba6b1b6 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 @@ void drawSunset() {
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 @@ int main(int launchID) {
}
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 70cb01249666..435b5ce6797f 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.EnvMode.*;
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 @@ class GrassRS {
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 @@ class GrassRS {
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 @@ class GrassRS {
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 @@ class GrassRS {
}
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 a641e1ef48d6..44d5b085faa7 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 @@ class GrassView extends RSSurfaceView {
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 21c975383c7c..e4979ea3b2d0 100644
--- a/libs/rs/rsScriptC_Lib.cpp
+++ b/libs/rs/rsScriptC_Lib.cpp
@@ -566,6 +566,59 @@ static void SC_color(float r, float g, float b, float a)
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 @@ ScriptCState::SymbolTable_t ScriptCState::gSyms[] = {
{ "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 @@ ScriptCState::SymbolTable_t ScriptCState::gSyms[] = {
"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)" },
generated by cgit v1.2.3-59-g8ed1b (git 2.39.0) at 2025-11-02 05:46:35 +0000