Lines Matching refs:result
350 _variable_type result = VARIABLE_TYPE_UNKNOWN;
356 result = VARIABLE_TYPE_BOOL;
375 result = VARIABLE_TYPE_DOUBLE;
385 result = VARIABLE_TYPE_INT;
395 result = VARIABLE_TYPE_UINT;
414 result = VARIABLE_TYPE_FLOAT;
425 return result;
436 unsigned int result = 0;
441 result = sizeof(bool);
444 result = sizeof(double);
447 result = sizeof(float);
450 result = sizeof(int);
453 result = sizeof(unsigned int);
462 return result;
475 unsigned char result = '?';
480 result = 'x';
483 result = 'y';
486 result = 'z';
489 result = 'w';
498 return result;
534 std::string result = "[?]";
539 result = "float";
542 result = "mat2";
545 result = "mat2x3";
548 result = "mat2x4";
551 result = "mat3";
554 result = "mat3x2";
557 result = "mat3x4";
560 result = "mat4";
563 result = "mat4x2";
566 result = "mat4x3";
569 result = "vec2";
572 result = "vec3";
575 result = "vec4";
584 return result;
596 glw::GLenum result = GL_NONE;
601 result = GL_BOOL;
604 result = GL_DOUBLE;
607 result = GL_FLOAT;
610 result = GL_INT;
613 result = GL_UNSIGNED_INT;
622 return result;
633 glw::GLenum result = GL_NONE;
638 result = GL_BOOL;
641 result = GL_DOUBLE;
644 result = GL_DOUBLE_MAT2;
647 result = GL_DOUBLE_MAT2x3;
650 result = GL_DOUBLE_MAT2x4;
653 result = GL_DOUBLE_MAT3;
656 result = GL_DOUBLE_MAT3x2;
659 result = GL_DOUBLE_MAT3x4;
662 result = GL_DOUBLE_MAT4;
665 result = GL_DOUBLE_MAT4x2;
668 result = GL_DOUBLE_MAT4x3;
671 result = GL_DOUBLE_VEC2;
674 result = GL_DOUBLE_VEC3;
677 result = GL_DOUBLE_VEC4;
680 result = GL_FLOAT;
683 result = GL_INT;
686 result = GL_INT_VEC2;
689 result = GL_INT_VEC3;
692 result = GL_INT_VEC4;
695 result = GL_FLOAT_MAT2;
698 result = GL_FLOAT_MAT2x3;
701 result = GL_FLOAT_MAT2x4;
704 result = GL_FLOAT_MAT3;
707 result = GL_FLOAT_MAT3x2;
710 result = GL_FLOAT_MAT3x4;
713 result = GL_FLOAT_MAT4;
716 result = GL_FLOAT_MAT4x2;
719 result = GL_FLOAT_MAT4x3;
722 result = GL_UNSIGNED_INT;
725 result = GL_UNSIGNED_INT_VEC2;
728 result = GL_UNSIGNED_INT_VEC3;
731 result = GL_UNSIGNED_INT_VEC4;
734 result = GL_FLOAT_VEC2;
737 result = GL_FLOAT_VEC3;
740 result = GL_FLOAT_VEC4;
749 return result;
788 unsigned int result = 0;
798 result = 1;
808 result = 2;
818 result = 3;
828 result = 4;
836 result = 2 * 2;
846 result = 2 * 3;
856 result = 2 * 4;
864 result = 3 * 3;
874 result = 3 * 4;
882 result = 4 * 4;
893 return result;
905 unsigned int result = 0;
927 result = 1;
939 result = 2;
951 result = 3;
963 result = 4;
974 return result;
986 unsigned int result = 0;
991 result = 1;
994 result = 1;
997 result = 2;
1000 result = 2;
1003 result = 2;
1006 result = 6;
1009 result = 8;
1012 result = 6;
1015 result = 4;
1018 result = 8;
1021 result = 8;
1024 result = 4;
1027 result = 6;
1036 return result;
1047 unsigned int result = 0;
1057 result = 1;
1073 result = 2;
1089 result = 3;
1105 result = 4;
1116 return result;
1135 Utils::_variable_type result;
1144 result = VARIABLE_TYPE_DMAT2;
1147 result = VARIABLE_TYPE_DMAT2X3;
1150 result = VARIABLE_TYPE_DMAT2X4;
1155 TCU_FAIL("Unrecognized amount of rows in result variable");
1167 result = VARIABLE_TYPE_DMAT3X2;
1170 result = VARIABLE_TYPE_DMAT3;
1173 result = VARIABLE_TYPE_DMAT3X4;
1178 TCU_FAIL("Unrecognized amount of rows in result variable");
1190 result = VARIABLE_TYPE_DMAT4X2;
1193 result = VARIABLE_TYPE_DMAT4X3;
1196 result = VARIABLE_TYPE_DMAT4;
1201 TCU_FAIL("Unrecognized amount of rows in result variable");
1210 TCU_FAIL("Unrecognized amount of columns in result variable");
1215 return result;
1262 Utils::_variable_type result;
1267 result = VARIABLE_TYPE_DMAT2;
1270 result = VARIABLE_TYPE_DMAT3X2;
1273 result = VARIABLE_TYPE_DMAT4X2;
1276 result = VARIABLE_TYPE_DMAT3;
1279 result = VARIABLE_TYPE_DMAT2X3;
1282 result = VARIABLE_TYPE_DMAT4X3;
1285 result = VARIABLE_TYPE_DMAT4;
1288 result = VARIABLE_TYPE_DMAT2X4;
1291 result = VARIABLE_TYPE_DMAT3X4;
1300 return result;
1338 std::string result = "[?]";
1343 result = "bool";
1346 result = "bvec2";
1349 result = "bvec3";
1352 result = "bvec4";
1355 result = "double";
1358 result = "dmat2";
1361 result = "dmat2x3";
1364 result = "dmat2x4";
1367 result = "dmat3";
1370 result = "dmat3x2";
1373 result = "dmat3x4";
1376 result = "dmat4";
1379 result = "dmat4x2";
1382 result = "dmat4x3";
1385 result = "dvec2";
1388 result = "dvec3";
1391 result = "dvec4";
1394 result = "float";
1397 result = "int";
1400 result = "ivec2";
1403 result = "ivec3";
1406 result = "ivec4";
1409 result = "mat2";
1412 result = "mat2x3";
1415 result = "mat2x4";
1418 result = "mat3";
1421 result = "mat3x2";
1424 result = "mat3x4";
1427 result = "mat4";
1430 result = "mat4x2";
1433 result = "mat4x3";
1436 result = "uint";
1439 result = "uvec2";
1442 result = "uvec3";
1445 result = "uvec4";
1448 result = "vec2";
1451 result = "vec3";
1454 result = "vec4";
1463 return result;
1533 bool result = false;
1538 result = true;
1541 result = true;
1544 result = true;
1547 result = true;
1550 result = true;
1556 return result;
1683 const char* result = "[?]";
1688 result = "glUniform1d";
1691 result = "glUniform1dv";
1694 result = "glUniform2d";
1697 result = "glUniform2dv";
1700 result = "glUniform3d";
1703 result = "glUniform3dv";
1706 result = "glUniform4d";
1709 result = "glUniform4dv";
1712 result = "glUniformMatrix2dv";
1715 result = "glUniformMatrix2x3dv";
1718 result = "glUniformMatrix2x4dv";
1721 result = "glUniformMatrix3dv";
1724 result = "glUniformMatrix3x2dv";
1727 result = "glUniformMatrix3x4dv";
1730 result = "glUniformMatrix4dv";
1733 result = "glUniformMatrix4x2dv";
1736 result = "glUniformMatrix4x3dv";
1742 return result;
1754 const char* result = "[?]";
1757 result = "uniform_bool_arr";
1759 result = "uniform_bool";
1761 result = "uniform_bvec2_arr";
1763 result = "uniform_bvec2";
1765 result = "uniform_bvec3_arr";
1767 result = "uniform_bvec3";
1769 result = "uniform_bvec4_arr";
1771 result = "uniform_bvec4";
1773 result = "uniform_dmat2_arr";
1775 result = "uniform_dmat2";
1777 result = "uniform_dmat2x3_arr";
1779 result = "uniform_dmat2x3";
1781 result = "uniform_dmat2x4_arr";
1783 result = "uniform_dmat2x4";
1785 result = "uniform_dmat3_arr";
1787 result = "uniform_dmat3";
1789 result = "uniform_dmat3x2_arr";
1791 result = "uniform_dmat3x2";
1793 result = "uniform_dmat3x4_arr";
1795 result = "uniform_dmat3x4";
1797 result = "uniform_dmat4_arr";
1799 result = "uniform_dmat4";
1801 result = "uniform_dmat4x2_arr";
1803 result = "uniform_dmat4x2";
1805 result = "uniform_dmat4x3_arr";
1807 result = "uniform_dmat4x3";
1809 result = "uniform_double_arr";
1811 result = "uniform_double";
1813 result = "uniform_dvec2_arr";
1815 result = "uniform_dvec2";
1817 result = "uniform_dvec3_arr";
1819 result = "uniform_dvec3";
1821 result = "uniform_dvec4_arr";
1823 result = "uniform_dvec4";
1825 result = "uniform_float_arr";
1827 result = "uniform_float";
1829 result = "uniform_int_arr";
1831 result = "uniform_int";
1833 result = "uniform_ivec2_arr";
1835 result = "uniform_ivec2";
1837 result = "uniform_ivec3_arr";
1839 result = "uniform_ivec3";
1841 result = "uniform_ivec4_arr";
1843 result = "uniform_ivec4";
1845 result = "uniform_uint_arr";
1847 result = "uniform_uint";
1849 result = "uniform_uvec2_arr";
1851 result = "uniform_uvec2";
1853 result = "uniform_uvec3_arr";
1855 result = "uniform_uvec3";
1857 result = "uniform_uvec4_arr";
1859 result = "uniform_uvec4";
1861 result = "uniform_vec2_arr";
1863 result = "uniform_vec2";
1865 result = "uniform_vec3_arr";
1867 result = "uniform_vec3";
1869 result = "uniform_vec4_arr";
1871 result = "uniform_vec4";
1873 return result;
2253 bool result = true;
2341 result = false;
2346 return result;
2360 bool result = true;
2439 result = false;
2443 return result;
2457 bool result = true;
2560 result = false;
2565 return result;
2576 bool result = true;
2698 result = false;
2702 return result;
2716 bool result = true;
2789 result = false;
2793 return result;
2807 bool result = true;
2939 result = false;
2944 return result;
2958 bool result = true;
3031 result = false;
3035 return result;
3049 bool result = true;
3142 result = false;
3147 return result;
3158 bool result = true;
3235 result = false;
3239 return result;
3326 bool result = true;
3350 result = false;
3355 /* Set result */
3356 if (true == result)
3764 static const glw::GLchar* passthrough_tess_eval_shader_body_code = " result = tcs_tes_result[0];\n";
3766 static const glw::GLchar* test_shader_body_code = "\n result = verification_result;\n";
3768 static const glw::GLchar* test_geometry_shader_body_code = "\n result = verification_result;\n"
3787 static const glw::GLchar* test_fragment_shader_out_variable = "layout(location = 0) out int result;\n";
3791 static const glw::GLchar* test_shader_out_variable = "out int result;\n";
3794 static const glw::GLchar* varying_name = "result";
4062 "layout(r32i) writeonly uniform iimage2D result;\n"
4068 " imageStore(result, ivec2(gl_WorkGroupID.xy), ivec4(verification_result, 0, 0, 0));\n"
4270 bool result = true;
4306 result = false;
4309 return result;
4348 if ((1 != size) || (GL_INT != type) || (0 != strcmp("result", name)))
4353 << ". Name: " << name << " expected: result" << tcu::TestLog::EndMessage;
4408 glw::GLint location = gl.getUniformLocation(program_id, "result");
4413 TCU_FAIL("Inactive uniform \"result\"");
4519 /** Result verification, expected result is that whole buffer is filled with m_result_success
4566 bool result = true;
4585 result = false;
4594 return result;
4697 bool result = true;
4711 result = false;
4717 result = false;
4723 result = false;
4726 /* Set result */
4727 if (true == result)
5158 * @return false if uniform offsets verification result is failure, true otherwise
5251 bool result = true;
5267 result = false;
5294 result = false;
5298 return result;
5459 /* Set result */
5466 << "Vertex shader stage result: " << vertex_shader_result
5470 << "Tesselation control shader stage result: " << tess_ctrl_shader_result
5474 << "Tesselation evaluation shader stage result: " << tess_eval_shader_result
5478 << "Geometry shader stage result: " << geometry_shader_result
5482 << "Fragment shader stage result: " << fragment_shader_result
5503 /* Select name for varying that will hold result of "that" shader_stage */
6344 "out vec4 result;\n"
6359 " result = vec4(0.0);\n"
6363 " result = vec4(1.0);\n"
6737 bool result = true;
6863 result = false;
6891 result = false;
6902 result = false;
6917 return result;
6929 bool result = true;
7106 result = false;
7122 result = false;
7145 result = false;
7161 result = false;
7170 return result;
7287 bool result = true;
7393 result &= verifyXFBData((const unsigned char*)xfb_data_ptr, test_case);
7408 return result;
7597 std::stringstream result;
7605 result << "#version 420\n"
7612 result << "out int result;\n";
7616 result << "out " << dst_type_string << " result;\n";
7623 result << "in int base_value;\n";
7627 result << "in " << base_type_string << " base_value;\n";
7636 result << "void main()\n"
7642 result << src_type_string << "(0 != ";
7646 result << src_type_string << "(";
7653 result << "base_value + " << n_component;
7657 result << ", ";
7665 result << "base_value";
7668 result << ");\n";
7676 result << "result = (bool(lside_value) == false) ? 0 : 1";
7680 result << "result = (lside_value == false) ? 0 : 1";
7687 result << "result = " << dst_type_string << "(lside_value)";
7691 result << "result = lside_value";
7710 result << "." << swizzle_string;
7715 result << ";\n"
7718 return result.str();
7769 const char* xfb_varying_name = "result";
7951 bool result = true;
8017 result = false;
8074 result = false;
8120 result = false;
8159 result = false;
8170 } /* for (all result components) */
8173 return result;
8257 bool result = true;
8327 result = false;
8331 return result;
8867 bool result = false;
8969 result = true;
8972 return result;
9134 bool result = true;
9235 result = false;
9244 return result;
9416 << "out vec4 result;\n"
9424 "result = vec4(1, 0, 0, 0);\n"
9563 " result = vec4(0, 1, 0, 0);\n"
9825 * @param variables List of variables to declare in the result string.
10451 bool result = true;
10521 result = false;
10525 return result;
10665 _argument_lists result;
10689 result.push_back(argument_list);
10692 return result;
11074 bool result = true;
11095 result = verifyXFBData(test_case, (const unsigned char*)xfb_data_ptr);
11101 return result;
11104 /** Performs a matrix multiplication, given types of l-side and r-side matrices and stores the result
11111 * @param out_result_ptr Deref to be used to store the multiplication result.
11129 tcu::Matrix2d result;
11133 result = matrix_a * matrix_b;
11135 memcpy(out_result_ptr, result.getColumnMajorData().getPtr(), sizeof(double) * 2 * 2);
11147 tcu::Matrix<double, 3, 3> result;
11151 result = matrix_a_transposed * matrix_b_transposed;
11153 memcpy(out_result_ptr, result.getColumnMajorData().getPtr(), sizeof(double) * 3 * 3);
11165 tcu::Matrix<double, 4, 4> result;
11169 result = matrix_a_transposed * matrix_b_transposed;
11171 memcpy(out_result_ptr, result.getColumnMajorData().getPtr(), sizeof(double) * 4 * 4);
11181 tcu::Matrix<double, 3, 3> result;
11185 result = matrix_a * matrix_b;
11187 memcpy(out_result_ptr, result.getColumnMajorData().getPtr(), sizeof(double) * 3 * 3);
11199 tcu::Matrix<double, 2, 2> result;
11203 result = matrix_a_transposed * matrix_b_transposed;
11205 memcpy(out_result_ptr, result.getColumnMajorData().getPtr(), sizeof(double) * 2 * 2);
11217 tcu::Matrix<double, 4, 4> result;
11221 result = matrix_a_transposed * matrix_b_transposed;
11223 memcpy(out_result_ptr, result.getColumnMajorData().getPtr(), sizeof(double) * 4 * 4);
11233 tcu::Matrix<double, 4, 4> result;
11237 result = matrix_a * matrix_b;
11239 memcpy(out_result_ptr, result.getColumnMajorData().getPtr(), sizeof(double) * 4 * 4);
11251 tcu::Matrix<double, 2, 2> result;
11255 result = matrix_a_transposed * matrix_b_transposed;
11257 memcpy(out_result_ptr, result.getColumnMajorData().getPtr(), sizeof(double) * 2 * 2);
11269 tcu::Matrix<double, 3, 3> result;
11273 result = matrix_a_transposed * matrix_b_transposed;
11275 memcpy(out_result_ptr, result.getColumnMajorData().getPtr(), sizeof(double) * 3 * 3);
11294 const char* result = NULL;
11299 result = "+";
11302 result = "/";
11305 result = "*";
11308 result = "-";
11314 result = "--";
11322 result = "++";
11333 return result;
11344 std::string result = "[?]";
11349 result = "addition";
11352 result = "division";
11355 result = "multiplication";
11358 result = "subtraction";
11361 result = "pre-decrementation";
11364 result = "pre-incrementation";
11367 result = "post-decrementation";
11370 result = "post-incrementation";
11379 return result;
11398 * for the result variable if either of the matrices is not square.
11420 << result_variable_type_string << " result;\n"
11478 "result = ";
11603 const char* xfb_names[] = { "result", "result_lt", "result_lte", "result_gt", "result_gte" };
11707 bool result = true;
11756 /* Generate as many components as will be expected for the result variable */
11764 /* Verify the result value(s) */
11813 result = false;
11816 } /* for (all result components) */
11873 result = false;
11905 result = false;
11924 result = false;
11943 result = false;
11963 result = false;
11982 result = false;
11986 return result;
11999 typedef T result;
12006 typedef T result;
12269 tcu::Matrix<glw::GLdouble, Size, Size> result;
12277 result(r, c) = (1 == (c + r) % 2) ? -minor_value : minor_value;
12281 return result;
12287 tcu::Vector<glw::GLuint, Size> result;
12293 result[i] = 1;
12297 result[i] = 0;
12301 return result;
12364 tcu::Matrix<glw::GLdouble, Size - 1, Size - 1> result;
12385 result(r + r_offset, c + c_offset) = matrix(r, c);
12389 return result;
12441 tcu::Matrix<glw::GLdouble, Size, Size> result = adjugate * inv_det;
12443 return result;
12539 T result = left * right;
12541 return result;
12557 tcu::Matrix<glw::GLdouble, Rows, Cols> result;
12569 result = left_mat * right_mat;
12571 return result;
12577 glw::GLdouble result;
12578 memcpy(&result, buffer, sizeof(result));
12579 return result;
12646 T result = temp * temp * (3 - 2 * temp);
12648 return result;
12667 tcu::Matrix<T, Cols, Rows> result = tcu::transpose(matrix);
12669 return result;
12678 const T result = sign(t) * result_value;
12680 return result;
12686 tcu::UVec2 result(ptr[0], ptr[1]);
12688 return result;
12811 * arguments for the function in question. The result of the
12856 glw::GLuint getResultComponents(glw::GLuint result) const;
12858 glw::GLuint getResultOffset(glw::GLuint result) const;
12859 virtual Utils::_variable_type getResultType(glw::GLuint result) const;
12860 glw::GLuint getResultStride(glw::GLuint result) const;
12861 glw::GLuint getBaseTypeSize(glw::GLuint result) const;
12989 TypeHelpers::typeInfo<typename TypeHelpers::referenceToType<T>::result>::variable_type;
13100 * @tparam ResT Type of result
13117 ResT result;
13124 result = p_function(arg);
13126 pack<ResT>::set(result_dst, result);
13132 * @tparam ResT Type of result
13163 * @tparam ResT Type of result
13210 Utils::_variable_type getResultType(glw::GLuint result) const
13214 switch (result)
13274 * @param ResT Type of result
13298 ResT result;
13303 result = p_function(arg_1, arg_2);
13305 pack<ResT>::set(result_dst, result);
13311 * @param ResT Type of result
13397 * @param ResT Type of result
13407 typedef typename TypeHelpers::referenceToType<Arg1T>::result arg1T;
13408 typedef typename TypeHelpers::referenceToType<Arg2T>::result arg2T;
13409 typedef typename TypeHelpers::referenceToType<Arg3T>::result arg3T;
13427 ResT result;
13433 result = p_function(arg_1, arg_2, arg_3);
13435 pack<ResT>::set(result_dst, result);
13537 /* Verify result */
13557 * @param result_type Type of result
13606 glw::GLuint result = 0;
13610 result += getArgumentStride(i);
13613 return result;
13623 glw::GLuint result = 0;
13627 result += getArgumentStride(i);
13630 return result;
13665 /** Get number of components for <result>
13667 * @param result Result ordinal, starts with 0
13671 glw::GLuint BuiltinFunctionTest::functionObject::getResultComponents(glw::GLuint result) const
13673 const Utils::_variable_type type = getResultType(result);
13688 /** Get offset in bytes of <result>. First result offset is 0. Assume tight packing.
13690 * @param result Result ordinal, starts with 0
13694 glw::GLuint BuiltinFunctionTest::functionObject::getResultOffset(glw::GLuint result) const
13698 for (glw::GLuint i = 0; i < result; ++i)
13707 /** Get stride in bytes of <result>.
13709 * @param result Result ordinal, starts with 0
13713 glw::GLuint BuiltinFunctionTest::functionObject::getResultStride(glw::GLuint result) const
13715 const Utils::_variable_type type = getResultType(result);
13718 return n_components * getBaseTypeSize(result);
13721 /** Get size in bytes of <result> base component.
13723 * @param result Result ordinal, starts with 0
13727 glw::GLuint BuiltinFunctionTest::functionObject::getBaseTypeSize(glw::GLuint result) const
13729 const Utils::_variable_type type = getResultType(result);
13759 /** Get type of <result>.
13761 * @param result Result ordinal, starts with 0
13765 Utils::_variable_type BuiltinFunctionTest::functionObject::getResultType(glw::GLuint /* result */) const
13809 bool result = true;
13830 result = false;
13851 result = false;
13872 result = false;
13885 return result;
14628 /** Get name of varying that will be used as <result>.
14630 * @param result Result index
14634 const glw::GLchar* BuiltinFunctionTest::getVaryingName(glw::GLuint result) const
14636 switch (result)
14713 bool result = look_up_table[function][type.m_general_type];
14715 if (true == result)
14720 result = (3 == type.m_n_rows);
14724 result = (type.m_n_columns == type.m_n_rows);
14731 return result;
15045 for (glw::GLuint result = 0; result < n_results; ++result)
15047 Utils::_variable_type variable_type = function_object.getResultType(result);
15048 const glw::GLchar* varying_name = getVaryingName(result);
15090 for (glw::GLuint result = 1; result < n_results; ++result)
15092 const glw::GLchar* varying_name = getVaryingName(result);
15259 /** Checks if function result is an acceptable edge case
15294 // verify if there is a mod(a, a) case and prepare new expected result
15305 // and component of result are equal then expected result must be corrected
15314 // recheck test result with corrected expected result
15345 for (glw::GLuint result = 0; result < n_results; ++result)
15347 const Utils::_variable_type result_type = function_object.getResultType(result);
15348 const glw::GLuint result_offset = function_object.getResultOffset(result);
15372 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Error. Invalid result."
15378 for (glw::GLuint result = 0; result < n_results; ++result)
15380 const Utils::_variable_type result_type = function_object.getResultType(result);
15381 const glw::GLuint result_offset = function_object.getResultOffset(result);
15387 logVariableType(expected_result_src, "Expected result", result_type);