/// <summary>
/// Creates a new random number generator of type Type
/// </summary>
/// <param name="Type">Generator type</param>
public CudaRandHost(GeneratorType Type)
{
_generator = new CurandGenerator();
_status = CudaRandNativeMethods.curandCreateGeneratorHost(ref _generator, Type);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "curandCreateGeneratorHost", _status));
if (_status != CurandStatus.Success) throw new CudaRandException(_status);
}
public void init(Hashtable attributeHash, GeneratorType type, Hashtable characterHash, int time)
{
this.type = type;
this.attributeHash = attributeHash;
this.radius = (int)(this.attributeHash["AOERadius"]);
this.hpMax = time;
this.hp = this.hpMax;
this.characterHash = characterHash;
if(this.type == GeneratorType.LifeGenerator)
{
this.per = (int)((Effect)this.attributeHash["hp"]).num;
startAddCharaterHp();
}
else if(this.type == GeneratorType.ShieldGenerator)
{
this.per = (int)((Effect)this.attributeHash["def_PHY"]).num;
}
if (null != lightRange){
lightRange.transform.localScale *= this.radius/100;
}
hpBar.initBar(this.hpMax);
startAutoConsumeTime();
// startRotationImage();
this.isEnabled = true;
}
public IChunkGenerator GetNewGenerator(GeneratorType type, long seed)
{
switch(type)
{
case GeneratorType.Custom: return new CustomChunkGenerator(_World, seed);
default: return new CustomChunkGenerator(_World, seed);
}
}
/// <summary>
/// Creates random generator of given type.
/// </summary>
/// <param name="generator">
/// Generator type.
/// </param>
/// <returns>
/// Random numbers generator.
/// </returns>
/// <exception cref="ArgumentException">
/// Thrown if generator type is unknown.
/// </exception>
public static IGenerator Create(GeneratorType generator)
{
switch (generator)
{
case GeneratorType.SimpleGenerator:
return new SimpleGenerator();
default:
throw new ArgumentException("This type of generator does not registered in system", "generator");
}
}
public generator_params(GeneratorType iGeneratorType, double fGeneratorParamFirst, double fGeneratorParamSecond)
{
InitializeComponent();
Z_comboBox.SelectedIndex = (int)iGeneratorType;
//Z_param1_label.Text = "a";
//Z_param2_label.Text = "b";
Z_param1_textBox.Text = fGeneratorParamFirst.ToString();
Z_param2_textBox.Text = fGeneratorParamSecond.ToString();
fGeneratorParamFirst_BASE = fGeneratorParamFirst;
fGeneratorParamSecond_BASE = fGeneratorParamSecond;
}
public GeneratorData(GeneratorJsonData data, GeneratorType type)
{
this.Id = data.id;
this.Name = data.name;
this.BaseCost = data.baseCost;
this.IncrementFactor = data.incrementFactor;
this.BaseGeneration = data.baseGeneration;
this.TimeToGenerate = data.timeToGenerate;
//this.CoinPrice = data.coinPrice;
this.EnhancePrice = data.enhancePrice;
this.ProfitIncrementFactor = data.profitIncrementFactor;
this.ManagerIconId = data.managerIcon;
this.Type = type;
}
/// <summary>
/// Generates a maze and returns it as two-dimensional array
/// </summary>
/// <param name="xSize">Width = X-size * 2 + 1</param>
/// <param name="ySize">Height = Y-size * 2 + 1</param>
/// <param name="generatorType">Type of generator. Possible variants: Latest, Random, LatestAndRandom,
/// LatestOverRandom, RandomOverLatest, Oldest, OldestAndNewest, OldestAndRandom</param>
/// <param name="cavernRate">Cavern frequency. How much caverns will be on map. It's making maze non-perfect. </param>
/// <param name="startCellX">CreateWorld cell for mazegen algorithm X. Null for Random.</param>
/// <param name="startCellY">CreateWorld cell for mazegen algorithm Y. Null for Random.</param>
/// <returns></returns>
public MazeGenParams(ushort xSize = 5, ushort ySize = 5, GeneratorType generatorType = GeneratorType.LatestOverRandom,
ushort cavernRate = 30, ushort?startCellX = null, ushort?startCellY = null)
{
if (xSize > MazeConfig.MazeMaxSize)
{
xSize = MazeConfig.MazeMaxSize;
}
if (ySize > MazeConfig.MazeMaxSize)
{
ySize = MazeConfig.MazeMaxSize;
}
if (xSize < MazeConfig.MazeMinSize)
{
xSize = MazeConfig.MazeMinSize;
}
if (ySize < MazeConfig.MazeMinSize)
{
ySize = MazeConfig.MazeMinSize;
}
XSize = xSize;
YSize = ySize;
GeneratorType = generatorType;
if (cavernRate > MazeConfig.MazeMaxCavernRate)
{
cavernRate = MazeConfig.MazeMaxCavernRate;
}
if (cavernRate < MazeConfig.MazeMinCavernRate)
{
cavernRate = MazeConfig.MazeMinCavernRate;
}
CavernRate = cavernRate;
StartCellX = startCellX;
StartCellY = startCellY;
// formula: (x * y - 2) ^ 0.67
var maxP = Convert.ToUInt16(Math.Pow(XSize * YSize - 1, 2 / 3f));
if (maxP > byte.MaxValue)
{
maxP = byte.MaxValue;
}
MaxPlayers = (byte)maxP;
}
public override void Read(PackFileDeserializer des, BinaryReaderEx br)
{
base.Read(des, br);
m_userData = br.ReadUInt64();
m_lazyRecomputeDisplacementThreshold = br.ReadSingle();
m_type = (GeneratorType)br.ReadByte();
m_forceGenerateOntoPpu = br.ReadByte();
br.ReadUInt16();
m_materialId = br.ReadInt32();
br.ReadUInt32();
m_cachedSilhouettes = des.ReadClassPointer <hkaiConvexSilhouetteSet>(br);
m_transform = new hkQTransform();
m_transform.Read(des, br);
}
public static string description(this GeneratorType type)
{
switch (type)
{
case GeneratorType.ATOMIC: return("Генератор на атомар-\nном принципе");
case GeneratorType.PLASMA: return("Генератор на плаз-\nменном принципе");
case GeneratorType.MULTYPHASE: return("Генератор на мульти-\nфазном принципе");
case GeneratorType.TUNNEL: return("Генератор на туне-\nльном принципе");
default: return("Неизвестный тип генератора");
}
}
public static int cost(this GeneratorType type)
{
switch (type)
{
case GeneratorType.ATOMIC: return(100);
case GeneratorType.PLASMA: return(200);
case GeneratorType.MULTYPHASE: return(300);
case GeneratorType.TUNNEL: return(400);
default: return(0);
}
}
public static float volume(this GeneratorType type)
{
switch (type)
{
case GeneratorType.ATOMIC: return(1);
case GeneratorType.PLASMA: return(1);
case GeneratorType.MULTYPHASE: return(1);
case GeneratorType.TUNNEL: return(1);
default: return(0);
}
}
public static string name(this GeneratorType type)
{
switch (type)
{
case GeneratorType.ATOMIC: return("Атомарный генератор");
case GeneratorType.PLASMA: return("Плазменный генератор");
case GeneratorType.MULTYPHASE: return("Мультифазный генератор");
case GeneratorType.TUNNEL: return("Тунельный генератор");
default: return("Неизвестный тип генератора");
}
}
public T Generate <T>(GeneratorType generatorType, int max)
{
if (max == 0)
{
new ArgumentNullException("max cannot be zero");
}
if (generatorType == GeneratorType.Integer)
{
return((T)(object)new Integers.Randomizer(random).Generate(0, max));
}
else
{
return((T)(object)new Strings.Randomizer(random).Generate(Strings.RandomizerType.Alphabetic, max));
}
}
public EditHtmlTemplate(GeneratorType type, string moduleName, string moduleUIName)
{
this.Type = type;
this.moduleName = moduleName;
this.moduleUIName = moduleUIName;
string attrValueTitle = type.Type.GetAttributeValue((TitleAttribute ta) => ta.Title);
this.title = $"{attrValueTitle}";
var properties = type.Type.GetProperties();
editableProperties = properties.Where(pi => pi.CustomAttributes.Any(ca => ca.AttributeType == typeof(DisplayAttribute))).ToArray();
collectionProperties = properties.Where(pi => IsCollection(pi.PropertyType)).ToArray();
}
public ListHtmlTemplate(GeneratorType type, string moduleName, string moduleUIName)
{
this.type = type;
this.moduleName = moduleName;
this.moduleUIName = moduleUIName;
string attrValueTitle = type.Type.GetAttributeValue((TitleAttribute ta) => ta.Title);
this.title = attrValueTitle;
searchProperty = getNamedArgument <DisplayAttribute>(type.Type.GetProperties().FirstOrDefault(pi => pi.CustomAttributes.Any(ca => ca.AttributeType == typeof(SearchPropertyAttribute))));
listableProperties = type.Type.GetProperties().Where(pi => pi.CustomAttributes.Any(ca => ca.AttributeType == typeof(DisplayAttribute))).ToArray();
}
public static Sprite getGeneratorSprite(GeneratorType type)
{
switch (type)
{
case GeneratorType.ATOMIC: return(generators[0]);
case GeneratorType.PLASMA: return(generators[1]);
case GeneratorType.MULTYPHASE: return(generators[2]);
case GeneratorType.TUNNEL: return(generators[3]);
default: Debug.Log("Unknown generator type: " + type); return(null);
}
}
public static TerrainGenerator makeTG(ScriptableObject opt, GeneratorType type)
{
if (type == GeneratorType.Bounds)
{
return(new BoundsGen(opt as BoundsGenOpt));
}
else if (type == GeneratorType.GeomRidge)
{
return(new GeomRidgeGen(opt as GeomRidgeGenOpt));
}
else if (type == GeneratorType.Normalise)
{
return(new Normalise());
}
else if (type == GeneratorType.Ridge)
{
return(new RidgeGenerator(opt as RidgeGenOpt));
}
else if (type == GeneratorType.SmoothGeometric)
{
return(new SmoothGeometric(opt as SmoothGeomOpt));
}
else if (type == GeneratorType.YTransform)
{
return(new YTransformGen(opt as YTransformOpt));
}
else if (type == GeneratorType.MultiplyConform)
{
return(new MultiplyConform(opt as MultiplyConformOpt));
}
else if (type == GeneratorType.AddConform)
{
return(new AddConform(opt as AddConformOpt));
}
else if (type == GeneratorType.SmoothStretch)
{
return(new SmoothStretchGen(opt as SmoothStrechOpt));
}
else if (type == GeneratorType.RidgeStretch)
{
return(new RidgeStretchGen(opt as RidgeStretchOpt));
}
Debug.Log("something has gone very wrong");
throw new System.Exception("unknown generator type");
//return null;
}
public static NodeBase createNewGenerate(GeneratorType t)
{
NodeBase rlt = null;
if (t == GeneratorType.Const_Value)
{
rlt = new NodeConst();
}
else if (t == GeneratorType.Noise)
{
rlt = new NodePerlin();
}
rlt.initInput();
rlt.guid = Guid.NewGuid().ToString();
return(rlt);
}
private ITeamGenerator SelectGeneratorByGeneratorType(GeneratorType type)
{
ITeamGenerator generator = null;
switch (type)
{
case GeneratorType.Random:
generator = new TeamGenerator();
break;
case GeneratorType.Manual:
case GeneratorType.None:
break;
}
return(generator);
}
public static string GenerateRndString(int uzunluk = 4, GeneratorType generatorType = GeneratorType.AllowAll)
{
Random Rnd = new Random();
StringBuilder stringBuilder = new StringBuilder();
int totalwritten = 0;
while (totalwritten < uzunluk)
{
int skey = Rnd.Next(48, 122);
if (skey == 94 || skey == 96)
{
skey++;
}
if (!char.IsLetterOrDigit((char)skey))
{
continue;
}
if (generatorType != GeneratorType.AllowAll)
{
if ((generatorType & GeneratorType.AllowNumeric) == 0)
{
if (char.IsDigit((char)skey))
{
continue;
}
}
if ((generatorType & GeneratorType.AllowUpperCaseChar) == 0)
{
if (char.IsUpper((char)skey))
{
continue;
}
}
if ((generatorType & GeneratorType.AllowLowerCaseChar) == 0)
{
if (char.IsLower((char)skey))
{
continue;
}
}
}
stringBuilder.Append(((char)skey));
totalwritten++;
}
return(stringBuilder.ToString());
}
public void AddGenerator(GeneratorType Type)
{
if ((Type & GeneratorType.Alpha) != 0)
{
Generators.Add(GenerateAlpha);
}
if ((Type & GeneratorType.Numeric) != 0)
{
Generators.Add(GenerateNumber);
}
if ((Type & GeneratorType.Symbols) != 0)
{
Generators.Add(GenerateSymbol);
}
}
public static IIDGenerator Create(GeneratorType type)
{
IIDGenerator generator = null;
switch (type)
{
case GeneratorType.GUID:
generator = new GUIDGenerator();
break;
case GeneratorType.SnowFlak:
generator = new SnowFlakGenerator();
break;
}
return(generator);
}
public DynamicMethodDefinition(MethodBase method, Func <AssemblyName, ModuleDefinition> moduleGen = null)
{
string type = Environment.GetEnvironmentVariable("MONOMOD_DMD_TYPE");
if (!string.IsNullOrEmpty(type))
{
try {
// TryGet is unavailable.
Generator = (GeneratorType)Enum.Parse(typeof(GeneratorType), type, true);
} catch {
}
}
Debug = Environment.GetEnvironmentVariable("MONOMOD_DMD_DEBUG") == "1";
Method = method ?? throw new ArgumentNullException(nameof(method));
Reload(moduleGen);
}
private static AbstractGenerator.AbstractGenerator GetGenerator(GeneratorType generatorType)
{
switch (generatorType)
{
case GeneratorType.JMeter:
return(new JMeterGenerator.JMeterGenerator());
case GeneratorType.OpenSTA:
return(new OpenSTAGenerator());
case GeneratorType.Testing:
return(new TestingGenerator.TestingGenerator());
default:
throw new NotImplementedException("GeneratorType is not implemented: " + generatorType);
}
}
public void initWindow(int id, DeleteFunc funDel, SelectFunc funSel)
{
winID = id;
funDelete = funDel;
funSelect = funSel;
rect = new Rect(0, 0, 128, 128 + 16);
rect.Set(pos.x, pos.y, rect.width, rect.height);
tex = new Texture2D(1, 1);
tex.SetPixel(0, 0, new Color(1, 1, 1));
generateType = node.value.getGeneratorType();
unaryOperatorType = node.value.getUnaryOperatorType();
binaryOperatorType = node.value.getBinaryOperatorType();
//ternaryOperatorType = node.value.getTernaryOperatorType();
texPort = new Texture2D(1, 1);
texPort.SetPixel(0, 0, new Color(1, 1, 1));
texPort.Apply();
}
public float SetEmissionFactor(GeneratorType generatorType)
{
switch (generatorType)
{
case GeneratorType.Coal:
return(0.30f);
case GeneratorType.Oil:
return(0.25f);
case GeneratorType.Gas:
return(0.25f);
default: //Wind, Solar, Hydro
return(0f);
}
}
private IFakeGenerator getGenerator(GeneratorType type)
{
string typeString = type.ToString();
if (generators.ContainsKey(typeString))
{
return(generators[typeString]);
}
Type systemType = Type.GetType(String.Format("{0}.{1}{2}", "DotNetFaker.Generators", typeString, "Generator"));
IFakeGenerator generator = (IFakeGenerator)Activator.CreateInstance(systemType);
generator.Random = random;
generators.Add(typeString, generator);
return(generators[typeString]);
}
public void Test_Generator_Is_Created()
{
// Arrange
DateTime dtJustBefore = DateTime.Now; System.Threading.Thread.Sleep(100);
// Act
GeneratorType generator = DocumentHelpers.GetDefaultGenerator();
// Pre-Assert Arrange
System.Threading.Thread.Sleep(100); DateTime dtJustAfter = DateTime.Now;
// Assert
Assert.IsNotNull(generator);
Assert.IsTrue((generator.timestamp > dtJustBefore) && (generator.timestamp < dtJustAfter));
Assert.IsFalse(string.IsNullOrEmpty(generator.product_name));
Assert.IsFalse(string.IsNullOrEmpty(generator.product_version));
Assert.IsTrue(generator.schema_version >= (decimal)5.6);
}
public List <T> GenerateList <T>(GeneratorType generatorType, int max)
{
List <T> ts = new List <T>();
if (max == 0)
{
new ArgumentNullException("max cannot be zero");
}
if (generatorType == GeneratorType.Integer)
{
ts.Add((T)(object)new Integers.Randomizer(random).Generate());
}
else
{
ts.Add((T)(object)new Strings.Randomizer(random).Generate());
}
return(ts);
}
int randInRange(int a, int b, GeneratorType generatorType)
{
float val = 0;
switch(generatorType)
{
case GeneratorType.degree:
val = randInRangeDegree ();
break;
case GeneratorType.normal:
val = randInRangeNormal ();
break;
case GeneratorType.perlin:
perlinNoise ();
break;
}
return (int)Mathf.Round ((b - a) * val) + a;
}
public Maze Generate(int x, int y, GeneratorType generatorType)
{
var dimension = new Dimension((ushort)x, (ushort)y);
switch (generatorType)
{
case GeneratorType.RecursiveSplit:
return(new RecursiveSplitMazeGenerator(this.rand, dimension).Generate());
case GeneratorType.Random:
return(new RandomMazeGenerator(this.rand).Generate(dimension));
default:
break;
}
throw new NotImplementedException();
}
public void Append(IEnumerable <GeneratorData> generators, GeneratorType type)
{
if (IsLoaded)
{
foreach (var gen in generators)
{
//GeneratorData newData = new GeneratorData(jsonData, type);
if (!Generators.ContainsKey(gen.Id))
{
Generators.Add(gen.Id, gen);
}
else
{
throw new UnityException($"Repository already contains generator => {gen.Id}");
}
}
}
}
public static GeneratorData createGeneratorData()
{
GeneratorType type = GeneratorType.ATOMIC;
switch (UnityEngine.Random.Range(0, Enum.GetNames(typeof(GeneratorType)).Length))
{
case 0: type = GeneratorType.ATOMIC; break;
case 1: type = GeneratorType.PLASMA; break;
case 2: type = GeneratorType.MULTYPHASE; break;
case 3: type = GeneratorType.TUNNEL; break;
default: Debug.Log("Unmapped value for generator"); break;
}
return(createGeneratorData(type));
}
public static IHelloWorldGenerator GetHelloWorldGeneratorInstance(GeneratorType type, IMessagePrinter printer)
{
IHelloWorldGenerator generator = null;
switch (type)
{
case GeneratorType.Console:
{
generator = new HelloWorldGeneratorConsole(printer);
break;
}
default:
{
throw new NotImplementedException();
}
}
return(generator);
}
public void ChangeFeedDisplay(GeneratorType _newFeedType)
{
ResetFeed();
whichItemsToPull = _newFeedType;
switch (whichItemsToPull)
{
case GeneratorType.CHALLENGE_FEED:
PullAllChallenges();
FillChallengeFeed();
break;
case GeneratorType.COMPLETED_FEED:
PullCompleted();
FillChallengeFeed();
break;
case GeneratorType.UPCOMING_FEED:
PullUpcoming();
FillChallengeFeed();
break;
case GeneratorType.REWARD_PAGE:
PullRewards();
FillRewardFeed();
break;
case GeneratorType.FEEDBACK_PAGE:
PullFeedback();
FillFeedbackFeed();
break;
case GeneratorType.CHALLENGER_UPCOMING:
PullChallengerUpcoming();
FillChallengerFeed();
break;
case GeneratorType.CHALLENGER_COMPLETED:
PullChallengerCompleted();
FillChallengeFeed();
break;
}
}
private void Init(Entity entity, XmlNode node)
{
this.entity = entity;
if (node != null)
{
type = Parse(Utils.Xml.GetAttrValue(node, "type"));
startWith = Utils.Xml.GetAttrValue(node, "startWith", startWith);
increment = Utils.Xml.GetAttrValue(node, "startWith", increment);
hasMaxValue = Utils.Xml.IsAttrExists(node, "maxValue");
maxValue = Utils.Xml.GetAttrValue(node, "maxValue", maxValue);
persistence = new Persistence(this, node);
}
else
{
persistence = new Persistence(this, entity.Persistence);
}
SetMinMax();
}
public GeneratorManager(GeneratorType type)
{
//这里根据传入的类型进行动态构建
switch (type)
{
case GeneratorType.Pdf:
{
generator = new PdfGenerator();
break;
}
case GeneratorType.Excel:
{
generator = new ExcelGenerator();
break;
}
default:
break;
}
}
public static IList<string[]> Generate(GeneratorType type, IList<NodeFeature> features)
{
IGenerate generator;
switch (type)
{
case GeneratorType.HeaderGenerator:
generator = new HeaderGenerator();
break;
case GeneratorType.CodeBehindGenerator:
generator = new CodeBehindGenerator();
break;
case GeneratorType.StepDefinitionGenerator:
generator = new StepDefinitionGenerator();
break;
default:
throw new NotImplementedException();
}
return generator.Generate(new MSCppUnitTestLanguageConfig(), features);
}
/// <summary>
/// Функция создания генератора заданого типа
/// возвращает интефейс этого генератора
/// </summary>
/// <param name="generatorType"></param>
/// <param name="fA"></param>
/// <param name="fB"></param>
/// <returns></returns>
public static IGen CreateGenerator(GeneratorType generatorType, double fA, double fB)
{
switch (generatorType)
{
case GeneratorType.Uniform:
return new UniformGen(fA, fB);
case GeneratorType.Normal:
return new NormalGen(fA, fB);
case GeneratorType.Rayleigh:
return new RayleighGen(fA);
case GeneratorType.Gamma:
return new GammaGen(fA, fB);
case GeneratorType.Exponential:
return new ExponentialGen(fA);
default:
return new UniformGen(0, 1);
}
}
// -------------------------------------------------------------------------------------------------------- UTILITIES
private void convertIntVarsToEnums()
{
switch (erosionTypeInt) {
case 0:
erosionType = ErosionType.Thermal;
break;
case 1:
erosionType = ErosionType.Hydraulic;
break;
case 2:
erosionType = ErosionType.Tidal;
break;
case 3:
erosionType = ErosionType.Wind;
break;
case 4:
erosionType = ErosionType.Glacial;
break;
}
switch (hydraulicTypeInt) {
case 0:
hydraulicType = HydraulicType.Fast;
break;
case 1:
hydraulicType = HydraulicType.Full;
break;
case 2:
hydraulicType = HydraulicType.Velocity;
break;
}
switch (generatorTypeInt) {
case 0:
generatorType = GeneratorType.Voronoi;
break;
case 1:
generatorType = GeneratorType.DiamondSquare;
break;
case 2:
generatorType = GeneratorType.Perlin;
break;
case 3:
generatorType = GeneratorType.Smooth;
break;
case 4:
generatorType = GeneratorType.Normalise;
break;
}
switch (voronoiTypeInt) {
case 0:
voronoiType = VoronoiType.Linear;
break;
case 1:
voronoiType = VoronoiType.Sine;
break;
case 2:
voronoiType = VoronoiType.Tangent;
break;
}
switch (neighbourhoodInt) {
case 0:
neighbourhood = Neighbourhood.Moore;
break;
case 1:
neighbourhood = Neighbourhood.VonNeumann;
break;
}
}
public void VoronoiGenerator(FeatureType featureType, int cells, float features, float scale, float blend)
{
generatorTypeInt = 0;
generatorType = GeneratorType.Voronoi;
switch (featureType) {
case FeatureType.Mountains:
voronoiTypeInt = 0;
voronoiType = VoronoiType.Linear;
break;
case FeatureType.Hills:
voronoiTypeInt = 1;
voronoiType = VoronoiType.Sine;
break;
case FeatureType.Plateaus:
voronoiTypeInt = 2;
voronoiType = VoronoiType.Tangent;
break;
}
voronoiCells = cells;
voronoiFeatures = features;
voronoiScale = scale;
voronoiBlend = blend;
GeneratorProgressDelegate generatorProgressDelegate = new GeneratorProgressDelegate(dummyGeneratorProgress);
generateTerrain(generatorProgressDelegate);
}
//функция установки параметров генератора
private bool SetGeneratorParameters(ref GeneratorType iGeneratorType, ref double fGeneratorParamFirst, ref double fGeneratorParamSecond)
{
bool bSetResult = false;
//iGeneratorType = 0;
//fGeneratorParamFirst = 0.0;
//fGeneratorParamSecond = 0.0;
using (generator_params generatorForm = new generator_params(iGeneratorType, fGeneratorParamFirst, fGeneratorParamSecond))
{
if (DialogResult.OK == generatorForm.ShowDialog())
{
iGeneratorType = (GeneratorType)generatorForm.Z_comboBox.SelectedIndex;
fGeneratorParamFirst = generatorForm.fGeneratorParamFirst;
fGeneratorParamSecond = generatorForm.fGeneratorParamSecond;
bSetResult = true;
}
}
return bSetResult;
}
public void FractalGenerator(float fractalDelta, float blend)
{
generatorTypeInt = 1;
generatorType = GeneratorType.DiamondSquare;
diamondSquareDelta = fractalDelta;
diamondSquareBlend = blend;
GeneratorProgressDelegate generatorProgressDelegate = new GeneratorProgressDelegate(dummyGeneratorProgress);
generateTerrain(generatorProgressDelegate);
}
public void NormaliseTerrain(float minHeight, float maxHeight, float blend)
{
generatorTypeInt = 4;
generatorType = GeneratorType.Normalise;
normaliseMin = minHeight;
normaliseMax = maxHeight;
normaliseBlend = blend;
GeneratorProgressDelegate generatorProgressDelegate = new GeneratorProgressDelegate(dummyGeneratorProgress);
generateTerrain(generatorProgressDelegate);
}
public IdAttribute(GeneratorType type)
{
GeneratorType = type;
}
public static extern CurandStatus curandCreateGeneratorHost(ref CurandGenerator generator, GeneratorType rng_type);
public void SmoothTerrain(int iterations, float blend)
{
generatorTypeInt = 3;
generatorType = GeneratorType.Smooth;
smoothIterations = iterations;
smoothBlend = blend;
GeneratorProgressDelegate generatorProgressDelegate = new GeneratorProgressDelegate(dummyGeneratorProgress);
generateTerrain(generatorProgressDelegate);
}
public void setVoronoiPreset(voronoiPresetData preset)
{
generatorTypeInt = 0;
generatorType = GeneratorType.Voronoi;
voronoiTypeInt = (int) preset.voronoiType;
voronoiType = preset.voronoiType;
voronoiCells = preset.voronoiCells;
voronoiFeatures = preset.voronoiFeatures;
voronoiScale = preset.voronoiScale;
voronoiBlend = preset.voronoiBlend;
}
public void setPerlinPreset(perlinPresetData preset)
{
generatorTypeInt = 2;
generatorType = GeneratorType.Perlin;
perlinFrequency = preset.perlinFrequency;
perlinAmplitude = preset.perlinAmplitude;
perlinOctaves = preset.perlinOctaves;
perlinBlend = preset.perlinBlend;
}
public void setFractalPreset(fractalPresetData preset)
{
generatorTypeInt = 1;
generatorType = GeneratorType.DiamondSquare;
diamondSquareDelta = preset.diamondSquareDelta;
diamondSquareBlend = preset.diamondSquareBlend;
}
public void PerlinGenerator(int frequency, float amplitude, int octaves, float blend)
{
generatorTypeInt = 2;
generatorType = GeneratorType.Perlin;
perlinFrequency = frequency;
perlinAmplitude = amplitude;
perlinOctaves = octaves;
perlinBlend = blend;
GeneratorProgressDelegate generatorProgressDelegate = new GeneratorProgressDelegate(dummyGeneratorProgress);
generateTerrain(generatorProgressDelegate);
}