MapGen.PastCalcNoiseValue                            *MapGen.PastCalcNoiseValue*

    Type: ~
        


MapGen                                                                  *MapGen*

    Fields: ~
        {layersByName}             (table<string,MapGen.Layer>)
        {layersList}               (MapGen.Layer[])
        {staticsByName}            (table<string,MapGen.StaticLayer>)
        {staticsList}              (MapGen.StaticLayer[])
        {layersNoisesInitialized}  (boolean)                           Is the fractal noise of the layer initialized? This is necessary for a one-time noise initialization.
        {cavernsNoiseInitialized}  (boolean)                           Is the fractal noise of the caverns initialized? This is necessary for a one-time noise initialization.
        {isRunning}                (boolean)                           A static field that guarantees that only one instance of the `MapGen` class will work.
        {nodeIDs}                  (table<string,number>)


MapGenDef                                                            *MapGenDef*
    Definition table for the `MapGen`.

    **Only for EmmyLua.**

    Fields: ~
        {nodes}  (table<string,string>)


MapGen:new({def})                                                   *MapGen:new*

    Parameters: ~
        {def}  (MapGenDef)

    Returns: ~
        (MapGen)


MapGen:getLayerByHeight({yPos})                        *MapGen:getLayerByHeight*
    Determines which layer a node belongs to based on its height coordinate.

    Parameters: ~
        {yPos}  (number)  @return      MapGen.Layer?


MapGen:getStaticByHeight({yPos})                      *MapGen:getStaticByHeight*
    Determines which statics layer a node belongs to based on its height coordinate.

    Parameters: ~
        {yPos}  (number)  @return      MapGen.StaticLayer?


MapGen:registerLayer({name}, {def})                       *MapGen:registerLayer*
    Mark the world area between two heights as a `MapGen.Layer`.

    Note: layers must not overlap.

    Parameters: ~
        {name}  (string)           The name that will be assigned to the layer. The name must be unique for each layer.
        {def}   (MapGen.LayerDef)  Layer description table, see details `MapGen.LayerDef`.


                                                *MapGen:registerLayerNoiseColor*
MapGen:registerLayerNoiseColor({layerName}, {category}, {color}, {noiseParams})
    Register the color and the noise parameters that correspond to it.

    Parameters: ~
        {layerName}    (string)                 The name of the layer for which the color will be registered.
        {category}     (MapGen.Layer.Category)  Category indicating what will be generated by noise.
        {color}        (ColorString)            Noise color. Must be unique.
        {noiseParams}  (NoiseParams)            Fractal noise parameters.


                                                    *MapGen:registerStaticLayer*
MapGen:registerStaticLayer({name}, {def})
    Mark the world area between two heights as a `MapGen.StaticLayer`.

    Note: layers must not overlap.

    Parameters: ~
        {name}  (string)                 The name that will be assigned to the static layer. The name must be unique for each layer.
        {def}   (MapGen.StaticLayerDef)  Static layer description table, see details `MapGen.StaticLayerDef`.


                                                           *MapGen:registerPeak*
MapGen:registerPeak({layerName}, {category}, {def})
    Mark a world point as `MapGen.Peak` and assign it a specific color that will affect the generation.

    Note: The peaks shouldn't overlap. This won't cause any errors, but it might ruin the generation.

    Parameters: ~
        {layerName}  (string)                 The name of the layer in which the new peak will be included.
        {category}   (MapGen.Layer.Category)  Category indicating what will be generated by peak.
        {def}        (MapGen.PeakDef)         Peak description table, see details `MapGen.PeakDef`.


                                                         *MapGen:register2DPeak*
MapGen:register2DPeak({layerName}, {category}, {def})
    Mark a world point as `MapGen.Peak` and assign it a specific color that will affect the generation.
    The Y coordinate will be forced to zero, and the `is2d` group will be added to the groups field.

    Note: The peaks shouldn't overlap. This won't cause any errors, but it might ruin the generation.

    Parameters: ~
        {layerName}  (string)                 The name of the layer in which the new peak will be included.
        {category}   (MapGen.Layer.Category)  Category indicating what will be generated by peak.
        {def}        (MapGen.PeakDef)         Peak description table, see details `MapGen.PeakDef`.


                                                        *MapGen:register2DPeaks*
MapGen:register2DPeaks({layerName}, {category}, {defs})
    Mark the world points as `MapGen.Peak` and assign them all a specific noise that will affect generation.
    The Y coordinate will be forced to zero, and the `is2d` group will be added to the groups field.

    Note: The peaks shouldn't overlap. This won't cause any errors, but it might ruin the generation.

    Parameters: ~
        {layerName}  (string)                 The name of the layer in which the new peaks will be included.
        {category}   (MapGen.Layer.Category)  Category indicating what will be generated by peaks.
        {defs}       (MapGen.PeakDef[])       Peaks description table, see details `MapGen.PeakDef`.


                                                *MapGen:register2DPeaksFromFile*
MapGen:register2DPeaksFromFile({layerName}, {map}, {scale}, {zeroPos}, {category}, {groups?})
    Extract the `MapGen.Peak` from the image and assign them all a specific color that will affect the generation.

    Parameters: ~
        {layerName}  (string)                 The name of the layer in which the new peaks will be included.
        {map}        (string)                 The name of the image from which the peaks will be extracted. It should be located in the `<mod_name>/textures/maps` folder and have the following format `<image_name>.ff`
        {scale}      (number)                 Multiplier of how many blocks (nodes) will be between image pixels. It is not recommended to set the value below 50 for performance reasons.
        {zeroPos}    (Position2d)             The position in pixels where the zero world coordinate will be in the image.
        {category}   (MapGen.Layer.Category)  Category indicating what will be generated by peaks.
        {groups?}    (table<string,number>)   Groups that will be added to all peaks.


                                                          *MapGen:registerBiome*
MapGen:registerBiome({layerName}, {biomeName}, {def})
    Mark a point on the biomes diagram and constrain the world area by height to mark it as `MapGen.Biome`.

    Parameters: ~
        {layerName}  (string)           The name of the layer in which the new biome will be included.
        {biomeName}  (string)           The name to be assigned to the biome. The name must be unique for each biome.
        {def}        (MapGen.BiomeDef)  Biome description table, see details `MapGen.BiomeDef`


                                                         *MapGen:registerCavern*
MapGen:registerCavern({layerName}, {cavernName}, {def})
    Mark the world area between two heights as a `MapGen.Cavern` and assign the noise that the cave will be generated from.

    Parameters: ~
        {layerName}   (string)            The name of the layer in which the new cavern will be included.
        {cavernName}  (string)            The name to be assigned to the cavern. The name must be unique for each cavern.
        {def}         (MapGen.CavernDef)  Cavern description table, see details `MapGen.CavernDef`


MapGen:initLayersTriangultaion()                *MapGen:initLayersTriangultaion*
    Divide all layers into triangles whose vertices are the `Mapgen.Peak` belonging to these layers.


MapGen:initLayersNoises()                              *MapGen:initLayersNoises*
    Initialize all layer noises. This should be called after the map object is loaded.


MapGen:initBiomesDiagram()                            *MapGen:initBiomesDiagram*
    Initialization of the biome diagram using the Voronoi method.


MapGen:initCavernsNoise()                              *MapGen:initCavernsNoise*
    Initialize caverns's noises. This should be called after the map object is loaded.


                                                       *MapGen:getNoises2dValue*
MapGen:getNoises2dValue({category}, {layer}, {x}, {y}, {z})
    Calculates a smoothed 2D noise value based on a preliminary space partitioning.

    Returns `nil` if the point is not included in any triangle.

    Parameters: ~
        {category}  (MapGen.Layer.Category)
        {layer}     (MapGen.Layer)
        {x}         (integer)
        {y}         (integer)
        {z}         (integer)                @return          number?


                                                      *MapGen:getNoises3dValues*
MapGen:getNoises3dValues({layer}, {x}, {y}, {z})
    Calculates a smoothed 3D noise value based on a preliminary space partitioning.

    Returns `nil` if the point is not included in any tetrahedron.


    Parameters: ~
        {layer}  (MapGen.Layer)
        {x}      (number)
        {y}      (number)
        {z}      (number)        @return          number?


                                                         *MapGen:onMapGenerated*
MapGen:onMapGenerated({voxelManip}, {minPos}, {maxPos}, {blockseed})
    Chunk generation handler.

    Parameters: ~
        {voxelManip}  (VoxelManip)
        {minPos}      (Position)
        {maxPos}      (Position)
        {blockseed}   (number)


MapGen:run()                                                        *MapGen:run*
    Run world generation through this mapgen object

    Note: only one instance of a `MapGen` class can be running.

    **FOR MAPGEN ENVIRONMENT ONLY**


vim:tw=78:ts=8:noet:ft=help:norl:
