external/openglcts/modules/glesext/tessellation_shader/esextcTessellationShaderBarrier.hpp

#ifndef _ESEXTCTESSELLATIONSHADERBARRIER_HPP
#define _ESEXTCTESSELLATIONSHADERBARRIER_HPP
/*-------------------------------------------------------------------------
 * 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 "gluShaderUtil.hpp"
#include "tcuDefs.hpp"

#include "../esextcTestCaseBase.hpp"

namespace glcts
{

/* Groups all barrier tests */
class TessellationShaderBarrierTests : public TestCaseGroupBase
{
public:
    /* Public methods */
    TessellationShaderBarrierTests(Context &context, const ExtParameters &extParams);

    virtual void init(void);
};

/** Base class for all tests that check the memory barrier functionality.
 **/
class TessellationShaderBarrierTestCase : public TestCaseBase
{
public:
    /* Public methods */
    TessellationShaderBarrierTestCase(Context &context, const ExtParameters &extParams, const char *name,
                                      const char *description);

    virtual ~TessellationShaderBarrierTestCase(void)
    {
    }

    virtual void deinit();
    virtual void initTest(void);
    virtual IterateResult iterate(void);

protected:
    /* Protected methods */
    virtual void getDrawCallArgs(glw::GLenum *out_mode, glw::GLint *out_count, glw::GLenum *out_tf_mode,
                                 glw::GLint *out_n_patch_vertices, glw::GLint *out_n_instances) = 0;

    virtual const char *getTCSCode()                                         = 0;
    virtual const char *getTESCode()                                         = 0;
    virtual const char *getVSCode()                                          = 0;
    virtual int getXFBBufferSize()                                           = 0;
    virtual void getXFBProperties(int *out_n_names, const char ***out_names) = 0;
    virtual bool verifyXFBBuffer(const void *data)                           = 0;

    /* Protected variables */
    glw::GLuint m_bo_id;
    glw::GLuint m_fs_id;
    glw::GLuint m_po_id;
    glw::GLuint m_tcs_id;
    glw::GLuint m_tes_id;
    glw::GLuint m_vao_id;
    glw::GLuint m_vs_id;
};

/** Implementation of Test Case 22.1
 *
 *  Make sure that a barrier used in a tessellation control shader synchronizes
 *  all instances working on the same patch. Tests the following scenario:
 *
 * * invocation A can correctly read a per-vertex & per-patch attribute
 *    modified by invocation B after a barrier() call;
 **/
class TessellationShaderBarrier1 : public TessellationShaderBarrierTestCase
{
public:
    /* Public methods */
    TessellationShaderBarrier1(Context &context, const ExtParameters &extParams);

    virtual ~TessellationShaderBarrier1(void)
    {
    }

protected:
    /* Protected methods */
    void getDrawCallArgs(glw::GLenum *out_mode, glw::GLint *out_count, glw::GLenum *out_tf_mode,
                         glw::GLint *out_n_patch_vertices, glw::GLint *out_n_instances);

    const char *getTCSCode();
    const char *getTESCode();
    const char *getVSCode();
    int getXFBBufferSize();
    void getXFBProperties(int *out_n_names, const char ***out_names);
    bool verifyXFBBuffer(const void *data);

private:
    /* Private fields */
    unsigned int m_n_input_vertices;
    const unsigned int m_n_result_vertices;
};

/** Implementation of Test Case 22.2
 *
 *  Make sure that a barrier used in a tessellation control shader synchronizes
 *  all instances working on the same patch. Tests the following scenario:
 *
 * * invocation A writes to a per-patch output. A barrier is then issued,
 *   after which invocation B overwrites the same per-patch output. One more
 *   barrier is issued, after which invocation A should be able to read this
 *   output correctly.
 **/
class TessellationShaderBarrier2 : public TessellationShaderBarrierTestCase
{
public:
    /* Public methods */
    TessellationShaderBarrier2(Context &context, const ExtParameters &extParams);

    virtual ~TessellationShaderBarrier2(void)
    {
    }

protected:
    /* Protected methods */
    void getDrawCallArgs(glw::GLenum *out_mode, glw::GLint *out_count, glw::GLenum *out_tf_mode,
                         glw::GLint *out_n_patch_vertices, glw::GLint *out_n_instances);

    const char *getTCSCode();
    const char *getTESCode();
    const char *getVSCode();
    int getXFBBufferSize();
    void getXFBProperties(int *out_n_names, const char ***out_names);
    bool verifyXFBBuffer(const void *data);

private:
    /* Private fields */
    unsigned int m_n_input_vertices;
    const unsigned int m_n_result_vertices;
};

/** Implementation of Test Case 22.3
 *
 *  Make sure that a barrier used in a tessellation control shader synchronizes
 *  all instances working on the same patch. Tests the following scenario:
 *
 * * even invocations should write their gl_InvocationID value to their
 *   per-vertex output. A barrier is then issued, after which each odd invocation
 *   should read values stored by preceding even invocation, add current
 *   invocation's ID to that value and then write it to its per-vertex output.
 *   One more barrier should be issued. Then, every fourth invocation should
 *   read & sum up per-vertex outputs for four invocations following it
 *   (including the one discussed), and store it in a per-patch variable. (n+1)-th,
 *   (n+2)-th and (n+3)-th invocations should store zero in dedicated per-patch
 *   variables. 16 invocations should be considered, with 10 instances used for the
 *   draw call, each patch should consist of 8 vertices.
 **/
class TessellationShaderBarrier3 : public TessellationShaderBarrierTestCase
{
public:
    /* Public methods */
    TessellationShaderBarrier3(Context &context, const ExtParameters &extParams);

    virtual ~TessellationShaderBarrier3(void)
    {
    }

protected:
    /* Protected methods */
    void getDrawCallArgs(glw::GLenum *out_mode, glw::GLint *out_count, glw::GLenum *out_tf_mode,
                         glw::GLint *out_n_patch_vertices, glw::GLint *out_n_instances);

    const char *getTCSCode();
    const char *getTESCode();
    const char *getVSCode();
    int getXFBBufferSize();
    void getXFBProperties(int *out_n_names, const char ***out_names);
    bool verifyXFBBuffer(const void *data);

private:
    /* Private fields */
    unsigned int m_n_input_vertices;
    const unsigned int m_n_instances;
    const unsigned int m_n_invocations;
    const unsigned int m_n_patch_vertices;
    const unsigned int m_n_patches_per_invocation;
    const unsigned int m_n_result_vertices;
};

} // namespace glcts

#endif // _ESEXTCTESSELLATIONSHADERBARRIER_HPP