Spaces:
Build error
Build error
| const formatMessage = require('format-message'); | |
| const BlockType = require('../../extension-support/block-type'); | |
| const ArgumentType = require('../../extension-support/argument-type'); | |
| const MersenneTwister = require('mersenne-twister'); | |
| const { createNoise3D } = require('simplex-noise'); | |
| /** | |
| * Class for perlin noise extension. | |
| * @constructor | |
| */ | |
| // noise generation code from p5.js | |
| class iygPerlin { | |
| constructor(runtime) { | |
| /** | |
| * The runtime instantiating this block package. | |
| * @type {Runtime} | |
| */ | |
| this.runtime = runtime; | |
| this.noise; | |
| this.seed = 123; | |
| this.size = 50; | |
| this.generator = new MersenneTwister(this.seed); | |
| } | |
| /** | |
| * @returns {object} metadata for this extension and its blocks. | |
| */ | |
| getInfo() { | |
| return { | |
| id: 'iygPerlin', | |
| name: 'Perlin Noise', | |
| color1: '#525252', | |
| color2: '#636363', | |
| blocks: [ | |
| // Hidden | |
| { | |
| opcode: 'GetNoise', | |
| blockType: BlockType.REPORTER, | |
| text: formatMessage({ | |
| id: 'iygPerlin.GetNoise', | |
| default: 'Get perlin noise with seed [SEED] and octave [OCTAVE] at x [X], y [Y], and z [Z]', | |
| description: 'Get seeded perlin noise at a specified x and y and z.' | |
| }), | |
| arguments: { | |
| SEED: { | |
| type: ArgumentType.NUMBER, | |
| defaultValue: 123 | |
| }, | |
| OCTAVE: { | |
| type: ArgumentType.NUMBER, | |
| defaultValue: 4 | |
| }, | |
| X: { | |
| type: ArgumentType.NUMBER, | |
| defaultValue: 0 | |
| }, | |
| Y: { | |
| type: ArgumentType.NUMBER, | |
| defaultValue: 0 | |
| }, | |
| Z: { | |
| type: ArgumentType.NUMBER, | |
| defaultValue: 0 | |
| } | |
| }, | |
| hideFromPalette: true | |
| }, | |
| // Hidden | |
| { | |
| opcode: 'GetRandomNoise', | |
| blockType: BlockType.REPORTER, | |
| text: formatMessage({ | |
| id: 'iygPerlin.GetRandomNoise', | |
| default: 'Get noise with seed [SEED] at x [X], y [Y], and z [Z]', | |
| description: 'Get seeded noise with a specified seed at a specified x and y and z.' | |
| }), | |
| arguments: { | |
| SEED: { | |
| type: ArgumentType.NUMBER, | |
| defaultValue: 123 | |
| }, | |
| X: { | |
| type: ArgumentType.NUMBER, | |
| defaultValue: 0 | |
| }, | |
| Y: { | |
| type: ArgumentType.NUMBER, | |
| defaultValue: 0 | |
| }, | |
| Z: { | |
| type: ArgumentType.NUMBER, | |
| defaultValue: 0 | |
| } | |
| }, | |
| hideFromPalette: true | |
| }, | |
| // Hidden | |
| { | |
| opcode: 'GeneratePerlinNoise', | |
| blockType: BlockType.COMMAND, | |
| text: formatMessage({ | |
| id: 'iygPerlin.GeneratePerlinNoise', | |
| default: 'Pre-generate perlin noise with seed [SEED] and octave [OCTAVE]', | |
| description: 'Pre-generate seeded perlin noise.' | |
| }), | |
| arguments: { | |
| SEED: { | |
| type: ArgumentType.NUMBER, | |
| defaultValue: 123 | |
| }, | |
| OCTAVE: { | |
| type: ArgumentType.NUMBER, | |
| defaultValue: 4 | |
| } | |
| }, | |
| hideFromPalette: true | |
| }, | |
| // Hidden | |
| { | |
| opcode: 'GenerateRandomNoise', | |
| blockType: BlockType.COMMAND, | |
| hideFromPalette: true, | |
| text: formatMessage({ | |
| id: 'iygPerlin.GenerateRandomNoise', | |
| default: 'not needed [SEED] [SIZE]', | |
| description: 'Pre-generate seeded noise.' | |
| }), | |
| arguments: { | |
| SEED: { | |
| type: ArgumentType.NUMBER, | |
| defaultValue: 123 | |
| }, | |
| SIZE: { | |
| type: ArgumentType.NUMBER, | |
| defaultValue: 50 | |
| } | |
| }, | |
| }, | |
| // Hidden | |
| { | |
| opcode: 'getSimplexNoise', | |
| blockType: BlockType.REPORTER, | |
| hideFromPalette: true, | |
| text: formatMessage({ | |
| id: 'iygPerlin.getSimplexNoise', | |
| default: 'Get simplex noise with seed [SEED] at x [X], y [Y], and z [Z]', | |
| description: 'Get simplex noise with a specified seed at a specified x and y and z.' | |
| }), | |
| arguments: { | |
| SEED: { | |
| type: ArgumentType.NUMBER, | |
| defaultValue: 123 | |
| }, | |
| X: { | |
| type: ArgumentType.NUMBER, | |
| defaultValue: 0 | |
| }, | |
| Y: { | |
| type: ArgumentType.NUMBER, | |
| defaultValue: 0 | |
| }, | |
| Z: { | |
| type: ArgumentType.NUMBER, | |
| defaultValue: 0 | |
| } | |
| } | |
| }, | |
| // End of hidden stuff | |
| { | |
| opcode: 'GetNoiseV2', | |
| blockType: BlockType.REPORTER, | |
| text: formatMessage({ | |
| id: 'iygPerlin.GetNoiseV2', | |
| default: 'Get perlin noise with seed [SEED] and octave [OCTAVE] at x [X], y [Y], and z [Z]', | |
| description: 'Get seeded perlin noise at a specified x and y and z.' | |
| }), | |
| arguments: { | |
| SEED: { | |
| type: ArgumentType.NUMBER, | |
| defaultValue: 123 | |
| }, | |
| OCTAVE: { | |
| type: ArgumentType.NUMBER, | |
| defaultValue: 4 | |
| }, | |
| X: { | |
| type: ArgumentType.NUMBER, | |
| defaultValue: 0 | |
| }, | |
| Y: { | |
| type: ArgumentType.NUMBER, | |
| defaultValue: 0 | |
| }, | |
| Z: { | |
| type: ArgumentType.NUMBER, | |
| defaultValue: 0 | |
| } | |
| }, | |
| }, | |
| { | |
| opcode: 'GetRandomNoiseV2', | |
| blockType: BlockType.REPORTER, | |
| text: formatMessage({ | |
| id: 'iygPerlin.GetRandomNoiseV2', | |
| default: 'Get random noise with seed [SEED] at x [X], y [Y], and z [Z]', | |
| description: 'Get seeded random noise with a specified seed at a specified x and y and z.' | |
| }), | |
| arguments: { | |
| SEED: { | |
| type: ArgumentType.NUMBER, | |
| defaultValue: 123 | |
| }, | |
| X: { | |
| type: ArgumentType.NUMBER, | |
| defaultValue: 0 | |
| }, | |
| Y: { | |
| type: ArgumentType.NUMBER, | |
| defaultValue: 0 | |
| }, | |
| Z: { | |
| type: ArgumentType.NUMBER, | |
| defaultValue: 0 | |
| } | |
| } | |
| }, | |
| { | |
| opcode: 'GeneratePerlinNoiseV2', | |
| blockType: BlockType.COMMAND, | |
| text: formatMessage({ | |
| id: 'iygPerlin.GeneratePerlinNoiseV2', | |
| default: 'Pre-generate perlin noise with seed [SEED] and octave [OCTAVE]', | |
| description: 'Pre-generate seeded perlin noise.' | |
| }), | |
| arguments: { | |
| SEED: { | |
| type: ArgumentType.NUMBER, | |
| defaultValue: 123 | |
| }, | |
| OCTAVE: { | |
| type: ArgumentType.NUMBER, | |
| defaultValue: 4 | |
| } | |
| } | |
| }, | |
| ] | |
| }; | |
| } | |
| goodSeedRandom() { | |
| this.generator.init_seed(this.seed); | |
| let result = this.generator.random_incl(); | |
| this.seed = result * 4294967296; | |
| return result; | |
| } | |
| dumbSeedRandom() { | |
| this.generator.init_seed(this.seed); | |
| let result = this.generator.random_incl(); | |
| this.seed = (1664525*this.seed + 1013904223) % 4294967296; | |
| return result; | |
| } | |
| GeneratePerlinNoise(args, util) { | |
| args.X = 0; | |
| args.Y = 0; | |
| args.Z = 0; | |
| this.GetNoise(args, util); | |
| } | |
| GenerateRandomNoise(args, util) { | |
| let seed = args.SEED; | |
| let size = args.SIZE; | |
| if (this.noise == null || seed != this.seed) { | |
| this.noise = new Array(size); | |
| this.seed = seed; | |
| for (let i = 0; i < size; i++) { | |
| this.noise[i] = new Array(size); | |
| for (let j = 0; j < size; j++) { | |
| this.noise[i][j] = new Array(size); | |
| for (let k = 0; k < size; k++) { | |
| this.noise[i][j][k] = this.dumbSeedRandom(); | |
| } | |
| } | |
| } | |
| this.seed = seed; | |
| this.prev_seed = seed; | |
| this.size = size; | |
| } | |
| if (size > this.size && seed == this.seed) { | |
| this.seed = this.prev_seed; | |
| for (let i = this.size; i < size+1; i++) { | |
| this.noise[i] = new Array(size); | |
| for (let j = this.size; j < size+1; j++) { | |
| this.noise[i][j] = new Array(size); | |
| for (let k = this.size; k < size+1; k++) { | |
| this.noise[i][j][k] = this.dumbSeedRandom(); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| GetRandomNoise(args, util) { | |
| let seed = args.SEED; | |
| let x = args.X; | |
| let y = args.Y; | |
| let z = args.Z; | |
| let pre_seed = this.seed; | |
| this.seed = seed+x+y*1000+z*10000; | |
| let result = this.dumbSeedRandom(); | |
| this.seed = pre_seed; | |
| return result; | |
| } | |
| generatePerlin(seed, perlin_octaves, rand, x, y, z) { | |
| let perlin_amp_falloff = 0.5; | |
| const scaled_cosine = i => 0.5 * (1.0 - Math.cos(i * Math.PI)); | |
| const PERLIN_SIZE = 4095; | |
| const PERLIN_YWRAPB = 4; | |
| const PERLIN_YWRAP = 1 << PERLIN_YWRAPB; | |
| const PERLIN_ZWRAPB = 8; | |
| const PERLIN_ZWRAP = 1 << PERLIN_ZWRAPB; | |
| if (this.perlin == null || seed != this.seed) { | |
| this.perlin = new Array(PERLIN_SIZE + 1); | |
| this.seed = seed; | |
| for (let i = 0; i < PERLIN_SIZE + 1; i++) { | |
| this.perlin[i] = rand(); | |
| } | |
| this.seed = seed; | |
| } | |
| if (x < 0) { | |
| x = -x; | |
| } | |
| if (y < 0) { | |
| y = -y; | |
| } | |
| if (z < 0) { | |
| z = -z; | |
| } | |
| let xi = Math.floor(x), | |
| yi = Math.floor(y), | |
| zi = Math.floor(z); | |
| let xf = x - xi; | |
| let yf = y - yi; | |
| let zf = z - zi; | |
| let rxf, ryf; | |
| let r = 0; | |
| let ampl = 0.5; | |
| let n1, n2, n3; | |
| for (let o = 0; o < perlin_octaves; o++) { | |
| let of = xi + (yi << PERLIN_YWRAPB) + (zi << PERLIN_ZWRAPB); | |
| rxf = scaled_cosine(xf); | |
| ryf = scaled_cosine(yf); | |
| n1 = this.perlin[of & PERLIN_SIZE]; | |
| n1 += rxf * (this.perlin[(of + 1) & PERLIN_SIZE] - n1); | |
| n2 = this.perlin[(of + PERLIN_YWRAP) & PERLIN_SIZE]; | |
| n2 += rxf * (this.perlin[(of + PERLIN_YWRAP + 1) & PERLIN_SIZE] - n2); | |
| n1 += ryf * (n2 - n1); | |
| of += PERLIN_ZWRAP; | |
| n2 = this.perlin[of & PERLIN_SIZE]; | |
| n2 += rxf * (this.perlin[(of + 1) & PERLIN_SIZE] - n2); | |
| n3 = this.perlin[(of + PERLIN_YWRAP) & PERLIN_SIZE]; | |
| n3 += rxf * (this.perlin[(of + PERLIN_YWRAP + 1) & PERLIN_SIZE] - n3); | |
| n2 += ryf * (n3 - n2); | |
| n1 += scaled_cosine(zf) * (n2 - n1); | |
| r += n1 * ampl; | |
| ampl *= perlin_amp_falloff; | |
| xi <<= 1; | |
| xf *= 2; | |
| yi <<= 1; | |
| yf *= 2; | |
| zi <<= 1; | |
| zf *= 2; | |
| if (xf >= 1.0) { | |
| xi++; | |
| xf--; | |
| } | |
| if (yf >= 1.0) { | |
| yi++; | |
| yf--; | |
| } | |
| if (zf >= 1.0) { | |
| zi++; | |
| zf--; | |
| } | |
| } | |
| return r % 1.0; | |
| } | |
| GetNoise(args, util) { | |
| let seed = args.SEED; | |
| let perlin_octaves = ((args.OCTAVE === Infinity) ? 4 : args.OCTAVE); | |
| let x = args.X + .5; | |
| let y = args.Y + .5; | |
| let z = args.Z + .5; | |
| return this.generatePerlin(seed, perlin_octaves, this.dumbSeedRandom.bind(this), x, y, z); | |
| } | |
| // ----- V2 ----- | |
| GetNoiseV2(args, util) { | |
| let seed = args.SEED; | |
| let perlin_octaves = ((args.OCTAVE === Infinity) ? 4 : args.OCTAVE); | |
| let x = args.X + .5; | |
| let y = args.Y + .5; | |
| let z = args.Z + .5; | |
| return this.generatePerlin(seed, perlin_octaves, this.goodSeedRandom.bind(this), x, y, z); | |
| } | |
| // ----- V2 ----- | |
| GetRandomNoiseV2(args, util) { | |
| let seed = args.SEED; | |
| let x = args.X; | |
| let y = args.Y; | |
| let z = args.Z; | |
| let pre_seed = this.seed; | |
| this.seed = seed + (x * 743) + (y * 942 ) + (z * 645); | |
| let result = this.goodSeedRandom.bind(this)(); | |
| this.seed = pre_seed; | |
| return result; | |
| } | |
| // ----- V2 ----- | |
| GeneratePerlinNoiseV2(args, util) { | |
| args.X = 0; | |
| args.Y = 0; | |
| args.Z = 0; | |
| this.GetNoiseV2(args, util); | |
| } | |
| getSimplexNoise(args) { | |
| const seed = args.SEED; | |
| const x = args.X; | |
| const y = args.Y; | |
| const z = args.Z; | |
| this.generator.init_seed(seed); | |
| const noise = createNoise3D(this.generator.random_incl.bind(this.generator)); | |
| return noise(x, y, z); | |
| } | |
| } | |
| module.exports = iygPerlin; | |