Kristian Høgsberg | 012a007 | 2010-10-26 00:02:20 -0400 | [diff] [blame] | 1 | /* |
| 2 | * Copyright © 2010 Kristian Høgsberg |
| 3 | * |
| 4 | * Permission to use, copy, modify, distribute, and sell this software and its |
| 5 | * documentation for any purpose is hereby granted without fee, provided that |
| 6 | * the above copyright notice appear in all copies and that both that copyright |
| 7 | * notice and this permission notice appear in supporting documentation, and |
| 8 | * that the name of the copyright holders not be used in advertising or |
| 9 | * publicity pertaining to distribution of the software without specific, |
| 10 | * written prior permission. The copyright holders make no representations |
| 11 | * about the suitability of this software for any purpose. It is provided "as |
| 12 | * is" without express or implied warranty. |
| 13 | * |
| 14 | * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, |
| 15 | * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO |
| 16 | * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR |
| 17 | * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, |
| 18 | * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER |
| 19 | * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE |
| 20 | * OF THIS SOFTWARE. |
| 21 | */ |
| 22 | |
| 23 | #include <stdint.h> |
| 24 | #include <stdio.h> |
| 25 | #include <stdlib.h> |
| 26 | #include <string.h> |
| 27 | #include <time.h> |
| 28 | #include <fcntl.h> |
| 29 | #include <unistd.h> |
| 30 | #include <math.h> |
| 31 | #include <time.h> |
| 32 | #include <cairo.h> |
| 33 | #include <glib.h> |
| 34 | |
Pekka Paalanen | 50719bc | 2011-11-22 14:18:50 +0200 | [diff] [blame] | 35 | #include <wayland-client.h> |
Kristian Høgsberg | 012a007 | 2010-10-26 00:02:20 -0400 | [diff] [blame] | 36 | #include "window.h" |
| 37 | |
| 38 | struct smoke { |
| 39 | struct display *display; |
| 40 | struct window *window; |
Kristian Høgsberg | 75bc667 | 2012-01-10 09:43:58 -0500 | [diff] [blame] | 41 | struct widget *widget; |
Kristian Høgsberg | 012a007 | 2010-10-26 00:02:20 -0400 | [diff] [blame] | 42 | cairo_surface_t *surface; |
| 43 | int x, y, width, height; |
| 44 | int offset, current; |
| 45 | struct { float *d, *u, *v; } b[2]; |
| 46 | }; |
| 47 | |
Kristian Høgsberg | 012a007 | 2010-10-26 00:02:20 -0400 | [diff] [blame] | 48 | static void diffuse(struct smoke *smoke, uint32_t time, |
| 49 | float *source, float *dest) |
| 50 | { |
Kristian Høgsberg | 012a007 | 2010-10-26 00:02:20 -0400 | [diff] [blame] | 51 | float *s, *d; |
| 52 | int x, y, k, stride; |
| 53 | float t, a = 0.0002; |
| 54 | |
| 55 | stride = smoke->width; |
| 56 | |
| 57 | for (k = 0; k < 5; k++) { |
| 58 | for (y = 1; y < smoke->height - 1; y++) { |
| 59 | s = source + y * stride; |
| 60 | d = dest + y * stride; |
| 61 | for (x = 1; x < smoke->width - 1; x++) { |
| 62 | t = d[x - 1] + d[x + 1] + |
| 63 | d[x - stride] + d[x + stride]; |
| 64 | d[x] = (s[x] + a * t) / (1 + 4 * a) * 0.995; |
| 65 | } |
| 66 | } |
| 67 | } |
| 68 | } |
| 69 | |
| 70 | static void advect(struct smoke *smoke, uint32_t time, |
| 71 | float *uu, float *vv, float *source, float *dest) |
| 72 | { |
Kristian Høgsberg | 012a007 | 2010-10-26 00:02:20 -0400 | [diff] [blame] | 73 | float *s, *d; |
| 74 | float *u, *v; |
Bryce Harrington | 40269a6 | 2010-11-19 12:15:36 -0800 | [diff] [blame] | 75 | int x, y, stride; |
Kristian Høgsberg | 012a007 | 2010-10-26 00:02:20 -0400 | [diff] [blame] | 76 | int i, j; |
| 77 | float px, py, fx, fy; |
| 78 | |
| 79 | stride = smoke->width; |
| 80 | |
| 81 | for (y = 1; y < smoke->height - 1; y++) { |
| 82 | d = dest + y * stride; |
| 83 | u = uu + y * stride; |
| 84 | v = vv + y * stride; |
| 85 | |
| 86 | for (x = 1; x < smoke->width - 1; x++) { |
| 87 | px = x - u[x]; |
| 88 | py = y - v[x]; |
| 89 | if (px < 0.5) |
| 90 | px = 0.5; |
| 91 | if (py < 0.5) |
| 92 | py = 0.5; |
| 93 | if (px > smoke->width - 0.5) |
| 94 | px = smoke->width - 0.5; |
| 95 | if (py > smoke->height - 0.5) |
| 96 | py = smoke->height - 0.5; |
| 97 | i = (int) px; |
| 98 | j = (int) py; |
| 99 | fx = px - i; |
| 100 | fy = py - j; |
| 101 | s = source + j * stride + i; |
| 102 | d[x] = (s[0] * (1 - fx) + s[1] * fx) * (1 - fy) + |
| 103 | (s[stride] * (1 - fx) + s[stride + 1] * fx) * fy; |
| 104 | } |
| 105 | } |
| 106 | } |
| 107 | |
| 108 | static void project(struct smoke *smoke, uint32_t time, |
| 109 | float *u, float *v, float *p, float *div) |
| 110 | { |
| 111 | int x, y, k, l, s; |
Bryce Harrington | 40269a6 | 2010-11-19 12:15:36 -0800 | [diff] [blame] | 112 | float h; |
Kristian Høgsberg | 012a007 | 2010-10-26 00:02:20 -0400 | [diff] [blame] | 113 | |
| 114 | h = 1.0 / smoke->width; |
| 115 | s = smoke->width; |
| 116 | memset(p, 0, smoke->height * smoke->width); |
| 117 | for (y = 1; y < smoke->height - 1; y++) { |
| 118 | l = y * s; |
| 119 | for (x = 1; x < smoke->width - 1; x++) { |
| 120 | div[l + x] = -0.5 * h * (u[l + x + 1] - u[l + x - 1] + |
| 121 | v[l + x + s] - v[l + x - s]); |
| 122 | p[l + x] = 0; |
| 123 | } |
| 124 | } |
| 125 | |
| 126 | for (k = 0; k < 5; k++) { |
| 127 | for (y = 1; y < smoke->height - 1; y++) { |
| 128 | l = y * s; |
| 129 | for (x = 1; x < smoke->width - 1; x++) { |
| 130 | p[l + x] = (div[l + x] + |
| 131 | p[l + x - 1] + |
| 132 | p[l + x + 1] + |
| 133 | p[l + x - s] + |
| 134 | p[l + x + s]) / 4; |
| 135 | } |
| 136 | } |
| 137 | } |
| 138 | |
| 139 | for (y = 1; y < smoke->height - 1; y++) { |
| 140 | l = y * s; |
| 141 | for (x = 1; x < smoke->width - 1; x++) { |
| 142 | u[l + x] -= 0.5 * (p[l + x + 1] - p[l + x - 1]) / h; |
| 143 | v[l + x] -= 0.5 * (p[l + x + s] - p[l + x - s]) / h; |
| 144 | } |
| 145 | } |
| 146 | } |
| 147 | |
| 148 | static void render(struct smoke *smoke) |
| 149 | { |
Bryce Harrington | 40269a6 | 2010-11-19 12:15:36 -0800 | [diff] [blame] | 150 | unsigned char *dest; |
Kristian Høgsberg | 012a007 | 2010-10-26 00:02:20 -0400 | [diff] [blame] | 151 | int x, y, width, height, stride; |
Kristian Høgsberg | 012a007 | 2010-10-26 00:02:20 -0400 | [diff] [blame] | 152 | float *s; |
| 153 | uint32_t *d, c, a; |
| 154 | |
| 155 | dest = cairo_image_surface_get_data (smoke->surface); |
| 156 | width = cairo_image_surface_get_width (smoke->surface); |
| 157 | height = cairo_image_surface_get_height (smoke->surface); |
| 158 | stride = cairo_image_surface_get_stride (smoke->surface); |
| 159 | |
| 160 | for (y = 1; y < height - 1; y++) { |
| 161 | s = smoke->b[smoke->current].d + y * smoke->height; |
| 162 | d = (uint32_t *) (dest + y * stride); |
| 163 | for (x = 1; x < width - 1; x++) { |
| 164 | c = (int) (s[x] * 800); |
| 165 | if (c > 255) |
| 166 | c = 255; |
| 167 | a = c; |
| 168 | if (a < 0x33) |
| 169 | a = 0x33; |
| 170 | d[x] = (a << 24) | (c << 16) | (c << 8) | c; |
| 171 | } |
| 172 | } |
| 173 | } |
| 174 | |
| 175 | static void |
Kristian Høgsberg | a8d1fa7 | 2011-08-23 18:14:06 -0400 | [diff] [blame] | 176 | frame_callback(void *data, struct wl_callback *callback, uint32_t time) |
Kristian Høgsberg | 012a007 | 2010-10-26 00:02:20 -0400 | [diff] [blame] | 177 | { |
Kristian Høgsberg | a8d1fa7 | 2011-08-23 18:14:06 -0400 | [diff] [blame] | 178 | static const struct wl_callback_listener listener = { |
| 179 | frame_callback, |
| 180 | }; |
Kristian Høgsberg | 012a007 | 2010-10-26 00:02:20 -0400 | [diff] [blame] | 181 | struct smoke *smoke = data; |
Kristian Høgsberg | 012a007 | 2010-10-26 00:02:20 -0400 | [diff] [blame] | 182 | |
| 183 | diffuse(smoke, time / 30, smoke->b[0].u, smoke->b[1].u); |
| 184 | diffuse(smoke, time / 30, smoke->b[0].v, smoke->b[1].v); |
| 185 | project(smoke, time / 30, |
| 186 | smoke->b[1].u, smoke->b[1].v, |
| 187 | smoke->b[0].u, smoke->b[0].v); |
| 188 | advect(smoke, time / 30, |
| 189 | smoke->b[1].u, smoke->b[1].v, |
| 190 | smoke->b[1].u, smoke->b[0].u); |
| 191 | advect(smoke, time / 30, |
| 192 | smoke->b[1].u, smoke->b[1].v, |
| 193 | smoke->b[1].v, smoke->b[0].v); |
| 194 | project(smoke, time / 30, |
| 195 | smoke->b[0].u, smoke->b[0].v, |
| 196 | smoke->b[1].u, smoke->b[1].v); |
| 197 | |
| 198 | diffuse(smoke, time / 30, smoke->b[0].d, smoke->b[1].d); |
| 199 | advect(smoke, time / 30, |
| 200 | smoke->b[0].u, smoke->b[0].v, |
| 201 | smoke->b[1].d, smoke->b[0].d); |
| 202 | |
| 203 | render(smoke); |
| 204 | |
Kristian Høgsberg | a8d1fa7 | 2011-08-23 18:14:06 -0400 | [diff] [blame] | 205 | if (callback) |
| 206 | wl_callback_destroy(callback); |
| 207 | |
Benjamin Franzke | bde55ec | 2011-03-07 15:08:09 +0100 | [diff] [blame] | 208 | display_surface_damage(smoke->display, smoke->surface, |
| 209 | 0, 0, smoke->width, smoke->height); |
Kristian Høgsberg | 012a007 | 2010-10-26 00:02:20 -0400 | [diff] [blame] | 210 | window_damage(smoke->window, 0, 0, smoke->width, smoke->height); |
Kristian Høgsberg | a8d1fa7 | 2011-08-23 18:14:06 -0400 | [diff] [blame] | 211 | |
| 212 | callback = wl_surface_frame(window_get_wl_surface(smoke->window)); |
| 213 | wl_callback_add_listener(callback, &listener, smoke); |
Kristian Høgsberg | 012a007 | 2010-10-26 00:02:20 -0400 | [diff] [blame] | 214 | } |
| 215 | |
| 216 | static int |
Kristian Høgsberg | 87a57bb | 2012-01-09 10:34:35 -0500 | [diff] [blame] | 217 | smoke_motion_handler(struct widget *widget, struct input *input, |
| 218 | uint32_t time, int32_t x, int32_t y, void *data) |
Kristian Høgsberg | 012a007 | 2010-10-26 00:02:20 -0400 | [diff] [blame] | 219 | { |
| 220 | struct smoke *smoke = data; |
| 221 | int i, i0, i1, j, j0, j1, k, d = 5; |
| 222 | |
Kristian Høgsberg | 87a57bb | 2012-01-09 10:34:35 -0500 | [diff] [blame] | 223 | if (x - d < 1) |
Kristian Høgsberg | 012a007 | 2010-10-26 00:02:20 -0400 | [diff] [blame] | 224 | i0 = 1; |
| 225 | else |
Kristian Høgsberg | 87a57bb | 2012-01-09 10:34:35 -0500 | [diff] [blame] | 226 | i0 = x - d; |
Kristian Høgsberg | 012a007 | 2010-10-26 00:02:20 -0400 | [diff] [blame] | 227 | if (i0 + 2 * d > smoke->width - 1) |
| 228 | i1 = smoke->width - 1; |
| 229 | else |
| 230 | i1 = i0 + 2 * d; |
| 231 | |
Kristian Høgsberg | 87a57bb | 2012-01-09 10:34:35 -0500 | [diff] [blame] | 232 | if (y - d < 1) |
Kristian Høgsberg | 012a007 | 2010-10-26 00:02:20 -0400 | [diff] [blame] | 233 | j0 = 1; |
| 234 | else |
Kristian Høgsberg | 87a57bb | 2012-01-09 10:34:35 -0500 | [diff] [blame] | 235 | j0 = y - d; |
Kristian Høgsberg | 012a007 | 2010-10-26 00:02:20 -0400 | [diff] [blame] | 236 | if (j0 + 2 * d > smoke->height - 1) |
| 237 | j1 = smoke->height - 1; |
| 238 | else |
| 239 | j1 = j0 + 2 * d; |
| 240 | |
| 241 | for (i = i0; i < i1; i++) |
| 242 | for (j = j0; j < j1; j++) { |
| 243 | k = j * smoke->width + i; |
| 244 | smoke->b[0].u[k] += 256 - (random() & 512); |
| 245 | smoke->b[0].v[k] += 256 - (random() & 512); |
| 246 | smoke->b[0].d[k] += 1; |
| 247 | } |
| 248 | |
| 249 | return POINTER_HAND1; |
| 250 | } |
| 251 | |
| 252 | int main(int argc, char *argv[]) |
| 253 | { |
| 254 | struct timespec ts; |
| 255 | struct smoke smoke; |
| 256 | struct display *d; |
Bryce Harrington | 40269a6 | 2010-11-19 12:15:36 -0800 | [diff] [blame] | 257 | int size; |
Kristian Høgsberg | 012a007 | 2010-10-26 00:02:20 -0400 | [diff] [blame] | 258 | |
Kristian Høgsberg | 9de79a9 | 2011-08-24 11:09:53 -0400 | [diff] [blame] | 259 | d = display_create(&argc, &argv, NULL); |
Yuval Fledel | e9f5e36 | 2010-11-22 21:34:19 +0200 | [diff] [blame] | 260 | if (d == NULL) { |
| 261 | fprintf(stderr, "failed to create display: %m\n"); |
| 262 | return -1; |
| 263 | } |
Kristian Høgsberg | 012a007 | 2010-10-26 00:02:20 -0400 | [diff] [blame] | 264 | |
| 265 | smoke.x = 200; |
| 266 | smoke.y = 200; |
| 267 | smoke.width = 200; |
| 268 | smoke.height = 200; |
| 269 | smoke.display = d; |
Kristian Høgsberg | 009ac0a | 2012-01-31 15:24:48 -0500 | [diff] [blame^] | 270 | smoke.window = window_create(d); |
Kristian Høgsberg | 75bc667 | 2012-01-10 09:43:58 -0500 | [diff] [blame] | 271 | smoke.widget = window_add_widget(smoke.window, &smoke); |
Kristian Høgsberg | 248c1b6 | 2011-01-21 18:03:15 -0500 | [diff] [blame] | 272 | window_set_title(smoke.window, "smoke"); |
Kristian Høgsberg | 012a007 | 2010-10-26 00:02:20 -0400 | [diff] [blame] | 273 | |
| 274 | window_set_buffer_type(smoke.window, WINDOW_BUFFER_TYPE_SHM); |
| 275 | clock_gettime(CLOCK_MONOTONIC, &ts); |
| 276 | srandom(ts.tv_nsec); |
| 277 | smoke.offset = random(); |
| 278 | |
| 279 | smoke.current = 0; |
| 280 | size = smoke.height * smoke.width; |
| 281 | smoke.b[0].d = calloc(size, sizeof(float)); |
| 282 | smoke.b[0].u = calloc(size, sizeof(float)); |
| 283 | smoke.b[0].v = calloc(size, sizeof(float)); |
| 284 | smoke.b[1].d = calloc(size, sizeof(float)); |
| 285 | smoke.b[1].u = calloc(size, sizeof(float)); |
| 286 | smoke.b[1].v = calloc(size, sizeof(float)); |
| 287 | |
Kristian Høgsberg | 012a007 | 2010-10-26 00:02:20 -0400 | [diff] [blame] | 288 | window_create_surface(smoke.window); |
| 289 | smoke.surface = window_get_surface(smoke.window); |
| 290 | |
| 291 | window_flush(smoke.window); |
| 292 | |
Kristian Høgsberg | 75bc667 | 2012-01-10 09:43:58 -0500 | [diff] [blame] | 293 | widget_set_motion_handler(smoke.widget, smoke_motion_handler); |
Kristian Høgsberg | 012a007 | 2010-10-26 00:02:20 -0400 | [diff] [blame] | 294 | |
| 295 | window_set_user_data(smoke.window, &smoke); |
Kristian Høgsberg | a8d1fa7 | 2011-08-23 18:14:06 -0400 | [diff] [blame] | 296 | frame_callback(&smoke, NULL, 0); |
Kristian Høgsberg | 012a007 | 2010-10-26 00:02:20 -0400 | [diff] [blame] | 297 | display_run(d); |
| 298 | |
| 299 | return 0; |
| 300 | } |