Update water with new wave physics.
diff --git a/res/raw/distort.rs b/res/raw/distort.rs
new file mode 100644
index 0000000..3158a04
--- /dev/null
+++ b/res/raw/distort.rs
@@ -0,0 +1,545 @@
+// 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(PVSky)
+#pragma stateFragment(PFBackground)
+#pragma stateStore(PFSBackground)
+
+#define RSID_RIPPLE_MAP 1
+#define RSID_REFRACTION_MAP 2
+
+#define LEAVES_TEXTURES_COUNT 4
+
+#define LEAF_SIZE 0.55f
+
+#define REFRACTION 1.333f
+#define DAMP 3
+
+#define DROP_RADIUS 2
+// The higher, the smaller the ripple
+#define RIPPLE_HEIGHT 10.0f
+
+float skyOffsetX;
+float skyOffsetY;
+
+int lastDrop;
+
+struct vert_s {
+ float x;
+ float y;
+ float z;
+ float s;
+ float t;
+ float nx;
+ float ny;
+ float nz;
+};
+
+struct drop_s {
+ float amp;
+ float phase;
+ float x;
+ float y;
+};
+struct drop_s gDrops[10];
+
+int offset(int x, int y, int width) {
+ return x + 1 + (y + 1) * (width + 2);
+}
+
+void init() {
+ gDrops[0].amp = 0.2f;
+ gDrops[0].phase = 0;
+}
+
+void initLeaves() {
+ if (State->isPreview) lastDrop = uptimeMillis();
+
+ struct Leaves_s *leaf = Leaves;
+ int leavesCount = State->leavesCount;
+ float width = State->glWidth;
+ float height = State->glHeight;
+
+ int i;
+ for (i = 0; i < leavesCount; i ++) {
+ int sprite = randf(LEAVES_TEXTURES_COUNT);
+ leaf->x = randf2(-width * 0.5f, width * 0.5f);
+ leaf->y = randf2(-height * 0.5f, height * 0.5f);
+ leaf->scale = randf2(0.4f, 0.5f);
+ leaf->angle = randf2(0.0f, 360.0f);
+ leaf->spin = degf(randf2(-0.02f, 0.02f)) * 0.25f;
+ leaf->u1 = sprite / (float) LEAVES_TEXTURES_COUNT;
+ leaf->u2 = (sprite + 1) / (float) LEAVES_TEXTURES_COUNT;
+ leaf->altitude = -1.0f;
+ leaf->rippled = 1.0f;
+ leaf->deltaX = randf2(-0.02f, 0.02f) / 60.0f;
+ leaf->deltaY = -0.08f * randf2(0.9f, 1.1f) / 60.0f;
+ leaf++;
+ }
+}
+
+void dropWithStrength(int x, int y, int r, int s) {
+ int width = State->meshWidth;
+ int height = State->meshHeight;
+
+ if (x < r) x = r;
+ if (y < r) y = r;
+ if (x >= width - r) x = width - r - 1;
+ if (y >= height - r) y = height - r - 1;
+
+ x = width - x;
+
+ int rippleMapSize = State->rippleMapSize;
+ int index = State->rippleIndex;
+ int origin = offset(0, 0, width);
+
+ int* current = loadArrayI32(RSID_RIPPLE_MAP, index * rippleMapSize + origin);
+ int sqr = r * r;
+ float invs = 1.0f / s;
+
+ int h = 0;
+ for ( ; h < r; h += 1) {
+ int sqv = h * h;
+ int yn = origin + (y - h) * (width + 2);
+ int yp = origin + (y + h) * (width + 2);
+ int w = 0;
+ for ( ; w < r; w += 1) {
+ int squ = w * w;
+ if (squ + sqv < sqr) {
+ int v = -sqrtf((sqr - (squ + sqv)) << 16) * invs;
+ current[yn + x + w] = v;
+ current[yp + x + w] = v;
+ current[yn + x - w] = v;
+ current[yp + x - w] = v;
+ }
+ }
+ }
+}
+
+void drop(int x, int y, int r) {
+ dropWithStrength(x, y, r, 1);
+}
+
+void updateRipples() {
+ int rippleMapSize = State->rippleMapSize;
+ int width = State->meshWidth;
+ int height = State->meshHeight;
+ int index = State->rippleIndex;
+ int origin = offset(0, 0, width);
+
+ int* current = loadArrayI32(RSID_RIPPLE_MAP, index * rippleMapSize + origin);
+ int* next = loadArrayI32(RSID_RIPPLE_MAP, (1 - index) * rippleMapSize + origin);
+
+ State->rippleIndex = 1 - index;
+
+ int a = 1;
+ int b = width + 2;
+ int h = height;
+ while (h) {
+ int w = width;
+ while (w) {
+ int droplet = ((current[-b] + current[b] + current[-a] + current[a]) >> 1) - *next;
+ *next = droplet - (droplet >> DAMP);
+ current += 1;
+ next += 1;
+ w -= 1;
+ }
+ current += 2;
+ next += 2;
+ h -= 1;
+ }
+}
+
+int refraction(int d, int wave, int *map) {
+ int i = d;
+ if (i < 0) i = -i;
+ if (i > 512) i = 512;
+ int w = (wave + 0x10000) >> 8;
+ w &= ~(w >> 31);
+ int r = (map[i] * w) >> 3;
+ if (d < 0) {
+ return -r;
+ }
+ return r;
+}
+
+void generateRipples() {
+ int rippleMapSize = State->rippleMapSize;
+ int width = State->meshWidth;
+ int height = State->meshHeight;
+ int index = State->rippleIndex;
+ int origin = offset(0, 0, width);
+
+ int b = width + 2;
+
+ int* current = loadArrayI32(RSID_RIPPLE_MAP, index * rippleMapSize + origin);
+ int *map = loadArrayI32(RSID_REFRACTION_MAP, 0);
+ float *vertices = loadSimpleMeshVerticesF(NAMED_WaterMesh, 0);
+ struct vert_s *vert = (struct vert_s *)vertices;
+
+ float fw = 1.0f / width;
+ float fh = 1.0f / height;
+ float fy = (1.0f / 512.0f) * (1.0f / RIPPLE_HEIGHT);
+/*
+ int h = height - 1;
+ while (h >= 0) {
+ int w = width - 1;
+ int wave = *current;
+ int offset = h * width;
+ struct vert_s *vtx = vert + offset + w;
+
+ while (w >= 0) {
+ int nextWave = current[1];
+ int dx = nextWave - wave;
+ int dy = current[b] - wave;
+
+ int offsetx = refraction(dx, wave, map) >> 16;
+ int u = (width - w) + offsetx;
+ u &= ~(u >> 31);
+ if (u >= width) u = width - 1;
+
+ int offsety = refraction(dy, wave, map) >> 16;
+ int v = (height - h) + offsety;
+ v &= ~(v >> 31);
+ if (v >= height) v = height - 1;
+
+ vtx->s = u * fw;
+ vtx->t = v * fh;
+ vtx->z = dy * fy;
+ debugF("es", vtx->s);
+ vtx --;
+
+ w -= 1;
+ current += 1;
+ wave = nextWave;
+ }
+ h -= 1;
+ current += 2;
+ }
+*/
+ {
+ gDrops[0].x = width / 2;
+ gDrops[0].y = height / 2;
+
+ int x, y;
+ struct vert_s *vtx = vert;
+ for (y=0; y < height; y++) {
+ for (x=0; x < width; x++) {
+ struct drop_s * d = &gDrops[0];
+ float z = 0;
+
+ {
+ float dx = d->x - x;
+ float dy = d->y - y;
+ float dist = sqrtf(dx*dx + dy*dy);
+ z = sinf(dist + d->phase) * d->amp;
+
+ vtx->s = (float)x / width;
+ vtx->t = (float)y / height;
+ vtx->z = z;
+ vtx ++;
+ }
+ }
+ }
+ gDrops[0].phase += 0.02;
+ }
+
+ // Compute the normals for lighting
+ int y = 0;
+ for ( ; y < (height-1); y += 1) {
+ int x = 0;
+ int yOffset = y * width;
+ struct vert_s *v = vert;
+ v += y * width;
+
+ for ( ; x < (width-1); x += 1) {
+ struct vec3_s n1, n2, n3;
+ vec3Sub(&n1, (struct vec3_s *)&(v+1)->x, (struct vec3_s *)&v->x);
+ vec3Sub(&n2, (struct vec3_s *)&(v+width)->x, (struct vec3_s *)&v->x);
+ vec3Cross(&n3, &n1, &n2);
+ vec3Norm(&n3);
+
+ // Average of previous normal and N1 x N2
+ vec3Sub(&n1, (struct vec3_s *)&(v+width+1)->x, (struct vec3_s *)&v->x);
+ vec3Cross(&n2, &n1, &n2);
+ vec3Add(&n3, &n3, &n2);
+ vec3Norm(&n3);
+
+ v->nx = n3.x;
+ v->ny = n3.y;
+ v->nz = -n3.z;
+ v->s += v->nx * 0.01;
+ v->t += v->ny * 0.01;
+ v += 1;
+
+ // reset Z
+ //vertices[(yOffset + x) << 3 + 7] = 0.0f;
+ }
+ }
+}
+
+void drawLeaf(struct Leaves_s *leaf, int meshWidth, int meshHeight, float glWidth, float glHeight,
+ int rotate) {
+
+ float x = leaf->x;
+ float x1 = x - LEAF_SIZE;
+ float x2 = x + LEAF_SIZE;
+
+ float y = leaf->y;
+ float y1 = y - LEAF_SIZE;
+ float y2 = y + LEAF_SIZE;
+
+ float u1 = leaf->u1;
+ float u2 = leaf->u2;
+
+ float z1 = 0.0f;
+ float z2 = 0.0f;
+ float z3 = 0.0f;
+ float z4 = 0.0f;
+
+ float a = leaf->altitude;
+ float s = leaf->scale;
+ float r = leaf->angle;
+
+ float tz = 0.0f;
+ if (a > 0.0f) {
+ tz = -a;
+ }
+
+ x1 -= x;
+ x2 -= x;
+ y1 -= y;
+ y2 -= y;
+
+ float matrix[16];
+
+ if (a > 0.0f) {
+ color(0.0f, 0.0f, 0.0f, 0.15f);
+
+ if (rotate) {
+ matrixLoadRotate(matrix, 90.0f, 0.0f, 0.0f, 1.0f);
+ } else {
+ matrixLoadIdentity(matrix);
+ }
+ matrixTranslate(matrix, x, y, 0.0f);
+ matrixScale(matrix, s, s, 1.0f);
+ matrixRotate(matrix, r, 0.0f, 0.0f, 1.0f);
+ vpLoadModelMatrix(matrix);
+
+ drawQuadTexCoords(x1, y1, z1, u1, 1.0f,
+ x2, y1, z2, u2, 1.0f,
+ x2, y2, z3, u2, 0.0f,
+ x1, y2, z4, u1, 0.0f);
+
+ float alpha = 1.0f;
+ if (a >= 0.4f) alpha = 1.0f - (a - 0.5f) / 0.1f;
+ color(1.0f, 1.0f, 1.0f, alpha);
+ } else {
+ color(1.0f, 1.0f, 1.0f, 1.0f);
+ }
+
+ if (rotate) {
+ matrixLoadRotate(matrix, 90.0f, 0.0f, 0.0f, 1.0f);
+ } else {
+ matrixLoadIdentity(matrix);
+ }
+ matrixTranslate(matrix, x, y, tz);
+ matrixScale(matrix, s, s, 1.0f);
+ matrixRotate(matrix, r, 0.0f, 0.0f, 1.0f);
+ vpLoadModelMatrix(matrix);
+
+ drawQuadTexCoords(x1, y1, z1, u1, 1.0f,
+ x2, y1, z2, u2, 1.0f,
+ x2, y2, z3, u2, 0.0f,
+ x1, y2, z4, u1, 0.0f);
+
+ float spin = leaf->spin;
+ if (a <= 0.0f) {
+ float rippled = leaf->rippled;
+ if (rippled < 0.0f) {
+ drop(((x + glWidth * 0.5f) / glWidth) * meshWidth,
+ meshHeight - ((y + glHeight * 0.5f) / glHeight) * meshHeight, 1);
+ spin /= 4.0f;
+ leaf->spin = spin;
+ leaf->rippled = 1.0f;
+ }
+ leaf->x = x + leaf->deltaX;
+ leaf->y = y + leaf->deltaY;
+ r += spin;
+ leaf->angle = r;
+ } else {
+ a -= 0.005f;
+ leaf->altitude = a;
+ r += spin * 2.0f;
+ leaf->angle = r;
+ }
+
+ if (-LEAF_SIZE * s + x > glWidth / 2.0f || LEAF_SIZE * s + x < -glWidth / 2.0f ||
+ LEAF_SIZE * s + y < -glHeight / 2.0f) {
+
+ int sprite = randf(LEAVES_TEXTURES_COUNT);
+ leaf->x = randf2(-glWidth * 0.5f, glWidth * 0.5f);
+ leaf->y = randf2(-glHeight * 0.5f, glHeight * 0.5f);
+ leaf->scale = randf2(0.4f, 0.5f);
+ leaf->spin = degf(randf2(-0.02f, 0.02f)) * 0.25f;
+ leaf->u1 = sprite / (float) LEAVES_TEXTURES_COUNT;
+ leaf->u2 = (sprite + 1) / (float) LEAVES_TEXTURES_COUNT;
+ leaf->altitude = 0.6f;
+ leaf->rippled = -1.0f;
+ leaf->deltaX = randf2(-0.02f, 0.02f) / 60.0f;
+ leaf->deltaY = -0.08f * randf2(0.9f, 1.1f) / 60.0f;
+ }
+}
+
+void drawLeaves() {
+ bindProgramFragment(NAMED_PFSky);
+ bindProgramFragmentStore(NAMED_PFSLeaf);
+ bindProgramVertex(NAMED_PVSky);
+ bindTexture(NAMED_PFSky, 0, NAMED_TLeaves);
+
+ color(1.0f, 1.0f, 1.0f, 1.0f);
+
+ int leavesCount = State->leavesCount;
+ int width = State->meshWidth;
+ int height = State->meshHeight;
+ float glWidth = State->glWidth;
+ float glHeight = State->glHeight;
+ int rotate = State->rotate;
+
+ struct Leaves_s *leaf = Leaves;
+
+ int i = 0;
+ for ( ; i < leavesCount; i += 1) {
+ drawLeaf(leaf, width, height, glWidth, glHeight, rotate);
+ leaf += 1;
+ }
+
+ float matrix[16];
+ matrixLoadIdentity(matrix);
+ vpLoadModelMatrix(matrix);
+}
+
+void drawRiverbed() {
+ bindTexture(NAMED_PFBackground, 0, NAMED_TRiverbed);
+
+ drawSimpleMesh(NAMED_WaterMesh);
+}
+
+void drawSky() {
+ color(1.0f, 1.0f, 1.0f, 0.4f);
+
+ bindProgramFragment(NAMED_PFSky);
+ bindProgramFragmentStore(NAMED_PFSLeaf);
+ bindTexture(NAMED_PFSky, 0, NAMED_TSky);
+
+ float x = skyOffsetX + State->skySpeedX;
+ float y = skyOffsetY + State->skySpeedY;
+
+ if (x > 1.0f) x = 0.0f;
+ if (x < -1.0f) x = 0.0f;
+ if (y > 1.0f) y = 0.0f;
+
+ skyOffsetX = x;
+ skyOffsetY = y;
+
+ float matrix[16];
+ matrixLoadTranslate(matrix, x, y, 0.0f);
+ vpLoadTextureMatrix(matrix);
+
+ drawSimpleMesh(NAMED_WaterMesh);
+
+ matrixLoadIdentity(matrix);
+ vpLoadTextureMatrix(matrix);
+}
+
+void drawLighting() {
+ ambient(0.0f, 0.0f, 0.0f, 1.0f);
+ diffuse(0.0f, 0.0f, 0.0f, 1.0f);
+ specular(0.44f, 0.44f, 0.44f, 1.0f);
+ shininess(40.0f);
+
+ bindProgramFragmentStore(NAMED_PFSBackground);
+ bindProgramFragment(NAMED_PFLighting);
+ bindProgramVertex(NAMED_PVLight);
+
+ drawSimpleMesh(NAMED_WaterMesh);
+}
+
+void drawNormals() {
+ int width = State->meshWidth;
+ int height = State->meshHeight;
+
+ float *vertices = loadSimpleMeshVerticesF(NAMED_WaterMesh, 0);
+
+ bindProgramVertex(NAMED_PVSky);
+ bindProgramFragment(NAMED_PFLighting);
+
+ color(1.0f, 0.0f, 0.0f, 1.0f);
+
+ float scale = 1.0f / 10.0f;
+ int y = 0;
+ for ( ; y < height; y += 1) {
+ int yOffset = y * width;
+ int x = 0;
+ for ( ; x < width; x += 1) {
+ int offset = (yOffset + x) << 3;
+ float vx = vertices[offset + 5];
+ float vy = vertices[offset + 6];
+ float vz = vertices[offset + 7];
+ float nx = vertices[offset + 0];
+ float ny = vertices[offset + 1];
+ float nz = vertices[offset + 2];
+ drawLine(vx, vy, vz, vx + nx * scale, vy + ny * scale, vz + nz * scale);
+ }
+ }
+}
+
+int main(int index) {
+ if (Drop->dropX != -1) {
+ drop(Drop->dropX, Drop->dropY, DROP_RADIUS);
+ Drop->dropX = -1;
+ Drop->dropY = -1;
+ }
+
+ if (State->isPreview) {
+ int now = uptimeMillis();
+ if (now - lastDrop > 2000) {
+ float x = randf(State->meshWidth);
+ float y = randf(State->meshHeight);
+
+ drop(x, y, DROP_RADIUS);
+
+ lastDrop = now;
+ }
+ }
+
+ updateRipples();
+ generateRipples();
+ updateSimpleMesh(NAMED_WaterMesh);
+
+ if (State->rotate) {
+ float matrix[16];
+ matrixLoadRotate(matrix, 90.0f, 0.0f, 0.0f, 1.0f);
+ vpLoadModelMatrix(matrix);
+ }
+
+ drawRiverbed();
+ //drawSky();
+ drawLighting();
+ //drawLeaves();
+ //drawNormals();
+
+ return 1;
+}
diff --git a/res/raw/fall.rs b/res/raw/fall.rs
index a54e3b5..326f326 100644
--- a/res/raw/fall.rs
+++ b/res/raw/fall.rs
@@ -17,25 +17,12 @@
#pragma stateFragment(PFBackground)
#pragma stateStore(PFSBackground)
-#define RSID_RIPPLE_MAP 1
-#define RSID_REFRACTION_MAP 2
-
#define LEAVES_TEXTURES_COUNT 4
-
#define LEAF_SIZE 0.55f
-#define REFRACTION 1.333f
-#define DAMP 3
-
-#define DROP_RADIUS 2
-// The higher, the smaller the ripple
-#define RIPPLE_HEIGHT 10.0f
-
float skyOffsetX;
float skyOffsetY;
-int lastDrop;
-
struct vert_s {
float x;
float y;
@@ -47,13 +34,29 @@
float nz;
};
-int offset(int x, int y, int width) {
- return x + 1 + (y + 1) * (width + 2);
+struct drop_s {
+ float amp;
+ float spread;
+ float invSpread;
+ float x;
+ float y;
+};
+struct drop_s gDrops[10];
+int gNextDrop;
+int gMaxDrops;
+
+void init() {
+ int ct;
+ gMaxDrops = 10;
+ for (ct=0; ct<gMaxDrops; ct++) {
+ gDrops[ct].amp = 0;
+ gDrops[ct].spread = 1;
+ gDrops[ct].invSpread = 1 / gDrops[ct].spread;
+ }
+ gNextDrop = 0;
}
void initLeaves() {
- if (State->isPreview) lastDrop = uptimeMillis();
-
struct Leaves_s *leaf = Leaves;
int leavesCount = State->leavesCount;
float width = State->glWidth;
@@ -77,89 +80,14 @@
}
}
-void dropWithStrength(int x, int y, int r, int s) {
- int width = State->meshWidth;
- int height = State->meshHeight;
-
- if (x < r) x = r;
- if (y < r) y = r;
- if (x >= width - r) x = width - r - 1;
- if (y >= height - r) y = height - r - 1;
-
- x = width - x;
-
- int rippleMapSize = State->rippleMapSize;
- int index = State->rippleIndex;
- int origin = offset(0, 0, width);
-
- int* current = loadArrayI32(RSID_RIPPLE_MAP, index * rippleMapSize + origin);
- int sqr = r * r;
- float invs = 1.0f / s;
-
- int h = 0;
- for ( ; h < r; h += 1) {
- int sqv = h * h;
- int yn = origin + (y - h) * (width + 2);
- int yp = origin + (y + h) * (width + 2);
- int w = 0;
- for ( ; w < r; w += 1) {
- int squ = w * w;
- if (squ + sqv < sqr) {
- int v = -sqrtf((sqr - (squ + sqv)) << 16) * invs;
- current[yn + x + w] = v;
- current[yp + x + w] = v;
- current[yn + x - w] = v;
- current[yp + x - w] = v;
- }
- }
- }
-}
-
-void drop(int x, int y, int r) {
- dropWithStrength(x, y, r, 1);
-}
-
-void updateRipples() {
- int rippleMapSize = State->rippleMapSize;
- int width = State->meshWidth;
- int height = State->meshHeight;
- int index = State->rippleIndex;
- int origin = offset(0, 0, width);
-
- int* current = loadArrayI32(RSID_RIPPLE_MAP, index * rippleMapSize + origin);
- int* next = loadArrayI32(RSID_RIPPLE_MAP, (1 - index) * rippleMapSize + origin);
-
- State->rippleIndex = 1 - index;
-
- int a = 1;
- int b = width + 2;
- int h = height;
- while (h) {
- int w = width;
- while (w) {
- int droplet = ((current[-b] + current[b] + current[-a] + current[a]) >> 1) - *next;
- *next = droplet - (droplet >> DAMP);
- current += 1;
- next += 1;
- w -= 1;
- }
- current += 2;
- next += 2;
- h -= 1;
- }
-}
-
-int refraction(int d, int wave, int *map) {
- int i = d;
- if (i < 0) i = -i;
- if (i > 512) i = 512;
- int w = (wave + 0x10000) >> 8;
- w &= ~(w >> 31);
- int r = (map[i] * w) >> 3;
- if (d < 0) {
- return -r;
- }
- return r;
+void drop(int x, int y, float s) {
+ gDrops[gNextDrop].amp = s;
+ gDrops[gNextDrop].spread = 0.5f;
+ gDrops[gNextDrop].x = x;
+ gDrops[gNextDrop].y = State->meshHeight - y - 1;
+ gNextDrop++;
+ if (gNextDrop >= gMaxDrops)
+ gNextDrop = 0;
}
void generateRipples() {
@@ -167,52 +95,42 @@
int width = State->meshWidth;
int height = State->meshHeight;
int index = State->rippleIndex;
- int origin = offset(0, 0, width);
- int b = width + 2;
-
- int* current = loadArrayI32(RSID_RIPPLE_MAP, index * rippleMapSize + origin);
- int *map = loadArrayI32(RSID_REFRACTION_MAP, 0);
float *vertices = loadSimpleMeshVerticesF(NAMED_WaterMesh, 0);
struct vert_s *vert = (struct vert_s *)vertices;
float fw = 1.0f / width;
float fh = 1.0f / height;
- float fy = (1.0f / 512.0f) * (1.0f / RIPPLE_HEIGHT);
+ {
+ int x, y, ct;
+ struct vert_s *vtx = vert;
+ for (y=0; y < height; y++) {
+ for (x=0; x < width; x++) {
+ struct drop_s * d = &gDrops[0];
+ float z = 0;
- int h = height - 1;
- while (h >= 0) {
- int w = width - 1;
- int wave = *current;
- int offset = h * width;
- struct vert_s *vtx = vert + offset + w;
-
- while (w >= 0) {
- int nextWave = current[1];
- int dx = nextWave - wave;
- int dy = current[b] - wave;
-
- int offsetx = refraction(dx, wave, map) >> 16;
- int u = (width - w) + offsetx;
- u &= ~(u >> 31);
- if (u >= width) u = width - 1;
-
- int offsety = refraction(dy, wave, map) >> 16;
- int v = (height - h) + offsety;
- v &= ~(v >> 31);
- if (v >= height) v = height - 1;
-
- vtx->s = u * fw;
- vtx->t = v * fh;
- vtx->z = dy * fy;
- vtx --;
-
- w -= 1;
- current += 1;
- wave = nextWave;
+ for (ct = 0; ct < gMaxDrops; ct++) {
+ float dx = d->x - x;
+ float dy = d->y - y;
+ float dist = sqrtf(dx*dx + dy*dy);
+ if (dist < d->spread && d->amp) {
+ float a = d->amp * d->invSpread;
+ a *= dist * d->invSpread;
+ z += sinf(d->spread - dist) * a;
+ }
+ d++;
+ }
+ vtx->s = (float)x * fw;
+ vtx->t = (float)y * fh;
+ vtx->z = z;
+ vtx ++;
+ }
}
- h -= 1;
- current += 2;
+ for (ct = 0; ct < gMaxDrops; ct++) {
+ gDrops[ct].spread += 1;
+ gDrops[ct].invSpread = 1 / gDrops[ct].spread;
+ gDrops[ct].amp = maxf(gDrops[ct].amp - 0.01f, 0);
+ }
}
// Compute the normals for lighting
@@ -239,6 +157,8 @@
v->nx = n3.x;
v->ny = n3.y;
v->nz = -n3.z;
+ v->s += v->nx * 0.005;
+ v->t += v->ny * 0.005;
v += 1;
// reset Z
@@ -279,8 +199,8 @@
x2 -= x;
y1 -= y;
y2 -= y;
-
- float matrix[16];
+
+ float matrix[16];
if (a > 0.0f) {
color(0.0f, 0.0f, 0.0f, 0.15f);
@@ -395,7 +315,7 @@
}
void drawSky() {
- color(1.0f, 1.0f, 1.0f, 0.8f);
+ color(1.0f, 1.0f, 1.0f, 0.5f);
bindProgramFragment(NAMED_PFSky);
bindProgramFragmentStore(NAMED_PFSLeaf);
@@ -465,24 +385,28 @@
int main(int index) {
if (Drop->dropX != -1) {
- drop(Drop->dropX, Drop->dropY, DROP_RADIUS);
+ drop(Drop->dropX, Drop->dropY, 1);
Drop->dropX = -1;
Drop->dropY = -1;
}
-
- if (State->isPreview) {
- int now = uptimeMillis();
- if (now - lastDrop > 2000) {
- float x = randf(State->meshWidth);
- float y = randf(State->meshHeight);
- drop(x, y, DROP_RADIUS);
+ int ct;
+ float amp = 0;
+ for (ct = 0; ct < gMaxDrops; ct++) {
+ amp += gDrops[ct].amp;
+ }
- lastDrop = now;
+ if (State->isPreview || (amp < 0.2f)) {
+ float x = randf(State->meshWidth);
+ float y = randf(State->meshHeight);
+
+ if (State->isPreview) {
+ drop(x, y, 1.f);
+ } else {
+ drop(x, y, 0.2f);
}
}
- updateRipples();
generateRipples();
updateSimpleMesh(NAMED_WaterMesh);
diff --git a/src/com/android/wallpaper/fall/FallRS.java b/src/com/android/wallpaper/fall/FallRS.java
index f68262e..46c72ea 100644
--- a/src/com/android/wallpaper/fall/FallRS.java
+++ b/src/com/android/wallpaper/fall/FallRS.java
@@ -53,7 +53,6 @@
private static final int RSID_TEXTURE_SKY = 2;
private static final int RSID_RIPPLE_MAP = 1;
- private static final int RSID_REFRACTION_MAP = 2;
private static final int RSID_LEAVES = 3;
private static final int RSID_DROP = 4;
@@ -94,7 +93,6 @@
private WorldState mWorldState;
private Allocation mRippleMap;
- private Allocation mRefractionMap;
private Allocation mLeaves;
private Type mLeavesType;
@@ -143,7 +141,6 @@
script.bindAllocation(mState, RSID_STATE);
script.bindAllocation(mRippleMap, RSID_RIPPLE_MAP);
- script.bindAllocation(mRefractionMap, RSID_REFRACTION_MAP);
script.bindAllocation(mLeaves, RSID_LEAVES);
script.bindAllocation(mDropState, RSID_DROP);
@@ -214,7 +211,6 @@
createState(rippleMapSize);
createRippleMap(rippleMapSize);
- createRefractionMap();
createLeaves();
}
@@ -223,17 +219,6 @@
mLeaves = Allocation.createTyped(mRS, mLeavesType);
}
- private void createRefractionMap() {
- final int[] refractionMap = new int[513];
- float ir = 1.0f / 1.333f;
- for (int i = 0; i < refractionMap.length; i++) {
- float d = (float) Math.tan(Math.asin(Math.sin(Math.atan(i * (1.0f / 256.0f))) * ir));
- refractionMap[i] = (int) Math.floor(d * (1 << 16) + 0.5f);
- }
- mRefractionMap = Allocation.createSized(mRS, USER_I32(mRS), refractionMap.length);
- mRefractionMap.data(refractionMap);
- }
-
private void createRippleMap(int rippleMapSize) {
final int[] rippleMap = new int[rippleMapSize * 2];
mRippleMap = Allocation.createSized(mRS, USER_I32(mRS), rippleMap.length);
diff --git a/src/com/android/wallpaper/fall/FallView.java b/src/com/android/wallpaper/fall/FallView.java
index 871ca16..25c7efb 100644
--- a/src/com/android/wallpaper/fall/FallView.java
+++ b/src/com/android/wallpaper/fall/FallView.java
@@ -45,7 +45,7 @@
public boolean onTouchEvent(MotionEvent event) {
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN:
- case MotionEvent.ACTION_MOVE:
+ //case MotionEvent.ACTION_MOVE:
mRender.addDrop(event.getX(), event.getY());
try {
Thread.sleep(16);
