/*-------------------------------------------------------------------------
 * OpenGL Conformance Test Suite
 * -----------------------------
 *
 * Copyright (c) 2014-2016 The Khronos Group Inc.
 *
 * 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.
 *
 */ /*!
 * \file
 * \brief
 */ /*-------------------------------------------------------------------*/

#include "esextcGeometryShaderPrimitiveQueries.hpp"

#include "gluDefs.hpp"
#include "glwEnums.hpp"
#include "glwFunctions.hpp"
#include "tcuTestLog.hpp"

namespace glcts
{

/* Fragment shader */
const char *GeometryShaderPrimitiveQueries::m_fs_code = "${VERSION}\n"
                                                        "\n"
                                                        "precision highp float;\n"
                                                        "\n"
                                                        "void main()\n"
                                                        "{\n"
                                                        "}\n";

/* Vertex shader */
const char *GeometryShaderPrimitiveQueries::m_vs_code = "${VERSION}\n"
                                                        "\n"
                                                        "precision highp float;\n"
                                                        "\n"
                                                        "void main()\n"
                                                        "{\n"
                                                        "    gl_Position = vec4(gl_VertexID, 0, 0, 1);\n"
                                                        "}\n";

/* Geometry shader */
const char *GeometryShaderPrimitiveQueriesPoints::m_gs_code =
    "${VERSION}\n"
    "\n"
    "${GEOMETRY_SHADER_REQUIRE}\n"
    "\n"
    "precision highp float;\n"
    "\n"
    "layout(points)                          in;\n"
    "layout(points, max_vertices=8)          out;\n"
    "\n"
    "void main()\n"
    "{\n"
    "    for (int n = 0; n < 8; ++n)\n"
    "    {\n"
    "        gl_Position = vec4(1.0 / (float(n) + 1.0), 1.0 / (float(n) + 2.0), 0.0, 1.0);\n"
    "        EmitVertex();\n"
    "    }\n"
    "\n"
    "    EndPrimitive();\n"
    "}\n";

/* Geometry shader */
const char *GeometryShaderPrimitiveQueriesLines::m_gs_code =
    "${VERSION}\n"
    "\n"
    "${GEOMETRY_SHADER_REQUIRE}\n"
    "\n"
    "precision highp float;\n"
    "\n"
    "layout(points)                          in;\n"
    "layout(line_strip, max_vertices=10)     out;\n"
    "\n"
    "void main()\n"
    "{\n"
    "    for (int n = 0; n < 10; ++n)\n"
    "    {\n"
    "        gl_Position = vec4(1.0 / (float(n) + 1.0), 1.0 / (float(n) + 2.0), 0.0, 1.0);\n"
    "        EmitVertex();\n"
    "    }\n"
    "\n"
    "    EndPrimitive();\n"
    "}\n";

/* Geometry shader */
const char *GeometryShaderPrimitiveQueriesTriangles::m_gs_code =
    "${VERSION}\n"
    "\n"
    "${GEOMETRY_SHADER_REQUIRE}\n"
    "\n"
    "precision highp float;\n"
    "\n"
    "layout(points)                          in;\n"
    "layout(triangle_strip, max_vertices=12) out;\n"
    "\n"
    "void main()\n"
    "{\n"
    "    for (int n = 0; n < 12; ++n)\n"
    "    {\n"
    "        gl_Position = vec4(1.0 / (float(n) + 1.0), 1.0 / (float(n) + 2.0), 0.0, 1.0);\n"
    "        EmitVertex();\n"
    "    }\n"
    "\n"
    "    EndPrimitive();\n"
    "}\n";

/** Constructor
 *
 * @param context       Test context
 * @param name          Test case's name
 * @param description   Test case's description
 **/
GeometryShaderPrimitiveQueriesPoints::GeometryShaderPrimitiveQueriesPoints(Context &context,
                                                                           const ExtParameters &extParams,
                                                                           const char *name, const char *description)
    : GeometryShaderPrimitiveQueries(context, extParams, name, description)
{
}

/** Gets geometry shader code
 *
 * @return geometry shader code
 **/
const char *GeometryShaderPrimitiveQueriesPoints::getGeometryShaderCode()
{
    return m_gs_code;
}

/** Gets the number of emitted vertices
 *
 * @return number of emitted vertices
 **/
glw::GLint GeometryShaderPrimitiveQueriesPoints::getAmountOfEmittedVertices()
{
    return 8;
}

/** Gets the transform feedback mode
 *
 * @return transform feedback mode
 **/
glw::GLenum GeometryShaderPrimitiveQueriesPoints::getTFMode()
{
    return GL_POINTS;
}

/** Constructor
 *
 * @param context       Test context
 * @param name          Test case's name
 * @param description   Test case's desricption
 **/
GeometryShaderPrimitiveQueriesLines::GeometryShaderPrimitiveQueriesLines(Context &context,
                                                                         const ExtParameters &extParams,
                                                                         const char *name, const char *description)
    : GeometryShaderPrimitiveQueries(context, extParams, name, description)
{
}

/** Gets geometry shader code
 *
 * @return geometry shader code
 **/
const char *GeometryShaderPrimitiveQueriesLines::getGeometryShaderCode()
{
    return m_gs_code;
}

/** Gets the number of emitted vertices
 *
 * @return number of emitted vertices
 **/
glw::GLint GeometryShaderPrimitiveQueriesLines::getAmountOfEmittedVertices()
{
    return 18;
}

/** Gets the transform feedback mode
 *
 * @return transform feedback mode
 **/
glw::GLenum GeometryShaderPrimitiveQueriesLines::getTFMode()
{
    return GL_LINES;
}

/** Constructor
 *
 * @param context       Test context
 * @param name          Test case's name
 * @param description   Test case's desricption
 **/
GeometryShaderPrimitiveQueriesTriangles::GeometryShaderPrimitiveQueriesTriangles(Context &context,
                                                                                 const ExtParameters &extParams,
                                                                                 const char *name,
                                                                                 const char *description)
    : GeometryShaderPrimitiveQueries(context, extParams, name, description)
{
}

/** Gets geometry shader code
 *
 * @return geometry shader code
 **/
const char *GeometryShaderPrimitiveQueriesTriangles::getGeometryShaderCode()
{
    return m_gs_code;
}

/** Gets the number of emitted vertices
 *
 * @return number of emitted vertices
 **/
glw::GLint GeometryShaderPrimitiveQueriesTriangles::getAmountOfEmittedVertices()
{
    return 30;
}

/** Gets the transform feedback mode
 *
 * @return transform feedback mode
 **/
glw::GLenum GeometryShaderPrimitiveQueriesTriangles::getTFMode()
{
    return GL_TRIANGLES;
}

/** Constructor
 *
 * @param context       Test context
 * @param name          Test case's name
 * @param description   Test case's desricption
 **/
GeometryShaderPrimitiveQueries::GeometryShaderPrimitiveQueries(Context &context, const ExtParameters &extParams,
                                                               const char *name, const char *description)
    : TestCaseBase(context, extParams, name, description)
    , m_n_texture_components(4)
    , m_bo_large_id(0)
    , m_bo_small_id(0)
    , m_fs_id(0)
    , m_gs_id(0)
    , m_po_id(0)
    , m_qo_primitives_generated_id(0)
    , m_qo_tf_primitives_written_id(0)
    , m_vao_id(0)
    , m_vs_id(0)
{
    /* Nothing to be done here */
}

/** Deinitializes GLES objects created during the test.
 *
 */
void GeometryShaderPrimitiveQueries::deinit(void)
{
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    /* Reset OpenGL ES state */
    gl.useProgram(0);
    gl.bindBuffer(GL_ARRAY_BUFFER, 0);
    gl.bindVertexArray(0);

    if (m_po_id != 0)
    {
        gl.deleteProgram(m_po_id);
    }

    if (m_fs_id != 0)
    {
        gl.deleteShader(m_fs_id);
    }

    if (m_gs_id != 0)
    {
        gl.deleteShader(m_gs_id);
    }

    if (m_vs_id != 0)
    {
        gl.deleteShader(m_vs_id);
    }

    if (m_bo_small_id != 0)
    {
        gl.deleteBuffers(1, &m_bo_small_id);
    }

    if (m_bo_large_id != 0)
    {
        gl.deleteBuffers(1, &m_bo_large_id);
    }

    if (m_qo_primitives_generated_id != 0)
    {
        gl.deleteQueries(1, &m_qo_primitives_generated_id);
    }

    if (m_qo_tf_primitives_written_id != 0)
    {
        gl.deleteQueries(1, &m_qo_tf_primitives_written_id);
    }

    if (m_vao_id != 0)
    {
        gl.deleteVertexArrays(1, &m_vao_id);
    }

    /* Release base class */
    TestCaseBase::deinit();
}

/** Executes the test.
 *  Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise.
 *  @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again.
 *  Note the function throws exception should an error occur!
 **/
tcu::TestNode::IterateResult GeometryShaderPrimitiveQueries::iterate(void)
{
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    /* Check if geometry_shader extension is supported */
    if (!m_is_geometry_shader_extension_supported)
    {
        throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__);
    }

    /* Create shader objects and a program object */
    m_vs_id = gl.createShader(GL_VERTEX_SHADER);
    m_fs_id = gl.createShader(GL_FRAGMENT_SHADER);
    m_gs_id = gl.createShader(m_glExtTokens.GEOMETRY_SHADER);
    m_po_id = gl.createProgram();

    GLU_EXPECT_NO_ERROR(gl.getError(), "Error creating program/shader objects.");

    /* Try to build test-specific program object */
    const char *tf_varyings[] = {"gl_Position"};
    const char *gs_code       = getGeometryShaderCode();

    gl.transformFeedbackVaryings(m_po_id, sizeof(tf_varyings) / sizeof(tf_varyings[0]), tf_varyings,
                                 GL_SEPARATE_ATTRIBS);

    if (!buildProgram(m_po_id, m_fs_id, 1 /* part */, &m_fs_code, m_gs_id, 1 /* part */, &gs_code, m_vs_id,
                      1 /* part */, &m_vs_code))
    {
        TCU_FAIL("Could not create a program for GeometryShaderPrimitiveQueries!");
    }

    /* Create and bind a vertex array object */
    gl.genVertexArrays(1, &m_vao_id);
    gl.bindVertexArray(m_vao_id);

    GLU_EXPECT_NO_ERROR(gl.getError(), "Error creating a vertex array object.");

    /* Create two buffer objects
     *
     * One with sufficiently large storage space to hold position data for particular output.
     * Another one of insufficient size.
     */
    gl.genBuffers(1, &m_bo_large_id);
    gl.genBuffers(1, &m_bo_small_id);

    gl.bindBuffer(GL_ARRAY_BUFFER, m_bo_large_id);
    gl.bufferData(GL_ARRAY_BUFFER,
                  getAmountOfEmittedVertices() * m_n_texture_components /* components */ * sizeof(float), NULL,
                  GL_STATIC_DRAW);

    gl.bindBuffer(GL_ARRAY_BUFFER, m_bo_small_id);
    gl.bufferData(GL_ARRAY_BUFFER,
                  (getAmountOfEmittedVertices() / 2) * m_n_texture_components /* components */ * sizeof(float), NULL,
                  GL_STATIC_DRAW);

    GLU_EXPECT_NO_ERROR(gl.getError(), "Error allocating buffer objects.");

    /* Create primitive query objects */
    gl.genQueries(1, &m_qo_tf_primitives_written_id);
    gl.genQueries(1, &m_qo_primitives_generated_id);

    glw::GLuint nPrimitivesGenerated = 0;
    glw::GLuint nTFPrimitivesWritten = 0;

    /* Test case 13.1 */
    readPrimitiveQueryValues(m_bo_large_id, &nPrimitivesGenerated, &nTFPrimitivesWritten);

    if (nPrimitivesGenerated == 0)
    {
        m_testCtx.getLog()
            << tcu::TestLog::Message
            << "Retrieved GL_PRIMITIVES_GENERATED_EXT query object value is zero which should never happen."
            << tcu::TestLog::EndMessage;

        m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
        return STOP;
    }

    if (nTFPrimitivesWritten == 0)
    {
        m_testCtx.getLog() << tcu::TestLog::Message
                           << "Retrieved GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN query "
                              "object value is zero which should never happen."
                           << tcu::TestLog::EndMessage;

        m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
        return STOP;
    }

    if (nPrimitivesGenerated != nTFPrimitivesWritten)
    {
        m_testCtx.getLog() << tcu::TestLog::Message << "Retrieved GL_PRIMITIVES_GENERATED_EXT query object value("
                           << nPrimitivesGenerated
                           << ") is different than for GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN ("
                           << nTFPrimitivesWritten << ")" << tcu::TestLog::EndMessage;

        m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
        return STOP;
    }

    /* Test case 13.2 */
    nPrimitivesGenerated = 0;
    nTFPrimitivesWritten = 0;

    readPrimitiveQueryValues(m_bo_small_id, &nPrimitivesGenerated, &nTFPrimitivesWritten);

    if (nPrimitivesGenerated == 0)
    {
        m_testCtx.getLog()
            << tcu::TestLog::Message
            << "Retrieved GL_PRIMITIVES_GENERATED_EXT query object value is zero which should never happen."
            << tcu::TestLog::EndMessage;

        m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
        return STOP;
    }

    if (nTFPrimitivesWritten == 0)
    {
        m_testCtx.getLog() << tcu::TestLog::Message
                           << "Retrieved GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN query "
                              "object value is zero which should never happen."
                           << tcu::TestLog::EndMessage;

        m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
        return STOP;
    }

    if ((nPrimitivesGenerated / 2) != nTFPrimitivesWritten)
    {
        m_testCtx.getLog() << tcu::TestLog::Message
                           << "Retrieved GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN query object value("
                           << nPrimitivesGenerated << ") should be half the amount of GL_PRIMITIVES_GENERATED_EXT ("
                           << nTFPrimitivesWritten << ")" << tcu::TestLog::EndMessage;

        m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
        return STOP;
    }

    m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
    return STOP;
}

/**
 * The function binds the provided bufferId to transform feedback target and sets up a query
 * for GL_PRIMITIVES_GENERATED_EXT GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN.
 * It then issues a draw call to execute the vertex and geometry shaders. Then results
 * of the queries are written to nPrimitivesGenerated and nPrimitivesWritten variables.
 *
 * @param context bufferId   id of the buffer to be bound to transform feedback target
 * @return nPrimitivesGenerated      the result of GL_PRIMITIVES_GENERATED_EXT query
 * @return nPrimitivesWritten        the result of GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN query
 */
void GeometryShaderPrimitiveQueries::readPrimitiveQueryValues(glw::GLint bufferId, glw::GLuint *nPrimitivesGenerated,
                                                              glw::GLuint *nPrimitivesWritten)
{
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    /* Bind the buffer object to hold the captured data.*/
    gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, bufferId);

    /* Activate the program object */
    gl.useProgram(m_po_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "Error using program object");

    gl.beginTransformFeedback(getTFMode());
    GLU_EXPECT_NO_ERROR(gl.getError(), "Error starting transform feedback");

    /* Activate the queries */
    gl.beginQuery(m_glExtTokens.PRIMITIVES_GENERATED, m_qo_primitives_generated_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "Error starting GL_PRIMITIVES_GENERATED_EXT query");

    gl.beginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, m_qo_tf_primitives_written_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "Error starting GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN query");

    /* Render */
    gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */);
    GLU_EXPECT_NO_ERROR(gl.getError(), "Error executing draw call");

    gl.endTransformFeedback();
    GLU_EXPECT_NO_ERROR(gl.getError(), "Error finishing transform feedback");

    /* Query objects end here. */
    gl.endQuery(m_glExtTokens.PRIMITIVES_GENERATED);
    gl.endQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);

    /* Retrieve query values */
    gl.getQueryObjectuiv(m_qo_primitives_generated_id, GL_QUERY_RESULT, nPrimitivesGenerated);
    gl.getQueryObjectuiv(m_qo_tf_primitives_written_id, GL_QUERY_RESULT, nPrimitivesWritten);

    GLU_EXPECT_NO_ERROR(gl.getError(), "Error retrieving query values.");
}

} // namespace glcts