Effects.mm

- (void) prepareToDraw {

    camModelViewMatrix = GLKMatrix4Multiply(cameraMatrix, modelViewMatrix);

    modelViewProjectionMatrix = GLKMatrix4Multiply(projectionMatrix, camModelViewMatrix);

    GLKMatrix3 normalMatrix = GLKMatrix3InvertAndTranspose(GLKMatrix4GetMatrix3(modelViewMatrix), NULL);

    glUniformMatrix4fv(uniforms[UNIFORM_MODELVIEWPROJECTION_MATRIX], 1, 0, modelViewProjectionMatrix.m);
    glUniformMatrix3fv(uniforms[UNIFORM_NORMAL_MATRIX], 1, 0, normalMatrix.m);


    float* lp = [self vec3ToFloat:lightPosition];
    glUniform3fv(uniforms[UNIFORM_VEC3_lightPosition], 1, lp);
    delete lp;

    float* ldc = [self vec4ToFloat:lightDiffuseColour];
    glUniform4fv(uniforms[UNIFORM_VEC4_lightDiffuseColour], 1, ldc);
    delete ldc;

    float* lsc = [self vec4ToFloat:lightSpecularColour];
    glUniform4fv(uniforms[UNIFORM_VEC4_lightSpecularColour], 1, lsc);
    delete lsc;

    GLKVector3 lightHalfVec = GLKVector3Normalize(GLKVector3Add(cameraPosition, lightPosition));
    float* lhv = [self vec3ToFloat:lightHalfVec];
    glUniform3fv(uniforms[UNIFORM_VEC3_lightHalfVector], 1, lhv);
    delete lhv;

    float* nc = [self vec4ToFloat:numberColour];
    glUniform4fv(uniforms[UNIFORM_VEC4_NumberColour], 1, nc);
    delete nc;

    float* fc = [self vec4ToFloat:faceColour];
    glUniform4fv(uniforms[UNIFORM_VEC4_FaceColour], 1, fc);
    delete fc;


    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, texture);
    glUniform1i(uniforms[UNIFORM_Texture], 0);


    glUseProgram(TexAndLighting);


}

- (void) drawOutline {

    camModelViewMatrix = GLKMatrix4Multiply(cameraMatrix, modelViewMatrix);

    modelViewProjectionMatrix = GLKMatrix4Multiply(projectionMatrix, camModelViewMatrix);;

    glUniformMatrix4fv(toon_mvp, 1, 0, modelViewProjectionMatrix.m);

    float* oc = [self vec4ToFloat:outlineColour];
    glUniform4fv(toon_outline, 1, oc);
    delete oc;

    glUseProgram(Toon);
}

//------ this is how i load the 2 different shaders --------

- (BOOL)loadShaders
{

    GLuint vertShader, fragShader;
    NSString *vertShaderPathname, *fragShaderPathname;

    // Create shader program.
    TexAndLighting = glCreateProgram();

    // Create and compile vertex shader.
    vertShaderPathname = [[NSBundle mainBundle] pathForResource:@"Shader" ofType:@"vsh"];

    if (![self compileShader:&vertShader type:GL_VERTEX_SHADER file:vertShaderPathname]) {
        NSLog(@"Failed to compile vertex shader");
        return NO;
    }

    // Create and compile fragment shader.
    fragShaderPathname = [[NSBundle mainBundle] pathForResource:@"Shader" ofType:@"fsh"];
    if (![self compileShader:&fragShader type:GL_FRAGMENT_SHADER file:fragShaderPathname]) {
        NSLog(@"Failed to compile fragment shader");
        return NO;
    }

    // Attach vertex shader to program.
    glAttachShader(TexAndLighting, vertShader);

    // Attach fragment shader to program.
    glAttachShader(TexAndLighting, fragShader);

    // Bind attribute locations.
    // This needs to be done prior to linking.
    //glBindAttribLocation(_program, ATTRIB_VERTEX, "position");
    //glBindAttribLocation(_program, ATTRIB_NORMAL, "normal");


    // Link program.
    if (![self linkProgram:TexAndLighting]) {
        NSLog(@"Failed to link program: %d", TexAndLighting);

        if (vertShader) {
            glDeleteShader(vertShader);
            vertShader = 0;
        }
        if (fragShader) {
            glDeleteShader(fragShader);
            fragShader = 0;
        }
        if (TexAndLighting) {
            glDeleteProgram(TexAndLighting);
            TexAndLighting = 0;
        }

        return NO;
    }

    // Get uniform locations.
    uniforms[UNIFORM_MODELVIEWPROJECTION_MATRIX] = glGetUniformLocation(TexAndLighting, "modelViewProjectionMatrix");
    uniforms[UNIFORM_NORMAL_MATRIX] = glGetUniformLocation(TexAndLighting, "normalMatrix");
    uniforms[UNIFORM_VEC3_lightPosition] = glGetUniformLocation(TexAndLighting, "lightPosition");
    uniforms[UNIFORM_VEC4_lightDiffuseColour] = glGetUniformLocation(TexAndLighting, "lightDiffuseColour");
    uniforms[UNIFORM_VEC4_lightSpecularColour] = glGetUniformLocation(TexAndLighting, "lightSpecularColour");
    uniforms[UNIFORM_VEC4_lightAmbientColour] = glGetUniformLocation(TexAndLighting, "lightAmbientColour");
    uniforms[UNIFORM_VEC3_lightHalfVector] = glGetUniformLocation(TexAndLighting, "lightHalfVector");
    uniforms[UNIFORM_Texture] = glGetUniformLocation(TexAndLighting, "Texture");
    uniforms[UNIFORM_VEC4_NumberColour] = glGetUniformLocation(TexAndLighting, "numberColour");
    uniforms[UNIFORM_VEC4_FaceColour] = glGetUniformLocation(TexAndLighting, "faceColour");

    texCoord = glGetAttribLocation(TexAndLighting, "TexCoordIn");
    vertCoord = glGetAttribLocation(TexAndLighting, "position");
    normal = glGetAttribLocation(TexAndLighting, "normal");
    //glEnableVertexAttribArray(texCoord);


    // Release vertex and fragment shaders.
    if (vertShader) {
        glDetachShader(TexAndLighting, vertShader);
        glDeleteShader(vertShader);
    }
    if (fragShader) {
        glDetachShader(TexAndLighting, fragShader);
        glDeleteShader(fragShader);
    }

    return YES;
}

- (BOOL)loadToonShaders
{

    GLuint vertShader, fragShader;
    NSString *vertShaderPathname, *fragShaderPathname;

    // Create shader program.
    Toon = glCreateProgram();

    // Create and compile vertex shader.
    vertShaderPathname = [[NSBundle mainBundle] pathForResource:@"Toon" ofType:@"vsh"];

    if (![self compileShader:&vertShader type:GL_VERTEX_SHADER file:vertShaderPathname]) {
        NSLog(@"Failed to compile vertex shader");
        return NO;
    }

    // Create and compile fragment shader.
    fragShaderPathname = [[NSBundle mainBundle] pathForResource:@"Toon" ofType:@"fsh"];
    if (![self compileShader:&fragShader type:GL_FRAGMENT_SHADER file:fragShaderPathname]) {
        NSLog(@"Failed to compile fragment shader");
        return NO;
    }

    // Attach vertex shader to program.
    glAttachShader(Toon, vertShader);

    // Attach fragment shader to program.
    glAttachShader(Toon, fragShader);

    // Bind attribute locations.
    // This needs to be done prior to linking.
    //glBindAttribLocation(_program, effect->vertCoord, "position");
    //glBindAttribLocation(_program, effect->normal, "normal");


    // Link program.
    if (![self linkProgram:Toon]) {
        NSLog(@"Failed to link program: %d", Toon);

        if (vertShader) {
            glDeleteShader(vertShader);
            vertShader = 0;
        }
        if (fragShader) {
            glDeleteShader(fragShader);
            fragShader = 0;
        }
        if (Toon) {
            glDeleteProgram(Toon);
            Toon = 0;
        }

        return NO;
    }

    // Get uniform locations.
    toon_mvp = glGetUniformLocation(Toon, "modelViewProjectionMatrix");
    toon_outline = glGetUniformLocation(Toon, "outlineColour");

    toon_vertCoord = glGetAttribLocation(Toon, "position");


    // Release vertex and fragment shaders.
    if (vertShader) {
        glDetachShader(Toon, vertShader);
        glDeleteShader(vertShader);
    }
    if (fragShader) {
        glDetachShader(Toon, fragShader);
        glDeleteShader(fragShader);
    }

    return YES;
}