コード例 #1
0
    float SampleCaves(float x, float y, float z, PerlinNoise perlin)
    {
        //The creates the noise used for the caves. It uses domain warping like the moiuntains
        //to creat long twisting caves.
        float w = perlin.FractalNoise3D(x, y, z, 1, 40.0f, 32.0f);

        //The last vaule is the cave amp and defines the maximum cave diameter. A larger value will create
        //larger caves (A higher frequency will also create larger caves). It is unitless, 1 != 1m
        return(Mathf.Abs(perlin.FractalNoise3D(x + w, y * 2.0f + w, z + w, 2, 40.0f, 2.0f)));
    }
コード例 #2
0
ファイル: AsteroidGenerator.cs プロジェクト: lwsn/SPACE
    void DeformMesh(Mesh mesh, PolygonCollider2D collider, int mult, int seed)
    {
        Vector3[] verts   = mesh.vertices;
        Vector3[] normals = mesh.normals;

        PerlinNoise pnoise = new PerlinNoise(seed);

        Vector2[] colPoints = new Vector2[14];

        int j = 0;
        int k = 0;

        for (int i = 0; i < verts.Length; i++)
        {
            Vector3 v = normals[i];
            v.z      = 0;
            verts[i] = verts[i] + v * (pnoise.FractalNoise3D(verts[i].x, verts[i].y, verts[i].z, (int)octaves / 2, frequency * 2, amplitude / 2 * mult));
            if (verts[i].z > -0.01)
            {
                if (k == 0)
                {
                    colPoints[j++ % 14] = verts[i];
                }
                k = (k + 1) % 3;
            }
        }
        mesh.vertices   = verts;
        collider.points = colPoints;
        mesh.RecalculateNormals();
        mesh.RecalculateBounds();
    }
コード例 #3
0
    Vector3 getPerlin3D(Vector3 pos)
    {
        float f1 = perlinX.FractalNoise3D(pos.x, pos.y, pos.z, 1, 1 / frequency, amplitude); //Mathf.PerlinNoise(pos.x,pos.y) -.5f;
        float f2 = perlinY.FractalNoise3D(pos.x, pos.y, pos.z, 1, 1 / frequency, amplitude); //Mathf.PerlinNoise(pos.x,pos.y) -.5f;
        float f3 = perlinZ.FractalNoise3D(pos.x, pos.y, pos.z, 1, 1 / frequency, amplitude); //Mathf.PerlinNoise(pos.x,pos.y) -.5f;

        return(new Vector3(f1, f2, f3));
    }
コード例 #4
0
    // Update is called once per frame
    void Update()
    {
        // Update the perlin index to lookup the perlin value
        m_PerlinIndex += m_PerlinIncrement * Time.deltaTime;

        Vector3 pos = transform.position;
        Vector3 perl;

        //m_PerlNoise
        perl.x = m_PerlNoise.FractalNoise3D(m_PerlinIndex, m_PerlinIndex + 5, m_PerlinIndex + 10, m_OctNum, 1, 1);
        perl.y = m_PerlNoise.FractalNoise3D(m_PerlinIndex + 5, m_PerlinIndex + 10, m_PerlinIndex, m_OctNum, 1, 1);
        perl.z = m_PerlNoise.FractalNoise3D(m_PerlinIndex + 10, m_PerlinIndex + 5, m_PerlinIndex, m_OctNum, 1, 1);

        //perl.x = m_PerlNoise.FractalNoise3D( m_PerlinIndex, m_PerlinIndex, m_PerlinIndex, m_OctNum, m_Freq, m_Amp );
        //perl.y = 0;
        //perl.z = 0;
        //print ( perl );
        //print ( perl );
        // Set the transform offset based on the perlin value

        perl.Scale(m_PerlinPositioning);
        m_TransformManager.m_OffsetPosition += perl;
    }
コード例 #5
0
ファイル: TESTspitGrid.cs プロジェクト: Cidolfas/Cave-Machine
    void AddNoiseToVoxels()
    {
        if (noiseAmount < 0f) return;

        PerlinNoise noise = new PerlinNoise (Random.seed);

        int v = voxelCountPerChunk * chunkStride;
        for (int i = 0; i < v; i++) {
            for (int j = 0; j < v; j++) {
                for (int k = 0; k < v; k++) {
                    if (voxels[i, j, k] == 0f) continue;
                    voxels[i, j, k] += noise.FractalNoise3D(i, j, k, octNum, noiseFreq, 1f) * noiseAmount;
                    voxels[i, j, k] = Mathf.Clamp01(voxels[i, j, k]);
                }
            }
        }
    }
コード例 #6
0
    void GenerateTerrain(float time)
    {
        PerlinNoise noiseGen = new PerlinNoise(0);

        for (int i = 0; i < _width; i++)
        {
            for (int j = 0; j < _height; j++)
            {
                float x = (float)i / (float)_width;
                float y = (float)j / (float)_height;

                float noise = noiseGen.FractalNoise3D(x, y, time, 2, _mapScale + 0.01f, 1.75f);

                _tileMap[i, j] = NoiseToTile(noise);
            }
        }
    }
コード例 #7
0
    public void Build()
    {
        float[,,] voxels = new float[size + 1, size + 1, size + 1];
        int   height;
        float hFactor;

        for (int z = 0; z < size + 1; z++)
        {
            for (int y = 0; y < size + 1; y++)
            {
                height  = yi + y;
                hFactor = (float)(maxHeight - 2 * height) / (float)maxHeight;
                for (int x = 0; x < size + 1; x++)
                {
                    voxels[x, y, z] = -hFactor + m_perlin.FractalNoise3D((float)(xi + x), (float)(yi + y), (float)(zi + z), 3, freq, 1.0f);
                }
            }
        }

        mesh = MarchingCubes.CreateMesh(voxels);

        //UV MAPPING
        Vector3[] vertices = mesh.vertices;
        Vector2[] uvs      = new Vector2[mesh.vertices.Length];
        for (int i = 0; i < uvs.Length; i++)
        {
            uvs[i] = new Vector2(vertices[i].x, vertices[i].z);
        }
        mesh.uv = uvs;
        //NORMALS
        mesh.RecalculateNormals();
        //TANGENTS
        TangentSolver.Solve(mesh);
        mesh.Optimize();
        AssetDatabase.CreateAsset(mesh, "Assets/Resources/meshes/mesh" + xi + yi + zi + ".asset");
        //GAMEOBJECT SETUP
        m_mesh.GetComponent <MeshFilter>().mesh = mesh;
        m_mesh.transform.localPosition          = gPos;
        m_mesh.AddComponent <MeshCollider>();
    }
コード例 #8
0
    public void GenerateEmptySurface(float[] field, Vector3 pos)
    {
        int rS = size + 1;

        for (int x = 0; x < rS; x++)
        {
            for (int y = 0; y < rS; y++)
            {
                for (int z = 0; z < rS; z++)
                {
                    Vector3 p = pos + new Vector3(x, y, z);
                    float   d = (c - p).magnitude;
                    float   t = 1f - 1f / (1f + d);

                    float n = noise.FractalNoise3D(pos.x + x, pos.y + y, pos.z + z, oct, frq, amp);

                    globalHeightFunction = AnimationCurve.Linear(0, startHeight + n, 1, 0);

                    field[x + y * rS + z * rS * rS] = globalHeightFunction.Evaluate(t);
                }
            }
        }
    }
コード例 #9
0
ファイル: AsteroidGenerator.cs プロジェクト: lwsn/SPACE
    void GenerateGenericTexture(Texture2D tex, Texture2D normal, Color asteroidColor, int seed)
    {
        float _x, _y, _z, noise;
        int   width  = tex.width;
        int   height = tex.height;

        Color[] pix  = new Color[width * height];
        Color[] pixn = new Color[width * height];

        noise = 0;

        Gradient[] gradients = MakeGenericGradients(asteroidColor);

        PerlinNoise pnoise = new PerlinNoise(seed);

        for (float y = 0; y < width; y++)
        {
            for (float x = 0; x < height; x++)
            {
                _x = (x / width - 0.5f) * 2;
                _y = (y / height - 0.5f) * 2;
                _z = Mathf.Sqrt(1 - Mathf.Pow(_x, 2) - Mathf.Pow(_y, 2));

                noise = 0;
                if (_z >= 0)
                {
                    noise = (pnoise.FractalNoise3D(_x, _y, _z, (int)octaves, frequency, amplitude));
                }

                pix[(int)y * tex.width + (int)x]  = gradients[0].Evaluate(1 - Mathf.Abs(noise)) * (1 - Mathf.Abs(noise));
                pixn[(int)y * tex.width + (int)x] = gradients[1].Evaluate(1 - Mathf.Abs(noise)) * (1 - Mathf.Abs(noise) * 4);
            }
        }
        tex.SetPixels(pix);
        normal.SetPixels(HeightToNormal(pixn));
    }
コード例 #10
0
ファイル: VoxelChunk.cs プロジェクト: kaldrick/VoxelTerrain
 float SampleCaves(float x, float y, float z, PerlinNoise perlin)
 {
     //The creates the noise used for the caves. It uses domain warping like the moiuntains
     //to creat long twisting caves.
     float w = perlin.FractalNoise3D(x, y, z, 1, 40.0f, 32.0f);
     //The last vaule is the cave amp and defines the maximum cave diameter. A larger value will create
     //larger caves (A higher frequency will also create larger caves). It is unitless, 1 != 1m
     return Mathf.Abs(perlin.FractalNoise3D(x+w, y*2.0f+w, z+w, 2, 40.0f, 2.0f));
 }
コード例 #11
0
    private void marchingCubesV2(Vector3 pos)
    {
        int vert, idx;

        cubeVerts = new float[8];
        int   flagIndex = 0;
        float offset    = 0.0f;

        edgeVertex = new Vector3[12];

        //This is getting the noise value at each corner
        //Possible bottleneck is the noise generation, just got that code off the internet and went with it.
        for (int i = 0; i < 8; i++)
        {
            //The argument for noise constructor is just a seed, feel free to change....Should make that an argument for marching constructor
            //PerlinNoise noise = new PerlinNoise(100);
            cubeVerts[i] = noise.FractalNoise3D(pos.x + vertexOffset[i, 0] * scale,
                                                pos.y + vertexOffset[i, 1] * scale,
                                                pos.z + vertexOffset[i, 2] * scale, 3, 40, 1);
        }

        //the target value is the value that determines if noise is solid or air.
        //In the case we say negative is air and positive is solid
        //If solid we do a bitwise shift on flagIndex
        for (int i = 0; i < 8; i++)
        {
            if (cubeVerts[i] >= target)
            {
                flagIndex |= 1 << i;
            }
        }

        //Nifty ass lookup table powers at work
        //Finds edges intersecting the surface.
        int edgeFlags = cubeEdgeFlags[flagIndex];

        //This cube is either entirely solid (edgeFlags == 255)
        //or entirely air so we don't do shit (edgeFlags == 0)
        //or it is outside the chunk we want generated (pos.x >= max || pos.y >= max || pos.z >= max)
        //So we don't do shit here
        if (edgeFlags == 0 || edgeFlags == 255 || pos.x > xmax || pos.y > ymax || pos.z > zmax || pos.x < xmin || pos.y < ymin || pos.z < zmin)
        {
            return;
        }        /*else{
                  *     GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
                  * cube.transform.position = new Vector3(pos.x + scale/2, pos.y + scale/2, pos.z + scale/2);
                  *     cube.transform.localScale = new Vector3(scale,scale,scale);
                  * }*/

        //Find the point of intersection of the surface with each edge
        //Then find the normal to the surface at those points
        for (int i = 0; i < 12; i++)
        {
            if ((edgeFlags & (1 << i)) != 0)
            {
                offset = getOffset(cubeVerts[edgeConnection[i, 0]], cubeVerts[edgeConnection[i, 1]]);

                edgeVertex[i].x = pos.x + (vertexOffset[edgeConnection[i, 0], 0] + offset * edgeDirection[i, 0]);
                edgeVertex[i].y = pos.y + (vertexOffset[edgeConnection[i, 0], 1] + offset * edgeDirection[i, 1]);
                edgeVertex[i].z = pos.z + (vertexOffset[edgeConnection[i, 0], 2] + offset * edgeDirection[i, 2]);
            }
        }

        //Draw the triangles..Up to 5 per cube
        for (int i = 0; i < 5; i++)
        {
            if (triangleConnectionTable[flagIndex, 3 * i] < 0)
            {
                break;
            }

            idx = vertList.Count;
            for (int j = 0; j < 3; j++)
            {
                //Here we are making the lists to create a mesh. Could also try straight up drawing the triangles at some point
                vert = triangleConnectionTable[flagIndex, 3 * i + j];
                indexList.Add(idx + windingOrder[j]);
                vertList.Add(edgeVertex[vert]);
            }
        }

        //March to the neighbors. Will be the six cubes that coincide with faces of this cube
        //Should actually attempt to put every new vector in the used hashset here before making the recusrive call at all...
        for (int i = 0; i < 6; i++)
        {
            if (used.Add(pos + neighbors[i] * scale))
            {
                marchingCubesV2(pos + neighbors[i] * scale);
            }
        }
    }
コード例 #12
0
ファイル: AsteroidGenerator.cs プロジェクト: LatexBotox/SPACE
	void DeformMesh (Mesh mesh, PolygonCollider2D collider, int mult, int seed) {
		Vector3[] verts = mesh.vertices;
		Vector3[] normals = mesh.normals;
		
		PerlinNoise pnoise = new PerlinNoise(seed);

		Vector2[] colPoints = new Vector2[14];
		
		int j = 0;
		int k = 0;
		for(int i = 0; i < verts.Length;i++) {
			Vector3 v = normals[i];
			v.z = 0;
			verts[i] = verts[i]+v*(pnoise.FractalNoise3D(verts[i].x, verts[i].y, verts[i].z, (int)octaves/2, frequency*2, amplitude/2*mult));
			if (verts[i].z > -0.01) {
				if (k == 0)
					colPoints[j++%14] = verts[i];
				k = (k+1)%3;
			}
		}
		mesh.vertices = verts;
		collider.points = colPoints;
		mesh.RecalculateNormals();
		mesh.RecalculateBounds();
	}
コード例 #13
0
ファイル: AsteroidGenerator.cs プロジェクト: LatexBotox/SPACE
	void GenerateGenericTexture(Texture2D tex, Texture2D normal, Color asteroidColor, int seed) {
		float _x, _y, _z, noise;
		int width = tex.width;
		int height = tex.height;

		Color[] pix = new Color[width*height];
		Color[] pixn = new Color[width*height];
		
		noise = 0;
		
		Gradient[] gradients = MakeGenericGradients(asteroidColor);

		PerlinNoise pnoise = new PerlinNoise(seed);
		for(float y = 0; y < width;y++) {
			for(float x = 0; x < height;x++) {
				_x = (x/width-0.5f)*2;
				_y = (y/height-0.5f)*2;
				_z = Mathf.Sqrt (1 - Mathf.Pow (_x, 2) - Mathf.Pow (_y,2));
				
				noise = 0;
				if (_z>=0)
					noise = (pnoise.FractalNoise3D(_x, _y, _z, (int)octaves, frequency, amplitude));
				
				pix[(int)y*tex.width+(int)x] = gradients[0].Evaluate (1-Mathf.Abs (noise))*(1-Mathf.Abs (noise));
				pixn[(int)y*tex.width+(int)x] = gradients[1].Evaluate (1-Mathf.Abs (noise))*(1-Mathf.Abs (noise)*4);
			}
		}
		tex.SetPixels(pix);
		normal.SetPixels (HeightToNormal (pixn));
	}
コード例 #14
0
	void GenerateTerrain(float time) {

		PerlinNoise noiseGen = new PerlinNoise (0);

		for (int i = 0; i < _width; i++) {

			for (int j = 0; j < _height; j++) {

				float x = (float)i / (float)_width;
				float y = (float)j / (float)_height;

				float noise = noiseGen.FractalNoise3D(x, y, time, 2, _mapScale + 0.01f, 1.75f);

				_tileMap[i,j] = NoiseToTile (noise);
			}
		}
	}