Не удается заставить Gouraud Shading в OpenGL работать

затенение из-за источника света, но я бы хотел, чтобы форма была одного цвета.

Разве эти два требования не являются взаимоисключающими? Каков именно ваш желаемый результат. Можете ли вы нарисовать картину того, что вы воображаете? Когда дело доходит до реализации, использование шейдеров много проще, чем жонглирование с помощью миллиарда переключателей конечных автоматов OpenGL.

Обновить

В любом случае, вот моя пересмотренная версия кода OP, которая рисует один треугольник, освещаемый Гурадом. Этот код компилирует и рисует один треугольник с намеком на зеркальный рефлекс.

Давайте пройдемся по тому, что я сделал. Сначала есть ваша первоначальная настройка треугольника. Ничего особенного здесь и ничего не изменилось (кроме нескольких включений) (РЕДАКТИРОВАТЬ) на второй взгляд, я сделал изменение. Использование std :: map было полностью пропущено. Мы знаем количество вершин и можем просто выделить память нормалей.

#include <GL/glut.h>
#include <math.h>

// for memcpy
#include <string.h>

#include <map>
#include <vector>
#include <iostream>

using namespace::std;

/* Verticies for simplified demo */
const int VERTICES_SIZE = 4;
float vertices[VERTICES_SIZE][3] = {
{0.1, 0.1, 0.1},
{0.2, 0.8, 0.3},
{0.3, 0.5, 0.5},
{0.8, 0.2, 0.1},
};

// this is now a plain array
float vertex_normals[VERTICES_SIZE][3];

/* Polygons for simplified demo */
const int POLYGON_SIZE = 4;
int polygon[POLYGON_SIZE][3] = {
{0, 1, 3},
{0, 2, 1},
{0, 3, 2},
{1, 2, 3},
};

/* Average point for looking at */
float av_point[3];

/*
* Calculates average point in list of vertices
* Stores in result
*/
void averagePoint(float vertices[][3], int length, float result[3]) {
for(int i = 0; i < length; i++) {
result[0] += vertices[i][0];
result[1] += vertices[i][1];
result[2] += vertices[i][2];
}

result[0] /= length;
result[1] /= length;
result[2] /= length;
}

/*
* Performs inplace normalisation of vector v
*/
void normalise(float v[3]) {
GLfloat length = sqrtf(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
v[0] /= length;
v[1] /= length;
v[2] /= length;
}

/*
* Performs cross product of vectors u and v and stores
* result in result
* Normalises result.
*/
void crossProduct(float u[], float v[], float result[]) {
result[0] = u[1] * v[2] - u[2] * v[1];
result[1] = u[2] * v[0] - u[0] * v[2];
result[2] = u[0] * v[1] - u[1] * v[0];
}

/*
* Calculates normal for plane
*/
void calculate_normal(int polygon[3], float vertices[][3], float normal[3]) {
GLfloat u[3], v[3];
for (int i = 0; i < 3; i++) {
u[i] = vertices[polygon[0]][i] - vertices[polygon[1]][i];
v[i] = vertices[polygon[2]][i] - vertices[polygon[1]][i];
}

crossProduct(u, v, normal);
normalise(normal);
}

РЕДАКТИРОВАТЬ: мое следующее изменение было здесь. Смотрите комментарий

/*
* Populates normals with it's averaged face normal
*
* Passing the normal output buffer as a parameter was a bit
* pointless, as this procedure accesses global variables anyway.
* Either pass everything as parameters or noting at all,
* be consequent. And doing it mixed is pure evil.
*/
void calculate_vertex_normals()
{
// We love RAII, no need for new and delete!
vector< vector<int> > vertex_to_faces(POLYGON_SIZE);
vector< vector<float> > faces_to_normal(POLYGON_SIZE);

// Loop over faces
for (int i = 0; i < POLYGON_SIZE; i++) {
vector<float> normal(3);
calculate_normal(polygon[i], vertices, &normal[0]);
for (int j = 0; j < 3; j++) {
vertex_to_faces[polygon[i][j]].push_back(i);
}
faces_to_normal[i] = normal;
}

// Loop over vertices
for (int v = 0; v < VERTICES_SIZE; v++) {
// avoid a copy here by using a reference
vector<int> &faces = vertex_to_faces[v];
int faces_count = 0;
float normal[3];
for (vector<int>::iterator it = faces.begin(); it != faces.end(); ++it){
normal[0] += faces_to_normal[*it][0];
normal[1] += faces_to_normal[*it][1];
normal[2] += faces_to_normal[*it][2];
faces_count++;
}
// dividing a vector obtained by a number of unit length vectors
// summed by the number of unit vectors summed does not normalize
// it. You need to normalize it properly!
normalise(normal);

// memcpy is really be best choice here
memcpy(vertex_normals[v], normal, sizeof(normal));
}
}

draw_polygon — довольно неудачное имя для этой функции. Он рисует триангулированную сетку. * РЕДАКТИРОВАТЬ: Кроме того, это может быть написано гораздо лучше, используя массивы вершин (доступно с 1994 года с OpenGL-1.1).

/*
* Draws polygons in polygon array.
*/
void draw_polygon() {
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);

glVertexPointer(3, GL_FLOAT, 0, &vertices[0][0]);
glNormalPointer(GL_FLOAT, 0, &vertex_normals[0][0]);

glDrawElements(GL_TRIANGLES, POLYGON_SIZE*3, GL_UNSIGNED_INT, polygon);
}

Здесь становится интересно. Распространенным заблуждением является то, что люди думают, что OpenGL «инициализирован». Это не тот случай. То, что вы инициализируете, это данные. В вашем случае ваши данные геометрии

/*
* Sets up lighting and material properties
*/
void init_geometry()
{
// Calculate average point for looking at
averagePoint(vertices, VERTICES_SIZE, av_point);

// Calculate vertices average normals
calculate_vertex_normals(vertex_normals);
}

Здесь возникает сложная часть: подсветка фиксированной функции OpenGL — это состояние, как и все остальное. Когда вы вызываете glLightfv, он устанавливает внутренние параметры в зависимости от состояния при вызове. Позиция трансформируется из вида модели при вызове этого. Но без правильной настройки модели вы не сможете настроить освещение. Поэтому я помещаю его в свою собственную функцию, которую мы вызываем сразу после настройки вида модели в функции рисования.

void setup_illumination()
{
// Intialise and set lighting parameters
GLfloat light_pos[] = {1.0, 1.0, 1.0, 0.0};
GLfloat light_ka[] = {0.2, 0.2, 0.2, 1.0};
GLfloat light_kd[] = {1.0, 1.0, 1.0, 1.0};
GLfloat light_ks[] = {1.0, 1.0, 1.0, 1.0};

glLightfv(GL_LIGHT0, GL_POSITION, light_pos);
glLightfv(GL_LIGHT0, GL_AMBIENT,  light_ka);
glLightfv(GL_LIGHT0, GL_DIFFUSE,  light_kd);
glLightfv(GL_LIGHT0, GL_SPECULAR, light_ks);

// Initialise and set material parameters
GLfloat material_ka[] = {1.0, 1.0, 1.0, 1.0};
GLfloat material_kd[] = {0.43, 0.47, 0.54, 1.0};
GLfloat material_ks[] = {0.33, 0.33, 0.52, 1.0};
GLfloat material_ke[] = {0.0, 0.0, 0.0, 0.0};
GLfloat material_se[] = {10.0};

glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT,  material_ka);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE,  material_kd);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR,  material_ks);
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION,  material_ke);
glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, material_se);

// Smooth shading
glShadeModel(GL_SMOOTH);

// Enable lighting
glEnable (GL_LIGHTING);
glEnable (GL_LIGHT0);
}

Для функции рисования несколько вещей были изменены. Смотрите комментарии в коде

/*
* Display simple polygon
*/
void display (void)
{
// float window sizes are usefull for view volume calculations
//
// requesting the window dimensions for each drawing iteration
// is just two function calls. Compare this to the number of function
// calls a typical application will do for the actual rendering
// Trying to optimize away those two calls is a fruitless microoptimization
float const window_width  = glutGet(GLUT_WINDOW_WIDTH);
float const window_height = glutGet(GLUT_WINDOW_HEIGHT);
float const window_aspect = window_width / window_height;

// glViewport operates independent of the projection --
// another reason to put it into the drawing code
glViewport(0, 0, window_width, window_height);

glClearDepth(1.);
glClearColor (0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

// It's a often made mistake to setup projection in the window resize
// handler. Projection is a drawing state, hence should be set in
// the drawing code. Also in most programs you will have multiple
// projections mixed throughout rendering a single frame so there you
// actually **must** set projection in drawing code, otherwise it
// wouldn't work.
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(70, window_aspect, 1, 100);

glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(0, 0, -3, av_point[0], av_point[1], av_point[2], 0, 1, 0);

// Fixed function pipeline light position setup calls operate on the current
// modelview matrix, so we must setup the illumination parameters with the
// modelview matrix at least after the view transformation (look-at) applied.
setup_illumination();

// Enable depth testing (z buffering would be enabled/disabled with glDepthMask)
glEnable(GL_DEPTH_TEST);

draw_polygon();

glutSwapBuffers();
}

int main (int argc, char **argv)
{
// Initialize graphics window
glutInit(&argc, argv);
glutInitWindowSize(256, 256);
glutInitDisplayMode    (GLUT_DEPTH | GLUT_DOUBLE);

// we actually have to create a window
glutCreateWindow("illuination");

// Initialize geometry
init_geometry();

glutDisplayFunc(display);

glutMainLoop();

return 0;
}