private void read_triangles()
{
int index = 0;
while (text_read_letter() == 't')
{
triangle_class triangle_temporary;
triangle_temporary = new triangle_class();
for (int i = 0; i < 3; i++)
{
index = (int)text_read_number();
for (int n = 0; n < 3; n++)
{
triangle_temporary.vertex[i][n] = vertex[index - 1][n];
}
}
triangle_temporary.material_index = (int)text_read_number();
triangle_temporary.initialize();
triangle.Add(triangle_temporary);
}
}
public double[] get_next_direction_triangle(double[] input_vector, triangle_class input_triangle, ref double incidence_ior, ref double[] multiplier)
{
double[] output_vector = new double[3];
double[] random_vector = new double[3];
double a, b, c, angle, radius;
angle = 2 * System.Math.PI * random.NextDouble();
radius = System.Math.Sqrt(random.NextDouble());
a = System.Math.Sin(angle) * radius;
b = System.Math.Cos(angle) * radius;
c = System.Math.Sqrt(1.0 - (a * a + b * b));
if (vector_class.vector_dot_product(input_triangle.normal, input_vector) > 0)
{
input_triangle.normal = vector_class.vector_negative(input_triangle.normal);
}
random_vector = vector_class.vector_add(vector_class.vector_add(vector_class.vector_scale(input_triangle.v, b),
vector_class.vector_scale(input_triangle.u, a)),
vector_class.vector_scale(input_triangle.normal, c));
if (random.NextDouble() * (reflectivity_mean + refractivity_mean) < reflectivity_mean) //reflect
{
output_vector = vector_class.vector_average(random_vector,
get_reflection(input_vector, input_triangle.normal),
reflect_glossiness);
for (int n = 0; n < 3; n++)
{
multiplier[n] *= color[n].reflectivity;
}
}
else //refract
{
output_vector = vector_class.vector_average(vector_class.vector_negative(random_vector),
get_refraction(input_vector, input_triangle.normal, incidence_ior, ref multiplier),
refract_glossiness);
for (int n = 0; n < 3; n++)
{
multiplier[n] *= color[n].refractivity;
}
incidence_ior = refractive_index;
}
return(output_vector);
}
public static double intersection_ray_triangle(double[] position, double[] vector, triangle_class triangle)
{
double output_t;
double[] vector_t, vector_p, vector_q;
double determinant, determinant_inverse;
double t, u, v;
double tolerance;
output_t = double.PositiveInfinity;
vector_t = new double[3];
vector_p = new double[3];
vector_q = new double[3];
determinant = 0;
determinant_inverse = 0;
t = 0;
u = 0;
v = 0;
tolerance = 0.000000001;
vector_p = vector_class.vector_cross_product(vector, triangle.edge_2);
determinant = vector_class.vector_dot_product(triangle.edge_1, vector_p);
if (determinant > -tolerance &&
determinant < tolerance)
{
return(output_t);
}
determinant_inverse = 1.0 / determinant;
vector_t = vector_class.vector_from_2_positions(position, triangle.vertex[0]);
u = vector_class.vector_dot_product(vector_t, vector_p) * determinant_inverse;
if (u < 0 ||
u > 1)
{
return(output_t);
}
vector_q = vector_class.vector_cross_product(vector_t, triangle.edge_1);
v = vector_class.vector_dot_product(vector, vector_q) * determinant_inverse;
if (v < 0 ||
v + u > 1)
{
return(output_t);
}
t = vector_class.vector_dot_product(triangle.edge_2, vector_q) * determinant_inverse;
output_t = t;
return(output_t);
}
