function loadShader(pGl, pShaderType, pShaderSource) {
    const lShader = pGl.createShader(pShaderType);
    pGl.shaderSource(lShader, pShaderSource);
    pGl.compileShader(lShader);
    if (!pGl.getShaderParameter(lShader, pGl.COMPILE_STATUS)) {
      alert('An error occurred compiling the shaders: ' + pGl.getShaderInfoLog(lShader));
      pGl.deleteShader(lShader);
      return null;
    }
  
    return lShader;
}

function loadOrthographicShader(pGl) {
    var lVertex, lFragment;

    function lLoadShaders() {
        const lVertexShader = loadShader(pGl, pGl.VERTEX_SHADER, lVertex);
        const lFragmentShader = loadShader(pGl, pGl.FRAGMENT_SHADER, lFragment);

        const lShaderProgram = pGl.createProgram();
        pGl.attachShader(lShaderProgram, lVertexShader);
        pGl.attachShader(lShaderProgram, lFragmentShader);
        pGl.linkProgram(lShaderProgram);

        if (!pGl.getProgramParameter(lShaderProgram, pGl.LINK_STATUS)) {
            alert('Unable to initialize the shader program: ' + pGl.getProgramInfoLog(lShaderProgram));
            return null;
        }

        var lRetval = {
            program: lShaderProgram,
            attributeLocations: {
                position: pGl.getAttribLocation(lShaderProgram, 'position'),
                color: pGl.getAttribLocation(lShaderProgram, 'color')
            },
            uniformLocations: {
                projection: pGl.getUniformLocation(lShaderProgram, 'projection'),
                model: pGl.getUniformLocation(lShaderProgram, 'model')
            }
        };

        lRetval.renderShape = function(pShape) {
            pGl.uniformMatrix4fv(lRetval.uniformLocations.model, false, pShape.model);
            pGl.bindBuffer(pGl.ARRAY_BUFFER, pShape.buffer);
            {
                pGl.enableVertexAttribArray(lRetval.attributeLocations.position);
                pGl.vertexAttribPointer(lRetval.attributeLocations.position, 2, pGl.FLOAT, false, BYTES_PER_FLOAT * 6, 0);

                pGl.enableVertexAttribArray(lRetval.attributeLocations.color);
                pGl.vertexAttribPointer(lRetval.attributeLocations.color, 4, pGl.FLOAT, false, BYTES_PER_FLOAT * 6, BYTES_PER_FLOAT * 2);
            }

            pGl.drawArrays(pGl.TRIANGLES, 0, pShape.vertexCount);
        }

        return lRetval;
    }

    return fetch('/_shared/2d/shaders/orthographic.vert').then(function(pResponse) {
        if (pResponse.status === 200) {
            return pResponse.text().then(function(pShader) {
                lVertex = pShader;

                return fetch('/_shared/2d/shaders/orthographic.frag').then(function(pResponse) {
                    if (pResponse.status === 200) {
                        return pResponse.text().then(function(pShader) {
                            lFragment = pShader;
                            return lLoadShaders();
                        });
                    }
                });
            });
        }
    });
}