fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-04-23 09:30:36 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

ilo: embed ilo_state_sbe in ilo_shader

Browse source
This commit is contained in:
Chia-I Wu 2015-06-02 23:09:53 +08:00
parent 5a52627c4f
commit da6e45fcbc
11 changed files with 166 additions and 251 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

167
src/gallium/drivers/ilo/core/ilo_builder_3d_bottom.h
View file

@ -37,6 +37,7 @@
#include "ilo_format.h"
#include "ilo_state_cc.h"
#include "ilo_state_raster.h"
#include "ilo_state_sbe.h"
#include "ilo_state_viewport.h"
#include "ilo_builder.h"
#include "ilo_builder_3d_top.h"
@ -59,126 +60,21 @@ gen6_3DSTATE_CLIP(struct ilo_builder *builder,
dw[3] = rs->clip[2];
}
static inline void
gen8_internal_3dstate_sbe(struct ilo_builder *builder,
uint8_t cmd_len, uint32_t *dw,
const struct ilo_shader_state *fs,
int sprite_coord_mode)
{
const struct ilo_kernel_routing *routing;
int vue_offset, vue_len, out_count;
ILO_DEV_ASSERT(builder->dev, 6, 8);
assert(cmd_len == 4);
dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_SBE) | (cmd_len - 2);
if (!fs) {
dw[1] = 1 << GEN7_SBE_DW1_URB_READ_LEN__SHIFT;
dw[2] = 0;
dw[3] = 0;
return;
}
routing = ilo_shader_get_kernel_routing(fs);
vue_offset = routing->source_skip;
assert(vue_offset % 2 == 0);
vue_offset /= 2;
vue_len = (routing->source_len + 1) / 2;
if (!vue_len)
vue_len = 1;
out_count = ilo_shader_get_kernel_param(fs, ILO_KERNEL_INPUT_COUNT);
assert(out_count <= 32);
dw[1] = out_count << GEN7_SBE_DW1_ATTR_COUNT__SHIFT |
vue_len << GEN7_SBE_DW1_URB_READ_LEN__SHIFT;
if (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) {
dw[1] |= GEN8_SBE_DW1_USE_URB_READ_LEN |
GEN8_SBE_DW1_USE_URB_READ_OFFSET |
vue_offset << GEN8_SBE_DW1_URB_READ_OFFSET__SHIFT;
} else {
dw[1] |= vue_offset << GEN7_SBE_DW1_URB_READ_OFFSET__SHIFT;
}
if (routing->swizzle_enable)
dw[1] |= GEN7_SBE_DW1_ATTR_SWIZZLE_ENABLE;
switch (sprite_coord_mode) {
case PIPE_SPRITE_COORD_UPPER_LEFT:
dw[1] |= GEN7_SBE_DW1_POINT_SPRITE_TEXCOORD_UPPERLEFT;
break;
case PIPE_SPRITE_COORD_LOWER_LEFT:
dw[1] |= GEN7_SBE_DW1_POINT_SPRITE_TEXCOORD_LOWERLEFT;
break;
}
/*
* From the Ivy Bridge PRM, volume 2 part 1, page 268:
*
* "This field (Point Sprite Texture Coordinate Enable) must be
* programmed to 0 when non-point primitives are rendered."
*
* TODO We do not check that yet.
*/
dw[2] = routing->point_sprite_enable;
dw[3] = routing->const_interp_enable;
}
static inline void
gen8_internal_3dstate_sbe_swiz(struct ilo_builder *builder,
uint8_t cmd_len, uint32_t *dw,
const struct ilo_shader_state *fs)
{
const struct ilo_kernel_routing *routing;
ILO_DEV_ASSERT(builder->dev, 6, 8);
assert(cmd_len == 11);
dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_SBE_SWIZ) | (cmd_len - 2);
if (!fs) {
memset(&dw[1], 0, sizeof(*dw) * (cmd_len - 1));
return;
}
routing = ilo_shader_get_kernel_routing(fs);
STATIC_ASSERT(sizeof(routing->swizzles) >= sizeof(*dw) * 8);
memcpy(&dw[1], routing->swizzles, sizeof(*dw) * 8);
/* WrapShortest enables */
dw[9] = 0;
dw[10] = 0;
}
static inline void
gen6_3DSTATE_SF(struct ilo_builder *builder,
const struct ilo_state_raster *rs,
unsigned sprite_coord_mode,
const struct ilo_shader_state *fs)
const struct ilo_state_sbe *sbe)
{
const uint8_t cmd_len = 20;
uint32_t gen8_3dstate_sbe[4], gen8_3dstate_sbe_swiz[11];
uint32_t *dw;
ILO_DEV_ASSERT(builder->dev, 6, 6);
gen8_internal_3dstate_sbe(builder, Elements(gen8_3dstate_sbe),
gen8_3dstate_sbe, fs, sprite_coord_mode);
gen8_internal_3dstate_sbe_swiz(builder, Elements(gen8_3dstate_sbe_swiz),
gen8_3dstate_sbe_swiz, fs);
ilo_builder_batch_pointer(builder, cmd_len, &dw);
dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_SF) | (cmd_len - 2);
dw[1] = gen8_3dstate_sbe[1];
/* see sbe_set_gen8_3DSTATE_SBE() */
dw[1] = sbe->sbe[0];
/* see raster_set_gen7_3DSTATE_SF() */
dw[2] = rs->sf[0];
@ -188,11 +84,14 @@ gen6_3DSTATE_SF(struct ilo_builder *builder,
dw[6] = rs->raster[2];
dw[7] = rs->raster[3];
memcpy(&dw[8], &gen8_3dstate_sbe_swiz[1], sizeof(*dw) * 8);
dw[16] = gen8_3dstate_sbe[2];
dw[17] = gen8_3dstate_sbe[3];
dw[18] = gen8_3dstate_sbe_swiz[9];
dw[19] = gen8_3dstate_sbe_swiz[10];
/* see sbe_set_gen8_3DSTATE_SBE_SWIZ() */
memcpy(&dw[8], sbe->swiz, sizeof(*dw) * 8);
dw[16] = sbe->sbe[1];
dw[17] = sbe->sbe[2];
/* WrapShortest enables */
dw[18] = 0;
dw[19] = 0;
}
static inline void
@ -221,35 +120,30 @@ gen7_3DSTATE_SF(struct ilo_builder *builder,
static inline void
gen7_3DSTATE_SBE(struct ilo_builder *builder,
const struct ilo_shader_state *fs,
int sprite_coord_mode)
const struct ilo_state_sbe *sbe)
{
const uint8_t cmd_len = 14;
uint32_t gen8_3dstate_sbe[4], gen8_3dstate_sbe_swiz[11];
uint32_t *dw;
ILO_DEV_ASSERT(builder->dev, 7, 7.5);
gen8_internal_3dstate_sbe(builder, Elements(gen8_3dstate_sbe),
gen8_3dstate_sbe, fs, sprite_coord_mode);
gen8_internal_3dstate_sbe_swiz(builder, Elements(gen8_3dstate_sbe_swiz),
gen8_3dstate_sbe_swiz, fs);
ilo_builder_batch_pointer(builder, cmd_len, &dw);
dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_SBE) | (cmd_len - 2);
dw[1] = gen8_3dstate_sbe[1];
memcpy(&dw[2], &gen8_3dstate_sbe_swiz[1], sizeof(*dw) * 8);
dw[10] = gen8_3dstate_sbe[2];
dw[11] = gen8_3dstate_sbe[3];
dw[12] = gen8_3dstate_sbe_swiz[9];
dw[13] = gen8_3dstate_sbe_swiz[10];
/* see sbe_set_gen8_3DSTATE_SBE() and sbe_set_gen8_3DSTATE_SBE_SWIZ() */
dw[1] = sbe->sbe[0];
memcpy(&dw[2], sbe->swiz, sizeof(*dw) * 8);
dw[10] = sbe->sbe[1];
dw[11] = sbe->sbe[2];
/* WrapShortest enables */
dw[12] = 0;
dw[13] = 0;
}
static inline void
gen8_3DSTATE_SBE(struct ilo_builder *builder,
const struct ilo_shader_state *fs,
int sprite_coord_mode)
const struct ilo_state_sbe *sbe)
{
const uint8_t cmd_len = 4;
uint32_t *dw;
@ -258,12 +152,16 @@ gen8_3DSTATE_SBE(struct ilo_builder *builder,
ilo_builder_batch_pointer(builder, cmd_len, &dw);
gen8_internal_3dstate_sbe(builder, cmd_len, dw, fs, sprite_coord_mode);
/* see sbe_set_gen8_3DSTATE_SBE() */
dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_SBE) | (cmd_len - 2);
dw[1] = sbe->sbe[0];
dw[2] = sbe->sbe[1];
dw[3] = sbe->sbe[2];
}
static inline void
gen8_3DSTATE_SBE_SWIZ(struct ilo_builder *builder,
const struct ilo_shader_state *fs)
const struct ilo_state_sbe *sbe)
{
const uint8_t cmd_len = 11;
uint32_t *dw;
@ -272,7 +170,12 @@ gen8_3DSTATE_SBE_SWIZ(struct ilo_builder *builder,
ilo_builder_batch_pointer(builder, cmd_len, &dw);
gen8_internal_3dstate_sbe_swiz(builder, cmd_len, dw, fs);
dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_SBE_SWIZ) | (cmd_len - 2);
/* see sbe_set_gen8_3DSTATE_SBE_SWIZ() */
memcpy(&dw[1], sbe->swiz, sizeof(*dw) * 8);
/* WrapShortest enables */
dw[9] = 0;
dw[10] = 0;
}
static inline void

1
src/gallium/drivers/ilo/ilo_blitter.h
View file

@ -67,6 +67,7 @@ struct ilo_blitter {
struct ilo_state_viewport vp;
uint32_t vp_data[20];
struct ilo_state_sbe sbe;
struct ilo_state_cc cc;
uint32_t depth_clear_value;

2
src/gallium/drivers/ilo/ilo_blitter_rectlist.c
View file

@ -73,6 +73,8 @@ ilo_blitter_set_invariants(struct ilo_blitter *blitter)
ilo_state_viewport_init_for_rectlist(&blitter->vp, blitter->ilo->dev,
blitter->vp_data, sizeof(blitter->vp_data));
ilo_state_sbe_init_for_rectlist(&blitter->sbe, blitter->ilo->dev, 0, 0);
ilo_state_urb_init_for_rectlist(&blitter->urb, blitter->ilo->dev,
ilo_state_vf_get_attr_count(&blitter->vf));

9
src/gallium/drivers/ilo/ilo_render_gen6.c
View file

@ -599,10 +599,9 @@ gen6_draw_sf(struct ilo_render *r,
struct ilo_render_draw_session *session)
{
/* 3DSTATE_SF */
if ((session->rs_delta.dirty & ILO_STATE_RASTER_3DSTATE_SF) ||
DIRTY(RASTERIZER) || DIRTY(FS)) {
gen6_3DSTATE_SF(r->builder, &vec->rasterizer->rs,
vec->rasterizer->state.sprite_coord_mode, vec->fs);
if ((session->rs_delta.dirty & ILO_STATE_RASTER_3DSTATE_SF) || DIRTY(FS)) {
const struct ilo_state_sbe *sbe = ilo_shader_get_kernel_sbe(vec->fs);
gen6_3DSTATE_SF(r->builder, &vec->rasterizer->rs, sbe);
}
}
@ -799,7 +798,7 @@ gen6_rectlist_vs_to_sf(struct ilo_render *r,
gen6_disable_3DSTATE_GS(r->builder);
gen6_3DSTATE_CLIP(r->builder, &blitter->fb.rs);
gen6_3DSTATE_SF(r->builder, &blitter->fb.rs, 0, NULL);
gen6_3DSTATE_SF(r->builder, &blitter->fb.rs, &blitter->sbe);
}
static void

8
src/gallium/drivers/ilo/ilo_render_gen7.c
View file

@ -457,9 +457,9 @@ gen7_draw_sf(struct ilo_render *r,
struct ilo_render_draw_session *session)
{
/* 3DSTATE_SBE */
if (DIRTY(RASTERIZER) || DIRTY(FS)) {
gen7_3DSTATE_SBE(r->builder, vec->fs, (vec->rasterizer) ?
vec->rasterizer->state.sprite_coord_mode : 0);
if (DIRTY(FS)) {
const struct ilo_state_sbe *sbe = ilo_shader_get_kernel_sbe(vec->fs);
gen7_3DSTATE_SBE(r->builder, sbe);
}
/* 3DSTATE_SF */
@ -684,7 +684,7 @@ gen7_rectlist_vs_to_sf(struct ilo_render *r,
gen7_wa_pre_3dstate_sf_depth_bias(r);
gen7_3DSTATE_SF(r->builder, &blitter->fb.rs);
gen7_3DSTATE_SBE(r->builder, NULL, 0);
gen7_3DSTATE_SBE(r->builder, &blitter->sbe);
}
static void

14
src/gallium/drivers/ilo/ilo_render_gen8.c
View file

@ -68,15 +68,13 @@ gen8_draw_sf(struct ilo_render *r,
if (session->rs_delta.dirty & ILO_STATE_RASTER_3DSTATE_RASTER)
gen8_3DSTATE_RASTER(r->builder, &vec->rasterizer->rs);
/* 3DSTATE_SBE */
if (DIRTY(RASTERIZER) || DIRTY(FS)) {
gen8_3DSTATE_SBE(r->builder, vec->fs, (vec->rasterizer) ?
vec->rasterizer->state.sprite_coord_mode : 0);
}
/* 3DSTATE_SBE and 3DSTATE_SBE_SWIZ */
if (DIRTY(FS)) {
const struct ilo_state_sbe *sbe = ilo_shader_get_kernel_sbe(vec->fs);
/* 3DSTATE_SBE_SWIZ */
if (DIRTY(FS))
gen8_3DSTATE_SBE_SWIZ(r->builder, vec->fs);
gen8_3DSTATE_SBE(r->builder, sbe);
gen8_3DSTATE_SBE_SWIZ(r->builder, sbe);
}
/* 3DSTATE_SF */
if (session->rs_delta.dirty & ILO_STATE_RASTER_3DSTATE_SF)

175
src/gallium/drivers/ilo/ilo_shader.c
View file

@ -897,82 +897,103 @@ route_attr(const int *semantics, const int *indices, int len,
* \return true if a different routing is selected
*/
bool
ilo_shader_select_kernel_routing(struct ilo_shader_state *shader,
const struct ilo_shader_state *source,
const struct ilo_rasterizer_state *rasterizer)
ilo_shader_select_kernel_sbe(struct ilo_shader_state *shader,
const struct ilo_shader_state *source,
const struct ilo_rasterizer_state *rasterizer)
{
const uint32_t sprite_coord_enable = rasterizer->state.sprite_coord_enable;
const bool is_point = true;
const bool light_twoside = rasterizer->state.light_twoside;
const uint32_t sprite_coord_enable = rasterizer->state.sprite_coord_enable;
const int sprite_coord_mode = rasterizer->state.sprite_coord_mode;
struct ilo_shader *kernel = shader->shader;
struct ilo_kernel_routing *routing = &kernel->routing;
struct ilo_state_sbe_swizzle_info swizzles[ILO_STATE_SBE_MAX_SWIZZLE_COUNT];
struct ilo_state_sbe_info info;
const int *src_semantics, *src_indices;
int src_len, max_src_slot;
int src_skip, src_len, src_slot;
int dst_len, dst_slot;
/* we are constructing 3DSTATE_SBE here */
ILO_DEV_ASSERT(shader->info.dev, 6, 8);
assert(kernel);
if (source) {
assert(source->shader);
src_semantics = source->shader->out.semantic_names;
src_indices = source->shader->out.semantic_indices;
src_len = source->shader->out.count;
}
else {
assert(src_len >= 2 &&
src_semantics[0] == TGSI_SEMANTIC_PSIZE &&
src_semantics[1] == TGSI_SEMANTIC_POSITION);
/*
* skip PSIZE and POSITION (how about the optional CLIPDISTs?), unless
* they are all the source shader has and FS needs to read some
* attributes.
*/
if (src_len > 2 || !kernel->in.count) {
src_semantics += 2;
src_indices += 2;
src_len -= 2;
src_skip = 2;
}
} else {
src_semantics = kernel->in.semantic_names;
src_indices = kernel->in.semantic_indices;
src_len = kernel->in.count;
src_skip = 0;
}
/* no change */
if (kernel->routing_initialized &&
routing->source_skip + routing->source_len <= src_len &&
kernel->routing_sprite_coord_enable == sprite_coord_enable &&
!memcmp(kernel->routing_src_semantics,
&src_semantics[routing->source_skip],
sizeof(kernel->routing_src_semantics[0]) * routing->source_len) &&
!memcmp(kernel->routing_src_indices,
&src_indices[routing->source_skip],
sizeof(kernel->routing_src_indices[0]) * routing->source_len))
if (routing->initialized &&
routing->is_point == is_point &&
routing->light_twoside == light_twoside &&
routing->sprite_coord_enable == sprite_coord_enable &&
routing->sprite_coord_mode == sprite_coord_mode &&
routing->src_len <= src_len &&
!memcmp(routing->src_semantics, src_semantics,
sizeof(src_semantics[0]) * routing->src_len) &&
!memcmp(routing->src_indices, src_indices,
sizeof(src_indices[0]) * routing->src_len))
return false;
if (source) {
/* skip PSIZE and POSITION (how about the optional CLIPDISTs?) */
assert(src_semantics[0] == TGSI_SEMANTIC_PSIZE);
assert(src_semantics[1] == TGSI_SEMANTIC_POSITION);
routing->source_skip = 2;
routing->is_point = is_point;
routing->light_twoside = light_twoside;
routing->sprite_coord_enable = sprite_coord_enable;
routing->sprite_coord_mode = sprite_coord_mode;
routing->source_len = src_len - routing->source_skip;
src_semantics += routing->source_skip;
src_indices += routing->source_skip;
}
else {
routing->source_skip = 0;
routing->source_len = src_len;
}
assert(kernel->in.count <= Elements(swizzles));
dst_len = MIN2(kernel->in.count, Elements(swizzles));
routing->const_interp_enable = kernel->in.const_interp_enable;
routing->point_sprite_enable = 0;
routing->swizzle_enable = false;
memset(&info, 0, sizeof(info));
memset(&swizzles, 0, sizeof(swizzles));
assert(kernel->in.count <= Elements(routing->swizzles));
dst_len = MIN2(kernel->in.count, Elements(routing->swizzles));
max_src_slot = -1;
info.attr_count = dst_len;
info.cv_vue_attr_count = src_skip + src_len;
info.vue_read_base = src_skip;
info.vue_read_count = 0;
info.has_min_read_count = true;
info.swizzle_enable = false;
info.swizzle_16_31 = false;
info.swizzle_count = 0;
info.swizzles = swizzles;
info.const_interp_enables = kernel->in.const_interp_enable;
info.point_sprite_enables = 0x0;
info.point_sprite_origin_lower_left =
(sprite_coord_mode == PIPE_SPRITE_COORD_LOWER_LEFT);
info.cv_is_point = is_point;
for (dst_slot = 0; dst_slot < dst_len; dst_slot++) {
const int semantic = kernel->in.semantic_names[dst_slot];
const int index = kernel->in.semantic_indices[dst_slot];
int src_slot;
if (semantic == TGSI_SEMANTIC_GENERIC &&
(sprite_coord_enable & (1 << index)))
routing->point_sprite_enable |= 1 << dst_slot;
info.point_sprite_enables |= 1 << dst_slot;
if (source) {
src_slot = route_attr(src_semantics, src_indices,
routing->source_len, semantic, index);
src_slot = route_attr(src_semantics, src_indices, src_len,
semantic, index);
/*
* The source shader stage does not output this attribute. The value
@ -986,59 +1007,47 @@ ilo_shader_select_kernel_routing(struct ilo_shader_state *shader,
*/
if (src_slot < 0)
src_slot = 0;
}
else {
} else {
src_slot = dst_slot;
}
routing->swizzles[dst_slot] = src_slot;
/* use the following slot for two-sided lighting */
if (semantic == TGSI_SEMANTIC_COLOR && light_twoside &&
src_slot + 1 < routing->source_len &&
src_slot + 1 < src_len &&
src_semantics[src_slot + 1] == TGSI_SEMANTIC_BCOLOR &&
src_indices[src_slot + 1] == index) {
routing->swizzles[dst_slot] |= GEN6_INPUTATTR_FACING <<
GEN8_SBE_SWIZ_SWIZZLE_SELECT__SHIFT;
swizzles[dst_slot].attr_select = GEN6_INPUTATTR_FACING;
swizzles[dst_slot].attr = src_slot;
info.swizzle_enable = true;
src_slot++;
} else {
swizzles[dst_slot].attr_select = GEN6_INPUTATTR_NORMAL;
swizzles[dst_slot].attr = src_slot;
if (src_slot != dst_slot)
info.swizzle_enable = true;
}
if (routing->swizzles[dst_slot] != dst_slot)
routing->swizzle_enable = true;
swizzles[dst_slot].force_zeros = false;
if (max_src_slot < src_slot)
max_src_slot = src_slot;
if (info.vue_read_count < src_slot + 1)
info.vue_read_count = src_slot + 1;
}
memset(&routing->swizzles[dst_slot], 0, sizeof(routing->swizzles) -
sizeof(routing->swizzles[0]) * dst_slot);
if (info.swizzle_enable)
info.swizzle_count = dst_len;
/*
* From the Sandy Bridge PRM, volume 2 part 1, page 248:
*
* "It is UNDEFINED to set this field (Vertex URB Entry Read Length) to
* 0 indicating no Vertex URB data to be read.
*
* This field should be set to the minimum length required to read the
* maximum source attribute. The maximum source attribute is indicated
* by the maximum value of the enabled Attribute # Source Attribute if
* Attribute Swizzle Enable is set, Number of Output Attributes-1 if
* enable is not set.
*
* read_length = ceiling((max_source_attr+1)/2)
*
* [errata] Corruption/Hang possible if length programmed larger than
* recommended"
*/
routing->source_len = max_src_slot + 1;
if (routing->initialized)
ilo_state_sbe_set_info(&routing->sbe, shader->info.dev, &info);
else
ilo_state_sbe_init(&routing->sbe, shader->info.dev, &info);
/* remember the states of the source */
kernel->routing_initialized = true;
kernel->routing_sprite_coord_enable = sprite_coord_enable;
memcpy(kernel->routing_src_semantics, src_semantics,
sizeof(kernel->routing_src_semantics[0]) * routing->source_len);
memcpy(kernel->routing_src_indices, src_indices,
sizeof(kernel->routing_src_indices[0]) * routing->source_len);
routing->src_len = info.vue_read_count;
memcpy(routing->src_semantics, src_semantics,
sizeof(src_semantics[0]) * routing->src_len);
memcpy(routing->src_indices, src_indices,
sizeof(src_indices[0]) * routing->src_len);
routing->initialized = true;
return true;
}
@ -1248,12 +1257,12 @@ ilo_shader_get_kernel_sol(const struct ilo_shader_state *shader)
/**
* Return the routing info of the selected kernel.
*/
const struct ilo_kernel_routing *
ilo_shader_get_kernel_routing(const struct ilo_shader_state *shader)
const struct ilo_state_sbe *
ilo_shader_get_kernel_sbe(const struct ilo_shader_state *shader)
{
const struct ilo_shader *kernel = shader->shader;
assert(kernel);
return &kernel->routing;
return &kernel->routing.sbe;
}

20
src/gallium/drivers/ilo/ilo_shader.h
View file

@ -81,21 +81,13 @@ enum ilo_kernel_param {
ILO_KERNEL_PARAM_COUNT,
};
struct ilo_kernel_routing {
uint32_t const_interp_enable;
uint32_t point_sprite_enable;
unsigned source_skip, source_len;
bool swizzle_enable;
uint16_t swizzles[16];
};
struct intel_bo;
struct ilo_builder;
struct ilo_rasterizer_state;
struct ilo_shader_cache;
struct ilo_shader_state;
struct ilo_shader_cso;
struct ilo_state_sbe;
struct ilo_state_sol;
struct ilo_state_vector;
@ -152,9 +144,9 @@ ilo_shader_select_kernel(struct ilo_shader_state *shader,
uint32_t dirty);
bool
ilo_shader_select_kernel_routing(struct ilo_shader_state *shader,
const struct ilo_shader_state *source,
const struct ilo_rasterizer_state *rasterizer);
ilo_shader_select_kernel_sbe(struct ilo_shader_state *shader,
const struct ilo_shader_state *source,
const struct ilo_rasterizer_state *rasterizer);
uint32_t
ilo_shader_get_kernel_offset(const struct ilo_shader_state *shader);
@ -172,7 +164,7 @@ ilo_shader_get_kernel_so_info(const struct ilo_shader_state *shader);
const struct ilo_state_sol *
ilo_shader_get_kernel_sol(const struct ilo_shader_state *shader);
const struct ilo_kernel_routing *
ilo_shader_get_kernel_routing(const struct ilo_shader_state *shader);
const struct ilo_state_sbe *
ilo_shader_get_kernel_sbe(const struct ilo_shader_state *shader);
#endif /* ILO_SHADER_H */

2
src/gallium/drivers/ilo/ilo_state.c
View file

@ -310,7 +310,7 @@ finalize_shader_states(struct ilo_state_vector *vec)
/* need to setup SBE for FS */
if (type == PIPE_SHADER_FRAGMENT && vec->dirty &
(state | ILO_DIRTY_GS | ILO_DIRTY_VS | ILO_DIRTY_RASTERIZER)) {
if (ilo_shader_select_kernel_routing(shader,
if (ilo_shader_select_kernel_sbe(shader,
(vec->gs) ? vec->gs : vec->vs, vec->rasterizer))
vec->dirty |= state;
}

1
src/gallium/drivers/ilo/ilo_state.h
View file

@ -32,6 +32,7 @@
#include "core/ilo_state_cc.h"
#include "core/ilo_state_raster.h"
#include "core/ilo_state_sampler.h"
#include "core/ilo_state_sbe.h"
#include "core/ilo_state_sol.h"
#include "core/ilo_state_surface.h"
#include "core/ilo_state_urb.h"

18
src/gallium/drivers/ilo/shader/ilo_shader_internal.h
View file

@ -28,6 +28,7 @@
#ifndef ILO_SHADER_INTERNAL_H
#define ILO_SHADER_INTERNAL_H
#include "core/ilo_state_sbe.h"
#include "core/ilo_state_sol.h"
#include "ilo_common.h"
@ -74,6 +75,19 @@ struct ilo_shader_variant {
uint32_t saturate_tex_coords[3];
};
struct ilo_kernel_routing {
bool initialized;
bool is_point;
bool light_twoside;
uint32_t sprite_coord_enable;
int sprite_coord_mode;
int src_len;
int src_semantics[PIPE_MAX_SHADER_OUTPUTS];
int src_indices[PIPE_MAX_SHADER_OUTPUTS];
struct ilo_state_sbe sbe;
};
/**
* A compiled shader.
*/
@ -125,10 +139,6 @@ struct ilo_shader {
void *kernel;
int kernel_size;
bool routing_initialized;
int routing_src_semantics[PIPE_MAX_SHADER_OUTPUTS];
int routing_src_indices[PIPE_MAX_SHADER_OUTPUTS];
uint32_t routing_sprite_coord_enable;
struct ilo_kernel_routing routing;
/* what does the push constant buffer consist of? */