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;
}
