/////////////////////////////////////////////////////////////////////////////
// Name:        oglstuff.cpp
// Purpose:     OpenGL manager for pyramid sample
// Author:      Manuel Martin
// Created:     2015/01/31
// Copyright:   (c) 2015 Manuel Martin
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#include <cmath>

#include "oglstuff.h"

// External function for GL errors
myOGLErrHandler* externalMyOGLErrHandler = NULL;

// Allow GL errors to be handled in other part of the app.
bool MyOnGLError(int err, const GLchar* glMsg = NULL)
{
    GLenum GLErrorVal = glGetError();

    if ( err == myoglERR_CLEAR )
    {
        // Clear previous errors
        while ( GLErrorVal != GL_NO_ERROR )
            GLErrorVal = glGetError();
        return true;
    }

    if ( (GLErrorVal == GL_NO_ERROR) && (glMsg == NULL) )
        return true;

    if ( externalMyOGLErrHandler )
    {
        // Use the external error message handler. We pass our err-enum value.
        externalMyOGLErrHandler(err, GLErrorVal, glMsg);
    }

    return err == myoglERR_JUSTLOG ? true : false;
}


// We do calculations with 'doubles'. We pass 'GLFloats' to the shaders
// because OGL added 'doubles' since OGL 4.0, and this sample is for 3.2
// Due to asynchronous nature of OGL, we can't trust in the passed matrix
// to be stored by GPU before the passing-function returns. So we don't use
// temporary storage, but dedicated matrices
void SetAsGLFloat4x4(double *matD, GLfloat *matF, int msize)
{
    for (int i = 0; i < msize; i++)
    {
        matF[i] = (GLfloat) matD[i];
    }
}

// ----------------------------------------------------------------------------
// Data for a regular tetrahedron with edge length 200, centered at the origin
// ----------------------------------------------------------------------------
const GLfloat gVerts[] = { 100.0f, -40.8248f, -57.7350f,
                             0.0f, -40.8248f, 115.4704f,
                          -100.0f, -40.8248f, -57.7350f,
                             0.0f, 122.4745f,   0.0f };

// Transparency (to see also inner faces) is in the last triangle only,
// so that glEnable(GL_BLEND) works well
const GLfloat gColours[] = { 0.0f, 1.0f, 0.0f, 1.0f,
                             1.0f, 0.0f, 0.0f, 1.0f,
                             0.0f, 0.0f, 1.0f, 1.0f,
                             1.0f, 1.0f, 0.0f, 0.3f }; //With transparency

// Normals heading outside of the tetrahedron
const GLfloat gNormals[] = { 0.0f,    -1.0f,      0.0f,     /* face 0 1 2 */
                            -0.81650f, 0.33333f,  0.47140f, /* face 1 2 3 */
                             0.0f,     0.33333f, -0.94281f, /* face 2 3 0 */
                             0.81650f, 0.33333f,  0.47140f  /* face 3 0 1 */ };

// Order would be important if we were using face culling
const GLushort gIndices[] = { 0, 1, 2, 3, 0, 1 };


// ----------------------------------------------------------------------------
// Shaders
// ----------------------------------------------------------------------------
// Note: We use GLSL 1.50 which is the minimum starting with OpenGL >= 3.2 (2009)
// Apple supports OpenGL 3.2 since OS X 10.7 "Lion" (2011)

// Vertex shader for the triangles
const GLchar* triangVertexShader =
{
    "#version 150 \n"

    "in vec3 in_Position; \n"
    "in vec4 in_Colour; \n"
    "in vec3 in_Normal; \n"
    "uniform mat4 mMVP; \n"
    "uniform mat4 mToViewSpace; \n"

    "flat out vec4 theColour; \n"
    "flat out vec3 theNormal; \n"
    "out vec3 pointPos; \n"

    "void main(void) \n"
    "{\n"
    "    gl_Position = mMVP * vec4(in_Position, 1.0); \n"
    "    theColour = in_Colour; \n"

    "    // Operations in View Space \n"
    "    vec4 temp4 = mToViewSpace * vec4(in_Position, 1.0); \n"
    "    pointPos = temp4.xyz; \n"
    "    temp4 = mToViewSpace * vec4(in_Normal, 0.0); \n"
    "    theNormal = normalize(temp4.xyz); \n"
    "}\n"
};

// Common function for fragment shaders
const GLchar* illuminationShader =
{
    "#version 150 \n"

    "vec3 Illuminate(in vec4 LiProps, in vec3 LiColour, in vec4 PColour, \n"
    "                in vec3 PNormal, in vec3 PPos) \n"
    "{\n"
    "    // Ambient illumination. Hardcoded \n"
    "    vec3 liAmbient = vec3(0.2, 0.2, 0.2); \n"

    "    // Operations in View Space \n"
    "    vec3 lightDirec = LiProps.xyz - PPos; \n"
    "    float lightDist = length(lightDirec); \n"
    "    // Normalize. Attention: No lightDist > 0 check \n"
    "    lightDirec = lightDirec / lightDist; \n"
    "    // Attenuation. Hardcoded for this sample distances \n"
    "    float attenu = 260.0 / lightDist; \n"
    "    attenu = attenu * attenu; \n"

    "    // Lambertian diffuse illumination \n"
    "    float diffuse = dot(lightDirec, PNormal); \n"
    "    diffuse = max(0.0, diffuse); \n"
    "    vec3 liDiffuse = LiColour * LiProps.w * diffuse * attenu; \n"

    "    // Gaussian specular illumination. Harcoded values again \n"
    "    // We avoid it for interior faces \n"
    "    vec3 viewDir = vec3(0.0, 0.0, 1.0); \n"
    "    vec3 halfDir = normalize(lightDirec + viewDir); \n"
    "    float angleHalf = acos(dot(halfDir, PNormal)); \n"
    "    float exponent = angleHalf / 0.05; \n"
    "    float specular = 0.0; \n"
    "    if (diffuse > 0.0) \n"
    "        specular = exp(-exponent * exponent); \n"

    "    vec3 lightRes = PColour.rgb * ( liAmbient + liDiffuse ); \n"
    "    // Specular colour is quite similar as light colour \n"
    "    lightRes += (0.2 * PColour.xyz + 0.8 * LiColour) * specular * attenu; \n"
    "    lightRes = clamp(lightRes, 0.0, 1.0); \n"

    "     return lightRes; \n"
    "}\n"
};

// Fragment shader for the triangles
const GLchar* triangFragmentShader =
{
    "#version 150 \n"

    "uniform vec4 lightProps; // Position in View space, and intensity \n"
    "uniform vec3 lightColour; \n"

    "flat in vec4 theColour; \n"
    "flat in vec3 theNormal; \n"
    "in vec3 pointPos; \n"

    "out vec4 fragColour; \n"

    "// Declare this function \n"
    "vec3 Illuminate(in vec4 LiProps, in vec3 LiColour, in vec4 PColour, \n"
    "                in vec3 PNormal, in vec3 PPos); \n"

    "void main(void) \n"
    "{\n"
    "    vec3 lightRes = Illuminate(lightProps, lightColour, theColour, \n"
    "                               theNormal, pointPos); \n "

    "    fragColour = vec4(lightRes, theColour.a); \n"
    "}\n"
};

// Vertex shader for strings (textures) with illumination
const GLchar* stringsVertexShader =
{
    "#version 150 \n"

    "in vec3 in_sPosition; \n"
    "in vec3 in_sNormal; \n"
    "in vec2 in_TextPos; \n"
    "uniform mat4 mMVP; \n"
    "uniform mat4 mToViewSpace; \n"

    "flat out vec3 theNormal; \n"
    "out vec3 pointPos; \n"
    "out vec2 textCoord; \n"

    "void main(void) \n"
    "{\n"
    "    gl_Position = mMVP * vec4(in_sPosition, 1.0); \n"
    "    textCoord = in_TextPos; \n"

    "    // Operations in View Space \n"
    "    vec4 temp4 = mToViewSpace * vec4(in_sPosition, 1.0); \n"
    "    pointPos = temp4.xyz; \n"
    "    temp4 = mToViewSpace * vec4(in_sNormal, 0.0); \n"
    "    theNormal = normalize(temp4.xyz); \n"
    "}\n"
};

// Fragment shader for strings (textures) with illumination
const GLchar* stringsFragmentShader =
{
    "#version 150 \n"

    "uniform vec4 lightProps; // Position in View space, and intensity \n"
    "uniform vec3 lightColour; \n"
    "uniform sampler2D stringTexture; \n"

    "flat in vec3 theNormal; \n"
    "in vec3 pointPos; \n"
    "in vec2 textCoord; \n"

    "out vec4 fragColour; \n"

    "// Declare this function \n"
    "vec3 Illuminate(in vec4 LiProps, in vec3 LiColour, in vec4 PColour, \n"
    "                in vec3 PNormal, in vec3 PPos); \n"

    "void main(void) \n"
    "{\n"
    "    vec4 colo4 = texture(stringTexture, textCoord); \n"
    "    vec3 lightRes = Illuminate(lightProps, lightColour, colo4, \n"
    "                               theNormal, pointPos); \n "

    "    fragColour = vec4(lightRes, colo4.a); \n"
    "}\n"
};

// Vertex shader for immutable strings (textures)
const GLchar* stringsImmutableVS =
{
    "#version 150 \n"

    "in vec3 in_sPosition; \n"
    "in vec2 in_TextPos; \n"
    "uniform mat4 mMVP; \n"
    "out vec2 textCoord; \n"

    "void main(void) \n"
    "{\n"
    "    gl_Position = mMVP * vec4(in_sPosition, 1.0); \n"
    "    textCoord = in_TextPos; \n"
    "}\n"
};

// Fragment shader for immutable strings (textures)
const GLchar* stringsImmutableFS =
{
    "#version 150 \n"

    "uniform sampler2D stringTexture; \n"
    "in vec2 textCoord; \n"
    "out vec4 fragColour; \n"

    "void main(void) \n"
    "{\n"
    "    fragColour= texture(stringTexture, textCoord); \n"
    "}\n"
};


// ----------------------------------------------------------------------------
// myOGLShaders
// ----------------------------------------------------------------------------

myOGLShaders::myOGLShaders()
{
    m_proId = 0;
    m_SHAinitializated = false;
}

myOGLShaders::~myOGLShaders()
{
    if ( m_proId )
        CleanUp();
}

void myOGLShaders::CleanUp()
{
    StopUse();

    glDeleteProgram(m_proId);

    glFlush();
}

void myOGLShaders::AddCode(const GLchar* shaString, GLenum shaType)
{
    // The code is a null-terminated string
    shaShas sv = {0, shaType, shaString};
    m_shaCode.push_back(sv);
}

void myOGLShaders::AddAttrib(const std::string& name)
{
    shaVars sv = {0, name}; //We will set the location later
    m_shaAttrib.push_back(sv);
    // We don't check the max number of attribute locations (usually 16)
}

void myOGLShaders::AddUnif(const std::string& name)
{
    shaVars sv = {0, name};
    m_shaUnif.push_back(sv);
}

// Inform GL of the locations in program for the vars for buffers used to feed
// the shader. We use glBindAttribLocation (before linking the gl program) with
// the location we want.
// Since GL 3.3 we could avoid this using in the shader "layout(location=x)...".
// The same names as in the shader must be previously set with AddAttrib()
void myOGLShaders::SetAttribLocations()
{
    GLuint loc = 0;
    for(shaVars_v::iterator it = m_shaAttrib.begin(); it != m_shaAttrib.end(); ++it)
    {
        it->loc = loc++;
        glBindAttribLocation(m_proId, it->loc, it->name.c_str());
    }
}

GLuint myOGLShaders::GetAttribLoc(const std::string& name)
{
    for (shaVars_v::iterator it = m_shaAttrib.begin(); it != m_shaAttrib.end(); ++it)
    {
        if ( it->name == name && it->loc != (GLuint)-1 )
            return it->loc;
    }

    return (GLuint) -1;
}

// Store the locations in program for uniforms vars
bool myOGLShaders::AskUnifLocations()
{
    for (shaVars_v::iterator it = m_shaUnif.begin(); it != m_shaUnif.end(); ++it)
    {
        GLint glret = glGetUniformLocation(m_proId, it->name.c_str());
        if ( glret == -1 )
        {
            // Return now, this GPU program cannot be used because we will
            // pass data to unknown/unused uniform locations
            return false;
        }
        it->loc = glret;
    }

    return true;
}

GLuint myOGLShaders::GetUnifLoc(const std::string& name)
{
    for (shaVars_v::iterator it = m_shaUnif.begin(); it != m_shaUnif.end(); ++it)
    {
        if ( it->name == name && it->loc != (GLuint)-1 )
            return it->loc;
    }

    return (GLuint) -1;
}

// Create a GPU program from the given shaders
void myOGLShaders::Init()
{
    MyOnGLError(myoglERR_CLEAR); //clear error stack

    bool resC = false;
    bool resL = false;

    // GLSL code load and compilation
    for (shaShas_v::iterator it = m_shaCode.begin(); it != m_shaCode.end(); ++it)
    {
        it->shaId = glCreateShader(it->typeSha);
        glShaderSource(it->shaId, 1, &(it->scode), NULL);
        MyOnGLError(myoglERR_SHADERCREATE);

        resC = Compile(it->shaId);
        if ( !resC )
            break;
    }

    if ( resC )
    {
        // The program in the GPU
        m_proId = glCreateProgram();
        for (shaShas_v::iterator it = m_shaCode.begin(); it != m_shaCode.end(); ++it)
        {
            glAttachShader(m_proId, it->shaId);
        }

        SetAttribLocations(); //Before linking

        resL = LinkProg(m_proId);
    }

    // We don't need them any more
    for (shaShas_v::iterator it = m_shaCode.begin(); it != m_shaCode.end(); ++it)
    {
        if ( resC && it->shaId )
        {
            glDetachShader(m_proId, it->shaId);
        }
        glDeleteShader(it->shaId);
    }

    if ( !resC || !resL )
        return;

    // Log that shaders are OK
    MyOnGLError(myoglERR_JUSTLOG, "Shaders successfully compiled and linked.");

    // After linking, we can get locations for uniforms
    m_SHAinitializated = AskUnifLocations();
    if ( !m_SHAinitializated )
        MyOnGLError(myoglERR_SHADERLOCATION, " Unused or unrecognized uniform.");
}

// Useful while developing: show shader compilation errors
bool myOGLShaders::Compile(GLuint shaId)
{
    glCompileShader(shaId);

    GLint Param = 0;
    glGetShaderiv(shaId, GL_COMPILE_STATUS, &Param);

    if ( Param == GL_FALSE )
    {
        glGetShaderiv(shaId, GL_INFO_LOG_LENGTH, &Param);

        if ( Param > 0 )
        {
            GLchar* InfoLog = new GLchar[Param];
            int nChars = 0;
            glGetShaderInfoLog(shaId, Param, &nChars, InfoLog);
            MyOnGLError(myoglERR_SHADERCOMPILE, InfoLog);
            delete [] InfoLog;
        }
        return false;
    }
    return true;
}

// Useful while developing: show shader program linkage errors
bool myOGLShaders::LinkProg(GLuint proId)
{
    glLinkProgram(proId);

    GLint Param = 0;
    glGetProgramiv(proId, GL_LINK_STATUS, &Param);

    if ( Param == GL_FALSE )
    {
        glGetProgramiv(proId, GL_INFO_LOG_LENGTH, &Param);

        if ( Param > 0 )
        {
            GLchar* InfoLog = new GLchar[Param];
            int nChars = 0;
            glGetProgramInfoLog(proId, Param, &nChars, InfoLog);
            MyOnGLError(myoglERR_SHADERLINK, InfoLog);
            delete [] InfoLog;
        }
        return false;
    }
    return true;
}

bool myOGLShaders::Use()
{
    if ( !m_SHAinitializated )
        return false;

    glUseProgram(m_proId);
    return true;
}

void myOGLShaders::StopUse()
{
    glUseProgram(0);
}

// Disable generic attributes from VAO.
// This should be needed only for some old card, which uses generic into VAO
void myOGLShaders::DisableGenericVAA()
{
    for(shaVars_v::iterator it = m_shaAttrib.begin(); it != m_shaAttrib.end(); ++it)
    {
        glDisableVertexAttribArray(it->loc);
    }
}


// ----------------------------------------------------------------------------
// A point light
// ----------------------------------------------------------------------------

void myLight::Set(const myVec3& position, GLfloat intensity,
                  GLfloat R, GLfloat G, GLfloat B)
{
    m_PosAndIntensisty[0] = (GLfloat) position.x;
    m_PosAndIntensisty[1] = (GLfloat) position.y;
    m_PosAndIntensisty[2] = (GLfloat) position.z;
    m_PosAndIntensisty[3] = (GLfloat) intensity;
    m_Colour[0] = R;
    m_Colour[1] = G;
    m_Colour[2] = B;
}


// ----------------------------------------------------------------------------
// myOGLTriangles
// ----------------------------------------------------------------------------
myOGLTriangles::myOGLTriangles()
{
    m_triangVAO = m_bufVertId = m_bufColNorId = m_bufIndexId = 0;
    m_triangShaders = NULL;
}

myOGLTriangles::~myOGLTriangles()
{
    Clear();
}

void myOGLTriangles::Clear()
{
    if ( m_triangShaders )
        m_triangShaders->DisableGenericVAA();

    // Clear graphics card memory
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    if ( m_bufIndexId )
        glDeleteBuffers(1, &m_bufIndexId);
    if ( m_bufColNorId )
        glDeleteBuffers(1, &m_bufColNorId);
    if ( m_bufVertId )
        glDeleteBuffers(1, &m_bufVertId);

    // Unbind from context
    glBindVertexArray(0);
    if ( m_triangVAO )
        glDeleteVertexArrays(1, &m_triangVAO);

    glFlush(); //Tell GL to execute those commands now, but we don't wait for them

    m_triangShaders = NULL;
    m_triangVAO = m_bufIndexId = m_bufColNorId = m_bufVertId = 0;
}

void myOGLTriangles::SetBuffers(myOGLShaders* theShader,
                                GLsizei nuPoints, GLsizei nuTriangs,
                                const GLfloat* vert, const GLfloat* colo,
                                const GLfloat* norm, const GLushort* indices)
{
    MyOnGLError(myoglERR_CLEAR); //clear error stack

    // NOTE: have you realized that I fully trust on parameters being != 0 and != NULL?

    // Part 1: Buffers - - - - - - - - - - - - - - - - - - -

    // Graphics card buffer for vertices.
    // Not shared buffer with colours and normals, why not? Just for fun.
    glGenBuffers(1, &m_bufVertId);
    glBindBuffer(GL_ARRAY_BUFFER, m_bufVertId);
    // Populate the buffer with the array "vert"
    GLsizeiptr nBytes = nuPoints * 3 * sizeof(GLfloat); //3 components {x,y,z}
    glBufferData(GL_ARRAY_BUFFER, nBytes, vert, GL_STATIC_DRAW);

    if ( ! MyOnGLError(myoglERR_BUFFER) )
    {
        // Likely the GPU got out of memory
        Clear();
        return;
    }

    // Graphics card buffer for colours and normals.
    glGenBuffers(1, &m_bufColNorId);
    glBindBuffer(GL_ARRAY_BUFFER, m_bufColNorId);
    // Allocate space for both arrays
    nBytes = (nuPoints * 4 + nuTriangs * 3) * sizeof(GLfloat);
    glBufferData(GL_ARRAY_BUFFER, nBytes, NULL, GL_STATIC_DRAW);
    if ( ! MyOnGLError(myoglERR_BUFFER) )
    {
        // Likely the GPU got out of memory
        Clear();
        return;
    }
    // Populate part of the buffer with the array "colo"
    nBytes = nuPoints * 4 * sizeof(GLfloat); // rgba components
    glBufferSubData(GL_ARRAY_BUFFER, 0, nBytes, colo);
    // Add the array "norm" to the buffer
    GLsizeiptr bufoffset = nBytes;
    nBytes = nuTriangs * 3 * sizeof(GLfloat);
    glBufferSubData(GL_ARRAY_BUFFER, bufoffset, nBytes, norm);

    // Graphics card buffer for indices.
    glGenBuffers(1, &m_bufIndexId);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_bufIndexId);
    // Populate the buffer with the array "indices"
    // We use "triangle strip". An index for each additional vertex.
    nBytes = (3 + nuTriangs - 1) * sizeof(GLushort); //Each triangle needs 3 indices
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, nBytes, indices, GL_STATIC_DRAW);

    if ( ! MyOnGLError(myoglERR_BUFFER) )
    {
        // Likely the GPU got out of memory
        Clear();
        return;
    }

    // Unbind buffers. We will bind them one by one just now, at VAO creation
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

    m_nuTriangs = nuTriangs;
    m_triangShaders = theShader;

    MyOnGLError(myoglERR_CLEAR); //clear error stack

    // Part 2: VAO - - - - - - - - - - - - - - - - - - -

    // Vertex Array Object (VAO) that stores the relationship between the
    // buffers and the shader input attributes
    glGenVertexArrays(1, &m_triangVAO);
    glBindVertexArray(m_triangVAO);

    // Set the way of reading (blocks of n floats each) from the current bound
    // buffer and passing data to the shader (through the index of an attribute).
    // Vertices positions
    glBindBuffer(GL_ARRAY_BUFFER, m_bufVertId);
    GLuint loc = m_triangShaders->GetAttribLoc("in_Position");
    glEnableVertexAttribArray(loc);
    glVertexAttribPointer(loc, 3, GL_FLOAT, GL_FALSE, 0, (GLvoid *)0);
    // Colours
    glBindBuffer(GL_ARRAY_BUFFER, m_bufColNorId);
    loc = m_triangShaders->GetAttribLoc("in_Colour");
    glEnableVertexAttribArray(loc);
    glVertexAttribPointer(loc, 4, GL_FLOAT, GL_FALSE, 0, (GLvoid *)0);
    // Normals. Their position in buffer starts at bufoffset
    loc = m_triangShaders->GetAttribLoc("in_Normal");
    glEnableVertexAttribArray(loc);
    glVertexAttribPointer(loc, 3, GL_FLOAT, GL_FALSE, 0, (GLvoid *)bufoffset);
    // Indices
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_bufIndexId);

    // Unbind
    glBindVertexArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

    // Some log
    MyOnGLError(myoglERR_JUSTLOG, "Triangles data loaded into GPU.");
}

void myOGLTriangles::Draw(const GLfloat* unifMvp, const GLfloat* unifToVw,
                          const myLight* theLight)
{
    if ( !m_triangVAO )
        return;

    MyOnGLError(myoglERR_CLEAR); //clear error stack

    if ( ! m_triangShaders->Use() )
        return;

    // Bind the source data for the shader
    glBindVertexArray(m_triangVAO);

    // Pass matrices to the shader in column-major order
    glUniformMatrix4fv(m_triangShaders->GetUnifLoc("mMVP"), 1, GL_FALSE, unifMvp);
    glUniformMatrix4fv(m_triangShaders->GetUnifLoc("mToViewSpace"), 1, GL_FALSE, unifToVw);
    // Pass the light, in View coordinates in this sample
    glUniform4fv(m_triangShaders->GetUnifLoc("lightProps"), 1, theLight->GetFLightPos());
    glUniform3fv(m_triangShaders->GetUnifLoc("lightColour"), 1, theLight->GetFLightColour());

    // We have a flat shading, and we want the first vertex data as the flat value
    glProvokingVertex(GL_FIRST_VERTEX_CONVENTION);

    // Indexed drawing the triangles in strip mode, using 6 indices
    glDrawElements(GL_TRIANGLE_STRIP, 6, GL_UNSIGNED_SHORT, (GLvoid *)0);

    MyOnGLError(myoglERR_DRAWING_TRI);

   // Unbind
    glBindVertexArray(0);
    m_triangShaders->StopUse();
}


// ----------------------------------------------------------------------------
// myOGLString
// ----------------------------------------------------------------------------
myOGLString::myOGLString()
{
    m_bufPosId = m_textureId = m_stringVAO = m_textureUnit = 0;
    m_stringShaders = NULL;
}

myOGLString::~myOGLString()
{
    Clear();
}

void myOGLString::Clear()
{
    if ( m_stringShaders )
        m_stringShaders->DisableGenericVAA();

    // Clear graphics card memory
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    if ( m_bufPosId )
        glDeleteBuffers(1, &m_bufPosId);

    // Unbind from context
    glBindVertexArray(0);
    glDeleteVertexArrays(1, &m_stringVAO);

    if ( m_textureUnit && m_textureId )
    {
        glActiveTexture(GL_TEXTURE0 + m_textureUnit);
        glBindTexture(GL_TEXTURE_2D, 0);
        glDeleteTextures(1, &m_textureId);
    }
    glActiveTexture(GL_TEXTURE0);

    glFlush(); //Tell GL to execute those commands now, but we don't wait for them

    m_bufPosId = m_textureId = m_stringVAO = m_textureUnit = 0;
    m_stringShaders = NULL;
}

void myOGLString::SetStringWithVerts(myOGLShaders* theShader,
                             const unsigned char* tImage, int tWidth, int tHeigh,
                             const GLfloat* vert, const GLfloat* norm)
{
    MyOnGLError(myoglERR_CLEAR); //clear error stack

    if ( !tImage )
        return;

    // Part 1: Buffers - - - - - - - - - - - - - - - - - - -

    // Graphics card buffer for vertices, normals, and texture coords
    glGenBuffers(1, &m_bufPosId);
    glBindBuffer(GL_ARRAY_BUFFER, m_bufPosId);
    // (4+4) (vertices + normals) x 3 components + 4 text-vertices x 2 components
    GLsizeiptr nBytes = (8 * 3 + 4 * 2) * sizeof(GLfloat);
    glBufferData(GL_ARRAY_BUFFER, nBytes, NULL, GL_STATIC_DRAW);

    if ( ! MyOnGLError(myoglERR_BUFFER) )
    {
        // Likely the GPU got out of memory
        Clear();
        return;
    }

    // Populate part of the buffer with the array "vert"
    nBytes = 12 * sizeof(GLfloat);
    glBufferSubData(GL_ARRAY_BUFFER, 0, nBytes, vert);
    // Add the array "norm" to the buffer
    GLsizeiptr bufoffset = nBytes;
    if ( norm )
    {
        // Just for string on face, not immutable string
        glBufferSubData(GL_ARRAY_BUFFER, bufoffset, nBytes, norm);
    }

    // Add the array of texture coordinates to the buffer.
    // Order is set accordingly with the vertices
    // See myOGLManager::SetStringOnPyr()
    GLfloat texcoords[8] = { 0.0, 1.0,  0.0, 0.0,  1.0, 1.0,  1.0, 0.0 };
    bufoffset += nBytes;
    nBytes = 8 * sizeof(GLfloat);
    glBufferSubData(GL_ARRAY_BUFFER, bufoffset, nBytes, texcoords);

    m_stringShaders = theShader;

    MyOnGLError(myoglERR_CLEAR); //clear error stack

    // Part 2: VAO - - - - - - - - - - - - - - - - - - -

    // Vertex Array Object (VAO) that stores the relationship between the
    // buffers and the shader input attributes
    glGenVertexArrays(1, &m_stringVAO);
    glBindVertexArray(m_stringVAO);

    // Set the way of reading (blocks of n floats each) from the current bound
    // buffer and passing data to the shader (through the index of an attribute).
    // Vertices positions
    GLuint loc = m_stringShaders->GetAttribLoc("in_sPosition");
    glEnableVertexAttribArray(loc);
    glVertexAttribPointer(loc, 3, GL_FLOAT, GL_FALSE, 0, (GLvoid *)0);
    // Normals. Their position in buffer starts at bufoffset
    bufoffset = 12 * sizeof(GLfloat);
    if ( norm )
    {
        // Just for string on face, not immutable string
        loc = m_stringShaders->GetAttribLoc("in_sNormal");
        glEnableVertexAttribArray(loc);
        glVertexAttribPointer(loc, 3, GL_FLOAT, GL_FALSE, 0, (GLvoid *)bufoffset);
    }
    // Texture coordinates
    bufoffset *= 2; //Normals take same amount of space as vertices
    loc = m_stringShaders->GetAttribLoc("in_TextPos");
    glEnableVertexAttribArray(loc);
    glVertexAttribPointer(loc, 2, GL_FLOAT, GL_FALSE, 0, (GLvoid *)bufoffset);

    // Part 3: The texture with the string as an image - - - - - - - -

    // Create the bind for the texture
    // Same unit for both textures (strings) since their characteristics are the same.
    m_textureUnit = 1;
    glActiveTexture(GL_TEXTURE0 + m_textureUnit);
    glGenTextures(1, &m_textureId); //"Name" of the texture object
    glBindTexture(GL_TEXTURE_2D, m_textureId);
    // Avoid some artifacts
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    // Do this before glTexImage2D because we only have 1 level, no mipmap
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
    // For RGBA default alignment (4) is good. In other circumstances, we may
    // need glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
    // Load texture into card. No mipmap, so 0-level
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
                 (GLsizei)tWidth, (GLsizei)tHeigh, 0,
                  GL_RGBA, GL_UNSIGNED_BYTE, tImage);
    if ( ! MyOnGLError(myoglERR_TEXTIMAGE) )
    {
        // Likely the GPU got out of memory
        Clear();
        return;
    }

    // Unbind
    glBindVertexArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindTexture(GL_TEXTURE_2D, 0);
    glActiveTexture(GL_TEXTURE0);

    // Some log
    MyOnGLError(myoglERR_JUSTLOG, "Texture for string loaded into GPU.");
}

void myOGLString::Draw(const GLfloat* unifMvp, const GLfloat* unifToVw,
                       const myLight* theLight)
{
    if ( !m_stringVAO )
        return;

    MyOnGLError(myoglERR_CLEAR); //clear error stack

    if ( ! m_stringShaders->Use() )
        return;

    // Bind the source data for the shader
    glBindVertexArray(m_stringVAO);

    // Pass matrices to the shader in column-major order
    glUniformMatrix4fv(m_stringShaders->GetUnifLoc("mMVP"), 1, GL_FALSE, unifMvp);
    if ( unifToVw && theLight )
    {
        // Just for string on face, not immutable string
        glUniformMatrix4fv(m_stringShaders->GetUnifLoc("mToViewSpace"), 1, GL_FALSE, unifToVw);
        // Pass the light, in View coordinates in this sample
        glUniform4fv(m_stringShaders->GetUnifLoc("lightProps"), 1, theLight->GetFLightPos());
        glUniform3fv(m_stringShaders->GetUnifLoc("lightColour"), 1, theLight->GetFLightColour());

        // We have a flat shading, and we want the first vertex normal as the flat value
        glProvokingVertex(GL_FIRST_VERTEX_CONVENTION);
    }

    // Use our texture unit
    glActiveTexture(GL_TEXTURE0 + m_textureUnit);
    glBindTexture(GL_TEXTURE_2D, m_textureId);
    // The fragment shader will read texture values (pixels) from the texture
    // currently active
    glUniform1i(m_stringShaders->GetUnifLoc("stringTexture"), m_textureUnit);

    // Draw the rectangle made up of two triangles
    glDrawArrays(GL_TRIANGLE_STRIP, 0,  4);

    MyOnGLError(myoglERR_DRAWING_STR);

    // Unbind
    glBindVertexArray(0);
    glBindTexture(GL_TEXTURE_2D, 0);
    glActiveTexture(GL_TEXTURE0);

    m_stringShaders->StopUse();
}

// ----------------------------------------------------------------------------
// myOGLImmutString
// ----------------------------------------------------------------------------
void myOGLImmutString::SetImmutString(myOGLShaders* theShader,
                        const unsigned char* tImage, int tWidth, int tHeigh)
{
    // Make a rectangle of the same size as the image. Order of vertices matters.
    // Set a 2 pixels margin
    double imaVerts[12];
    imaVerts[0] = 2.0         ;   imaVerts[1] = 2.0         ; imaVerts[2]  = -1.0;
    imaVerts[3] = 2.0         ;   imaVerts[4] = 2.0 + tHeigh; imaVerts[5]  = -1.0;
    imaVerts[6] = 2.0 + tWidth;   imaVerts[7] = 2.0         ; imaVerts[8]  = -1.0;
    imaVerts[9] = 2.0 + tWidth;  imaVerts[10] = 2.0 + tHeigh; imaVerts[11] = -1.0;

    // GLFloat version
    GLfloat fimaVerts[12];
    SetAsGLFloat4x4(imaVerts, fimaVerts, 12);

    // Call the base class without normals, it will handle this case
    SetStringWithVerts(theShader, tImage, tWidth, tHeigh, fimaVerts, NULL);
}

void myOGLImmutString::SetOrtho(int winWidth, int winHeight)
{
    // We want an image always of the same size, regardless of window size.
    // The orthogonal projection with the whole window achieves it.
    MyOrtho(0.0, winWidth, 0.0, winHeight, -1.0, 1.0, m_dOrtho);
    // Store the 'float' matrix
    SetAsGLFloat4x4(m_dOrtho, m_fOrtho, 16);
}


// ----------------------------------------------------------------------------
// myOGLCamera
// ----------------------------------------------------------------------------
myOGLCamera::myOGLCamera()
{
    m_needMVPUpdate = true; //Matrix must be updated
    InitPositions();
}

void myOGLCamera::InitPositions()
{
    // We have a tetrahedron centered at origin and edge length = 200
    m_centerOfWorld.x = m_centerOfWorld.y = m_centerOfWorld.z = 0.0;

    // The radius of the bounding sphere
    m_radiusOfWorld = 122.4745;

    // From degrees to radians
    double degToRad = (double) 4.0 * atan(1.0) / 180.0;

    // Angle of the field of view
    m_fov = 40.0 * degToRad; //radians

    // Position the camera far enough so we can see the whole world.
    // The camera is between X and Z axis, below the pyramid
    double tmpv = m_radiusOfWorld / sin(m_fov/2.0);
    tmpv *= 1.05; // 5% margin
    m_camPosition.x = m_centerOfWorld.x + tmpv * cos(75.0 * degToRad);
    m_camPosition.z = m_centerOfWorld.z + tmpv * sin(75.0 * degToRad);
    m_camPosition.y = m_centerOfWorld.y - m_radiusOfWorld;

    // This camera looks always at center
    m_camTarget = m_centerOfWorld;

    // A vector perpendicular to Position-Target heading Y+
    myVec3 vper = MyNormalize(m_camTarget - m_camPosition);
    m_camUp = myVec3(0.0, 1.0, 0.0);
    m_camUp = MyCross(m_camUp, vper);
    m_camUp = MyNormalize( MyCross(vper, m_camUp) );

    tmpv = MyDistance(m_camPosition, m_centerOfWorld);
    // Calculate distances, not coordinates, with some margins
    // Near clip-plane distance to the camera
    m_nearD = tmpv - 1.10 * m_radiusOfWorld - 5.0;
    // Far clip-plane distance to the camera
    m_farD = tmpv + 1.10 * m_radiusOfWorld + 5.0;

    // The "View" matrix. We will not change it any more in this sample
    MyLookAt(m_camPosition, m_camUp, m_camTarget, m_dView);

    // The initial "Model" matrix is the Identity matrix
    MyRotate(myVec3(0.0, 0.0, 1.0), 0.0, m_dMode);

    // Nothing else. "View" matrix is calculated at ViewSizeChanged()
}

void myOGLCamera::ViewSizeChanged(int newWidth, int newHeight)
{
    // These values are also used for MouseRotation()
    m_winWidth = newWidth;
    m_winHeight = newHeight;

    // Calculate the projection matrix
    double aspect = (double) newWidth / newHeight;
    MyPerspective(m_fov, aspect, m_nearD, m_farD, m_dProj);

    // Inform we need to calculate MVP matrix
    m_needMVPUpdate = true;
}

const GLfloat* myOGLCamera::GetFloatMVP()
{
    UpdateMatrices();

    return m_fMVP;
}

const GLfloat* myOGLCamera::GetFloatToVw()
{
    UpdateMatrices();

    return m_fToVw;
}

void myOGLCamera::UpdateMatrices()
{
   if ( m_needMVPUpdate )
    {
        MyMatMul4x4(m_dView, m_dMode, m_dToVw);
        MyMatMul4x4(m_dProj, m_dToVw, m_dMVP);
        // Store the 'float' matrices
        SetAsGLFloat4x4(m_dToVw, m_fToVw, 16);
        SetAsGLFloat4x4(m_dMVP, m_fMVP, 16);
        m_needMVPUpdate = false;
    }
}

void myOGLCamera::MouseRotation(int fromX, int fromY, int toX, int toY)
{
    if ( fromX == toX && fromY == toY )
        return; //no rotation

    // 1. Obtain axis of rotation and angle simulating a virtual trackball "r"

    // 1.1. Calculate normalized coordinates (2x2x2 box).
    // The trackball is a part of sphere of radius "r" (the rest is hyperbolic)
    // Use r= 0.8 for better maximum rotation (more-less 150 degrees)
    double xw1 = (2.0 * fromX - m_winWidth) / m_winWidth;
    double yw1 = (2.0 * fromY - m_winHeight) / m_winHeight;
    double xw2 = (2.0 * toX - m_winWidth) / m_winWidth;
    double yw2 = (2.0 * toY - m_winHeight) / m_winHeight;
    double z1 = GetTrackballZ(xw1, yw1, 0.8);
    double z2 = GetTrackballZ(xw2, yw2, 0.8);

    // 1.2. With normalized vectors, compute axis from 'cross' and angle from 'dot'
    myVec3 v1(xw1, yw1, z1);
    myVec3 v2(xw2, yw2, z2);
    v1 = MyNormalize(v1);
    v2 = MyNormalize(v2);
    myVec3 axis(MyCross(v1, v2));

    // 'axis' is in camera coordinates. Transform it to world coordinates.
    double mtmp[16];
    MyMatInverse(m_dView, mtmp);
    myVec4 res = MyMatMul4x1(mtmp, myVec4(axis));
    axis.x = res.x;
    axis.y = res.y;
    axis.z = res.z;
    axis = MyNormalize(axis);

    double angle = AngleBetween(v1, v2);

    // 2. Compute the model transformation (rotate the model) matrix
    MyRotate(axis, angle, mtmp);
    // Update "Model" matrix
    double mnew[16];
    MyMatMul4x4(mtmp, m_dMode, mnew);
    for (size_t i = 0; i<16; ++i)
        m_dMode[i] = mnew[i];

    // Inform we need to calculate MVP matrix
    m_needMVPUpdate = true;
}

// Return the orthogonal projection of (x,y) into a sphere centered on the screen
// and radius 'r'. This makes some (x,y) to be outside of circle r='r'. We avoid
// this issue by using a hyperbolic sheet for (x,y) outside of r = 0.707 * 'r'.
double myOGLCamera::GetTrackballZ(double x, double y, double r)
{
    double d = x*x + y*y;
    double r2 = r*r;
    return  (d < r2/2.0) ? sqrt(r2 - d) : r2/2.0/sqrt(d);
}


// ----------------------------------------------------------------------------
// myOGLManager
// ----------------------------------------------------------------------------

myOGLManager::myOGLManager(myOGLErrHandler* extErrHnd)
{
    externalMyOGLErrHandler = extErrHnd;
    MyOnGLError(myoglERR_CLEAR); //clear error stack
}

myOGLManager::~myOGLManager()
{
    MyOnGLError(myoglERR_CLEAR); //clear error stack

    // Force GPU finishing before the context is deleted
    glFinish();
}

/* Static */
bool myOGLManager::Init()
{
    // Retrieve the pointers to OGL functions we use in this sample
    return MyInitGLPointers();
}

const GLubyte* myOGLManager::GetGLVersion()
{
    return glGetString(GL_VERSION);
}

const GLubyte* myOGLManager::GetGLVendor()
{
    return glGetString(GL_VENDOR);
}

const GLubyte* myOGLManager::GetGLRenderer()
{
    return glGetString(GL_RENDERER);
}

void myOGLManager::SetShadersAndTriangles()
{
    // The shaders attributes and uniforms
    m_TriangShaders.AddAttrib("in_Position");
    m_TriangShaders.AddAttrib("in_Colour");
    m_TriangShaders.AddAttrib("in_Normal");
    m_TriangShaders.AddUnif("mMVP");
    m_TriangShaders.AddUnif("mToViewSpace");
    m_TriangShaders.AddUnif("lightProps");
    m_TriangShaders.AddUnif("lightColour");
    m_TriangShaders.AddCode(triangVertexShader, GL_VERTEX_SHADER);
    m_TriangShaders.AddCode(illuminationShader, GL_FRAGMENT_SHADER);
    m_TriangShaders.AddCode(triangFragmentShader, GL_FRAGMENT_SHADER);
    m_TriangShaders.Init();
    m_StringShaders.AddAttrib("in_sPosition");
    m_StringShaders.AddAttrib("in_sNormal");
    m_StringShaders.AddAttrib("in_TextPos");
    m_StringShaders.AddUnif("mMVP");
    m_StringShaders.AddUnif("mToViewSpace");
    m_StringShaders.AddUnif("lightProps");
    m_StringShaders.AddUnif("lightColour");
    m_StringShaders.AddUnif("stringTexture");
    m_StringShaders.AddCode(stringsVertexShader, GL_VERTEX_SHADER);
    m_StringShaders.AddCode(illuminationShader, GL_FRAGMENT_SHADER);
    m_StringShaders.AddCode(stringsFragmentShader, GL_FRAGMENT_SHADER);
    m_StringShaders.Init();
    m_ImmutStringSha.AddAttrib("in_sPosition");
    m_ImmutStringSha.AddAttrib("in_TextPos");
    m_ImmutStringSha.AddUnif("mMVP");
    m_ImmutStringSha.AddUnif("stringTexture");
    m_ImmutStringSha.AddCode(stringsImmutableVS, GL_VERTEX_SHADER);
    m_ImmutStringSha.AddCode(stringsImmutableFS, GL_FRAGMENT_SHADER);
    m_ImmutStringSha.Init();
    // The point light. Set its color as full white.
    // In this sample we set the light position same as the camera position
    // In View space, camera position is {0, 0, 0}
    m_Light.Set(myVec3(0.0, 0.0, 0.0), 1.0, 1.0, 1.0, 1.0);
    // The triangles data
    m_Triangles.SetBuffers(&m_TriangShaders, 4, 4, gVerts, gColours, gNormals, gIndices);
}

void myOGLManager::SetStringOnPyr(const unsigned char* strImage, int iWidth, int iHeigh)
{
    // Some geometry. We want a rectangle close to face 0-1-2 (X-Z plane).
    // The rectangle must preserve strImage proportions. If the height of the
    // rectangle is "h" and we want to locate it with its largest side parallel
    // to the edge of the face and at distance= h/2, then the rectangle width is
    // rw = edgeLength - 2 * ((h/2 + h + h/2)/tan60) = edgeLength - 4*h/sqrt(3)
    // If h/rw = Prop then
    //    rw = edgeLength / (1+4/sqrt(3)*Prop) and h = Prop * rw

    double edgeLen = MyDistance(myVec3(gVerts[0], gVerts[1], gVerts[2]),
                                 myVec3(gVerts[6], gVerts[7], gVerts[8]));
    GLfloat prop = ((GLfloat) iHeigh) / ((GLfloat) iWidth);
    GLfloat rw = float(edgeLen) / (1 + 4 * prop / std::sqrt(3.0f));
    GLfloat h = prop * rw;
    GLfloat de = 2 * h / std::sqrt(3.0f);
    // A bit of separation of the face so as to avoid z-fighting
    GLfloat rY = gVerts[1] - 0.01f; // Towards outside
    GLfloat sVerts[12];
    // The image was created top to bottom, but OpenGL axis are bottom to top.
    // The image would display upside down. We avoid it choosing the right
    // order of vertices and texture coords. See myOGLString::SetStringWithVerts()
    sVerts[0] = gVerts[6] + de;  sVerts[1] = rY;   sVerts[2] = gVerts[8] + h / 2;
    sVerts[3] = sVerts[0]     ;  sVerts[4] = rY;   sVerts[5] = sVerts[2] + h;
    sVerts[6] = sVerts[0] + rw;  sVerts[7] = rY;   sVerts[8] = sVerts[2];
    sVerts[9] = sVerts[6]     ; sVerts[10] = rY;  sVerts[11] = sVerts[5];

    // Normals for the rectangle illumination, same for the four vertices
    const GLfloat strNorms[] = { gNormals[0], gNormals[1], gNormals[2],
                                 gNormals[0], gNormals[1], gNormals[2],
                                 gNormals[0], gNormals[1], gNormals[2],
                                 gNormals[0], gNormals[1], gNormals[2]};

    // The texture data for the string on the face of the pyramid
    m_StringOnPyr.SetStringWithVerts(&m_StringShaders, strImage, iWidth, iHeigh,
                                     sVerts, strNorms);
}

void myOGLManager::SetImmutableString(const unsigned char* strImage,
                                      int iWidth, int iHeigh)
{
    m_ImmString.SetImmutString(&m_ImmutStringSha, strImage, iWidth, iHeigh);
}

void myOGLManager::SetViewport(int x, int y, int width, int height)
{
    if (width < 1) width = 1;
    if (height < 1) height = 1;

    glViewport(x, y, (GLsizei)width, (GLsizei)height);

    // The camera handles perspective projection
    m_Camera.ViewSizeChanged(width, height);
    // And this object handles its own orthogonal projection
    m_ImmString.SetOrtho(width, height);
}

void myOGLManager::Render()
{
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LEQUAL);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    glClearColor((GLfloat)0.15, (GLfloat)0.15, 0.0, (GLfloat)1.0); // Dark, but not black.
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

    m_Triangles.Draw(m_Camera.GetFloatMVP(), m_Camera.GetFloatToVw(), &m_Light);
    m_StringOnPyr.Draw(m_Camera.GetFloatMVP(), m_Camera.GetFloatToVw(), &m_Light);
    // This string is at the very front, whatever z-coords are given
    glDisable(GL_DEPTH_TEST);
    m_ImmString.Draw(m_ImmString.GetFloatMVP(), NULL, NULL);
}

void myOGLManager::OnMouseButDown(int posX, int posY)
{
    // Just save mouse position
    m_mousePrevX = posX;
    m_mousePrevY = posY;
}

void myOGLManager::OnMouseRotDragging(int posX, int posY)
{
    m_Camera.MouseRotation(m_mousePrevX, m_mousePrevY, posX, posY);
    m_mousePrevX = posX;
    m_mousePrevY = posY;
}