private void Awake() { noiseFilters = new SimpleNoiseFilter[objectSettings.noiseLayers.Length]; for (int i = 0; i < noiseFilters.Length; i++) { noiseFilters[i] = new SimpleNoiseFilter(objectSettings.noiseLayers[i].noiseSettings); } lastObjectSettings = JsonUtility.ToJson(objectSettings); GetComponent <MeshFilter>().mesh = OctahedronSphereCreator.Create(objectSettings, noiseFilters);; GetComponent <Renderer>().material = m_TerrainMaterial; texture = new Texture2D(textureResolution, 1); updateColours(); m_TerrainMaterial.SetVector("_elevationMinMax", new Vector4(objectSettings.radius, objectSettings.radius + (0.9f * objectSettings.radius / (objectSettings.radius + objectSettings.radius)))); noiseFilters = new INoiseFilter[objectSettings.noiseLayers.Length]; for (int i = 0; i < noiseFilters.Length; i++) { noiseFilters[i] = NoiseFilterFactory.CreateNoiseFilter(objectSettings.noiseLayers[i].noiseSettings); } lastObjectSettings = JsonUtility.ToJson(objectSettings); mesh = OctahedronSphereCreator.Create(objectSettings, noiseFilters); GetComponent <MeshFilter>().mesh = mesh; updateColours(); m_TerrainMaterial.SetVector("_elevationMinMax", new Vector4(objectSettings.radius, objectSettings.radius + (0.9f * objectSettings.radius / (objectSettings.radius + objectSettings.radius)))); GetComponent <MeshCollider>().sharedMesh = mesh; }
// Start is called before the first frame update void Start() { meshGenerator = new MeshGenerator(NoiseFilterFactory.CreateNoiseFilter(noiseSettings)); noiseSettings.settingsUpdated += recomputeTerrain; for (int i = 0; i < 6; i++) { var planetSide = new TerrainQuadTree( transform.position, Mathf.Pow(2, PLANET_SIZE) * SCALE, directions[i], 3.0f, PLANET_SIZE, material, meshGenerator ); planetSide.terrain.transform.parent = transform; planetSide.terrain.name = directionNames[i]; planetSides[i] = planetSide; } planetSides[0].neighbors = new[] { planetSides[2], planetSides[4], planetSides[3], planetSides[5] }; planetSides[1].neighbors = new[] { planetSides[3], planetSides[4], planetSides[2], planetSides[5] }; planetSides[2].neighbors = new[] { planetSides[4], planetSides[0], planetSides[5], planetSides[1] }; planetSides[3].neighbors = new[] { planetSides[5], planetSides[0], planetSides[4], planetSides[1] }; planetSides[4].neighbors = new[] { planetSides[3], planetSides[0], planetSides[2], planetSides[1] }; planetSides[5].neighbors = new[] { planetSides[2], planetSides[0], planetSides[3], planetSides[1] }; }
public ShapeGenerator(ShapeSettings settings) { 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); } }
public void UpdateSettings(ShapeSettings settings) { 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); } }
public void UpdateSettings(ColourSettings settings) { _settings = settings; if (_texture2D == null || _texture2D.height != settings.BiomeColourSettings.Biomes.Length) { _texture2D = new Texture2D(_textureResolution, settings.BiomeColourSettings.Biomes.Length); } biomeNoiseFilter = NoiseFilterFactory.CreateNoiseFilter(settings.BiomeColourSettings.NoiseSettings); }
public void UpdateSettings(ColorSettings settings) { this.settings = settings; if (texture == null || texture.height != settings.biomeColorSettings.biomes.Length) { texture = new Texture2D(textureResolution * 2, settings.biomeColorSettings.biomes.Length, TextureFormat.RGBA32, false); } biomeNoiseFilter = NoiseFilterFactory.CreateNoiseFilter(settings.biomeColorSettings.noise); }
public void UpdateSettings(ShapeSettings settings) { this.settings = settings; noiseFilters = new INoiseFilter[settings.noiseLayers.Length]; for (int i = 0; i < noiseFilters.Length; i++) { noiseFilters[i] = NoiseFilterFactory.CreateNoiseFilter(settings.noiseLayers[i].settings); } elevationMinMax = new MinMax(); }
public ShapeGenerator(ShapeSettings shapeSettings) { _settings = shapeSettings; _noiseFilters = new INoiseFilter[_settings.noiseLayers.Length]; for (int i = 0; i < _noiseFilters.Length; i++) { _noiseFilters[i] = NoiseFilterFactory.CreateNoiseFilter(_settings.noiseLayers[i].noiseSettings); } }
public System.Random rand = new System.Random(); // Randomisation of planet settings // ********************************************************************** // public void UpdateSettings(ColourSettings settings, bool reset, ColourSamplingStatistics colorStats) { this.settings = reset ? RandomizeColourSettings(settings, colorStats) : settings; // generate a new random planet if (texture == null || texture.height != settings.biomeColourSettings.biomes.Length) { texture = new Texture2D(textureResolution * 2, settings.biomeColourSettings.biomes.Length, TextureFormat.RGBA32, false); // first half of this is the ocean, second half is the biomes/icy north pole etc } biomeNoiseFilter = NoiseFilterFactory.CreateNoiseFilter(settings.biomeColourSettings.noise); tintColor = settings.biomeColourSettings.biomes[0].tint; }
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].BaseNoiseSettings); } _elevationMinMax = new MinMax(); }
public void UpdateSettings(ColorSettings settings) { this.settings = settings; if (texture == null || texture.height != settings.biomeColorSettings.biomes.Length) { //Uing first half of texture for ocean and second half for solid ground texture = new Texture2D(textureResolution * 2, settings.biomeColorSettings.biomes.Length, TextureFormat.RGBA32, false); } biomeNoiseFilter = NoiseFilterFactory.CreateNoiseFilter(settings.biomeColorSettings.noise); }
// Update the planet according to the current shape settings. public void UpdateSettings(ShapeSettings settings) { this.settings = settings; // Assign the current shape settings. noiseFilters = new INoiseFilter[settings.noiseLayers.Length]; for (int i = 0; i < noiseFilters.Length; i++) // Loop through all noise filters and create a noise layer of the specified type. { noiseFilters[i] = NoiseFilterFactory.CreateNoiseFilter(settings.noiseLayers[i].noiseSettings); } elevationMinMax = new MinMax(); }
// ********************************************************************** // public void UpdateSettings(ShapeSettings settings, bool reset, ShapeSamplingStatistics shapeSampleStats) { this.settings = reset ? RandomizeShapeSettings(settings, shapeSampleStats) : settings; // generate a new random planet 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 void UpdateSettings(WorldShapeSettings settings) { shapeSettings = settings; noiseFilters = new INoiseFilter[shapeSettings.NoiseLayers.Length]; for (int i = 0; i < noiseFilters.Length; i++) { noiseFilters[i] = NoiseFilterFactory.CreateNoiseFilter(shapeSettings.NoiseLayers[i].NoiseSettings); } }
public void UpdateSettings(ColourSettings settings) { this.settings = settings; int numberOfBiomes = settings.biomeColourSettings.biomes.Length; if (texture == null || texture.height != numberOfBiomes) { this.texture = new Texture2D(textureResolution, numberOfBiomes); } biomeNoiseFilter = NoiseFilterFactory.CreateNoiseFilter(settings.biomeColourSettings.noise); }
public ShapeGenerator(ShapeSettings settings) { Settings = settings; ElevationMinMax = new MinMax(); settingsLayers = settings.Layers.Where(x => x != null).ToList(); noiseFilters = new INoiseFilter[settingsLayers.Count]; for (int i = 0; i < noiseFilters.Length; i++) { noiseFilters[i] = NoiseFilterFactory.CreateNoiseFilter(settingsLayers[i]); } }
public void UpdateSettings(ColorSettings settings) { m_settings = settings; if (m_texture == null || m_texture.height != m_settings.m_biomeColorSettings.m_biomes.Length) { m_texture = new Texture2D(m_textureRes, m_settings.m_biomeColorSettings.m_biomes.Length); } m_biomeNoiseFilter = NoiseFilterFactory.CreateNoiseFilter(m_settings.m_biomeColorSettings.m_noise); }
public void UpdateSettings(ColorSettings colorSettings) { this.colorSettings = colorSettings; //the first `textureResolution` keeps data for `ocean`, the second part keeps data for `lands` if (texture == null || texture.height != colorSettings.biomeColorSettings.biomes.Length) { texture = new Texture2D(textureResolution * 2, colorSettings.biomeColorSettings.biomes.Length, TextureFormat.RGBA32, false); } biomeNoiseFilter = NoiseFilterFactory.CreateNoiseFilter(colorSettings.biomeColorSettings.noise); }
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 void Initialize() { cameraController.AddPostProcessingClient(this); //worleyNoiseGenerator = new WorleyNoiseGenerator(worleyComputeShader); //cloudSettings.texture = worleyNoiseGenerator.RunShader(); noiseFilter = NoiseFilterFactory.CreateNoiseFilter(settings.noiseSettings); settings.texture = new Texture3D(40, 40, 40, TextureFormat.RGBA32, true); GenerateTexture(); }
public void UpdateSettings(ShapeSettings settings) { shapeSettings = settings; noiseFilters = new iNoiseFilter[settings.noiseLayers.Length]; for (int i = 0; i < noiseFilters.Length; ++i) { noiseFilters[i] = NoiseFilterFactory.CreateNoiseFilter(settings.noiseLayers[i].noiseSettings); } elevationRange = new MinMax(); }
// Initialize settings and apply texture if none is selected. public void UpdateSettings(ColorSettings settings) { this.settings = settings; if (texture == null || texture.height != settings.biomeColorSettings.biomes.Length) { // Height corresponds to num of biomes. // Store biome and ocean textures. texture = new Texture2D(textureResolution * 2, settings.biomeColorSettings.biomes.Length, TextureFormat.RGBA32, false); } // Initialize the noise settings of the biome. biomeNoisefilter = NoiseFilterFactory.CreateNoiseFilter(settings.biomeColorSettings.noise); }
public void UpdateSettings(ShapeSettings settings) { m_settings = settings; m_noiseFilters = new INoiseFilter[m_settings.m_noiseLayers.Length]; for (int i = 0; i < m_settings.m_noiseLayers.Length; i++) { m_noiseFilters[i] = NoiseFilterFactory.CreateNoiseFilter(m_settings.m_noiseLayers[i].m_noiseSettings); } m_elevationMinMax = new MinMax(); }
public void UpdateSettings(ColourSettings settings) { this.settings = settings; if (texture == null || texture.height != settings.biomeColourSettings.biomes.Length) // update texture if null or if height not equal to nb of biomes { // first half of each texture strip is ocean texture texture = new Texture2D(textureResolution * 2, settings.biomeColourSettings.biomes.Length, TextureFormat.RGBA32, false); // width, height (each row stores the colour for a biome) // disable mipmapping (lowres texture version for viewing from far away) } // Initialise biome noise filter biomeNoiseFilter = NoiseFilterFactory.CreateNoiseFilter(settings.biomeColourSettings.noise); }
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(); }
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(); }
void Update() { if (lastObjectSettings != JsonUtility.ToJson(objectSettings)) { noiseFilters = new INoiseFilter[objectSettings.noiseLayers.Length]; for (int i = 0; i < noiseFilters.Length; i++) { noiseFilters[i] = NoiseFilterFactory.CreateNoiseFilter(objectSettings.noiseLayers[i].noiseSettings); } lastObjectSettings = JsonUtility.ToJson(objectSettings); mesh = OctahedronSphereCreator.Create(objectSettings, noiseFilters); GetComponent <MeshFilter>().mesh = mesh; updateColours(); m_TerrainMaterial.SetVector("_elevationMinMax", new Vector4(objectSettings.radius, objectSettings.radius + (0.9f * objectSettings.radius / (objectSettings.radius + objectSettings.radius)))); GetComponent <MeshCollider>().sharedMesh = mesh; } transform.Rotate(Vector3.up * 0.1f * rotationSpeed); }
protected virtual void OnValidate() { minMax = new MinMax(); vertexCount = 0; noiseFilters = new INoiseFilter[noiseLayers.Length]; for (int i = 0; i < noiseFilters.Length; i++) { noiseFilters[i] = NoiseFilterFactory.CreateNoiseFilter(noiseLayers[i].noiseSettings); } if (Application.isPlaying) { if (!builded) { BuildPlanet(); } } else { BuildPlanet(); } // base.OnValidate(); }
public void Initialize() { simpleNoise = (SimpleNoiseFilter)NoiseFilterFactory.CreateNoiseFilter(terrainSettings.noiseLayers[0].noiseSettings); fragmentObjPool = new FragmentObjectPool(material, transform); viewerPosition = viewer.transform.position; visibleFragments = new Dictionary <Vector2, TerrainFragment>(); for (int i = 0; i < transform.childCount; i++) //destroy editor terrain fragments { Destroy(transform.GetChild(i).gameObject); } oldViewerPosition = viewer.transform.position; if (viewerPosition == null) { viewerPosition = viewer.transform.position; } visibleLastframeFragments = new Dictionary <Vector2, TerrainFragment>(); setResolutionLevels(); fragmentVisibleInViewDistance = Mathf.RoundToInt(terrainSettings.maxViewDistance / (float)terrainSettings.fragmentSize); GenerateFragements(); }
public NoiseOccupancyDescriptor(NoiseOccupancySettings settings) { this.settings = settings; noiseFilter3D = NoiseFilterFactory.CreateNoiseFilter(settings.noiseSettings); }