/*******************************************************************************
 * Copyright 2011 See AUTHORS file.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 ******************************************************************************/

package com.badlogic.gdx.graphics.g3d.particles.values;

import com.badlogic.gdx.graphics.VertexAttributes;
import com.badlogic.gdx.graphics.VertexAttributes.Usage;
import com.badlogic.gdx.math.CumulativeDistribution;
import com.badlogic.gdx.math.MathUtils;
import com.badlogic.gdx.math.Vector3;

/** Encapsulate the formulas to spawn a particle on a mesh shape dealing with not uniform area triangles.
 * @author Inferno */
public final class WeightMeshSpawnShapeValue extends MeshSpawnShapeValue {

	private CumulativeDistribution<Triangle> distribution;

	public WeightMeshSpawnShapeValue (WeightMeshSpawnShapeValue value) {
		super(value);
		distribution = new CumulativeDistribution<Triangle>();
		load(value);
	}

	public WeightMeshSpawnShapeValue () {
		super();
		distribution = new CumulativeDistribution<Triangle>();
	}

	@Override
	public void init () {
		calculateWeights();
	}

	/** Calculate the weights of each triangle of the wrapped mesh. If the mesh has indices: the function will calculate the weight
	 * of those triangles. If the mesh has not indices: the function will consider the vertices as a triangle strip. */
	public void calculateWeights () {
		distribution.clear();
		VertexAttributes attributes = mesh.getVertexAttributes();
		int indicesCount = mesh.getNumIndices();
		int vertexCount = mesh.getNumVertices();
		int vertexSize = (short)(attributes.vertexSize / 4), positionOffset = (short)(attributes.findByUsage(Usage.Position).offset / 4);
		float[] vertices = new float[vertexCount * vertexSize];
		mesh.getVertices(vertices);
		if (indicesCount > 0) {
			short[] indices = new short[indicesCount];
			mesh.getIndices(indices);

			// Calculate the Area
			for (int i = 0; i < indicesCount; i += 3) {
				int p1Offset = indices[i] * vertexSize + positionOffset, p2Offset = indices[i + 1] * vertexSize + positionOffset, p3Offset = indices[i + 2]
					* vertexSize + positionOffset;
				float x1 = vertices[p1Offset], y1 = vertices[p1Offset + 1], z1 = vertices[p1Offset + 2], x2 = vertices[p2Offset], y2 = vertices[p2Offset + 1], z2 = vertices[p2Offset + 2], x3 = vertices[p3Offset], y3 = vertices[p3Offset + 1], z3 = vertices[p3Offset + 2];
				float area = Math.abs((x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2f);
				distribution.add(new Triangle(x1, y1, z1, x2, y2, z2, x3, y3, z3), area);
			}
		} else {
			// Calculate the Area
			for (int i = 0; i < vertexCount; i += vertexSize) {
				int p1Offset = i + positionOffset, p2Offset = p1Offset + vertexSize, p3Offset = p2Offset + vertexSize;
				float x1 = vertices[p1Offset], y1 = vertices[p1Offset + 1], z1 = vertices[p1Offset + 2], x2 = vertices[p2Offset], y2 = vertices[p2Offset + 1], z2 = vertices[p2Offset + 2], x3 = vertices[p3Offset], y3 = vertices[p3Offset + 1], z3 = vertices[p3Offset + 2];
				float area = Math.abs((x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2f);
				distribution.add(new Triangle(x1, y1, z1, x2, y2, z2, x3, y3, z3), area);
			}
		}

		// Generate cumulative distribution
		distribution.generateNormalized();
	}

	@Override
	public void spawnAux (Vector3 vector, float percent) {
		Triangle t = distribution.value();
		float a = MathUtils.random(), b = MathUtils.random();
		vector.set(t.x1 + a * (t.x2 - t.x1) + b * (t.x3 - t.x1), t.y1 + a * (t.y2 - t.y1) + b * (t.y3 - t.y1), t.z1 + a
			* (t.z2 - t.z1) + b * (t.z3 - t.z1));
	}

	@Override
	public SpawnShapeValue copy () {
		return new WeightMeshSpawnShapeValue(this);
	}

}