#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"
}
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];
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
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;
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;
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
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;
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));
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);
}
}
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
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 */
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
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)
* \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->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;
- }
+ 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->const_interp_enable = kernel->in.const_interp_enable;
- routing->point_sprite_enable = 0;
- routing->swizzle_enable = false;
+ assert(kernel->in.count <= Elements(swizzles));
+ dst_len = MIN2(kernel->in.count, Elements(swizzles));
- assert(kernel->in.count <= Elements(routing->swizzles));
- dst_len = MIN2(kernel->in.count, Elements(routing->swizzles));
- max_src_slot = -1;
+ memset(&info, 0, sizeof(info));
+ memset(&swizzles, 0, sizeof(swizzles));
+
+ 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
*/
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);
-
- /*
- * 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;
-
- /* 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);
+ if (info.swizzle_enable)
+ info.swizzle_count = dst_len;
+
+ 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);
+
+ 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;
}
/**
* 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;
}
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;
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);
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 */
/* 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;
}
#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"
#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"
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.
*/
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? */
projects / platform / upstream / mesa.git / commitdiff