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

#ifndef _ESEXTCTESSELLATIONSHADERVERTEXSPACING_HPP
#define _ESEXTCTESSELLATIONSHADERVERTEXSPACING_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 "../esextcTestCaseBase.hpp"
#include "esextcTessellationShaderUtils.hpp"
#include "gluShaderUtil.hpp"
#include "tcuDefs.hpp"
#include <deMath.h>

namespace glcts
{
/** Implementation of Test Case 25
 *
 *  Make sure that vertex spacing mode defined in a tessellation evaluation
 *  shader affects the tessellation primitive generator as per specification,
 *  to the limit enforced by implementation-dependent behaviour.
 *  Consider all three tessellation primitive generator modes (triangles,
 *  quads, isolines). TE stage should be run in point mode.
 *  Make sure that by default the tessellation primitive generator works in
 *  equal_spacing spacing mode.
 *  Make sure that negative inner levels are clamped as defined for active
 *  vertex spacing mode.
 *
 *  Technical details:
 *
 *  0. Consider the following set: {-1 (where valid), 1, MAX_TESS_GEN_LEVEL_EXT / 2,
 *     MAX_TESS_GEN_LEVEL_EXT}. All combinations of values from this set
 *     in regard to relevant inner/outer tessellation levels for all
 *     primitive generator modes should be checked by this test.
 *
 *  1. This test should capture vertices output by TE stage and verify their
 *     locations. If an edge is defined by function y = a * t + b (a, b
 *     computed from locations of edge start & end points), t should be
 *     calculated for each vertex that is a part of the edge considered.
 *  2. Test passes if t values are in agreement with the specification
 *     (assume epsilon 1e-5) and vertex spacing mode considered.
 *
 *  This test implementation skips configurations meeting all of the following
 *  properties:
 *
 *  - primitive mode:      QUADS
 *  - vertex spacing mode: FRACTIONAL ODD
 *  - inner tess level[0]: <= 1
 *  - inner tess level[1]: <= 1
 *
 *  These configurations are affected by a nuance described in greater
 *  detail in Khronos Bugzilla#11979, which this test cannot handle.
 **/
class TessellationShaderVertexSpacing : public TestCaseBase
{
public:
    /* Public methods */
    TessellationShaderVertexSpacing(Context &context, const ExtParameters &extParams);

    virtual ~TessellationShaderVertexSpacing(void)
    {
    }

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

private:
    /* Private type definitions */
    /** Stores properties of a single test run */
    typedef struct _run
    {
        float inner[2];
        float outer[4];
        _tessellation_primitive_mode primitive_mode;
        _tessellation_shader_vertex_spacing vertex_spacing;

        std::vector<char> data;
        float *data_cartesian; /* only used for 'triangles' case */
        unsigned int n_vertices;

        /* Constructor. Resets all fields to default values */
        _run()
        {
            memset(inner, 0, sizeof(inner));
            memset(outer, 0, sizeof(outer));
            data_cartesian = 0;
            n_vertices     = 0;
            primitive_mode = TESSELLATION_SHADER_PRIMITIVE_MODE_UNKNOWN;
            vertex_spacing = TESSELLATION_SHADER_VERTEX_SPACING_UNKNOWN;
        }
    } _run;

    /** Stores either barycentric or Cartesian coordinate data
     *  (depending on primitive mode of a test run this structure
     *  will be instantiated for)
     */
    typedef struct _tess_coordinate
    {
        float u;
        float v;
        float w;

        /* Constructor. Resets all fields to 0 */
        _tess_coordinate()
        {
            u = 0.0f;
            v = 0.0f;
            w = 0.0f;
        }

        /* Constructor.
         *
         * @param u Value to set for U component;
         * @param v Value to set for V component;
         * @param w Value to set for W component;
         */
        _tess_coordinate(float _u, float _v, float _w)
        {
            this->u = _u;
            this->v = _v;
            this->w = _w;
        }

        /** Compares two barycentric/Cartesian coordinates, using test-wide epsilon.
         *
         *  @param in Coordinate to compare current instance against.
         *
         *  @return true if the coordinates are equal, false otherwise.
         **/
        bool operator==(const _tess_coordinate &in) const;
    } _tess_coordinate;

    /** Stores Cartesian coordinate data. */
    typedef struct _tess_coordinate_cartesian
    {
        float x;
        float y;

        /* Constructor. Resets all values to 0 */
        _tess_coordinate_cartesian()
        {
            x = 0.0f;
            y = 0.0f;
        }

        /* Constructor.
         *
         * @param x Value to use for X component;
         * @param y Value to use for Y component;
         */
        _tess_coordinate_cartesian(float _x, float _y)
        {
            this->x = _x;
            this->y = _y;
        }

        /** Compares two Cartesian coordinates, using test-wide epsilon.
         *
         *  @param in Coordinate to compare current instance against.
         *
         *  @return true if the coordinates are equal, false otherwise.
         **/
        bool operator==(const _tess_coordinate_cartesian &in) const;
    } _tess_coordinate_cartesian;

    /** Stores information on:
     *
     *  - a delta between two coordinates;
     *  - amount of segments that had exactly that length.
     **/
    typedef struct _tess_coordinate_delta
    {
        unsigned int counter;
        float delta;

        /* Constructor. Resets all values to 0 */
        _tess_coordinate_delta()
        {
            counter = 0;
            delta   = 0.0f;
        }
    } _tess_coordinate_delta;

    /** Vector of coordinate deltas */
    typedef std::vector<_tess_coordinate_delta> _tess_coordinate_deltas;
    typedef _tess_coordinate_deltas::const_iterator _tess_coordinate_deltas_const_iterator;
    typedef _tess_coordinate_deltas::iterator _tess_coordinate_deltas_iterator;

    /** Vector of Cartesian coordinates making up an edge. */
    typedef std::vector<_tess_coordinate_cartesian> _tess_edge_points;
    typedef _tess_edge_points::const_iterator _tess_edge_points_const_iterator;
    typedef _tess_edge_points::iterator _tess_edge_points_iterator;

    /** Defines a single edge of a quad/triangle *or* a single isoline (depending
     *  on the primitive mode used for a test run, for which the edge is defined)
     */
    typedef struct _tess_edge
    {
        _tess_edge_points points;
        float edge_length;
        float outermost_tess_level;
        float tess_level;

        /* Constructor.
         *
         * @param in_tess_level  Tessellation level value specific to the edge.
         * @param in_edge_length Total Euclidean length of the edge.
         */
        _tess_edge(const float &in_tess_level, const float &in_outermost_tess_level, const float &in_edge_length)
            : edge_length(in_edge_length)
            , outermost_tess_level(in_outermost_tess_level)
            , tess_level(in_tess_level)
        {
        }
    } _tess_edge;

    /** Vector of edges */
    typedef std::vector<_tess_edge> _tess_edges;
    typedef _tess_edges::const_iterator _tess_edges_const_iterator;
    typedef _tess_edges::iterator _tess_edges_iterator;

    /** Vector of test runs */
    typedef std::vector<_run> _runs;
    typedef _runs::const_iterator _runs_const_iterator;

    /** Comparator that is used to sort points relative to a certain origin. */
    struct _comparator_relative_to_base_point
    {
        /* Constructor. Sets all fields to 0 */
        _comparator_relative_to_base_point() : base_point(0, 0)
        {
        }

        /* Constructor.
         *
         * @param base_point Origin, against which all comparisons should be run against.
         */
        _comparator_relative_to_base_point(const _tess_coordinate_cartesian &_base_point) : base_point(_base_point)
        {
        }

        /* Tells which of the user-provided points is closer to the instance-specific
         * "origin".
         *
         * @param a First point to use.
         * @param b Second point to use.
         *
         * @return true if point @param a is closer to the "origin", false otherwise.
         */
        bool operator()(_tess_coordinate_cartesian a, _tess_coordinate_cartesian b)
        {
            float distance_a_to_base =
                deFloatSqrt((a.x - base_point.x) * (a.x - base_point.x) + (a.y - base_point.y) * (a.y - base_point.y));
            float distance_b_to_base =
                deFloatSqrt((b.x - base_point.x) * (b.x - base_point.x) + (b.y - base_point.y) * (b.y - base_point.y));

            return distance_a_to_base < distance_b_to_base;
        }

        _tess_coordinate_cartesian base_point;
    };

    /** Comparator that is used to compare two tessellation coordinates using FP value
     *  equal operator.
     */
    struct _comparator_exact_tess_coordinate_match : public std::unary_function<float, bool>
    {
        /* Constructor.
         *
         * @param in_base_coordinate Base tessellation coordinate to compare against.
         */
        _comparator_exact_tess_coordinate_match(const _tess_coordinate_cartesian &in_base_coordinate)
            : base_coordinate(in_base_coordinate)
        {
        }

        /* Tells if the user-provided tessellation coordinate exactly matches the base tessellation
         * coordinate.
         *
         * @param value Tessellation coordinate to use for the operation.
         *
         * @return true if the coordinates are equal, false otherwise.
         */
        bool operator()(const _tess_coordinate_cartesian &value)
        {
            return (value.x == base_coordinate.x) && (value.y == base_coordinate.y);
        }

        _tess_coordinate_cartesian base_coordinate;
    };

    /* Private methods */
    static bool compareEdgeByX(_tess_coordinate_cartesian a, _tess_coordinate_cartesian b);
    static bool compareEdgeByY(_tess_coordinate_cartesian a, _tess_coordinate_cartesian b);

    bool isPointOnLine(const _tess_coordinate_cartesian &line_v1, const _tess_coordinate_cartesian &line_v2,
                       const _tess_coordinate_cartesian &point);

    _tess_edges getEdgesForIsolinesTessellation(const _run &run);
    _tess_edges getEdgesForQuadsTessellation(const _run &run);
    _tess_edges getEdgesForTrianglesTessellation(const _run &run);
    void verifyEdges(const _tess_edges &edges, const _run &run);

    /* Private variables */
    glw::GLint m_gl_max_tess_gen_level_value;
    glw::GLuint m_vao_id;
    _runs m_runs;
    TessellationShaderUtils *m_utils;
};

} // namespace glcts

#endif // _ESEXTCTESSELLATIONSHADERVERTEXSPACING_HPP