API tools faq
paste
Guest User

Untitled

a guest
Aug 13th, 2017
57
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 14.11 KB | None | 0 0
raw download clone embed print report
  1. using System;
  2. using UnityEngine;
  3. using Kopernicus;
  4. using LibNoise;
  5. using Kopernicus.Configuration.ModLoader;
  6.  
  7. namespace PQSMod_VertexExtraNoise
  8. {
  9.     public class PQSMod_VertexExtraNoise : PQSMod
  10.     {
  11.         public enum NoiseType
  12.         {
  13.             RiggedMultifractal = 0,         //0
  14.             Billow = 1,                     //1
  15.             Perlin = 2,                     //2
  16.             PerfectRiggedMultifractal = 3,  //3
  17.             PerfectBillow = 4,              //4
  18.             PerfectPerlin = 5,              //5
  19.             Voronoi = 6,                    //6
  20.             PerfectVoronoi = 7,             //7
  21.             Simplex = 8,                    //8
  22.             PerfectSimplex = 9,             //9
  23.             Multiply = 10,                   //10
  24.             Power = 11,                      //11
  25.             Offset = 12                      //12
  26.         }
  27.         public NoiseType noiseType;
  28.         public Boolean useEnum;
  29.         public Int32 modMode;
  30.         public Double deformity;
  31.         public Double frequency;
  32.         public Double persistence;
  33.         public Double lacunarity;
  34.         public Boolean enableDistance;
  35.         public Int32 octaves;
  36.         public Int32 seed;
  37.         public NoiseQuality mode;
  38.         public Boolean addRange;
  39.         public Double minAltitude;
  40.         public Double maxAltitude;
  41.         Double trueMin;
  42.         Double trueMax;
  43.  
  44.         //Let's store the noise as object
  45.  
  46.         Double Perfectionize(Double noise)
  47.         {
  48.             //First, make noise on scale of 0<=>2 rather than -1<=>1, then divide by 2 to make 0<=>1
  49.             return (noise + 1) / 2;
  50.         }
  51.  
  52.         Billow b;
  53.         RidgedMultifractal r;
  54.         Perlin p;
  55.         Simplex s;
  56.         Voronoi v;
  57.  
  58.         public override void OnSetup()
  59.         {
  60.             trueMax = maxAltitude + sphere.radius;
  61.             trueMin = minAltitude + sphere.radius;
  62.  
  63.             if (!useEnum)
  64.             {
  65.                 if (modMode == 0)
  66.                 {
  67.                     noiseType = NoiseType.RiggedMultifractal;
  68.                 }
  69.                 if (modMode == 1)
  70.                 {
  71.                     noiseType = NoiseType.Billow;
  72.                 }
  73.                 if (modMode == 2)
  74.                 {
  75.                     noiseType = NoiseType.Perlin;
  76.                 }
  77.                 if (modMode == 3)
  78.                 {
  79.                     noiseType = NoiseType.PerfectRiggedMultifractal;
  80.                 }
  81.                 if (modMode == 4)
  82.                 {
  83.                     noiseType = NoiseType.PerfectBillow;
  84.                 }
  85.                 if (modMode == 5)
  86.                 {
  87.                     noiseType = NoiseType.PerfectPerlin;
  88.                 }
  89.                 if (modMode == 6)
  90.                 {
  91.                     noiseType = NoiseType.Voronoi;
  92.                 }
  93.                 if (modMode == 7)
  94.                 {
  95.                     noiseType = NoiseType.PerfectVoronoi;
  96.                 }
  97.                 if (modMode == 8)
  98.                 {
  99.                     noiseType = NoiseType.Simplex;
  100.                 }
  101.                 if (modMode == 9)
  102.                 {
  103.                     noiseType = NoiseType.PerfectSimplex;
  104.                 }
  105.                 if (modMode == 10)
  106.                 {
  107.                     noiseType = NoiseType.Multiply;
  108.                 }
  109.                 if (modMode == 11)
  110.                 {
  111.                     noiseType = NoiseType.Power;
  112.                 }
  113.                 if (modMode == 12)
  114.                 {
  115.                     noiseType = NoiseType.Offset;
  116.                 }
  117.             }
  118.         }
  119.  
  120.         public override void OnVertexBuildHeight(PQS.VertexBuildData data)
  121.         {
  122.             Double heightToSea = data.vertHeight - sphere.radius;
  123.             if (modMode == 1)
  124.             {
  125.                 b = new Billow(frequency, lacunarity, persistence, octaves, seed, mode);
  126.                 if (addRange)
  127.                 {
  128.                     if (data.vertHeight >= trueMin && data.vertHeight <= trueMax)
  129.                     {
  130.                         data.vertHeight += b.GetValue(data.directionFromCenter) * deformity;
  131.                     }
  132.                 }
  133.                 else
  134.                 {
  135.                     data.vertHeight += b.GetValue(data.directionFromCenter) * deformity;
  136.                 }
  137.             }
  138.             else if (modMode == 10)
  139.             {
  140.                 if (addRange)
  141.                 {
  142.                     if (data.vertHeight >= trueMin && data.vertHeight <= trueMax)
  143.                     {
  144.                         data.vertHeight += heightToSea * deformity;
  145.                     }
  146.                 }
  147.                 else
  148.                 {
  149.                     data.vertHeight += heightToSea * deformity;
  150.                 }
  151.             }
  152.             else if (modMode == 12)
  153.             {
  154.                 if (addRange)
  155.                 {
  156.                     if (data.vertHeight >= trueMin && data.vertHeight <= trueMax)
  157.                     {
  158.                         data.vertHeight += deformity;
  159.                     }
  160.                 }
  161.                 else
  162.                 {
  163.                     data.vertHeight += deformity;
  164.                 }
  165.             }
  166.             else if (modMode == 4)
  167.             {
  168.                 b = new Billow(frequency, lacunarity, persistence, octaves, seed, mode);
  169.                 if (addRange)
  170.                 {
  171.                     if (data.vertHeight >= trueMin && data.vertHeight <= trueMax)
  172.                     {
  173.                         data.vertHeight += Perfectionize(b.GetValue(data.directionFromCenter)) * deformity;
  174.                     }
  175.                 }
  176.                 else
  177.                 {
  178.                     data.vertHeight += Perfectionize(b.GetValue(data.directionFromCenter)) * deformity;
  179.                 }
  180.             }
  181.             else if (modMode == 5)
  182.             {
  183.                 p = new Perlin(frequency, lacunarity, persistence, octaves, seed, mode);
  184.                 if (addRange)
  185.                 {
  186.                     if (data.vertHeight >= trueMin && data.vertHeight <= trueMax)
  187.                     {
  188.                         data.vertHeight += Perfectionize(p.GetValue(data.directionFromCenter)) * deformity;
  189.                     }
  190.                 }
  191.                 else
  192.                 {
  193.                     data.vertHeight += Perfectionize(p.GetValue(data.directionFromCenter)) * deformity;
  194.                 }
  195.             }
  196.             else if (modeMode == 3)
  197.             {
  198.                 r = new RidgedMultifractal(frequency, lacunarity, octaves, seed, mode);
  199.                 if (addRange)
  200.                 {
  201.                     if (data.vertHeight >= trueMin && data.vertHeight <= trueMax)
  202.                     {
  203.                         data.vertHeight += Perfectionize(p.GetValue(data.directionFromCenter)) * deformity;
  204.                     }
  205.                 }
  206.                 else
  207.                 {
  208.                     data.vertHeight += Perfectionize(p.GetValue(data.directionFromCenter)) * deformity;
  209.                 }
  210.             }
  211.             else if (modMode == 9)
  212.             {
  213.                 s = new Simplex(seed, octaves, persistence, frequency);
  214.                 if (addRange)
  215.                 {
  216.                     if (data.vertHeight >= trueMin && data.vertHeight <= trueMax)
  217.                     {
  218.                         data.vertHeight += Perfectionize(s.noise(data.directionFromCenter)) * deformity;
  219.                     }
  220.                 }
  221.                 else
  222.                 {
  223.                     data.vertHeight += Perfectionize(s.noise(data.directionFromCenter)) * deformity;
  224.                 }
  225.             }
  226.             else if (modMode == 7)
  227.             {
  228.                 v = new Voronoi(frequency, persistence, seed, enableDistance);
  229.                 if (addRange)
  230.                 {
  231.                     if (data.vertHeight >= trueMin && data.vertHeight <= trueMax)
  232.                     {
  233.                         data.vertHeight += Perfectionize(v.GetValue(data.directionFromCenter)) * deformity;
  234.                     }
  235.                 }
  236.                 else
  237.                 {
  238.                     data.vertHeight += Perfectionize(v.GetValue(data.directionFromCenter)) * deformity;
  239.                 }
  240.             }
  241.             else if (modMode == 2)
  242.             {
  243.                 p = new Perlin(frequency, lacunarity, persistence, octaves, seed, mode);
  244.                 if (addRange)
  245.                 {
  246.                     if (data.vertHeight >= trueMin && data.vertHeight <= trueMax)
  247.                     {
  248.                         data.vertHeight += p.GetValue(data.directionFromCenter) * deformity;
  249.                     }
  250.                 }
  251.                 else
  252.                 {
  253.                     data.vertHeight += p.GetValue(data.directionFromCenter) * deformity;
  254.                 }
  255.             }
  256.             else if (modMode == 11)
  257.             {
  258.                 if (addRange)
  259.                 {
  260.                     if (data.vertHeight >= trueMin && data.vertHeight <= trueMax)
  261.                     {
  262.                         data.vertHeight = System.Math.Pow(heightToSea, deformity);
  263.                     }
  264.                 }
  265.                 else
  266.                 {
  267.                     data.vertHeight = System.Math.Pow(heightToSea, deformity);
  268.                 }
  269.             }
  270.             else if (modMode == 0)
  271.             {
  272.                 r = new RidgedMultifractal(frequency, lacunarity, octaves, seed, mode);
  273.                 if (addRange)
  274.                 {
  275.                     if (data.vertHeight >= trueMin && data.vertHeight <= trueMax)
  276.                     {
  277.                         data.vertHeight += r.GetValue(data.directionFromCenter) * deformity;
  278.                     }
  279.                 }
  280.                 else
  281.                 {
  282.                     data.vertHeight += r.GetValue(data.directionFromCenter) * deformity;
  283.                 }
  284.             }
  285.             else if (noiseType == NoiseType.Simplex)
  286.             {
  287.                 s = new Simplex(seed, octaves, persistence, frequency);
  288.                 if (addRange)
  289.                 {
  290.                     if (data.vertHeight >= trueMin && data.vertHeight <= trueMax)
  291.                     {
  292.                         data.vertHeight += s.noise(data.directionFromCenter) * deformity;
  293.                     }
  294.                 }
  295.                 else
  296.                 {
  297.                     data.vertHeight += s.noise(data.directionFromCenter) * deformity;
  298.                 }
  299.             }
  300.             else if (modMode == 8)
  301.             {
  302.                 v = new Voronoi(frequency, persistence, seed, enableDistance);
  303.                 if (addRange)
  304.                 {
  305.                     if (data.vertHeight >= trueMin && data.vertHeight <= trueMax)
  306.                     {
  307.                         data.vertHeight += v.GetValue(data.directionFromCenter) * deformity;
  308.                     }
  309.                 }
  310.                 else
  311.                 {
  312.                     data.vertHeight += v.GetValue(data.directionFromCenter) * deformity;
  313.                 }
  314.             }
  315.             else
  316.             {
  317.                 throw new ArgumentNullException("Noise type is unreadable.", nameof(noiseType));
  318.             }
  319.         }
  320.     }
  321.     [RequireConfigType(ConfigType.Node)]
  322.     public class VertexExtraNoise : ModLoader<PQSMod_VertexExtraNoise>
  323.     {
  324.         [ParserTarget("noiseType")]
  325.         public EnumParser<PQSMod_VertexExtraNoise.NoiseType> noiseType
  326.         {
  327.             get { return (PQSMod_VertexExtraNoise.NoiseType)mod.modMode; }
  328.             set { mod.modMode = (int)value; }
  329.         }
  330.         [ParserTarget("deformity")]
  331.         public NumericParser<double> deformity
  332.         {
  333.             get { return mod.deformity; }
  334.             set { mod.deformity = value; }
  335.         }
  336.         [ParserTarget("useEnum")]
  337.         public NumericParser<bool> useEnum
  338.         {
  339.             get { return mod.useEnum; }
  340.             set { mod.useEnum = value; }
  341.         }
  342.         //[ParserTarget("modMode")]
  343.         //public EnumParser< modMode
  344.         //{
  345.         //    get { return mod.modMode; }
  346.         //    set { mod.modMode = value; }
  347.         //}
  348.         [ParserTarget("frequency")]
  349.         public NumericParser<double> frequency
  350.         {
  351.             get { return mod.frequency; }
  352.             set { mod.frequency = value; }
  353.         }
  354.         [ParserTarget("persistence")]
  355.         public NumericParser<double> persistence
  356.         {
  357.             get { return mod.persistence; }
  358.             set { mod.persistence = value; }
  359.         }
  360.         [ParserTarget("lacunarity")]
  361.         public NumericParser<double> lacunarity
  362.         {
  363.             get { return mod.lacunarity; }
  364.             set { mod.lacunarity = value; }
  365.         }
  366.         [ParserTarget("enableDistance")]
  367.         public NumericParser<bool> enableDistance
  368.         {
  369.             get { return mod.enableDistance; }
  370.             set { mod.enableDistance = value; }
  371.         }
  372.         [ParserTarget("octaves")]
  373.         public NumericParser<int> octaves
  374.         {
  375.             get { return mod.octaves; }
  376.             set { mod.octaves = Mathf.Clamp(value, 1, 30); }
  377.         }
  378.         [ParserTarget("seed")]
  379.         public NumericParser<int> seed
  380.         {
  381.             get { return mod.seed; }
  382.             set { mod.seed = value; }
  383.         }
  384.         [ParserTarget("mode")]
  385.         public EnumParser<KopernicusNoiseQuality> mode
  386.         {
  387.             get { return (KopernicusNoiseQuality)(int)mod.mode; }
  388.             set { mod.mode = (NoiseQuality)(int) value.value; }
  389.         }
  390.         [ParserTarget("addRange")]
  391.         public NumericParser<bool> addRange
  392.         {
  393.             get { return mod.addRange; }
  394.             set { mod.addRange = value; }
  395.         }
  396.         [ParserTarget("maxAltitude")]
  397.         public NumericParser<double> maxAltitude
  398.         {
  399.             get { return mod.maxAltitude; }
  400.             set { mod.maxAltitude = value; }
  401.         }
  402.         [ParserTarget("minAltitude")]
  403.         public NumericParser<double> minAltitude
  404.         {
  405.             get { return mod.minAltitude; }
  406.             set { mod.minAltitude = value; }
  407.         }
  408.     }
  409. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!