//
// util.cc
//
// Various utility functions
//
// Copyright (C) 1999.11.21
//

#include <cassert>

#include "util.h"
#include "triangle3d.h"

#if 1
/**
 * Calculate the surface normal at each point3d
 * @param size	width of square
 * @param p3d	array of points which make up square
 * @param v3d	array of vectors in which to store calculated surface normals
 */
void util::get_normal(int size, const point3d* p3d, vector3d* v3d)
{
	assert(p3d);
	assert(v3d);

	int index = 0;
	for (int z=0; z<size; z++) {
		for (int x=0; x<size; x++) {

			int up, down, left, right;

			// Pick 4 adjacent points, adjusting for edges
			if (z == 0) {
				up = index;
			} else {
				up = index - size;
			}
			if (z == size-1) {
				down = index;
			} else {
				down = index + size;
			}
			if (x == 0) {
				left = index;	
			} else {
				left = index - 1;
			}
			if (x == size-1) {
				right = index;	
			} else {
				right = index + 1;
			}

			// Average out the points to make the normal
			float ii, jj, kk;
			ii = jj = kk = 0.0;


			// Top left
			if (x > 0 && z > 0) {
				triangle3d t(index, left, up);
				t.calculate_normal(p3d);
				ii += t.normal.i;
				jj += t.normal.j;
				kk += t.normal.k;
			}

			// Top right
			if (x < size-1 && z > 0) {
				triangle3d t(index, up, right);
				t.calculate_normal(p3d);
				ii += t.normal.i;
				jj += t.normal.j;
				kk += t.normal.k;
			}

			// Bottom right
			if (x < size-1 && z < size-1) {
				triangle3d t(index, right, down);
				t.calculate_normal(p3d);
				ii += t.normal.i;
				jj += t.normal.j;
				kk += t.normal.k;
			}

			// Bottom left
			if (x > 0 && z < size-1) {
				triangle3d t(index, right, down);
				t.calculate_normal(p3d);
				ii += t.normal.i;
				jj += t.normal.j;
				kk += t.normal.k;
			}


			v3d[index] = vector3d(ii, jj, kk);

			v3d[index].normalise();

			// Next point...
			index++;
		}
	}
}
#endif	// 0


#if 0
//
// Calculate the surface normal at each point3d
//
void util::get_normal(int size, const point3d* p3d, vector3d* v3d)
{
	assert(p3d);
	assert(v3d);

	int index = 0;
	for (int z=0; z<size; z++) {
		for (int x=0; x<size; x++) {

			int vector_count = 0;
			int up, down, left, right;

			vector3d total(0.0, 0.0, 0.0);

			// Pick 4 adjacent points, adjusting for edges
			if (z != 0) {

				up = index - size;
				vector3d v = p3d[up] - p3d[index];
if (index == 4) {
	cout << v << endl;
}
				total = total + v;
				vector_count++;
			}


			if (x != size-1) {

				right = index + 1;
				vector3d v = p3d[right] - p3d[index];
if (index == 4) {
	cout << v << endl;
}				total = total + v;
				vector_count++;
			}


			if (z != size-1) {

				down = index + size;
				vector3d v = p3d[down] - p3d[index];
if (index == 4) {
	cout << v << endl;
}				total = total + v;
				vector_count++;
			}


			if (x != 0) {

				left = index - 1;
				vector3d v = p3d[left] - p3d[index];
if (index == 4) {
	cout << v << endl;
}				total = total + v;
				vector_count++;
			}


			assert(vector_count);
if (index == 4) {
	cout << total << endl;
}
			total.i /= vector_count;
			total.j /= vector_count;
			total.k /= vector_count;

			total.j = 1.0;

			total.normalise();

			v3d[index] = total;


			// Next point...
			index++;
		}
	}
}
#endif	// 0