Problemi con ombreggiamento piatto e phong - c ++, opengl, phong

(Modificare): Il codice originale che ho pubblicato era per entrambe le opzioni di ombreggiatura di gouraud e phong. L'ho cambiato in modo che sia solo phong shading e pubblicato di seguito. La mesh è troppo grande per essere descritta qui, poiché è generata da una patch di Bezier.

Sto avendo dei problemi con flat e phongombreggiatura in Open GL 3 Mesa 9. Sembra non importa cosa faccio, ottengo figure ombreggiate piatte, con piccole sfaccettature (piani) e non riesco a far funzionare l'ombreggiatura di Blinn-Phong.

Ecco i miei shader:

(Vertex Shader)

//material parameters

uniform vec4 AmbientProduct, DiffuseProduct, SpecularProduct;
uniform float Shininess;


attribute vec4 vPosition;
//attribute vec4 vColor;
attribute vec4 vNormal;
attribute vec4 vControlColor;
attribute vec2 texcoord;


uniform mat4 model_view;
uniform mat4 projection;

uniform int flag;
uniform int phong_flag;
uniform vec4 eye_position;

//lighting parameters
uniform vec4 light_1;               //light 1 position
uniform vec4 light_2;               //light 2 position



varying vec4 control_color;
varying vec4 color;
varying vec4 position;
varying vec4 normal;

varying vec2 st;

void
main()
{

control_color = vControlColor;
position = vPosition;
normal = vNormal;
tex_coords = texcoord;
st = texcoord;
gl_Position = projection*model_view*vPosition;

}

E il mio frammento shader:

//material parameters

uniform vec4 AmbientProduct, DiffuseProduct, SpecularProduct;
uniform float Shininess;
uniform vec4 eye_position;

uniform int phong_flag;


//lighting parameters
uniform vec4 light_1;               //light 1 position
uniform vec4 light_2;               //light 2 position
varying vec4 light_2_transformed;   //light 2 transformed position
uniform int Control_Point_Flag;
uniform sampler2D texMap;

varying vec4 color;
varying vec4 position;
varying vec4 normal;
varying vec4 control_color;

varying vec2 st;

void
main()
{

vec4 N = normalize(normal);
vec4 E = normalize(eye_position - position);
vec4 L1 = normalize(light_1 - position);
vec4 L2 = normalize(light_2 - position);
vec4 H1 = normalize( L1 + E);
vec4 H2 = normalize( L2 + E);

//calculate ambient component
vec4 ambient = AmbientProduct;


//calculate diffuse componenent
float k_d_1 = max(dot(L1,N), 0.0);
float k_d_2 = max(dot(L2,N), 0.0);
vec4 diffuse1 = k_d_1*DiffuseProduct;
vec4 diffuse2 = k_d_2*DiffuseProduct;

//calculate specular componenent
float k_s_1 = pow(max(dot(N, H1), 0.0), Shininess);
float k_s_2 = pow(max(dot(N, H2), 0.0), Shininess);
vec4 specular1 = k_s_1*SpecularProduct;
vec4 specular2 = k_s_2*SpecularProduct;

//if specular color is behind the camera, discard it
if (dot(L1, N) < 0.0) {
specular1 = vec4(0.0, 0.0, 0.0, 1.0);
}
if (dot(L2, N) < 0.0) {
specular2 = vec4(0.0, 0.0, 0.0, 1.0);
}


vec4 final_color = ambient + diffuse1 + diffuse2 + specular1 + specular2;

final_color.a = 1.0;

/* gl_FragColor = final_color; */
gl_FragColor = final_color*texture2D(texMap, st);

}

Tutto sembra ok per i miei shader?

risposte:

Cose da notare:

1. Hai variabili per a modelview nel tuo vertice shader, ma non lo usi mai nel calcolo position. Il tuo vertice "position"Sono quindi tutto ciò che viene passato dal tuo OpenGLapplicazione e non sono interessati dalle trasformazioni che potresti provare a fare, sebbene siano posizionate fisicamente correttamente perché usi le matrici per gl_Position.
2. Non stai passando a Matrice normale al tuo shader. La matrice normale viene calcolata prendendo l'inverso di trasposizione della matrice ModelView. Calcola questo fuori dallo shader e passalo dentro. Se non moltiplichi le tue normali per la matrice Normale, sarai ancora in grado di trasformare il tuo modello, ma le normali saranno ancora rivolte allo stesso modo, quindi la tua illuminazione sarà errato.

Tuttavia, i tuoi normali vettori sul lato OpenGL potrebbero essere probabilmente il colpevole. Vedere questa domanda per una buona spiegazione di una possibile fonte di ombreggiatura piatta indesiderata.

Come nota a margine, entrambi i tuoi shader sembrano piùcomplicato di quanto dovrebbero essere. Vale a dire, hanno troppe variabili che non vengono utilizzate e troppe cose che potresti condensare in meno righe. È solo un servizio di pulizia, ma renderà più facile tenere traccia del tuo codice.