2015-09-11 17:48:05 +01:00
|
|
|
/*
|
|
|
|
* Mesa 3-D graphics library
|
|
|
|
*
|
|
|
|
* Copyright © 2015 Red Hat
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
|
|
* to deal in the Software without restriction, including without limitation
|
|
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice (including the next
|
|
|
|
* paragraph) shall be included in all copies or substantial portions of the
|
|
|
|
* Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
|
|
* IN THE SOFTWARE.
|
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Rob Clark <robclark@freedesktop.org>
|
|
|
|
*/
|
|
|
|
|
2015-10-08 23:19:00 +01:00
|
|
|
#include "shader_enums.h"
|
2015-09-11 17:48:05 +01:00
|
|
|
#include "util/macros.h"
|
2015-10-09 21:27:45 +01:00
|
|
|
#include "mesa/main/config.h"
|
2015-09-11 17:48:05 +01:00
|
|
|
|
|
|
|
#define ENUM(x) [x] = #x
|
|
|
|
#define NAME(val) ((((val) < ARRAY_SIZE(names)) && names[(val)]) ? names[(val)] : "UNKNOWN")
|
|
|
|
|
2016-01-15 21:31:34 +00:00
|
|
|
const char *
|
|
|
|
gl_shader_stage_name(gl_shader_stage stage)
|
2015-09-11 17:48:05 +01:00
|
|
|
{
|
|
|
|
static const char *names[] = {
|
|
|
|
ENUM(MESA_SHADER_VERTEX),
|
|
|
|
ENUM(MESA_SHADER_TESS_CTRL),
|
|
|
|
ENUM(MESA_SHADER_TESS_EVAL),
|
|
|
|
ENUM(MESA_SHADER_GEOMETRY),
|
|
|
|
ENUM(MESA_SHADER_FRAGMENT),
|
|
|
|
ENUM(MESA_SHADER_COMPUTE),
|
2020-02-19 18:14:10 +00:00
|
|
|
ENUM(MESA_SHADER_TASK),
|
|
|
|
ENUM(MESA_SHADER_MESH),
|
|
|
|
ENUM(MESA_SHADER_RAYGEN),
|
|
|
|
ENUM(MESA_SHADER_ANY_HIT),
|
|
|
|
ENUM(MESA_SHADER_CLOSEST_HIT),
|
|
|
|
ENUM(MESA_SHADER_MISS),
|
|
|
|
ENUM(MESA_SHADER_INTERSECTION),
|
|
|
|
ENUM(MESA_SHADER_CALLABLE),
|
2018-11-29 14:21:12 +00:00
|
|
|
ENUM(MESA_SHADER_KERNEL),
|
2015-09-11 17:48:05 +01:00
|
|
|
};
|
2018-11-29 14:21:12 +00:00
|
|
|
STATIC_ASSERT(ARRAY_SIZE(names) == MESA_ALL_SHADER_STAGES);
|
2015-09-11 17:48:05 +01:00
|
|
|
return NAME(stage);
|
|
|
|
}
|
|
|
|
|
2016-01-08 20:35:48 +00:00
|
|
|
/**
|
|
|
|
* Translate a gl_shader_stage to a short shader stage name for debug
|
|
|
|
* printouts and error messages.
|
|
|
|
*/
|
2016-01-15 21:31:34 +00:00
|
|
|
const char *
|
|
|
|
_mesa_shader_stage_to_string(unsigned stage)
|
2016-01-08 20:35:48 +00:00
|
|
|
{
|
|
|
|
switch (stage) {
|
|
|
|
case MESA_SHADER_VERTEX: return "vertex";
|
|
|
|
case MESA_SHADER_FRAGMENT: return "fragment";
|
|
|
|
case MESA_SHADER_GEOMETRY: return "geometry";
|
|
|
|
case MESA_SHADER_COMPUTE: return "compute";
|
2018-11-29 14:21:12 +00:00
|
|
|
case MESA_SHADER_KERNEL: return "kernel";
|
2016-01-01 00:28:08 +00:00
|
|
|
case MESA_SHADER_TESS_CTRL: return "tessellation control";
|
|
|
|
case MESA_SHADER_TESS_EVAL: return "tessellation evaluation";
|
2020-02-19 18:14:10 +00:00
|
|
|
case MESA_SHADER_TASK: return "task";
|
|
|
|
case MESA_SHADER_MESH: return "mesh";
|
|
|
|
case MESA_SHADER_RAYGEN: return "raygen";
|
|
|
|
case MESA_SHADER_ANY_HIT: return "any hit";
|
|
|
|
case MESA_SHADER_CLOSEST_HIT: return "closest hit";
|
|
|
|
case MESA_SHADER_MISS: return "miss";
|
|
|
|
case MESA_SHADER_INTERSECTION: return "intersection";
|
|
|
|
case MESA_SHADER_CALLABLE: return "callable";
|
2016-01-08 20:35:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
unreachable("Unknown shader stage.");
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Translate a gl_shader_stage to a shader stage abbreviation (VS, GS, FS)
|
|
|
|
* for debug printouts and error messages.
|
|
|
|
*/
|
2016-01-15 21:31:34 +00:00
|
|
|
const char *
|
|
|
|
_mesa_shader_stage_to_abbrev(unsigned stage)
|
2016-01-08 20:35:48 +00:00
|
|
|
{
|
|
|
|
switch (stage) {
|
|
|
|
case MESA_SHADER_VERTEX: return "VS";
|
|
|
|
case MESA_SHADER_FRAGMENT: return "FS";
|
|
|
|
case MESA_SHADER_GEOMETRY: return "GS";
|
|
|
|
case MESA_SHADER_COMPUTE: return "CS";
|
2018-11-29 14:21:12 +00:00
|
|
|
case MESA_SHADER_KERNEL: return "CL";
|
2016-01-08 20:35:48 +00:00
|
|
|
case MESA_SHADER_TESS_CTRL: return "TCS";
|
|
|
|
case MESA_SHADER_TESS_EVAL: return "TES";
|
2020-02-19 18:14:10 +00:00
|
|
|
case MESA_SHADER_TASK: return "TASK";
|
|
|
|
case MESA_SHADER_MESH: return "MESH";
|
|
|
|
case MESA_SHADER_RAYGEN: return "RGEN";
|
|
|
|
case MESA_SHADER_ANY_HIT: return "RAHIT";
|
|
|
|
case MESA_SHADER_CLOSEST_HIT: return "RCHIT";
|
|
|
|
case MESA_SHADER_MISS: return "RMISS";
|
|
|
|
case MESA_SHADER_INTERSECTION: return "RINT";
|
|
|
|
case MESA_SHADER_CALLABLE: return "RCALL";
|
2016-01-08 20:35:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
unreachable("Unknown shader stage.");
|
|
|
|
}
|
|
|
|
|
2016-01-15 21:31:34 +00:00
|
|
|
const char *
|
|
|
|
gl_vert_attrib_name(gl_vert_attrib attrib)
|
2015-09-11 17:48:05 +01:00
|
|
|
{
|
|
|
|
static const char *names[] = {
|
|
|
|
ENUM(VERT_ATTRIB_POS),
|
|
|
|
ENUM(VERT_ATTRIB_NORMAL),
|
|
|
|
ENUM(VERT_ATTRIB_COLOR0),
|
|
|
|
ENUM(VERT_ATTRIB_COLOR1),
|
|
|
|
ENUM(VERT_ATTRIB_FOG),
|
|
|
|
ENUM(VERT_ATTRIB_COLOR_INDEX),
|
|
|
|
ENUM(VERT_ATTRIB_TEX0),
|
|
|
|
ENUM(VERT_ATTRIB_TEX1),
|
|
|
|
ENUM(VERT_ATTRIB_TEX2),
|
|
|
|
ENUM(VERT_ATTRIB_TEX3),
|
|
|
|
ENUM(VERT_ATTRIB_TEX4),
|
|
|
|
ENUM(VERT_ATTRIB_TEX5),
|
|
|
|
ENUM(VERT_ATTRIB_TEX6),
|
|
|
|
ENUM(VERT_ATTRIB_TEX7),
|
|
|
|
ENUM(VERT_ATTRIB_POINT_SIZE),
|
|
|
|
ENUM(VERT_ATTRIB_GENERIC0),
|
|
|
|
ENUM(VERT_ATTRIB_GENERIC1),
|
|
|
|
ENUM(VERT_ATTRIB_GENERIC2),
|
|
|
|
ENUM(VERT_ATTRIB_GENERIC3),
|
|
|
|
ENUM(VERT_ATTRIB_GENERIC4),
|
|
|
|
ENUM(VERT_ATTRIB_GENERIC5),
|
|
|
|
ENUM(VERT_ATTRIB_GENERIC6),
|
|
|
|
ENUM(VERT_ATTRIB_GENERIC7),
|
|
|
|
ENUM(VERT_ATTRIB_GENERIC8),
|
|
|
|
ENUM(VERT_ATTRIB_GENERIC9),
|
|
|
|
ENUM(VERT_ATTRIB_GENERIC10),
|
|
|
|
ENUM(VERT_ATTRIB_GENERIC11),
|
|
|
|
ENUM(VERT_ATTRIB_GENERIC12),
|
|
|
|
ENUM(VERT_ATTRIB_GENERIC13),
|
|
|
|
ENUM(VERT_ATTRIB_GENERIC14),
|
|
|
|
ENUM(VERT_ATTRIB_GENERIC15),
|
2021-05-27 02:14:56 +01:00
|
|
|
ENUM(VERT_ATTRIB_EDGEFLAG),
|
2015-09-11 17:48:05 +01:00
|
|
|
};
|
2015-10-09 21:27:45 +01:00
|
|
|
STATIC_ASSERT(ARRAY_SIZE(names) == VERT_ATTRIB_MAX);
|
2015-09-11 17:48:05 +01:00
|
|
|
return NAME(attrib);
|
|
|
|
}
|
|
|
|
|
2016-01-15 21:31:34 +00:00
|
|
|
const char *
|
2021-02-11 20:35:44 +00:00
|
|
|
gl_varying_slot_name_for_stage(gl_varying_slot slot, gl_shader_stage stage)
|
2015-09-11 17:48:05 +01:00
|
|
|
{
|
2021-02-11 20:35:44 +00:00
|
|
|
if (stage != MESA_SHADER_FRAGMENT && slot == VARYING_SLOT_PRIMITIVE_SHADING_RATE)
|
|
|
|
return "VARYING_SLOT_PRIMITIVE_SHADING_RATE";
|
|
|
|
|
2021-04-29 21:45:56 +01:00
|
|
|
switch (stage) {
|
|
|
|
case MESA_SHADER_MESH:
|
|
|
|
switch (slot) {
|
|
|
|
case VARYING_SLOT_PRIMITIVE_COUNT: return "VARYING_SLOT_PRIMITIVE_COUNT";
|
|
|
|
case VARYING_SLOT_PRIMITIVE_INDICES: return "VARYING_SLOT_PRIMITIVE_INDICES";
|
2022-03-30 13:37:12 +01:00
|
|
|
case VARYING_SLOT_CULL_PRIMITIVE: return "VARYING_SLOT_CULL_PRIMITIVE";
|
2021-04-29 21:45:56 +01:00
|
|
|
default:
|
|
|
|
/* Not an overlapping value. */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MESA_SHADER_TASK:
|
|
|
|
switch (slot) {
|
|
|
|
case VARYING_SLOT_TASK_COUNT: return "VARYING_SLOT_TASK_COUNT";
|
|
|
|
default:
|
|
|
|
/* Not an overlapping value. */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2015-09-11 17:48:05 +01:00
|
|
|
static const char *names[] = {
|
|
|
|
ENUM(VARYING_SLOT_POS),
|
|
|
|
ENUM(VARYING_SLOT_COL0),
|
|
|
|
ENUM(VARYING_SLOT_COL1),
|
|
|
|
ENUM(VARYING_SLOT_FOGC),
|
|
|
|
ENUM(VARYING_SLOT_TEX0),
|
|
|
|
ENUM(VARYING_SLOT_TEX1),
|
|
|
|
ENUM(VARYING_SLOT_TEX2),
|
|
|
|
ENUM(VARYING_SLOT_TEX3),
|
|
|
|
ENUM(VARYING_SLOT_TEX4),
|
|
|
|
ENUM(VARYING_SLOT_TEX5),
|
|
|
|
ENUM(VARYING_SLOT_TEX6),
|
|
|
|
ENUM(VARYING_SLOT_TEX7),
|
|
|
|
ENUM(VARYING_SLOT_PSIZ),
|
|
|
|
ENUM(VARYING_SLOT_BFC0),
|
|
|
|
ENUM(VARYING_SLOT_BFC1),
|
|
|
|
ENUM(VARYING_SLOT_EDGE),
|
|
|
|
ENUM(VARYING_SLOT_CLIP_VERTEX),
|
|
|
|
ENUM(VARYING_SLOT_CLIP_DIST0),
|
|
|
|
ENUM(VARYING_SLOT_CLIP_DIST1),
|
2016-08-29 01:17:16 +01:00
|
|
|
ENUM(VARYING_SLOT_CULL_DIST0),
|
|
|
|
ENUM(VARYING_SLOT_CULL_DIST1),
|
2015-09-11 17:48:05 +01:00
|
|
|
ENUM(VARYING_SLOT_PRIMITIVE_ID),
|
|
|
|
ENUM(VARYING_SLOT_LAYER),
|
|
|
|
ENUM(VARYING_SLOT_VIEWPORT),
|
|
|
|
ENUM(VARYING_SLOT_FACE),
|
|
|
|
ENUM(VARYING_SLOT_PNTC),
|
|
|
|
ENUM(VARYING_SLOT_TESS_LEVEL_OUTER),
|
|
|
|
ENUM(VARYING_SLOT_TESS_LEVEL_INNER),
|
2016-05-30 16:50:07 +01:00
|
|
|
ENUM(VARYING_SLOT_BOUNDING_BOX0),
|
|
|
|
ENUM(VARYING_SLOT_BOUNDING_BOX1),
|
2017-03-21 22:22:10 +00:00
|
|
|
ENUM(VARYING_SLOT_VIEW_INDEX),
|
2020-04-10 18:47:05 +01:00
|
|
|
ENUM(VARYING_SLOT_VIEWPORT_MASK),
|
2015-09-11 17:48:05 +01:00
|
|
|
ENUM(VARYING_SLOT_VAR0),
|
|
|
|
ENUM(VARYING_SLOT_VAR1),
|
|
|
|
ENUM(VARYING_SLOT_VAR2),
|
|
|
|
ENUM(VARYING_SLOT_VAR3),
|
|
|
|
ENUM(VARYING_SLOT_VAR4),
|
|
|
|
ENUM(VARYING_SLOT_VAR5),
|
|
|
|
ENUM(VARYING_SLOT_VAR6),
|
|
|
|
ENUM(VARYING_SLOT_VAR7),
|
|
|
|
ENUM(VARYING_SLOT_VAR8),
|
|
|
|
ENUM(VARYING_SLOT_VAR9),
|
|
|
|
ENUM(VARYING_SLOT_VAR10),
|
|
|
|
ENUM(VARYING_SLOT_VAR11),
|
|
|
|
ENUM(VARYING_SLOT_VAR12),
|
|
|
|
ENUM(VARYING_SLOT_VAR13),
|
|
|
|
ENUM(VARYING_SLOT_VAR14),
|
|
|
|
ENUM(VARYING_SLOT_VAR15),
|
|
|
|
ENUM(VARYING_SLOT_VAR16),
|
|
|
|
ENUM(VARYING_SLOT_VAR17),
|
|
|
|
ENUM(VARYING_SLOT_VAR18),
|
|
|
|
ENUM(VARYING_SLOT_VAR19),
|
|
|
|
ENUM(VARYING_SLOT_VAR20),
|
|
|
|
ENUM(VARYING_SLOT_VAR21),
|
|
|
|
ENUM(VARYING_SLOT_VAR22),
|
|
|
|
ENUM(VARYING_SLOT_VAR23),
|
|
|
|
ENUM(VARYING_SLOT_VAR24),
|
|
|
|
ENUM(VARYING_SLOT_VAR25),
|
|
|
|
ENUM(VARYING_SLOT_VAR26),
|
|
|
|
ENUM(VARYING_SLOT_VAR27),
|
|
|
|
ENUM(VARYING_SLOT_VAR28),
|
|
|
|
ENUM(VARYING_SLOT_VAR29),
|
|
|
|
ENUM(VARYING_SLOT_VAR30),
|
|
|
|
ENUM(VARYING_SLOT_VAR31),
|
|
|
|
};
|
2015-10-09 21:27:45 +01:00
|
|
|
STATIC_ASSERT(ARRAY_SIZE(names) == VARYING_SLOT_MAX);
|
2015-09-11 17:48:05 +01:00
|
|
|
return NAME(slot);
|
|
|
|
}
|
|
|
|
|
2016-01-15 21:31:34 +00:00
|
|
|
const char *
|
|
|
|
gl_system_value_name(gl_system_value sysval)
|
2015-09-11 17:48:05 +01:00
|
|
|
{
|
|
|
|
static const char *names[] = {
|
2017-03-30 11:10:00 +01:00
|
|
|
ENUM(SYSTEM_VALUE_SUBGROUP_SIZE),
|
|
|
|
ENUM(SYSTEM_VALUE_SUBGROUP_INVOCATION),
|
|
|
|
ENUM(SYSTEM_VALUE_SUBGROUP_EQ_MASK),
|
|
|
|
ENUM(SYSTEM_VALUE_SUBGROUP_GE_MASK),
|
|
|
|
ENUM(SYSTEM_VALUE_SUBGROUP_GT_MASK),
|
|
|
|
ENUM(SYSTEM_VALUE_SUBGROUP_LE_MASK),
|
|
|
|
ENUM(SYSTEM_VALUE_SUBGROUP_LT_MASK),
|
2017-09-30 22:50:40 +01:00
|
|
|
ENUM(SYSTEM_VALUE_NUM_SUBGROUPS),
|
|
|
|
ENUM(SYSTEM_VALUE_SUBGROUP_ID),
|
2015-09-11 17:48:05 +01:00
|
|
|
ENUM(SYSTEM_VALUE_VERTEX_ID),
|
|
|
|
ENUM(SYSTEM_VALUE_INSTANCE_ID),
|
2016-03-25 17:50:11 +00:00
|
|
|
ENUM(SYSTEM_VALUE_INSTANCE_INDEX),
|
2015-09-11 17:48:05 +01:00
|
|
|
ENUM(SYSTEM_VALUE_VERTEX_ID_ZERO_BASE),
|
2018-07-11 00:13:46 +01:00
|
|
|
ENUM(SYSTEM_VALUE_BASE_VERTEX),
|
2018-01-25 18:15:38 +00:00
|
|
|
ENUM(SYSTEM_VALUE_FIRST_VERTEX),
|
2018-04-28 13:09:18 +01:00
|
|
|
ENUM(SYSTEM_VALUE_IS_INDEXED_DRAW),
|
2017-01-30 17:58:56 +00:00
|
|
|
ENUM(SYSTEM_VALUE_BASE_INSTANCE),
|
|
|
|
ENUM(SYSTEM_VALUE_DRAW_ID),
|
2015-09-11 17:48:05 +01:00
|
|
|
ENUM(SYSTEM_VALUE_INVOCATION_ID),
|
2018-07-11 00:13:46 +01:00
|
|
|
ENUM(SYSTEM_VALUE_FRAG_COORD),
|
2019-06-04 12:23:44 +01:00
|
|
|
ENUM(SYSTEM_VALUE_POINT_COORD),
|
2020-07-03 11:57:36 +01:00
|
|
|
ENUM(SYSTEM_VALUE_LINE_COORD),
|
2015-09-11 17:48:05 +01:00
|
|
|
ENUM(SYSTEM_VALUE_FRONT_FACE),
|
|
|
|
ENUM(SYSTEM_VALUE_SAMPLE_ID),
|
|
|
|
ENUM(SYSTEM_VALUE_SAMPLE_POS),
|
|
|
|
ENUM(SYSTEM_VALUE_SAMPLE_MASK_IN),
|
2018-07-11 00:13:46 +01:00
|
|
|
ENUM(SYSTEM_VALUE_HELPER_INVOCATION),
|
2019-05-27 16:48:42 +01:00
|
|
|
ENUM(SYSTEM_VALUE_COLOR0),
|
|
|
|
ENUM(SYSTEM_VALUE_COLOR1),
|
2015-09-11 17:48:05 +01:00
|
|
|
ENUM(SYSTEM_VALUE_TESS_COORD),
|
|
|
|
ENUM(SYSTEM_VALUE_VERTICES_IN),
|
|
|
|
ENUM(SYSTEM_VALUE_PRIMITIVE_ID),
|
|
|
|
ENUM(SYSTEM_VALUE_TESS_LEVEL_OUTER),
|
|
|
|
ENUM(SYSTEM_VALUE_TESS_LEVEL_INNER),
|
2020-05-29 19:09:37 +01:00
|
|
|
ENUM(SYSTEM_VALUE_TESS_LEVEL_OUTER_DEFAULT),
|
|
|
|
ENUM(SYSTEM_VALUE_TESS_LEVEL_INNER_DEFAULT),
|
2015-09-11 17:48:05 +01:00
|
|
|
ENUM(SYSTEM_VALUE_LOCAL_INVOCATION_ID),
|
2016-03-25 17:51:23 +00:00
|
|
|
ENUM(SYSTEM_VALUE_LOCAL_INVOCATION_INDEX),
|
|
|
|
ENUM(SYSTEM_VALUE_GLOBAL_INVOCATION_ID),
|
2020-07-28 00:56:21 +01:00
|
|
|
ENUM(SYSTEM_VALUE_BASE_GLOBAL_INVOCATION_ID),
|
2020-05-29 19:09:37 +01:00
|
|
|
ENUM(SYSTEM_VALUE_GLOBAL_INVOCATION_INDEX),
|
2021-06-04 20:04:15 +01:00
|
|
|
ENUM(SYSTEM_VALUE_WORKGROUP_ID),
|
|
|
|
ENUM(SYSTEM_VALUE_NUM_WORKGROUPS),
|
2021-05-27 22:39:03 +01:00
|
|
|
ENUM(SYSTEM_VALUE_WORKGROUP_SIZE),
|
2018-02-22 22:35:50 +00:00
|
|
|
ENUM(SYSTEM_VALUE_GLOBAL_GROUP_SIZE),
|
2020-05-29 19:09:37 +01:00
|
|
|
ENUM(SYSTEM_VALUE_USER_DATA_AMD),
|
2018-03-08 19:18:59 +00:00
|
|
|
ENUM(SYSTEM_VALUE_WORK_DIM),
|
2017-09-21 23:51:55 +01:00
|
|
|
ENUM(SYSTEM_VALUE_DEVICE_INDEX),
|
2017-03-21 22:22:10 +00:00
|
|
|
ENUM(SYSTEM_VALUE_VIEW_INDEX),
|
2015-09-11 22:01:23 +01:00
|
|
|
ENUM(SYSTEM_VALUE_VERTEX_CNT),
|
2020-01-27 17:45:26 +00:00
|
|
|
ENUM(SYSTEM_VALUE_BARYCENTRIC_PERSP_PIXEL),
|
|
|
|
ENUM(SYSTEM_VALUE_BARYCENTRIC_PERSP_SAMPLE),
|
|
|
|
ENUM(SYSTEM_VALUE_BARYCENTRIC_PERSP_CENTROID),
|
2022-07-05 17:51:58 +01:00
|
|
|
ENUM(SYSTEM_VALUE_BARYCENTRIC_PERSP_CENTER_RHW),
|
2020-01-24 09:52:25 +00:00
|
|
|
ENUM(SYSTEM_VALUE_BARYCENTRIC_LINEAR_PIXEL),
|
|
|
|
ENUM(SYSTEM_VALUE_BARYCENTRIC_LINEAR_CENTROID),
|
|
|
|
ENUM(SYSTEM_VALUE_BARYCENTRIC_LINEAR_SAMPLE),
|
|
|
|
ENUM(SYSTEM_VALUE_BARYCENTRIC_PULL_MODEL),
|
2020-05-13 19:56:03 +01:00
|
|
|
ENUM(SYSTEM_VALUE_RAY_LAUNCH_ID),
|
|
|
|
ENUM(SYSTEM_VALUE_RAY_LAUNCH_SIZE),
|
2022-04-01 14:57:51 +01:00
|
|
|
ENUM(SYSTEM_VALUE_RAY_LAUNCH_SIZE_ADDR_AMD),
|
2020-05-13 19:56:03 +01:00
|
|
|
ENUM(SYSTEM_VALUE_RAY_WORLD_ORIGIN),
|
|
|
|
ENUM(SYSTEM_VALUE_RAY_WORLD_DIRECTION),
|
|
|
|
ENUM(SYSTEM_VALUE_RAY_OBJECT_ORIGIN),
|
|
|
|
ENUM(SYSTEM_VALUE_RAY_OBJECT_DIRECTION),
|
|
|
|
ENUM(SYSTEM_VALUE_RAY_T_MIN),
|
|
|
|
ENUM(SYSTEM_VALUE_RAY_T_MAX),
|
|
|
|
ENUM(SYSTEM_VALUE_RAY_OBJECT_TO_WORLD),
|
|
|
|
ENUM(SYSTEM_VALUE_RAY_WORLD_TO_OBJECT),
|
|
|
|
ENUM(SYSTEM_VALUE_RAY_HIT_KIND),
|
|
|
|
ENUM(SYSTEM_VALUE_RAY_FLAGS),
|
|
|
|
ENUM(SYSTEM_VALUE_RAY_GEOMETRY_INDEX),
|
2022-05-10 15:10:31 +01:00
|
|
|
ENUM(SYSTEM_VALUE_CULL_MASK),
|
2021-07-22 12:47:42 +01:00
|
|
|
ENUM(SYSTEM_VALUE_MESH_VIEW_COUNT),
|
|
|
|
ENUM(SYSTEM_VALUE_MESH_VIEW_INDICES),
|
2019-10-11 01:17:10 +01:00
|
|
|
ENUM(SYSTEM_VALUE_GS_HEADER_IR3),
|
2019-10-23 00:33:18 +01:00
|
|
|
ENUM(SYSTEM_VALUE_TCS_HEADER_IR3),
|
tu, freedreno/a6xx, ir3: Rewrite tess PrimID handling
The previous handling conflated RelPatchID and PrimID, which would
result in incorrect gl_PrimitiveID when doing draw splitting and didn't
work with PrimID passthrough which fills the VPC slot with the "correct"
PrimID value from the tess factor BO which we left 0. Replace PrimID in
the tess lowering pass with a new RelPatchID sysval, and relace PrimID
with RelPatchID in the VS input code in turnip/freedreno at the same
time so that there is no net change in the tess lowering code. However,
now we have to add new mechanisms for getting the user-level PrimID:
- In the TCS it comes from the VS, just like gl_PrimitiveIDIn in the GS.
This means we have to add another register to our VS->TCS ABI. I
decided to put PrimID in r0.z, after the TCS header and RelPatchID,
because it might not be read in the TCS.
- If any stage after the TCS uses PrimID, the TCS stores it in the first
dword of the tess factor BO, and it is read by the fixed-function
tessellator and accessed in the TES via the newly-uncovered DSPRIMID
field. If we have tess and GS, the TES passes this value through to
the GS in the same way as the VS does. PrimID passthrough for reading
it in the FS when there's tess but no GS also "just works" once we
start storing it in the TCS. In particular this fixes
dEQP-VK.pipeline.misc.primitive_id_from_tess which tests exactly that.
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/12166>
2021-08-02 10:55:15 +01:00
|
|
|
ENUM(SYSTEM_VALUE_REL_PATCH_ID_IR3),
|
2020-10-20 08:41:00 +01:00
|
|
|
ENUM(SYSTEM_VALUE_FRAG_SHADING_RATE),
|
2015-09-11 17:48:05 +01:00
|
|
|
};
|
2015-10-09 21:27:45 +01:00
|
|
|
STATIC_ASSERT(ARRAY_SIZE(names) == SYSTEM_VALUE_MAX);
|
2015-09-11 17:48:05 +01:00
|
|
|
return NAME(sysval);
|
|
|
|
}
|
|
|
|
|
2016-01-15 21:31:34 +00:00
|
|
|
const char *
|
2016-07-07 10:02:38 +01:00
|
|
|
glsl_interp_mode_name(enum glsl_interp_mode qual)
|
2015-09-11 17:48:05 +01:00
|
|
|
{
|
|
|
|
static const char *names[] = {
|
2016-07-07 10:02:38 +01:00
|
|
|
ENUM(INTERP_MODE_NONE),
|
|
|
|
ENUM(INTERP_MODE_SMOOTH),
|
|
|
|
ENUM(INTERP_MODE_FLAT),
|
|
|
|
ENUM(INTERP_MODE_NOPERSPECTIVE),
|
2020-01-24 09:14:42 +00:00
|
|
|
ENUM(INTERP_MODE_EXPLICIT),
|
2020-08-15 07:45:05 +01:00
|
|
|
ENUM(INTERP_MODE_COLOR),
|
2015-09-11 17:48:05 +01:00
|
|
|
};
|
2016-07-07 10:02:38 +01:00
|
|
|
STATIC_ASSERT(ARRAY_SIZE(names) == INTERP_MODE_COUNT);
|
2015-09-11 17:48:05 +01:00
|
|
|
return NAME(qual);
|
|
|
|
}
|
|
|
|
|
2016-01-15 21:31:34 +00:00
|
|
|
const char *
|
|
|
|
gl_frag_result_name(gl_frag_result result)
|
2015-09-11 17:48:05 +01:00
|
|
|
{
|
|
|
|
static const char *names[] = {
|
|
|
|
ENUM(FRAG_RESULT_DEPTH),
|
|
|
|
ENUM(FRAG_RESULT_STENCIL),
|
|
|
|
ENUM(FRAG_RESULT_COLOR),
|
|
|
|
ENUM(FRAG_RESULT_SAMPLE_MASK),
|
|
|
|
ENUM(FRAG_RESULT_DATA0),
|
|
|
|
ENUM(FRAG_RESULT_DATA1),
|
|
|
|
ENUM(FRAG_RESULT_DATA2),
|
|
|
|
ENUM(FRAG_RESULT_DATA3),
|
|
|
|
ENUM(FRAG_RESULT_DATA4),
|
|
|
|
ENUM(FRAG_RESULT_DATA5),
|
|
|
|
ENUM(FRAG_RESULT_DATA6),
|
|
|
|
ENUM(FRAG_RESULT_DATA7),
|
|
|
|
};
|
2015-10-09 21:27:45 +01:00
|
|
|
STATIC_ASSERT(ARRAY_SIZE(names) == FRAG_RESULT_MAX);
|
2015-09-11 17:48:05 +01:00
|
|
|
return NAME(result);
|
|
|
|
}
|
2022-02-14 09:44:28 +00:00
|
|
|
|
|
|
|
unsigned
|
|
|
|
num_mesh_vertices_per_primitive(unsigned prim)
|
|
|
|
{
|
|
|
|
switch (prim) {
|
|
|
|
case SHADER_PRIM_POINTS:
|
|
|
|
return 1;
|
|
|
|
case SHADER_PRIM_LINES:
|
|
|
|
return 2;
|
|
|
|
case SHADER_PRIM_TRIANGLES:
|
|
|
|
return 3;
|
|
|
|
default:
|
|
|
|
unreachable("invalid mesh shader primitive type");
|
|
|
|
}
|
|
|
|
}
|