Рендеринг OpenGL по сравнению с собственной Реализацией Освещения Phong

Я реализовал Схему Освещения Phong с помощью камеры, это центрируется в (0,0,0) и смотрящий непосредственно на примитивную сферу. Следующее является соответствующим содержанием файла сцены, который используется, чтобы просмотреть сцену с помощью OpenGL, а также представить сцену с помощью моей собственной реализации:

ambient 0 1 0

dir_light  1 1 1       -3 -4 -5

# A red sphere with 0.5 green ambiance, centered at (0,0,0) with radius 1
material  0 0.5 0  1 0 0    1 0 0   0 0 0  0 0 0  10 1 0
sphere   0    0 0 0    1   

Получающееся изображение производится OpenGL.

Изображение, которое производит мое приложение рендеринга.

Как Вы видите, существуют различные различия между двумя:

1. Зеркальная подсветка на моем изображении меньше, чем то в OpenGL.
2. Рассеянная поверхность, кажется, не рассеивается корректным способом, приводящим к желтому региону, чтобы быть излишне большой в моем изображении, тогда как в OpenGL существует хороший темно-зеленый регион ближе к нижней части сферы
3. Цвет, произведенный OpenGL, является намного более темным, чем тот в моем изображении.

Это - самые видные три различия, которые я вижу. Следующее является моей реализацией освещения Phong:

R3Rgb Phong(R3Scene *scene, R3Ray *ray, R3Intersection *intersection)
{
  R3Rgb radiance;
  if(intersection->hit == 0)
  {
    radiance = scene->background;
    return radiance;
  }

  R3Vector normal = intersection->normal;
  R3Rgb Kd = intersection->node->material->kd;
  R3Rgb Ks = intersection->node->material->ks;

  // obtain ambient term
  R3Rgb intensity_ambient = intersection->node->material->ka*scene->ambient;

  // obtain emissive term
  R3Rgb intensity_emission = intersection->node->material->emission;

  // for each light in the scene, obtain calculate the diffuse and specular terms
  R3Rgb intensity_diffuse(0,0,0,1);
  R3Rgb intensity_specular(0,0,0,1);
  for(unsigned int i = 0; i < scene->lights.size(); i++)
  {
    R3Light *light = scene->Light(i);
    R3Rgb light_color = LightIntensity(scene->Light(i), intersection->position);
    R3Vector light_vector = -LightDirection(scene->Light(i), intersection->position);

    // calculate diffuse reflection
    intensity_diffuse += Kd*normal.Dot(light_vector)*light_color;

    // calculate specular reflection
    R3Vector reflection_vector = 2.*normal.Dot(light_vector)*normal-light_vector;
    reflection_vector.Normalize();
    R3Vector viewing_vector = ray->Start() - intersection->position;
    viewing_vector.Normalize();
    double n = intersection->node->material->shininess;
    intensity_specular += Ks*pow(max(0.,viewing_vector.Dot(reflection_vector)),n)*light_color;

  }

  radiance = intensity_emission+intensity_ambient+intensity_diffuse+intensity_specular;
  return radiance;
}

Вот связанные LightIntensity (...), и LightDirection (...) функционирует:

R3Vector LightDirection(R3Light *light, R3Point position)
{
  R3Vector light_direction;
  switch(light->type)
  {
    case R3_DIRECTIONAL_LIGHT:
      light_direction = light->direction;
      break;

    case R3_POINT_LIGHT:
      light_direction = position-light->position;
      break;

    case R3_SPOT_LIGHT:
      light_direction = position-light->position;
      break;
  }
  light_direction.Normalize();
  return light_direction;
}

R3Rgb LightIntensity(R3Light *light, R3Point position)
{
  R3Rgb light_intensity; 
  double distance;
  double denominator;
  if(light->type != R3_DIRECTIONAL_LIGHT)
  {
    distance = (position-light->position).Length();
    denominator = light->constant_attenuation + 
                         light->linear_attenuation*distance + 
                         light->quadratic_attenuation*distance*distance;
  }   

  switch(light->type)
  {
    case R3_DIRECTIONAL_LIGHT:
      light_intensity = light->color;
      break;

    case R3_POINT_LIGHT:
      light_intensity = light->color/denominator;
      break;

    case R3_SPOT_LIGHT:
      R3Vector from_light_to_point = position - light->position;
      light_intensity = light->color*(
                        pow(light->direction.Dot(from_light_to_point),
                            light->angle_attenuation));
      break;
  }
  return light_intensity;
}

Я был бы очень признателен за любые предложения относительно любых ошибок реализации, которые очевидны. Я задаюсь вопросом, могли ли различия происходить просто из-за гамма значений, используемых для дисплея OpenGL и гамма значением по умолчанию для моего дисплея. Я также знаю, что OpenGL (или по крайней мере tha части, которые мне предоставили) не может наклонные тени на объектах. Не то, чтобы это важно для рассматриваемого вопроса, но он просто приводит меня задаваться вопросом, является ли это просто дисплей и различия в возможности между OpenGL и что я пытаюсь сделать.

Спасибо за помощь.