User:Ledrug/bits: Difference between revisions
mNo edit summary |
mNo edit summary |
||
Line 3: | Line 3: | ||
#include <math.h> |
#include <math.h> |
||
#define MAXD 8 |
|||
⚫ | |||
/* Perlin-like noise */ |
|||
inline double |
|||
⚫ | |||
# define rot(a, d) ((a << (d)) | (a >> (32 - d))) |
# define rot(a, d) ((a << (d)) | (a >> (32 - d))) |
||
unsigned int *d = (void*)data, h = 0x123456, tmp; |
unsigned int *d = (void*)data, h = 0x123456, tmp; |
||
Line 20: | Line 23: | ||
} |
} |
||
double |
double scale[MAXD], scale_u[MAXD]; |
||
void noise_init() |
|||
{ |
|||
int i; |
|||
⚫ | |||
⚫ | |||
⚫ | |||
} |
|||
} |
|||
double noise(double *x, int d) |
|||
{ |
{ |
||
# define sum(s, x) for (s = 0, j = 0; j < d; j++) s += x |
# define sum(s, x) for (s = 0, j = 0; j < d; j++) s += x |
||
int i, j |
register int i, j; |
||
int n[MAXD], o[MAXD], tmp; |
|||
double |
double s, r, t, ret, w; |
||
double u[MAXD], sk[MAXD]; |
|||
sum(s, x[j]); |
sum(s, x[j]); |
||
⚫ | |||
⚫ | |||
⚫ | |||
for (i = 0; i < d; i++) { |
for (i = 0; i < d; i++) { |
||
// sk[i] = x[i] + s; |
|||
t = x[i] + s; |
|||
u[i] = t - (n[i] = floor(t)); |
|||
o[i] = i; |
o[i] = i; |
||
} |
} |
||
Line 40: | Line 54: | ||
for (j = i; j < d; j++) |
for (j = i; j < d; j++) |
||
if (u[o[i]] < u[o[j]]) |
if (u[o[i]] < u[o[j]]) |
||
tmp = o[i], o[i] = o[j], o[j] = tmp; |
|||
ret = w = |
ret = 0, r = 1, w = 1; |
||
⚫ | |||
⚫ | |||
sum(s, n[j]); |
|||
⚫ | |||
for (i = 0; i < d; i++) { |
|||
⚫ | |||
t = s * s * (3 - 2 * s); |
|||
ret += hashed(n, d) * (1 - t) * r; |
|||
⚫ | |||
⚫ | |||
r *= t; |
|||
n[o[i]]++; |
|||
w += s; |
|||
ret += hashed(n, d) * s; |
|||
} |
|||
⚫ | |||
} |
} |
||
return |
return ret + hashed(n, d) * r; |
||
} |
} |
||
double get_noise2(double x, double y) |
double get_noise2(double x, double y) |
||
{ |
{ |
||
int i |
int i, ws; |
||
double r = 0, v[2] |
double r = 0, v[2]; |
||
for (i = 1, ws = 0; i <= 256; i <<= 1) { |
for (i = 1, ws = 0; i <= 256; i <<= 1) { |
||
v[0] = x * i, v[1] = y * i; |
v[0] = x * i, v[1] = y * i; |
||
r += noise(v, 2); |
|||
ws ++; |
|||
ws += w; |
|||
} |
} |
||
r /= ws; |
r /= ws; |
||
Line 80: | Line 87: | ||
double get_noise3(double x, double y, double z) |
double get_noise3(double x, double y, double z) |
||
{ |
{ |
||
int i |
int i, ws; |
||
double r = 0, v[3], w; |
double r = 0, v[3], w; |
||
for (i = 1, ws = 0; i <= |
for (i = 1, ws = 0; i <= 128; i <<= 1) { |
||
v[0] = x * i, v[1] = y * i, v[2] = z * i; |
v[0] = x * i, v[1] = y * i, v[2] = z * i; |
||
w = 1./i; |
w = 1./sqrt(i); |
||
r += noise(v, 3) * w; |
r += noise(v, 3) * w; |
||
ws += w; |
ws += w; |
||
} |
} |
||
r / |
return r / ws; |
||
return fmod(r * 5 + 5, 1); |
|||
} |
} |
||
Line 100: | Line 106: | ||
double x, y, z, w; |
double x, y, z, w; |
||
FILE *fp; |
FILE *fp; |
||
noise_init(); |
|||
for (p = pix, i = 0; i < 256 * 256; i++) *p++ = 0; |
for (p = pix, i = 0; i < 256 * 256; i++) *p++ = 0; |
||
get_noise2(0, .0001); |
|||
for (p = pix, i = 0; i < 256; i++) { |
for (p = pix, i = 0; i < 256; i++) { |
||
y = (i - 128) / 125.; |
y = (i - 128) / 125.; |
||
for (j = 0; j < 256; j++, p++) { |
for (j = 0; j < 256; j++, p++) { |
||
x = (j - 128) / 125.; |
x = (j - 128) / 125.; |
||
*p = (get_noise2(i/256., j/256.) + 1) / |
*p = (get_noise2(i/256., j/256.) + 1) / 6 * i; |
||
//*p = (get_noise2(i/256., j/256.) + 1) / 2 * 255; |
|||
z = 1- x*x - y*y; |
z = 1- x*x - y*y; |
||
Line 113: | Line 123: | ||
z = sqrt(z); |
z = sqrt(z); |
||
w = get_noise3(x, y, z + 1); |
|||
w = (w + 1) / 2; |
|||
⚫ | |||
⚫ | |||
w = get_noise3(x, y, z); |
|||
⚫ | |||
⚫ | |||
⚫ | |||
*p = w * 255; |
*p = w * 255; |
||
} |
} |
Revision as of 06:43, 24 September 2011
<lang c>#include <stdio.h>
- include <stdlib.h>
- include <math.h>
- define MAXD 8
/* Perlin-like noise */ inline double hashed(int *data, int len) {
- define rot(a, d) ((a << (d)) | (a >> (32 - d)))
unsigned int *d = (void*)data, h = 0x123456, tmp;
while (len--) { tmp = *d++; h += rot(h, 16) ^ (rot(tmp, 5) ^ h); }
h ^= rot(h, 7); h += rot(h, 11); h ^= rot(h, 17); h += rot(h, 25);
- undef rot
return (double)(int)h / (1U << 31); }
double scale[MAXD], scale_u[MAXD]; void noise_init() { int i; for (i = 1; i < MAXD; i++) { scale[i] = 1 / (1 + sqrt(i + 1)); scale_u[i] = scale[i] / sqrt(i + 1); } }
double noise(double *x, int d) {
- define sum(s, x) for (s = 0, j = 0; j < d; j++) s += x
register int i, j; int n[MAXD], o[MAXD], tmp; double s, r, t, ret, w; double u[MAXD], sk[MAXD];
sum(s, x[j]); s *= scale[d];
for (i = 0; i < d; i++) { // sk[i] = x[i] + s; t = x[i] + s; u[i] = t - (n[i] = floor(t)); o[i] = i; }
for (i = 0; i < d - 1; i++) for (j = i; j < d; j++) if (u[o[i]] < u[o[j]]) tmp = o[i], o[i] = o[j], o[j] = tmp;
ret = 0, r = 1, w = 1;
for (i = 0; i < d; i++) { s = u[o[i]] / w; t = s * s * (3 - 2 * s); ret += hashed(n, d) * (1 - t) * r; w *= s; if (!w) return ret;
r *= t; n[o[i]]++; } return ret + hashed(n, d) * r; }
double get_noise2(double x, double y) { int i, ws; double r = 0, v[2];
for (i = 1, ws = 0; i <= 256; i <<= 1) { v[0] = x * i, v[1] = y * i; r += noise(v, 2); ws ++; } r /= ws; return r; }
double get_noise3(double x, double y, double z) { int i, ws; double r = 0, v[3], w;
for (i = 1, ws = 0; i <= 128; i <<= 1) { v[0] = x * i, v[1] = y * i, v[2] = z * i; w = 1./sqrt(i); r += noise(v, 3) * w; ws += w; } return r / ws; }
int main()
{
unsigned char pix[256 * 256], *p;
int i, j;
double x, y, z, w;
FILE *fp;
noise_init();
for (p = pix, i = 0; i < 256 * 256; i++) *p++ = 0;
get_noise2(0, .0001); for (p = pix, i = 0; i < 256; i++) { y = (i - 128) / 125.; for (j = 0; j < 256; j++, p++) { x = (j - 128) / 125.; *p = (get_noise2(i/256., j/256.) + 1) / 6 * i; //*p = (get_noise2(i/256., j/256.) + 1) / 2 * 255;
z = 1- x*x - y*y; if (z < 0) continue;
z = sqrt(z); w = get_noise3(x, y, z + 1); w = (w + 1) / 2; w = w * (.5 + x - y + z) / 3; if (w < 0) w = 0;
*p = w * 255; } }
fp = fopen("out.pgm", "w+"); fprintf(fp, "P5\n256 256\n255\n"); fwrite(pix, 1, 256 * 256, fp); fclose(fp);
return 0; }</lang> <lang c>#include <stdio.h>
- include <stdlib.h>
- include <stdint.h>
- include <string.h>
typedef uint32_t hash_t;
typedef struct hash_value_t { void *data; char *key; struct hash_value_t *chain; } hash_value_t;
typedef struct hash_table_t { hash_value_t **v, *pool; size_t n, cap; } hash_table_t, *htbl;
inline hash_t hash(char *s) { hash_t hash; for (hash = 0; *s; s++) { hash += *s; hash += (hash << 10); hash ^= (hash >> 6); } hash += hash << 3; hash ^= hash >> 11; hash += hash << 15; return hash; }
htbl hash_new(size_t size) { htbl h = calloc(1, sizeof(hash_table_t)); if (!size) size = 4;
for (h->cap = 1; h->cap < size; h->cap <<= 1);
h->v = calloc(h->cap, sizeof(hash_value_t*)); h->pool = 0; return h; }
hash_value_t *hash_get_storage(htbl t) { size_t len; hash_value_t *p = t->pool; if (!p) { len = 1024; if (len > t->cap) len = t->cap; t->pool = calloc(len, sizeof(hash_value_t)); for (p = t->pool; len > 1; len --) p->chain = p + 1; p = t->pool; } t->pool = p->chain; return p; }
void hash_insert_node(htbl t, hash_value_t *p) { size_t idx = hash(p->key) % t->cap; p->chain = t->v[idx]; t->v[idx] = p; }
void hash_expand(htbl t) { size_t i, c = t->cap; hash_value_t *p, *tmp;
t->v = realloc(t->v, sizeof(hash_value_t*) * c * 2); memset(t->v + c, 0, c * sizeof(hash_table_t*));
t->cap *= 2; for (i = 0; i < c; i++) { p = t->v[i]; if (!p) continue;
t->v[i] = 0; while (p) { tmp = p->chain; p->chain = 0; hash_insert_node(t, p); p = tmp; } } }
void hash_insert(htbl t, char *s, void *data) { hash_value_t *p = hash_get_storage(t); if (t->n * 5 >= t->cap * 4) hash_expand(t); p->key = strdup(s); p->data = data; hash_insert_node(t, p); t->n ++; }
void* hash_remove(htbl t, char *s) { size_t idx = hash(s) % t->cap; hash_value_t *head = 0, *p = t->v[idx];
while (p) { if (!strcmp(p->key, s)) break; head = p; p = p->chain; } if (!p) return 0;
free(p->key);
if (head) head->chain = p->chain; else t->v[idx] = p->chain;
p->chain = t->pool; t->pool = p; t->n--; return p->data; }
void* hash_lookup(htbl t, char *s) { size_t idx = hash(s) % t->cap; hash_value_t *p; p = t->v[idx]; while (p) { if (!strcmp(p->key, s)) return p->data; p = p->chain; } return (void*)-1; }</lang>