public void UpdateSettings(ShapeSettings _settings) { settings = _settings; noiseFilters = new INoiseFilter[settings.noiseLayers.Length]; for (int i = 0; i < noiseFilters.Length; i++) { noiseFilters[i] = NoiseFilterFactory.CreateNoiseFilter(_settings.noiseLayers[i].noiseSettings); } minMaxHeightInPlanet = new MinMaxHeightInPlanet(); }
public PlanetMeshChunkRenderer(Transform _parent, ShapeGenerator _shapeGenerator, ShapeType _shapeType) { if (_shapeGenerator == null) { Debug.LogError("Shape generator is null"); return; } if (_shapeGenerator.shapeSettings == null) { Debug.LogError("Shape generator settings is null"); return; } shapeType = _shapeType; test = GameObject.Find("Render Debug Point"); parent = _parent; shapeGenerator = _shapeGenerator; shapeSettings = _shapeGenerator.shapeSettings; noise = new Noise(); var radius = shapeSettings.radius; var t = (1.0f + Mathf.Sqrt(5.0f)) / 2.0f; // The base vertices that make up a base form icosahedron baseFormVertices = new List <Vector3>() { new Vector3(-1, t, 0).normalized *radius, new Vector3(1, t, 0).normalized *radius, new Vector3(-1, -t, 0).normalized *radius, new Vector3(1, -t, 0).normalized *radius, new Vector3(0, -1, t).normalized *radius, new Vector3(0, 1, t).normalized *radius, new Vector3(0, -1, -t).normalized *radius, new Vector3(0, 1, -t).normalized *radius, new Vector3(t, 0, -1).normalized *radius, new Vector3(t, 0, 1).normalized *radius, new Vector3(-t, 0, -1).normalized *radius, new Vector3(-t, 0, 1).normalized *radius }; chunks = new List <PlanetMeshChunk>(); sphereVertices = new List <Vector3>(); HandleBaseFormFaces(); PlanetMeshChunk.count = 0; }
void Draw() { Shader shader = Shade ? new Shader { ShadeB = 0.05f, ShadeG = 0.03f, ShadeR = 0.03f, LightB = 1f, LightG = 1f, LigtR = 1f, Enabled = true } : new Shader(); int w = (int)SystemParameters.PrimaryScreenWidth; int h = (int)SystemParameters.PrimaryScreenHeight; using (TriangleDrawer g = new TriangleDrawer(w, h)) { openview.Size size = new openview.Size(w, h); g.Lock(); gl.Matrix matrix = transform.Matrix; for (int i = 0; i < planets.Count; i++) { ShapeSettings shapeSettings = planets[i].shapeSettings; Vector3 v = matrix.ApplyTo(shapeSettings.position - transform.position); float x = v.x, y = v.y, z = v.z; float r = shapeSettings.PlanetRadius + shapeSettings.MaxDifference; y += r; bool xCorrect = x > 0 ? x - r <y : x + r> -y; bool zCorrect = z > 0 ? z - r <y : z + r> -y; gl.Transform Applied = transform; Applied.position = Applied.position - shapeSettings.position; //Applied.position = shapeSettings.position- Applied.position; if (y > 0 && xCorrect && zCorrect) { planets[i].Draw(g, Applied, transform.position, DrawOnlyBorders, size, precision, 1000 / precision, shader, zoom); } } if (DrawCockpit) { g.DrawImage(cockpit, 255); } if (MotionBlur) { if (LastDraw != null) { g.DrawImage(LastDraw, 128); } LastDraw = g.Unlock(); Background = new ImageBrush(LastDraw); } else { Background = new ImageBrush(g.Unlock()); } Title = g.elapsed.ToString(); } }
public void UpdateSettings(ShapeSettings settings) { this.settings = settings; INoiseFilter[] oldFilters = noiseFilters; noiseFilters = new INoiseFilter[settings.noiseLayers.Length]; for (int i = 0; i < noiseFilters.Length; i++) { int seed = oldFilters != null? oldFilters[i] != null? oldFilters[i].GetSeed() : 0 : 0; noiseFilters[i] = NoiseFilterFactory.CreateNoisefilter(settings.noiseLayers[i].noiseSettings, seed); } elevationMinMax = new MinMax(); }
public ShapeGenerator(ShapeSettings _settings, int _seed) { settings = _settings; noiseFilters = new NoiseFilter[_settings.shapeNoiseLayers.Length]; for (var i = 0; i < noiseFilters.Length; i++) { noiseFilters[i] = new NoiseFilter(_settings.shapeNoiseLayers[i].noiseSettings, _seed); } elevationMinMax = new MinMax(); }
public void updateSettings(ShapeSettings settings) { if (settings != null) { this.settings = settings; noiseFilters = new INoiseFilter[settings.noiseLayers.Length]; for (int i = 0; i < noiseFilters.Length; i++) { noiseFilters[i] = NoiseFilterFactory.createNoiseFilter(settings.noiseLayers[i].noiseSettings); } elevationMinMax = new MinMax(); } }
public AABB GetShapeBounds(Quaternion rotation) { if (editMode == EditMode.ExtrudeShape || editMode == EditMode.EditShape) { return(settings.bounds); } var bounds = ShapeSettings.CalculateBounds(rotation, gridTangent, gridBinormal); if (settings.vertices.Length < 3) { bounds.Extend(rotation * worldPosition); } return(bounds); }
public void UpdateSettings(ShapeSettings settings) { this.settings = settings; // Initialize noiseFilters array of noise filters noiseFilters = new INoiseFilter[settings.noiseLayers.Length]; // Populate noiseFilters array for (int i = 0; i < noiseFilters.Length; i++) { noiseFilters[i] = NoiseFilterFactory.CreateNoiseFilter(settings.noiseLayers[i].noiseSettings);//new SimpleNoiseFilter(settings.noiseLayers[i].noiseSettings); // new noise filter with settings } // Generate elevationMinMax elevationMinMax = new MinMax(); }
void Initialize() { colorSettings = (ColorSettings)ScriptableObject.CreateInstance("ColorSettings"); colorSettings.InitColorSettings(new Material(shader), BiomeCount); shapeSettings = (ShapeSettings)ScriptableObject.CreateInstance("ShapeSettings"); shapeSettings.InitShapeSettings(NoiseLayerCount, PlanetRadius); shapeGenerator.UpdateSettings(shapeSettings); colorGenerator.UpdateSettings(colorSettings); if (meshFilters == null || meshFilters.Length == 0) { meshFilters = new MeshFilter[6]; } if (meshColliders == null || meshColliders.Length == 0) { meshColliders = new MeshCollider[6]; } terrainFaces = new TerrainFace[6]; Vector3[] directions = { Vector3.up, Vector3.down, Vector3.left, Vector3.right, Vector3.forward, Vector3.back }; if (transform != null) { for (int i = 0; i < 6; i++) { if (meshFilters[i] == null) { GameObject meshObj = new GameObject("Face " + FaceNames[i]); meshObj.transform.parent = transform; meshObj.transform.localPosition = Vector3.zero; meshObj.AddComponent <MeshRenderer>(); meshFilters[i] = meshObj.AddComponent <MeshFilter>(); meshColliders[i] = meshObj.AddComponent <MeshCollider>(); meshColliders[i].convex = true; } if (meshFilters[i].sharedMesh == null) { meshFilters[i].sharedMesh = new Mesh(); } meshFilters[i].GetComponent <MeshRenderer>().sharedMaterial = colorSettings.planetMaterial; terrainFaces[i] = new TerrainFace(shapeGenerator, meshFilters[i].sharedMesh, meshColliders[i], resolution, directions[i]); bool renderFace = faceRenderMask == FaceRenderMask.All || (int)faceRenderMask - 1 == i; meshFilters[i].gameObject.SetActive(renderFace); } } }
public void UpdateSettings(ShapeSettings shapeSettings) { this.settings = shapeSettings; if (settings.noiseLayers != null) { simpleNoiseFilters = new iNoiseFilter[settings.noiseLayers.Length];//SimpleNoiseFilter(settings.noiseSettings); for (int i = 0; i < simpleNoiseFilters.Length; i++) { simpleNoiseFilters[i] = NoiseFilterFactory.CreateNoiseFilter(settings.noiseLayers[i].noiseSettings); } } else { Debug.Log("Error in shapeGenerator: no noiseLayers found!"); } elevationMinMax = new MinMax(); }
public static ShapeSettings CopyShapeSettings() { ShapeSettings newSettings = (ShapeSettings)ScriptableObject.CreateInstance("ShapeSettings"); newSettings.noiseLayers = new ShapeSettings.NoiseLayer[2]; for (int i = 0; i < newSettings.noiseLayers.Length; i++) { newSettings.noiseLayers[i] = new ShapeSettings.NoiseLayer(); newSettings.noiseLayers[i].noiseSettings = new NoiseSettings(); } newSettings.noiseLayers[0].noiseSettings.filterType = NoiseSettings.FilterType.Rigid; // set stadard values for landmass noise newSettings.noiseLayers[1].noiseSettings.filterType = NoiseSettings.FilterType.LandMass; newSettings.noiseLayers[1].noiseSettings.amplitude = 0.1f; return(newSettings); }
// Update is called once per frame void Update() { origin = originController.GetOrigin(); Vector3 clamp; ShapeSettings settings = originController.objects[0].GetComponent <Planet>().shapeSettings; ShapeGenerator temp = new ShapeGenerator(); temp.UpdateSettings(settings); for (int i = 0; i < 25; i++) { Vector3 offset = Quaternion.LookRotation(-transform.position, transform.up) * new Vector3((i % size) * 40, Mathf.Floor(i / size) * 40, 0); buildings[i].transform.position = origin + transform.position * 10000 + offset; clamp = origin + (Quaternion.LookRotation(origin - buildings[i].transform.position) * new Vector3(0, 0, -100010)) * temp.GetScaledElevation(temp.CalculateUnscaledElevation(Quaternion.LookRotation(origin - buildings[i].transform.position) * new Vector3(0, 0, -1))); buildings[i].transform.position = clamp; } }
private void FixedUpdate() { gameController.MoveCam(); //print(Vector3.Distance(playerCam.transform.position, origin)); ShapeSettings settings = objects[0].GetComponent <Planet>().shapeSettings; ShapeGenerator temp = new ShapeGenerator(); temp.UpdateSettings(settings); Vector3 clamp = Vector3.zero; /*if (Vector3.Distance(playerCam.transform.position, origin) < ((Quaternion.LookRotation(playerCam.transform.position - origin, Vector3.up) * new Vector3(0, 0, 100000 * 1.00005F)) * temp.GetScaledElevation(temp.CalculateUnscaledElevation((Quaternion.LookRotation(playerCam.transform.position - origin, Vector3.up) * new Vector3(0, 0, 1))))).magnitude-1) * { * clamp = origin + (Quaternion.LookRotation(playerCam.transform.position - origin, Vector3.up) * new Vector3(0, 0, 100000 * 1.00005F)) * temp.GetScaledElevation(temp.CalculateUnscaledElevation((Quaternion.LookRotation(playerCam.transform.position - origin, Vector3.up) * new Vector3(0, 0, 1)))); * } * else * { * clamp = playerCam.transform.position; * } * playerCam.transform.position = clamp;// */ }
protected virtual bool StartEditMode(Camera camera) { if (editMode == EditMode.EditShape || editMode == EditMode.ExtrudeShape) { return(false); } Undo.RecordObject(this, "Created shape"); if (GUIUtility.hotControl == shapeId) { GUIUtility.hotControl = 0; GUIUtility.keyboardControl = 0; EditorGUIUtility.SetWantsMouseJumping(0); EditorGUIUtility.editingTextField = false; } CalculateWorldSpaceTangents(camera); brushPosition = buildPlane.Project(ShapeSettings.GetCenter(buildPlane)); editMode = EditMode.EditShape; CSGPlane newPlane = buildPlane; ShapeSettings.CalculatePlane(ref newPlane); if (newPlane.normal.sqrMagnitude != 0) { buildPlane = newPlane; } if (ModelTraits.IsModelEditable(geometryModel)) { SelectionUtility.LastUsedModel = geometryModel; } UpdateBaseShape(); //StartExtrudeMode(); //GrabHeightHandle(ignoreFirstMouseUp: true); return(true); }
public ShapeGenerator(ShapeSettings settings, Interactor interaction, CraterGenerator craterGenerator) { this.settings = settings; noiseFilters = new NoiseInterface[settings.noiseLayers.Length]; this.interaction = interaction; this.masks = new List <Dictionary <string, float> >(); //this.masks.Add(DataChanger.arraysToDict(maskKeys, maskValues)); this.maskKeys = new List <string>(); this.maskValues = new List <float>(); for (int i = 0; i < noiseFilters.Length; i++) { masks.Add(new Dictionary <string, float>()); noiseFilters[i] = NoiseFactory.createNoiseFilter(settings.noiseLayers[i].noiseSettings); } elevationMinMax = new MinMax(); this.craterGenerator = craterGenerator; settings.zeroLvlIsOcean = true; }
public ShapeGenerator(ShapeSettings settings) { this.settings = settings; }
// Constructor public PlanetShapeGenerator(ShapeSettings shapeSettings) { this.settings = shapeSettings; }
// Start is called before the first frame update void Start() { if (!_errorText) { throw new Exception("You must define an error message text !"); } _errorText.enabled = false; _IsOrbit = true; if (!ListeAstreDontDestroyOnLoad) { ListeAstreDontDestroyOnLoad = GameObject.Find("DontDestroyOnLoad").GetComponent <ListAstre>(); } for (int i = 0; i < transform.childCount; i++) { if (transform.GetChild(i).name == "PanelPlanetSetting") { _PanelPlanetSetting = transform.GetChild(i); } if (transform.GetChild(i).name == "PanelListAstreInSolarSystem") { _PanelListAstreInSolarSystem = transform.GetChild(i); } } for (int i = 0; i < _PanelPlanetSetting.childCount; i++) { if (_PanelPlanetSetting.GetChild(i).name == "Name") { _NameInputField = _PanelPlanetSetting.GetChild(i).GetComponent <InputField>(); } if (_PanelPlanetSetting.GetChild(i).name == "Resolution") { _ResolutionInputField = _PanelPlanetSetting.GetChild(i).GetComponent <InputField>(); } if (_PanelPlanetSetting.GetChild(i).name == "Radius") { _RadiusInputField = _PanelPlanetSetting.GetChild(i).GetComponent <InputField>(); } if (_PanelPlanetSetting.GetChild(i).name == "Impulsion") { _ImpulsionInputField = _PanelPlanetSetting.GetChild(i).GetComponent <InputField>(); } if (_PanelPlanetSetting.GetChild(i).name == "Distance") { _DistInputField = _PanelPlanetSetting.GetChild(i).GetComponent <InputField>(); } if (_PanelPlanetSetting.GetChild(i).name == "AddAstre") { _AddAstre = _PanelPlanetSetting.GetChild(i).GetComponent <Button>(); } if (_PanelPlanetSetting.GetChild(i).name == "ShapeSetting") { _ShapeSettingDropDown = _PanelPlanetSetting.GetChild(i).GetComponent <Dropdown>(); } if (_PanelPlanetSetting.GetChild(i).name == "ColourSetting") { _ColorSettingDropDown = _PanelPlanetSetting.GetChild(i).GetComponent <Dropdown>(); } } for (int i = 0; i < _PanelListAstreInSolarSystem.childCount; i++) { if (_PanelListAstreInSolarSystem.GetChild(i).name == "ListeOfAstres") { _ListeOfAstreText = _PanelListAstreInSolarSystem.GetChild(i).GetComponent <Text>(); } } _NameInputField.onEndEdit.AddListener(delegate { setName(); }); _ResolutionInputField.onEndEdit.AddListener(delegate { setResolution(); }); _RadiusInputField.onEndEdit.AddListener(delegate { setRadius(); }); _ImpulsionInputField.onEndEdit.AddListener(delegate { setImpulsion(); }); _DistInputField.onEndEdit.AddListener(delegate { setDistance(); }); _AddAstre.onClick.AddListener(delegate { AddAstre(); }); List <string> namesshapes = new List <string>(); namesshapes.Add("EarthShape"); namesshapes.Add("MarsShape"); namesshapes.Add("VenusShape"); _ShapeSettingDropDown.options.Clear(); _ShapeSettingDropDown.AddOptions(namesshapes); _ShapeSetting = Resources.Load("Script/Shapes/" + _ShapeSettingDropDown.options[_ShapeSettingDropDown.value].text, typeof(ShapeSettings)) as ShapeSettings; _ShapeSettingDropDown.onValueChanged.AddListener(delegate { setShape(); }); List <string> namescolors = new List <string>(); namescolors.Add("EarthColor"); namescolors.Add("MarsColor"); namescolors.Add("VenusColor"); _ColorSettingDropDown.options.Clear(); _ColorSettingDropDown.AddOptions(namescolors); _ColorSetting = Resources.Load("Script/Colors/" + _ColorSettingDropDown.options[_ColorSettingDropDown.value].text, typeof(ColourSettings)) as ColourSettings; _ColorSettingDropDown.onValueChanged.AddListener(delegate { setColor(); }); }
void setShape() { _ShapeSetting = (Resources.Load("Script/Shapes/" + _ShapeSettingDropDown.options[_ShapeSettingDropDown.value].text, typeof(ShapeSettings)) as ShapeSettings); }
public void RegenerateShape() { ShapeSettings settings = ScriptableObject.CreateInstance("ShapeSettings") as ShapeSettings; float planetRadius = Random.Range(g.planetRadiusMin, g.planetRadiusMax); float minValue = Random.Range(g.seaLevelMin, g.seaLevelMax); int numLayers = Random.Range(g.minNoiseLayers, g.maxNoiseLayers); float strength = Random.Range(g.strengthMin, g.strengthMax); float roughness = Random.Range(g.roughnessMin, g.roughnessMax); float persistance = Random.Range(g.persistanceMin, g.persistanceMax); float baseRoughness = Random.Range(g.baseRoughnessMin, g.baseRoughnessMax); settings.planetRadius = planetRadius; int numFilters = Random.Range(g.minNoiseFilters, g.maxNoiseFilters); int numRigidNoiseFilters = Random.Range(g.minRigidNoiseFilters, g.maxRigidNoiseFilters); if (numRigidNoiseFilters >= numFilters) { numRigidNoiseFilters = numFilters - 1; } settings.noiseLayers = new ShapeSettings.NoiseLayer[numFilters]; for (int i = 0; i < numFilters; i++) { settings.noiseLayers[i] = new ShapeSettings.NoiseLayer(); settings.noiseLayers[i].noiseSettings = new NoiseSettings(); } settings.noiseLayers[0].noiseSettings.simpleNoiseSettings = new NoiseSettings.SimpleNoiseSettings(); settings.noiseLayers[0].noiseSettings.filterType = NoiseSettings.FilterType.Simple; settings.noiseLayers[0].noiseSettings.simpleNoiseSettings.numLayers = numLayers; settings.noiseLayers[0].noiseSettings.simpleNoiseSettings.strength = strength; settings.noiseLayers[0].noiseSettings.simpleNoiseSettings.roughness = roughness; settings.noiseLayers[0].noiseSettings.simpleNoiseSettings.persistance = persistance; settings.noiseLayers[0].noiseSettings.simpleNoiseSettings.baseRoughness = baseRoughness; settings.noiseLayers[0].noiseSettings.simpleNoiseSettings.minValue = minValue; settings.noiseLayers[0].noiseSettings.simpleNoiseSettings.seed = seed; settings.noiseLayers[0].enabled = true; for (int i = 1; i < numFilters; i++) { numLayers = Random.Range(g.minNoiseLayers, g.maxNoiseLayers); strength = Random.Range(g.strengthMin, g.strengthMax); roughness = Random.Range(g.roughnessMin, g.roughnessMax); persistance = Random.Range(g.persistanceMin, g.persistanceMax); baseRoughness = Random.Range(g.baseRoughnessMin, g.baseRoughnessMax); if (i < numFilters - numRigidNoiseFilters) { settings.noiseLayers[i].noiseSettings.simpleNoiseSettings = new NoiseSettings.SimpleNoiseSettings(); settings.noiseLayers[i].noiseSettings.filterType = NoiseSettings.FilterType.Simple; settings.noiseLayers[i].noiseSettings.simpleNoiseSettings.numLayers = numLayers; settings.noiseLayers[i].noiseSettings.simpleNoiseSettings.strength = strength; settings.noiseLayers[i].noiseSettings.simpleNoiseSettings.roughness = roughness; settings.noiseLayers[i].noiseSettings.simpleNoiseSettings.persistance = persistance; settings.noiseLayers[i].noiseSettings.simpleNoiseSettings.baseRoughness = baseRoughness; settings.noiseLayers[i].noiseSettings.simpleNoiseSettings.minValue = 0; settings.noiseLayers[i].noiseSettings.simpleNoiseSettings.seed = seed; } else { settings.noiseLayers[i].noiseSettings.rigidNoiseSettings = new NoiseSettings.RigidNoiseSettings(); settings.noiseLayers[i].noiseSettings.filterType = NoiseSettings.FilterType.Rigid; settings.noiseLayers[i].noiseSettings.rigidNoiseSettings.numLayers = numLayers; settings.noiseLayers[i].noiseSettings.rigidNoiseSettings.strength = strength; settings.noiseLayers[i].noiseSettings.rigidNoiseSettings.roughness = roughness; settings.noiseLayers[i].noiseSettings.rigidNoiseSettings.persistance = persistance; settings.noiseLayers[i].noiseSettings.rigidNoiseSettings.baseRoughness = baseRoughness; settings.noiseLayers[i].noiseSettings.rigidNoiseSettings.minValue = 0; settings.noiseLayers[i].noiseSettings.rigidNoiseSettings.seed = seed; settings.noiseLayers[i].noiseSettings.rigidNoiseSettings.weightMultiplier = Random.Range(g.weightMultiplierMin, g.weightMultiplierMax); } settings.noiseLayers[i].enabled = true; settings.noiseLayers[i].useFirstLayerAsMask = true; } planet.shapeSettings = settings; }
// ********************************************************************** // public ShapeSettings RandomizeShapeSettings(ShapeSettings settings, ShapeSamplingStatistics shapeSampleStats) { // Planet physical shape settings settings.planetRadius = 1f; settings.mountainHeightLevel = shapeSampleStats.mountainHeightLevel; settings.mountainRoughnessLevel = shapeSampleStats.mountainRoughnessLevel; for (int i = 0; i < settings.noiseLayers.Length; i++) { ShapeSettings.NoiseLayer noiseLayer = settings.noiseLayers[i]; noiseLayer.enabled = true; noiseLayer.useFirstLayerAsMask = true; // ***HRS these are for playing with so that we are modifying values in reasonable-looking ranges across the features that we want switch (noiseLayer.noiseSettings.filterType) { case NoiseSettings.FilterType.Simple: // constant feature values noiseLayer.noiseSettings.simpleNoiseSettings.persistence = 0.6f; // keep this fixed around .5f noiseLayer.noiseSettings.simpleNoiseSettings.minValue = 0.95f; // keep this fixed around .95f, because the height-based colours start f*****g up noiseLayer.noiseSettings.simpleNoiseSettings.numLayers = 4; // variable feature values if (shapeSampleStats.setMean) { // note that these will appear weird if they take on negative values, so be aware of that. We dont want to truncate at 0 though because then we effectively limit the variability. mountainHeight = GaussianRandom(shapeSampleStats.meanStrength, shapeSampleStats.stdStrength) * (i + 1); mountainRoughness = GaussianRandom(shapeSampleStats.meanBaseRoughness, shapeSampleStats.stdBaseRoughness) * (i + 1); // we may want to keep this one fixed around 1f noiseLayer.noiseSettings.simpleNoiseSettings.strength = mountainHeight; noiseLayer.noiseSettings.simpleNoiseSettings.baseRoughness = mountainRoughness; } else { noiseLayer.noiseSettings.simpleNoiseSettings.strength = RandomNumberInRange(0.01f, 0.3f) * (i + 1); noiseLayer.noiseSettings.simpleNoiseSettings.baseRoughness = RandomNumberInRange(0.7f, 1.1f) * (i + 1); // we may want to keep this one fixed around 1f } noiseLayer.noiseSettings.simpleNoiseSettings.roughness = 2.2f; // RandomNumberInRange(1f, 3.0f); // looks nice around 2.2f // change the position of the noise on the planet (almost the same as creating new noise object, if we do this for each layer independently its fine noiseLayer.noiseSettings.simpleNoiseSettings.centre.x = RandomNumberInRange(-.5f, .5f); noiseLayer.noiseSettings.simpleNoiseSettings.centre.y = RandomNumberInRange(-.5f, .5f); noiseLayer.noiseSettings.simpleNoiseSettings.centre.z = RandomNumberInRange(-.5f, .5f); break; case NoiseSettings.FilterType.Rigid: // HRS note in generated stimulus set version we dont have any rigid noise filters to keep the stimuli dimensions clearly separable /* * // constant feature values * noiseLayer.noiseSettings.rigidNoiseSettings.persistence = 0.5f; // keep this fixed around .5f * noiseLayer.noiseSettings.rigidNoiseSettings.minValue = 0.95f; // keep this fixed around .95f, because the height-based colours start f*****g up * noiseLayer.noiseSettings.rigidNoiseSettings.numLayers = 4; * * // variable feature values * noiseLayer.noiseSettings.rigidNoiseSettings.strength = RandomNumberInRange(0.05f, 0.4f) * (i + 1); // height of mountains * noiseLayer.noiseSettings.rigidNoiseSettings.baseRoughness = RandomNumberInRange(0.8f, 3f) * (i + 1); // roughness of mountains * noiseLayer.noiseSettings.rigidNoiseSettings.roughness = 2.2f; // RandomNumberInRange(1f, 3.0f); // looks nice around 2.2f * * // change the position of the noise on the planet (almost the same as creating new noise object, if we do this for each layer independently its fine * noiseLayer.noiseSettings.rigidNoiseSettings.centre.x = RandomNumberInRange(-.5f, .5f); * noiseLayer.noiseSettings.rigidNoiseSettings.centre.y = RandomNumberInRange(-.5f, .5f); * noiseLayer.noiseSettings.rigidNoiseSettings.centre.z = RandomNumberInRange(-.5f, .5f); */ break; } settings.noiseLayers[i] = noiseLayer; } return(settings); }
void Physics() { bool NewCollided = false; //Vector3 PlusSpeed = new Vector3(); List <Planet> ps = planets; int l = planets.Count; Vector3 pos = transform.position; const float gravitational_constant = 0.01f; #region PlayerPhysics float dist = float.PositiveInfinity; int nearest = 0; if (GravityOnPlayer) { for (int i = 0; i < l; i++)//gravity planets on spacecraft { ShapeSettings shapeSettings = planets[i].shapeSettings; Vector3 planetpos = shapeSettings.position - pos;//points to left var float r = shapeSettings.PlanetRadius + shapeSettings.MaxDifference * .5f; float d = planetpos.Length; if (d - r < dist) { dist = d; nearest = i; } float weight = r * r * r; planetpos *= gravitational_constant * weight / (d * d * d);//gravity = const * w/(d*d), extra division to normalize speed += planetpos; } } Planet NearestPlanet = planets[nearest]; ShapeSettings nearestSettings = NearestPlanet.shapeSettings; Vector3 Sum = transform.position + speed; Vector3 ppos = nearestSettings.position; Vector3 sub = Sum - ppos;//pointing to left variable float distanceToNearestPlanet = sub.Length; Vector3 normal = sub / distanceToNearestPlanet; //check wether colliding with nearest planet float val = NearestPlanet.shapeGenerator.noiseFilter.Evaluate(ppos + normal) * nearestSettings.MaxDifference + nearestSettings.PlanetRadius; const float bounce = -.5f, height = .005f; float Friction; if (val > distanceToNearestPlanet)//collide, bounce { NewCollided = true; Friction = 0.5f; //if (!LastCollided) speed *= bounce; //else speed = new Vector3(); normal = (transform.position - ppos).normalized; val = planets[nearest].shapeGenerator.noiseFilter.Evaluate(ppos + normal) * nearestSettings.MaxDifference + nearestSettings.PlanetRadius; //transform.position = ppos + normal * (val + height); } else { Friction = 0.1f; transform.position += speed; } OnPlanet = distanceToNearestPlanet < nearestSettings.PlanetRadius + nearestSettings.MaxDifference; if (OnPlanet) { speed = Vector3.Lerp(speed, NearestPlanet.Speed, Friction); //in space is no friction } LastCollided = NewCollided; #endregion if (GravityOnPlanets) { for (int i = 0; i < l; i++)//gravity planets on eachother { Planet planetA = planets[i]; ShapeSettings shapeSettingsA = planetA.shapeSettings; Vector3 planetApos = shapeSettingsA.position; float rA = shapeSettingsA.PlanetRadius + shapeSettingsA.MaxDifference * .5f; float weightA = rA * rA * rA; for (int j = i + 1; j < l; j++) { Planet planetB = planets[j]; ShapeSettings shapeSettingsB = planetB.shapeSettings; Vector3 planetBpos = shapeSettingsB.position; Vector3 FromBToA = planetApos - planetBpos; float rB = shapeSettingsB.PlanetRadius + shapeSettingsB.MaxDifference * .5f; float d = FromBToA.Length; //points to planetA if (d < rA + rB) //planets collide { if (rA > rB) { //planetA.Colliding.Add(planetB); planetB.Destroyed = true; } else { //planetB.Colliding.Add(planetA); planetA.Destroyed = true; } } else { float weightB = rB * rB * rB; FromBToA *= gravitational_constant / (d * d * d); planetB.Speed += FromBToA * weightA; planetA.Speed -= FromBToA * weightB; } } } } for (int i = 0; i < l; i++) { Planet planetA = planets[i]; if (planetA.Destroyed) { planets.RemoveAt(i--); l--; continue; } int collidecount = planetA.Colliding.Count; if (collidecount > 0) { ElevationSettings elevationSettingsA = planetA.shapeSettings.NoiseSettings.settings; List <Elevation> BigPlanetElevations = elevationSettingsA.Elevations; float rA = planetA.shapeSettings.PlanetRadius + planetA.shapeSettings.MaxDifference * .5f; float mA = rA * rA * rA; //other planets have collided, but their radius was lesser than this planet's radius for (int j = 0; j < collidecount; j++) { Planet PlanetB = planetA.Colliding[j]; ElevationSettings elevationSettingsB = PlanetB.shapeSettings.NoiseSettings.settings; //add height layers to this planet Elevation[] elevations = elevationSettingsB.Elevations.ToArray(); int ElevationCount = elevations.Length; Elevation BottomElevation = elevations[0]; float rB = PlanetB.shapeSettings.PlanetRadius + PlanetB.shapeSettings.MaxDifference * .5f; float mB = rB * rB * rB; float TotalMass = mB + mA; float multiplierA = mA / TotalMass; float multiplierB = mB / TotalMass;// 1/multA float NewRadius = (float)sys.Math.Pow(TotalMass, 1 / 3); float LastElevationHeight = BigPlanetElevations[BigPlanetElevations.Count - 1].height; for (int k = 0; k < BigPlanetElevations.Count; k++) { BigPlanetElevations[k].height *= multiplierA; } for (int k = 0; k > ElevationCount; k++) { BigPlanetElevations.Add(new Elevation(elevations[k].color, elevations[k].height * multiplierB + multiplierA)); //elevations[0]. } //add water to this planet float waterheight = elevationSettingsB.WaterHeight; Color waterColor = elevationSettingsB.WaterColor; elevationSettingsA.WaterHeight = (elevationSettingsA.WaterHeight * mA + elevationSettingsB.WaterHeight * mB) / TotalMass; elevationSettingsA.WaterColor.ScR = (elevationSettingsA.WaterColor.ScR * mA + elevationSettingsB.WaterColor.ScR * mB) / TotalMass; elevationSettingsA.WaterColor.ScG = (elevationSettingsA.WaterColor.ScG * mA + elevationSettingsB.WaterColor.ScG * mB) / TotalMass; elevationSettingsA.WaterColor.ScB = (elevationSettingsA.WaterColor.ScB * mA + elevationSettingsB.WaterColor.ScB * mB) / TotalMass; planetA.shapeSettings.PlanetRadius = (planetA.shapeSettings.PlanetRadius * mA + PlanetB.shapeSettings.PlanetRadius * mB) / TotalMass; planetA.Speed += PlanetB.Speed * mB / mA; } } planetA.Colliding.Clear(); planetA.shapeSettings.position += planets[i].Speed; for (int j = 0; j < 6; j++) {//force the planet to regenerate mesh planetA.TerrainFaces[j].Childs = null; planetA.TerrainFaces[j].LastMesh = null; planetA.TerrainFaces[j].LastResolution = 0; } //planets[i].GeneratePlanet(); //planets[i]. } }
/// <summary> /// Generates a face mesh with a given resolution and direction, with a collider /// </summary> private static WorldFace GenerateWorldFace(Transform parent, Vector3 direction, int resolution, int colliderResolutionFraction, Material material, ShapeSettings shapeSettings) { var face = new GameObject("Mesh"); var renderer = face.AddComponent <MeshRenderer>(); renderer.sharedMaterial = material; // Face geometry var meshFilter = face.AddComponent <MeshFilter>(); var terrainFace = TerrainFaceGenerator.GenerateTerrainFace(resolution, direction, shapeSettings); meshFilter.sharedMesh = terrainFace.Mesh; // Only generate colliders around planet if (direction != Vector3.forward && direction != Vector3.back) { // Collider geometry var collider = face.AddComponent <MeshCollider>(); var collisionFace = TerrainFaceGenerator.GenerateTerrainFace(resolution / colliderResolutionFraction, direction, shapeSettings); collider.sharedMesh = collisionFace.Mesh; } // var combinedElevationMinMax = MinMax.Union(faces.Select(face => face.ElevationRange)); renderer.sharedMaterial.SetVector("_elevationMinMax", new Vector4(0, 10)); return(new WorldFace() { GameObject = face, ElevationRange = terrainFace.ElevationRange }); }
public static void SaveSettings(EntityBox entityBox) { Properties.Settings settings = Properties.Settings.Default; /// Save global settings GlobalSettings global = new GlobalSettings(entityBox); settings.SelectEntitiesAfterAdd = global.SelectEntitiesAfterAdd; settings.Grayscale = global.Grayscale; settings.Lambda = global.Lambda; settings.LockScroll0 = global.LockScroll0; settings.LockScroll1 = global.LockScroll1; settings.LockScroll2 = global.LockScroll2; settings.LockZoom0 = global.LockZoom0; settings.LockZoom1 = global.LockZoom1; settings.LockZoom2 = global.LockZoom2; settings.HideGrid = global.HideGrid; settings.HideLambdaMetrics = global.HideLambdaMetrics; settings.CellTextAlignment = (int)global.CellTextAlignment; settings.ViasTextAlignment = (int)global.ViasTextAlignment; settings.WireTextAlignment = (int)global.WireTextAlignment; /// Save color settings /// ColorSettings color = new ColorSettings(entityBox); settings.SelectionBoxColor = color.SelectionBoxColor; settings.ViasInputColor = color.ViasInputColor; settings.ViasOutputColor = color.ViasOutputColor; settings.ViasInoutColor = color.ViasInoutColor; settings.ViasConnectColor = color.ViasConnectColor; settings.ViasFloatingColor = color.ViasFloatingColor; settings.ViasPowerColor = color.ViasPowerColor; settings.ViasGroundColor = color.ViasGroundColor; settings.WireInterconnectColor = color.WireInterconnectColor; settings.WirePowerColor = color.WirePowerColor; settings.WireGroundColor = color.WireGroundColor; settings.CellNotColor = color.CellNotColor; settings.CellBufferColor = color.CellBufferColor; settings.CellMuxColor = color.CellMuxColor; settings.CellLogicColor = color.CellLogicColor; settings.CellAdderColor = color.CellAdderColor; settings.CellBusSuppColor = color.CellBusSuppColor; settings.CellFlipFlopColor = color.CellFlipFlopColor; settings.CellLatchColor = color.CellLatchColor; settings.CellOtherColor = color.CellOtherColor; settings.UnitRegfileColor = color.UnitRegfileColor; settings.UnitMemoryColor = color.UnitMemoryColor; settings.UnitCustomColor = color.UnitCustomColor; settings.SelectionColor = color.SelectionColor; settings.ViasOverrideColor = color.ViasOverrideColor; settings.WireOverrideColor = color.WireOverrideColor; settings.CellOverrideColor = color.CellOverrideColor; settings.RegionOverrideColor = color.RegionOverrideColor; /// Save priority settings /// PrioritySettings priority = new PrioritySettings(entityBox); settings.ViasPriority = priority.ViasPriority; settings.WirePriority = priority.WirePriority; settings.CellPriority = priority.CellPriority; settings.BeaconPriority = priority.BeaconPriority; settings.RegionPriority = priority.RegionPriority; settings.AutoPriority = priority.AutoPriority; /// Save opacity settings /// OpacitySettings opacity = new OpacitySettings(entityBox); settings.ViasOpacity = opacity.ViasOpacity; settings.WireOpacity = opacity.WireOpacity; settings.CellOpacity = opacity.CellOpacity; /// Save shape settings /// ShapeSettings shape = new ShapeSettings(entityBox); settings.ViasShape = (int)shape.ViasShape; settings.Save(); }
public ShapeGenerator(ShapeSettings settings, int zOffset) { this.settings = settings; this.zOffset = zOffset; }
void Start() { shapeSettings = GetComponent <Planet>().shapeSettings; AdjustSizes(); }
public override AABB GetShapeBounds() { return ShapeSettings.CalculateBounds(Quaternion.identity, gridTangent, gridBinormal); }
public ShapeSettings(ShapeSettings shapeSettings) { m_planetRadius = shapeSettings.m_planetRadius; m_noiseLayers = shapeSettings.m_noiseLayers; }
public shapeGenerator(ShapeSettings settings) { this.settings = settings; noiseFilter = new NoiseFilter(settings.noiseSettings); }
public AstresDonnees(float impulsion, bool isOrbit, float radius, int resolution, float distWithSun, string name, ShapeSettings shape, ColourSettings color) { Impulsion = impulsion; IsOrbit = isOrbit; Radius = radius; Resolution = resolution; DistWithSun = distWithSun; Name = name; Shape = shape; Color = color; }