public AudXSettings()
: base()
{
this.Quality = QualityMode.STDQ;
this.Codec = AudioCodec.MP3;
this.EncoderType = AudioEncoderType.AUDX;
}
protected override void DrawModuleProperties()
{
quality = (QualityMode)EditorGUILayout.EnumPopup(new GUIContent("Quality"), quality);
seed = EditorGUILayout.IntField("Seed", seed);
frequency = EditorGUILayout.FloatField("Frequency", frequency);
octaves = EditorGUILayout.IntSlider("Octaves", octaves, 1, 30);
lacunarity = EditorGUILayout.FloatField("Lacunarity", lacunarity);
}
public FastRidgedMultifractal(int seed)
: base(seed)
{
Frequency = 1.0;
Lacunarity = 2.0;
OctaveCount = 6;
NoiseQuality = QualityMode.High;
}
protected override void DrawModuleProperties()
{
quality = (QualityMode)EditorGUILayout.EnumPopup(new GUIContent("Quality"), quality);
seed = EditorGUILayout.IntField("Seed", seed);
frequency = EditorGUILayout.FloatField("Frequency", frequency);
octaves = EditorGUILayout.IntSlider("Octaves", octaves, 1, 30);
lacunarity = EditorGUILayout.FloatField("Lacunarity", lacunarity);
}
/// <summary>
/// Initializes a new instance of RidgedMultifractal.
/// </summary>
/// <param name="frequency">The frequency of the first octave.</param>
/// <param name="lacunarity">The lacunarity of the ridged-multifractal noise.</param>
/// <param name="octaves">The number of octaves of the ridged-multifractal noise.</param>
/// <param name="seed">The seed of the ridged-multifractal noise.</param>
/// <param name="quality">The quality of the ridged-multifractal noise.</param>
public RidgedMultifractal(double frequency, double lacunarity, int octaves, int seed, QualityMode quality)
: base(0)
{
Frequency = frequency;
Lacunarity = lacunarity;
OctaveCount = octaves;
Seed = seed;
Quality = quality;
}
public RiggedMultifractal(double frequency, double lacunarity, int octaves, int seed, QualityMode quality)
: base(0)
{
this.Frequency = frequency;
this.Lacunarity = lacunarity;
this.OctaveCount = octaves;
this.Seed = seed;
this.Quality = quality;
}
/// <summary>
/// Initializes a new instance of RiggedMultifractal.
/// </summary>
/// <param name="frequency">The frequency of the first octave.</param>
/// <param name="lacunarity">The lacunarity of the ridged-multifractal noise.</param>
/// <param name="octaves">The number of octaves of the ridged-multifractal noise.</param>
/// <param name="seed">The seed of the ridged-multifractal noise.</param>
/// <param name="quality">The quality of the ridged-multifractal noise.</param>
public BrownianMotion(double frequency, double lacunarity, int octaves, int seed, QualityMode quality)
: base(0)
{
this.Frequency = frequency;
this.Lacunarity = lacunarity;
this.OctaveCount = octaves;
this.Seed = seed;
this.Quality = quality;
}
/// <summary>
/// Initializes a new instance of RidgedMultifractal.
/// </summary>
/// <param name="frequency">The frequency of the first octave.</param>
/// <param name="lacunarity">The lacunarity of the ridged-multifractal noise.</param>
/// <param name="octaves">The number of octaves of the ridged-multifractal noise.</param>
/// <param name="seed">The seed of the ridged-multifractal noise.</param>
/// <param name="quality">The quality of the ridged-multifractal noise.</param>
public RidgedMultifractal(double frequency, double lacunarity, int octaves, int seed, QualityMode quality)
: base(0)
{
Frequency = frequency;
Lacunarity = lacunarity;
OctaveCount = octaves;
Seed = seed;
Quality = quality;
}
/// <summary>
/// Initializes a new instance of Perlin.
/// </summary>
/// <param name="frequency">The frequency of the first octave.</param>
/// <param name="lacunarity">The lacunarity of the perlin noise.</param>
/// <param name="persistence">The persistence of the perlin noise.</param>
/// <param name="octaves">The number of octaves of the perlin noise.</param>
/// <param name="seed">The seed of the perlin noise.</param>
/// <param name="quality">The quality of the perlin noise.</param>
public Perlin(float frequency, float lacunarity, float persistence, int octaves, int seed, QualityMode quality)
: base(0)
{
this.Frequency = frequency;
this.Lacunarity = lacunarity;
this.OctaveCount = octaves;
this.Persistence = persistence;
this.Seed = seed;
this.Quality = quality;
}
public ExDistPerlin(double frequency, double lacunarity, double persistence, double mu, int octaves, int seed, QualityMode quality) : base(0)
{
Frequency = frequency;
Lacunarity = lacunarity;
Persistence = persistence;
Mu = mu;
OctaveCount = octaves;
Seed = seed;
Quality = quality;
}
/// <summary>
/// Initializes a new instance of Billow.
/// </summary>
/// <param name="frequency">The frequency of the first octave.</param>
/// <param name="lacunarity">The lacunarity of the billowy noise.</param>
/// <param name="persistence">The persistence of the billowy noise.</param>
/// <param name="octaves">The number of octaves of the billowy noise.</param>
/// <param name="seed">The seed of the billowy noise.</param>
/// <param name="quality">The quality of the billowy noise.</param>
public Billow(double frequency, double lacunarity, double persistence, int octaves, int seed, QualityMode quality)
: base(0)
{
Frequency = frequency;
Lacunarity = lacunarity;
OctaveCount = octaves;
Persistence = persistence;
Seed = seed;
Quality = quality;
}
public HybridMultifractal(Double frequency, Single lacunarity, Int32 octaves, Int32 seed, QualityMode quality, Single offset)
: base(0)
{
Frequency = frequency;
Lacunarity = lacunarity;
OctaveCount = octaves;
Seed = seed;
Quality = quality;
Offset = offset;
}
/// <summary>
/// Initializes a new instance of Billow.
/// </summary>
/// <param name="frequency">The frequency of the first octave.</param>
/// <param name="lacunarity">The lacunarity of the billowy noise.</param>
/// <param name="persistence">The persistence of the billowy noise.</param>
/// <param name="octaves">The number of octaves of the billowy noise.</param>
/// <param name="seed">The seed of the billowy noise.</param>
/// <param name="quality">The quality of the billowy noise.</param>
public Billow(double frequency, double lacunarity, double persistence, int octaves, int seed, QualityMode quality)
: base(0)
{
Frequency = frequency;
Lacunarity = lacunarity;
OctaveCount = octaves;
Persistence = persistence;
Seed = seed;
Quality = quality;
}
/// <summary>
/// Initializes a new instance of Billow.
/// </summary>
/// <param name="frequency">The frequency of the first octave.</param>
/// <param name="lacunarity">The lacunarity of the billowy noise.</param>
/// <param name="persistence">The persistence of the billowy noise.</param>
/// <param name="octaves">The number of octaves of the billowy noise.</param>
/// <param name="seed">The seed of the billowy noise.</param>
/// <param name="quality">The quality of the billowy noise.</param>
public Billow(double frequency, double lacunarity, double persistence, int octaves, int seed, QualityMode quality)
: base(0)
{
this.Frequency = frequency;
this.Lacunarity = lacunarity;
this.OctaveCount = octaves;
this.Persistence = persistence;
this.Seed = seed;
this.Quality = quality;
}
/// <summary>
/// Initializes a new instance of Perlin.
/// </summary>
/// <param name="frequency">The frequency of the first octave.</param>
/// <param name="lacunarity">The lacunarity of the perlin noise.</param>
/// <param name="persistence">The persistence of the perlin noise.</param>
/// <param name="octaves">The number of octaves of the perlin noise.</param>
/// <param name="seed">The seed of the perlin noise.</param>
/// <param name="quality">The quality of the perlin noise.</param>
public Perlin(Double frequency, Double lacunarity, Double persistence, Int32 octaves, Int32 seed,
QualityMode quality)
: base(0)
{
Frequency = frequency;
Lacunarity = lacunarity;
OctaveCount = octaves;
Persistence = persistence;
Seed = seed;
Quality = quality;
}
public NoiseFunctions()
{
enabled = true;
frequency = 1;
lacunarity = 2.2;
persistence = 0.5;
octaves = 1;
qualityMode = QualityMode.Low;
displacement = 1;
distance = true;
}
/// <summary>
/// Initializes a new instance of RiggedMultifractal.
/// </summary>
/// <param name="frequency">The frequency of the first octave.</param>
/// <param name="lacunarity">The lacunarity of the ridged-multifractal noise.</param>
/// <param name="octaves">The number of octaves of the ridged-multifractal noise.</param>
/// <param name="seed">The seed of the ridged-multifractal noise.</param>
/// <param name="quality">The quality of the ridged-multifractal noise.</param>
public HeterogeneousMultiFractal(double frequency, double lacunarity, int octaves, double persistence, int seed, double offset, QualityMode quality)
: base(0)
{
this.Frequency = frequency;
this.Lacunarity = lacunarity;
this.OctaveCount = octaves;
this.Seed = seed;
this.Persistence = persistence;
this.Offset = offset;
this.Quality = quality;
}
public ExoticNoise(Double frequency, Double lacunarity, Double modMode, QualityMode quality, Int32 octaves, Int32 seed, Double persistence)
: base(0)
{
Frequency = frequency;
Lacunarity = lacunarity;
OctaveCount = octaves;
Seed = seed;
Quality = quality;
ModMode = modMode;
Persistence = persistence;
}
/// <summary>
/// Initializes a new instance of RiggedMultifractal.
/// </summary>
/// <param name="frequency">The frequency of the first octave.</param>
/// <param name="lacunarity">The lacunarity of the ridged-multifractal noise.</param>
/// <param name="octaves">The number of octaves of the ridged-multifractal noise.</param>
/// <param name="seed">The seed of the ridged-multifractal noise.</param>
/// <param name="quality">The quality of the ridged-multifractal noise.</param>
public HybridMulti(double frequency, double lacunarity, int octaves, double persistence, int seed, double offset, double gain, QualityMode quality)
: base(0)
{
this.Frequency = frequency;
this.Lacunarity = lacunarity;
this.OctaveCount = octaves;
this.Seed = seed;
this.Offset = offset;
this.Persistence = persistence;
this.Quality = quality;
this.Gain = gain;
}
/// <summary>
/// 传入必须数据,初始化
/// </summary>
/// <param name="targetCamera">场景主相机</param>
/// <param name="targetList">需要产生阴影的显示对象</param>
/// <param name="lightEulerAngles">场景内平行光的欧拉角</param>
public void SetData(Camera targetCamera, List <Transform> targetList, Vector3 lightEulerAngles, QualityMode qualityMode = QualityMode.High)
{
this.targetCamera = targetCamera;
if (targetList == null)
{
targetList = new List <Transform>();
}
this.targetList = targetList;
transform.eulerAngles = lightEulerAngles;
currentMode = qualityMode;
Init();
}
public void SetAutoUpdateMode(bool autoUpdate)
{
//print("Auto-update: " + autoUpdate);
if (autoUpdate)
{
m_qualityMode = QualityMode.Automatic;
}
else
{
m_qualityMode = QualityMode.Manual;
}
}
public NoiseFunction()
{
type = NoiseType.None;
enabled = true;
frequency = 1;
lacunarity = 2.2;
persistence = 0.5;
octaves = 1;
qualityMode = QualityMode.Low;
displacement = 1;
distance = true;
blendMode = BlendMode.Add;
}
public void GetDefault()
{
type = NoiseType.Perlin;
enabled = true;
frequency = 1.1;
lacunarity = 2.2;
persistence = 0.6;
octaves = 7;
qualityMode = QualityMode.Low;
displacement = 1;
distance = true;
blendMode = BlendMode.Add;
}
public override void NodeGUI()
{
outputKnob.DisplayLayout();
_frequency = RTEditorGUI.FloatField(new GUIContent("Frequency"), _frequency);
_lacunarity = RTEditorGUI.FloatField(new GUIContent("Lacunarity"), _lacunarity);
_octaves = RTEditorGUI.IntField(new GUIContent("Octaves"), _octaves);
_seed = SeedGUIUtils.SeedInput(_seedInputKnob, _seed);
_quality = (QualityMode)RTEditorGUI.EnumPopup(new GUIContent("Quality"), _quality);
if (GUI.changed)
{
NodeEditor.curNodeCanvas.OnNodeChange(this);
}
}
private static TextureImporterPlatformSettings GetPlatformSettings(
string name,
TextureImporterFormat format,
int maxSize,
QualityMode quality
)
{
var setting = new TextureImporterPlatformSettings();
setting.overridden = true;
setting.name = name;
setting.format = format;
setting.maxTextureSize = maxSize;
setting.compressionQuality = (int)quality;
return(setting);
}
public NoiseFunctions(NoisePresets presets)
{
enabled = presets.enabled;
frequency = presets.frequency;
lacunarity = presets.lacunarity;
persistence = presets.persistence;
octaves = presets.octaves;
if (presets.qualityMode == NoisePresets.QualityMode.High)
{
qualityMode = QualityMode.High;
}
else if (presets.qualityMode == NoisePresets.QualityMode.Medium)
{
qualityMode = QualityMode.Medium;
}
else
{
qualityMode = QualityMode.Low;
}
if (presets.noiseType == NoisePresets.NoiseType.Billow)
{
type = NoiseType.Billow;
}
else if (presets.noiseType == NoisePresets.NoiseType.Perlin)
{
type = NoiseType.Perlin;
}
else if (presets.noiseType == NoisePresets.NoiseType.RiggedMultifractal)
{
type = NoiseType.RiggedMultifractal;
}
else if (presets.noiseType == NoisePresets.NoiseType.Voronoi)
{
type = NoiseType.Voronoi;
}
else
{
type = NoiseType.None;
}
displacement = presets.displacement;
distance = presets.distance;
}
public double GradientCoherentNoise(double x, double y, double z, int seed, QualityMode noiseQuality)
{
int x0 = (x > 0.0 ? (int)x : (int)x - 1);
int y0 = (y > 0.0 ? (int)y : (int)y - 1);
int z0 = (z > 0.0 ? (int)z : (int)z - 1);
int X = x0 & 255;
int Y = y0 & 255;
int Z = z0 & 255;
double u = 0, v = 0, w = 0;
switch (noiseQuality)
{
case QualityMode.Low:
u = (x - x0);
v = (y - y0);
w = (z - z0);
break;
case QualityMode.Medium:
u = SCurve3(x - x0);
v = SCurve3(y - y0);
w = SCurve3(z - z0);
break;
case QualityMode.High:
u = SCurve5(x - x0);
v = SCurve5(y - y0);
w = SCurve5(z - z0);
break;
}
int A = SelectedPermutations[X] + Y, AA = SelectedPermutations[A] + Z, AB = SelectedPermutations[A + 1] + Z,
B = SelectedPermutations[X + 1] + Y, BA = SelectedPermutations[B] + Z, BB = SelectedPermutations[B + 1] + Z;
double a = LinearInterpolate(GradientTable[AA], GradientTable[BA], u);
double b = LinearInterpolate(GradientTable[AB], GradientTable[BB], u);
double c = LinearInterpolate(a, b, v);
double d = LinearInterpolate(GradientTable[AA + 1], GradientTable[BA + 1], u);
double e = LinearInterpolate(GradientTable[AB + 1], GradientTable[BB + 1], u);
double f = LinearInterpolate(d, e, v);
return(LinearInterpolate(c, f, w));
}
public CustomNoise(Double frequency, Double lacunarity, Int32 seed, Int32 octaves, QualityMode mode, Double persistence,
Vector2 pass1, Vector2 pass2, Vector2 pass3, Vector2 pass4, Vector2 pass5, Vector2 pass6, Vector2 pass7, Vector2 pass8,
Vector2 pass9, Vector2 pass10)
: base(0)
{
Frequency = frequency;
Lacunarity = lacunarity;
Seed = seed;
OctaveCount = octaves;
NoiseMode = mode;
Persistence = persistence;
Edit1 = pass1;
Edit2 = pass2;
Edit3 = pass3;
Edit4 = pass4;
Edit5 = pass5;
Edit6 = pass6;
Edit7 = pass7;
Edit8 = pass8;
Edit9 = pass9;
Edit10 = pass10;
}
private void SetQualityMode(QualityMode qualityMode)
{
if (!detailManager.gameObject.activeSelf)
{
_currentQualityModeText.text = "Current Quality Mode: GPU Instancer disabled (Unity terrain)";
}
else
{
_currentQualityModeText.text = "Current Quality Mode: " + qualityMode + " Quality";
if (_currentQualityMode == qualityMode)
{
return;
}
_currentQualityMode = qualityMode;
SetPrototypesByQuality(qualityMode);
GPUInstancerAPI.UpdateDetailInstances(detailManager, true);
}
}
private void SetPrototypesByQuality(QualityMode qualityMode)
{
for (int i = 0; i < detailManager.prototypeList.Count; i++)
{
GPUInstancerDetailPrototype detailPrototype = (GPUInstancerDetailPrototype)detailManager.prototypeList[i];
switch (qualityMode)
{
case QualityMode.Low:
detailPrototype.isBillboard = !detailPrototype.usePrototypeMesh;
detailPrototype.useCrossQuads = false;
//detailPrototype.quadCount = 2;
//detailPrototype.billboardDistance = 50f;
detailPrototype.isShadowCasting = false;
detailPrototype.maxDistance = 150f;
break;
case QualityMode.Mid:
detailPrototype.isBillboard = false;
detailPrototype.useCrossQuads = !detailPrototype.usePrototypeMesh;
detailPrototype.quadCount = 2;
//detailPrototype.billboardDistance = 50f;
detailPrototype.isShadowCasting = detailPrototype.usePrototypeMesh;
detailPrototype.maxDistance = 250;
break;
case QualityMode.High:
detailPrototype.isBillboard = false;
detailPrototype.useCrossQuads = !detailPrototype.usePrototypeMesh;
detailPrototype.quadCount = 4;
//detailPrototype.billboardDistance = 50f;
detailPrototype.isShadowCasting = true;
detailPrototype.maxDistance = 500;
break;
}
}
}
public ExDistPerlin(double frequency, double lacunarity, double persistence, double mu, int octaves, int seed, QualityMode quality)
: base(0)
{
Frequency = frequency;
Lacunarity = lacunarity;
Persistence = persistence;
Mu = mu;
OctaveCount = octaves;
Seed = seed;
Quality = quality;
}
/// <summary>
/// Initializes a new instance of Perlin.
/// </summary>
/// <param name="frequency">The frequency of the first octave.</param>
/// <param name="lacunarity">The lacunarity of the perlin noise.</param>
/// <param name="persistence">The persistence of the perlin noise.</param>
/// <param name="octaves">The number of octaves of the perlin noise.</param>
/// <param name="seed">The seed of the perlin noise.</param>
/// <param name="quality">The quality of the perlin noise.</param>
public Perlin(double frequency, double lacunarity, double persistence, int octaves, int seed, QualityMode quality)
: base(0)
{
this.Frequency = frequency;
this.Lacunarity = lacunarity;
this.OctaveCount = octaves;
this.Persistence = persistence;
this.Seed = seed;
this.Quality = quality;
}
public override void OnInspectorGUI()
{
var graphic = target as UICapturedImage;
//基础
EditorGUILayout.PropertyField(texture);
EditorGUILayout.PropertyField(color);
EditorGUILayout.PropertyField(raycastTarget);
GUILayout.Space(10);
EditorGUILayout.LabelField("效果", EditorStyles.boldLabel);
//材质球
EditorGUI.BeginDisabledGroup(true);
CreateLine(material, "材质球");
EditorGUI.EndDisabledGroup();
//特效模式
CreateLine(effectMode, "特效模式");
if (effectMode.intValue != (int)EffectMode.None)
{
EditorGUI.indentLevel++;
CreateLine(effectFactor, "特效程度");
EditorGUI.indentLevel--;
}
//颜色模式
CreateLine(colorMode, "颜色模式");
EditorGUI.indentLevel++;
EditorGUI.BeginChangeCheck();
EditorGUI.showMixedValue = color.hasMultipleDifferentValues;
content.text = "颜色特效";
#if UNITY_2018_1_OR_NEWER
effectColor.colorValue =
EditorGUILayout.ColorField(content, effectColor.colorValue, true, false, false);
#else
effectColor.colorValue =
EditorGUILayout.ColorField(content, effectColor.colorValue, true, false, false, null);
#endif
if (EditorGUI.EndChangeCheck())
{
color.serializedObject.ApplyModifiedProperties();
}
CreateLine(colorFactor, "颜色程度");
EditorGUI.indentLevel--;
//模糊程度
CreateLine(blurMode, "模糊模式");
if (blurMode.intValue != (int)BlurMode.None)
{
EditorGUI.indentLevel++;
CreateLine(blurFactor, "模糊程度");
EditorGUI.indentLevel--;
}
//进阶设置
GUILayout.Space(10);
EditorGUILayout.LabelField("进阶设置", EditorStyles.boldLabel);
CreateLine(captureOnEnable, "Enable立即启用");
CreateLine(keepSizeToRootCanvas, "填充父节点");
CreateLine(immediateCapturing, "是否立即执行");
//品质设定
EditorGUI.BeginChangeCheck();
QualityMode quality = Quality;
quality = (QualityMode)EditorGUILayout.EnumPopup("效果品质", quality);
if (EditorGUI.EndChangeCheck())
{
Quality = quality;
}
customAdvancedOption = (quality == QualityMode.Custom);
//自定义品质
if (customAdvancedOption)
{
if (blurMode.intValue != 0)
{
CreateLine(iterations, "模糊次数");
}
//降低采样
DrawDesamplingRate(reductionRate, true);
EditorGUILayout.Space();
EditorGUILayout.LabelField("最终图片设置", EditorStyles.boldLabel);
//提升采样
CreateLine(filterMode, "滤波模式");
DrawDesamplingRate(desamplingRate, false);
}
serializedObject.ApplyModifiedProperties();
using (new EditorGUILayout.HorizontalScope(EditorStyles.helpBox))
{
GUILayout.Label("测试");
if (GUILayout.Button("播放", "ButtonLeft"))
{
graphic.Release();
EditorApplication.delayCall += graphic.Capture;
}
EditorGUI.BeginDisabledGroup(!graphic.CapturedTexture);
if (GUILayout.Button("结束", "ButtonRight"))
{
graphic.Release();
}
EditorGUI.EndDisabledGroup();
}
}
/// <summary>
/// Initializes a new instance of RiggedMultifractal.
/// </summary>
/// <param name="frequency">The frequency of the first octave.</param>
/// <param name="lacunarity">The lacunarity of the ridged-multifractal noise.</param>
/// <param name="octaves">The number of octaves of the ridged-multifractal noise.</param>
/// <param name="seed">The seed of the ridged-multifractal noise.</param>
/// <param name="quality">The quality of the ridged-multifractal noise.</param>
public HybridMulti(double frequency, double lacunarity, int octaves, double persistence, int seed, double offset, double gain, QualityMode quality)
: base(0)
{
this.Frequency = frequency;
this.Lacunarity = lacunarity;
this.OctaveCount = octaves;
this.Seed = seed;
this.Offset = offset;
this.Persistence = persistence;
this.Quality = quality;
this.Gain = gain;
}
internal static double GradientCoherentNoise3D(double x, double y, double z, long seed, QualityMode quality)
{
int x0 = x > 0.0 ? (int)x : (int)x - 1;
int x1 = x0 + 1;
int y0 = y > 0.0 ? (int)y : (int)y - 1;
int y1 = y0 + 1;
int z0 = z > 0.0 ? (int)z : (int)z - 1;
int z1 = z0 + 1;
double xs = 0, ys = 0, zs = 0;
switch (quality)
{
case QualityMode.Low:
{
xs = (x - x0);
ys = (y - y0);
zs = (z - z0);
break;
}
case QualityMode.Medium:
{
xs = MapCubicSCurve(x - x0);
ys = MapCubicSCurve(y - y0);
zs = MapCubicSCurve(z - z0);
break;
}
case QualityMode.High:
{
xs = MapQuinticSCurve(x - x0);
ys = MapQuinticSCurve(y - y0);
zs = MapQuinticSCurve(z - z0);
break;
}
}
double n0 = GradientNoise3D(x, y, z, x0, y0, z0, seed);
double n1 = GradientNoise3D(x, y, z, x1, y0, z0, seed);
double ix0 = InterpolateLinear(n0, n1, xs);
n0 = GradientNoise3D(x, y, z, x0, y1, z0, seed);
n1 = GradientNoise3D(x, y, z, x1, y1, z0, seed);
double ix1 = InterpolateLinear(n0, n1, xs);
double iy0 = InterpolateLinear(ix0, ix1, ys);
n0 = GradientNoise3D(x, y, z, x0, y0, z1, seed);
n1 = GradientNoise3D(x, y, z, x1, y0, z1, seed);
ix0 = InterpolateLinear(n0, n1, xs);
n0 = GradientNoise3D(x, y, z, x0, y1, z1, seed);
n1 = GradientNoise3D(x, y, z, x1, y1, z1, seed);
ix1 = InterpolateLinear(n0, n1, xs);
double iy1 = InterpolateLinear(ix0, ix1, ys);
return InterpolateLinear(iy0, iy1, zs);
}
//noise
private double GradientCoherentDistributedNoise3D(double x, double y, double z, long seed, QualityMode quality)
{
var x0 = x > 0.0 ? (int) x : (int) x - 1;
var x1 = x0 + 1;
var y0 = y > 0.0 ? (int) y : (int) y - 1;
var y1 = y0 + 1;
var z0 = z > 0.0 ? (int) z : (int) z - 1;
var z1 = z0 + 1;
double xs = 0, ys = 0, zs = 0;
switch (quality)
{
case QualityMode.Low:
{
xs = (x - x0);
ys = (y - y0);
zs = (z - z0);
break;
}
case QualityMode.Medium:
{
xs = Utils.MapCubicCurve(x - x0);
ys = Utils.MapCubicCurve(y - y0);
zs = Utils.MapCubicCurve(z - z0);
break;
}
case QualityMode.High:
{
xs = Utils.MapQuinticCurve(x - x0);
ys = Utils.MapQuinticCurve(y - y0);
zs = Utils.MapQuinticCurve(z - z0);
break;
}
}
long i = 255;
var j0 = GradientDistributedNoise3D (x, y, z, x0, y0, z0, seed, ref i);
var n0 = j0 * magnitudes[Math.Abs(i) % B];
var j1 = GradientDistributedNoise3D (x, y, z, x1, y0, z0, seed, ref i);
var n1 = j1 * magnitudes[Math.Abs(i) % B];
var ix0 = Utils.LerpD (n0, n1, xs);
j0 = GradientDistributedNoise3D (x, y, z, x0, y1, z0, seed, ref i);
n0 = j0 * magnitudes[Math.Abs(i) % B];
j1 = GradientDistributedNoise3D (x, y, z, x1, y1, z0, seed, ref i);
n1 = j1 * magnitudes[Math.Abs(i) % B];
var ix1 = Utils.LerpD (n0, n1, xs);
var iy0 = Utils.LerpD (ix0, ix1, ys);
j0 = GradientDistributedNoise3D (x, y, z, x0, y0, z1, seed, ref i);
n0 = j0 * magnitudes[Math.Abs(i) % B];
j1 = GradientDistributedNoise3D (x, y, z, x1, y0, z1, seed, ref i);
n1 = j1 * magnitudes[Math.Abs(i) % B];
ix0 = Utils.LerpD (n0, n1, xs);
j0 = GradientDistributedNoise3D (x, y, z, x0, y1, z1, seed, ref i);
n0 = j0 * magnitudes[Math.Abs(i) % B];
j1 = GradientDistributedNoise3D (x, y, z, x1, y1, z1, seed, ref i);
n1 = j1 * magnitudes[Math.Abs(i) % B];
ix1 = Utils.LerpD (n0, n1, xs);
var iy1 = Utils.LerpD (ix0, ix1, ys);
return Utils.LerpD (iy0, iy1, zs);
}
public AudXSettings()
: base(ID, AudioCodec.MP3, AudioEncoderType.AUDX, 80)
{
this.Quality = QualityMode.STDQ;
}
internal static float GradientCoherentNoise3D(float x, float y, float z, long seed, QualityMode quality)
{
int x0 = x > 0.0 ? (int)x : (int)x - 1;
int x1 = x0 + 1;
int y0 = y > 0.0 ? (int)y : (int)y - 1;
int y1 = y0 + 1;
int z0 = z > 0.0 ? (int)z : (int)z - 1;
int z1 = z0 + 1;
float xs = 0, ys = 0, zs = 0;
switch (quality)
{
case QualityMode.Low:
{
xs = (x - (float)x0);
ys = (y - (float)y0);
zs = (z - (float)z0);
break;
}
case QualityMode.Medium:
{
xs = Utils.MapCubicSCurve(x - (float)x0);
ys = Utils.MapCubicSCurve(y - (float)y0);
zs = Utils.MapCubicSCurve(z - (float)z0);
break;
}
case QualityMode.High:
{
xs = Utils.MapQuinticSCurve(x - (float)x0);
ys = Utils.MapQuinticSCurve(y - (float)y0);
zs = Utils.MapQuinticSCurve(z - (float)z0);
break;
}
}
float n0, n1, ix0, ix1, iy0, iy1;
n0 = Utils.GradientNoise3D(x, y, z, x0, y0, z0, seed);
n1 = Utils.GradientNoise3D(x, y, z, x1, y0, z0, seed);
ix0 = Utils.InterpolateLinear(n0, n1, xs);
n0 = Utils.GradientNoise3D(x, y, z, x0, y1, z0, seed);
n1 = Utils.GradientNoise3D(x, y, z, x1, y1, z0, seed);
ix1 = Utils.InterpolateLinear(n0, n1, xs);
iy0 = Utils.InterpolateLinear(ix0, ix1, ys);
n0 = Utils.GradientNoise3D(x, y, z, x0, y0, z1, seed);
n1 = Utils.GradientNoise3D(x, y, z, x1, y0, z1, seed);
ix0 = Utils.InterpolateLinear(n0, n1, xs);
n0 = Utils.GradientNoise3D(x, y, z, x0, y1, z1, seed);
n1 = Utils.GradientNoise3D(x, y, z, x1, y1, z1, seed);
ix1 = Utils.InterpolateLinear(n0, n1, xs);
iy1 = Utils.InterpolateLinear(ix0, ix1, ys);
return Utils.InterpolateLinear(iy0, iy1, zs);
}
internal static double GradientCoherentNoise3D(double x, double y, double z, long seed, QualityMode quality)
{
int x0 = x > 0.0 ? (int)x : (int)x - 1;
int x1 = x0 + 1;
int y0 = y > 0.0 ? (int)y : (int)y - 1;
int y1 = y0 + 1;
int z0 = z > 0.0 ? (int)z : (int)z - 1;
int z1 = z0 + 1;
double xs = 0, ys = 0, zs = 0;
switch (quality)
{
case QualityMode.Low:
{
xs = (x - (double)x0);
ys = (y - (double)y0);
zs = (z - (double)z0);
break;
}
case QualityMode.Medium:
{
xs = Utils.MapCubicSCurve(x - (double)x0);
ys = Utils.MapCubicSCurve(y - (double)y0);
zs = Utils.MapCubicSCurve(z - (double)z0);
break;
}
case QualityMode.High:
{
xs = Utils.MapQuinticSCurve(x - (double)x0);
ys = Utils.MapQuinticSCurve(y - (double)y0);
zs = Utils.MapQuinticSCurve(z - (double)z0);
break;
}
}
double n0, n1, ix0, ix1, iy0, iy1;
n0 = Utils.GradientNoise3D(x, y, z, x0, y0, z0, seed);
n1 = Utils.GradientNoise3D(x, y, z, x1, y0, z0, seed);
ix0 = Utils.InterpolateLinear(n0, n1, xs);
n0 = Utils.GradientNoise3D(x, y, z, x0, y1, z0, seed);
n1 = Utils.GradientNoise3D(x, y, z, x1, y1, z0, seed);
ix1 = Utils.InterpolateLinear(n0, n1, xs);
iy0 = Utils.InterpolateLinear(ix0, ix1, ys);
n0 = Utils.GradientNoise3D(x, y, z, x0, y0, z1, seed);
n1 = Utils.GradientNoise3D(x, y, z, x1, y0, z1, seed);
ix0 = Utils.InterpolateLinear(n0, n1, xs);
n0 = Utils.GradientNoise3D(x, y, z, x0, y1, z1, seed);
n1 = Utils.GradientNoise3D(x, y, z, x1, y1, z1, seed);
ix1 = Utils.InterpolateLinear(n0, n1, xs);
iy1 = Utils.InterpolateLinear(ix0, ix1, ys);
return(Utils.InterpolateLinear(iy0, iy1, zs));
}
/// <summary>
/// Implement this function to make a custom inspector.
/// </summary>
public override void OnInspectorGUI()
{
serializedObject.Update();
//================
// Basic properties.
//================
EditorGUILayout.PropertyField(_spTexture);
EditorGUILayout.PropertyField(_spColor);
EditorGUILayout.PropertyField(_spRaycastTarget);
//================
// Capture effect.
//================
GUILayout.Space(10);
EditorGUILayout.LabelField("Capture Effect", EditorStyles.boldLabel);
UIEffectEditor.DrawEffectProperties(UIEffectCapturedImage.shaderName, serializedObject);
//================
// Advanced option.
//================
GUILayout.Space(10);
EditorGUILayout.LabelField("Advanced Option", EditorStyles.boldLabel);
EditorGUI.BeginChangeCheck();
QualityMode quality = qualityMode;
quality = (QualityMode)EditorGUILayout.EnumPopup("Quality Mode", quality);
if (EditorGUI.EndChangeCheck())
{
_customAdvancedOption = (quality == QualityMode.Custom) || _spTargetTexture.objectReferenceValue;
qualityMode = quality;
}
// When qualityMode is `Custom`, show advanced option.
if (_customAdvancedOption)
{
if (_spBlurMode.intValue != 0)
{
EditorGUILayout.PropertyField(_spIterations); // Iterations.
}
EditorGUILayout.PropertyField(_spKeepSizeToRootCanvas); // Keep Graphic Size To RootCanvas.
DrawDesamplingRate(_spReductionRate); // Reduction rate.
EditorGUILayout.Space();
EditorGUILayout.LabelField("Result Texture Setting", EditorStyles.boldLabel);
if (!_spTargetTexture.objectReferenceValue)
{
EditorGUILayout.PropertyField(_spFilterMode); // Filter Mode.
DrawDesamplingRate(_spDesamplingRate); // Desampling rate.
}
using (new EditorGUILayout.HorizontalScope())
{
EditorGUILayout.PropertyField(_spTargetTexture); // Target Texture.
Texture t = _spTargetTexture.objectReferenceValue as Texture;
if (t)
{
GUILayout.Label(string.Format("{0}x{1}", t.width, t.height), EditorStyles.miniLabel);
}
}
}
serializedObject.ApplyModifiedProperties();
// Debug.
using (new EditorGUILayout.HorizontalScope(EditorStyles.helpBox))
{
GUILayout.Label("Debug");
if (GUILayout.Button("Capture", "ButtonLeft"))
{
UpdateTexture(true);
}
EditorGUI.BeginDisabledGroup(!(target as UIEffectCapturedImage).capturedTexture);
if (GUILayout.Button("Release", "ButtonRight"))
{
UpdateTexture(false);
}
EditorGUI.EndDisabledGroup();
}
// Warning message for overlay rendering.
var graphic = (target as UIEffectCapturedImage);
if (graphic && graphic.canvas)
{
var canvas = graphic.canvas.rootCanvas;
if (canvas && canvas.renderMode != RenderMode.ScreenSpaceCamera)
{
using (new GUILayout.HorizontalScope())
{
EditorGUILayout.HelpBox("'ScreenSpace - Overlay' and 'WorldSpace - Camera' render modes are not supported. Change render mode of root canvas to 'ScreenSpace - Camera'.", MessageType.Warning);
if (GUILayout.Button("Canvas"))
{
Selection.activeGameObject = canvas.gameObject;
}
}
}
}
}
public NoiseFunction(NoisePresets presets)
{
enabled = presets.enabled;
frequency = presets.frequency;
lacunarity = presets.lacunarity;
persistence = presets.persistence;
octaves = presets.octaves;
if (presets.qualityMode == NoisePresets.QualityMode.High)
{
qualityMode = QualityMode.High;
}
else if (presets.qualityMode == NoisePresets.QualityMode.Medium)
{
qualityMode = QualityMode.Medium;
}
else
{
qualityMode = QualityMode.Low;
}
if (presets.noiseType == NoisePresets.NoiseType.Billow)
{
type = NoiseType.Billow;
}
else if (presets.noiseType == NoisePresets.NoiseType.Perlin)
{
type = NoiseType.Perlin;
}
else if (presets.noiseType == NoisePresets.NoiseType.RidgedMultifractal)
{
type = NoiseType.RidgedMultifractal;
}
else if (presets.noiseType == NoisePresets.NoiseType.Voronoi)
{
type = NoiseType.Voronoi;
}
else
{
type = NoiseType.None;
}
if (presets.blendMode == NoisePresets.BlendMode.Subtract)
{
blendMode = BlendMode.Subtract;
}
else if (presets.blendMode == NoisePresets.BlendMode.Max)
{
blendMode = BlendMode.Max;
}
else if (presets.blendMode == NoisePresets.BlendMode.Min)
{
blendMode = BlendMode.Min;
}
else if (presets.blendMode == NoisePresets.BlendMode.Multiply)
{
blendMode = BlendMode.Multiply;
}
else if (presets.blendMode == NoisePresets.BlendMode.Power)
{
blendMode = BlendMode.Power;
}
else
{
blendMode = BlendMode.Add;
}
displacement = presets.displacement;
distance = presets.distance;
}
internal static double GradientCoherentNoise3D(double x, double y, double z, long seed, QualityMode quality)
{
int num = (x > 0.0) ? ((int)x) : ((int)x - 1);
int ix = num + 1;
int num2 = (y > 0.0) ? ((int)y) : ((int)y - 1);
int iy = num2 + 1;
int num3 = (z > 0.0) ? ((int)z) : ((int)z - 1);
int iz = num3 + 1;
double position = 0.0;
double position2 = 0.0;
double position3 = 0.0;
switch (quality)
{
case QualityMode.Low:
position = x - (double)num;
position2 = y - (double)num2;
position3 = z - (double)num3;
break;
case QualityMode.Medium:
position = MapCubicSCurve(x - (double)num);
position2 = MapCubicSCurve(y - (double)num2);
position3 = MapCubicSCurve(z - (double)num3);
break;
case QualityMode.High:
position = MapQuinticSCurve(x - (double)num);
position2 = MapQuinticSCurve(y - (double)num2);
position3 = MapQuinticSCurve(z - (double)num3);
break;
}
double a = GradientNoise3D(x, y, z, num, num2, num3, seed);
double b = GradientNoise3D(x, y, z, ix, num2, num3, seed);
double a2 = InterpolateLinear(a, b, position);
double a3 = GradientNoise3D(x, y, z, num, iy, num3, seed);
b = GradientNoise3D(x, y, z, ix, iy, num3, seed);
double b2 = InterpolateLinear(a3, b, position);
double a4 = InterpolateLinear(a2, b2, position2);
double a5 = GradientNoise3D(x, y, z, num, num2, iz, seed);
b = GradientNoise3D(x, y, z, ix, num2, iz, seed);
double a6 = InterpolateLinear(a5, b, position);
double a7 = GradientNoise3D(x, y, z, num, iy, iz, seed);
b = GradientNoise3D(x, y, z, ix, iy, iz, seed);
b2 = InterpolateLinear(a7, b, position);
double b3 = InterpolateLinear(a6, b2, position2);
return(InterpolateLinear(a4, b3, position3));
}
/// <summary>
/// Initializes a new instance of Perlin.
/// </summary>
/// <param name="frequency">The frequency of the first octave.</param>
/// <param name="lacunarity">The lacunarity of the perlin noise.</param>
/// <param name="persistence">The persistence of the perlin noise.</param>
/// <param name="octaves">The number of octaves of the perlin noise.</param>
/// <param name="seed">The seed of the perlin noise.</param>
/// <param name="quality">The quality of the perlin noise.</param>
public Perlin(double frequency, double lacunarity, double persistence, int octaves, int seed,
QualityMode quality)
: base(frequency, lacunarity, persistence, octaves, seed, quality)
{
}
//sam
public RidgedMultifractal(double frequency, double lacunarity, int octaves, int seed, QualityMode quality, int tid)
: this(frequency, lacunarity, octaves, seed, quality)
{
textID = tid;
}
