void Start()
    {
        filter = gameObject.GetComponent<MeshFilter>();
        coll = gameObject.GetComponent<MeshCollider>();

        //past here is just to set up an example chunk
        blocks = new Block[chunkSize, chunkSize, chunkSize];

        for (int x = 0; x < chunkSize; x++)
        {
            for (int y = 0; y < chunkSize; y++)
            {
                for (int z = 0; z < chunkSize; z++)
                {
                    blocks[x, y, z] = new BlockAir();
                }
            }
        }

        blocks[1, 1, 1] = new Block();
        blocks[1, 2, 1] = new Block();
        blocks[1, 2, 2] = new Block();
        blocks[2, 2, 2] = new Block();

        UpdateChunk();
    }

	// Use this for initialization
	void Start () {
		mesh = GetComponent<MeshFilter> ().mesh;
		meshC = GetComponent<MeshCollider> ();
		vertices = mesh.vertices;
		fireballs = GameObject.FindGameObjectsWithTag("Fireball");
		Debug.Log (vertices.Length);
	}

    // Use this for initialization
    void Start()
    {
        hmul = 1F / hardness;
        mf = GetComponent<MeshFilter> ();
        mc = GetComponent<MeshCollider> ();
        verts = mf.mesh.vertices;
        tris = mf.mesh.triangles;
        //mf.mesh.SetIndices (tris, MeshTopology.LineStrip, 0);

        connections = new VertexConnection[verts.Length];
        for (int i = 0; i < verts.Length; i++) {
            Vector3 P1 = verts [i];
            VertexConnection VC1 = connections [i];
            for (int n = i+1; n < verts.Length; n++) {
                if (P1 == verts [n]) {
                    var VC2 = connections [n];
                    if (VC2 == null)
                        VC2 = connections [n] = new VertexConnection ();
                    if (VC1 == null)
                        VC1 = connections [i] = new VertexConnection ();
                    VC1.connections.Add (n);
                    VC2.connections.Add (i);
                }
            }
        }
    }

 /// <summary>
 /// Initialized the components
 /// </summary>
 void Awake()
 {
     this.isoObj = GetComponent<IsoObject>();
     this.collider = GetComponent<MeshCollider>();
     collider.sharedMesh = createMesh();
     deltaSize = isoObj.Size;
 }

    public void GenerateMesh(int[,] map, float squareSize)
    {
        if(wallCollider == null)
        {
            wallCollider = walls.gameObject.AddComponent<MeshCollider> ();
        }
        outlines.Clear();
        checkedVertices.Clear ();
        triangleDictionary.Clear();

        squareGrid = new SquareGrid(map, squareSize);

        vertices = new List<Vector3>();
        triangles = new List<int>();

        for (int x = 0; x < squareGrid.squares.GetLength(0); x++)
        {
            for(int y =0; y < squareGrid.squares.GetLength(1); y++)
            {
                TriangulateSquare(squareGrid.squares[x,y]);
            }
        }

        Mesh mesh = new Mesh();
        cave.mesh = mesh;
        mesh.vertices = vertices.ToArray();
        mesh.triangles = triangles.ToArray();
        mesh.RecalculateNormals();

        if(!is2D) {
            CreateWallMesh();
        }
    }

		// Use this for initialization
		protected void Awake()
		{
			Filter = gameObject.GetComponent<MeshFilter>();
			Coll = gameObject.GetComponent<MeshCollider>();

			//past here is just to set up an example chunk
			//Blocks = new VoxBlock[ChunkSize, ChunkSize, ChunkSize];

			for (var x = 0; x < World.ChunkSize; x++)
			{
				for (var y = 0; y < World.ChunkSize; y++)
				{
					for (var z = 0; z < World.ChunkSize; z++)
					{
						Blocks[x, y, z] = new Block(Color.white) { BlockType = VoxBlockType.Empty };
					}
				}
			}

			//Blocks[1, 14, 1] = new VoxBlock();

			//Blocks[3, 5, 2] = new VoxBlock();
			//Blocks[4, 5, 2] = new VoxBlock();


			//UpdateChunk();

		}

 // Use this for initialization
 void Start()
 {
     // check this node for mReferenceCollider
     if (mReferenceCollider == null) {
         mReferenceCollider = this.GetComponent<BoxCollider>();
     }
     if (mReferenceCollider == null) {
         mReferenceCollider = this.GetComponent<SphereCollider>();
     }
     if (mReferenceCollider == null) {
         mReferenceCollider = this.GetComponent<CapsuleCollider>(); // unlikely.
     }
     // check the parent node for mReferenceCollider
     if (mReferenceCollider == null) {
         mReferenceCollider = this.transform.parent.GetComponent<BoxCollider>();
     }
     if (mReferenceCollider == null) {
         mReferenceCollider = this.transform.parent.GetComponent<SphereCollider>();
     }
     if (mReferenceCollider == null) {
         mReferenceCollider = this.transform.parent.GetComponent<CapsuleCollider>(); // unlikely.
     }
     if (mMeshCollider == null) {
         mMeshCollider = this.GetComponent<MeshCollider>();
     }
 }

 void Start()
 {
     collider=GetComponent<MeshCollider>();
     startRot=transform.rotation;
     rbody=GetComponent<Rigidbody>();
     startPos=transform.position;
 }

	private void BuildMesh (MeshFilter mf, MeshRenderer mr, MeshCollider mc, int i, int j) {
		Mesh mesh = new Mesh();
		mesh.Clear();
		
		// the vertices of our new mesh, separated into two groups
		Vector3[] inner = new Vector3[grid.smoothness + 1]; // the inner vertices (closer to the centre)
		Vector3[] outer = new Vector3[grid.smoothness + 1]; // the outer vertices

		// vertices must be given in local space
		Transform trnsfrm = mf.gameObject.transform;
		
		// the amount of vertices depends on how much the grid is smoothed
		for (int k = 0; k < grid.smoothness + 1; k++) {
			// rad is the current distance from the centre, sctr is the current sector and i * (1.0f / grid.smoothness) is the fraction inside the current sector
			inner[k] = trnsfrm.InverseTransformPoint(grid.GridToWorld(new Vector3(i, j + k * (1.0f / grid.smoothness), 0)));
			outer[k] = trnsfrm.InverseTransformPoint(grid.GridToWorld(new Vector3(i + 1, j + k * (1.0f / grid.smoothness), 0)));
		}
		
		//this is wher the actual vertices go
		Vector3[] vertices = new Vector3[2 * (grid.smoothness + 1)];
		// copy the sorted vertices into the new array
		inner.CopyTo(vertices, 0);
		// for each inner vertex its outer counterpart has the same index plus grid.smoothness + 1, this will be relevant later
		outer.CopyTo(vertices, grid.smoothness + 1);
		// assign them as the vertices of the mesh
		mesh.vertices = vertices;
		
		// now we have to assign the triangles
		int[] triangles = new int[6 * grid.smoothness]; // for each smoothing step we need two triangles and each triangle is three indices
		int counter = 0; // keeps track of the current index
		for (int k = 0; k < grid.smoothness; k++) {
			// triangles are assigned in a clockwise fashion
			triangles[counter] = k;
			triangles[counter+1] = k + (grid.smoothness + 1) + 1;
			triangles[counter+2] = k + (grid.smoothness + 1);
			
			triangles[counter+3] = k + 1;
			triangles[counter+4] = k + (grid.smoothness + 1) + 1;
			triangles[counter+5] = k;

			counter += 6; // increment the counter for the nex six indices
		}
		mesh.triangles = triangles;
		
		// add some dummy UVs to keep the shader happy or else it complains, but they are not used in this example
		Vector2[] uvs = new Vector2[vertices.Length];
        for (int k = 0; k < uvs.Length; k++) {
            uvs[k] = new Vector2(vertices[k].x, vertices[k].y);
        }
        mesh.uv = uvs;
		
		// the usual cleanup
		mesh.RecalculateNormals();
		mesh.RecalculateBounds();
		mesh.Optimize();
		
		// assign the mesh  to the mesh filter and mesh collider
		mf.mesh = mesh;
		mc.sharedMesh = mesh;
	}

 private void pStart()
 {
     _collider = (MeshCollider)gameObject.collider;
         //this sets the collider mesh to equal the objects mesh filter.
         //May not be required if you aren't using 2D Toolkit
         _collider.sharedMesh = gameObject.GetComponent<MeshFilter>().sharedMesh;
 }

	public void DuplicateOldChunk(string ChunkData)
	{
		meshCollider = GetComponent<MeshCollider>();
		map = new byte[width, width, width];
		int iter = 0;
		for (int x = 0; x < width; x++)
		{
			for (int z = 0; z < width; z++)
			{
				//make the bottom layer of the chunk all solid blocks
				if(ChunkData[iter] == '0')
					map[x,0,z]=0;
				else
					map[x,0,z]=1;
				iter++;
				//make the second layer of the chunk random
				if(ChunkData[iter] == '0')
					map[x,1,z]=0;
				else
					map[x,1,z]=1;
				iter++;
			}
		}
		mesh = new Mesh();
		GetComponent<MeshFilter>().mesh = mesh;
		Regenerate();
	}

 // Use this for initialization
 void Awake()
 {
     rMesh = gameObject.GetComponent<MeshRenderer>();
     fMesh = gameObject.GetComponent<MeshFilter>();
     cMesh = gameObject.GetComponent<MeshCollider>();
     mesh = new Mesh();
 }

	void Awake () {
		anim = GetComponent<Animator>();
		SFX = GetComponent<AudioSource>();
		health = startingHealth;
		meshCollider = GetComponent<MeshCollider>();
		meshCollider.enabled = false;
	}

    // Use this for initialization
    void Start()
    {
        world = GameObject.FindWithTag("world").GetComponent("World") as World;

        displayBlock = new BlockSelect();
        filter = gameObject.GetComponent<MeshFilter>();
        coll = gameObject.GetComponent<MeshCollider>();
    }

    void Start()
	{
		if (DataManager == null) 
			DataManager = GetManager.GetDataManager ();	// need a better way to do this, keep references in a static object..!
		HasInitialLoad = false;
        filter = gameObject.GetComponent<MeshFilter>();
        coll = gameObject.GetComponent<MeshCollider>();
    }

		public void Initialize (World world, Chunk chunk, MeshFilter meshFilter, MeshCollider meshCollider)
		{
				this.meshFilter = meshFilter;
				this.meshCollider = meshCollider;
				this.chunk = chunk;
				this.world = world;
				this.lastLevelY = world.LevelY;
		}

	void Start(){
		mesh = GetComponent<MeshFilter>().mesh;
		meshCollider = GetComponent<MeshCollider>();

		GenerateTerrain();
		BuildMesh();
		UpdateMesh();
	}

 public void Initialize(Block[, ,] data, int size, Material material, Terrain world)
 {
     _meshFilter = GetComponent<MeshFilter>();
     _meshCollider = GetComponent<MeshCollider>();
     GetComponent<MeshRenderer>().material = material;
     this._data = data;
     _size = size;
     _parentWorld = world;
 }

 /// <summary>
 /// <para>Constructor for conveniently filling out a SurfaceData struct.</para>
 /// </summary>
 /// <param name="_id">ID for the surface in question.</param>
 /// <param name="_outputMesh">MeshFilter to write Mesh data to.</param>
 /// <param name="_outputAnchor">WorldAnchor receiving the anchor point for the surface.</param>
 /// <param name="_outputCollider">MeshCollider to write baked physics data to (optional).</param>
 /// <param name="_trianglesPerCubicMeter">Requested resolution for the computed Mesh.  Actual resolution may be less than this value.</param>
 /// <param name="_bakeCollider">Set to true if collider baking is/has been requested.</param>
 public SurfaceData(SurfaceId _id, MeshFilter _outputMesh, WorldAnchor _outputAnchor, MeshCollider _outputCollider, float _trianglesPerCubicMeter, bool _bakeCollider)
 {
     this.id = _id;
     this.outputMesh = _outputMesh;
     this.outputAnchor = _outputAnchor;
     this.outputCollider = _outputCollider;
     this.trianglesPerCubicMeter = _trianglesPerCubicMeter;
     this.bakeCollider = _bakeCollider;
 }

    private CWeightList[] nodeWeights; // array of node weights (one per node)

    #endregion Fields

    #region Methods

    // Function:    Start
    //      This basically translates the information about the skinned mesh into
    // data that we can internally use to quickly update the collision mesh.
    void Start()
    {
        SkinnedMeshRenderer rend = GetComponent(typeof(SkinnedMeshRenderer)) as SkinnedMeshRenderer;
        collide = GetComponent(typeof(MeshCollider)) as MeshCollider;

        if (collide!=null && rend!=null)
        {
            Mesh baseMesh = rend.sharedMesh;
            mesh = new Mesh();
            mesh.vertices = baseMesh.vertices;
            mesh.uv = baseMesh.uv;
            mesh.triangles = baseMesh.triangles;
            newVert = new Vector3[baseMesh.vertices.Length];

            short i;
            // Make a CWeightList for each bone in the skinned mesh
            nodeWeights = new CWeightList[rend.bones.Length];
            for ( i=0 ; i<rend.bones.Length ; i++ )
            {
                nodeWeights[i] = new CWeightList();
                nodeWeights[i].transform = rend.bones[i];
            }

            // Create a bone weight list for each bone, ready for quick calculation during an update...
            Vector3 localPt;
            for ( i=0 ; i<baseMesh.vertices.Length ; i++ )
            {
                BoneWeight bw = baseMesh.boneWeights[i];
                if (bw.weight0!=0.0f)
                {
                    localPt = baseMesh.bindposes[bw.boneIndex0].MultiplyPoint3x4( baseMesh.vertices[i] );
                    nodeWeights[bw.boneIndex0].weights.Add( new CVertexWeight( i, localPt, bw.weight0 ) );
                }
                if (bw.weight1!=0.0f)
                {
                    localPt = baseMesh.bindposes[bw.boneIndex1].MultiplyPoint3x4( baseMesh.vertices[i] );
                    nodeWeights[bw.boneIndex1].weights.Add( new CVertexWeight( i, localPt, bw.weight1 ) );
                }
                if (bw.weight2!=0.0f)
                {
                    localPt = baseMesh.bindposes[bw.boneIndex2].MultiplyPoint3x4( baseMesh.vertices[i] );
                    nodeWeights[bw.boneIndex2].weights.Add( new CVertexWeight( i, localPt, bw.weight2 ) );
                }
                if (bw.weight3!=0.0f)
                {
                    localPt = baseMesh.bindposes[bw.boneIndex3].MultiplyPoint3x4( baseMesh.vertices[i] );
                    nodeWeights[bw.boneIndex3].weights.Add( new CVertexWeight( i, localPt, bw.weight3 ) );
                }
            }

            UpdateCollisionMesh();
        }
        else
        {
            Debug.LogError(gameObject.name + ": SkinnedCollisionHelper: this object either has no SkinnedMeshRenderer or has no MeshCollider!");
        }
    }