/*
* Copyright (C) 2017 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

#include "CoreProfileEngine.h"

#include "CoreProfileEngineShaders.h"
#include "GLcommon/GLEScontext.h"
#include "GLcommon/GLESpointer.h"
#include "GLEScmContext.h"

#include "aemu/base/containers/Lookup.h"
#include "host-common/crash_reporter.h"

#include <glm/vec3.hpp>
#include <glm/vec4.hpp>
#include <glm/gtc/matrix_inverse.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

CoreProfileEngine::CoreProfileEngine(GLEScmContext* ctx, bool onGles) :
    mCtx(ctx),
    mOnGles(onGles) {
    getGeometryDrawState();
}

CoreProfileEngine::~CoreProfileEngine() {
    teardown();
}

static const uint32_t sDrawTexIbo[] = {
    0, 1, 2, 0, 2, 3,
};

const CoreProfileEngine::DrawTexOESCoreState& CoreProfileEngine::getDrawTexOESCoreState() {
    if (!m_drawTexOESCoreState.program) {
        m_drawTexOESCoreState.vshader =
            GLEScontext::compileAndValidateCoreShader(
                GL_VERTEX_SHADER,
                mOnGles ? kDrawTexOESGles2_vshader : kDrawTexOESCore_vshader);
        m_drawTexOESCoreState.fshader =
            GLEScontext::compileAndValidateCoreShader(
                GL_FRAGMENT_SHADER,
                mOnGles ? kDrawTexOESGles2_fshader : kDrawTexOESCore_fshader);
        m_drawTexOESCoreState.program =
            GLEScontext::linkAndValidateProgram(m_drawTexOESCoreState.vshader,
                                                m_drawTexOESCoreState.fshader);
    }
    if (!m_drawTexOESCoreState.vao) {
        GLDispatch& gl = GLEScontext::dispatcher();

        gl.glGenVertexArrays(1, &m_drawTexOESCoreState.vao);
        gl.glBindVertexArray(m_drawTexOESCoreState.vao);

        // Initialize VBO
        // Save IBO, attrib arrays/pointers to VAO
        gl.glGenBuffers(1, &m_drawTexOESCoreState.ibo);
        gl.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_drawTexOESCoreState.ibo);
        gl.glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(sDrawTexIbo), sDrawTexIbo, GL_STATIC_DRAW);

        gl.glGenBuffers(1, &m_drawTexOESCoreState.vbo);
        gl.glBindBuffer(GL_ARRAY_BUFFER, m_drawTexOESCoreState.vbo);

        gl.glEnableVertexAttribArray(0); // pos
        gl.glEnableVertexAttribArray(1); // texcoord

        gl.glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (GLvoid*)0);
        gl.glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float),
                                 (GLvoid*)(uintptr_t)(3 * sizeof(float)));

        gl.glBindVertexArray(0);

        gl.glBindBuffer(GL_ARRAY_BUFFER, 0);
        gl.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    }

    return m_drawTexOESCoreState;
}

void CoreProfileEngine::teardown() {
    GLDispatch& gl = GLEScontext::dispatcher();

    if (m_drawTexOESCoreState.program) {
        gl.glDeleteProgram(m_drawTexOESCoreState.program);
        m_drawTexOESCoreState.program = 0;
    }

    if (m_drawTexOESCoreState.vao) {
        gl.glBindVertexArray(0);
        gl.glDeleteVertexArrays(1, &m_drawTexOESCoreState.vao);
        gl.glDeleteBuffers(1, &m_drawTexOESCoreState.ibo);
        gl.glDeleteBuffers(1, &m_drawTexOESCoreState.vbo);
        m_drawTexOESCoreState.vao = 0;
        m_drawTexOESCoreState.vbo = 0;
        m_drawTexOESCoreState.ibo = 0;
    }

    if (m_geometryDrawState.program) {
        gl.glDeleteProgram(m_geometryDrawState.program);
        m_geometryDrawState.program = 0;
    }

    if (m_geometryDrawState.programFlat) {
        gl.glDeleteProgram(m_geometryDrawState.programFlat);
        m_geometryDrawState.programFlat = 0;
    }

    if (m_geometryDrawState.vao) {
        gl.glDeleteVertexArrays(1, &m_geometryDrawState.vao);
        m_geometryDrawState.vao = 0;
    }
    if (m_geometryDrawState.posVbo) {
        gl.glDeleteBuffers(1, &m_geometryDrawState.posVbo);
        m_geometryDrawState.posVbo = 0;
    }

    if (m_geometryDrawState.normalVbo) {
        gl.glDeleteBuffers(1, &m_geometryDrawState.normalVbo);
        m_geometryDrawState.normalVbo = 0;
    }

    if (m_geometryDrawState.colorVbo) {
        gl.glDeleteBuffers(1, &m_geometryDrawState.colorVbo);
        m_geometryDrawState.colorVbo = 0;
    }

    if (m_geometryDrawState.pointsizeVbo) {
        gl.glDeleteBuffers(1, &m_geometryDrawState.pointsizeVbo);
        m_geometryDrawState.pointsizeVbo = 0;
    }

    if (m_geometryDrawState.texcoordVbo) {
        gl.glDeleteBuffers(1, &m_geometryDrawState.texcoordVbo);
        m_geometryDrawState.texcoordVbo = 0;
    }

    if (m_geometryDrawState.ibo) {
        gl.glDeleteBuffers(1, &m_geometryDrawState.ibo);
        m_geometryDrawState.ibo = 0;
    }
}

// Match attribute locations in the shader below.
static GLint arrayTypeToCoreAttrib(GLenum type) {
    switch (type) {
    case GL_VERTEX_ARRAY:
        return 0;
    case GL_NORMAL_ARRAY:
        return 1;
    case GL_COLOR_ARRAY:
        return 2;
    case GL_POINT_SIZE_ARRAY_OES:
        return 3;
    case GL_TEXTURE_COORD_ARRAY:
        return 4;
    }
    fprintf(stderr, "%s: error: unsupported array type 0x%x\n",
            __func__, type);
    return 0;
}

static std::string sMakeGeometryDrawShader(bool isGles, GLenum shaderType, bool flat) {
    // Set up a std::string to hold the result of
    // interpolating the template. We will require some extra padding
    // in the result string depending on how many characters
    // we could potentially insert.
    // For now it's just 10 chars and for a
    // single interpolation qualifier |flat|.
    static const char versionPartEssl300[] = "#version 300 es\n";
    static const char versionPart330Core[] = "#version 330 core\n";
    static const char flatKeyword[] = "flat";

    size_t extraStringLengthRequired = 10 +
        sizeof(versionPartEssl300) +
        sizeof(versionPart330Core) +
        sizeof(flatKeyword);

    size_t reservation = extraStringLengthRequired;
    std::string res;
    const char* shaderTemplate = nullptr;

    switch (shaderType) {
    case GL_VERTEX_SHADER:
        reservation += sizeof(kGeometryDrawVShaderSrcTemplateCore);
        shaderTemplate = kGeometryDrawVShaderSrcTemplateCore;
        break;
    case GL_FRAGMENT_SHADER:
        reservation += sizeof(kGeometryDrawFShaderSrcTemplateCore);
        shaderTemplate = kGeometryDrawFShaderSrcTemplateCore;
        break;
    default:
        break;
        // emugl_crash_reporter(
        //     "%s: unknown shader type 0x%x (memory corrupt)\n", __func__,
        //     shaderType);
    }

    if (shaderTemplate) {
        res.resize(reservation);
        snprintf(&res[0], res.size(), shaderTemplate,
                isGles ? versionPartEssl300 : versionPart330Core,
                flat ? flatKeyword : "");
    }
    return res;
}

const CoreProfileEngine::GeometryDrawState& CoreProfileEngine::getGeometryDrawState() {
    auto& gl = GLEScontext::dispatcher();

    if (!m_geometryDrawState.program) {

        // Non-flat shader
        m_geometryDrawState.vshader =
            GLEScontext::compileAndValidateCoreShader(
                GL_VERTEX_SHADER,
                sMakeGeometryDrawShader(mOnGles, GL_VERTEX_SHADER, false /* no flat shading */).c_str());

        m_geometryDrawState.fshader =
            GLEScontext::compileAndValidateCoreShader(
                GL_FRAGMENT_SHADER,
                sMakeGeometryDrawShader(mOnGles, GL_FRAGMENT_SHADER, false /* no flat shading */).c_str());

        m_geometryDrawState.program =
            GLEScontext::linkAndValidateProgram(m_geometryDrawState.vshader,
                                                m_geometryDrawState.fshader);

        m_geometryDrawState.vshaderFlat =
            GLEScontext::compileAndValidateCoreShader(
                    GL_VERTEX_SHADER,
                    sMakeGeometryDrawShader(mOnGles, GL_VERTEX_SHADER, true /* flat shading */).c_str());
        m_geometryDrawState.fshaderFlat =
            GLEScontext::compileAndValidateCoreShader(
                    GL_FRAGMENT_SHADER,
                    sMakeGeometryDrawShader(mOnGles, GL_FRAGMENT_SHADER, true /* flat shading */).c_str());
        m_geometryDrawState.programFlat =
            GLEScontext::linkAndValidateProgram(m_geometryDrawState.vshaderFlat,
                                                m_geometryDrawState.fshaderFlat);

        m_geometryDrawState.projMatrixLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "projection");
        m_geometryDrawState.modelviewMatrixLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "modelview");
        m_geometryDrawState.modelviewInvTrLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "modelview_invtr");
        m_geometryDrawState.textureMatrixLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "texture_matrix");
        m_geometryDrawState.textureSamplerLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "tex_sampler");
        m_geometryDrawState.textureCubeSamplerLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "tex_cube_sampler");

        m_geometryDrawState.enableTextureLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "enable_textures");
        m_geometryDrawState.enableLightingLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "enable_lighting");
        m_geometryDrawState.enableRescaleNormalLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "enable_rescale_normal");
        m_geometryDrawState.enableNormalizeLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "enable_normalize");
        m_geometryDrawState.enableColorMaterialLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "enable_color_material");
        m_geometryDrawState.enableFogLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "enable_fog");
        m_geometryDrawState.enableReflectionMapLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "enable_reflection_map");

        m_geometryDrawState.textureEnvModeLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "texture_env_mode");
        m_geometryDrawState.textureFormatLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "texture_format");

        m_geometryDrawState.materialAmbientLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "material_ambient");
        m_geometryDrawState.materialDiffuseLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "material_diffuse");
        m_geometryDrawState.materialSpecularLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "material_specular");
        m_geometryDrawState.materialEmissiveLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "material_emissive");
        m_geometryDrawState.materialSpecularExponentLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "material_specular_exponent");

        m_geometryDrawState.lightModelSceneAmbientLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "light_model_scene_ambient");
        m_geometryDrawState.lightModelTwoSidedLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "light_model_two_sided");

        m_geometryDrawState.lightEnablesLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "light_enables");
        m_geometryDrawState.lightAmbientsLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "light_ambients");
        m_geometryDrawState.lightDiffusesLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "light_diffuses");
        m_geometryDrawState.lightSpecularsLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "light_speculars");
        m_geometryDrawState.lightPositionsLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "light_positions");
        m_geometryDrawState.lightDirectionsLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "light_directions");
        m_geometryDrawState.lightSpotlightExponentsLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "light_spotlight_exponents");
        m_geometryDrawState.lightSpotlightCutoffAnglesLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "light_spotlight_cutoff_angles");
        m_geometryDrawState.lightAttenuationConstsLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "light_attenuation_consts");
        m_geometryDrawState.lightAttenuationLinearsLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "light_attenuation_linears");
        m_geometryDrawState.lightAttenuationQuadraticsLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "light_attenuation_quadratics");

        m_geometryDrawState.fogModeLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "fog_mode");
        m_geometryDrawState.fogDensityLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "fog_density");
        m_geometryDrawState.fogStartLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "fog_start");
        m_geometryDrawState.fogEndLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "fog_end");
        m_geometryDrawState.fogColorLoc =
            gl.glGetUniformLocation(m_geometryDrawState.program, "fog_color");

    }

    if (!m_geometryDrawState.vao) {

        gl.glGenBuffers(1, &m_geometryDrawState.posVbo);
        gl.glGenBuffers(1, &m_geometryDrawState.normalVbo);
        gl.glGenBuffers(1, &m_geometryDrawState.colorVbo);
        gl.glGenBuffers(1, &m_geometryDrawState.pointsizeVbo);
        gl.glGenBuffers(1, &m_geometryDrawState.texcoordVbo);

        gl.glGenVertexArrays(1, &m_geometryDrawState.vao);
        gl.glBindVertexArray(m_geometryDrawState.vao);

        gl.glGenBuffers(1, &m_geometryDrawState.ibo);
        gl.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_geometryDrawState.ibo);

        gl.glBindVertexArray(0);

        gl.glBindBuffer(GL_ARRAY_BUFFER, 0);
        gl.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    }

    return m_geometryDrawState;
}

GLuint CoreProfileEngine::getVboFor(GLenum type) {
    switch (type) {
    case GL_VERTEX_ARRAY:
        return m_geometryDrawState.posVbo;
    case GL_NORMAL_ARRAY:
        return m_geometryDrawState.normalVbo;
    case GL_COLOR_ARRAY:
        return m_geometryDrawState.colorVbo;
    case GL_POINT_SIZE_ARRAY_OES:
        return m_geometryDrawState.pointsizeVbo;
    case GL_TEXTURE_COORD_ARRAY:
        return m_geometryDrawState.texcoordVbo;
    }
    return 0;
}

size_t CoreProfileEngine::sizeOfType(GLenum type) {
    switch (type) {
    case GL_BYTE:
    case GL_UNSIGNED_BYTE:
        return 1;
    case GL_SHORT:
    case GL_UNSIGNED_SHORT:
    case GL_HALF_FLOAT_OES:
        return 2;
    case GL_INT:
    case GL_UNSIGNED_INT:
    case GL_FLOAT:
        return 4;
    }
    return 4;
}

template <class T>
static GLsizei sNeededVboCount(GLsizei indicesCount, const T* indices) {
    T maxIndex = 0;
    for (GLsizei i = 0; i < indicesCount; i++) {
        T index = indices[i];
        maxIndex = (index > maxIndex) ? index : maxIndex;
    }
    return (GLsizei)maxIndex + 1;
}

void CoreProfileEngine::setupArrayForDraw(
    GLenum arrayType,
    GLESpointer* p,
    GLint first, GLsizei count,
    bool isIndexed, GLenum indicesType, const GLvoid* indices) {

    auto& gl = GLEScontext::dispatcher();
    GLint attribNum = -1;

    gl.glBindVertexArray(m_geometryDrawState.vao);

    attribNum = arrayTypeToCoreAttrib(arrayType);

    GLsizei vboCount = 0;

    if (isIndexed) {

        GLsizei indexSize = 4;
        GLsizei indicesCount = count;

        switch (indicesType) {
        case GL_UNSIGNED_BYTE:
            indexSize = 1;
            vboCount = sNeededVboCount(indicesCount, (unsigned char*)indices);
            break;
        case GL_UNSIGNED_SHORT:
            indexSize = 2;
            vboCount = sNeededVboCount(indicesCount, (uint16_t*)indices);
            break;
        case GL_UNSIGNED_INT:
        default:
            indexSize = 4;
            vboCount = sNeededVboCount(indicesCount, (uint32_t*)indices);
        }

        // And send the indices
        gl.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_geometryDrawState.ibo);
        gl.glBufferData(GL_ELEMENT_ARRAY_BUFFER, indexSize * indicesCount, indices, GL_STREAM_DRAW);
    } else {
        gl.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
        vboCount = count;
    }

    if (p->isEnable()) {
        gl.glEnableVertexAttribArray(attribNum);
        gl.glBindBuffer(GL_ARRAY_BUFFER, getVboFor(arrayType));

        GLESConversionArrays arrs;

        bool convert = mCtx->doConvert(arrs, first, count, indicesType, indices, !isIndexed, p, arrayType);
        ArrayData currentArr = arrs.getCurrentArray();

        GLint size = p->getSize();
        GLenum dataType = convert ? currentArr.type : p->getType();
        GLsizei stride = convert ? currentArr.stride : p->getStride();

        GLsizei effectiveStride =
            stride ? stride :
                     (size * sizeOfType(dataType));

        char* bufData = convert ? (char*)currentArr.data : (char*)p->getData();
        uint32_t offset = first * effectiveStride;
        uint32_t bufSize = offset + vboCount * effectiveStride;

        gl.glBufferData(GL_ARRAY_BUFFER, bufSize, bufData, GL_STREAM_DRAW);

        gl.glVertexAttribDivisor(attribNum, 0);
        GLboolean shouldNormalize = false;

        if (arrayType == GL_COLOR_ARRAY &&
            (dataType == GL_BYTE ||
             dataType == GL_UNSIGNED_BYTE ||
             dataType == GL_INT ||
             dataType == GL_UNSIGNED_INT ||
             dataType == GL_FIXED))
            shouldNormalize = true;

        gl.glVertexAttribPointer(attribNum, size, dataType,
                                 shouldNormalize ? GL_TRUE : GL_FALSE /* normalized */,
                                 effectiveStride, nullptr /* no offset into vbo */);
        gl.glBindBuffer(GL_ARRAY_BUFFER, 0);
    } else {
        if (arrayType == GL_COLOR_ARRAY ||
            arrayType == GL_NORMAL_ARRAY ||
            arrayType == GL_TEXTURE_COORD_ARRAY) {

            gl.glEnableVertexAttribArray(attribNum);
            gl.glBindBuffer(GL_ARRAY_BUFFER, getVboFor(arrayType));

            GLint size;
            std::vector<float> buffer;
            switch (arrayType) {
                case GL_COLOR_ARRAY:
                    size = 4;
                    mCtx->getColor(count, buffer);
                    break;
                case GL_NORMAL_ARRAY:
                    size = 3;
                    mCtx->getNormal(count, buffer);
                    break;
                case GL_TEXTURE_COORD_ARRAY:
                    size = 4;
                    mCtx->getMultiTexCoord(count, mCtx->getActiveTextureUnit(), buffer);
                    break;
                default:
                    fprintf(stderr, "Error: Invalid array type %d.\n", arrayType);
                    mCtx->setGLerror(GL_INVALID_OPERATION);
                    return;
            }

            // We need a buffer large enough to hold `count` copies of the vertex attributes provided
            // above.
            GLsizei bufSize = count * size * sizeof(float);
            gl.glBufferData(GL_ARRAY_BUFFER, bufSize, buffer.data(), GL_STREAM_DRAW);
            // Stride is set to 0 to indicate that our values are tightly packed -- the driver will
            // do the calculation.
            gl.glVertexAttribPointer(attribNum, size, GL_FLOAT, GL_FALSE, 0, nullptr);
            gl.glBindBuffer(GL_ARRAY_BUFFER, 0);
        } else {
            gl.glDisableVertexAttribArray(attribNum);
        }
    }

    gl.glBindVertexArray(0);
}

// API

void CoreProfileEngine::enable(GLenum cap) {
    switch (cap) {
        case GL_TEXTURE_2D:
        case GL_TEXTURE_CUBE_MAP_OES:
        case GL_TEXTURE_GEN_STR_OES:
        case GL_RESCALE_NORMAL:
        case GL_NORMALIZE:
        case GL_LIGHTING:
        case GL_LIGHT0:
        case GL_LIGHT1:
        case GL_LIGHT2:
        case GL_LIGHT3:
        case GL_LIGHT4:
        case GL_LIGHT5:
        case GL_LIGHT6:
        case GL_LIGHT7:
        case GL_COLOR_MATERIAL:
        case GL_FOG:
        case GL_POINT_SMOOTH:
        case GL_ALPHA_TEST:
            return;
        default:
            break;
    }

    auto& gl = GLEScontext::dispatcher();
    gl.glEnable(cap);
}

void CoreProfileEngine::disable(GLenum cap) {
    switch (cap) {
        case GL_TEXTURE_2D:
        case GL_TEXTURE_CUBE_MAP_OES:
        case GL_TEXTURE_GEN_STR_OES:
        case GL_RESCALE_NORMAL:
        case GL_NORMALIZE:
        case GL_LIGHTING:
        case GL_LIGHT0:
        case GL_LIGHT1:
        case GL_LIGHT2:
        case GL_LIGHT3:
        case GL_LIGHT4:
        case GL_LIGHT5:
        case GL_LIGHT6:
        case GL_LIGHT7:
        case GL_COLOR_MATERIAL:
        case GL_FOG:
        case GL_POINT_SMOOTH:
        case GL_ALPHA_TEST:
            return;
        default:
            break;
    }

    auto& gl = GLEScontext::dispatcher();
    gl.glDisable(cap);
}

void CoreProfileEngine::shadeModel(GLenum mode) {
    // no-op
}

void CoreProfileEngine::matrixMode(GLenum mode) {
    // no-op
}

void CoreProfileEngine::loadIdentity() {
    // no-op
}

void CoreProfileEngine::loadMatrixf(const GLfloat* m) {
    // no-op
}

void CoreProfileEngine::pushMatrix() {
    // no-op
}

void CoreProfileEngine::popMatrix() {
    // no-op
}

void CoreProfileEngine::multMatrixf(const GLfloat* m) {
    // no-op
}

void CoreProfileEngine::orthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) {
    // no-op
}

void CoreProfileEngine::frustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) {
    // no-op
}

void CoreProfileEngine::texEnvf(GLenum target, GLenum pname, GLfloat param) {
    // no-op
}

void CoreProfileEngine::texEnvfv(GLenum target, GLenum pname, const GLfloat* params) {
    // no-op
}

void CoreProfileEngine::texEnvi(GLenum target, GLenum pname, GLint param) {
    // no-op
}

void CoreProfileEngine::texEnviv(GLenum target, GLenum pname, const GLint* params) {
    // no-op
}

void CoreProfileEngine::getTexEnvfv(GLenum env, GLenum pname, GLfloat* params) {
    // no-op
}

void CoreProfileEngine::getTexEnviv(GLenum env, GLenum pname, GLint* params) {
    // no-op
}

void CoreProfileEngine::texGenf(GLenum coord, GLenum pname, GLfloat param) {
    // no-op
}

void CoreProfileEngine::texGenfv(GLenum coord, GLenum pname, const GLfloat* params) {
    // no-op
}

void CoreProfileEngine::texGeni(GLenum coord, GLenum pname, GLint param) {
    // no-op
}

void CoreProfileEngine::texGeniv(GLenum coord, GLenum pname, const GLint* params) {
    // no-op
}

void CoreProfileEngine::getTexGeniv(GLenum coord, GLenum pname, GLint* params) {
    // no-op
}

void CoreProfileEngine::getTexGenfv(GLenum coord, GLenum pname, GLfloat* params) {
    // no-op
}

void CoreProfileEngine::enableClientState(GLenum clientState) {
    // no-op
}

void CoreProfileEngine::disableClientState(GLenum clientState) {
    // no-op
}

void CoreProfileEngine::drawTexOES(float x, float y, float z, float width, float height) {
    auto& gl = GLEScontext::dispatcher();

    // get viewport
    GLint viewport[4] = {};
    gl.glGetIntegerv(GL_VIEWPORT,viewport);

    // track previous vbo/ibo
    GLuint prev_vbo;
    GLuint prev_ibo;
    gl.glGetIntegerv(GL_ARRAY_BUFFER_BINDING, (GLint*)&prev_vbo);
    gl.glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, (GLint*)&prev_ibo);

    // compile shaders, generate vbo/ibo if not done already
    CoreProfileEngine::DrawTexOESCoreState drawTexState =
        getDrawTexOESCoreState();

    GLuint prog = drawTexState.program;
    GLuint vbo = drawTexState.vbo;
    GLuint vao = drawTexState.vao;

    gl.glUseProgram(prog);

    gl.glBindVertexArray(vao);
    // This is not strictly needed, but Swiftshader indirect VAO
    // can forget its ELEMENT_ARRAY_BUFFER binding.
    gl.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_drawTexOESCoreState.ibo);

    GLint samplerLoc = gl.glGetUniformLocation(prog, "tex_sampler");

    // Compute screen coordinates for our texture.
    // Recenter, rescale. (e.g., [0, 0, 1080, 1920] -> [-1, -1, 1, 1])
    float xNdc = 2.0f * (float)(x - viewport[0] - viewport[2] / 2) / (float)viewport[2];
    float yNdc = 2.0f * (float)(y - viewport[1] - viewport[3] / 2) / (float)viewport[3];
    float wNdc = 2.0f * (float)width / (float)viewport[2];
    float hNdc = 2.0f * (float)height / (float)viewport[3];
    z = z >= 1.0f ? 1.0f : z;
    z = z <= 0.0f ? 0.0f : z;
    float zNdc = z * 2.0f - 1.0f;

    for (int i = 0; i < mCtx->getMaxTexUnits(); i++) {
        if (mCtx->isTextureUnitEnabled(GL_TEXTURE0 + i)) {
            GLuint bindedTex = mCtx->getBindedTexture(GL_TEXTURE0 + i, GL_TEXTURE_2D);
            ObjectLocalName tex = mCtx->getTextureLocalName(GL_TEXTURE_2D, bindedTex);

            auto objData = mCtx->shareGroup()->getObjectData(NamedObjectType::TEXTURE, tex);

            if (objData) {
                TextureData* texData = (TextureData*)objData;

                float texCropX = (float)(texData->crop_rect[0]);
                float texCropY = (float)(texData->crop_rect[1]);

                float texCropW = (float)(texData->crop_rect[2]);
                float texCropH = (float)(texData->crop_rect[3]);

                float texW = (float)(texData->width);
                float texH = (float)(texData->height);

                // Now we know the vertex attributes (pos, texcoord).
                // Our vertex attributes are formatted with interleaved
                // position and texture coordinate:
                float vertexAttrs[] = {
                    xNdc, yNdc, zNdc,
                    texCropX / texW, texCropY / texH,

                    xNdc + wNdc, yNdc, zNdc,
                    (texCropX + texCropW) / texW, texCropY / texH,

                    xNdc + wNdc, yNdc + hNdc, zNdc,
                    (texCropX + texCropW) / texW, (texCropY + texCropH) / texH,

                    xNdc, yNdc + hNdc, zNdc,
                    texCropX / texW, (texCropY + texCropH) / texH,
                };

                gl.glBindBuffer(GL_ARRAY_BUFFER, vbo);
                gl.glBufferData(GL_ARRAY_BUFFER, sizeof(vertexAttrs),
                                vertexAttrs, GL_STREAM_DRAW);
            }

            gl.glActiveTexture(GL_TEXTURE0 + i);
            gl.glUniform1i(samplerLoc, i);
            gl.glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
        }
    }

    gl.glBindVertexArray(0);

    gl.glUseProgram(0);

    gl.glBindBuffer(GL_ARRAY_BUFFER, prev_vbo);
    gl.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, prev_ibo);
}

void CoreProfileEngine::rotatef(float angle, float x, float y, float z) {
    // no-op
}

void CoreProfileEngine::scalef(float x, float y, float z) {
    // no-op
}

void CoreProfileEngine::translatef(float x, float y, float z) {
    // no-op
}

void CoreProfileEngine::color4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
    // no-op
}

void CoreProfileEngine::color4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) {
    // no-op
}

void CoreProfileEngine::activeTexture(GLenum unit) {
    // Use 2 texture image units for each texture unit of GLES1.
    // This allows us to simultaneously use GL_TEXTURE_2D
    // and GL_TEXTURE_CUBE_MAP with the same texture unit through
    // using different samplers for the image units.
    GLEScontext::dispatcher().glActiveTexture(
        GL_TEXTURE0 + mCtx->getActiveTextureUnit() * 2);
}

void CoreProfileEngine::clientActiveTexture(GLenum unit) {
    GLEScontext::dispatcher().glActiveTexture(
        GL_TEXTURE0 + mCtx->getActiveTextureUnit() * 2);
}


void CoreProfileEngine::preDrawTextureUnitEmulation() {
    auto& gl = GLEScontext::dispatcher();
    unsigned int currTextureUnit = mCtx->getActiveTextureUnit();

    gl.glUniform1i(m_geometryDrawState.enableTextureLoc,
                   mCtx->isEnabled(GL_TEXTURE_2D) &&
                   mCtx->isArrEnabled(GL_TEXTURE_COORD_ARRAY));

    gl.glUniform1i(m_geometryDrawState.textureSamplerLoc, currTextureUnit * 2);
    gl.glUniform1i(m_geometryDrawState.textureCubeSamplerLoc, currTextureUnit * 2 + 1);

    if (auto cubeMapTex = mCtx->getBindedTexture(currTextureUnit + GL_TEXTURE0, GL_TEXTURE_CUBE_MAP)) {
        GLuint cubeMapTexGlobal = mCtx->shareGroup()->getGlobalName(
                                      NamedObjectType::TEXTURE, cubeMapTex);
        gl.glActiveTexture(GL_TEXTURE0 + currTextureUnit * 2);
        gl.glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
        gl.glActiveTexture(GL_TEXTURE0 + currTextureUnit * 2 + 1);
        gl.glBindTexture(GL_TEXTURE_CUBE_MAP, cubeMapTexGlobal);
        gl.glActiveTexture(GL_TEXTURE0 + currTextureUnit * 2);
    }

    GLenum textureGenMode = mCtx->getTextureGenMode();
    if (textureGenMode == GL_REFLECTION_MAP_OES) {
        gl.glUniform1i(m_geometryDrawState.enableTextureLoc, 1);
        gl.glUniform1i(m_geometryDrawState.enableReflectionMapLoc, 1);
    } else {
        gl.glUniform1i(m_geometryDrawState.enableReflectionMapLoc, 0);
    }

    auto bindedTex = mCtx->getBindedTexture(GL_TEXTURE_2D);
    ObjectLocalName tex = mCtx->getTextureLocalName(GL_TEXTURE_2D, bindedTex);
    auto objData = mCtx->shareGroup()->getObjectData(NamedObjectType::TEXTURE, tex);

    if (objData) {
        TextureData* texData = (TextureData*)objData;
        gl.glUniform1i(m_geometryDrawState.textureFormatLoc, texData->internalFormat);
    } else {
        gl.glUniform1i(m_geometryDrawState.textureFormatLoc, GL_RGBA);
    }

    gl.glUniform1i(m_geometryDrawState.enableLightingLoc, 0);
    gl.glUniform1i(m_geometryDrawState.textureEnvModeLoc, mCtx->getTextureEnvMode());
}

void CoreProfileEngine::postDrawTextureUnitEmulation() {
    auto& gl = GLEScontext::dispatcher();
    unsigned int currTextureUnit = mCtx->getActiveTextureUnit();

    GLuint cubeMapTex = mCtx->getBindedTexture(currTextureUnit + GL_TEXTURE0, GL_TEXTURE_CUBE_MAP);

    if (cubeMapTex) {
        GLuint cubeMapTexGlobal = mCtx->shareGroup()->getGlobalName(
                                      NamedObjectType::TEXTURE, cubeMapTex);
        gl.glActiveTexture(GL_TEXTURE0 + currTextureUnit * 2);
        gl.glBindTexture(GL_TEXTURE_CUBE_MAP, cubeMapTexGlobal);
        gl.glActiveTexture(GL_TEXTURE0 + currTextureUnit * 2 + 1);
        gl.glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
        gl.glActiveTexture(GL_TEXTURE0 + currTextureUnit * 2);
    }
}

void CoreProfileEngine::preDrawVertexSetup() {
    auto& gl = GLEScontext::dispatcher();

    glm::mat4 currProjMatrix = mCtx->getProjMatrix();
    glm::mat4 currModelviewMatrix = mCtx->getModelviewMatrix();
    glm::mat4 currTextureMatrix = mCtx->getTextureMatrix();
    glm::mat4 currModelviewMatrixInvTr = glm::inverseTranspose(currModelviewMatrix);

    gl.glBindVertexArray(m_geometryDrawState.vao);

    gl.glUseProgram(mCtx->getShadeModel() == GL_FLAT ?
                    m_geometryDrawState.programFlat :
                    m_geometryDrawState.program);
    gl.glUniformMatrix4fv(m_geometryDrawState.projMatrixLoc, 1, GL_FALSE, glm::value_ptr(currProjMatrix));
    gl.glUniformMatrix4fv(m_geometryDrawState.modelviewMatrixLoc, 1, GL_FALSE, glm::value_ptr(currModelviewMatrix));
    gl.glUniformMatrix4fv(m_geometryDrawState.modelviewInvTrLoc, 1, GL_FALSE, glm::value_ptr(currModelviewMatrixInvTr));
    gl.glUniformMatrix4fv(m_geometryDrawState.textureMatrixLoc, 1, GL_FALSE, glm::value_ptr(currTextureMatrix));
}

void CoreProfileEngine::postDrawVertexSetup() {
    auto& gl = GLEScontext::dispatcher();

    gl.glBindVertexArray(0);
}

void CoreProfileEngine::setupLighting() {
    auto& gl = GLEScontext::dispatcher();

    gl.glUniform1i(m_geometryDrawState.enableLightingLoc,
                   mCtx->isEnabled(GL_LIGHTING));
    gl.glUniform1i(m_geometryDrawState.enableRescaleNormalLoc,
                   mCtx->isEnabled(GL_RESCALE_NORMAL));
    gl.glUniform1i(m_geometryDrawState.enableNormalizeLoc,
                   mCtx->isEnabled(GL_NORMALIZE));
    gl.glUniform1i(m_geometryDrawState.enableColorMaterialLoc,
                   mCtx->isEnabled(GL_COLOR_MATERIAL));

    const auto& material = mCtx->getMaterialInfo();

    gl.glUniform4fv(m_geometryDrawState.materialAmbientLoc, 1, material.ambient);
    gl.glUniform4fv(m_geometryDrawState.materialDiffuseLoc, 1, material.diffuse);
    gl.glUniform4fv(m_geometryDrawState.materialSpecularLoc, 1, material.specular);
    gl.glUniform4fv(m_geometryDrawState.materialEmissiveLoc, 1, material.emissive);
    gl.glUniform1f(m_geometryDrawState.materialSpecularExponentLoc, material.specularExponent);

    const auto& lightModel = mCtx->getLightModelInfo();

    gl.glUniform4fv(m_geometryDrawState.lightModelSceneAmbientLoc, 1, lightModel.color);
    gl.glUniform1i(m_geometryDrawState.lightModelTwoSidedLoc, lightModel.twoSided);

    assert(kMaxLights == GLEScmContext::kMaxLights);

    for (int i = 0; i < GLEScmContext::kMaxLights; i++) {
        m_lightingBuffer.lightEnables[i] = mCtx->isEnabled(GL_LIGHT0 + i);
        const auto& light = mCtx->getLightInfo(i);
        memcpy(m_lightingBuffer.lightAmbients + 4 * i, &light.ambient, 4 * sizeof(GLfloat));
        memcpy(m_lightingBuffer.lightDiffuses + 4 * i, &light.diffuse, 4 * sizeof(GLfloat));
        memcpy(m_lightingBuffer.lightSpeculars + 4 * i, &light.specular, 4 * sizeof(GLfloat));
        memcpy(m_lightingBuffer.lightPositions + 4 * i, &light.position, 4 * sizeof(GLfloat));
        memcpy(m_lightingBuffer.lightDirections + 3 * i, &light.direction, 3 * sizeof(GLfloat));
        m_lightingBuffer.spotlightExponents[i] = light.spotlightExponent;
        m_lightingBuffer.spotlightCutoffAngles[i] = light.spotlightCutoffAngle;
        m_lightingBuffer.attenuationConsts[i] = light.attenuationConst;
        m_lightingBuffer.attenuationLinears[i] = light.attenuationLinear;
        m_lightingBuffer.attenuationQuadratics[i] = light.attenuationQuadratic;
    }

    gl.glUniform1iv(m_geometryDrawState.lightEnablesLoc, GLEScmContext::kMaxLights, m_lightingBuffer.lightEnables);
    gl.glUniform4fv(m_geometryDrawState.lightAmbientsLoc, GLEScmContext::kMaxLights, m_lightingBuffer.lightAmbients);
    gl.glUniform4fv(m_geometryDrawState.lightDiffusesLoc, GLEScmContext::kMaxLights, m_lightingBuffer.lightDiffuses);
    gl.glUniform4fv(m_geometryDrawState.lightSpecularsLoc, GLEScmContext::kMaxLights, m_lightingBuffer.lightSpeculars);
    gl.glUniform4fv(m_geometryDrawState.lightPositionsLoc, GLEScmContext::kMaxLights, m_lightingBuffer.lightPositions);
    gl.glUniform3fv(m_geometryDrawState.lightDirectionsLoc, GLEScmContext::kMaxLights, m_lightingBuffer.lightDirections);
    gl.glUniform1fv(m_geometryDrawState.lightSpotlightExponentsLoc, GLEScmContext::kMaxLights, m_lightingBuffer.spotlightExponents);
    gl.glUniform1fv(m_geometryDrawState.lightSpotlightCutoffAnglesLoc, GLEScmContext::kMaxLights, m_lightingBuffer.spotlightCutoffAngles);
    gl.glUniform1fv(m_geometryDrawState.lightAttenuationConstsLoc, GLEScmContext::kMaxLights, m_lightingBuffer.attenuationConsts);
    gl.glUniform1fv(m_geometryDrawState.lightAttenuationLinearsLoc, GLEScmContext::kMaxLights, m_lightingBuffer.attenuationLinears);
    gl.glUniform1fv(m_geometryDrawState.lightAttenuationQuadraticsLoc, GLEScmContext::kMaxLights, m_lightingBuffer.attenuationQuadratics);
}

void CoreProfileEngine::setupFog() {
    auto& gl = GLEScontext::dispatcher();

    gl.glUniform1i(m_geometryDrawState.enableFogLoc,
                   mCtx->isEnabled(GL_FOG));

    const auto& fogInfo = mCtx->getFogInfo();

    gl.glUniform1i(m_geometryDrawState.fogModeLoc, fogInfo.mode);
    gl.glUniform1f(m_geometryDrawState.fogDensityLoc, fogInfo.density);
    gl.glUniform1f(m_geometryDrawState.fogStartLoc, fogInfo.start);
    gl.glUniform1f(m_geometryDrawState.fogEndLoc, fogInfo.end);

    gl.glUniform4fv(m_geometryDrawState.fogColorLoc, 1, fogInfo.color);
}

void CoreProfileEngine::drawArrays(GLenum type, GLint first, GLsizei count) {
    auto& gl = GLEScontext::dispatcher();

    preDrawVertexSetup();
    preDrawTextureUnitEmulation();

    setupLighting();
    setupFog();

    gl.glDrawArrays(type, first, count);

    postDrawVertexSetup();
    postDrawTextureUnitEmulation();
}

void CoreProfileEngine::drawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices) {
    auto& gl = GLEScontext::dispatcher();

    preDrawVertexSetup();
    preDrawTextureUnitEmulation();

    setupLighting();
    setupFog();

    gl.glDrawElements(mode, count, type, (GLvoid*)0);

    postDrawVertexSetup();
    postDrawTextureUnitEmulation();
}