public void OnAfterDeserialize()
{
if (noiseData == null || noiseData.Length == 0)
{
heightOutput = 0;
noiseModules = new NoiseModule[1] {
new Simplex()
{
planet = this
}
};
return;
}
using (System.IO.MemoryStream ms = new System.IO.MemoryStream(noiseData))
using (System.IO.BinaryReader br = new System.IO.BinaryReader(ms)) {
heightOutput = br.ReadInt32();
int c = br.ReadInt32();
noiseModules = new NoiseModule[c];
for (int i = 0; i < c; i++)
{
noiseModules[i] = NoiseModule.DeserializeModule(br);
noiseModules[i].planet = this;
noiseModules[i].index = i;
}
}
}
Rect Box(Vector2 pos, int lines, NoiseModule nm)
{
pos += cameraOffset;
pos.x = (int)(pos.x + .5f);
pos.y = (int)(pos.y + .5f);
Rect r = new Rect(pos.x, pos.y, moduleWidth, (int)((EditorGUIUtility.singleLineHeight + 2) * (lines + 1) + .5f));
r.x -= (int)(r.width * .5f + .5f);
r.y -= (int)(r.height * .5f + .5f);
Color c = Color.black;
if (r.Contains(Event.current.mousePosition) && nm != null && nm != add)
{
hover = nm.index;
c = Color.yellow;
}
else if (nm != null && selected == nm.index)
{
c = new Color(1f, .6f, 0f);
}
EditorGUI.DrawRect(new Rect(r.x - 3, r.y + 3, r.width + 4, r.height), new Color(0f, 0f, 0f, .25f)); // shadow
EditorGUI.DrawRect(new Rect(r.x - 1, r.y - 1, r.width + 2, r.height + 2), c); // outline
EditorGUI.DrawRect(r, inspectorColor); // background
EditorGUI.DrawRect(new Rect(r.x, r.y + (int)(EditorGUIUtility.singleLineHeight * 1.25f + .5f), (int)(r.width * .45f + .5f), 1), Color.black); // title underline
return(r);
}
void DrawNoiseModule(NoiseModule module)
{
if (module.displayGroup != curDisplayGroup)
{
return;
}
if (module is Simplex)
{
DrawSimplex(module as Simplex);
}
else if (module is Fractal)
{
DrawFractal(module as Fractal);
}
else if (module is NoiseBlend)
{
DrawBlend(module as NoiseBlend);
}
else if (module is NoiseMath)
{
DrawMath(module as NoiseMath);
}
else if (module is NoiseValue)
{
DrawValue(module as NoiseValue);
}
}
/// <summary>
/// Set ParticleSystem noiseModule field value.
/// </summary>
/// <param name="particleSystem"></param>
/// <param name="vgoModule"></param>
protected virtual void SetModuleValue(ParticleSystem particleSystem, VGO_PS_NoiseModule vgoModule)
{
if (vgoModule == null)
{
return;
}
NoiseModule module = particleSystem.noise;
module.enabled = vgoModule.enabled;
module.separateAxes = vgoModule.separateAxes;
if (vgoModule.separateAxes)
{
module.strengthX = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.strengthX);
module.strengthY = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.strengthY);
module.strengthZ = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.strengthZ);
module.strengthXMultiplier = vgoModule.strengthXMultiplier;
module.strengthYMultiplier = vgoModule.strengthYMultiplier;
module.strengthZMultiplier = vgoModule.strengthZMultiplier;
}
else
{
module.strength = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.strengthX);
module.strengthMultiplier = vgoModule.strengthXMultiplier;
}
module.frequency = vgoModule.frequency;
module.scrollSpeed = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.scrollSpeed);
module.scrollSpeedMultiplier = vgoModule.scrollSpeedMultiplier;
module.damping = vgoModule.damping;
module.octaveCount = vgoModule.octaveCount;
module.octaveMultiplier = vgoModule.octaveMultiplier;
module.octaveScale = vgoModule.octaveScale;
module.quality = vgoModule.quality;
module.remapEnabled = vgoModule.remapEnabled;
if (vgoModule.remapEnabled)
{
if (vgoModule.separateAxes)
{
module.remapX = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.remapX);
module.remapY = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.remapY);
module.remapZ = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.remapZ);
module.remapXMultiplier = vgoModule.remapXMultiplier;
module.remapYMultiplier = vgoModule.remapYMultiplier;
module.remapZMultiplier = vgoModule.remapZMultiplier;
}
else
{
module.remap = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.remapX);
module.remapMultiplier = vgoModule.remapXMultiplier;
}
}
module.positionAmount = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.positionAmount);
module.rotationAmount = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.rotationAmount);
module.sizeAmount = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.sizeAmount);
}
private FractalBrownianMotionImpl(int octaves, NoiseModule frequency, NoiseModule lacunarity, NoiseModule persistence)
{
NumberFormatInfo nfi = new NumberFormatInfo();
nfi.NumberGroupSeparator = "";
nfi.NumberDecimalSeparator = ".";
genCode(octaves.ToString(nfi), frequency.Code, lacunarity.Code, persistence.Code);
}
private VoronoiImpl(NoiseModule frequency, VoronoiType type)
{
NumberFormatInfo nfi = new NumberFormatInfo();
nfi.NumberGroupSeparator = "";
nfi.NumberDecimalSeparator = ".";
genCode(frequency.Code, getVoronoiFunction(type));
}
bool SetNoiseCS_3D(NoiseModule _noise, ComputeBuffer _res)
{
if (_noise == null || _res == null)
{
return(false);
}
string path = "TiliedCurlNoise3D";
string kanel = "CS_CurlNoise3D";
RandomTable randFunc = SetCommonRandomTable;
ComputeShader cs = Resources.Load <ComputeShader>(path);
if (cs == null)
{
return(false);
}
int kID = cs.FindKernel(kanel);
ComputeBuffer rtBuffer = null;
if (randFunc != null)
{
rtBuffer = randFunc.Invoke(cs, kID);
}
cs.SetInt("Octaves", _noise.bFBM ? _noise.iOctaves : 1);
cs.SetFloat("Persistence", _noise.fPersistence);
cs.SetFloat("Scale", _noise.fScale);
cs.SetFloat("Period", _noise.iPeriod);
cs.SetInt("TexWidth", mTexSize);
cs.SetInt("TexHeight", mTexSize);
cs.SetInt("TexDepth", mTexSize);
cs.SetBuffer(kID, "Result", _res);
uint sizeX, sizeY, sizeZ;
cs.GetKernelThreadGroupSizes(
kID,
out sizeX,
out sizeY,
out sizeZ
);
cs.Dispatch(kID, mTexSize / (int)sizeX, mTexSize / (int)sizeY, mTexSize / (int)sizeZ);
if (rtBuffer != null)
{
rtBuffer.Release();
rtBuffer = null;
}
return(true);
}
private RidgedMultifractalImpl(int octaves, NoiseModule frequency, NoiseModule lacunarity, NoiseModule persistence, NoiseModule offset)
{
NumberFormatInfo nfi = new NumberFormatInfo();
nfi.NumberGroupSeparator = "";
nfi.NumberDecimalSeparator = ".";
genCode(octaves.ToString(nfi), frequency.Code, lacunarity.Code, persistence.Code, offset.Code);
}
void ConnectionOutputButton(NoiseModule output, Vector2 center)
{
GUILayout.BeginArea(new Rect((int)(center.x + .5f) - 10, (int)(center.y + .5f) - 8, 20, 20));
if (GUILayout.Button(">", EditorStyles.miniButton))
{
connectFrom = output.index;
buttonClick = true;
}
GUILayout.EndArea();
}
public TerrainPatch(float globTileX_i, float globTileZ_i, Chunk chunk_i, float h0_i, float h1_i)
{
globalTileX = globTileX_i;
globalTileZ = globTileZ_i;
chunk = chunk_i;
h0 = h0_i;
h1 = h1_i;
m_mountainNoise = new PerlinNoise(chunk.seed);
m_plainsNoise = new PerlinNoise(chunk.seed);
}
public Blend(NoiseModule sourceModule1, NoiseModule sourceModule2, NoiseModule weightModule)
{
if (sourceModule1 == null || sourceModule2 == null || weightModule == null)
{
throw new ArgumentNullException("No source Modules may be null");
}
SourceModule1 = sourceModule1;
SourceModule2 = sourceModule2;
WeightModule = weightModule;
}
/// <summary>
/// Create VGO_PS_NoiseModule from NoiseModule.
/// </summary>
/// <param name="module"></param>
/// <returns></returns>
protected virtual VGO_PS_NoiseModule CreateVgoModule(NoiseModule module)
{
var vgoModule = new VGO_PS_NoiseModule()
{
enabled = module.enabled,
separateAxes = module.separateAxes,
frequency = module.frequency,
scrollSpeed = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.scrollSpeed),
scrollSpeedMultiplier = module.scrollSpeedMultiplier,
damping = module.damping,
octaveCount = module.octaveCount,
octaveMultiplier = module.octaveMultiplier,
octaveScale = module.octaveScale,
quality = module.quality,
remapEnabled = module.remapEnabled,
positionAmount = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.positionAmount),
rotationAmount = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.rotationAmount),
sizeAmount = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.sizeAmount),
};
if (module.separateAxes)
{
vgoModule.strengthX = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.strengthX);
vgoModule.strengthY = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.strengthY);
vgoModule.strengthZ = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.strengthZ);
vgoModule.strengthXMultiplier = module.strengthXMultiplier;
vgoModule.strengthYMultiplier = module.strengthYMultiplier;
vgoModule.strengthZMultiplier = module.strengthZMultiplier;
if (module.remapEnabled)
{
vgoModule.remapX = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.remapX);
vgoModule.remapY = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.remapY);
vgoModule.remapZ = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.remapZ);
vgoModule.remapXMultiplier = module.remapXMultiplier;
vgoModule.remapYMultiplier = module.remapYMultiplier;
vgoModule.remapZMultiplier = module.remapZMultiplier;
}
}
else
{
vgoModule.strengthX = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.strengthX);
vgoModule.strengthXMultiplier = module.strengthXMultiplier;
if (module.remapEnabled)
{
vgoModule.remapX = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.remapX);
vgoModule.remapXMultiplier = module.remapXMultiplier;
}
}
return(vgoModule);
}
void GenerateMap(NoiseModule nm, bool color = true)
{
if (!preview)
{
preview = new Texture2D(1024, 512);
}
Color[] colors = new Color[preview.width * preview.height];
double dx, dy, dz;
double h;
double lat, lon;
double latdelta = Mathd.PiTimes2 * 1d / preview.width;
double londelta = Mathd.Pi * 1d / preview.height;
int c = preview.height - 1;
lon = -Mathd.Pi;
for (int x = 0; x < preview.width; x++)
{
lon += londelta;
lat = -Mathd.PiOver2;
for (int y = 0; y < preview.height; y++)
{
dx = Mathd.Cos(lat) * Mathd.Cos(lon);
dy = Mathd.Sin(lat);
dz = Mathd.Cos(lat) * Mathd.Sin(lon);
h = nm.Get(dx, dy, dz) * .5 + .5;
if (color)
{
if (planet.hasWater && h < planet.waterHeight / planet.terrainHeight)
{
colors[x + (c - y) * preview.width] = Color.blue;
}
else
{
colors[x + (c - y) * preview.width] = planet.heightColorGradient.Evaluate((float)h);
}
}
else
{
colors[x + (c - y) * preview.width] = Color.white * (float)h;
}
lat += latdelta;
}
}
preview.SetPixels(colors);
preview.Apply();
}
//function to create the voxel noises and caves etc.
public static byte[, , ]CreateVoxels(byte[,,] m_voxels,Vector3 m_pos,VoxelChunk chunk,NoiseModule noiseModule)
{
//float startTime = Time.realtimeSinceStartup;
//Creates the data the mesh is created form. Fills m_voxels with values between -1 and 1 where
//-1 is a soild voxel and 1 is a empty voxel.
int w = m_voxels.GetLength(0);
int h= m_voxels.GetLength(1);
int l = m_voxels.GetLength(2);
float worldX;
float worldZ;
float worldY;
float ht;
for(int x = 0; x < w; x++)
{
for(int z = 0; z < l; z++)
{
//world pos is the voxels position plus the voxel chunks position
worldX = x+m_pos.x;
worldZ = z+m_pos.z;
ht = generator.noise.FillVoxel2d(worldX,worldZ,m_pos,SurfacePerlin,CavePerlin);
for(int y = 0; y < h; y++)
{
worldY = y+m_pos.y;
float HT=ht+worldY-h/2;
if(MakeCaves&&y<h/2-50)
HT -= generator.noise.FillVoxel3d(worldX,worldY,worldZ,m_pos);
HT/=16;
HT = Mathf.Clamp(HT , -0.5f, 0.5f);
HT+=0.5f;
HT*=255;
m_voxels[x,y,z]=(byte)HT;
m_voxels[x,y,z]=(byte)Mathf.Clamp(m_voxels[x,y,z],0,255);
if(y>=h-5&&m_voxels[x,y,z]<=127)m_voxels[x,y,z]=255;
if(y<=5&&m_voxels[x,y,z]>=127)m_voxels[x,y,z]=0;
}
}
}
return m_voxels;
}
private bool CreateModule(string moduleCode)
{
string code =
@"using System;
using ClooN;
namespace Stub
{
public class StubClass
{
public static NoiseModule ModuleMaker()
{
return
" + moduleCode + @";
}
}
}";
CSharpCodeProvider provider = new CSharpCodeProvider();
CompilerParameters parameters = new CompilerParameters();
parameters.ReferencedAssemblies.Add("ClooN.dll");
parameters.GenerateInMemory = true;
parameters.GenerateExecutable = false;
CompilerResults results = provider.CompileAssemblyFromSource(parameters, code);
if (results.Errors.HasErrors)
{
StringBuilder sb = new StringBuilder();
foreach (CompilerError error in results.Errors)
{
sb.AppendLine(String.Format("Error : {2}", error.Line - 9, error.Column, error.ErrorText));
}
errorMessage = sb.ToString();
return(false);
}
else
{
MethodInfo info = results.CompiledAssembly.GetType("Stub.StubClass").GetMethod("ModuleMaker");
lastSuccessful = ((Func <NoiseModule>)Delegate.CreateDelegate(typeof(Func <NoiseModule>), info))();
lastValidCode = moduleCode;
return(true);
}
}
void Start()
{
SoI = Mathd.Sqrt(Gravity.G * mass / .0001);
double s = 1.41421356237 * radius;
Vector3d[] v = new Vector3d[] {
Vector3d.up,
Vector3d.down,
Vector3d.left,
Vector3d.right,
Vector3d.forward,
Vector3d.back
};
Quaterniond[] q = new Quaterniond[] {
Quaterniond.Euler(0, 0, 0),
Quaterniond.Euler(180, 0, 0),
Quaterniond.Euler(0, 0, 90),
Quaterniond.Euler(0, 0, -90),
Quaterniond.Euler(90, 0, 0),
Quaterniond.Euler(-90, 0, 0)
};
groundNodes = new QuadNode[6];
if (hasWater)
{
waterNodes = new QuadNode[6];
}
for (int i = 0; i < 6; i++)
{
groundNodes[i] = new QuadNode(this, QuadNode.SurfaceType.Ground, 0, s, 0, null, s * .5 * v[i], q[i]);
if (hasWater)
{
waterNodes[i] = new QuadNode(this, QuadNode.SurfaceType.Water, 0, s, 0, null, s * .5 * v[i], q[i]);
}
}
simplex = new Simplex()
{
seed = seed
};
InitPropertyBlock();
started = true;
}
public IProcedural Generate()
{
int i = 0;
for (int x = 0; x < Bounds.X; x++)
{
int y = 0;
int z = 0;
//System.Diagnostics.Debug.WriteLine($"V:{x},{y},{z} | {VoxelSize}");
for (y = 0; y < Bounds.Y; y++)
{
for (z = 0; z < Bounds.Z; z++)
{
Vector3 coords = new Vector3(x, y, z) * VoxelSize;
var n = NoiseModule2D.GetValue(x, z);
Dictionary <ECubeFace, float> noisyNeighbors = new Dictionary <ECubeFace, float>();
noisyNeighbors.Add(ECubeFace.Top, NoiseModule.GetValue(x, y + 1, z));
noisyNeighbors.Add(ECubeFace.Bottom, NoiseModule.GetValue(x, y - 1, z));
noisyNeighbors.Add(ECubeFace.Left, NoiseModule.GetValue(x - 1, y, z));
noisyNeighbors.Add(ECubeFace.Right, NoiseModule.GetValue(x + 1, y, z));
noisyNeighbors.Add(ECubeFace.Front, NoiseModule.GetValue(x, y, z - 1));
noisyNeighbors.Add(ECubeFace.Back, NoiseModule.GetValue(x, y, z + 1));
IVoxel voxel = new Voxel
{
Id = Guid.NewGuid(),
Bounds = VoxelSize,
Coordinates = coords,
Noise = n,
NeighborNoiseValues = noisyNeighbors,
Material = new Material(n)
};
voxel.Generated += OnVoxelInitialized;
Debug.WriteLine($"Voxel: {i}");
voxel.Generate();
}
}
}
if (Voxels.Count == Bounds.X * Bounds.Y * Bounds.Z)
{
Generated.Invoke(this, new EventArgs());
}
return(this);
}
void OnGUI()
{
if (window == null)
{
GUILayout.Label("Missing window reference!");
return;
}
if (noises == null)
{
noises = new NoiseModule();
}
EditorGUILayout.BeginVertical("Box");
IntPow2Field("Noise Texture Size", ref mTexSize);
EditorGUILayout.EndVertical();
EditorGUILayout.BeginHorizontal("Box");
EditorGUILayout.LabelField("Random Seed:", mRandomSeed.ToString());
if (GUILayout.Button("Random"))
{
mRandomSeed = UnityEngine.Random.Range(0.001f, 200000f);
}
EditorGUILayout.EndHorizontal();
mDim = (eNoiseDim)EditorGUILayout.EnumPopup("Texture Dimension:", mDim);
SettingNoise("Curl Noise Setting", noises);
if (GUILayout.Button("Generate"))
{
switch (mDim)
{
case eNoiseDim.Dimension2:
GenerateNoise_2D();
break;
case eNoiseDim.Dimension3:
GenerateNoise_3D();
break;
}
}
}
protected override YAMLMappingNode ExportYAMLRoot(IAssetsExporter exporter)
{
#warning TODO: values acording to read version (current 2017.3.0f3)
YAMLMappingNode node = base.ExportYAMLRoot(exporter);
node.AddSerializedVersion(GetSerializedVersion(exporter.Version));
node.Add("lengthInSec", LengthInSec);
node.Add("simulationSpeed", SimulationSpeed);
node.Add("stopAction", StopAction);
node.Add("looping", Looping);
node.Add("prewarm", Prewarm);
node.Add("playOnAwake", PlayOnAwake);
node.Add("useUnscaledTime", UseUnscaledTime);
node.Add("autoRandomSeed", AutoRandomSeed);
node.Add("useRigidbodyForVelocity", UseRigidbodyForVelocity);
node.Add("startDelay", StartDelay.ExportYAML(exporter));
node.Add("moveWithTransform", MoveWithTransform);
node.Add("moveWithCustomTransform", MoveWithCustomTransform.ExportYAML(exporter));
node.Add("scalingMode", ScalingMode);
node.Add("randomSeed", RandomSeed);
node.Add("InitialModule", InitialModule.ExportYAML(exporter));
node.Add("ShapeModule", ShapeModule.ExportYAML(exporter));
node.Add("EmissionModule", EmissionModule.ExportYAML(exporter));
node.Add("SizeModule", SizeModule.ExportYAML(exporter));
node.Add("RotationModule", RotationModule.ExportYAML(exporter));
node.Add("ColorModule", ColorModule.ExportYAML(exporter));
node.Add("UVModule", UVModule.ExportYAML(exporter));
node.Add("VelocityModule", VelocityModule.ExportYAML(exporter));
node.Add("InheritVelocityModule", InheritVelocityModule.ExportYAML(exporter));
node.Add("ForceModule", ForceModule.ExportYAML(exporter));
node.Add("ExternalForcesModule", ExternalForcesModule.ExportYAML(exporter));
node.Add("ClampVelocityModule", ClampVelocityModule.ExportYAML(exporter));
node.Add("NoiseModule", NoiseModule.ExportYAML(exporter));
node.Add("SizeBySpeedModule", SizeBySpeedModule.ExportYAML(exporter));
node.Add("RotationBySpeedModule", RotationBySpeedModule.ExportYAML(exporter));
node.Add("ColorBySpeedModule", ColorBySpeedModule.ExportYAML(exporter));
node.Add("CollisionModule", CollisionModule.ExportYAML(exporter));
node.Add("TriggerModule", TriggerModule.ExportYAML(exporter));
node.Add("SubModule", SubModule.ExportYAML(exporter));
node.Add("LightsModule", LightsModule.ExportYAML(exporter));
node.Add("TrailModule", TrailModule.ExportYAML(exporter));
node.Add("CustomDataModule", CustomDataModule.ExportYAML(exporter));
return(node);
}
void OnGUI()
{
if (window == null)
{
GUILayout.Label("Missing window reference!");
return;
}
if (noises == null)
{
noises = new NoiseModule[4];
for (int i = 0; i < 4; ++i)
{
noises[i] = new NoiseModule();
}
}
EditorGUILayout.BeginVertical("Box");
IntPow2Field("Noise Texture Size", ref mTexSize);
EditorGUILayout.EndVertical();
mDim = (eNoiseDim)EditorGUILayout.EnumPopup("Texture Dimension:", mDim);
SettingNoise("Channel (R)", noises[0]);
SettingNoise("Channel (G)", noises[1]);
SettingNoise("Channel (B)", noises[2]);
SettingNoise("Channel (A)", noises[3]);
if (GUILayout.Button("Generate"))
{
switch (mDim)
{
case eNoiseDim.Dimension2:
GenerateNoise_2D();
break;
case eNoiseDim.Dimension3:
GenerateNoise_3D();
break;
}
}
}
void SettingNoise(string _Title, NoiseModule _noise)
{
if (_noise == null)
{
return;
}
EditorGUILayout.Space();
EditorGUILayout.LabelField(_Title);
EditorGUILayout.BeginVertical("Box");
_noise.eType = (eNoiseType)EditorGUILayout.EnumPopup("Noise Type:", _noise.eType);
_noise.iPeriod = EditorGUILayout.IntSlider("Noise Period", _noise.iPeriod, 2, 40);
EditorGUILayout.BeginHorizontal();
_noise.fRandomSeed = EditorGUILayout.FloatField("Random Seed:", _noise.fRandomSeed);
if (GUILayout.Button("Random"))
{
_noise.fRandomSeed = UnityEngine.Random.Range(0.001f, 200000f);
}
EditorGUILayout.EndHorizontal();
if (EnableFBM(_noise.eType) == true)
{
_noise.bFBM = EditorGUILayout.Toggle("Use fBm", _noise.bFBM);
if (_noise.bFBM == true)
{
_noise.iOctaves = EditorGUILayout.IntSlider("fBm Octaves", _noise.iOctaves, 2, 20);
_noise.fPersistence = EditorGUILayout.Slider("fBm Persistence", _noise.fPersistence, 0f, 1f);
_noise.fScale = EditorGUILayout.Slider("fBm Scale", _noise.fScale, 1f, 10f);
}
}
else
{
_noise.bFBM = false;
}
EditorGUILayout.EndVertical();
}
void SettingNoise(string _Title, NoiseModule _noise)
{
if (_noise == null)
{
return;
}
EditorGUILayout.Space();
EditorGUILayout.LabelField(_Title);
EditorGUILayout.BeginVertical("Box");
_noise.iPeriod = EditorGUILayout.IntSlider("Noise Period", _noise.iPeriod, 2, 20);
_noise.bFBM = EditorGUILayout.Toggle("Use fBm", _noise.bFBM);
if (_noise.bFBM == true)
{
_noise.iOctaves = EditorGUILayout.IntSlider("fBm Octaves", _noise.iOctaves, 2, 10);
_noise.fPersistence = EditorGUILayout.Slider("fBm Persistence", _noise.fPersistence, 0f, 1f);
_noise.fScale = EditorGUILayout.Slider("fBm Scale", _noise.fScale, 1f, 10f);
}
EditorGUILayout.EndVertical();
}
public override void Read(AssetReader reader)
{
base.Read(reader);
LengthInSec = reader.ReadSingle();
if (IsStartDelayFirst(reader.Version))
{
if (HasStartDelaySingle(reader.Version))
{
StartDelaySingle = reader.ReadSingle();
}
else
{
StartDelay.Read(reader);
}
}
SimulationSpeed = reader.ReadSingle();
if (HasStopAction(reader.Version))
{
StopAction = (ParticleSystemStopAction)reader.ReadInt32();
}
if (IsRandomSeedFirst(reader.Version))
{
RandomSeed = unchecked ((int)reader.ReadUInt32());
}
if (HasCullingMode(reader.Version))
{
CullingMode = (ParticleSystemCullingMode)reader.ReadInt32();
RingBufferMode = (ParticleSystemRingBufferMode)reader.ReadInt32();
RingBufferLoopRange.Read(reader);
}
Looping = reader.ReadBoolean();
Prewarm = reader.ReadBoolean();
PlayOnAwake = reader.ReadBoolean();
if (HasUseUnscaledTime(reader.Version))
{
UseUnscaledTime = reader.ReadBoolean();
}
if (IsMoveWithTransformBool(reader.Version))
{
MoveWithTransform = reader.ReadBoolean() ? ParticleSystemSimulationSpace.Local : ParticleSystemSimulationSpace.World;
}
if (HasAutoRandomSeed(reader.Version))
{
AutoRandomSeed = reader.ReadBoolean();
}
if (HasUseRigidbodyForVelocity(reader.Version))
{
UseRigidbodyForVelocity = reader.ReadBoolean();
}
if (IsAlign(reader.Version))
{
reader.AlignStream();
}
if (!IsStartDelayFirst(reader.Version))
{
StartDelay.Read(reader);
reader.AlignStream();
}
if (!IsMoveWithTransformBool(reader.Version))
{
MoveWithTransform = (ParticleSystemSimulationSpace)reader.ReadInt32();
reader.AlignStream();
}
if (HasMoveWithCustomTransform(reader.Version))
{
MoveWithCustomTransform.Read(reader);
}
if (HasScalingMode(reader.Version))
{
ScalingMode = (ParticleSystemScalingMode)reader.ReadInt32();
}
if (!IsRandomSeedFirst(reader.Version))
{
RandomSeed = reader.ReadInt32();
}
InitialModule.Read(reader);
ShapeModule.Read(reader);
EmissionModule.Read(reader);
SizeModule.Read(reader);
RotationModule.Read(reader);
ColorModule.Read(reader);
UVModule.Read(reader);
VelocityModule.Read(reader);
if (HasInheritVelocityModule(reader.Version))
{
InheritVelocityModule.Read(reader);
}
ForceModule.Read(reader);
if (HasExternalForcesModule(reader.Version))
{
ExternalForcesModule.Read(reader);
}
ClampVelocityModule.Read(reader);
if (HasNoiseModule(reader.Version))
{
NoiseModule.Read(reader);
}
SizeBySpeedModule.Read(reader);
RotationBySpeedModule.Read(reader);
ColorBySpeedModule.Read(reader);
CollisionModule.Read(reader);
if (HasTriggerModule(reader.Version))
{
TriggerModule.Read(reader);
}
SubModule.Read(reader);
if (HasLightsModule(reader.Version))
{
LightsModule.Read(reader);
TrailModule.Read(reader);
}
if (HasCustomDataModule(reader.Version))
{
CustomDataModule.Read(reader);
}
}
public static NoiseModule ValueOf(NoiseModule module1, NoiseModule module2)
{
return(new MinImpl(module1, module2));
}
private MinImpl(NoiseModule module1, NoiseModule module2)
{
genCode(module1.Code, module2.Code);
}
public static NoiseModule ValueOf(NoiseModule module)
{
return(new RoundImpl(module));
}
private RoundImpl(NoiseModule module)
{
genCode(module.Code);
}
public void SetDisplaceModules(NoiseModule x, NoiseModule y, NoiseModule z)
{
XDisplaceModule = x;
YDisplaceModule = y;
ZDisplaceModule = z;
}
public static NoiseModule ValueOf(int octaves, NoiseModule frequency, NoiseModule lacunarity, NoiseModule persistence)
{
return(new FractalBrownianMotionImpl(octaves, frequency, lacunarity, persistence));
}
public static NoiseModule ValueOf(int octaves, NoiseModule frequency, NoiseModule lacunarity, NoiseModule persistence)
{
return(new TurbulenceImpl(octaves, frequency, lacunarity, persistence));
}
public static NoiseModule ValueOf(NoiseModule ls, NoiseModule rs)
{
return(new AddImpl(ls, rs));
}
private AddImpl(NoiseModule ls, NoiseModule rs)
{
genCode(ls.Code, rs.Code);
}
