Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 1 | // Copyright (C) 2009 The Android Open Source Project |
| 2 | // |
| 3 | // Licensed under the Apache License, Version 2.0 (the "License"); |
| 4 | // you may not use this file except in compliance with the License. |
| 5 | // You may obtain a copy of the License at |
| 6 | // |
| 7 | // http://www.apache.org/licenses/LICENSE-2.0 |
| 8 | // |
| 9 | // Unless required by applicable law or agreed to in writing, software |
| 10 | // distributed under the License is distributed on an "AS IS" BASIS, |
| 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 12 | // See the License for the specific language governing permissions and |
| 13 | // limitations under the License. |
| 14 | |
| 15 | #pragma version(1) |
| 16 | #pragma stateVertex(PVSky) |
| 17 | #pragma stateFragment(PFBackground) |
Jason Sams | cc92447 | 2009-10-05 14:37:53 -0700 | [diff] [blame] | 18 | #pragma stateStore(PFSBackground) |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 19 | |
Mike Cleron | 70ebeb8 | 2009-11-12 07:49:08 -0800 | [diff] [blame] | 20 | #define LEAVES_TEXTURES_COUNT 8 |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 21 | #define LEAF_SIZE 0.55f |
Mike Cleron | 5b219fc | 2009-11-19 23:23:13 -0800 | [diff] [blame] | 22 | #define LEAVES_COUNT 14 |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 23 | |
Romain Guy | f0bb956 | 2009-10-07 12:25:24 -0700 | [diff] [blame] | 24 | float skyOffsetX; |
| 25 | float skyOffsetY; |
Jason Sams | 756f974 | 2009-11-15 10:16:07 -0800 | [diff] [blame] | 26 | float g_DT; |
| 27 | int g_LastTime; |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 28 | |
Jason Sams | 2cfcc6d | 2009-10-21 17:51:46 -0700 | [diff] [blame] | 29 | struct drop_s { |
Jason Sams | b344cf4 | 2009-11-06 11:50:42 -0800 | [diff] [blame] | 30 | float ampS; |
| 31 | float ampE; |
Jason Sams | 2cfcc6d | 2009-10-21 17:51:46 -0700 | [diff] [blame] | 32 | float spread; |
Jason Sams | 2cfcc6d | 2009-10-21 17:51:46 -0700 | [diff] [blame] | 33 | float x; |
| 34 | float y; |
| 35 | }; |
| 36 | struct drop_s gDrops[10]; |
Jason Sams | 2cfcc6d | 2009-10-21 17:51:46 -0700 | [diff] [blame] | 37 | int gMaxDrops; |
| 38 | |
Mike Cleron | 5b219fc | 2009-11-19 23:23:13 -0800 | [diff] [blame] | 39 | struct Leaves_s { |
| 40 | float x; |
| 41 | float y; |
| 42 | float scale; |
| 43 | float angle; |
| 44 | float spin; |
| 45 | float u1; |
| 46 | float u2; |
| 47 | float altitude; |
| 48 | float rippled; |
| 49 | float deltaX; |
| 50 | float deltaY; |
| 51 | int newLeaf; |
| 52 | }; |
| 53 | |
| 54 | struct Leaves_s gLeavesStore[LEAVES_COUNT]; |
Mike Cleron | 5b219fc | 2009-11-19 23:23:13 -0800 | [diff] [blame] | 55 | struct Leaves_s* gLeaves[LEAVES_COUNT]; |
Mike Cleron | 5b219fc | 2009-11-19 23:23:13 -0800 | [diff] [blame] | 56 | struct Leaves_s* gNextLeaves[LEAVES_COUNT]; |
| 57 | |
Jason Sams | 2cfcc6d | 2009-10-21 17:51:46 -0700 | [diff] [blame] | 58 | void init() { |
| 59 | int ct; |
| 60 | gMaxDrops = 10; |
| 61 | for (ct=0; ct<gMaxDrops; ct++) { |
Jason Sams | b344cf4 | 2009-11-06 11:50:42 -0800 | [diff] [blame] | 62 | gDrops[ct].ampS = 0; |
| 63 | gDrops[ct].ampE = 0; |
Jason Sams | 2cfcc6d | 2009-10-21 17:51:46 -0700 | [diff] [blame] | 64 | gDrops[ct].spread = 1; |
Jason Sams | 2cfcc6d | 2009-10-21 17:51:46 -0700 | [diff] [blame] | 65 | } |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 66 | } |
| 67 | |
Romain Guy | 59014c6 | 2009-10-09 12:27:18 -0700 | [diff] [blame] | 68 | void initLeaves() { |
Mike Cleron | 5b219fc | 2009-11-19 23:23:13 -0800 | [diff] [blame] | 69 | struct Leaves_s *leaf = gLeavesStore; |
Jason Sams | 873e993 | 2009-10-22 14:03:52 -0700 | [diff] [blame] | 70 | float width = State->glWidth * 2; |
Romain Guy | 59014c6 | 2009-10-09 12:27:18 -0700 | [diff] [blame] | 71 | float height = State->glHeight; |
| 72 | |
| 73 | int i; |
Mike Cleron | 5b219fc | 2009-11-19 23:23:13 -0800 | [diff] [blame] | 74 | for (i = 0; i < LEAVES_COUNT; i ++) { |
| 75 | gLeaves[i] = leaf; |
Romain Guy | 59014c6 | 2009-10-09 12:27:18 -0700 | [diff] [blame] | 76 | int sprite = randf(LEAVES_TEXTURES_COUNT); |
Romain Guy | 2d42794 | 2009-10-14 15:43:27 -0700 | [diff] [blame] | 77 | leaf->x = randf2(-width * 0.5f, width * 0.5f); |
| 78 | leaf->y = randf2(-height * 0.5f, height * 0.5f); |
Romain Guy | 59014c6 | 2009-10-09 12:27:18 -0700 | [diff] [blame] | 79 | leaf->scale = randf2(0.4f, 0.5f); |
| 80 | leaf->angle = randf2(0.0f, 360.0f); |
Romain Guy | 2d42794 | 2009-10-14 15:43:27 -0700 | [diff] [blame] | 81 | leaf->spin = degf(randf2(-0.02f, 0.02f)) * 0.25f; |
Romain Guy | 59014c6 | 2009-10-09 12:27:18 -0700 | [diff] [blame] | 82 | leaf->u1 = sprite / (float) LEAVES_TEXTURES_COUNT; |
| 83 | leaf->u2 = (sprite + 1) / (float) LEAVES_TEXTURES_COUNT; |
| 84 | leaf->altitude = -1.0f; |
| 85 | leaf->rippled = 1.0f; |
Jason Sams | 756f974 | 2009-11-15 10:16:07 -0800 | [diff] [blame] | 86 | leaf->deltaX = randf2(-0.02f, 0.02f) / 2.0f; |
| 87 | leaf->deltaY = -0.08f * randf2(0.9f, 1.1f) / 2.0f; |
Romain Guy | 59014c6 | 2009-10-09 12:27:18 -0700 | [diff] [blame] | 88 | leaf++; |
| 89 | } |
| 90 | } |
| 91 | |
Jason Sams | b344cf4 | 2009-11-06 11:50:42 -0800 | [diff] [blame] | 92 | void updateDrop(int ct) { |
Jason Sams | 756f974 | 2009-11-15 10:16:07 -0800 | [diff] [blame] | 93 | gDrops[ct].spread += 30.f * g_DT; |
Jason Sams | 16bf60c | 2010-01-26 12:40:07 -0800 | [diff] [blame] | 94 | gDrops[ct].ampE = gDrops[ct].ampS / gDrops[ct].spread; |
Jason Sams | b344cf4 | 2009-11-06 11:50:42 -0800 | [diff] [blame] | 95 | } |
| 96 | |
Jason Sams | 2cfcc6d | 2009-10-21 17:51:46 -0700 | [diff] [blame] | 97 | void drop(int x, int y, float s) { |
Jason Sams | 6eec598 | 2009-10-23 17:47:12 -0700 | [diff] [blame] | 98 | int ct; |
| 99 | int iMin = 0; |
| 100 | float minAmp = 10000.f; |
| 101 | for (ct = 0; ct < gMaxDrops; ct++) { |
Jason Sams | b344cf4 | 2009-11-06 11:50:42 -0800 | [diff] [blame] | 102 | if (gDrops[ct].ampE < minAmp) { |
Jason Sams | 6eec598 | 2009-10-23 17:47:12 -0700 | [diff] [blame] | 103 | iMin = ct; |
Jason Sams | b344cf4 | 2009-11-06 11:50:42 -0800 | [diff] [blame] | 104 | minAmp = gDrops[ct].ampE; |
Jason Sams | 6eec598 | 2009-10-23 17:47:12 -0700 | [diff] [blame] | 105 | } |
| 106 | } |
Jason Sams | b344cf4 | 2009-11-06 11:50:42 -0800 | [diff] [blame] | 107 | gDrops[iMin].ampS = s; |
| 108 | gDrops[iMin].spread = 0; |
Jason Sams | 6eec598 | 2009-10-23 17:47:12 -0700 | [diff] [blame] | 109 | gDrops[iMin].x = x; |
| 110 | gDrops[iMin].y = State->meshHeight - y - 1; |
Jason Sams | b344cf4 | 2009-11-06 11:50:42 -0800 | [diff] [blame] | 111 | updateDrop(iMin); |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 112 | } |
| 113 | |
| 114 | void generateRipples() { |
Jason Sams | 16bf60c | 2010-01-26 12:40:07 -0800 | [diff] [blame] | 115 | int ct; |
| 116 | for (ct = 0; ct < gMaxDrops; ct++) { |
| 117 | struct drop_s * d = &gDrops[ct]; |
| 118 | vecF32_4_t *v = &Constants->Drop01; |
| 119 | v += ct; |
| 120 | v->x = d->x; |
| 121 | v->y = d->y; |
| 122 | v->z = d->ampE * 0.12f; |
| 123 | v->w = d->spread; |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 124 | } |
Jason Sams | 16bf60c | 2010-01-26 12:40:07 -0800 | [diff] [blame] | 125 | Constants->Offset.x = State->xOffset; |
| 126 | |
Jason Sams | 73f2f5f | 2009-11-10 16:13:23 -0800 | [diff] [blame] | 127 | for (ct = 0; ct < gMaxDrops; ct++) { |
| 128 | updateDrop(ct); |
| 129 | } |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 130 | } |
| 131 | |
Jason Sams | 6eec598 | 2009-10-23 17:47:12 -0700 | [diff] [blame] | 132 | void genLeafDrop(struct Leaves_s *leaf, float amp) { |
| 133 | float nx = (leaf->x + State->glWidth * 0.5f) / State->glWidth; |
| 134 | float ny = (leaf->y + State->glHeight * 0.5f) / State->glHeight; |
| 135 | drop(nx * State->meshWidth, State->meshHeight - ny * State->meshHeight, amp); |
| 136 | |
| 137 | } |
| 138 | |
Mike Cleron | 5b219fc | 2009-11-19 23:23:13 -0800 | [diff] [blame] | 139 | int drawLeaf(struct Leaves_s *leaf) { |
Romain Guy | a6d4d98 | 2009-10-15 12:37:13 -0700 | [diff] [blame] | 140 | |
Romain Guy | 59014c6 | 2009-10-09 12:27:18 -0700 | [diff] [blame] | 141 | float x = leaf->x; |
Romain Guy | 59014c6 | 2009-10-09 12:27:18 -0700 | [diff] [blame] | 142 | float y = leaf->y; |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 143 | |
Romain Guy | 59014c6 | 2009-10-09 12:27:18 -0700 | [diff] [blame] | 144 | float u1 = leaf->u1; |
| 145 | float u2 = leaf->u2; |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 146 | |
Romain Guy | 59014c6 | 2009-10-09 12:27:18 -0700 | [diff] [blame] | 147 | float a = leaf->altitude; |
| 148 | float s = leaf->scale; |
| 149 | float r = leaf->angle; |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 150 | |
| 151 | float tz = 0.0f; |
| 152 | if (a > 0.0f) { |
| 153 | tz = -a; |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 154 | } |
| 155 | |
Jason Sams | 2cfcc6d | 2009-10-21 17:51:46 -0700 | [diff] [blame] | 156 | float matrix[16]; |
Romain Guy | 59014c6 | 2009-10-09 12:27:18 -0700 | [diff] [blame] | 157 | if (a > 0.0f) { |
Jason Sams | 73f2f5f | 2009-11-10 16:13:23 -0800 | [diff] [blame] | 158 | |
Mike Cleron | fc6bdef | 2009-11-10 13:31:30 -0800 | [diff] [blame] | 159 | float alpha = 1.0f; |
Mike Cleron | 701a47f | 2009-11-10 12:55:26 -0800 | [diff] [blame] | 160 | if (a >= 0.4f) alpha = 1.0f - (a - 0.4f) / 0.1f; |
Jason Sams | 73f2f5f | 2009-11-10 16:13:23 -0800 | [diff] [blame] | 161 | |
Mike Cleron | 701a47f | 2009-11-10 12:55:26 -0800 | [diff] [blame] | 162 | color(0.0f, 0.0f, 0.0f, alpha * 0.15f); |
Romain Guy | a6d4d98 | 2009-10-15 12:37:13 -0700 | [diff] [blame] | 163 | |
Jason Sams | 6eec598 | 2009-10-23 17:47:12 -0700 | [diff] [blame] | 164 | if (State->rotate) { |
Romain Guy | a6d4d98 | 2009-10-15 12:37:13 -0700 | [diff] [blame] | 165 | matrixLoadRotate(matrix, 90.0f, 0.0f, 0.0f, 1.0f); |
| 166 | } else { |
| 167 | matrixLoadIdentity(matrix); |
| 168 | } |
Jason Sams | 73f2f5f | 2009-11-10 16:13:23 -0800 | [diff] [blame] | 169 | |
Mike Cleron | 701a47f | 2009-11-10 12:55:26 -0800 | [diff] [blame] | 170 | float shadowOffet = a / 5; |
Jason Sams | 73f2f5f | 2009-11-10 16:13:23 -0800 | [diff] [blame] | 171 | |
Mike Cleron | 701a47f | 2009-11-10 12:55:26 -0800 | [diff] [blame] | 172 | matrixTranslate(matrix, (x - State->xOffset * 2) + (shadowOffet / 2), y - shadowOffet, tz); |
Romain Guy | 59014c6 | 2009-10-09 12:27:18 -0700 | [diff] [blame] | 173 | matrixScale(matrix, s, s, 1.0f); |
| 174 | matrixRotate(matrix, r, 0.0f, 0.0f, 1.0f); |
| 175 | vpLoadModelMatrix(matrix); |
| 176 | |
Jason Sams | 873e993 | 2009-10-22 14:03:52 -0700 | [diff] [blame] | 177 | drawQuadTexCoords(-LEAF_SIZE, -LEAF_SIZE, 0, u1, 1.0f, |
| 178 | LEAF_SIZE, -LEAF_SIZE, 0, u2, 1.0f, |
| 179 | LEAF_SIZE, LEAF_SIZE, 0, u2, 0.0f, |
| 180 | -LEAF_SIZE, LEAF_SIZE, 0, u1, 0.0f); |
Romain Guy | 59014c6 | 2009-10-09 12:27:18 -0700 | [diff] [blame] | 181 | |
Romain Guy | 59014c6 | 2009-10-09 12:27:18 -0700 | [diff] [blame] | 182 | color(1.0f, 1.0f, 1.0f, alpha); |
| 183 | } else { |
| 184 | color(1.0f, 1.0f, 1.0f, 1.0f); |
| 185 | } |
| 186 | |
Jason Sams | 6eec598 | 2009-10-23 17:47:12 -0700 | [diff] [blame] | 187 | if (State->rotate) { |
Romain Guy | a6d4d98 | 2009-10-15 12:37:13 -0700 | [diff] [blame] | 188 | matrixLoadRotate(matrix, 90.0f, 0.0f, 0.0f, 1.0f); |
| 189 | } else { |
| 190 | matrixLoadIdentity(matrix); |
| 191 | } |
Jason Sams | 873e993 | 2009-10-22 14:03:52 -0700 | [diff] [blame] | 192 | matrixTranslate(matrix, x - State->xOffset * 2, y, tz); |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 193 | matrixScale(matrix, s, s, 1.0f); |
| 194 | matrixRotate(matrix, r, 0.0f, 0.0f, 1.0f); |
| 195 | vpLoadModelMatrix(matrix); |
| 196 | |
Jason Sams | 873e993 | 2009-10-22 14:03:52 -0700 | [diff] [blame] | 197 | drawQuadTexCoords(-LEAF_SIZE, -LEAF_SIZE, 0, u1, 1.0f, |
| 198 | LEAF_SIZE, -LEAF_SIZE, 0, u2, 1.0f, |
| 199 | LEAF_SIZE, LEAF_SIZE, 0, u2, 0.0f, |
| 200 | -LEAF_SIZE, LEAF_SIZE, 0, u1, 0.0f); |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 201 | |
Romain Guy | 59014c6 | 2009-10-09 12:27:18 -0700 | [diff] [blame] | 202 | float spin = leaf->spin; |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 203 | if (a <= 0.0f) { |
Romain Guy | 59014c6 | 2009-10-09 12:27:18 -0700 | [diff] [blame] | 204 | float rippled = leaf->rippled; |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 205 | if (rippled < 0.0f) { |
Jason Sams | 6eec598 | 2009-10-23 17:47:12 -0700 | [diff] [blame] | 206 | genLeafDrop(leaf, 1.5f); |
| 207 | //drop(((x + State->glWidth * 0.5f) / State->glWidth) * meshWidth, |
| 208 | // meshHeight - ((y + State->glHeight * 0.5f) / State->glHeight) * meshHeight, 1); |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 209 | spin /= 4.0f; |
Romain Guy | 59014c6 | 2009-10-09 12:27:18 -0700 | [diff] [blame] | 210 | leaf->spin = spin; |
| 211 | leaf->rippled = 1.0f; |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 212 | } |
Jason Sams | 756f974 | 2009-11-15 10:16:07 -0800 | [diff] [blame] | 213 | leaf->x = x + leaf->deltaX * g_DT; |
| 214 | leaf->y = y + leaf->deltaY * g_DT; |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 215 | r += spin; |
Romain Guy | 59014c6 | 2009-10-09 12:27:18 -0700 | [diff] [blame] | 216 | leaf->angle = r; |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 217 | } else { |
Jason Sams | 756f974 | 2009-11-15 10:16:07 -0800 | [diff] [blame] | 218 | a -= 0.15f * g_DT; |
Romain Guy | 59014c6 | 2009-10-09 12:27:18 -0700 | [diff] [blame] | 219 | leaf->altitude = a; |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 220 | r += spin * 2.0f; |
Romain Guy | 59014c6 | 2009-10-09 12:27:18 -0700 | [diff] [blame] | 221 | leaf->angle = r; |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 222 | } |
| 223 | |
Mike Cleron | 5b219fc | 2009-11-19 23:23:13 -0800 | [diff] [blame] | 224 | int newLeaf = 0; |
Jason Sams | 6eec598 | 2009-10-23 17:47:12 -0700 | [diff] [blame] | 225 | if (-LEAF_SIZE * s + x > State->glWidth || LEAF_SIZE * s + x < -State->glWidth || |
| 226 | LEAF_SIZE * s + y < -State->glHeight / 2.0f) { |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 227 | |
| 228 | int sprite = randf(LEAVES_TEXTURES_COUNT); |
Jason Sams | 6eec598 | 2009-10-23 17:47:12 -0700 | [diff] [blame] | 229 | leaf->x = randf2(-State->glWidth, State->glWidth); |
| 230 | leaf->y = randf2(-State->glHeight * 0.5f, State->glHeight * 0.5f); |
Jason Sams | 756f974 | 2009-11-15 10:16:07 -0800 | [diff] [blame] | 231 | |
Romain Guy | 59014c6 | 2009-10-09 12:27:18 -0700 | [diff] [blame] | 232 | leaf->scale = randf2(0.4f, 0.5f); |
Mike Cleron | 70ebeb8 | 2009-11-12 07:49:08 -0800 | [diff] [blame] | 233 | leaf->spin = degf(randf2(-0.02f, 0.02f)) * 0.35f; |
Romain Guy | 59014c6 | 2009-10-09 12:27:18 -0700 | [diff] [blame] | 234 | leaf->u1 = sprite / (float) LEAVES_TEXTURES_COUNT; |
| 235 | leaf->u2 = (sprite + 1) / (float) LEAVES_TEXTURES_COUNT; |
Mike Cleron | 70ebeb8 | 2009-11-12 07:49:08 -0800 | [diff] [blame] | 236 | leaf->altitude = 0.7f; |
Romain Guy | 59014c6 | 2009-10-09 12:27:18 -0700 | [diff] [blame] | 237 | leaf->rippled = -1.0f; |
Jason Sams | 756f974 | 2009-11-15 10:16:07 -0800 | [diff] [blame] | 238 | leaf->deltaX = randf2(-0.02f, 0.02f) / 2.0f; |
| 239 | leaf->deltaY = -0.08f * randf2(0.9f, 1.1f) / 2.0f; |
Mike Cleron | 5b219fc | 2009-11-19 23:23:13 -0800 | [diff] [blame] | 240 | leaf->newLeaf = 1; |
| 241 | newLeaf = 1; |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 242 | } |
Mike Cleron | 5b219fc | 2009-11-19 23:23:13 -0800 | [diff] [blame] | 243 | return newLeaf; |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 244 | } |
| 245 | |
| 246 | void drawLeaves() { |
Romain Guy | 59014c6 | 2009-10-09 12:27:18 -0700 | [diff] [blame] | 247 | bindProgramFragment(NAMED_PFSky); |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 248 | bindProgramFragmentStore(NAMED_PFSLeaf); |
| 249 | bindProgramVertex(NAMED_PVSky); |
Romain Guy | 59014c6 | 2009-10-09 12:27:18 -0700 | [diff] [blame] | 250 | bindTexture(NAMED_PFSky, 0, NAMED_TLeaves); |
| 251 | |
| 252 | color(1.0f, 1.0f, 1.0f, 1.0f); |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 253 | |
Mike Cleron | 5b219fc | 2009-11-19 23:23:13 -0800 | [diff] [blame] | 254 | int newLeaves = 0; |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 255 | int i = 0; |
Mike Cleron | 5b219fc | 2009-11-19 23:23:13 -0800 | [diff] [blame] | 256 | for ( ; i < LEAVES_COUNT; i += 1) { |
| 257 | if (drawLeaf(gLeaves[i])) { |
| 258 | newLeaves = 1; |
Jason Sams | 0cd5306 | 2009-12-08 15:46:00 -0800 | [diff] [blame] | 259 | |
Mike Cleron | 5b219fc | 2009-11-19 23:23:13 -0800 | [diff] [blame] | 260 | } |
| 261 | } |
Jason Sams | 0cd5306 | 2009-12-08 15:46:00 -0800 | [diff] [blame] | 262 | |
| 263 | if (newLeaves > 0) { |
Mike Cleron | 5b219fc | 2009-11-19 23:23:13 -0800 | [diff] [blame] | 264 | int index = 0; |
Jason Sams | 0cd5306 | 2009-12-08 15:46:00 -0800 | [diff] [blame] | 265 | |
Mike Cleron | 5b219fc | 2009-11-19 23:23:13 -0800 | [diff] [blame] | 266 | // Copy all the old leaves to the beginning of gNextLeaves |
| 267 | for (i=0; i < LEAVES_COUNT; i++) { |
| 268 | if (gLeaves[i]->newLeaf == 0) { |
| 269 | gNextLeaves[index] = gLeaves[i]; |
| 270 | index++; |
| 271 | } |
| 272 | } |
Jason Sams | 0cd5306 | 2009-12-08 15:46:00 -0800 | [diff] [blame] | 273 | |
Mike Cleron | 5b219fc | 2009-11-19 23:23:13 -0800 | [diff] [blame] | 274 | // Now copy all the newly falling leaves to the end of gNextLeaves |
| 275 | for (i=0; i < LEAVES_COUNT; i++) { |
| 276 | if (gLeaves[i]->newLeaf > 0) { |
| 277 | gNextLeaves[index] = gLeaves[i]; |
| 278 | gNextLeaves[index]->newLeaf = 0; |
| 279 | index++; |
| 280 | } |
| 281 | } |
Jason Sams | 0cd5306 | 2009-12-08 15:46:00 -0800 | [diff] [blame] | 282 | |
Mike Cleron | 5b219fc | 2009-11-19 23:23:13 -0800 | [diff] [blame] | 283 | // And move everything in gNextLeaves back to gLeaves |
| 284 | for (i=0; i < LEAVES_COUNT; i++) { |
| 285 | gLeaves[i] = gNextLeaves[i]; |
| 286 | } |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 287 | } |
| 288 | |
| 289 | float matrix[16]; |
| 290 | matrixLoadIdentity(matrix); |
| 291 | vpLoadModelMatrix(matrix); |
| 292 | } |
| 293 | |
| 294 | void drawRiverbed() { |
| 295 | bindTexture(NAMED_PFBackground, 0, NAMED_TRiverbed); |
Jason Sams | 2430b67 | 2009-09-24 13:01:52 -0700 | [diff] [blame] | 296 | drawSimpleMesh(NAMED_WaterMesh); |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 297 | } |
| 298 | |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 299 | int main(int index) { |
Jason Sams | 756f974 | 2009-11-15 10:16:07 -0800 | [diff] [blame] | 300 | // Compute dt in seconds. |
| 301 | int newTime = uptimeMillis(); |
| 302 | g_DT = (newTime - g_LastTime) / 1000.f; |
| 303 | g_LastTime = newTime; |
| 304 | g_DT = minf(g_DT, 0.2f); |
| 305 | |
| 306 | |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 307 | if (Drop->dropX != -1) { |
Jason Sams | 73f2f5f | 2009-11-10 16:13:23 -0800 | [diff] [blame] | 308 | drop(Drop->dropX, Drop->dropY, 2); |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 309 | Drop->dropX = -1; |
| 310 | Drop->dropY = -1; |
| 311 | } |
Romain Guy | 2d42794 | 2009-10-14 15:43:27 -0700 | [diff] [blame] | 312 | |
Jason Sams | 2cfcc6d | 2009-10-21 17:51:46 -0700 | [diff] [blame] | 313 | int ct; |
Jason Sams | 6eec598 | 2009-10-23 17:47:12 -0700 | [diff] [blame] | 314 | int add = 0; |
Jason Sams | 2cfcc6d | 2009-10-21 17:51:46 -0700 | [diff] [blame] | 315 | for (ct = 0; ct < gMaxDrops; ct++) { |
Jason Sams | b344cf4 | 2009-11-06 11:50:42 -0800 | [diff] [blame] | 316 | if (gDrops[ct].ampE < 0.005f) { |
Jason Sams | 6eec598 | 2009-10-23 17:47:12 -0700 | [diff] [blame] | 317 | add = 1; |
| 318 | } |
Jason Sams | 2cfcc6d | 2009-10-21 17:51:46 -0700 | [diff] [blame] | 319 | } |
Romain Guy | 2d42794 | 2009-10-14 15:43:27 -0700 | [diff] [blame] | 320 | |
Jason Sams | 6eec598 | 2009-10-23 17:47:12 -0700 | [diff] [blame] | 321 | if (add) { |
Mike Cleron | 5b219fc | 2009-11-19 23:23:13 -0800 | [diff] [blame] | 322 | int i = (int)randf(LEAVES_COUNT); |
| 323 | genLeafDrop(gLeaves[i], randf(0.3f) + 0.1f); |
Romain Guy | a454eca | 2009-10-14 18:22:20 -0700 | [diff] [blame] | 324 | } |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 325 | |
Romain Guy | a6d4d98 | 2009-10-15 12:37:13 -0700 | [diff] [blame] | 326 | if (State->rotate) { |
| 327 | float matrix[16]; |
| 328 | matrixLoadRotate(matrix, 90.0f, 0.0f, 0.0f, 1.0f); |
| 329 | vpLoadModelMatrix(matrix); |
| 330 | } |
| 331 | |
Jason Sams | 16bf60c | 2010-01-26 12:40:07 -0800 | [diff] [blame] | 332 | bindProgramVertex(NAMED_PVWater); |
| 333 | generateRipples(); |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 334 | drawRiverbed(); |
Jason Sams | 16bf60c | 2010-01-26 12:40:07 -0800 | [diff] [blame] | 335 | |
| 336 | bindProgramVertex(NAMED_PVSky); |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 337 | drawLeaves(); |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 338 | |
Jason Sams | 0cd5306 | 2009-12-08 15:46:00 -0800 | [diff] [blame] | 339 | return 30; |
Romain Guy | 59206df | 2009-09-09 13:07:58 -0700 | [diff] [blame] | 340 | } |