return p;
    }

    private static DoubleBuffer getTextureCoordinates(int density)
	{
		if (density < 1)
			density = 1;

		// Approximate 1 to avoid shearing off of right and top skirts in SurfaceTileRenderer.
		// TODO: dig into this more: why are the skirts being sheared off?
		final double one = 0.999999;

		DoubleBuffer p = parameterizations.get(density);
		if (p != null)
			return p;

		int coordCount = (density + 3) * (density + 3);
		p = BufferUtil.newDoubleBuffer(2 * coordCount);
		double delta = 1d / density;
		int k = 2 * (density + 3);
		for (int j = 0; j < density; j++)
		{
			double v = j * delta;

			// skirt column; duplicate first column
			p.put(k++, 0d);
			p.put(k++, v);

			// interior columns
			for (int i = 0; i < density; i++)
			{
				p.put(k++, i * delta); // u
				p.put(k++, v);
			}

			// last interior column; force u to 1.
			p.put(k++, one);//1d);
			p.put(k++, v);

			// skirt column; duplicate previous column
			p.put(k++, one);//1d);
			p.put(k++, v);
		}

		// Last interior row
		//noinspection UnnecessaryLocalVariable
		double v = one;//1d;
		p.put(k++, 0d); // skirt column
		p.put(k++, v);

		for (int i = 0; i < density; i++)
		{
			p.put(k++, i * delta); // u
			p.put(k++, v);
		}
		p.put(k++, one);//1d); // last interior column
		p.put(k++, v);

		p.put(k++, one);//1d); // skirt column
		p.put(k++, v);

		// last skirt row
		int kk = k - 2 * (density + 3);
		for (int i = 0; i < density + 3; i++)
		{
			p.put(k++, p.get(kk++));
			p.put(k++, p.get(kk++));
		}

		// first skirt row
		k = 0;
		kk = 2 * (density + 3);
		for (int i = 0; i < density + 3; i++)
		{
			p.put(k++, p.get(kk++));
			p.put(k++, p.get(kk++));
		}

		parameterizations.put(density, p);

		return p;
	}

	protected static IntBuffer getIndices(int density)
	{
		if (density < 1)
			density = 1;

		// return a pre-computed buffer if possible.
		java.nio.IntBuffer buffer = indexLists.get(density);
		if (buffer != null)
			return buffer;

		int sideSize = density + 2;

		int indexCount = 2 * sideSize * sideSize + 4 * sideSize - 2;
		buffer = BufferUtil.newIntBuffer(indexCount);
		int k = 0;
		for (int i = 0; i < sideSize; i++)
		{
			buffer.put(k);
			if (i > 0)
			{
				buffer.put(++k);
				buffer.put(k);
			}

			if (i % 2 == 0) // even
			{
				buffer.put(++k);
				for (int j = 0; j < sideSize; j++)
				{
					k += sideSize;
					buffer.put(k);
					buffer.put(++k);
				}
			}
			else
			// odd
			{
				buffer.put(--k);
				for (int j = 0; j < sideSize; j++)
				{
					k -= sideSize;
					buffer.put(k);
					buffer.put(--k);
				}
			}
		}

		indexLists.put(density, buffer);

		return buffer;
	}

	//calculates normals quickly, but uses 4 surrounding vertices
	//instead of average of connected faces
	protected static DoubleBuffer getNormalsQuick(int density,
			DoubleBuffer vertices, Vec4 referenceCenter)
	{
		int side = density + 3;
		int numVertices = side * side;
		java.nio.DoubleBuffer normals = BufferUtil
				.newDoubleBuffer(numVertices * 3);
		Vec4 p0, p1, p2, p3, p4;

		//don't calculate skirt normals yet
		for (int j = 1; j < side - 1; j++)
		{
			for (int i = 1; i < side - 1; i++)
			{
				int index0 = j * side + i;
				int index1 = j * side + (i - 1);
				int index2 = j * side + (i + 1);
				int index3 = (j - 1) * side + i;
				int index4 = (j + 1) * side + i;
				p0 = getVec4(index0, vertices, referenceCenter);
				p1 = getVec4(index1, vertices, referenceCenter);
				p2 = getVec4(index2, vertices, referenceCenter);
				p3 = getVec4(index3, vertices, referenceCenter);
				p4 = getVec4(index4, vertices, referenceCenter);

				Vec4 n1 = p0.subtract3(p1).normalize3().cross3(
						p0.subtract3(p3).normalize3());
				Vec4 n2 = p0.subtract3(p2).normalize3().cross3(
						p0.subtract3(p4).normalize3());
				Vec4 normal = n1.add3(n2).normalize3();

				normals.put(index0 * 3, normal.x).put(index0 * 3 + 1, normal.y)
						.put(index0 * 3 + 2, normal.z);
			}
		}

		//copy skirt normals from neighbours
		for (int i = 1; i < side - 1; i++)
		{
			int di = i;
			int si = side + i;
			copyNormalInBuffer(si, di, normals);

			di = side * (side - 1) + i;
			si = side * (side - 2) + i;
			copyNormalInBuffer(si, di, normals);
		}
		for (int i = 0; i < side; i++)
		{
			int di = i * side;
			int si = i * side + 1;
			copyNormalInBuffer(si, di, normals);

			di = i * side + (side - 1);
			si = i * side + (side - 2);
			copyNormalInBuffer(si, di, normals);
		}

		return normals;
	}

	private static Vec4 getVec4(int index, DoubleBuffer vertices,
			Vec4 referenceCenter)
	{
		return new Vec4(vertices.get(index * 3) + referenceCenter.x, vertices
				.get(index * 3 + 1)
				+ referenceCenter.y, vertices.get(index * 3 + 2)
				+ referenceCenter.z);
	}

	private static void copyNormalInBuffer(int srcIndex, int dstIndex,
			DoubleBuffer normals)
	{
		normals.put(dstIndex * 3, normals.get(srcIndex * 3));
		normals.put(dstIndex * 3 + 1, normals.get(srcIndex * 3 + 1));
		normals.put(dstIndex * 3 + 2, normals.get(srcIndex * 3 + 2));
	}

	//computes normals for the triangle strip
	protected static java.nio.DoubleBuffer getNormals(int density,
			DoubleBuffer vertices, java.nio.IntBuffer indices,
			Vec4 referenceCenter)
	{
		int side = density + 3;
		int numVertices = side * side;
		int numFaces = indices.limit() - 2;
		double centerX = referenceCenter.x;
		double centerY = referenceCenter.y;
		double centerZ = referenceCenter.z;
		// Create normal buffer
		java.nio.DoubleBuffer normals = BufferUtil
				.newDoubleBuffer(numVertices * 3);
		int[] counts = new int[numVertices];
		Vec4[] norms = new Vec4[numVertices];
		for (int i = 0; i < numVertices; i++)
			norms[i] = new Vec4(0d);

		for (int i = 0; i < numFaces; i++)
		{
			//get vertex indices
			int index0 = indices.get(i);
			int index1 = indices.get(i + 1);
			int index2 = indices.get(i + 2);

			//get verts involved in current face
			Vec4 v0 = new Vec4(vertices.get(index0 * 3) + centerX, vertices
					.get(index0 * 3 + 1)
					+ centerY, vertices.get(index0 * 3 + 2) + centerZ);

			Vec4 v1 = new Vec4(vertices.get(index1 * 3) + centerX, vertices
					.get(index1 * 3 + 1)
					+ centerY, vertices.get(index1 * 3 + 2) + centerZ);

			Vec4 v2 = new Vec4(vertices.get(index2 * 3) + centerX, vertices
					.get(index2 * 3 + 1)
					+ centerY, vertices.get(index2 * 3 + 2) + centerZ);

			// get triangle edge vectors and plane normal
			Vec4 e1 = v1.subtract3(v0), e2;
			if (i % 2 == 0)
				e2 = v2.subtract3(v0);
			else
				e2 = v0.subtract3(v2);
			Vec4 N = e1.cross3(e2).normalize3(); // if N is 0, the triangle is degenerate

            if (N.getLength3() > 0)
            {
                // Store the face's normal for each of the vertices that make up the face.
                norms[index0] = norms[index0].add3(N);
                norms[index1] = norms[index1].add3(N);
                norms[index2] = norms[index2].add3(N);

                //increment vertex normal counts
                counts[index0]++;
                counts[index1]++;
                counts[index2]++;
            }
        }

		// Now loop through each vertex, and average out all the normals stored.
		for (int i = 0; i < numVertices; i++)
		{
            if (counts[i] > 0)
                norms[i] = norms[i].divide3(counts[i]).normalize3();
			int index = i * 3;
			normals.put(index++, norms[i].x).put(index++, norms[i].y).put(
					index, norms[i].z);
		}

		return normals;
	}

	// TODO: The following method was brought over from BasicRectangularTessellator and is unchecked.
	// Compute normals for a strip
	/*protected static java.nio.DoubleBuffer getNormals(int density,
			DoubleBuffer vertices, java.nio.IntBuffer indices,
			Vec4 referenceCenter)
	{
		int numVertices = (density + 3) * (density + 3);
		int sideSize = density + 2;
		int numFaces = indices.limit() - 2;
		double centerX = referenceCenter.x;
		double centerY = referenceCenter.y;
		double centerZ = referenceCenter.z;
		// Create normal buffer
		java.nio.DoubleBuffer normals = BufferUtil
				.newDoubleBuffer(numVertices * 3);
		// Create per vertex normal lists
		List<List<Vec4>> normalLists = new ArrayList<List<Vec4>>(numVertices);
		for (int i = 0; i < numVertices; i++)
			normalLists.add(i, new ArrayList<Vec4>());
		// Go through all faces in the strip and store normals in lists
		for (int i = 0; i < numFaces; i++)
		{
			int vIndex = 3 * indices.get(i);
			Vec4 v0 = new Vec4((vertices.get(vIndex++) + centerX), (vertices
					.get(vIndex++) + centerY), (vertices.get(vIndex) + centerZ));

			vIndex = 3 * indices.get(i + 1);
			Vec4 v1 = new Vec4((vertices.get(vIndex++) + centerX), (vertices
					.get(vIndex++) + centerY), (vertices.get(vIndex) + centerZ));

			vIndex = 3 * indices.get(i + 2);
			Vec4 v2 = new Vec4((vertices.get(vIndex++) + centerX), (vertices
					.get(vIndex++) + centerY), (vertices.get(vIndex) + centerZ));

			// get triangle edge vectors and plane normal
			Vec4 e1 = v1.subtract3(v0);
			Vec4 e2 = v2.subtract3(v0);
			Vec4 N = e1.cross3(e2).normalize3(); // if N is 0, the triangle is degenerate

			// Store the face's normal for each of the vertices that make up the face.
			// TODO: Clear up warnings here
			normalLists.get(indices.get(i)).add(N);
			normalLists.get(indices.get(i + 1)).add(N);
			normalLists.get(indices.get(i + 2)).add(N);
			//System.out.println("Normal: " + N);
		}

		// Now loop through each vertex, and average out all the normals stored.
		int idx = 0;
		for (int i = 0; i < numVertices; i++)
		{
			Vec4 normal = Vec4.ZERO;
			// Sum
			for (int j = 0; j < normalLists.get(i).size(); ++j)
				normal = normal.add3(normalLists.get(i).get(j));
			// Average
			normal = normal.multiply3(1.0f / normalLists.get(i).size())
					.normalize3();
			// Fill normal buffer
			normals.put(idx++, normal.x);
			normals.put(idx++, normal.y);
			normals.put(idx++, normal.z);
			//System.out.println("Normal: " + normal + " - " + normalLists[i].size());
			//System.out.println("Normal buffer: " + normals.get(idx - 3) + ", " + normals.get(idx - 2) + ", " + normals.get(idx - 1));
		}

		return normals;
	}*/


    private SectorGeometry.ExtractedShapeDescription getIntersectingTessellationPieces(RectTile tile, Plane[] planes)
    {
        tile.ri.vertices.rewind();
        tile.ri.indices.rewind();

        Vec4 offset = tile.ri.referenceCenter;
        if (offset == null)
            offset = new Vec4(0.0);

        int trianglesNum = tile.ri.indices.capacity() - 2;

        int[] indices = new int[3];
        double[] coords = new double[3];

        SectorGeometry.ExtractedShapeDescription clippedTriangleList = null;
        for (int i = 0; i < trianglesNum; i++)
        {
            tile.ri.indices.position(i);
            tile.ri.indices.get(indices);

            if ((indices[0] == indices[1]) || (indices[0] == indices[2]) ||
                (indices[1] == indices[2]))
                // degenerate triangle
                continue;
            Vec4[] triVerts = new Vec4[3];
            for (int j=0 ; j<3 ; j++)
            {
                tile.ri.vertices.position(3 * indices[j]);
                tile.ri.vertices.get(c