Home

Welcome to the More Density Functions Wiki!

This mod adds in several unique density function types that lets you accomplish more than the vanilla Density Function types allow you to do.

The namespace used for all of these is moredfs, and will be referenced repeatedly in the following examples.

Notice:

This wiki is written to the best of my ability/understanding. You can check the source code to verify everything (on their respective branches). The names of the density function types are defined in main-entry point for their respective versions (e.g. MoreDensityFunctionsFabric). The density function's logic is defined in their respective class files in the densityfunctions package in common. If you find any correctness issues in either the code or wiki, make an issue report please!

Wiki Status: 2.2.1

Arc Cosine
Arc Sine
Arc Tangent
Cube Root
Ceil
Clamp
Cosine
Derivative
Distance
Divide
Dot Product
Floor
Floor Divide
Floor Modulo
Gapped Grid Square Spiral
Gradient Magnitude
Hyperbolic Cosine
Hyperbolic Sine
Hyperbolic Tangent
IEEE Remainder
Log
Log2
Log2 Floor
Modulo
Natural Log
Negate
Or Else
Polar Coordinates
Power
Profiler
Radius
Radius 3D
Reciprocal
Remainder
Resolver
Round
Shift
Sigmoid
Signum
Sine
Single Channel Image Tessellation
Square Root
Subtract
Tangent
Value Noise
Vector Angle
X-Coord
X Clamped Gradient
Y-Coord
Z-Coord
Z Clamped Gradient

Random Samplers:

Beta
Binomial
Exponential
Gamma
Geometric
Normal
Poisson
Uniform

Distance Metrics:

Chebyshev
Euclidean
Manhattan
Minkowski

Density Function Types

Coordinate Functions

Functions that directly output coordinate values or create gradients along coordinate axes.

X-Coord

Inputs:

N/A

Output:
The exact x-coordinate at that position in the world

Example:

{
  "type": "moredfs:x"
}

Y-Coord

Inputs:

N/A

Output:
The exact y-coordinate at that position in the world

Example:

{
  "type": "moredfs:y"
}

Note that this can be done using the vanilla "minecraft:y" density function, but this is just a y_clamped_gradient. I would assume this is faster.

Z-Coord

Inputs:

N/A

Output:
The exact z-coordinate at that position in the world

Example:

{
  "type": "moredfs:z"
}

X Clamped Gradient

Inputs:

from_x: Integer in the range [-30,000,000, 30,000,000]
to_x: Integer in the range [-30,000,000, 30,000,000]
from_value: Double in the range [-10,000,000, 10,000,000]
to_value: Double in the range [-10,000,000, 10,000,000]

Output:
Creates a gradient along the x-axis, identically to the y_clamped_gradient vanilla Density Function

Example:

{
  "type": "moredfs:x_clamped_gradient",
  "from_x": -1024,
  "to_x": 1024,
  "from_value": -1,
  "to_value": 1
}

Z Clamped Gradient

Inputs:

from_z: Integer in the range [-30,000,000, 30,000,000]
to_z: Integer in the range [-30,000,000, 30,000,000]
from_value: Double in the range [-10,000,000, 10,000,000]
to_value: Double in the range [-10,000,000, 10,000,000]

Output:
Creates a gradient along the z-axis, identically to the y_clamped_gradient vanilla DensityFunction

Example:

{
  "type": "moredfs:z_clamped_gradient",
  "from_z": -1024,
  "to_z": 1024,
  "from_value": -1,
  "to_value": 1
}

Polar Coordinates

Inputs:

N/A

Output:
Computes the angle (in radians) of the current (x, z) block position relative to the origin (0, 0) through atan2(x, z)

Example:

{
  "type": "moredfs:polar_coords"
}

Radius

Inputs:

N/A

Output:
The euclidean distance of the current (x, z) block position relative to the origin (0, 0).

Example:

{
  "type": "moredfs:radius"
}

Radius 3D

Inputs:

N/A

Output:
The euclidean distance of the current (x, y, z) block position relative to the origin (0, 0, 0).

Example:

{
  "type": "moredfs:radius_3d"
}

Distance

Inputs:

distance_metric: DistanceMetric
point1: Optional List of DensityFunctions*
point2: Optional List of DensityFunctions*

Output:
The distance, based on the distance_metric, between the n-dimensional point sampled as point1 and the n-dimensional point sampled as point2.

*Note: point1 and point2 are conditionally optional and also must match lengths (e.g. if you have one term in point1, you cannot have more than one term in point2, but you can have an empty or missing point2, and this would autocomplete as an n-dimensional origin [0], in this case, or [0, 0, 0, 0] in the case that point1 has 4 terms. This applies to point1 and point2 (order doesn't matter).

Example (recreation of moredfs:radius):

{
  "type": "moredfs:distance",
  "distance_metric": {
    "type": "euclidean"
  }
  "points1": [{"type": "moredfs:x"}, {"type": "moredfs:z"}]
}

Trigonometric Functions

Functions that perform trigonometric operations (sine, cosine, tangent) and their inverse operations.

Arc Cosine

Inputs:

argument: DensityFunction

Output:
All values output are the input with the arc cosine function applied to them (returns radians). Note that non-finite double values (e.g. NaN, ∞, -∞) can be returned by this function, and these cases can be handled by Or Else.

Example:

{
  "type": "moredfs:acos",
  "argument": "minecraft:overworld/erosion"
}

Arc Sine

Inputs:

argument: DensityFunction

Output:
All values output are the input with the arc sine function applied to them (returns radians). Note that non-finite double values (e.g. NaN, ∞, -∞) can be returned by this function, and these cases can be handled by Or Else.

Example:

{
  "type": "moredfs:asin",
  "argument": "minecraft:overworld/erosion"
}

Arc Tangent

Inputs:

argument: DensityFunction

Output:
All values output are the input with the arc tangent function applied to them (returns radians).

Example:

{
  "type": "moredfs:atan",
  "argument": "minecraft:overworld/erosion"
}

Hyperbolic Cosine

Inputs:

argument: DensityFunction

Output:
All values output are the input with the hyperbolic cosine function applied to them (returns radians).

Example:

{
  "type": "moredfs:cosh",
  "argument": "minecraft:overworld/erosion"
}

Hyperbolic Sine

Inputs:

argument: DensityFunction

Output:
All values output are the input with the hyperbolic sine function applied to them (returns radians).

Example:

{
  "type": "moredfs:sinh",
  "argument": "minecraft:overworld/erosion"
}

Hyperbolic Tangent

Inputs:

argument: DensityFunction

Output:
All values output are the input with the hyperbolic tangent function applied to them (returns radians).

Example:

{
  "type": "moredfs:tanh",
  "argument": "minecraft:overworld/erosion"
}

Cosine

Inputs:

argument: DensityFunction

Output:
All values output are the input with the cosine function applied to them (in radians)

Example:

{
  "type": "moredfs:cos",
  "argument": "minecraft:overworld/erosion"
}

Sine

Inputs:

argument: DensityFunction

Output:
All values output are the input with the sine function applied to them (in radians)

Example:

{
  "type": "moredfs:sin",
  "argument": "minecraft:overworld/erosion"
}

Tangent

Inputs:

argument: DensityFunction

Output:
All values output are the input with the tangent function applied to them (in radians). Although in theory, tan has an infinite number of vertical asymptotes, I do not believe that it is capable of returning non-finite double values (e.g. NaN, ∞, -∞), but if you are worried about that, you can either use Or Else to handle such cases.

Example:

{
  "type": "moredfs:tan",
  "argument": "minecraft:overworld/erosion"
}

Vector Angle

Inputs:

argument1: DensityFunction
argument2: DensityFunction

Output:
Given the coordinate system, argument1, and argument2, the output is the angle (in radians) between the position formed by (argument1, argument2) relative to the origin (0, 0) through atan2(argument1, argument2).

Example:

{
  "type": "moredfs:vector_angle",
  "argument1": 0.707,
  "argument2": "minecraft:overworld/erosion"
}

Arithmetic Operations

Functions that perform basic mathematical operations like addition, subtraction, multiplication, and division.

Cube Root

Inputs:

argument: DensityFunction

Output:
All values output are the input with the Cube Root function applied to them

Example:

{
  "type": "moredfs:cbrt",
  "argument": "minecraft:overworld/erosion"
}

Divide

Inputs:

numerator: DensityFunction
denominator: DensityFunction

Output:
Output is the numerator field divided by the denominator field. Note that non-finite double values (e.g. NaN, ∞, -∞) can be returned by this function, and these cases can be handled by Or Else.

Example:

{
  "type": "moredfs:div",
  "numerator": "minecraft:overworld/erosion",
  "denominator": "minecraft:overworld/continents"
}

Floor Divide

Inputs:

numerator: DensityFunction
denominator: DensityFunction

Output:
Output is the numerator field divided by the denominator field with flooring applied. Note that non-finite double values (e.g. NaN, ∞, -∞) can be returned by this function, and these cases can be handled by Or Else.

Example:

{
  "type": "moredfs:floor_div",
  "numerator": "minecraft:overworld/erosion",
  "denominator": "minecraft:overworld/continents"
}

Modulo

Inputs:

numerator: DensityFunction
denominator: DensityFunction

Output:
Output is the modulo of the numerator field divided by the denominator field. Note that non-finite double values (e.g. NaN, ∞, -∞) can be returned by this function, and these cases can be handled by Or Else.

Example:

{
  "type": "moredfs:mod",
  "numerator": {
    "type": "moredfs:x"
  },
  "denominator": 16
}

Floor Modulo

Inputs:

numerator: DensityFunction
denominator: DensityFunction

Output:
Output is the floor'd modulo of the numerator field divided by the denominator field. Note that non-finite double values (e.g. NaN, ∞, -∞) can be returned by this function, and these cases can be handled by Or Else.

Example:

{
  "type": "moredfs:floor_mod",
  "numerator": {
    "type": "moredfs:x"
  },
  "denominator": 16
}

IEEE Remainder

Inputs:

numerator: DensityFunction
denominator: DensityFunction

Output:
Output is the IEEE remainder of the numerator field divided by the denominator field. Note that non-finite double values (e.g. NaN, ∞, -∞) can be returned by this function, and these cases can be handled by Or Else.

Example:

{
  "type": "moredfs:ieee_rem",
  "numerator": "minecraft:overworld/erosion",
  "denominator": 2.0
}

Remainder

Inputs:

numerator: DensityFunction
denominator: DensityFunction

Output:
Output is the remainder of the numerator field divided by the denominator field. Note that non-finite double values (e.g. NaN, ∞, -∞) can be returned by this function, and these cases can be handled by Or Else.

Example:

{
  "type": "moredfs:rem",
  "numerator": "minecraft:overworld/erosion",
  "denominator": 3.14159
}

Negate

Inputs:

argument: DensityFunction

Output:
All values output are the input multiplied by -1.

Example:

{
  "type": "moredfs:negate",
  "argument": "minecraft:overworld/erosion"
}

Note that this can be done using the vanilla using a "minecraft:mul" with -1 as a argument1/2, but is less verbose.

Power

Inputs:

base: DensityFunction
exponent: DensityFunction

Output:
Output is the base field raised to the power of the exponent field. Note that non-finite double values (e.g. NaN, ∞, -∞) can be returned by this function, and these cases can be handled by Or Else.

Example:

{
  "type": "moredfs:power",
  "base": "minecraft:overworld/erosion",
  "exponent": 10
}

Reciprocal

Inputs:

denominator: DensityFunction

Output:
Output is the inverse of the denominator field (E.g. 2 -> 0.5). Note that non-finite double values (e.g. NaN, ∞, -∞) can be returned by this function, and these cases can be handled by Or Else.

Example:

{
  "type": "moredfs:reciprocal",
  "denominator": "minecraft:overworld/erosion"
}

Remainder

Inputs:

numerator: DensityFunction
denominator: DensityFunction

Output:
Output is the remainder of the numerator field divided by the denominator field. Note that non-finite double values (e.g. NaN, ∞, -∞) can be returned by this function, and these cases can be handled by Or Else.

Example:

{
  "type": "moredfs:rem",
  "numerator": "minecraft:overworld/erosion",
  "denominator": 3.14159
}

Square Root

Inputs:

argument: DensityFunction

Output:
All values output are the input with the Square Root function applied to them. Note that non-finite double values (e.g. NaN, ∞, -∞) can be returned by this function, and these cases can be handled by Or Else.

Example:

{
  "type": "moredfs:sqrt",
  "argument": "minecraft:overworld/erosion"
}

Subtract

Inputs:

argument1: DensityFunction
argument2: DensityFunction

Output:
Output is equal to argument1 - argument2

Example:

{
  "type": "moredfs:subtract",
  "argument1": "minecraft:overworld/erosion",
  "argument2": 0.25
}

Note that this can be done using the vanilla using a "minecraft:mul" with -1 as an input, and a "minecraft:add", but is less verbose.

Logarithmic Functions

Functions that perform logarithmic operations with various bases.

Log

Inputs:

argument: DensityFunction
base: DensityFunction

Output:
All values output are the logarithm of the argument in the specified base. Note that non-finite double values (e.g. NaN, ∞, -∞) can be returned by this function, and these cases can be handled by Or Else.

Example:

{
  "type": "moredfs:log",
  "argument": "minecraft:overworld/erosion",
  "base": 10.0
}

Log2

Inputs:

argument: DensityFunction

Output:
All values output are the base-2 logarithm of the input. Note that non-finite double values (e.g. NaN, ∞, -∞) can be returned by this function, and these cases can be handled by Or Else.

Example:

{
  "type": "moredfs:log2",
  "argument": "minecraft:overworld/erosion"
}

Log2 Floor

Inputs:

argument: DensityFunction

Output:
All values output are the floor of the base-2 logarithm of the input using a bit manipulation algorithm for speed. Note that non-finite double values (e.g. NaN, ∞, -∞) can be returned by this function, and these cases can be handled by Or Else.

Example:

{
  "type": "moredfs:log2_floor",
  "argument": "minecraft:overworld/erosion"
}

Natural Log

Inputs:

argument: DensityFunction

Output:
All values output are the natural logarithm of the input. Note that non-finite double values (e.g. NaN, ∞, -∞) can be returned by this function, and these cases can be handled by Or Else.

Example:

{
  "type": "moredfs:ln",
  "argument": "minecraft:overworld/erosion"
}

Rounding and Clamping Functions

Functions that modify values by rounding, clamping, or applying step functions.

Ceil

Inputs:

argument: DensityFunction

Output:
All values output are rounded-up to the nearest integer value

Example:

{
  "type": "moredfs:ceil",
  "argument": "minecraft:overworld/erosion"
}

Clamp

Inputs:

argument: DensityFunction
min: Double
max: Double

Output:
All values output are clamped between the min and max values

Example:

{
  "type": "moredfs:clamp",
  "argument": "minecraft:overworld/erosion",
  "min": -1.0,
  "max": 1.0
}

Floor

Inputs:

argument: DensityFunction

Output:
All values output are rounded-down to the nearest integer value

Example:

{
  "type": "moredfs:floor",
  "argument": "minecraft:overworld/erosion"
}

Round

Inputs:

argument: DensityFunction

Output:
All values output are rounded to the nearest integer value

Example:

{
  "type": "moredfs:round",
  "argument": "minecraft:overworld/erosion"
}

Sigmoid

Inputs:

argument: DensityFunction

Output:
All values output are the input with the sigmoid function applied, creating an S-shaped curve

Example:

{
  "type": "moredfs:sigmoid",
  "argument": "minecraft:overworld/erosion"
}

Signum

Inputs:

argument: DensityFunction

Output:
All values output are the input with the Signum function applied (x<0 -> -1, x=0 -> 0, x>0 -> 1).

Example:

{
  "type": "moredfs:signum",
  "argument": "minecraft:overworld/continents"
}

Calculus and Derivative Functions

Functions that perform calculus operations like derivatives and gradient calculations.

Derivative

Inputs:

argument: DensityFunction
component_x: An Optional DerivativeComponent*
- step: Integer >0
- direction: DensityFunction
component_y: An Optional DerivativeComponent*
- step: Integer >0
- direction: DensityFunction
component_z: An Optional DerivativeComponent*
- step: Integer >0
- direction: DensityFunction

*Note: Although they are all Optional, at least one must be defined.

Output:
The directional derivative of the input function in the specified direction

Example:

{
  "type": "moredfs:derivative",
  "argument": "minecraft:overworld/erosion",
  "component_x": {
    "step": 128,
    "direction": "minecraft:overworld/continents"
  }
}

Gradient Magnitude

Inputs:

argument: DensityFunction
step_x: An Optional Integer >0*
step_y: An Optional Integer >0*
step_z: An Optional Integer >0*

*Note: Although they are all Optional, at least one must be defined.

Output:
The magnitude of the gradient vector formed by the three input components

Example:

{
  "type": "moredfs:gradient_magnitude",
  "argument": "minecraft:overworld/erosion",
  "step_x": 10
}

Dot Product

Inputs:

argument1: DensityFunction
argument2: DensityFunction
step_x: An Optional Integer >0*
step_y: An Optional Integer >0*
step_z: An Optional Integer >0*

*Note: Although they are all Optional, at least one must be defined.

Output:
The dot product formed by argument1 and argument2 based on the direction defined by step_x, step_y, and step_z

Example:

{
  "type": "moredfs:dot_product",
  "argument1": "minecraft:overworld/erosion",
  "argument2": "minecraft:overworld/continents",
  "step_x": 10
}

Spatial Transformation Functions

Functions that modify the spatial evaluation of other density functions.

Shift

Inputs:

argument: DensityFunction
shift_x: DensityFunction
shift_y: DensityFunction
shift_z: DensityFunction

Output:
Output is the output of the argument density function at the new shifted position, which is the current position shifted shift_x blocks in the x-axis, shifted shift_y blocks in the y-axis, and shifted shift_z blocks in the z-axis

Example:

{
  "type": "moredfs:shift",
  "input": "minecraft:overworld/erosion",
  "shift_x": "minecraft:overworld/continents",
  "shift_y": 0,
  "shift_z": 100
}

Noise Generation Functions

Functions that generate various types of noise for procedural generation.

Value Noise

Inputs:

sampler: RandomSampler(add annotation me)
size_x: Integer >=0
size_y: Integer >=0
size_z: Integer >=0
interpolation: String of either "none", "lerp", or "smoothstep"
salt: An Optional Integer, defaults to = 0
extra_octaves: An Optional ExtraOctaves, defaults to ExtraOctaves{count: 0, ..}
- count: Integer >=0
- lacunarity: Double
- persistence: Double

Output:
Output is value noise generated at the current position according to the input parameters.

sampler

The sampler field is the primary source of randomness for the value_noise, it is the value sampled from at the given position in the grid cell defined by the size fields. There are many different types of RandomSampler that can be used for the source of RNG, and I will not go into detail here about them though... visit Random Samplers for more details.

size_x, size_y, size_z

The size_x, size_y, size_z fields determine the scale noise cells of the value_noise, in blocks. For example, using size_x = size_y = size_z = 16 will result in noise where the values are rolled at every 16 blocks on a grid. Using size_c = 0 results in that coordinate not being used for the noise calculation (more precisely, sampling only at 0 for that coordinate).

interpolation

The interpolation field determines the blending used between noise cells for the value_noise. "none" results in literally just using that noise value for the entire cell size. E.g. using size_x = size_y = size_z = 16 will result in 16x16x16 cubes of noise throughout the world, with values determined by the sampler.

salt

The salt field is used to further increment the RNG seed for value_noise. The guarantee I am giving you with salt is that changing it even by 1 will result in a completely new RNG seed (with very little correlation) used for that value_noise instance, even if all the other Inputs are identical. You will typically not need to use this except in one of the following scenarios: say you wanted to use a value_noise for a biome parameter, and then you liked that distribution and scale so much, that you wanted to use it for another biome parameter. If you leave the salt at the default, 0, for both values, you would find out you have identical noise for both Inputs, which is not ideal. The way vanilla gets around this with their implementation of noise is by 1. requiring noises to be defined in their own, separate file, which means that every noise will 2. have a file name that is used for the hashing of the RNG seed. Effectively, their salt field, is the noise.json file name. That is why we need salt.

extra_octaves

The extra_octaves field is an incredibly useful shortcut to adding variation/complexity to the value_noise. If you unfamiliar with noise terms like extra_octaves, lacunarity, and persistence, don't worry, they are actually pretty simple! All they do is add additional layers of the same noise on top of itself. I think it is easiest to show this with an example.

Say we have the following value_noise implementation:

{
  "type": "moredfs:value_noise",
  "sampler": {
    "type": "moredfs:normal",
    "mean": 0,
    "std_dev": 0.125
  },
  "size_x": 128,
  "size_y": 0,
  "size_z": 128,
  "interpolation": "smoothstep"
}

Awesome, in a few lines, we have created a decently large-scale 2D value_noise density function based on sampling a normal distribution. With the smoothstep interpolation, this will look pretty cool already. But, it might ironically be too smooth for most purposes (say, wanting more jagged terrain). So, how can we fix this?

Well, if we used a smaller scale for the noise (size_x = size_z = 32) that would certainly make it more jagged, but... it would make it jagged and drastic, everywhere and we wouldn't have large-scale transitions in terrain height, only rapid changes.

Ah, I see! Okay here's how we can do it! We can just add the small scale value_noise to the normal scaled value_noise. But we have to be careful. If we give the smaller scaled value_noise the same influence as the larger noise, we will be stuck with those rapid height changes still. We can tune down the influence of the smaller noise by multiplying it by a small value (in this case, 0.5). If you know anything about minecraft's noise, this is actually how the amplitudes fields work, except in a bit of a weird and different way.

For us though, if we want to do this without extra_octaves, we'd have to do this:

{
  "type": "minecraft:add",
  "argument1": {
    "type": "moredfs:value_noise",
    "sampler": {
      "type": "moredfs:normal",
      "mean": 0,
      "std_dev": 0.125
    },
    "size_x": 128,
    "size_y": 0,
    "size_z": 128,
    "interpolation": "smoothstep"
  },
  "argument2": {
    "type": "minecraft:mul",
    "argument1": 0.5,
    "argument2": {
      "type": "moredfs:value_noise",
      "sampler": {
        "type": "moredfs:normal",
        "mean": 0,
        "std_dev": 0.125
      },
      "size_x": 32,
      "size_y": 0,
      "size_z": 32,
      "interpolation": "smoothstep"
    }
  }
}

But we can add even more variance by doing this again, with another identical noise, at a smaller scale, and multiplied by an even smaller value (e.g. size_x/y/z = 8 and mul by 0.25).

Adding and making all of these noises though is tedious, and we clearly have a pattern going on here! We decided to scale down our size by 4 and our influence by 0.5 each time. That's where extra_octaves comes in!

We can simply the example above by doing:

{
  "type": "moredfs:value_noise",
  "sampler": {
    "type": "moredfs:normal",
    "mean": 0,
    "std_dev": 0.125
  },
  "size_x": 128,
  "size_y": 0,
  "size_z": 128,
  "interpolation": "smoothstep",
  "extra_octaves": {
    "count": 1,
    "lacunarity": 4,
    "persistence": 0.5
  }
}

And if we just change count to 2, we can add another layer at the Inputs we mentioned (size_x/y/z = 8 and mul by 0.25). Changing count to 0 is allowed as an easy way to toggle off extra_octaves for dev testing, without having to delete the extra_octaves field constantly...

Example:

{
  "type": "moredfs:value_noise",
  "sampler": {
    "type": "moredfs:uniform",
    "min": 0.2,
    "max": 1.0
  },
  "size_x": 100,
  "size_y": 2,
  "size_z": 100,
  "interpolation": "lerp",
  "extra_octaves": {
    "count": 3,
    "lacunarity": 2,
    "persistence": 0.66
  }
}

Utility Functions

Functions that provide utility features like performance, profiling, and invalid value handling.

Or Else

Inputs:

argument: DensityFunction
fallback: DensityFunction

Output:
The value of argument at that position, unless the value is a non-finite double values (e.g. NaN, ∞, -∞), then the value of fallback is returned at that position.

Example:

{
  "type": "moredfs:or_else",
  "argument": {
    "type": "moredfs:div",
    "numerator": "minecraft:overworld/erosion",
    "denominator": "minecraft:overworld/continents"
  },
  "fallback": 0
}

Resolver

Inputs:

argument: DensityFunction

Output:
The value of argument at that position. Internally, this memoizes the mapAll call for the DensityFunction, and also calls unwrap on all the HolderHolders, resulting in reduced-sized DensityFunction trees. I've tested and seen mariginal to decent performance improvements when using, depending on the context.

Example:

{
  "type": "moredfs:resolver",
  "argument": "minecraft:overworld/erosion"
}

Profiler

Inputs:

argument: DensityFunction
warm_up: Integer >=0
iterations: Integer >=0

Output:
Whenever this density function is first encountered, a message is printed to the console, signifying the start of the profile of argument. Then, it enters two loops: the warm-up and profiling loop. The warm-up loop evaluates argument warm_up times. This is meant to be used to activate the JIT compiler for argument. After that, System.gc() is called in an attempt to keep performance stable for the upcoming profiling loop. Then the profiling loop evaluates argument iterations times. After this, the results of the profile are printed to the console: the average operation time of argument during the warm-up loop and the profiling loop, and the total time of the profile.

Example:

{
  "type": "moredfs:profiler",
  "argument": "minecraft:overworld/erosion",
  "warm_up": 50000,
  "iterations": 10000000
}

Misc. Functions

Functions that... I have no words for.

Gapped Grid Square Spiral

Inputs:

x_size: Integer >0
z_size: Integer >0
spacing: Integer >0
grid_cell_args: List of DensityFunctions
out_of_bounds_argument: DensityFunction

Output:
Square Spiral: A spiral that covers all the coordinates in a plane by iterating in a square pattern starting at the origin

Sequence: (0, 0), (1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0), (-1, -1), (0, -1), (1, -1), (2, -1)... Grid: Meaning, each coordinate is actually a grid cell of the dimensions x_size by z_size blocks Gapped: Meaning, leaving spacing cells of space in between cells on the spiral
Sequence, spacing = 2: (0, 0), (2, 0), (2, 2), (0, 2), (-2, 2), (-2, 0), (-2, -2), (0, -2), (2, -2), (4, -2)...

The function produces a Gapped Grid Square Spiral as we have defined with the first n grid cells in the spiral being the result of grid_cell_args[n] (where n is the length of grid_cell_args)

If you are in a gap (produced by spacing) or there are no more grid_cell_args left, out_of_bounds_argument is output instead.

The following example does the following...

For the first grid cell in the spiral (x = [0, 511], z = [0, 511]), the function outputs 1
For the second grid cell in the spiral (x = [1024, 1535], z = [0, 511]; keep in mind spacing = 2), the function outputs minecraft:overworld/erosion
For the third grid cell in the spiral (x = [1024, 1535], x = [1024, 1535]; keep in mind spacing = 2), the function outputs

{
  "type": "minecraft:temperature",
  "xz_scale": 0.25,
  "y_scale": 0
}

Every other position results in -1

Example:

{
  "type": "moredfs:gapped_grid_square_spiral",
  "x_size": 512,
  "z_size": 512,
  "spacing": 2,
  "grid_cell_args": [1, "minecraft:overworld/erosion", {"type": "minecraft:temperature", "xz_scale": 0.25, "y_scale": 0}]
  "out_of_bounds_argument": -1
}

Single Channel Image Tessellation (SCIT)

Inputs:

x_size: Integer >0
z_size: Integer >0
deflated_frame_data: String (Base64 Encoded)

Output:
Single Channel Image: Meaning, an image that only has one byte of information associated with each pixel's color (typically black and white image) Tessellation: An infinite tiling across the entire world Deflated: Meaning compressed, specifically using the same compression algorithm as zlib Base64 Encoded String: Meaning, a conversion from byte[] to a String using Base64 encoding

The function takes the deflated base64 String encoded frame data, decodes it into a byte[], and inflates the byte[] into the original single channel image's flattened byte[].

It then indexes the byte[] as if it were an x_size by z_size image using the x and z block position coordinates as the input with StrictMath.floorMod() applied to each, resulting in the appropriate byte as a double value being output at the corresponding position that would be seen in the original single channel image, assuming that x_size and z_size are the same dimensions as the image.

The example is the 767th frame of the Bad Apple!! music video, at 360p, with a border added and a signed distance field applied after.

**Example:**

{
  "type": "moredfs:single_channel_image_tessellation",
  "x_size": 544,
  "z_size": 424,
  "deflated_frame_data": "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"
}

Random Sampler Types

These produce randomly sampled values based on their type, and designed to be used in implementations of NoiseDensityFunctions, such as value_noise's sampler field. Most of them internally use smart optimizations, but there is definitely significant performance variance with them, depending on their inputs. If you have any suggestions, file an issue report (or make a PR if you are really dedicated :P)

Beta

Inputs:

alpha: Double >0
beta: Double >0

Output:
Produces sampled values from a Beta Distribution

Example:

{
  "type": "beta",
  "alpha": 1.0,
  "beta": 0.2
}

Binomial

Inputs:

trials: Integer in the range [0, 1,000,000]
probability: Double in the range [0.0, 1.0]

Output:
Produces sampled values from a Binomial Distribution

Example:

{
  "type": "binomial",
  "trials": 20,
  "probability": 0.1
}

Exponential

Inputs:

lambda: Double >0

Output:
Produces sampled values from an Exponential Distribution

Example:

{
  "type": "exponential",
  "lambda": 0.33
}

Gamma

Inputs:

shape: Double >0
scale: Double

Output:
Produces sampled values from a Gamma Distribution

Example:

{
  "type": "gamma",
  "shape": 0.5
  "scale": 0.1
}

Geometric

Inputs:

probability: Double on the range (0.0, 1.0]

Output:
Produces sampled values from a Geometric Distribution

Example:

{
  "type": "geometric",
  "probability": 0.2
}

Normal

Inputs:

mean: Double
std_dev: Double >0

Output:
Produces sampled values from a Normal Distribution

Example:

{
  "type": "normal",
  "mean": 0.5,
  "std_dev": 0.125
}

Poisson

Inputs:

lambda: Double >0

Output:
Produces sampled values from a Poisson Distribution

Example:

{
  "type": "poisson",
  "lambda": 1.1
}

Uniform

Inputs:

min: Double
max: Double >=min

Output:
Produces sampled values from a Uniform Distribution

Example:

{
  "type": "uniform",
  "min": 0.25,
  "max": 0.75
}

Distance Metric Types

These allow for the computation of distances between n-dimensional points based on the type used, and designed to be used for moredfs:distance density function, and likely moredfs:worley_noise when that gets added... One notable optimization is that the linear type is automatically delegated whenever a 1-dimensional distance is sought (at least by moredfs:distance) and minkowski automatically delegates to manhattan when p = 0 is used, and euclidean when p = 1 is used.

Chebyshev

Inputs:

N/A

Output:
Calculates the Chebyshev distance between points

Example:

{
  "type": "chebyshev"
}

Euclidean

Inputs:

N/A

Output:
Calculates the Euclidean distance between points

Example:

{
  "type": "euclidean"
}

Manhattan

Inputs:

N/A

Output:
Calculates the Manhattan distance between points

Example:

{
  "type": "manhattan"
}

Minkowski

Inputs:

p Integer

Output:
Calculates the Minkowski distance between points

Example:

{
  "type": "minkowski",
  "p": 3
}

Back to Top

↑ Return to Table of Contents