private static int get_closest_sphere(scene_class scene, double[] position, ref double[] vector, int exclude)
{
int output_sphere = -1;
double t_previous = double.MaxValue;
double t = 0;
for (int i = 0; i < scene.sphere.Count; i++)
{
if (i != exclude)
{
t = intersection_ray_sphere(position, vector, scene.sphere[i]);
if (t < t_previous)
{
t_previous = t;
output_sphere = i;
}
}
}
if (t_previous < double.MaxValue)
{
vector = vector_class.vector_scale(vector, t_previous);
}
return(output_sphere);
}
private static double[] sample_image(scene_class scene, System.Random random, int length, System.ComponentModel.BackgroundWorker background_worker)
{
double[] output_image = new double[length];
double[] pixel_color = new double[3];
int i = 0;
if (background_worker.CancellationPending)
{
return(output_image);
}
for (int y = 0; y < scene.image_height; y++)
{
for (int x = 0; x < scene.image_width; x++)
{
pixel_color = renderer_class.sample_pixel(scene,
x,
y,
random,
background_worker);
for (int n = 0; n < 3; n++)
{
output_image[i + n] = pixel_color[2 - n];
}
i += 3;
}
i += scene.image_width % 4;
}
return(output_image);
}
public renderer_class()
{
scene = new scene_class();
output_image_bitmap_data = new System.Drawing.Imaging.BitmapData();
output_image_pointer = (System.IntPtr) 0;
output_image_data_byte = new byte[0];
output_image_data_double = new double[0];
lock_object = new object();
}
private static double[] sample_pixel(scene_class scene, int x, int y, System.Random random, System.ComponentModel.BackgroundWorker background_worker)
{
double[] output_pixel = new double[3];
double[] position = new double[3];
double[] vector = new double[3];
position = scene.camera.position;
vector = scene.camera.get_vector(scene, x, y);
output_pixel = get_total_radiance(scene, x, y, random, position, vector);
return(output_pixel);
/*
* double[][] output_pixel = new double[5][];
* double[] teh_uber_output_pixel = new double[3];
* for (int i = 0; i < output_pixel.GetLength (0); i++)
* {
* output_pixel[i] = new double[3];
* }
*
*
* double[] position = new double[3];
* double[] vector = new double[3];
*
* for (int i = 0; i < output_pixel.GetLength (0); i++)
* {
* position = scene.camera.position;
* vector = scene.camera.get_vector (scene, x, y);
*
* output_pixel[i] = get_total_radiance (scene, x, y, random, position, vector);
* }
*
* teh_uber_output_pixel = output_pixel[0];
* for (int i = 1; i < output_pixel.GetLength (0); i++)
* {
* teh_uber_output_pixel = vector_class.vector_average (teh_uber_output_pixel, output_pixel[i], 1 / ((double)i + 1));
* }
*
* return teh_uber_output_pixel;
*/
}
public double[] get_vector(scene_class scene, int x_pixel, int y_pixel)
{
x = (double)x_pixel + random.NextDouble();
y = (double)y_pixel + random.NextDouble();
angle_x = (((x - image_width_half)) / image_width_half) * (scene.camera.view_angle_width * pi_180_half);
angle_y = (((image_height_half - y)) / image_height_half) * (scene.camera.view_angle_height * pi_180_half);
cos_angle_y = System.Math.Cos(angle_y);
v_scalar = System.Math.Sin(angle_y);
u_scalar = System.Math.Sin(angle_x) * cos_angle_y;
w_scalar = System.Math.Cos(angle_x) * cos_angle_y;
output_vector = vector_class.vector_add(vector_class.vector_add(vector_class.vector_scale(vector_u, u_scalar),
vector_class.vector_scale(vector_v, v_scalar)),
vector_class.vector_scale(vector_look, w_scalar));
return(output_vector);
}
private static int get_closest_triangle(scene_class scene, double[] position, ref double[] vector, int exclude)
{
int output_triangle = -1;
double t_previous = double.MaxValue;
double t = 0;
for (int i = 0; i < scene.triangle.Count; i++)
{
if (i != exclude)
{
t = intersection_ray_triangle(position, vector, scene.triangle[i]);
if (t > 0)
{
t = double.PositiveInfinity;
}
else
{
t = -t;
}
if (t < t_previous)
{
t_previous = t;
output_triangle = i;
}
}
}
if (t_previous < double.MaxValue)
{
vector = vector_class.vector_scale(vector, t_previous);
}
return(output_triangle);
}
private static double[] get_total_radiance(scene_class scene, int x, int y, System.Random random, double[] position, double[] vector)
{
double[] total_color_radiance = new double[3];
double[] vector_t = new double[3];
double[] vector_s = new double[3];
double[] multiplier = new double[3];
for (int i = 0; i < 3; i++)
{
multiplier[i] = 1;
}
double medium_refractive_index = 1.0008;
int triangle_hit = -1;
int sphere_hit = -1;
for (int i = 0; i < scene.ray_depth; i++)
{
vector_t = vector;
vector_s = vector;
triangle_hit = get_closest_triangle(scene, position, ref vector_t, triangle_hit);
sphere_hit = get_closest_sphere(scene, position, ref vector_s, sphere_hit);
if (vector_s != vector &&
(vector_t == vector ||
vector_class.vector_is_larger(vector_t, vector_s)))
{
vector = vector_s;
triangle_hit = -1;
if (sphere_hit != -1)
{
for (int n = 0; n < 3; n++)
{
total_color_radiance[n] += scene.material[scene.sphere[sphere_hit].material_index - 1].color[n].radiance;
}
if (i != scene.ray_depth - 1)
{
position = vector_class.vector_add(position, vector_class.vector_scale(vector, 1 - 0.000000001));
vector = scene.material[scene.sphere[sphere_hit].material_index - 1].get_next_direction_sphere(position, vector, scene.sphere[sphere_hit], ref medium_refractive_index, ref multiplier);
}
}
else
{
for (int n = 0; n < 3; n++)
{
total_color_radiance[n] += scene.sky_radiance[n];
}
break;
}
}
else
{
vector = vector_t;
sphere_hit = -1;
if (triangle_hit != -1)
{
for (int n = 0; n < 3; n++)
{
total_color_radiance[n] += scene.material[scene.triangle[triangle_hit].material_index - 1].color[n].radiance;
}
if (i != scene.ray_depth - 1)
{
position = vector_class.vector_add(position, vector_class.vector_scale(vector, 1 - 0.000000001));
vector = scene.material[scene.triangle[triangle_hit].material_index - 1].get_next_direction_triangle(vector, scene.triangle[triangle_hit], ref medium_refractive_index, ref multiplier);
}
}
else
{
for (int n = 0; n < 3; n++)
{
total_color_radiance[n] += scene.sky_radiance[n];
}
break;
}
}
}
for (int i = 0; i < 3; i++)
{
total_color_radiance[i] *= multiplier[i];
}
return(total_color_radiance);
}
