spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Quellcode

void main(){
    position = vec3(pmv*vec4(vertex0, 1.0)); // pmv = ProjectionModelView
    normal = vec3(normalPmv*vec4(normal0, 1.0)); // invertierte, transponierte pmv
    texCoord = texCoord0;
    gl_Position = pmv*vec4(vertex0, 1.0);
}

Quellcode

void main(){
    vec3 p = texture(position, vertex).xyz; // vertex = Koordinate eines Quads für den rasterizer
    vec3 n = normalize(texture(normal, vertex)).xyz;
        
    vec4 color = 0.5*texture(diffuse, vertex); // 0.5 ist nur ein Testwert
    
    // directional light
    vec3 l = normalize(light0.position);
    float ndotl = max(dot(n, l), 0.0);
    
    if(ndotl > 0.0){
        vec3 h = normalize(-camera-l); // halfway vector
        float ndoth = max(dot(n, h), 0.0);
        
        color += light0.diffuse*ndotl+light0.specular*pow(ndoth, mat0.shininess);
    }
    
    gl_FragColor = color;
}

C-/C++-Quelltext

shader->sendUniform4x4("normalPmv", (camera->projectionMatrix*camera->viewMatrix).inverse().transpose().getArray());

Quellcode

void main(){
    position = vec3(mv*vec4(vertex0, 1.0));
    normal = vec3(normalMv*vec4(normal0, 0.0)); // da view*model Matrix (invertiert, transponiert)
    texCoord = texCoord0;
    gl_Position = p*mv*vec4(vertex0, 1.0);
}

Quellcode

#version 330

precision highp float;

struct DirLight{
    vec3 direction;
    vec4 diffuse, specular;
};

uniform sampler2D position;
uniform sampler2D diffuse;
uniform sampler2D normal;

uniform mat4 inverseView;

DirLight light0 = DirLight(vec3(1, 0, 0), vec4(0.0), vec4(0.0));

in vec2 vertex;

void main(){
    vec3 n = normalize(texture(normal, vertex)).xyz;
    vec4 color = texture(diffuse, vertex)*0.5;
    
    float ndotl = max(dot(n, normalize(light0.direction)), 0.0); // ohne view
        float ndotl = max(dot(n, normalize(inverseView*vec4(light0.direction, 0.0)).xyz), 0.0); // mit view
    
    if(ndotl > 0.0){
        color += vec4(ndotl);
    }
    
    gl_FragColor = color;
}

Quellcode

position = vec3(m*vec4(vertex0, 1.0));
normal = vec3(normalM*vec4(normal0, 0.0));
texCoord = texCoord0;
gl_Position = pmv*vec4(vertex0, 1.0);

Quellcode

vec4 point(vec4 color, vec3 p, vec3 n, PointLight pl){ // Ausgangsfarbe, Position, Normale, Punktlicht
    float ndotl = max(dot(n, normalize(pl.position-p)), 0.0);
    
    if(ndotl > 0.0){
        float ndoth = max(dot(n, (normalize(camera-p)+normalize(pl.position-p))), 0.0);
        float distance = length(p-pl.position);
        float attenuation = 1.0/(pl.constantAttenuation+pl.linearAttenuation*distance+pl.quadraticAttenuation*distance*distance);
        
        color += light0.diffuse*ndotl*attenuation+pl.specular*pow(ndoth, 6)*attenuation; // 6 = fixer Testwert
    }
    
    return color;
}

void main(){
    vec3 p = vec3(texture(position, vertex));
    vec3 n = vec3(normalize(texture(normal, vertex)));
    
    vec4 color = texture(diffuse, vertex)*0.5; // 0.5 = fixer Testwert
    color = point(color, p, n, light1); // Punktlicht berechnen
    
    gl_FragColor = color;
}

C-/C++-Quelltext

shader->sendUniform4x4("pmv", (camera->projectionMatrix*camera->viewMatrix*object->modelMatrix).getArray()); // projection*view*model
shader->sendUniform4x4("normalPm", (camera->projectionMatrix*object->modelMatrix).inverse().transpose().getArray()); // transpose(inverse(projection*model))