diff --git a/src/asahi/lib/agx_usc.h b/src/asahi/lib/agx_usc.h index 42ea85720b4..123208a9d82 100644 --- a/src/asahi/lib/agx_usc.h +++ b/src/asahi/lib/agx_usc.h @@ -84,7 +84,7 @@ agx_usc_shared_non_fragment(struct agx_usc_builder *b, const struct agx_shader_info *info, unsigned variable_shared_mem) { - if (info->stage != PIPE_SHADER_FRAGMENT) { + if (info->stage != MESA_SHADER_FRAGMENT) { agx_usc_shared(b, info->local_size, info->imageblock_stride, variable_shared_mem); } diff --git a/src/asahi/vulkan/hk_cmd_buffer.c b/src/asahi/vulkan/hk_cmd_buffer.c index a04ac1490bd..02eb976f336 100644 --- a/src/asahi/vulkan/hk_cmd_buffer.c +++ b/src/asahi/vulkan/hk_cmd_buffer.c @@ -645,7 +645,7 @@ hk_reserve_scratch(struct hk_cmd_buffer *cmd, struct hk_cs *cs, _mesa_shader_stage_to_abbrev(s->b.info.stage)); switch (s->b.info.stage) { - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: cs->scratch.fs.main = true; cs->scratch.fs.preamble = MAX2(cs->scratch.fs.preamble, preamble_size); break; diff --git a/src/asahi/vulkan/hk_device.h b/src/asahi/vulkan/hk_device.h index 8c774727f38..b4ea364fdd6 100644 --- a/src/asahi/vulkan/hk_device.h +++ b/src/asahi/vulkan/hk_device.h @@ -142,7 +142,7 @@ hk_device_scratch_locked(struct hk_device *dev, enum pipe_shader_type stage) simple_mtx_assert_locked(&dev->scratch.lock); switch (stage) { - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: return &dev->scratch.fs; case MESA_SHADER_VERTEX: return &dev->scratch.vs; diff --git a/src/gallium/auxiliary/cso_cache/cso_context.c b/src/gallium/auxiliary/cso_cache/cso_context.c index fdc85a5b5e5..443904e12a7 100644 --- a/src/gallium/auxiliary/cso_cache/cso_context.c +++ b/src/gallium/auxiliary/cso_cache/cso_context.c @@ -338,7 +338,7 @@ cso_create_context(struct pipe_context *pipe, unsigned flags) ctx->sampler_format = true; ctx->max_fs_samplerviews = - pipe->screen->shader_caps[PIPE_SHADER_FRAGMENT].max_texture_samplers; + pipe->screen->shader_caps[MESA_SHADER_FRAGMENT].max_texture_samplers; ctx->max_sampler_seen = -1; return &ctx->base; @@ -420,7 +420,7 @@ cso_unbind_context(struct cso_context *cso) struct pipe_stencil_ref sr = {0}; ctx->base.pipe->set_stencil_ref(ctx->base.pipe, sr); ctx->base.pipe->bind_fs_state(ctx->base.pipe, NULL); - ctx->base.pipe->set_constant_buffer(ctx->base.pipe, PIPE_SHADER_FRAGMENT, 0, false, NULL); + ctx->base.pipe->set_constant_buffer(ctx->base.pipe, MESA_SHADER_FRAGMENT, 0, false, NULL); ctx->base.pipe->bind_vs_state(ctx->base.pipe, NULL); ctx->base.pipe->set_constant_buffer(ctx->base.pipe, MESA_SHADER_VERTEX, 0, false, NULL); if (ctx->has_geometry_shader) { @@ -1526,7 +1526,7 @@ cso_set_samplers(struct cso_context *cso, static void cso_save_fragment_samplers(struct cso_context_priv *ctx) { - struct sampler_info *info = &ctx->samplers[PIPE_SHADER_FRAGMENT]; + struct sampler_info *info = &ctx->samplers[MESA_SHADER_FRAGMENT]; struct sampler_info *saved = &ctx->fragment_samplers_saved; memcpy(saved->cso_samplers, info->cso_samplers, @@ -1538,7 +1538,7 @@ cso_save_fragment_samplers(struct cso_context_priv *ctx) static void cso_restore_fragment_samplers(struct cso_context_priv *ctx) { - struct sampler_info *info = &ctx->samplers[PIPE_SHADER_FRAGMENT]; + struct sampler_info *info = &ctx->samplers[MESA_SHADER_FRAGMENT]; struct sampler_info *saved = &ctx->fragment_samplers_saved; memcpy(info->cso_samplers, saved->cso_samplers, @@ -1552,7 +1552,7 @@ cso_restore_fragment_samplers(struct cso_context_priv *ctx) } } - cso_single_sampler_done(&ctx->base, PIPE_SHADER_FRAGMENT); + cso_single_sampler_done(&ctx->base, MESA_SHADER_FRAGMENT); } @@ -1726,15 +1726,15 @@ cso_restore_state(struct cso_context *ctx, unsigned unbind) if (state_mask & CSO_BIT_VERTEX_SHADER) cso_restore_vertex_shader(cso); if (unbind & CSO_UNBIND_FS_SAMPLERVIEWS) - cso->base.pipe->set_sampler_views(cso->base.pipe, PIPE_SHADER_FRAGMENT, 0, 0, + cso->base.pipe->set_sampler_views(cso->base.pipe, MESA_SHADER_FRAGMENT, 0, 0, cso->max_fs_samplerviews, NULL); if (unbind & CSO_UNBIND_FS_SAMPLERVIEW0) - cso->base.pipe->set_sampler_views(cso->base.pipe, PIPE_SHADER_FRAGMENT, 0, 0, + cso->base.pipe->set_sampler_views(cso->base.pipe, MESA_SHADER_FRAGMENT, 0, 0, 1, NULL); if (state_mask & CSO_BIT_FRAGMENT_SAMPLERS) cso_restore_fragment_samplers(cso); if (unbind & CSO_UNBIND_FS_IMAGE0) - cso->base.pipe->set_shader_images(cso->base.pipe, PIPE_SHADER_FRAGMENT, 0, 0, 1, NULL); + cso->base.pipe->set_shader_images(cso->base.pipe, MESA_SHADER_FRAGMENT, 0, 0, 1, NULL); if (state_mask & CSO_BIT_FRAMEBUFFER) cso_restore_framebuffer(cso); if (state_mask & CSO_BIT_BLEND) @@ -1752,7 +1752,7 @@ cso_restore_state(struct cso_context *ctx, unsigned unbind) if (unbind & CSO_UNBIND_VS_CONSTANTS) cso->base.pipe->set_constant_buffer(cso->base.pipe, MESA_SHADER_VERTEX, 0, false, NULL); if (unbind & CSO_UNBIND_FS_CONSTANTS) - cso->base.pipe->set_constant_buffer(cso->base.pipe, PIPE_SHADER_FRAGMENT, 0, false, NULL); + cso->base.pipe->set_constant_buffer(cso->base.pipe, MESA_SHADER_FRAGMENT, 0, false, NULL); if (state_mask & CSO_BIT_VERTEX_ELEMENTS) cso_restore_vertex_elements(cso); if (state_mask & CSO_BIT_STREAM_OUTPUTS) diff --git a/src/gallium/auxiliary/draw/draw_pipe_pstipple.c b/src/gallium/auxiliary/draw/draw_pipe_pstipple.c index 128e5f6d3e1..62634b0ff70 100644 --- a/src/gallium/auxiliary/draw/draw_pipe_pstipple.c +++ b/src/gallium/auxiliary/draw/draw_pipe_pstipple.c @@ -220,10 +220,10 @@ pstip_first_tri(struct draw_stage *stage, struct prim_header *header) draw->suspend_flushing = true; - pstip->driver_bind_sampler_states(pipe, PIPE_SHADER_FRAGMENT, 0, + pstip->driver_bind_sampler_states(pipe, MESA_SHADER_FRAGMENT, 0, num_samplers, pstip->state.samplers); - pstip->driver_set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0, + pstip->driver_set_sampler_views(pipe, MESA_SHADER_FRAGMENT, 0, num_sampler_views, 0, pstip->state.sampler_views); @@ -249,11 +249,11 @@ pstip_flush(struct draw_stage *stage, unsigned flags) draw->suspend_flushing = true; pstip->driver_bind_fs_state(pipe, pstip->fs ? pstip->fs->driver_fs : NULL); - pstip->driver_bind_sampler_states(pipe, PIPE_SHADER_FRAGMENT, 0, + pstip->driver_bind_sampler_states(pipe, MESA_SHADER_FRAGMENT, 0, pstip->num_samplers, pstip->state.samplers); - pstip->driver_set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0, + pstip->driver_set_sampler_views(pipe, MESA_SHADER_FRAGMENT, 0, pstip->num_sampler_views, 0, pstip->state.sampler_views); @@ -396,7 +396,7 @@ pstip_bind_sampler_states(struct pipe_context *pipe, assert(start == 0); - if (shader == PIPE_SHADER_FRAGMENT) { + if (shader == MESA_SHADER_FRAGMENT) { /* save current */ memcpy(pstip->state.samplers, sampler, num * sizeof(void *)); for (unsigned i = num; i < PIPE_MAX_SAMPLERS; i++) { @@ -419,7 +419,7 @@ pstip_set_sampler_views(struct pipe_context *pipe, { struct pstip_stage *pstip = pstip_stage_from_pipe(pipe); - if (shader == PIPE_SHADER_FRAGMENT) { + if (shader == MESA_SHADER_FRAGMENT) { /* save current */ unsigned i; for (i = 0; i < num; i++) { diff --git a/src/gallium/auxiliary/driver_ddebug/dd_draw.c b/src/gallium/auxiliary/driver_ddebug/dd_draw.c index b424c52ddf8..cc7d3ec4902 100644 --- a/src/gallium/auxiliary/driver_ddebug/dd_draw.c +++ b/src/gallium/auxiliary/driver_ddebug/dd_draw.c @@ -268,7 +268,7 @@ dd_dump_shader(struct dd_draw_state *dstate, enum pipe_shader_type sh, FILE *f) shader_str[MESA_SHADER_TESS_CTRL] = "TESS_CTRL"; shader_str[MESA_SHADER_TESS_EVAL] = "TESS_EVAL"; shader_str[MESA_SHADER_GEOMETRY] = "GEOMETRY"; - shader_str[PIPE_SHADER_FRAGMENT] = "FRAGMENT"; + shader_str[MESA_SHADER_FRAGMENT] = "FRAGMENT"; shader_str[PIPE_SHADER_COMPUTE] = "COMPUTE"; if (sh == MESA_SHADER_TESS_CTRL && @@ -283,7 +283,7 @@ dd_dump_shader(struct dd_draw_state *dstate, enum pipe_shader_type sh, FILE *f) dstate->tess_default_levels[4], dstate->tess_default_levels[5]); - if (sh == PIPE_SHADER_FRAGMENT) + if (sh == MESA_SHADER_FRAGMENT) if (dstate->rs) { unsigned num_viewports = dd_num_active_viewports(dstate); diff --git a/src/gallium/auxiliary/gallivm/lp_bld_tgsi_soa.c b/src/gallium/auxiliary/gallivm/lp_bld_tgsi_soa.c index 6322549166f..b9db4ab785d 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_tgsi_soa.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_tgsi_soa.c @@ -2051,7 +2051,7 @@ lp_build_lod_property( reg->Register.File == TGSI_FILE_IMMEDIATE) { lod_property = LP_SAMPLER_LOD_SCALAR; } - else if (bld_base->info->processor == PIPE_SHADER_FRAGMENT) { + else if (bld_base->info->processor == MESA_SHADER_FRAGMENT) { if (gallivm_perf & GALLIVM_PERF_NO_QUAD_LOD) { lod_property = LP_SAMPLER_LOD_PER_ELEMENT; } @@ -2243,7 +2243,7 @@ emit_tex( struct lp_build_tgsi_soa_context *bld, * could also check all src regs if constant but I doubt such * cases exist in practice. */ - if (bld->bld_base.info->processor == PIPE_SHADER_FRAGMENT) { + if (bld->bld_base.info->processor == MESA_SHADER_FRAGMENT) { if (gallivm_perf & GALLIVM_PERF_NO_QUAD_LOD) { lod_property = LP_SAMPLER_LOD_PER_ELEMENT; } @@ -2412,7 +2412,7 @@ emit_sample(struct lp_build_tgsi_soa_context *bld, * could also check all src regs if constant but I doubt such * cases exist in practice. */ - if (bld->bld_base.info->processor == PIPE_SHADER_FRAGMENT) { + if (bld->bld_base.info->processor == MESA_SHADER_FRAGMENT) { if (gallivm_perf & GALLIVM_PERF_NO_QUAD_LOD) { lod_property = LP_SAMPLER_LOD_PER_ELEMENT; } diff --git a/src/gallium/auxiliary/hud/hud_context.c b/src/gallium/auxiliary/hud/hud_context.c index 3fd16290ef5..972daef738a 100644 --- a/src/gallium/auxiliary/hud/hud_context.c +++ b/src/gallium/auxiliary/hud/hud_context.c @@ -577,9 +577,9 @@ hud_draw_results(struct hud_context *hud, struct pipe_resource *tex) cso_set_vertex_shader_handle(cso, hud->vs_color); cso_set_vertex_elements(cso, &hud->velems); cso_set_render_condition(cso, NULL, false, 0); - pipe->set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0, 1, 0, + pipe->set_sampler_views(pipe, MESA_SHADER_FRAGMENT, 0, 1, 0, &hud->font_sampler_view); - cso_set_samplers(cso, PIPE_SHADER_FRAGMENT, 1, sampler_states); + cso_set_samplers(cso, MESA_SHADER_FRAGMENT, 1, sampler_states); pipe->set_constant_buffer(pipe, MESA_SHADER_VERTEX, 0, false, &hud->constbuf); /* draw accumulated vertices for background quads */ diff --git a/src/gallium/auxiliary/nir/nir_to_tgsi_info.c b/src/gallium/auxiliary/nir/nir_to_tgsi_info.c index 3d5c50a7978..4178e999ecd 100644 --- a/src/gallium/auxiliary/nir/nir_to_tgsi_info.c +++ b/src/gallium/auxiliary/nir/nir_to_tgsi_info.c @@ -561,7 +561,7 @@ void nir_tgsi_scan_shader(const struct nir_shader *nir, info->writes_edgeflag = true; break; case TGSI_SEMANTIC_POSITION: - if (info->processor == PIPE_SHADER_FRAGMENT) { + if (info->processor == MESA_SHADER_FRAGMENT) { if (!variable->data.fb_fetch_output) info->writes_z = true; } else { @@ -632,7 +632,7 @@ void nir_tgsi_scan_shader(const struct nir_shader *nir, info->num_written_clipdistance = nir->info.clip_distance_array_size; info->num_written_culldistance = nir->info.cull_distance_array_size; - if (info->processor == PIPE_SHADER_FRAGMENT) + if (info->processor == MESA_SHADER_FRAGMENT) info->uses_kill = nir->info.fs.uses_discard; nir_function *func = (struct nir_function *) diff --git a/src/gallium/auxiliary/nir/tgsi_to_nir.c b/src/gallium/auxiliary/nir/tgsi_to_nir.c index a69e39e66f7..1984ae7e2ba 100644 --- a/src/gallium/auxiliary/nir/tgsi_to_nir.c +++ b/src/gallium/auxiliary/nir/tgsi_to_nir.c @@ -303,7 +303,7 @@ ttn_emit_declaration(struct ttn_compile *c) var->data.mode = nir_var_shader_in; nir_variable_set_namef(b->shader, var, "in_%d", idx); - if (c->scan->processor == PIPE_SHADER_FRAGMENT) { + if (c->scan->processor == MESA_SHADER_FRAGMENT) { if (decl->Semantic.Name == TGSI_SEMANTIC_FACE) { var->type = glsl_bool_type(); if (c->cap_face_is_sysval) { @@ -367,7 +367,7 @@ ttn_emit_declaration(struct ttn_compile *c) semantic_name == TGSI_SEMANTIC_TESSOUTER || semantic_name == TGSI_SEMANTIC_PATCH; - if (c->scan->processor == PIPE_SHADER_FRAGMENT) { + if (c->scan->processor == MESA_SHADER_FRAGMENT) { switch (semantic_name) { case TGSI_SEMANTIC_COLOR: { /* TODO tgsi loses some information, so we cannot @@ -646,15 +646,15 @@ ttn_src_for_file_and_index(struct ttn_compile *c, unsigned file, unsigned index, } case TGSI_FILE_INPUT: - if (c->scan->processor == PIPE_SHADER_FRAGMENT && + if (c->scan->processor == MESA_SHADER_FRAGMENT && c->scan->input_semantic_name[index] == TGSI_SEMANTIC_FACE) { assert(!c->cap_face_is_sysval && c->input_var_face); return nir_src_for_ssa(ttn_emulate_tgsi_front_face(c)); - } else if (c->scan->processor == PIPE_SHADER_FRAGMENT && + } else if (c->scan->processor == MESA_SHADER_FRAGMENT && c->scan->input_semantic_name[index] == TGSI_SEMANTIC_POSITION) { assert(!c->cap_position_is_sysval && c->input_var_position); return nir_src_for_ssa(nir_load_var(&c->build, c->input_var_position)); - } else if (c->scan->processor == PIPE_SHADER_FRAGMENT && + } else if (c->scan->processor == MESA_SHADER_FRAGMENT && c->scan->input_semantic_name[index] == TGSI_SEMANTIC_PCOORD) { assert(!c->cap_point_is_sysval && c->input_var_point); return nir_src_for_ssa(nir_load_var(&c->build, c->input_var_point)); @@ -668,7 +668,7 @@ ttn_src_for_file_and_index(struct ttn_compile *c, unsigned file, unsigned index, break; case TGSI_FILE_OUTPUT: - if (c->scan->processor == PIPE_SHADER_FRAGMENT) { + if (c->scan->processor == MESA_SHADER_FRAGMENT) { c->outputs[index]->data.fb_fetch_output = 1; nir_deref_instr *deref = nir_build_deref_var(&c->build, c->outputs[index]); diff --git a/src/gallium/auxiliary/postprocess/pp_colors.c b/src/gallium/auxiliary/postprocess/pp_colors.c index 14376a5b278..c63e7c250b3 100644 --- a/src/gallium/auxiliary/postprocess/pp_colors.c +++ b/src/gallium/auxiliary/postprocess/pp_colors.c @@ -46,8 +46,8 @@ pp_nocolor(struct pp_queue_t *ppq, struct pipe_resource *in, pp_filter_set_fb(p); pp_filter_misc_state(p); - cso_set_samplers(p->cso, PIPE_SHADER_FRAGMENT, 1, samplers); - pipe->set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0, 1, 0, &p->view); + cso_set_samplers(p->cso, MESA_SHADER_FRAGMENT, 1, samplers); + pipe->set_sampler_views(pipe, MESA_SHADER_FRAGMENT, 0, 1, 0, &p->view); cso_set_vertex_shader_handle(p->cso, ppq->shaders[n][0]); cso_set_fragment_shader_handle(p->cso, ppq->shaders[n][1]); diff --git a/src/gallium/auxiliary/postprocess/pp_mlaa.c b/src/gallium/auxiliary/postprocess/pp_mlaa.c index 82ce9c4d9e3..0803104e11d 100644 --- a/src/gallium/auxiliary/postprocess/pp_mlaa.c +++ b/src/gallium/auxiliary/postprocess/pp_mlaa.c @@ -105,7 +105,7 @@ pp_jimenezmlaa_run(struct pp_queue_t *ppq, struct pipe_resource *in, struct pipe_context *pipe = ppq->p->pipe; pipe->set_constant_buffer(pipe, MESA_SHADER_VERTEX, 0, false, &cb); - pipe->set_constant_buffer(pipe, PIPE_SHADER_FRAGMENT, 0, false, &cb); + pipe->set_constant_buffer(pipe, MESA_SHADER_FRAGMENT, 0, false, &cb); mstencil.stencil[0].enabled = 1; mstencil.stencil[0].valuemask = mstencil.stencil[0].writemask = ~0; @@ -132,9 +132,9 @@ pp_jimenezmlaa_run(struct pp_queue_t *ppq, struct pipe_resource *in, { const struct pipe_sampler_state *samplers[] = {&p->sampler_point}; - cso_set_samplers(p->cso, PIPE_SHADER_FRAGMENT, 1, samplers); + cso_set_samplers(p->cso, MESA_SHADER_FRAGMENT, 1, samplers); } - pipe->set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0, 1, 0, &p->view); + pipe->set_sampler_views(pipe, MESA_SHADER_FRAGMENT, 0, 1, 0, &p->view); cso_set_vertex_shader_handle(p->cso, ppq->shaders[n][1]); /* offsetvs */ cso_set_fragment_shader_handle(p->cso, ppq->shaders[n][2]); @@ -162,11 +162,11 @@ pp_jimenezmlaa_run(struct pp_queue_t *ppq, struct pipe_resource *in, { const struct pipe_sampler_state *samplers[] = {&p->sampler_point, &p->sampler_point, &p->sampler}; - cso_set_samplers(p->cso, PIPE_SHADER_FRAGMENT, 3, samplers); + cso_set_samplers(p->cso, MESA_SHADER_FRAGMENT, 3, samplers); } arr[0] = p->view; - pipe->set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0, 3, 0, arr); + pipe->set_sampler_views(pipe, MESA_SHADER_FRAGMENT, 0, 3, 0, arr); cso_set_vertex_shader_handle(p->cso, ppq->shaders[n][0]); /* passvs */ cso_set_fragment_shader_handle(p->cso, ppq->shaders[n][3]); @@ -193,11 +193,11 @@ pp_jimenezmlaa_run(struct pp_queue_t *ppq, struct pipe_resource *in, { const struct pipe_sampler_state *samplers[] = {&p->sampler_point, &p->sampler_point}; - cso_set_samplers(p->cso, PIPE_SHADER_FRAGMENT, 2, samplers); + cso_set_samplers(p->cso, MESA_SHADER_FRAGMENT, 2, samplers); } arr[1] = p->view; - pipe->set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0, 2, 0, arr); + pipe->set_sampler_views(pipe, MESA_SHADER_FRAGMENT, 0, 2, 0, arr); cso_set_vertex_shader_handle(p->cso, ppq->shaders[n][1]); /* offsetvs */ cso_set_fragment_shader_handle(p->cso, ppq->shaders[n][4]); diff --git a/src/gallium/auxiliary/tgsi/tgsi_dump.c b/src/gallium/auxiliary/tgsi/tgsi_dump.c index 466945adec7..9f5cedf224a 100644 --- a/src/gallium/auxiliary/tgsi/tgsi_dump.c +++ b/src/gallium/auxiliary/tgsi/tgsi_dump.c @@ -425,7 +425,7 @@ iter_declaration( } if (decl->Declaration.Interpolate) { - if (iter->processor.Processor == PIPE_SHADER_FRAGMENT && + if (iter->processor.Processor == MESA_SHADER_FRAGMENT && decl->Declaration.File == TGSI_FILE_INPUT) { TXT( ", " ); diff --git a/src/gallium/auxiliary/tgsi/tgsi_exec.c b/src/gallium/auxiliary/tgsi/tgsi_exec.c index d1bf0cb04a0..e35f817f6f2 100644 --- a/src/gallium/auxiliary/tgsi/tgsi_exec.c +++ b/src/gallium/auxiliary/tgsi/tgsi_exec.c @@ -1227,7 +1227,7 @@ tgsi_exec_machine_create(enum pipe_shader_type shader_type) goto fail; } - if (shader_type == PIPE_SHADER_FRAGMENT) { + if (shader_type == MESA_SHADER_FRAGMENT) { mach->InputSampleOffsetApply = align_malloc(sizeof(apply_sample_offset_func) * PIPE_MAX_SHADER_INPUTS, 16); if (!mach->InputSampleOffsetApply) goto fail; @@ -2774,7 +2774,7 @@ exec_declaration(struct tgsi_exec_machine *mach, return; } - if (mach->ShaderType == PIPE_SHADER_FRAGMENT) { + if (mach->ShaderType == MESA_SHADER_FRAGMENT) { if (decl->Declaration.File == TGSI_FILE_INPUT) { unsigned first, last, mask; @@ -6076,7 +6076,7 @@ tgsi_exec_machine_run( struct tgsi_exec_machine *mach, int start_pc ) #if 0 /* we scale from floats in [0,1] to Zbuffer ints in sp_quad_depth_test.c */ - if (mach->ShaderType == PIPE_SHADER_FRAGMENT) { + if (mach->ShaderType == MESA_SHADER_FRAGMENT) { /* * Scale back depth component. */ diff --git a/src/gallium/auxiliary/tgsi/tgsi_from_mesa.h b/src/gallium/auxiliary/tgsi/tgsi_from_mesa.h index f2d97f8da4e..668825364db 100644 --- a/src/gallium/auxiliary/tgsi/tgsi_from_mesa.h +++ b/src/gallium/auxiliary/tgsi/tgsi_from_mesa.h @@ -62,7 +62,7 @@ static inline enum pipe_shader_type pipe_shader_type_from_mesa(gl_shader_stage stage) { STATIC_ASSERT((enum pipe_shader_type) MESA_SHADER_VERTEX == MESA_SHADER_VERTEX); - STATIC_ASSERT((enum pipe_shader_type) MESA_SHADER_FRAGMENT == PIPE_SHADER_FRAGMENT); + STATIC_ASSERT((enum pipe_shader_type) MESA_SHADER_FRAGMENT == MESA_SHADER_FRAGMENT); STATIC_ASSERT((enum pipe_shader_type) MESA_SHADER_TESS_CTRL == MESA_SHADER_TESS_CTRL); STATIC_ASSERT((enum pipe_shader_type) MESA_SHADER_TESS_EVAL == MESA_SHADER_TESS_EVAL); STATIC_ASSERT((enum pipe_shader_type) MESA_SHADER_GEOMETRY == MESA_SHADER_GEOMETRY); diff --git a/src/gallium/auxiliary/tgsi/tgsi_lowering.c b/src/gallium/auxiliary/tgsi/tgsi_lowering.c index 42f8880167e..8b4631f7a62 100644 --- a/src/gallium/auxiliary/tgsi/tgsi_lowering.c +++ b/src/gallium/auxiliary/tgsi/tgsi_lowering.c @@ -1448,7 +1448,7 @@ tgsi_transform_lowering(const struct tgsi_lowering_config *config, * color, then figure out the number of additional inputs we need * to create for BCOLOR's.. */ - if ((info->processor == PIPE_SHADER_FRAGMENT) && + if ((info->processor == MESA_SHADER_FRAGMENT) && config->color_two_side) { int i; ctx.face_idx = -1; diff --git a/src/gallium/auxiliary/tgsi/tgsi_scan.c b/src/gallium/auxiliary/tgsi/tgsi_scan.c index cd6159f3f9c..08009c291c9 100644 --- a/src/gallium/auxiliary/tgsi/tgsi_scan.c +++ b/src/gallium/auxiliary/tgsi/tgsi_scan.c @@ -110,7 +110,7 @@ scan_src_operand(struct tgsi_shader_info *info, info->input_usage_mask[ind] |= usage_mask_after_swizzle; } - if (info->processor == PIPE_SHADER_FRAGMENT) { + if (info->processor == MESA_SHADER_FRAGMENT) { unsigned name, input; if (src->Register.Indirect && src->Indirect.ArrayID) @@ -509,7 +509,7 @@ scan_declaration(struct tgsi_shader_info *info, info->writes_edgeflag = true; break; case TGSI_SEMANTIC_POSITION: - if (procType == PIPE_SHADER_FRAGMENT) + if (procType == MESA_SHADER_FRAGMENT) info->writes_z = true; else info->writes_position = true; @@ -610,7 +610,7 @@ tgsi_scan_shader(const struct tgsi_token *tokens, return; } procType = parse.FullHeader.Processor.Processor; - assert(procType == PIPE_SHADER_FRAGMENT || + assert(procType == MESA_SHADER_FRAGMENT || procType == MESA_SHADER_VERTEX || procType == MESA_SHADER_GEOMETRY || procType == MESA_SHADER_TESS_CTRL || diff --git a/src/gallium/auxiliary/tgsi/tgsi_text.c b/src/gallium/auxiliary/tgsi/tgsi_text.c index 91a4116f5c4..c9ce8060c8d 100644 --- a/src/gallium/auxiliary/tgsi/tgsi_text.c +++ b/src/gallium/auxiliary/tgsi/tgsi_text.c @@ -333,7 +333,7 @@ static bool parse_header( struct translate_ctx *ctx ) enum pipe_shader_type processor; if (str_match_nocase_whole( &ctx->cur, "FRAG" )) - processor = PIPE_SHADER_FRAGMENT; + processor = MESA_SHADER_FRAGMENT; else if (str_match_nocase_whole( &ctx->cur, "VERT" )) processor = MESA_SHADER_VERTEX; else if (str_match_nocase_whole( &ctx->cur, "GEOM" )) diff --git a/src/gallium/auxiliary/tgsi/tgsi_ureg.c b/src/gallium/auxiliary/tgsi/tgsi_ureg.c index 97a1ec15398..00f522a7366 100644 --- a/src/gallium/auxiliary/tgsi/tgsi_ureg.c +++ b/src/gallium/auxiliary/tgsi/tgsi_ureg.c @@ -1862,7 +1862,7 @@ static void emit_decls( struct ureg_program *ureg ) emit_decl_range( ureg, TGSI_FILE_INPUT, i, 1 ); } } - } else if (ureg->processor == PIPE_SHADER_FRAGMENT) { + } else if (ureg->processor == MESA_SHADER_FRAGMENT) { if (ureg->supports_any_inout_decl_range) { for (i = 0; i < ureg->nr_inputs; i++) { emit_decl_fs(ureg, @@ -2117,7 +2117,7 @@ const struct tgsi_token *ureg_finalize( struct ureg_program *ureg ) case MESA_SHADER_TESS_EVAL: ureg_property(ureg, TGSI_PROPERTY_NEXT_SHADER, ureg->next_shader_processor == -1 ? - PIPE_SHADER_FRAGMENT : + MESA_SHADER_FRAGMENT : ureg->next_shader_processor); break; default: @@ -2190,7 +2190,7 @@ void *ureg_create_shader( struct ureg_program *ureg, return pipe->create_tes_state(pipe, &state); case MESA_SHADER_GEOMETRY: return pipe->create_gs_state(pipe, &state); - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: return pipe->create_fs_state(pipe, &state); default: return NULL; diff --git a/src/gallium/auxiliary/util/u_blitter.c b/src/gallium/auxiliary/util/u_blitter.c index e145ecf76d4..a29920dfe26 100644 --- a/src/gallium/auxiliary/util/u_blitter.c +++ b/src/gallium/auxiliary/util/u_blitter.c @@ -723,11 +723,11 @@ static void util_blitter_restore_textures_internal(struct blitter_context *blitt void *states[2] = {NULL}; assert(count <= ARRAY_SIZE(states)); if (ctx->base.saved_num_sampler_states) - pipe->bind_sampler_states(pipe, PIPE_SHADER_FRAGMENT, 0, + pipe->bind_sampler_states(pipe, MESA_SHADER_FRAGMENT, 0, ctx->base.saved_num_sampler_states, ctx->base.saved_sampler_states); else if (count) - pipe->bind_sampler_states(pipe, PIPE_SHADER_FRAGMENT, 0, + pipe->bind_sampler_states(pipe, MESA_SHADER_FRAGMENT, 0, count, states); @@ -735,11 +735,11 @@ static void util_blitter_restore_textures_internal(struct blitter_context *blitt /* Fragment sampler views. */ if (ctx->base.saved_num_sampler_views) - pipe->set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0, + pipe->set_sampler_views(pipe, MESA_SHADER_FRAGMENT, 0, ctx->base.saved_num_sampler_views, 0, ctx->base.saved_sampler_views); else if (count) - pipe->set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0, + pipe->set_sampler_views(pipe, MESA_SHADER_FRAGMENT, 0, 0, count, NULL); @@ -759,7 +759,7 @@ void util_blitter_restore_constant_buffer_state(struct blitter_context *blitter) { struct pipe_context *pipe = blitter->pipe; - pipe->set_constant_buffer(pipe, PIPE_SHADER_FRAGMENT, blitter->cb_slot, + pipe->set_constant_buffer(pipe, MESA_SHADER_FRAGMENT, blitter->cb_slot, true, &blitter->saved_fs_constant_buffer); blitter->saved_fs_constant_buffer.buffer = NULL; } @@ -1523,7 +1523,7 @@ static void util_blitter_clear_custom(struct blitter_context *blitter, .user_buffer = color->f, .buffer_size = 4 * sizeof(float), }; - pipe->set_constant_buffer(pipe, PIPE_SHADER_FRAGMENT, blitter->cb_slot, + pipe->set_constant_buffer(pipe, MESA_SHADER_FRAGMENT, blitter->cb_slot, false, &cb); bind_fs_clear_color(ctx, true); } else { @@ -2143,8 +2143,8 @@ void util_blitter_blit_generic(struct blitter_context *blitter, views[1] = pipe->create_sampler_view(pipe, src->texture, &templ); count = 2; - pipe->set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0, 2, 0, views); - pipe->bind_sampler_states(pipe, PIPE_SHADER_FRAGMENT, 0, 2, samplers); + pipe->set_sampler_views(pipe, MESA_SHADER_FRAGMENT, 0, 2, 0, views); + pipe->bind_sampler_states(pipe, MESA_SHADER_FRAGMENT, 0, 2, samplers); pipe_sampler_view_reference(&views[1], NULL); } else if (src_has_stencil && dst_has_stencil) { @@ -2159,15 +2159,15 @@ void util_blitter_blit_generic(struct blitter_context *blitter, view = pipe->create_sampler_view(pipe, src->texture, &templ); count = 1; - pipe->set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0, 1, 0, &view); - pipe->bind_sampler_states(pipe, PIPE_SHADER_FRAGMENT, + pipe->set_sampler_views(pipe, MESA_SHADER_FRAGMENT, 0, 1, 0, &view); + pipe->bind_sampler_states(pipe, MESA_SHADER_FRAGMENT, 0, 1, &sampler_state); pipe_sampler_view_reference(&view, NULL); } else { count = 1; - pipe->set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0, 1, 0, &src); - pipe->bind_sampler_states(pipe, PIPE_SHADER_FRAGMENT, + pipe->set_sampler_views(pipe, MESA_SHADER_FRAGMENT, 0, 1, 0, &src); + pipe->bind_sampler_states(pipe, MESA_SHADER_FRAGMENT, 0, 1, &sampler_state); } @@ -2287,7 +2287,7 @@ void util_blitter_generate_mipmap(struct blitter_context *blitter, } else { sampler_state = ctx->sampler_state_linear; } - pipe->bind_sampler_states(pipe, PIPE_SHADER_FRAGMENT, + pipe->bind_sampler_states(pipe, MESA_SHADER_FRAGMENT, 0, 1, &sampler_state); blitter_set_common_draw_rect_state(ctx, false, false); @@ -2320,7 +2320,7 @@ void util_blitter_generate_mipmap(struct blitter_context *blitter, src_templ.format = format; src_view = pipe->create_sampler_view(pipe, tex, &src_templ); - pipe->set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0, 1, 0, &src_view); + pipe->set_sampler_views(pipe, MESA_SHADER_FRAGMENT, 0, 1, 0, &src_view); do_blits(ctx, &dst_templ, &dstbox, src_view, tex->width0, tex->height0, &srcbox, is_depth, false, false, 0); @@ -2383,7 +2383,7 @@ void util_blitter_clear_render_target(struct blitter_context *blitter, .user_buffer = color->f, .buffer_size = 4 * sizeof(float), }; - pipe->set_constant_buffer(pipe, PIPE_SHADER_FRAGMENT, blitter->cb_slot, + pipe->set_constant_buffer(pipe, MESA_SHADER_FRAGMENT, blitter->cb_slot, false, &cb); num_layers = dstsurf->last_layer - dstsurf->first_layer + 1; @@ -2808,8 +2808,8 @@ util_blitter_stencil_fallback(struct blitter_context *blitter, pipe->set_scissor_states(pipe, 0, 1, scissor); } - pipe->set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0, 1, 0, &src_view); - pipe->bind_sampler_states(pipe, PIPE_SHADER_FRAGMENT, 0, 1, &ctx->sampler_state); + pipe->set_sampler_views(pipe, MESA_SHADER_FRAGMENT, 0, 1, 0, &src_view); + pipe->bind_sampler_states(pipe, MESA_SHADER_FRAGMENT, 0, 1, &ctx->sampler_state); unsigned stencil_bits = util_format_get_component_bits(dst->format, @@ -2833,7 +2833,7 @@ util_blitter_stencil_fallback(struct blitter_context *blitter, .user_buffer = &mask, .buffer_size = sizeof(mask), }; - pipe->set_constant_buffer(pipe, PIPE_SHADER_FRAGMENT, blitter->cb_slot, + pipe->set_constant_buffer(pipe, MESA_SHADER_FRAGMENT, blitter->cb_slot, false, &cb); pipe->bind_depth_stencil_alpha_state(pipe, diff --git a/src/gallium/auxiliary/util/u_screen.c b/src/gallium/auxiliary/util/u_screen.c index 4d2a740365a..19e7bcdbf98 100644 --- a/src/gallium/auxiliary/util/u_screen.c +++ b/src/gallium/auxiliary/util/u_screen.c @@ -163,7 +163,7 @@ u_init_pipe_screen_caps(struct pipe_screen *pscreen, int accel) caps->allow_dynamic_vao_fastpath = true; caps->max_constant_buffer_size = - pscreen->shader_caps[PIPE_SHADER_FRAGMENT].max_const_buffer0_size; + pscreen->shader_caps[MESA_SHADER_FRAGMENT].max_const_buffer0_size; /* accel=0: on CPU, always disabled * accel>0: on GPU, enable by default, user can disable it manually diff --git a/src/gallium/auxiliary/util/u_simple_shaders.c b/src/gallium/auxiliary/util/u_simple_shaders.c index 0e7114e93e5..853d7348a61 100644 --- a/src/gallium/auxiliary/util/u_simple_shaders.c +++ b/src/gallium/auxiliary/util/u_simple_shaders.c @@ -261,7 +261,7 @@ util_make_fragment_tex_shader(struct pipe_context *pipe, assert((stype == TGSI_RETURN_TYPE_FLOAT) == (dtype == TGSI_RETURN_TYPE_FLOAT)); - ureg = ureg_create( PIPE_SHADER_FRAGMENT ); + ureg = ureg_create( MESA_SHADER_FRAGMENT ); if (!ureg) return NULL; @@ -320,7 +320,7 @@ util_make_fs_blit_zs(struct pipe_context *pipe, unsigned zs_mask, struct ureg_src depth_sampler, stencil_sampler, coord; struct ureg_dst depth, stencil, tmp; - ureg = ureg_create(PIPE_SHADER_FRAGMENT); + ureg = ureg_create(MESA_SHADER_FRAGMENT); if (!ureg) return NULL; @@ -410,7 +410,7 @@ util_make_fragment_passthrough_shader(struct pipe_context *pipe, void * util_make_empty_fragment_shader(struct pipe_context *pipe) { - struct ureg_program *ureg = ureg_create(PIPE_SHADER_FRAGMENT); + struct ureg_program *ureg = ureg_create(MESA_SHADER_FRAGMENT); if (!ureg) return NULL; @@ -434,7 +434,7 @@ util_make_fragment_cloneinput_shader(struct pipe_context *pipe, int num_cbufs, assert(num_cbufs <= PIPE_MAX_COLOR_BUFS); - ureg = ureg_create( PIPE_SHADER_FRAGMENT ); + ureg = ureg_create( MESA_SHADER_FRAGMENT ); if (!ureg) return NULL; @@ -734,7 +734,7 @@ util_make_fs_msaa_resolve(struct pipe_context *pipe, struct ureg_dst out, tmp_sum, tmp_coord, tmp; unsigned i; - ureg = ureg_create(PIPE_SHADER_FRAGMENT); + ureg = ureg_create(MESA_SHADER_FRAGMENT); if (!ureg) return NULL; @@ -802,7 +802,7 @@ util_make_fs_msaa_resolve_bilinear(struct pipe_context *pipe, struct ureg_dst tmp_coord[4], tmp_sum[4], weights; unsigned i, c; - ureg = ureg_create(PIPE_SHADER_FRAGMENT); + ureg = ureg_create(MESA_SHADER_FRAGMENT); if (!ureg) return NULL; @@ -998,7 +998,7 @@ util_make_fs_pack_color_zs(struct pipe_context *pipe, bool z24_is_high = zs_format == PIPE_FORMAT_S8_UINT_Z24_UNORM || zs_format == PIPE_FORMAT_X8Z24_UNORM; - ureg = ureg_create(PIPE_SHADER_FRAGMENT); + ureg = ureg_create(MESA_SHADER_FRAGMENT); if (!ureg) return NULL; diff --git a/src/gallium/auxiliary/util/u_tests.c b/src/gallium/auxiliary/util/u_tests.c index ea1494cde11..f93a9010839 100644 --- a/src/gallium/auxiliary/util/u_tests.c +++ b/src/gallium/auxiliary/util/u_tests.c @@ -394,7 +394,7 @@ null_sampler_view(struct pipe_context *ctx, unsigned tgsi_tex_target) PIPE_FORMAT_R8G8B8A8_UNORM, 0); util_set_common_states_and_clear(cso, ctx, cb); - ctx->set_sampler_views(ctx, PIPE_SHADER_FRAGMENT, 0, 0, 1, NULL); + ctx->set_sampler_views(ctx, MESA_SHADER_FRAGMENT, 0, 0, 1, NULL); /* Fragment shader. */ fs = util_make_fragment_tex_shader(ctx, tgsi_tex_target, @@ -436,7 +436,7 @@ util_test_constant_buffer(struct pipe_context *ctx, PIPE_FORMAT_R8G8B8A8_UNORM, 0); util_set_common_states_and_clear(cso, ctx, cb); - pipe_set_constant_buffer(ctx, PIPE_SHADER_FRAGMENT, 0, constbuf); + pipe_set_constant_buffer(ctx, MESA_SHADER_FRAGMENT, 0, constbuf); /* Fragment shader. */ { @@ -707,7 +707,7 @@ test_texture_barrier(struct pipe_context *ctx, bool use_fbfetch, templ.swizzle_b = PIPE_SWIZZLE_Z; templ.swizzle_a = PIPE_SWIZZLE_W; view = ctx->create_sampler_view(ctx, cb, &templ); - ctx->set_sampler_views(ctx, PIPE_SHADER_FRAGMENT, 0, 1, 0, &view); + ctx->set_sampler_views(ctx, MESA_SHADER_FRAGMENT, 0, 1, 0, &view); /* Fragment shader. */ if (num_samples > 1) { diff --git a/src/gallium/auxiliary/util/u_threaded_context.c b/src/gallium/auxiliary/util/u_threaded_context.c index 1e307c6028c..dc6e2e32d43 100644 --- a/src/gallium/auxiliary/util/u_threaded_context.c +++ b/src/gallium/auxiliary/util/u_threaded_context.c @@ -911,7 +911,7 @@ tc_add_all_gfx_bindings_to_buffer_list(struct threaded_context *tc) tc_add_bindings_to_buffer_list(buffer_list, tc->streamout_buffers, PIPE_MAX_SO_BUFFERS); tc_add_shader_bindings_to_buffer_list(tc, buffer_list, MESA_SHADER_VERTEX); - tc_add_shader_bindings_to_buffer_list(tc, buffer_list, PIPE_SHADER_FRAGMENT); + tc_add_shader_bindings_to_buffer_list(tc, buffer_list, MESA_SHADER_FRAGMENT); if (tc->seen_tcs) tc_add_shader_bindings_to_buffer_list(tc, buffer_list, MESA_SHADER_TESS_CTRL); @@ -955,7 +955,7 @@ tc_rebind_buffer(struct threaded_context *tc, uint32_t old_id, uint32_t new_id, unsigned rebound = vbo + so; rebound += tc_rebind_shader_bindings(tc, old_id, new_id, MESA_SHADER_VERTEX, rebind_mask); - rebound += tc_rebind_shader_bindings(tc, old_id, new_id, PIPE_SHADER_FRAGMENT, rebind_mask); + rebound += tc_rebind_shader_bindings(tc, old_id, new_id, MESA_SHADER_FRAGMENT, rebind_mask); if (tc->seen_tcs) rebound += tc_rebind_shader_bindings(tc, old_id, new_id, MESA_SHADER_TESS_CTRL, rebind_mask); @@ -1007,7 +1007,7 @@ tc_is_buffer_bound_for_write(struct threaded_context *tc, uint32_t id) return true; if (tc_is_buffer_shader_bound_for_write(tc, id, MESA_SHADER_VERTEX) || - tc_is_buffer_shader_bound_for_write(tc, id, PIPE_SHADER_FRAGMENT) || + tc_is_buffer_shader_bound_for_write(tc, id, MESA_SHADER_FRAGMENT) || tc_is_buffer_shader_bound_for_write(tc, id, PIPE_SHADER_COMPUTE)) return true; @@ -5508,13 +5508,13 @@ threaded_context_create(struct pipe_context *pipe, /* If you have different limits in each shader stage, set the maximum. */ struct pipe_screen *screen = pipe->screen;; tc->max_const_buffers = - screen->shader_caps[PIPE_SHADER_FRAGMENT].max_const_buffers; + screen->shader_caps[MESA_SHADER_FRAGMENT].max_const_buffers; tc->max_shader_buffers = - screen->shader_caps[PIPE_SHADER_FRAGMENT].max_shader_buffers; + screen->shader_caps[MESA_SHADER_FRAGMENT].max_shader_buffers; tc->max_images = - screen->shader_caps[PIPE_SHADER_FRAGMENT].max_shader_images; + screen->shader_caps[MESA_SHADER_FRAGMENT].max_shader_images; tc->max_samplers = - screen->shader_caps[PIPE_SHADER_FRAGMENT].max_texture_samplers; + screen->shader_caps[MESA_SHADER_FRAGMENT].max_texture_samplers; tc->base.set_context_param = tc_set_context_param; /* always set this */ diff --git a/src/gallium/auxiliary/vl/vl_bicubic_filter.c b/src/gallium/auxiliary/vl/vl_bicubic_filter.c index 06dba0ef5d7..caaee4589c5 100644 --- a/src/gallium/auxiliary/vl/vl_bicubic_filter.c +++ b/src/gallium/auxiliary/vl/vl_bicubic_filter.c @@ -161,12 +161,12 @@ create_frag_shader(struct vl_bicubic_filter *filter, unsigned video_width, struct ureg_dst t; unsigned i; - if (screen->shader_caps[PIPE_SHADER_FRAGMENT].max_temps < 23) { + if (screen->shader_caps[MESA_SHADER_FRAGMENT].max_temps < 23) { return NULL; } - shader = ureg_create(PIPE_SHADER_FRAGMENT); + shader = ureg_create(MESA_SHADER_FRAGMENT); if (!shader) { return NULL; } @@ -449,13 +449,13 @@ vl_bicubic_filter_render(struct vl_bicubic_filter *filter, filter->pipe->clear_render_target(filter->pipe, dst, &clear_color, 0, 0, pipe_surface_width(dst), pipe_surface_height(dst), false); - filter->pipe->set_constant_buffer(filter->pipe, PIPE_SHADER_FRAGMENT, + filter->pipe->set_constant_buffer(filter->pipe, MESA_SHADER_FRAGMENT, 0, false, &cb); filter->pipe->bind_rasterizer_state(filter->pipe, filter->rs_state); filter->pipe->bind_blend_state(filter->pipe, filter->blend); - filter->pipe->bind_sampler_states(filter->pipe, PIPE_SHADER_FRAGMENT, + filter->pipe->bind_sampler_states(filter->pipe, MESA_SHADER_FRAGMENT, 0, 1, &filter->sampler); - filter->pipe->set_sampler_views(filter->pipe, PIPE_SHADER_FRAGMENT, + filter->pipe->set_sampler_views(filter->pipe, MESA_SHADER_FRAGMENT, 0, 1, 0, &src); filter->pipe->bind_vs_state(filter->pipe, filter->vs); filter->pipe->bind_fs_state(filter->pipe, filter->fs); diff --git a/src/gallium/auxiliary/vl/vl_compositor_gfx.c b/src/gallium/auxiliary/vl/vl_compositor_gfx.c index 2d261fa5236..23d0cd87b1c 100644 --- a/src/gallium/auxiliary/vl/vl_compositor_gfx.c +++ b/src/gallium/auxiliary/vl/vl_compositor_gfx.c @@ -268,7 +268,7 @@ create_frag_shader_video_buffer(struct vl_compositor *c) struct ureg_dst texel; struct ureg_dst fragment; - shader = ureg_create(PIPE_SHADER_FRAGMENT); + shader = ureg_create(MESA_SHADER_FRAGMENT); if (!shader) return NULL; @@ -290,7 +290,7 @@ create_frag_shader_weave_rgb(struct vl_compositor *c) struct ureg_program *shader; struct ureg_dst texel, fragment; - shader = ureg_create(PIPE_SHADER_FRAGMENT); + shader = ureg_create(MESA_SHADER_FRAGMENT); if (!shader) return NULL; @@ -313,7 +313,7 @@ create_frag_shader_deint_yuv(struct vl_compositor *c, bool y, bool w) struct ureg_program *shader; struct ureg_dst texel, fragment; - shader = ureg_create(PIPE_SHADER_FRAGMENT); + shader = ureg_create(MESA_SHADER_FRAGMENT); if (!shader) return NULL; @@ -351,7 +351,7 @@ create_frag_shader_palette(struct vl_compositor *c, bool include_cc) struct ureg_dst fragment; unsigned i; - shader = ureg_create(PIPE_SHADER_FRAGMENT); + shader = ureg_create(MESA_SHADER_FRAGMENT); if (!shader) return NULL; @@ -405,7 +405,7 @@ create_frag_shader_rgba(struct vl_compositor *c) struct ureg_src tc, color, sampler; struct ureg_dst texel, fragment; - shader = ureg_create(PIPE_SHADER_FRAGMENT); + shader = ureg_create(MESA_SHADER_FRAGMENT); if (!shader) return NULL; @@ -440,7 +440,7 @@ create_frag_shader_rgb_yuv(struct vl_compositor *c, bool y) struct ureg_src csc[3]; unsigned i; - shader = ureg_create(PIPE_SHADER_FRAGMENT); + shader = ureg_create(MESA_SHADER_FRAGMENT); if (!shader) return NULL; @@ -683,9 +683,9 @@ draw_layers(struct vl_compositor *c, struct vl_compositor_state *s, struct u_rec c->pipe->bind_blend_state(c->pipe, blend); c->pipe->set_viewport_states(c->pipe, 0, 1, &layer->viewport); c->pipe->bind_fs_state(c->pipe, layer->fs); - c->pipe->bind_sampler_states(c->pipe, PIPE_SHADER_FRAGMENT, 0, + c->pipe->bind_sampler_states(c->pipe, MESA_SHADER_FRAGMENT, 0, num_sampler_views, layer->samplers); - c->pipe->set_sampler_views(c->pipe, PIPE_SHADER_FRAGMENT, 0, + c->pipe->set_sampler_views(c->pipe, MESA_SHADER_FRAGMENT, 0, num_sampler_views, 0, samplers); util_draw_arrays(c->pipe, MESA_PRIM_QUADS, vb_index * 4, 4); @@ -740,7 +740,7 @@ vl_compositor_gfx_render(struct vl_compositor_state *s, c->pipe->bind_vs_state(c->pipe, c->vs); c->pipe->bind_vertex_elements_state(c->pipe, c->vertex_elems_state); util_set_vertex_buffers(c->pipe, 1, false, &c->vertex_buf); - pipe_set_constant_buffer(c->pipe, PIPE_SHADER_FRAGMENT, 0, s->shader_params); + pipe_set_constant_buffer(c->pipe, MESA_SHADER_FRAGMENT, 0, s->shader_params); c->pipe->bind_rasterizer_state(c->pipe, c->rast); draw_layers(c, s, dirty_area); diff --git a/src/gallium/auxiliary/vl/vl_deint_filter.c b/src/gallium/auxiliary/vl/vl_deint_filter.c index 833d0c97d97..7160827a7e8 100644 --- a/src/gallium/auxiliary/vl/vl_deint_filter.c +++ b/src/gallium/auxiliary/vl/vl_deint_filter.c @@ -94,7 +94,7 @@ create_copy_frag_shader(struct vl_deint_filter *filter, unsigned field, struct ureg_dst o_fragment; struct ureg_dst t_tex; - shader = ureg_create(PIPE_SHADER_FRAGMENT); + shader = ureg_create(MESA_SHADER_FRAGMENT); if (!shader) { return NULL; } @@ -144,7 +144,7 @@ create_deint_frag_shader(struct vl_deint_filter *filter, unsigned field, struct ureg_dst t_a, t_b; struct ureg_dst t_weave, t_linear; - shader = ureg_create(PIPE_SHADER_FRAGMENT); + shader = ureg_create(MESA_SHADER_FRAGMENT); if (!shader) { return NULL; } @@ -496,7 +496,7 @@ vl_deint_filter_render(struct vl_deint_filter *filter, filter->pipe->bind_vertex_elements_state(filter->pipe, filter->ves); util_set_vertex_buffers(filter->pipe, 1, false, &filter->quad); filter->pipe->bind_vs_state(filter->pipe, filter->vs); - filter->pipe->bind_sampler_states(filter->pipe, PIPE_SHADER_FRAGMENT, + filter->pipe->bind_sampler_states(filter->pipe, MESA_SHADER_FRAGMENT, 0, 4, filter->sampler); /* prepare viewport */ @@ -531,7 +531,7 @@ vl_deint_filter_render(struct vl_deint_filter *filter, sampler_views[1] = prev_sv[k]; sampler_views[2] = cur_sv[k]; sampler_views[3] = next_sv[k]; - filter->pipe->set_sampler_views(filter->pipe, PIPE_SHADER_FRAGMENT, + filter->pipe->set_sampler_views(filter->pipe, MESA_SHADER_FRAGMENT, 0, 4, 0, sampler_views); /* blit current field */ diff --git a/src/gallium/auxiliary/vl/vl_idct.c b/src/gallium/auxiliary/vl/vl_idct.c index cff2b13405e..306149f48fd 100644 --- a/src/gallium/auxiliary/vl/vl_idct.c +++ b/src/gallium/auxiliary/vl/vl_idct.c @@ -200,7 +200,7 @@ create_mismatch_frag_shader(struct vl_idct *idct) unsigned i; - shader = ureg_create(PIPE_SHADER_FRAGMENT); + shader = ureg_create(MESA_SHADER_FRAGMENT); if (!shader) return NULL; @@ -327,7 +327,7 @@ create_stage1_frag_shader(struct vl_idct *idct) unsigned i; int j; - shader = ureg_create(PIPE_SHADER_FRAGMENT); + shader = ureg_create(MESA_SHADER_FRAGMENT); if (!shader) return NULL; @@ -820,10 +820,10 @@ vl_idct_flush(struct vl_idct *idct, struct vl_idct_buffer *buffer, unsigned num_ idct->pipe->bind_rasterizer_state(idct->pipe, idct->rs_state); idct->pipe->bind_blend_state(idct->pipe, idct->blend); - idct->pipe->bind_sampler_states(idct->pipe, PIPE_SHADER_FRAGMENT, + idct->pipe->bind_sampler_states(idct->pipe, MESA_SHADER_FRAGMENT, 0, 2, idct->samplers); - idct->pipe->set_sampler_views(idct->pipe, PIPE_SHADER_FRAGMENT, 0, 2, 0, + idct->pipe->set_sampler_views(idct->pipe, MESA_SHADER_FRAGMENT, 0, 2, 0, buffer->sampler_views.stage[0]); /* mismatch control */ @@ -848,8 +848,8 @@ vl_idct_prepare_stage2(struct vl_idct *idct, struct vl_idct_buffer *buffer) /* second stage */ idct->pipe->bind_rasterizer_state(idct->pipe, idct->rs_state); - idct->pipe->bind_sampler_states(idct->pipe, PIPE_SHADER_FRAGMENT, + idct->pipe->bind_sampler_states(idct->pipe, MESA_SHADER_FRAGMENT, 0, 2, idct->samplers); - idct->pipe->set_sampler_views(idct->pipe, PIPE_SHADER_FRAGMENT, + idct->pipe->set_sampler_views(idct->pipe, MESA_SHADER_FRAGMENT, 0, 2, 0, buffer->sampler_views.stage[1]); } diff --git a/src/gallium/auxiliary/vl/vl_matrix_filter.c b/src/gallium/auxiliary/vl/vl_matrix_filter.c index 15a27d0e1e4..241979f1ac0 100644 --- a/src/gallium/auxiliary/vl/vl_matrix_filter.c +++ b/src/gallium/auxiliary/vl/vl_matrix_filter.c @@ -86,7 +86,7 @@ create_frag_shader(struct vl_matrix_filter *filter, unsigned num_offsets, struct ureg_dst o_fragment; unsigned i; - shader = ureg_create(PIPE_SHADER_FRAGMENT); + shader = ureg_create(MESA_SHADER_FRAGMENT); if (!shader) { return NULL; } @@ -299,9 +299,9 @@ vl_matrix_filter_render(struct vl_matrix_filter *filter, filter->pipe->bind_rasterizer_state(filter->pipe, filter->rs_state); filter->pipe->bind_blend_state(filter->pipe, filter->blend); - filter->pipe->bind_sampler_states(filter->pipe, PIPE_SHADER_FRAGMENT, + filter->pipe->bind_sampler_states(filter->pipe, MESA_SHADER_FRAGMENT, 0, 1, &filter->sampler); - filter->pipe->set_sampler_views(filter->pipe, PIPE_SHADER_FRAGMENT, + filter->pipe->set_sampler_views(filter->pipe, MESA_SHADER_FRAGMENT, 0, 1, 0, &src); filter->pipe->bind_vs_state(filter->pipe, filter->vs); filter->pipe->bind_fs_state(filter->pipe, filter->fs); diff --git a/src/gallium/auxiliary/vl/vl_mc.c b/src/gallium/auxiliary/vl/vl_mc.c index 8f26cddf4f7..9272186ec86 100644 --- a/src/gallium/auxiliary/vl/vl_mc.c +++ b/src/gallium/auxiliary/vl/vl_mc.c @@ -169,7 +169,7 @@ create_ref_frag_shader(struct vl_mc *r) struct ureg_dst fragment; unsigned label; - shader = ureg_create(PIPE_SHADER_FRAGMENT); + shader = ureg_create(MESA_SHADER_FRAGMENT); if (!shader) return NULL; @@ -320,7 +320,7 @@ create_ycbcr_frag_shader(struct vl_mc *r, float scale, bool invert, struct ureg_dst fragment; unsigned label; - shader = ureg_create(PIPE_SHADER_FRAGMENT); + shader = ureg_create(MESA_SHADER_FRAGMENT); if (!shader) return NULL; @@ -620,9 +620,9 @@ vl_mc_render_ref(struct vl_mc *renderer, struct vl_mc_buffer *buffer, struct pip renderer->pipe->bind_vs_state(renderer->pipe, renderer->vs_ref); renderer->pipe->bind_fs_state(renderer->pipe, renderer->fs_ref); - renderer->pipe->set_sampler_views(renderer->pipe, PIPE_SHADER_FRAGMENT, + renderer->pipe->set_sampler_views(renderer->pipe, MESA_SHADER_FRAGMENT, 0, 1, 0, &ref); - renderer->pipe->bind_sampler_states(renderer->pipe, PIPE_SHADER_FRAGMENT, + renderer->pipe->bind_sampler_states(renderer->pipe, MESA_SHADER_FRAGMENT, 0, 1, &renderer->sampler_ref); util_draw_arrays_instanced(renderer->pipe, MESA_PRIM_QUADS, 0, 4, 0, diff --git a/src/gallium/auxiliary/vl/vl_median_filter.c b/src/gallium/auxiliary/vl/vl_median_filter.c index 8576fd94c13..be56870e9ef 100644 --- a/src/gallium/auxiliary/vl/vl_median_filter.c +++ b/src/gallium/auxiliary/vl/vl_median_filter.c @@ -92,13 +92,13 @@ create_frag_shader(struct vl_median_filter *filter, return NULL; } - if (num_offsets > screen->shader_caps[PIPE_SHADER_FRAGMENT].max_temps) { + if (num_offsets > screen->shader_caps[MESA_SHADER_FRAGMENT].max_temps) { FREE(t_array); return NULL; } - shader = ureg_create(PIPE_SHADER_FRAGMENT); + shader = ureg_create(MESA_SHADER_FRAGMENT); if (!shader) { FREE(t_array); return NULL; @@ -417,9 +417,9 @@ vl_median_filter_render(struct vl_median_filter *filter, filter->pipe->bind_rasterizer_state(filter->pipe, filter->rs_state); filter->pipe->bind_blend_state(filter->pipe, filter->blend); - filter->pipe->bind_sampler_states(filter->pipe, PIPE_SHADER_FRAGMENT, + filter->pipe->bind_sampler_states(filter->pipe, MESA_SHADER_FRAGMENT, 0, 1, &filter->sampler); - filter->pipe->set_sampler_views(filter->pipe, PIPE_SHADER_FRAGMENT, + filter->pipe->set_sampler_views(filter->pipe, MESA_SHADER_FRAGMENT, 0, 1, 0, &src); filter->pipe->bind_vs_state(filter->pipe, filter->vs); filter->pipe->bind_fs_state(filter->pipe, filter->fs); diff --git a/src/gallium/auxiliary/vl/vl_mpeg12_decoder.c b/src/gallium/auxiliary/vl/vl_mpeg12_decoder.c index 99e319ddd94..c8296be5005 100644 --- a/src/gallium/auxiliary/vl/vl_mpeg12_decoder.c +++ b/src/gallium/auxiliary/vl/vl_mpeg12_decoder.c @@ -822,10 +822,10 @@ vl_mpeg12_end_frame(struct pipe_video_codec *decoder, vl_idct_prepare_stage2(i ? &dec->idct_c : &dec->idct_y, &buf->idct[plane]); else { dec->context->set_sampler_views(dec->context, - PIPE_SHADER_FRAGMENT, 0, 1, 0, + MESA_SHADER_FRAGMENT, 0, 1, 0, &mc_source_sv[plane]); dec->context->bind_sampler_states(dec->context, - PIPE_SHADER_FRAGMENT, + MESA_SHADER_FRAGMENT, 0, 1, &dec->sampler_ycbcr); } vl_mc_render_ycbcr(i ? &dec->mc_c : &dec->mc_y, &buf->mc[i], j, buf->num_ycbcr_blocks[plane]); @@ -959,7 +959,7 @@ init_idct(struct vl_mpeg12_decoder *dec, const struct format_config* format_conf nr_of_idct_render_targets = dec->context->screen->caps.max_render_targets; - max_inst = dec->context->screen->shader_caps[PIPE_SHADER_FRAGMENT].max_instructions; + max_inst = dec->context->screen->shader_caps[MESA_SHADER_FRAGMENT].max_instructions; // Just assume we need 32 inst per render target, not 100% true, but should work in most cases if (nr_of_idct_render_targets >= 4 && max_inst >= 32*4) diff --git a/src/gallium/auxiliary/vl/vl_zscan.c b/src/gallium/auxiliary/vl/vl_zscan.c index 752fb339b4d..2468846cd6a 100644 --- a/src/gallium/auxiliary/vl/vl_zscan.c +++ b/src/gallium/auxiliary/vl/vl_zscan.c @@ -137,7 +137,7 @@ create_frag_shader(struct vl_zscan *zscan) unsigned i; - shader = ureg_create(PIPE_SHADER_FRAGMENT); + shader = ureg_create(MESA_SHADER_FRAGMENT); if (!shader) return NULL; @@ -531,11 +531,11 @@ vl_zscan_render(struct vl_zscan *zscan, struct vl_zscan_buffer *buffer, unsigned zscan->pipe->bind_rasterizer_state(zscan->pipe, zscan->rs_state); zscan->pipe->bind_blend_state(zscan->pipe, zscan->blend); - zscan->pipe->bind_sampler_states(zscan->pipe, PIPE_SHADER_FRAGMENT, + zscan->pipe->bind_sampler_states(zscan->pipe, MESA_SHADER_FRAGMENT, 0, 3, zscan->samplers); zscan->pipe->set_framebuffer_state(zscan->pipe, &buffer->fb_state); zscan->pipe->set_viewport_states(zscan->pipe, 0, 1, &buffer->viewport); - zscan->pipe->set_sampler_views(zscan->pipe, PIPE_SHADER_FRAGMENT, + zscan->pipe->set_sampler_views(zscan->pipe, MESA_SHADER_FRAGMENT, 0, 3, 0, &buffer->src); zscan->pipe->bind_vs_state(zscan->pipe, zscan->vs); zscan->pipe->bind_fs_state(zscan->pipe, zscan->fs); diff --git a/src/gallium/drivers/asahi/agx_blit.c b/src/gallium/drivers/asahi/agx_blit.c index f90f4af941b..230adf023b8 100644 --- a/src/gallium/drivers/asahi/agx_blit.c +++ b/src/gallium/drivers/asahi/agx_blit.c @@ -482,11 +482,11 @@ agx_blitter_save(struct agx_context *ctx, struct blitter_context *blitter, util_blitter_save_scissor(blitter, &ctx->scissor[0]); util_blitter_save_fragment_shader( - blitter, ctx->stage[PIPE_SHADER_FRAGMENT].shader); + blitter, ctx->stage[MESA_SHADER_FRAGMENT].shader); if (op & ASAHI_SAVE_FRAGMENT_CONSTANT) { util_blitter_save_fragment_constant_buffer_slot( - blitter, ctx->stage[PIPE_SHADER_FRAGMENT].cb); + blitter, ctx->stage[MESA_SHADER_FRAGMENT].cb); } } @@ -496,12 +496,12 @@ agx_blitter_save(struct agx_context *ctx, struct blitter_context *blitter, if (op & ASAHI_SAVE_TEXTURES) { util_blitter_save_fragment_sampler_states( - blitter, ctx->stage[PIPE_SHADER_FRAGMENT].sampler_count, - (void **)(ctx->stage[PIPE_SHADER_FRAGMENT].samplers)); + blitter, ctx->stage[MESA_SHADER_FRAGMENT].sampler_count, + (void **)(ctx->stage[MESA_SHADER_FRAGMENT].samplers)); util_blitter_save_fragment_sampler_views( - blitter, ctx->stage[PIPE_SHADER_FRAGMENT].texture_count, - (struct pipe_sampler_view **)ctx->stage[PIPE_SHADER_FRAGMENT].textures); + blitter, ctx->stage[MESA_SHADER_FRAGMENT].texture_count, + (struct pipe_sampler_view **)ctx->stage[MESA_SHADER_FRAGMENT].textures); } if (!(op & ASAHI_DISABLE_RENDER_COND)) { diff --git a/src/gallium/drivers/asahi/agx_disk_cache.c b/src/gallium/drivers/asahi/agx_disk_cache.c index 0abef672b83..7b7907060c8 100644 --- a/src/gallium/drivers/asahi/agx_disk_cache.c +++ b/src/gallium/drivers/asahi/agx_disk_cache.c @@ -37,7 +37,7 @@ agx_disk_cache_compute_key(struct disk_cache *cache, if (uncompiled->type == MESA_SHADER_VERTEX || uncompiled->type == MESA_SHADER_TESS_EVAL) key_size = sizeof(shader_key->vs); - else if (uncompiled->type == PIPE_SHADER_FRAGMENT) + else if (uncompiled->type == MESA_SHADER_FRAGMENT) key_size = sizeof(shader_key->fs); else key_size = 0; @@ -95,7 +95,7 @@ read_shader(struct agx_screen *screen, struct blob_reader *blob, if (uncompiled->type == MESA_SHADER_VERTEX || uncompiled->type == MESA_SHADER_TESS_EVAL || - uncompiled->type == PIPE_SHADER_FRAGMENT) { + uncompiled->type == MESA_SHADER_FRAGMENT) { binary->b.binary = malloc(size); blob_copy_bytes(blob, binary->b.binary, size); diff --git a/src/gallium/drivers/asahi/agx_nir_lower_sysvals.c b/src/gallium/drivers/asahi/agx_nir_lower_sysvals.c index 10ed8d32c11..fcbc1da01e9 100644 --- a/src/gallium/drivers/asahi/agx_nir_lower_sysvals.c +++ b/src/gallium/drivers/asahi/agx_nir_lower_sysvals.c @@ -422,7 +422,7 @@ lay_out_uniforms(struct agx_compiled_shader *shader, struct state *state) } uniform = AGX_ABI_VUNI_COUNT_GL(count, sw); - } else if (state->stage == PIPE_SHADER_FRAGMENT) { + } else if (state->stage == MESA_SHADER_FRAGMENT) { struct agx_draw_uniforms *u = NULL; struct agx_stage_uniforms *s = NULL; shader->push[shader->push_range_count++] = (struct agx_push_range){ diff --git a/src/gallium/drivers/asahi/agx_pipe.c b/src/gallium/drivers/asahi/agx_pipe.c index 348f1e34a75..bf215cbc32a 100644 --- a/src/gallium/drivers/asahi/agx_pipe.c +++ b/src/gallium/drivers/asahi/agx_pipe.c @@ -1879,7 +1879,7 @@ agx_init_shader_caps(struct pipe_screen *pscreen) * correctly, though. The full 32 is undesirable since it would require * shenanigans to handle. */ - caps->max_outputs = i == PIPE_SHADER_FRAGMENT ? 8 + caps->max_outputs = i == MESA_SHADER_FRAGMENT ? 8 : i == MESA_SHADER_VERTEX ? 24 : 32; diff --git a/src/gallium/drivers/asahi/agx_state.c b/src/gallium/drivers/asahi/agx_state.c index 2a9f8c5522f..d23050ef70c 100644 --- a/src/gallium/drivers/asahi/agx_state.c +++ b/src/gallium/drivers/asahi/agx_state.c @@ -1634,10 +1634,10 @@ agx_compile_variant(struct agx_device *dev, struct pipe_context *pctx, NIR_PASS(_, nir, agx_nir_lower_multisampled_image_store); struct agx_compiled_shader *compiled = agx_compile_nir( - dev, nir, &pctx->debug, so->type, false, so->type != PIPE_SHADER_FRAGMENT, + dev, nir, &pctx->debug, so->type, false, so->type != MESA_SHADER_FRAGMENT, false, 0, attrib_components_read); - if (so->type == PIPE_SHADER_FRAGMENT) { + if (so->type == MESA_SHADER_FRAGMENT) { /* XXX: don't replicate this all over the driver */ epilog_key.rt_spill_base = BITSET_LAST_BIT(nir->info.textures_used) + (2 * BITSET_LAST_BIT(nir->info.images_used)); @@ -1714,7 +1714,7 @@ agx_get_shader_variant(struct agx_screen *screen, struct pipe_context *pctx, union asahi_shader_key *cloned_key = rzalloc(so->variants, union asahi_shader_key); - if (so->type == PIPE_SHADER_FRAGMENT) { + if (so->type == MESA_SHADER_FRAGMENT) { memcpy(cloned_key, key, sizeof(struct asahi_fs_shader_key)); } else if (so->type == MESA_SHADER_VERTEX || so->type == MESA_SHADER_TESS_EVAL) { @@ -1949,7 +1949,7 @@ agx_create_shader_state(struct pipe_context *pctx, */ if ((so->type == MESA_SHADER_TESS_CTRL) || (so->type == MESA_SHADER_GEOMETRY) || - (so->type == PIPE_SHADER_FRAGMENT && !so->info.uses_fbfetch)) { + (so->type == MESA_SHADER_FRAGMENT && !so->info.uses_fbfetch)) { union asahi_shader_key key = {0}; agx_get_shader_variant(agx_screen(pctx->screen), pctx, so, &key); } else if (so->type == MESA_SHADER_VERTEX) { @@ -1970,7 +1970,7 @@ agx_create_shader_state(struct pipe_context *pctx, /* TODO: Tessellation shaders with shader-db */ return so; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: key.fs.nr_samples = 1; /* For fbfetch */ @@ -2142,7 +2142,7 @@ asahi_fast_link(struct agx_context *ctx, struct agx_uncompiled_shader *so, struct agx_linked_shader *linked = rzalloc(so->linked_shaders, struct agx_linked_shader); - agx_fast_link(linked, dev, so->type == PIPE_SHADER_FRAGMENT, &key->main->b, + agx_fast_link(linked, dev, so->type == MESA_SHADER_FRAGMENT, &key->main->b, &prolog->b, &epilog->b, key->nr_samples_shaded); /* Cache the fast linked program */ @@ -2296,7 +2296,7 @@ agx_update_fs(struct agx_batch *batch) /* Get main shader */ struct asahi_fs_shader_key key = {0}; - if (ctx->stage[PIPE_SHADER_FRAGMENT].shader->info.uses_fbfetch) { + if (ctx->stage[MESA_SHADER_FRAGMENT].shader->info.uses_fbfetch) { key.nr_samples = nr_samples; for (unsigned i = 0; i < batch->key.nr_cbufs; ++i) { @@ -2304,7 +2304,7 @@ agx_update_fs(struct agx_batch *batch) } } - agx_update_shader(ctx, &ctx->fs, PIPE_SHADER_FRAGMENT, + agx_update_shader(ctx, &ctx->fs, MESA_SHADER_FRAGMENT, (union asahi_shader_key *)&key); /* Fast link with prolog/epilog */ @@ -2380,7 +2380,7 @@ agx_update_fs(struct agx_batch *batch) void *old = ctx->linked.fs; ctx->linked.fs = - asahi_fast_link(ctx, ctx->stage[PIPE_SHADER_FRAGMENT].shader, &link_key); + asahi_fast_link(ctx, ctx->stage[MESA_SHADER_FRAGMENT].shader, &link_key); if (ctx->fs->bo) agx_batch_add_bo(batch, ctx->fs->bo); @@ -2398,7 +2398,7 @@ agx_bind_shader_state(struct pipe_context *pctx, void *cso, if (stage == MESA_SHADER_VERTEX) ctx->dirty |= AGX_DIRTY_VS_PROG; - else if (stage == PIPE_SHADER_FRAGMENT) + else if (stage == MESA_SHADER_FRAGMENT) ctx->dirty |= AGX_DIRTY_FS_PROG; else ctx->stage[stage].dirty = ~0; @@ -2415,7 +2415,7 @@ agx_bind_vs_state(struct pipe_context *pctx, void *cso) static void agx_bind_fs_state(struct pipe_context *pctx, void *cso) { - agx_bind_shader_state(pctx, cso, PIPE_SHADER_FRAGMENT); + agx_bind_shader_state(pctx, cso, MESA_SHADER_FRAGMENT); } static void @@ -2664,7 +2664,7 @@ agx_nr_tex_descriptors(struct agx_batch *batch, struct agx_compiled_shader *cs) unsigned n = agx_nr_tex_descriptors_without_spilled_rts(cs); /* We add on texture/PBE descriptors for spilled render targets */ - bool spilled_rt = cs->stage == PIPE_SHADER_FRAGMENT && + bool spilled_rt = cs->stage == MESA_SHADER_FRAGMENT && agx_tilebuffer_spills(&batch->tilebuffer_layout); if (spilled_rt) n += (batch->key.nr_cbufs * 2); @@ -2777,7 +2777,7 @@ agx_upload_textures(struct agx_batch *batch, struct agx_compiled_shader *cs, agx_batch_upload_pbe(batch, pbe, view, false, false, false, false); } - if (stage == PIPE_SHADER_FRAGMENT && + if (stage == MESA_SHADER_FRAGMENT && agx_tilebuffer_spills(&batch->tilebuffer_layout)) { struct agx_texture_packed *out = @@ -2955,7 +2955,7 @@ agx_build_pipeline(struct agx_batch *batch, struct agx_compiled_shader *cs, unsigned preamble_size = (cs->b.info.preamble_scratch_size > 0) ? 1 : 0; switch (phys_stage) { - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: agx_scratch_alloc(&ctx->scratch_fs, max_scratch_size, max_subgroups); batch->fs_scratch = true; batch->fs_preamble_scratch = @@ -2976,7 +2976,7 @@ agx_build_pipeline(struct agx_batch *batch, struct agx_compiled_shader *cs, } } - if (stage == PIPE_SHADER_FRAGMENT) { + if (stage == MESA_SHADER_FRAGMENT) { agx_usc_push_packed(&b, SHARED, &batch->tilebuffer_layout.usc); } else { agx_usc_shared_non_fragment(&b, &cs->b.info, variable_shared_mem); @@ -2986,7 +2986,7 @@ agx_build_pipeline(struct agx_batch *batch, struct agx_compiled_shader *cs, agx_usc_push_packed(&b, SHADER, linked->shader); agx_usc_push_packed(&b, REGISTERS, linked->regs); - if (stage == PIPE_SHADER_FRAGMENT) + if (stage == MESA_SHADER_FRAGMENT) agx_usc_push_packed(&b, FRAGMENT_PROPERTIES, linked->fragment_props); } else { agx_usc_pack(&b, SHADER, cfg) { @@ -3671,7 +3671,7 @@ agx_encode_state(struct agx_batch *batch, uint8_t *out) } if (dirty.fragment_shader) { - unsigned frag_tex_count = ctx->stage[PIPE_SHADER_FRAGMENT].texture_count; + unsigned frag_tex_count = ctx->stage[MESA_SHADER_FRAGMENT].texture_count; agx_ppp_push(&ppp, FRAGMENT_SHADER_WORD_0, cfg) { cfg.uniform_register_count = ctx->fs->b.info.push_count; @@ -3679,13 +3679,13 @@ agx_encode_state(struct agx_batch *batch, uint8_t *out) cfg.texture_state_register_count = agx_nr_tex_descriptors(batch, ctx->fs); cfg.sampler_state_register_count = - translate_sampler_state_count(ctx, PIPE_SHADER_FRAGMENT); + translate_sampler_state_count(ctx, MESA_SHADER_FRAGMENT); cfg.cf_binding_count = ctx->linked.fs->cf.nr_bindings; } agx_ppp_push(&ppp, FRAGMENT_SHADER_WORD_1, cfg) { cfg.pipeline = agx_build_pipeline(batch, ctx->fs, ctx->linked.fs, - PIPE_SHADER_FRAGMENT, 0, 0); + MESA_SHADER_FRAGMENT, 0, 0); } agx_ppp_push(&ppp, FRAGMENT_SHADER_WORD_2, cfg) { @@ -3930,7 +3930,7 @@ agx_batch_geometry_params(struct agx_batch *batch, uint64_t input_index_buffer, struct agx_geometry_params params = { .indirect_desc = batch->geom_indirect, .flat_outputs = - batch->ctx->stage[PIPE_SHADER_FRAGMENT].shader->info.inputs_flat_shaded, + batch->ctx->stage[MESA_SHADER_FRAGMENT].shader->info.inputs_flat_shaded, .input_topology = info->mode, .xfb_offs_ptrs = {AGX_ZERO_PAGE_ADDRESS, AGX_ZERO_PAGE_ADDRESS, AGX_ZERO_PAGE_ADDRESS, AGX_ZERO_PAGE_ADDRESS}, @@ -5043,8 +5043,8 @@ agx_draw_vbo(struct pipe_context *pctx, const struct pipe_draw_info *info, agx_assign_uvs( &batch->linked_varyings, &vs->uvs, - ctx->stage[PIPE_SHADER_FRAGMENT].shader->info.inputs_flat_shaded, - ctx->stage[PIPE_SHADER_FRAGMENT].shader->info.inputs_linear_shaded); + ctx->stage[MESA_SHADER_FRAGMENT].shader->info.inputs_flat_shaded, + ctx->stage[MESA_SHADER_FRAGMENT].shader->info.inputs_linear_shaded); for (unsigned i = 0; i < VARYING_SLOT_MAX; ++i) { batch->uniforms.uvs_index[i] = batch->linked_varyings.slots[i]; @@ -5060,8 +5060,8 @@ agx_draw_vbo(struct pipe_context *pctx, const struct pipe_draw_info *info, if (agx_update_fs(batch)) { ctx->dirty |= AGX_DIRTY_FS | AGX_DIRTY_FS_PROG; - ctx->stage[PIPE_SHADER_FRAGMENT].dirty = ~0; - } else if ((ctx->stage[PIPE_SHADER_FRAGMENT].dirty) || + ctx->stage[MESA_SHADER_FRAGMENT].dirty = ~0; + } else if ((ctx->stage[MESA_SHADER_FRAGMENT].dirty) || (ctx->dirty & (AGX_DIRTY_BLEND_COLOR | AGX_DIRTY_SAMPLE_MASK))) { ctx->dirty |= AGX_DIRTY_FS; } diff --git a/src/gallium/drivers/asahi/agx_state.h b/src/gallium/drivers/asahi/agx_state.h index 65fc244ef1f..fb89517616e 100644 --- a/src/gallium/drivers/asahi/agx_state.h +++ b/src/gallium/drivers/asahi/agx_state.h @@ -96,7 +96,7 @@ static_assert(AGX_SYSVAL_STAGE(MESA_SHADER_TESS_EVAL) == AGX_SYSVAL_TABLE_TES, "fixed enum orderings"); static_assert(AGX_SYSVAL_STAGE(MESA_SHADER_GEOMETRY) == AGX_SYSVAL_TABLE_GS, "fixed enum orderings"); -static_assert(AGX_SYSVAL_STAGE(PIPE_SHADER_FRAGMENT) == AGX_SYSVAL_TABLE_FS, +static_assert(AGX_SYSVAL_STAGE(MESA_SHADER_FRAGMENT) == AGX_SYSVAL_TABLE_FS, "fixed enum orderings"); static_assert(AGX_SYSVAL_STAGE(PIPE_SHADER_COMPUTE) == AGX_SYSVAL_TABLE_CS, "fixed enum orderings"); diff --git a/src/gallium/drivers/crocus/crocus_screen.c b/src/gallium/drivers/crocus/crocus_screen.c index 8ebf75490fb..1a8ac779e6a 100644 --- a/src/gallium/drivers/crocus/crocus_screen.c +++ b/src/gallium/drivers/crocus/crocus_screen.c @@ -145,12 +145,12 @@ crocus_init_shader_caps(struct crocus_screen *screen) if (devinfo->ver < 6 && i != MESA_SHADER_VERTEX && - i != PIPE_SHADER_FRAGMENT) + i != MESA_SHADER_FRAGMENT) continue; if (devinfo->ver == 6 && i != MESA_SHADER_VERTEX && - i != PIPE_SHADER_FRAGMENT && + i != MESA_SHADER_FRAGMENT && i != MESA_SHADER_GEOMETRY) continue; @@ -181,7 +181,7 @@ crocus_init_shader_caps(struct crocus_screen *screen) (devinfo->verx10 >= 75) ? CROCUS_MAX_TEXTURE_SAMPLERS : 16; if (devinfo->ver >= 7 && - (i == PIPE_SHADER_FRAGMENT || i == PIPE_SHADER_COMPUTE)) + (i == MESA_SHADER_FRAGMENT || i == PIPE_SHADER_COMPUTE)) caps->max_shader_images = CROCUS_MAX_TEXTURE_SAMPLERS; caps->max_shader_buffers = diff --git a/src/gallium/drivers/crocus/crocus_state.c b/src/gallium/drivers/crocus/crocus_state.c index 583ab5eb4f9..8a316df7103 100644 --- a/src/gallium/drivers/crocus/crocus_state.c +++ b/src/gallium/drivers/crocus/crocus_state.c @@ -2318,7 +2318,7 @@ crocus_bind_sampler_states(struct pipe_context *ctx, if (dirty) { #if GFX_VER <= 5 - if (p_stage == PIPE_SHADER_FRAGMENT) + if (p_stage == MESA_SHADER_FRAGMENT) ice->state.dirty |= CROCUS_DIRTY_WM; else if (p_stage == MESA_SHADER_VERTEX) ice->state.stage_dirty |= CROCUS_STAGE_DIRTY_VS; diff --git a/src/gallium/drivers/d3d12/d3d12_blit.cpp b/src/gallium/drivers/d3d12/d3d12_blit.cpp index 9539aefcb23..9835d3e3b5b 100644 --- a/src/gallium/drivers/d3d12/d3d12_blit.cpp +++ b/src/gallium/drivers/d3d12/d3d12_blit.cpp @@ -270,7 +270,7 @@ util_blit_save_state(struct d3d12_context *ctx) util_blitter_save_vertex_elements(ctx->blitter, ctx->gfx_pipeline_state.ves); util_blitter_save_stencil_ref(ctx->blitter, &ctx->stencil_ref); util_blitter_save_rasterizer(ctx->blitter, ctx->gfx_pipeline_state.rast); - util_blitter_save_fragment_shader(ctx->blitter, ctx->gfx_stages[PIPE_SHADER_FRAGMENT]); + util_blitter_save_fragment_shader(ctx->blitter, ctx->gfx_stages[MESA_SHADER_FRAGMENT]); util_blitter_save_vertex_shader(ctx->blitter, ctx->gfx_stages[MESA_SHADER_VERTEX]); util_blitter_save_geometry_shader(ctx->blitter, ctx->gfx_stages[MESA_SHADER_GEOMETRY]); util_blitter_save_tessctrl_shader(ctx->blitter, ctx->gfx_stages[MESA_SHADER_TESS_CTRL]); @@ -280,12 +280,12 @@ util_blit_save_state(struct d3d12_context *ctx) util_blitter_save_viewport(ctx->blitter, ctx->viewport_states); util_blitter_save_scissor(ctx->blitter, ctx->scissor_states); util_blitter_save_fragment_sampler_states(ctx->blitter, - ctx->num_samplers[PIPE_SHADER_FRAGMENT], - (void **)ctx->samplers[PIPE_SHADER_FRAGMENT]); + ctx->num_samplers[MESA_SHADER_FRAGMENT], + (void **)ctx->samplers[MESA_SHADER_FRAGMENT]); util_blitter_save_fragment_sampler_views(ctx->blitter, - ctx->num_sampler_views[PIPE_SHADER_FRAGMENT], - ctx->sampler_views[PIPE_SHADER_FRAGMENT]); - util_blitter_save_fragment_constant_buffer_slot(ctx->blitter, ctx->cbufs[PIPE_SHADER_FRAGMENT]); + ctx->num_sampler_views[MESA_SHADER_FRAGMENT], + ctx->sampler_views[MESA_SHADER_FRAGMENT]); + util_blitter_save_fragment_constant_buffer_slot(ctx->blitter, ctx->cbufs[MESA_SHADER_FRAGMENT]); util_blitter_save_vertex_buffers(ctx->blitter, ctx->vbs, ctx->num_vbs); util_blitter_save_sample_mask(ctx->blitter, ctx->gfx_pipeline_state.sample_mask, 0); util_blitter_save_so_targets(ctx->blitter, ctx->gfx_pipeline_state.num_so_targets, ctx->so_targets, @@ -502,8 +502,8 @@ resolve_stencil_to_temp(struct d3d12_context *ctx, void *sampler_state = get_sampler_state(ctx); util_blit_save_state(ctx); - pctx->set_sampler_views(pctx, PIPE_SHADER_FRAGMENT, 0, 1, 0, &src_view); - pctx->bind_sampler_states(pctx, PIPE_SHADER_FRAGMENT, 0, 1, &sampler_state); + pctx->set_sampler_views(pctx, MESA_SHADER_FRAGMENT, 0, 1, 0, &src_view); + pctx->bind_sampler_states(pctx, MESA_SHADER_FRAGMENT, 0, 1, &sampler_state); util_blitter_custom_shader(ctx->blitter, &dst_tmpl, (uint16_t)pipe_surface_width(&dst_tmpl), (uint16_t)pipe_surface_height(&dst_tmpl), diff --git a/src/gallium/drivers/d3d12/d3d12_compiler.cpp b/src/gallium/drivers/d3d12/d3d12_compiler.cpp index 06b64777b74..c01d1393e14 100644 --- a/src/gallium/drivers/d3d12/d3d12_compiler.cpp +++ b/src/gallium/drivers/d3d12/d3d12_compiler.cpp @@ -120,14 +120,14 @@ compile_nir(struct d3d12_context *ctx, struct d3d12_shader_selector *sel, const struct dxil_nir_lower_loads_stores_options loads_stores_options = {}; NIR_PASS(_, nir, dxil_nir_lower_loads_stores_to_dxil, &loads_stores_options); - if (key->stage == PIPE_SHADER_FRAGMENT && key->fs.multisample_disabled) + if (key->stage == MESA_SHADER_FRAGMENT && key->fs.multisample_disabled) NIR_PASS(_, nir, d3d12_disable_multisampling); struct nir_to_dxil_options opts = {}; opts.interpolate_at_vertex = screen->have_load_at_vertex; opts.lower_int16 = !screen->opts4.Native16BitShaderOpsSupported; opts.last_ubo_is_not_arrayed = shader->num_state_vars > 0; - if (key->stage == PIPE_SHADER_FRAGMENT) + if (key->stage == MESA_SHADER_FRAGMENT) opts.provoking_vertex = key->fs.provoking_vertex; opts.input_clip_size = key->input_clip_size; opts.environment = DXIL_ENVIRONMENT_GL; @@ -234,7 +234,7 @@ missing_dual_src_outputs(struct d3d12_context *ctx) if (!ctx->gfx_pipeline_state.blend || !ctx->gfx_pipeline_state.blend->is_dual_src) return 0; - struct d3d12_shader_selector *fs = ctx->gfx_stages[PIPE_SHADER_FRAGMENT]; + struct d3d12_shader_selector *fs = ctx->gfx_stages[MESA_SHADER_FRAGMENT]; if (!fs) return 0; @@ -275,7 +275,7 @@ missing_dual_src_outputs(struct d3d12_context *ctx) static unsigned frag_result_color_lowering(struct d3d12_context *ctx) { - struct d3d12_shader_selector *fs = ctx->gfx_stages[PIPE_SHADER_FRAGMENT]; + struct d3d12_shader_selector *fs = ctx->gfx_stages[MESA_SHADER_FRAGMENT]; assert(fs); if (fs->initial->info.outputs_written & BITFIELD64_BIT(FRAG_RESULT_COLOR)) @@ -310,7 +310,7 @@ manual_depth_range(struct d3d12_context *ctx) * it. */ - struct d3d12_shader_selector *fs = ctx->gfx_stages[PIPE_SHADER_FRAGMENT]; + struct d3d12_shader_selector *fs = ctx->gfx_stages[MESA_SHADER_FRAGMENT]; return fs && fs->initial->info.inputs_read & VARYING_BIT_POS; } @@ -434,7 +434,7 @@ get_provoking_vertex(struct d3d12_selection_context *sel_ctx, bool *alternate, c bool has_flat_varyings(struct d3d12_context *ctx) { - struct d3d12_shader_selector *fs = ctx->gfx_stages[PIPE_SHADER_FRAGMENT]; + struct d3d12_shader_selector *fs = ctx->gfx_stages[MESA_SHADER_FRAGMENT]; if (!fs) return false; @@ -631,7 +631,7 @@ validate_geometry_shader_variant(struct d3d12_selection_context *sel_ctx) return; d3d12_shader_selector* vs = ctx->gfx_stages[MESA_SHADER_VERTEX]; - d3d12_shader_selector* fs = ctx->gfx_stages[PIPE_SHADER_FRAGMENT]; + d3d12_shader_selector* fs = ctx->gfx_stages[MESA_SHADER_FRAGMENT]; struct d3d12_gs_variant_key key; key.all = 0; @@ -730,7 +730,7 @@ d3d12_compare_shader_keys(struct d3d12_selection_context* sel_ctx, const d3d12_s expect->ds.prev_patch_outputs != have->ds.prev_patch_outputs) return false; break; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: if (expect->fs.all != have->fs.all) return false; break; @@ -808,7 +808,7 @@ d3d12_shader_key_hash(const d3d12_shader_key *key) case MESA_SHADER_GEOMETRY: hash += static_cast(key->gs.all); break; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: hash += key->fs.all; break; case PIPE_SHADER_COMPUTE: @@ -846,7 +846,7 @@ d3d12_fill_shader_key(struct d3d12_selection_context *sel_ctx, case MESA_SHADER_VERTEX: key->vs.needs_format_emulation = 0; break; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: key->fs.all = 0; break; case MESA_SHADER_GEOMETRY: @@ -879,7 +879,7 @@ d3d12_fill_shader_key(struct d3d12_selection_context *sel_ctx, /* Set the provoking vertex based on the previous shader output. Only set the * key value if the driver actually supports changing the provoking vertex though */ - if (stage == PIPE_SHADER_FRAGMENT && sel_ctx->ctx->gfx_pipeline_state.rast && + if (stage == MESA_SHADER_FRAGMENT && sel_ctx->ctx->gfx_pipeline_state.rast && !sel_ctx->needs_vertex_reordering && d3d12_screen(sel_ctx->ctx->base.screen)->have_load_at_vertex) key->fs.provoking_vertex = sel_ctx->provoking_vertex; @@ -888,7 +888,7 @@ d3d12_fill_shader_key(struct d3d12_selection_context *sel_ctx, * to the output, and in cases of TES or GS you could have differently-sized inputs * and outputs. For FS, there is no output, so it's repurposed to mean input. */ - if (stage != PIPE_SHADER_FRAGMENT) + if (stage != MESA_SHADER_FRAGMENT) key->input_clip_size = prev->initial->info.clip_distance_array_size; } @@ -904,7 +904,7 @@ d3d12_fill_shader_key(struct d3d12_selection_context *sel_ctx, if (stage == MESA_SHADER_GEOMETRY || ((stage == MESA_SHADER_VERTEX || stage == MESA_SHADER_TESS_EVAL) && - (!next || next->stage == PIPE_SHADER_FRAGMENT))) { + (!next || next->stage == MESA_SHADER_FRAGMENT))) { key->last_vertex_processing_stage = 1; key->invert_depth = sel_ctx->ctx->reverse_depth_range; key->halfz = sel_ctx->ctx->gfx_pipeline_state.rast ? @@ -937,7 +937,7 @@ d3d12_fill_shader_key(struct d3d12_selection_context *sel_ctx, if (next->initial->info.inputs_read & VARYING_BIT_PRIMITIVE_ID) key->gs.primitive_id = 1; } - } else if (stage == PIPE_SHADER_FRAGMENT) { + } else if (stage == MESA_SHADER_FRAGMENT) { key->fs.missing_dual_src_outputs = sel_ctx->missing_dual_src_outputs; key->fs.frag_result_color_lowering = sel_ctx->frag_result_color_lowering; key->fs.manual_depth_range = sel_ctx->manual_depth_range; @@ -1029,7 +1029,7 @@ d3d12_fill_shader_key(struct d3d12_selection_context *sel_ctx, } } - if (stage == PIPE_SHADER_FRAGMENT && + if (stage == MESA_SHADER_FRAGMENT && sel_ctx->ctx->gfx_stages[MESA_SHADER_GEOMETRY] && sel_ctx->ctx->gfx_stages[MESA_SHADER_GEOMETRY]->is_variant && sel_ctx->ctx->gfx_stages[MESA_SHADER_GEOMETRY]->gs_key.has_front_face) { @@ -1090,7 +1090,7 @@ select_shader_variant(struct d3d12_selection_context *sel_ctx, d3d12_shader_sele if (key.gs.triangle_strip) NIR_PASS(_, new_nir_variant, d3d12_lower_triangle_strip); } - else if (key.stage == PIPE_SHADER_FRAGMENT) + else if (key.stage == MESA_SHADER_FRAGMENT) { if (key.fs.polygon_stipple) { NIR_PASS(_, new_nir_variant, nir_lower_pstipple_fs, @@ -1125,7 +1125,7 @@ select_shader_variant(struct d3d12_selection_context *sel_ctx, d3d12_shader_sele false); } - if (key.stage == PIPE_SHADER_FRAGMENT) { + if (key.stage == MESA_SHADER_FRAGMENT) { if (key.fs.cast_to_uint) NIR_PASS(_, new_nir_variant, d3d12_lower_uint_cast, false); if (key.fs.cast_to_int) @@ -1202,7 +1202,7 @@ get_prev_shader(struct d3d12_context *ctx, pipe_shader_type current) switch (current) { case MESA_SHADER_VERTEX: return NULL; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: if (ctx->gfx_stages[MESA_SHADER_GEOMETRY]) return ctx->gfx_stages[MESA_SHADER_GEOMETRY]; FALLTHROUGH; @@ -1238,8 +1238,8 @@ get_next_shader(struct d3d12_context *ctx, pipe_shader_type current) return ctx->gfx_stages[MESA_SHADER_GEOMETRY]; FALLTHROUGH; case MESA_SHADER_GEOMETRY: - return ctx->gfx_stages[PIPE_SHADER_FRAGMENT]; - case PIPE_SHADER_FRAGMENT: + return ctx->gfx_stages[MESA_SHADER_FRAGMENT]; + case MESA_SHADER_FRAGMENT: return NULL; default: UNREACHABLE("shader type not supported"); @@ -1528,9 +1528,9 @@ d3d12_select_shader_variants(struct d3d12_context *ctx, const struct pipe_draw_i next = get_next_shader(ctx, MESA_SHADER_GEOMETRY); select_shader_variant(&sel_ctx, stages[MESA_SHADER_GEOMETRY], prev, next); } - if (stages[PIPE_SHADER_FRAGMENT]) { - prev = get_prev_shader(ctx, PIPE_SHADER_FRAGMENT); - select_shader_variant(&sel_ctx, stages[PIPE_SHADER_FRAGMENT], prev, nullptr); + if (stages[MESA_SHADER_FRAGMENT]) { + prev = get_prev_shader(ctx, MESA_SHADER_FRAGMENT); + select_shader_variant(&sel_ctx, stages[MESA_SHADER_FRAGMENT], prev, nullptr); } } diff --git a/src/gallium/drivers/d3d12/d3d12_context_graphics.cpp b/src/gallium/drivers/d3d12/d3d12_context_graphics.cpp index 0fa80da7661..f5a6e43ab62 100644 --- a/src/gallium/drivers/d3d12/d3d12_context_graphics.cpp +++ b/src/gallium/drivers/d3d12/d3d12_context_graphics.cpp @@ -1097,7 +1097,7 @@ static void * d3d12_create_fs_state(struct pipe_context *pctx, const struct pipe_shader_state *shader) { - return d3d12_create_shader(d3d12_context(pctx), PIPE_SHADER_FRAGMENT, shader); + return d3d12_create_shader(d3d12_context(pctx), MESA_SHADER_FRAGMENT, shader); } static void @@ -1105,7 +1105,7 @@ d3d12_bind_fs_state(struct pipe_context *pctx, void *fss) { struct d3d12_context* ctx = d3d12_context(pctx); - bind_stage(ctx, PIPE_SHADER_FRAGMENT, + bind_stage(ctx, MESA_SHADER_FRAGMENT, (struct d3d12_shader_selector *) fss); ctx->has_flat_varyings = has_flat_varyings(ctx); ctx->missing_dual_src_outputs = missing_dual_src_outputs(ctx) != 0; @@ -1116,7 +1116,7 @@ static void d3d12_delete_fs_state(struct pipe_context *pctx, void *fs) { - delete_shader(d3d12_context(pctx), PIPE_SHADER_FRAGMENT, + delete_shader(d3d12_context(pctx), MESA_SHADER_FRAGMENT, (struct d3d12_shader_selector *) fs); } @@ -1950,7 +1950,7 @@ d3d12_clear_render_target(struct pipe_context *pctx, util_blitter_save_vertex_elements(ctx->blitter, ctx->gfx_pipeline_state.ves); util_blitter_save_stencil_ref(ctx->blitter, &ctx->stencil_ref); util_blitter_save_rasterizer(ctx->blitter, ctx->gfx_pipeline_state.rast); - util_blitter_save_fragment_shader(ctx->blitter, ctx->gfx_stages[PIPE_SHADER_FRAGMENT]); + util_blitter_save_fragment_shader(ctx->blitter, ctx->gfx_stages[MESA_SHADER_FRAGMENT]); util_blitter_save_vertex_shader(ctx->blitter, ctx->gfx_stages[MESA_SHADER_VERTEX]); util_blitter_save_geometry_shader(ctx->blitter, ctx->gfx_stages[MESA_SHADER_GEOMETRY]); util_blitter_save_tessctrl_shader(ctx->blitter, ctx->gfx_stages[MESA_SHADER_TESS_CTRL]); @@ -1960,12 +1960,12 @@ d3d12_clear_render_target(struct pipe_context *pctx, util_blitter_save_viewport(ctx->blitter, ctx->viewport_states); util_blitter_save_scissor(ctx->blitter, ctx->scissor_states); util_blitter_save_fragment_sampler_states(ctx->blitter, - ctx->num_samplers[PIPE_SHADER_FRAGMENT], - (void **)ctx->samplers[PIPE_SHADER_FRAGMENT]); + ctx->num_samplers[MESA_SHADER_FRAGMENT], + (void **)ctx->samplers[MESA_SHADER_FRAGMENT]); util_blitter_save_fragment_sampler_views(ctx->blitter, - ctx->num_sampler_views[PIPE_SHADER_FRAGMENT], - ctx->sampler_views[PIPE_SHADER_FRAGMENT]); - util_blitter_save_fragment_constant_buffer_slot(ctx->blitter, ctx->cbufs[PIPE_SHADER_FRAGMENT]); + ctx->num_sampler_views[MESA_SHADER_FRAGMENT], + ctx->sampler_views[MESA_SHADER_FRAGMENT]); + util_blitter_save_fragment_constant_buffer_slot(ctx->blitter, ctx->cbufs[MESA_SHADER_FRAGMENT]); util_blitter_save_vertex_buffers(ctx->blitter, ctx->vbs, ctx->num_vbs); util_blitter_save_sample_mask(ctx->blitter, ctx->gfx_pipeline_state.sample_mask, 0); util_blitter_save_so_targets(ctx->blitter, ctx->gfx_pipeline_state.num_so_targets, ctx->so_targets, @@ -2165,7 +2165,7 @@ d3d12_set_tess_state(struct pipe_context *pctx, bool d3d12_need_zero_one_depth_range(struct d3d12_context *ctx) { - struct d3d12_shader_selector *fs = ctx->gfx_stages[PIPE_SHADER_FRAGMENT]; + struct d3d12_shader_selector *fs = ctx->gfx_stages[MESA_SHADER_FRAGMENT]; /** * OpenGL Compatibility spec, section 15.2.3 (Shader Outputs) says diff --git a/src/gallium/drivers/d3d12/d3d12_draw.cpp b/src/gallium/drivers/d3d12/d3d12_draw.cpp index 20cadadc851..97d5aa54fce 100644 --- a/src/gallium/drivers/d3d12/d3d12_draw.cpp +++ b/src/gallium/drivers/d3d12/d3d12_draw.cpp @@ -115,7 +115,7 @@ fill_srv_descriptors(struct d3d12_context *ctx, view->texture_generation_id = res->generation_id; } - D3D12_RESOURCE_STATES state = (stage == PIPE_SHADER_FRAGMENT) ? + D3D12_RESOURCE_STATES state = (stage == MESA_SHADER_FRAGMENT) ? D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE : D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE; if (view->base.texture->target == PIPE_BUFFER) { @@ -955,7 +955,7 @@ d3d12_draw_vbo(struct pipe_context *pctx, } if (ctx->pstipple.enabled && ctx->gfx_pipeline_state.rast->base.poly_stipple_enable) - ctx->shader_dirty[PIPE_SHADER_FRAGMENT] |= D3D12_SHADER_DIRTY_SAMPLER_VIEWS | + ctx->shader_dirty[MESA_SHADER_FRAGMENT] |= D3D12_SHADER_DIRTY_SAMPLER_VIEWS | D3D12_SHADER_DIRTY_SAMPLERS; /* this should *really* be fixed at a higher level than here! */ diff --git a/src/gallium/drivers/d3d12/d3d12_pipeline_state.cpp b/src/gallium/drivers/d3d12/d3d12_pipeline_state.cpp index 5dd51313188..d7be04ed5bf 100644 --- a/src/gallium/drivers/d3d12/d3d12_pipeline_state.cpp +++ b/src/gallium/drivers/d3d12/d3d12_pipeline_state.cpp @@ -308,9 +308,9 @@ create_gfx_pipeline_state(struct d3d12_context *ctx) } bool last_vertex_stage_writes_pos = (last_vertex_stage_nir->info.outputs_written & VARYING_BIT_POS) != 0; - if (last_vertex_stage_writes_pos && state->stages[PIPE_SHADER_FRAGMENT] && + if (last_vertex_stage_writes_pos && state->stages[MESA_SHADER_FRAGMENT] && !state->rast->base.rasterizer_discard) { - auto shader = state->stages[PIPE_SHADER_FRAGMENT]; + auto shader = state->stages[MESA_SHADER_FRAGMENT]; pso_desc.PS = D3D12_SHADER_BYTECODE{ shader->bytecode, shader->bytecode_length }; } diff --git a/src/gallium/drivers/d3d12/d3d12_root_signature.cpp b/src/gallium/drivers/d3d12/d3d12_root_signature.cpp index 967459ff1e1..b3e85508ec2 100644 --- a/src/gallium/drivers/d3d12/d3d12_root_signature.cpp +++ b/src/gallium/drivers/d3d12/d3d12_root_signature.cpp @@ -43,7 +43,7 @@ get_shader_visibility(enum pipe_shader_type stage) switch (stage) { case MESA_SHADER_VERTEX: return D3D12_SHADER_VISIBILITY_VERTEX; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: return D3D12_SHADER_VISIBILITY_PIXEL; case MESA_SHADER_GEOMETRY: return D3D12_SHADER_VISIBILITY_GEOMETRY; diff --git a/src/gallium/drivers/d3d12/d3d12_screen.cpp b/src/gallium/drivers/d3d12/d3d12_screen.cpp index b072ec13e56..0b792674d0a 100644 --- a/src/gallium/drivers/d3d12/d3d12_screen.cpp +++ b/src/gallium/drivers/d3d12/d3d12_screen.cpp @@ -142,7 +142,7 @@ d3d12_init_shader_caps(struct d3d12_screen *screen) caps->max_inputs = D3D12_VS_INPUT_REGISTER_COUNT; caps->max_outputs = D3D12_VS_OUTPUT_REGISTER_COUNT; break; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: caps->max_inputs = D3D12_PS_INPUT_REGISTER_COUNT; caps->max_outputs = D3D12_PS_OUTPUT_REGISTER_COUNT; break; diff --git a/src/gallium/drivers/etnaviv/etnaviv_clear_blit.c b/src/gallium/drivers/etnaviv/etnaviv_clear_blit.c index 1acf9a0b329..791fb886fd0 100644 --- a/src/gallium/drivers/etnaviv/etnaviv_clear_blit.c +++ b/src/gallium/drivers/etnaviv/etnaviv_clear_blit.c @@ -50,7 +50,7 @@ void etna_blit_save_state(struct etna_context *ctx, bool render_cond) { util_blitter_save_fragment_constant_buffer_slot(ctx->blitter, - ctx->constant_buffer[PIPE_SHADER_FRAGMENT].cb); + ctx->constant_buffer[MESA_SHADER_FRAGMENT].cb); util_blitter_save_vertex_buffers(ctx->blitter, ctx->vertex_buffer.vb, ctx->vertex_buffer.count); util_blitter_save_vertex_elements(ctx->blitter, ctx->vertex_elements); diff --git a/src/gallium/drivers/etnaviv/etnaviv_context.c b/src/gallium/drivers/etnaviv/etnaviv_context.c index 0ab0f5734b4..844b60effa4 100644 --- a/src/gallium/drivers/etnaviv/etnaviv_context.c +++ b/src/gallium/drivers/etnaviv/etnaviv_context.c @@ -346,8 +346,8 @@ etna_draw_vbo(struct pipe_context *pctx, const struct pipe_draw_info *info, u_foreach_bit(i, ctx->constant_buffer[MESA_SHADER_VERTEX].enabled_mask) resource_read(ctx, ctx->constant_buffer[MESA_SHADER_VERTEX].cb[i].buffer); - u_foreach_bit(i, ctx->constant_buffer[PIPE_SHADER_FRAGMENT].enabled_mask) - resource_read(ctx, ctx->constant_buffer[PIPE_SHADER_FRAGMENT].cb[i].buffer); + u_foreach_bit(i, ctx->constant_buffer[MESA_SHADER_FRAGMENT].enabled_mask) + resource_read(ctx, ctx->constant_buffer[MESA_SHADER_FRAGMENT].cb[i].buffer); } if (ctx->dirty & ETNA_DIRTY_VERTEX_BUFFERS) { diff --git a/src/gallium/drivers/etnaviv/etnaviv_emit.c b/src/gallium/drivers/etnaviv/etnaviv_emit.c index 1c43b365662..3bbf7e1d728 100644 --- a/src/gallium/drivers/etnaviv/etnaviv_emit.c +++ b/src/gallium/drivers/etnaviv/etnaviv_emit.c @@ -749,7 +749,7 @@ etna_emit_state(struct etna_context *ctx) if (need_steering) etna_set_state(stream, VIVS_SH_CONTROL, VIVS_SH_CONTROL_PS_UNIFORM); - etna_uniforms_write(ctx, ctx->shader.fs, ctx->constant_buffer[PIPE_SHADER_FRAGMENT].cb); + etna_uniforms_write(ctx, ctx->shader.fs, ctx->constant_buffer[MESA_SHADER_FRAGMENT].cb); if (screen->info->halti >= 5) { /* HALTI5 needs to be prompted to pre-fetch shaders */ @@ -770,7 +770,7 @@ etna_emit_state(struct etna_context *ctx) etna_set_state(stream, VIVS_SH_CONTROL, VIVS_SH_CONTROL_PS_UNIFORM); if (dirty & (uniform_dirty_bits | ctx->shader.fs->uniforms_dirty_bits)) - etna_uniforms_write(ctx, ctx->shader.fs, ctx->constant_buffer[PIPE_SHADER_FRAGMENT].cb); + etna_uniforms_write(ctx, ctx->shader.fs, ctx->constant_buffer[MESA_SHADER_FRAGMENT].cb); } /**** End of state update ****/ #undef EMIT_STATE diff --git a/src/gallium/drivers/etnaviv/etnaviv_screen.c b/src/gallium/drivers/etnaviv/etnaviv_screen.c index 5da4ab6dd69..cce55e727c6 100644 --- a/src/gallium/drivers/etnaviv/etnaviv_screen.c +++ b/src/gallium/drivers/etnaviv/etnaviv_screen.c @@ -171,7 +171,7 @@ etna_init_single_shader_caps(struct etna_screen *screen, enum pipe_shader_type s * of vertex elements - each element defines one vertex shader * input register. For the fragment shader, this is the number * of varyings. */ - caps->max_inputs = shader == PIPE_SHADER_FRAGMENT ? + caps->max_inputs = shader == MESA_SHADER_FRAGMENT ? screen->specs.max_varyings : screen->specs.vertex_max_elements; caps->max_outputs = screen->specs.max_vs_outputs; caps->max_temps = 64; /* Max native temporaries. */ @@ -183,13 +183,13 @@ etna_init_single_shader_caps(struct etna_screen *screen, enum pipe_shader_type s caps->integers = screen->info->halti >= 2; caps->max_texture_samplers = - caps->max_sampler_views = shader == PIPE_SHADER_FRAGMENT + caps->max_sampler_views = shader == MESA_SHADER_FRAGMENT ? screen->specs.fragment_sampler_count : screen->specs.vertex_sampler_count; caps->max_const_buffer0_size = ubo_enable ? 16384 /* 16384 so state tracker enables UBOs */ : - (shader == PIPE_SHADER_FRAGMENT + (shader == MESA_SHADER_FRAGMENT ? screen->specs.max_ps_uniforms * sizeof(float[4]) : screen->specs.max_vs_uniforms * sizeof(float[4])); @@ -202,7 +202,7 @@ static void etna_init_shader_caps(struct etna_screen *screen) { etna_init_single_shader_caps(screen, MESA_SHADER_VERTEX); - etna_init_single_shader_caps(screen, PIPE_SHADER_FRAGMENT); + etna_init_single_shader_caps(screen, MESA_SHADER_FRAGMENT); } static void diff --git a/src/gallium/drivers/etnaviv/etnaviv_texture.c b/src/gallium/drivers/etnaviv/etnaviv_texture.c index 9b02ee9462c..1decf02b516 100644 --- a/src/gallium/drivers/etnaviv/etnaviv_texture.c +++ b/src/gallium/drivers/etnaviv/etnaviv_texture.c @@ -50,7 +50,7 @@ etna_bind_sampler_states(struct pipe_context *pctx, enum pipe_shader_type shader int offset; switch (shader) { - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: offset = 0; ctx->num_fragment_samplers = num_samplers; break; @@ -331,7 +331,7 @@ etna_set_sampler_views(struct pipe_context *pctx, enum pipe_shader_type shader, ctx->dirty |= ETNA_DIRTY_SAMPLER_VIEWS | ETNA_DIRTY_TEXTURE_CACHES; switch (shader) { - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: etna_fragtex_set_sampler_views(ctx, num_views, views); break; case MESA_SHADER_VERTEX: diff --git a/src/gallium/drivers/freedreno/a2xx/fd2_draw.c b/src/gallium/drivers/freedreno/a2xx/fd2_draw.c index decbaadd957..c7ee307d6d7 100644 --- a/src/gallium/drivers/freedreno/a2xx/fd2_draw.c +++ b/src/gallium/drivers/freedreno/a2xx/fd2_draw.c @@ -638,7 +638,7 @@ dirty: FD_DIRTY_BLEND | FD_DIRTY_FRAMEBUFFER | FD_DIRTY_SCISSOR; ctx->dirty_shader[MESA_SHADER_VERTEX] |= FD_DIRTY_SHADER_PROG; - ctx->dirty_shader[PIPE_SHADER_FRAGMENT] |= + ctx->dirty_shader[MESA_SHADER_FRAGMENT] |= FD_DIRTY_SHADER_PROG | FD_DIRTY_SHADER_CONST; return true; diff --git a/src/gallium/drivers/freedreno/a2xx/fd2_emit.c b/src/gallium/drivers/freedreno/a2xx/fd2_emit.c index ef8344aedc8..da5c99188e7 100644 --- a/src/gallium/drivers/freedreno/a2xx/fd2_emit.c +++ b/src/gallium/drivers/freedreno/a2xx/fd2_emit.c @@ -137,7 +137,7 @@ emit_texture(struct fd_ringbuffer *ring, struct fd_context *ctx, static void emit_textures(struct fd_ringbuffer *ring, struct fd_context *ctx) { - struct fd_texture_stateobj *fragtex = &ctx->tex[PIPE_SHADER_FRAGMENT]; + struct fd_texture_stateobj *fragtex = &ctx->tex[MESA_SHADER_FRAGMENT]; struct fd_texture_stateobj *verttex = &ctx->tex[MESA_SHADER_VERTEX]; texmask emitted = 0; unsigned i; @@ -351,7 +351,7 @@ fd2_emit_state(struct fd_context *ctx, const enum fd_dirty_3d_state dirty) &ctx->constbuf[MESA_SHADER_VERTEX], (dirty & FD_DIRTY_PROG) ? ctx->prog.vs : NULL); emit_constants(ring, PS_CONST_BASE * 4, - &ctx->constbuf[PIPE_SHADER_FRAGMENT], + &ctx->constbuf[MESA_SHADER_FRAGMENT], (dirty & FD_DIRTY_PROG) ? ctx->prog.fs : NULL); } diff --git a/src/gallium/drivers/freedreno/a2xx/fd2_program.c b/src/gallium/drivers/freedreno/a2xx/fd2_program.c index 9a0048d80d2..9a6f5b944cd 100644 --- a/src/gallium/drivers/freedreno/a2xx/fd2_program.c +++ b/src/gallium/drivers/freedreno/a2xx/fd2_program.c @@ -177,7 +177,7 @@ fd2_program_emit(struct fd_context *ctx, struct fd_ringbuffer *ring, if (prog != &ctx->solid_prog && prog != &ctx->blit_prog[0]) { patch_fetches(ctx, vpi, ctx->vtx.vtx, &ctx->tex[MESA_SHADER_VERTEX]); if (fp) - patch_fetches(ctx, fpi, NULL, &ctx->tex[PIPE_SHADER_FRAGMENT]); + patch_fetches(ctx, fpi, NULL, &ctx->tex[MESA_SHADER_FRAGMENT]); } emit(ring, MESA_SHADER_VERTEX, vpi, diff --git a/src/gallium/drivers/freedreno/a2xx/fd2_texture.c b/src/gallium/drivers/freedreno/a2xx/fd2_texture.c index b953e394977..cad8406f767 100644 --- a/src/gallium/drivers/freedreno/a2xx/fd2_texture.c +++ b/src/gallium/drivers/freedreno/a2xx/fd2_texture.c @@ -109,14 +109,14 @@ fd2_sampler_states_bind(struct pipe_context *pctx, enum pipe_shader_type shader, if (!hwcso) nr = 0; - if (shader == PIPE_SHADER_FRAGMENT) { + if (shader == MESA_SHADER_FRAGMENT) { struct fd_context *ctx = fd_context(pctx); /* on a2xx, since there is a flat address space for textures/samplers, * a change in # of fragment textures/samplers will trigger patching and * re-emitting the vertex shader: */ - if (nr != ctx->tex[PIPE_SHADER_FRAGMENT].num_samplers) + if (nr != ctx->tex[MESA_SHADER_FRAGMENT].num_samplers) ctx->dirty |= FD_DIRTY_TEXSTATE; } @@ -188,14 +188,14 @@ fd2_set_sampler_views(struct pipe_context *pctx, enum pipe_shader_type shader, unsigned unbind_num_trailing_slots, struct pipe_sampler_view **views) in_dt { - if (shader == PIPE_SHADER_FRAGMENT) { + if (shader == MESA_SHADER_FRAGMENT) { struct fd_context *ctx = fd_context(pctx); /* on a2xx, since there is a flat address space for textures/samplers, * a change in # of fragment textures/samplers will trigger patching and * re-emitting the vertex shader: */ - if (nr != ctx->tex[PIPE_SHADER_FRAGMENT].num_textures) + if (nr != ctx->tex[MESA_SHADER_FRAGMENT].num_textures) ctx->dirty |= FD_DIRTY_TEXSTATE; } @@ -218,9 +218,9 @@ unsigned fd2_get_const_idx(struct fd_context *ctx, struct fd_texture_stateobj *tex, unsigned samp_id) assert_dt { - if (tex == &ctx->tex[PIPE_SHADER_FRAGMENT]) + if (tex == &ctx->tex[MESA_SHADER_FRAGMENT]) return samp_id; - return samp_id + ctx->tex[PIPE_SHADER_FRAGMENT].num_samplers; + return samp_id + ctx->tex[MESA_SHADER_FRAGMENT].num_samplers; } void diff --git a/src/gallium/drivers/freedreno/a3xx/fd3_emit.c b/src/gallium/drivers/freedreno/a3xx/fd3_emit.c index 80ec5d1a840..7ff0eb670c8 100644 --- a/src/gallium/drivers/freedreno/a3xx/fd3_emit.c +++ b/src/gallium/drivers/freedreno/a3xx/fd3_emit.c @@ -813,8 +813,8 @@ fd3_emit_state(struct fd_context *ctx, struct fd_ringbuffer *ring, if (ctx->dirty_shader[MESA_SHADER_VERTEX] & FD_DIRTY_SHADER_TEX) emit_textures(ctx, ring, SB_VERT_TEX, &ctx->tex[MESA_SHADER_VERTEX]); - if (ctx->dirty_shader[PIPE_SHADER_FRAGMENT] & FD_DIRTY_SHADER_TEX) - emit_textures(ctx, ring, SB_FRAG_TEX, &ctx->tex[PIPE_SHADER_FRAGMENT]); + if (ctx->dirty_shader[MESA_SHADER_FRAGMENT] & FD_DIRTY_SHADER_TEX) + emit_textures(ctx, ring, SB_FRAG_TEX, &ctx->tex[MESA_SHADER_FRAGMENT]); } /* emit setup at begin of new cmdstream buffer (don't rely on previous diff --git a/src/gallium/drivers/freedreno/a4xx/fd4_emit.c b/src/gallium/drivers/freedreno/a4xx/fd4_emit.c index 3c17ef6b4c5..51f99507ebf 100644 --- a/src/gallium/drivers/freedreno/a4xx/fd4_emit.c +++ b/src/gallium/drivers/freedreno/a4xx/fd4_emit.c @@ -897,15 +897,15 @@ fd4_emit_state(struct fd_context *ctx, struct fd_ringbuffer *ring, if (ctx->dirty_shader[MESA_SHADER_VERTEX] & FD_DIRTY_SHADER_TEX) emit_textures(ctx, ring, SB4_VS_TEX, &ctx->tex[MESA_SHADER_VERTEX], vp); - if (ctx->dirty_shader[PIPE_SHADER_FRAGMENT] & FD_DIRTY_SHADER_TEX) - emit_textures(ctx, ring, SB4_FS_TEX, &ctx->tex[PIPE_SHADER_FRAGMENT], fp); + if (ctx->dirty_shader[MESA_SHADER_FRAGMENT] & FD_DIRTY_SHADER_TEX) + emit_textures(ctx, ring, SB4_FS_TEX, &ctx->tex[MESA_SHADER_FRAGMENT], fp); if (!emit->binning_pass) { - if (ctx->dirty_shader[PIPE_SHADER_FRAGMENT] & FD_DIRTY_SHADER_SSBO) - emit_ssbos(ctx, ring, SB4_SSBO, &ctx->shaderbuf[PIPE_SHADER_FRAGMENT]); + if (ctx->dirty_shader[MESA_SHADER_FRAGMENT] & FD_DIRTY_SHADER_SSBO) + emit_ssbos(ctx, ring, SB4_SSBO, &ctx->shaderbuf[MESA_SHADER_FRAGMENT]); - if (ctx->dirty_shader[PIPE_SHADER_FRAGMENT] & FD_DIRTY_SHADER_IMAGE) - fd4_emit_images(ctx, ring, PIPE_SHADER_FRAGMENT, fp); + if (ctx->dirty_shader[MESA_SHADER_FRAGMENT] & FD_DIRTY_SHADER_IMAGE) + fd4_emit_images(ctx, ring, MESA_SHADER_FRAGMENT, fp); } } diff --git a/src/gallium/drivers/freedreno/a4xx/fd4_image.c b/src/gallium/drivers/freedreno/a4xx/fd4_image.c index 0daffa73108..82cdd870030 100644 --- a/src/gallium/drivers/freedreno/a4xx/fd4_image.c +++ b/src/gallium/drivers/freedreno/a4xx/fd4_image.c @@ -15,12 +15,12 @@ static enum a4xx_state_block texsb[] = { [PIPE_SHADER_COMPUTE] = SB4_CS_TEX, - [PIPE_SHADER_FRAGMENT] = SB4_FS_TEX, + [MESA_SHADER_FRAGMENT] = SB4_FS_TEX, }; static enum a4xx_state_block imgsb[] = { [PIPE_SHADER_COMPUTE] = SB4_CS_SSBO, - [PIPE_SHADER_FRAGMENT] = SB4_SSBO, + [MESA_SHADER_FRAGMENT] = SB4_SSBO, }; struct fd4_image { diff --git a/src/gallium/drivers/freedreno/a4xx/fd4_texture.c b/src/gallium/drivers/freedreno/a4xx/fd4_texture.c index 60a42ce409a..ef0df31888b 100644 --- a/src/gallium/drivers/freedreno/a4xx/fd4_texture.c +++ b/src/gallium/drivers/freedreno/a4xx/fd4_texture.c @@ -224,7 +224,7 @@ fd4_set_sampler_views(struct pipe_context *pctx, enum pipe_shader_type shader, uint16_t *sampler_swizzles; unsigned i; - if (shader == PIPE_SHADER_FRAGMENT) { + if (shader == MESA_SHADER_FRAGMENT) { sampler_swizzles = fd4_ctx->fsampler_swizzles; } else if (shader == MESA_SHADER_VERTEX) { sampler_swizzles = fd4_ctx->vsampler_swizzles; @@ -274,7 +274,7 @@ fd4_set_sampler_views(struct pipe_context *pctx, enum pipe_shader_type shader, sampler_swizzles[start + nr + i] = 0x688; } - if (shader == PIPE_SHADER_FRAGMENT) { + if (shader == MESA_SHADER_FRAGMENT) { fd4_ctx->fastc_srgb = astc_srgb; } else if (shader == MESA_SHADER_VERTEX) { fd4_ctx->vastc_srgb = astc_srgb; diff --git a/src/gallium/drivers/freedreno/a5xx/fd5_emit.c b/src/gallium/drivers/freedreno/a5xx/fd5_emit.c index e53ba36c4d6..24e0f400deb 100644 --- a/src/gallium/drivers/freedreno/a5xx/fd5_emit.c +++ b/src/gallium/drivers/freedreno/a5xx/fd5_emit.c @@ -301,7 +301,7 @@ emit_border_color(struct fd_context *ctx, struct fd_ringbuffer *ring) assert_dt entries = ptr; setup_border_colors(&ctx->tex[MESA_SHADER_VERTEX], &entries[0]); - setup_border_colors(&ctx->tex[PIPE_SHADER_FRAGMENT], + setup_border_colors(&ctx->tex[MESA_SHADER_FRAGMENT], &entries[ctx->tex[MESA_SHADER_VERTEX].num_samplers]); OUT_PKT4(ring, REG_A5XX_TPL1_TP_BORDER_COLOR_BASE_ADDR_LO, 2); @@ -829,15 +829,15 @@ fd5_emit_state(struct fd_context *ctx, struct fd_ringbuffer *ring, OUT_RING(ring, ctx->tex[MESA_SHADER_VERTEX].num_textures); } - if (ctx->dirty_shader[PIPE_SHADER_FRAGMENT] & FD_DIRTY_SHADER_TEX) { + if (ctx->dirty_shader[MESA_SHADER_FRAGMENT] & FD_DIRTY_SHADER_TEX) { needs_border |= - emit_textures(ctx, ring, SB4_FS_TEX, &ctx->tex[PIPE_SHADER_FRAGMENT]); + emit_textures(ctx, ring, SB4_FS_TEX, &ctx->tex[MESA_SHADER_FRAGMENT]); } OUT_PKT4(ring, REG_A5XX_TPL1_FS_TEX_COUNT, 1); - OUT_RING(ring, ctx->shaderimg[PIPE_SHADER_FRAGMENT].enabled_mask + OUT_RING(ring, ctx->shaderimg[MESA_SHADER_FRAGMENT].enabled_mask ? ~0 - : ctx->tex[PIPE_SHADER_FRAGMENT].num_textures); + : ctx->tex[MESA_SHADER_FRAGMENT].num_textures); OUT_PKT4(ring, REG_A5XX_TPL1_CS_TEX_COUNT, 1); OUT_RING(ring, 0); @@ -846,12 +846,12 @@ fd5_emit_state(struct fd_context *ctx, struct fd_ringbuffer *ring, emit_border_color(ctx, ring); if (!emit->binning_pass) { - if (ctx->dirty_shader[PIPE_SHADER_FRAGMENT] & FD_DIRTY_SHADER_SSBO) - emit_ssbos(ctx, ring, SB4_SSBO, &ctx->shaderbuf[PIPE_SHADER_FRAGMENT], + if (ctx->dirty_shader[MESA_SHADER_FRAGMENT] & FD_DIRTY_SHADER_SSBO) + emit_ssbos(ctx, ring, SB4_SSBO, &ctx->shaderbuf[MESA_SHADER_FRAGMENT], fp); - if (ctx->dirty_shader[PIPE_SHADER_FRAGMENT] & FD_DIRTY_SHADER_IMAGE) - fd5_emit_images(ctx, ring, PIPE_SHADER_FRAGMENT, fp); + if (ctx->dirty_shader[MESA_SHADER_FRAGMENT] & FD_DIRTY_SHADER_IMAGE) + fd5_emit_images(ctx, ring, MESA_SHADER_FRAGMENT, fp); } } diff --git a/src/gallium/drivers/freedreno/a5xx/fd5_image.c b/src/gallium/drivers/freedreno/a5xx/fd5_image.c index 9695e8afd62..d732f7dd069 100644 --- a/src/gallium/drivers/freedreno/a5xx/fd5_image.c +++ b/src/gallium/drivers/freedreno/a5xx/fd5_image.c @@ -15,12 +15,12 @@ static enum a4xx_state_block texsb[] = { [PIPE_SHADER_COMPUTE] = SB4_CS_TEX, - [PIPE_SHADER_FRAGMENT] = SB4_FS_TEX, + [MESA_SHADER_FRAGMENT] = SB4_FS_TEX, }; static enum a4xx_state_block imgsb[] = { [PIPE_SHADER_COMPUTE] = SB4_CS_SSBO, - [PIPE_SHADER_FRAGMENT] = SB4_SSBO, + [MESA_SHADER_FRAGMENT] = SB4_SSBO, }; struct fd5_image { diff --git a/src/gallium/drivers/freedreno/a6xx/fd6_const.cc b/src/gallium/drivers/freedreno/a6xx/fd6_const.cc index 677b02d4d77..4f2f80f7ac0 100644 --- a/src/gallium/drivers/freedreno/a6xx/fd6_const.cc +++ b/src/gallium/drivers/freedreno/a6xx/fd6_const.cc @@ -358,7 +358,7 @@ fd6_build_user_consts(struct fd6_emit *emit) emit_user_consts(emit->gs, constobj, &ctx->constbuf[MESA_SHADER_GEOMETRY]); } } - emit_user_consts(emit->fs, constobj, &ctx->constbuf[PIPE_SHADER_FRAGMENT]); + emit_user_consts(emit->fs, constobj, &ctx->constbuf[MESA_SHADER_FRAGMENT]); return constobj; } diff --git a/src/gallium/drivers/freedreno/a6xx/fd6_context.cc b/src/gallium/drivers/freedreno/a6xx/fd6_context.cc index 932c5457a77..1b7d21f1de6 100644 --- a/src/gallium/drivers/freedreno/a6xx/fd6_context.cc +++ b/src/gallium/drivers/freedreno/a6xx/fd6_context.cc @@ -185,7 +185,7 @@ setup_state_map(struct fd_context *ctx) BIT(FD6_GROUP_DS_TEX)); fd_context_add_shader_map(ctx, MESA_SHADER_GEOMETRY, FD_DIRTY_SHADER_TEX, BIT(FD6_GROUP_GS_TEX)); - fd_context_add_shader_map(ctx, PIPE_SHADER_FRAGMENT, FD_DIRTY_SHADER_TEX, + fd_context_add_shader_map(ctx, MESA_SHADER_FRAGMENT, FD_DIRTY_SHADER_TEX, BIT(FD6_GROUP_FS_TEX)); fd_context_add_shader_map(ctx, PIPE_SHADER_COMPUTE, FD_DIRTY_SHADER_TEX, BIT(FD6_GROUP_CS_TEX)); @@ -206,13 +206,13 @@ setup_state_map(struct fd_context *ctx) * state (ie. it needs to be re-generated with fb-read descriptor * patched in) but this special case is handled in fd6_emit_3d_state() */ - fd_context_add_shader_map(ctx, PIPE_SHADER_FRAGMENT, + fd_context_add_shader_map(ctx, MESA_SHADER_FRAGMENT, FD_DIRTY_SHADER_SSBO | FD_DIRTY_SHADER_IMAGE, BIT(FD6_GROUP_FS_BINDLESS)); fd_context_add_shader_map(ctx, PIPE_SHADER_COMPUTE, FD_DIRTY_SHADER_SSBO | FD_DIRTY_SHADER_IMAGE, BIT(FD6_GROUP_CS_BINDLESS)); - fd_context_add_shader_map(ctx, PIPE_SHADER_FRAGMENT, + fd_context_add_shader_map(ctx, MESA_SHADER_FRAGMENT, FD_DIRTY_SHADER_PROG, BIT(FD6_GROUP_PRIM_MODE_SYSMEM) | BIT(FD6_GROUP_PRIM_MODE_GMEM)); diff --git a/src/gallium/drivers/freedreno/a6xx/fd6_emit.cc b/src/gallium/drivers/freedreno/a6xx/fd6_emit.cc index 3f3bd00c5f0..46b2e48e75d 100644 --- a/src/gallium/drivers/freedreno/a6xx/fd6_emit.cc +++ b/src/gallium/drivers/freedreno/a6xx/fd6_emit.cc @@ -675,7 +675,7 @@ fd6_emit_3d_state(struct fd_ringbuffer *ring, struct fd6_emit *emit) fd6_state_take_group(&emit->state, state, FD6_GROUP_GS_BINDLESS); break; case FD6_GROUP_FS_BINDLESS: - state = fd6_build_bindless_state(ctx, PIPE_SHADER_FRAGMENT, fs->fb_read); + state = fd6_build_bindless_state(ctx, MESA_SHADER_FRAGMENT, fs->fb_read); fd6_state_take_group(&emit->state, state, FD6_GROUP_FS_BINDLESS); break; case FD6_GROUP_CONST: @@ -709,7 +709,7 @@ fd6_emit_3d_state(struct fd_ringbuffer *ring, struct fd6_emit *emit) fd6_state_take_group(&emit->state, state, FD6_GROUP_GS_TEX); break; case FD6_GROUP_FS_TEX: - state = tex_state(ctx, PIPE_SHADER_FRAGMENT); + state = tex_state(ctx, MESA_SHADER_FRAGMENT); fd6_state_take_group(&emit->state, state, FD6_GROUP_FS_TEX); break; case FD6_GROUP_SO: diff --git a/src/gallium/drivers/freedreno/a6xx/fd6_texture.cc b/src/gallium/drivers/freedreno/a6xx/fd6_texture.cc index 06d3b6a20e9..3393139d85d 100644 --- a/src/gallium/drivers/freedreno/a6xx/fd6_texture.cc +++ b/src/gallium/drivers/freedreno/a6xx/fd6_texture.cc @@ -638,7 +638,7 @@ build_texture_state(struct fd_context *ctx, enum pipe_shader_type type, tex_const_reg = REG_A6XX_SP_GS_TEXMEMOBJ_BASE; tex_count_reg = REG_A6XX_SP_GS_TSIZE; break; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: sb = SB6_FS_TEX; opcode = CP_LOAD_STATE6_FRAG; tex_samp_reg = REG_A6XX_SP_PS_SAMPLER_BASE; diff --git a/src/gallium/drivers/freedreno/freedreno_blitter.c b/src/gallium/drivers/freedreno/freedreno_blitter.c index ee39d8cba09..0c2cd7df347 100644 --- a/src/gallium/drivers/freedreno/freedreno_blitter.c +++ b/src/gallium/drivers/freedreno/freedreno_blitter.c @@ -87,13 +87,13 @@ fd_blitter_pipe_begin(struct fd_context *ctx, bool render_cond) assert_dt util_blitter_save_sample_mask(ctx->blitter, ctx->sample_mask, 1 /* min_samples -- unused in freedreno */); util_blitter_save_framebuffer(ctx->blitter, &ctx->framebuffer); util_blitter_save_fragment_sampler_states( - ctx->blitter, ctx->tex[PIPE_SHADER_FRAGMENT].num_samplers, - (void **)ctx->tex[PIPE_SHADER_FRAGMENT].samplers); + ctx->blitter, ctx->tex[MESA_SHADER_FRAGMENT].num_samplers, + (void **)ctx->tex[MESA_SHADER_FRAGMENT].samplers); util_blitter_save_fragment_sampler_views( - ctx->blitter, ctx->tex[PIPE_SHADER_FRAGMENT].num_textures, - ctx->tex[PIPE_SHADER_FRAGMENT].textures); + ctx->blitter, ctx->tex[MESA_SHADER_FRAGMENT].num_textures, + ctx->tex[MESA_SHADER_FRAGMENT].textures); util_blitter_save_fragment_constant_buffer_slot(ctx->blitter, - ctx->constbuf[PIPE_SHADER_FRAGMENT].cb); + ctx->constbuf[MESA_SHADER_FRAGMENT].cb); if (!render_cond) util_blitter_save_render_condition(ctx->blitter, ctx->cond_query, ctx->cond_cond, ctx->cond_mode); @@ -158,7 +158,7 @@ build_f16_copy_fs_shader(struct pipe_screen *pscreen, enum pipe_texture_target t [PIPE_TEXTURE_CUBE_ARRAY] = GLSL_SAMPLER_DIM_CUBE, }; - const nir_shader_compiler_options *options = pscreen->nir_options[PIPE_SHADER_FRAGMENT]; + const nir_shader_compiler_options *options = pscreen->nir_options[MESA_SHADER_FRAGMENT]; nir_builder _b = nir_builder_init_simple_shader(MESA_SHADER_FRAGMENT, options, "f16 copy %s fs", @@ -292,7 +292,7 @@ fd_blitter_clear(struct pipe_context *pctx, unsigned buffers, .buffer_size = 16, .user_buffer = &color->ui, }; - pctx->set_constant_buffer(pctx, PIPE_SHADER_FRAGMENT, 0, false, &cb); + pctx->set_constant_buffer(pctx, MESA_SHADER_FRAGMENT, 0, false, &cb); unsigned rs_idx = pfb->samples > 1 ? 1 : 0; if (!ctx->clear_rs_state[rs_idx]) { diff --git a/src/gallium/drivers/freedreno/freedreno_program.c b/src/gallium/drivers/freedreno/freedreno_program.c index b2b7d8fe16d..fbb82339ab6 100644 --- a/src/gallium/drivers/freedreno/freedreno_program.c +++ b/src/gallium/drivers/freedreno/freedreno_program.c @@ -108,8 +108,8 @@ fd_fs_state_bind(struct pipe_context *pctx, void *hwcso) in_dt { struct fd_context *ctx = fd_context(pctx); ctx->prog.fs = hwcso; - fd_context_dirty_shader(ctx, PIPE_SHADER_FRAGMENT, FD_DIRTY_SHADER_PROG); - update_bound_stage(ctx, PIPE_SHADER_FRAGMENT, !!hwcso); + fd_context_dirty_shader(ctx, MESA_SHADER_FRAGMENT, FD_DIRTY_SHADER_PROG); + update_bound_stage(ctx, MESA_SHADER_FRAGMENT, !!hwcso); } static const char *solid_fs = "FRAG \n" @@ -187,7 +187,7 @@ fd_prog_blit_fs(struct pipe_context *pctx, int rts, bool depth) assert(rts <= MAX_RENDER_TARGETS); - ureg = ureg_create(PIPE_SHADER_FRAGMENT); + ureg = ureg_create(MESA_SHADER_FRAGMENT); if (!ureg) return NULL; diff --git a/src/gallium/drivers/freedreno/freedreno_screen.c b/src/gallium/drivers/freedreno/freedreno_screen.c index edb788e0c55..126df86a441 100644 --- a/src/gallium/drivers/freedreno/freedreno_screen.c +++ b/src/gallium/drivers/freedreno/freedreno_screen.c @@ -261,7 +261,7 @@ fd_init_shader_caps(struct fd_screen *screen) caps->int16 = caps->fp16 = (is_a5xx(screen) || is_a6xx(screen)) && - (i == PIPE_SHADER_COMPUTE || i == PIPE_SHADER_FRAGMENT) && + (i == PIPE_SHADER_COMPUTE || i == MESA_SHADER_FRAGMENT) && !FD_DBG(NOFP16); caps->glsl_16bit_load_dst = true; @@ -272,7 +272,7 @@ fd_init_shader_caps(struct fd_screen *screen) (1 << PIPE_SHADER_IR_NIR) | /* tgsi_to_nir doesn't support all stages: */ COND(i == MESA_SHADER_VERTEX || - i == PIPE_SHADER_FRAGMENT || + i == MESA_SHADER_FRAGMENT || i == PIPE_SHADER_COMPUTE, 1 << PIPE_SHADER_IR_TGSI); @@ -302,7 +302,7 @@ fd_init_shader_caps(struct fd_screen *screen) * but images also need texture state for read access * (isam/isam.3d) */ - if (i == PIPE_SHADER_FRAGMENT || i == PIPE_SHADER_COMPUTE) { + if (i == MESA_SHADER_FRAGMENT || i == PIPE_SHADER_COMPUTE) { caps->max_shader_buffers = caps->max_shader_images = 24; } diff --git a/src/gallium/drivers/freedreno/ir3/ir3_const.h b/src/gallium/drivers/freedreno/ir3/ir3_const.h index 45f9dd7b816..80f04808602 100644 --- a/src/gallium/drivers/freedreno/ir3/ir3_const.h +++ b/src/gallium/drivers/freedreno/ir3/ir3_const.h @@ -587,7 +587,7 @@ ir3_emit_fs_consts(const struct ir3_shader_variant *v, { assert(v->type == MESA_SHADER_FRAGMENT); - emit_common_consts(v, ring, ctx, PIPE_SHADER_FRAGMENT); + emit_common_consts(v, ring, ctx, MESA_SHADER_FRAGMENT); } static inline struct ir3_driver_params_cs diff --git a/src/gallium/drivers/freedreno/ir3/ir3_descriptor.h b/src/gallium/drivers/freedreno/ir3/ir3_descriptor.h index d95d475eee4..5b38384f2bb 100644 --- a/src/gallium/drivers/freedreno/ir3/ir3_descriptor.h +++ b/src/gallium/drivers/freedreno/ir3/ir3_descriptor.h @@ -39,7 +39,7 @@ ir3_shader_descriptor_set(enum pipe_shader_type shader) case MESA_SHADER_TESS_CTRL: return 1; case MESA_SHADER_TESS_EVAL: return 2; case MESA_SHADER_GEOMETRY: return 3; - case PIPE_SHADER_FRAGMENT: return 4; + case MESA_SHADER_FRAGMENT: return 4; case PIPE_SHADER_COMPUTE: return 0; case MESA_SHADER_KERNEL: return 0; default: diff --git a/src/gallium/drivers/freedreno/ir3/ir3_gallium.c b/src/gallium/drivers/freedreno/ir3/ir3_gallium.c index 94b6a47d4bb..65486d685e6 100644 --- a/src/gallium/drivers/freedreno/ir3/ir3_gallium.c +++ b/src/gallium/drivers/freedreno/ir3/ir3_gallium.c @@ -464,7 +464,7 @@ ir3_fixup_shader_state(struct pipe_context *pctx, struct ir3_shader_key *key) if (!ir3_shader_key_equal(ctx->last.key, key)) { if (ir3_shader_key_changes_fs(ctx->last.key, key)) { - fd_context_dirty_shader(ctx, PIPE_SHADER_FRAGMENT, + fd_context_dirty_shader(ctx, MESA_SHADER_FRAGMENT, FD_DIRTY_SHADER_PROG); } @@ -542,7 +542,7 @@ ir3_screen_init(struct pipe_screen *pscreen) struct ir3_compiler_options options = { .bindless_fb_read_descriptor = - ir3_shader_descriptor_set(PIPE_SHADER_FRAGMENT), + ir3_shader_descriptor_set(MESA_SHADER_FRAGMENT), .bindless_fb_read_slot = IR3_BINDLESS_IMAGE_OFFSET + IR3_BINDLESS_IMAGE_COUNT - 1 - screen->max_rts, .dual_color_blend_by_location = screen->driconf.dual_color_blend_by_location, diff --git a/src/gallium/drivers/i915/i915_screen.c b/src/gallium/drivers/i915/i915_screen.c index 6cb1fc691ef..f38d7c36fc1 100644 --- a/src/gallium/drivers/i915/i915_screen.c +++ b/src/gallium/drivers/i915/i915_screen.c @@ -281,7 +281,7 @@ i915_init_shader_caps(struct i915_screen *is) caps->max_shader_buffers = false; caps->max_shader_images = false; - caps = (struct pipe_shader_caps *)&is->base.shader_caps[PIPE_SHADER_FRAGMENT]; + caps = (struct pipe_shader_caps *)&is->base.shader_caps[MESA_SHADER_FRAGMENT]; caps->supported_irs = (1 << PIPE_SHADER_IR_NIR) | (1 << PIPE_SHADER_IR_TGSI); /* XXX: some of these are just shader model 2.0 values, fix this! */ @@ -558,7 +558,7 @@ i915_screen_create(struct i915_winsys *iws) is->base.fence_finish = i915_fence_finish; is->base.nir_options[MESA_SHADER_VERTEX] = &gallivm_nir_options; - is->base.nir_options[PIPE_SHADER_FRAGMENT] = &i915_compiler_options; + is->base.nir_options[MESA_SHADER_FRAGMENT] = &i915_compiler_options; i915_init_screen_resource_functions(is); diff --git a/src/gallium/drivers/i915/i915_state.c b/src/gallium/drivers/i915/i915_state.c index ecc84d6720d..518216f5c04 100644 --- a/src/gallium/drivers/i915/i915_state.c +++ b/src/gallium/drivers/i915/i915_state.c @@ -353,7 +353,7 @@ i915_bind_sampler_states(struct pipe_context *pipe, enum pipe_shader_type shader, unsigned start, unsigned num, void **samplers) { - if (shader != PIPE_SHADER_FRAGMENT) { + if (shader != MESA_SHADER_FRAGMENT) { assert(num == 0); return; } @@ -784,7 +784,7 @@ i915_set_sampler_views(struct pipe_context *pipe, enum pipe_shader_type shader, unsigned unbind_num_trailing_slots, struct pipe_sampler_view **views) { - if (shader != PIPE_SHADER_FRAGMENT) { + if (shader != MESA_SHADER_FRAGMENT) { /* No support for VS samplers, because it would mean accessing the * write-combined maps of the textures, which is very slow. VS samplers * are not a required feature of GL2.1 or GLES2. diff --git a/src/gallium/drivers/i915/i915_state_emit.c b/src/gallium/drivers/i915/i915_state_emit.c index 6430707af8b..f3561b143e8 100644 --- a/src/gallium/drivers/i915/i915_state_emit.c +++ b/src/gallium/drivers/i915/i915_state_emit.c @@ -335,7 +335,7 @@ emit_constants(struct i915_context *i915) const uint32_t *c; if (i915->fs->constant_flags[i] == I915_CONSTFLAG_USER) { /* grab user-defined constant */ - c = (uint32_t *)i915_buffer(i915->constants[PIPE_SHADER_FRAGMENT]) + c = (uint32_t *)i915_buffer(i915->constants[MESA_SHADER_FRAGMENT]) ->data; c += 4 * i; } else { diff --git a/src/gallium/drivers/iris/iris_screen.c b/src/gallium/drivers/iris/iris_screen.c index 65549ac8d37..d501a3ce15f 100644 --- a/src/gallium/drivers/iris/iris_screen.c +++ b/src/gallium/drivers/iris/iris_screen.c @@ -205,10 +205,10 @@ iris_init_shader_caps(struct iris_screen *screen) struct pipe_shader_caps *caps = (struct pipe_shader_caps *)&screen->base.shader_caps[i]; - caps->max_instructions = i == PIPE_SHADER_FRAGMENT ? 1024 : 16384; + caps->max_instructions = i == MESA_SHADER_FRAGMENT ? 1024 : 16384; caps->max_alu_instructions = caps->max_tex_instructions = - caps->max_tex_indirections = i == PIPE_SHADER_FRAGMENT ? 1024 : 0; + caps->max_tex_indirections = i == MESA_SHADER_FRAGMENT ? 1024 : 0; caps->max_control_flow_depth = UINT_MAX; diff --git a/src/gallium/drivers/lima/lima_draw.c b/src/gallium/drivers/lima/lima_draw.c index 3f100ada16d..7d2f11f73a7 100644 --- a/src/gallium/drivers/lima/lima_draw.c +++ b/src/gallium/drivers/lima/lima_draw.c @@ -713,7 +713,7 @@ lima_pack_render_state(struct lima_context *ctx, const struct pipe_draw_info *in state.has_samplers = true; } - if (ctx->const_buffer[PIPE_SHADER_FRAGMENT].buffer) { + if (ctx->const_buffer[MESA_SHADER_FRAGMENT].buffer) { state.uniforms_address = lima_ctx_buff_va(ctx, lima_ctx_buff_pp_uniform_array); uint32_t size = ctx->buffer_state[lima_ctx_buff_pp_uniform].size; uint32_t uniform_count = 0; @@ -866,8 +866,8 @@ lima_update_gp_uniform(struct lima_context *ctx) static void lima_update_pp_uniform(struct lima_context *ctx) { - const float *const_buff = ctx->const_buffer[PIPE_SHADER_FRAGMENT].buffer; - size_t const_buff_size = ctx->const_buffer[PIPE_SHADER_FRAGMENT].size / sizeof(float); + const float *const_buff = ctx->const_buffer[MESA_SHADER_FRAGMENT].buffer; + size_t const_buff_size = ctx->const_buffer[MESA_SHADER_FRAGMENT].size / sizeof(float); if (!const_buff) return; @@ -1016,9 +1016,9 @@ lima_draw_vbo_update(struct pipe_context *pctx, lima_pack_vs_cmd(ctx, info, draw); if (ctx->dirty & LIMA_CONTEXT_DIRTY_CONST_BUFF && - ctx->const_buffer[PIPE_SHADER_FRAGMENT].dirty) { + ctx->const_buffer[MESA_SHADER_FRAGMENT].dirty) { lima_update_pp_uniform(ctx); - ctx->const_buffer[PIPE_SHADER_FRAGMENT].dirty = false; + ctx->const_buffer[MESA_SHADER_FRAGMENT].dirty = false; } lima_update_textures(ctx); diff --git a/src/gallium/drivers/lima/lima_program.c b/src/gallium/drivers/lima/lima_program.c index dcbcc32a017..137e3f053c0 100644 --- a/src/gallium/drivers/lima/lima_program.c +++ b/src/gallium/drivers/lima/lima_program.c @@ -96,7 +96,7 @@ lima_program_get_compiler_options(enum pipe_shader_type shader) switch (shader) { case MESA_SHADER_VERTEX: return &vs_nir_options; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: return &fs_nir_options; default: return NULL; diff --git a/src/gallium/drivers/lima/lima_screen.c b/src/gallium/drivers/lima/lima_screen.c index d61253679eb..066c216b703 100644 --- a/src/gallium/drivers/lima/lima_screen.c +++ b/src/gallium/drivers/lima/lima_screen.c @@ -114,7 +114,7 @@ lima_init_shader_caps(struct pipe_screen *screen) caps->max_const_buffers = 1; caps->max_temps = 256; /* need investigate */ - caps = (struct pipe_shader_caps *)&screen->shader_caps[PIPE_SHADER_FRAGMENT]; + caps = (struct pipe_shader_caps *)&screen->shader_caps[MESA_SHADER_FRAGMENT]; caps->max_instructions = caps->max_alu_instructions = diff --git a/src/gallium/drivers/llvmpipe/lp_screen.c b/src/gallium/drivers/llvmpipe/lp_screen.c index b4922b84713..c36a6866ee0 100644 --- a/src/gallium/drivers/llvmpipe/lp_screen.c +++ b/src/gallium/drivers/llvmpipe/lp_screen.c @@ -127,7 +127,7 @@ llvmpipe_init_shader_caps(struct pipe_screen *screen) struct pipe_shader_caps *caps = (struct pipe_shader_caps *)&screen->shader_caps[i]; switch (i) { - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: case PIPE_SHADER_COMPUTE: case PIPE_SHADER_MESH: case PIPE_SHADER_TASK: diff --git a/src/gallium/drivers/llvmpipe/lp_setup.c b/src/gallium/drivers/llvmpipe/lp_setup.c index 20432ee269b..87842a64605 100644 --- a/src/gallium/drivers/llvmpipe/lp_setup.c +++ b/src/gallium/drivers/llvmpipe/lp_setup.c @@ -1052,8 +1052,8 @@ try_update_scene_state(struct lp_setup_context *setup) struct llvmpipe_context *llvmpipe = llvmpipe_context(setup->pipe); if (llvmpipe->dirty & LP_NEW_FS_CONSTANTS) lp_setup_set_fs_constants(llvmpipe->setup, - ARRAY_SIZE(llvmpipe->constants[PIPE_SHADER_FRAGMENT]), - llvmpipe->constants[PIPE_SHADER_FRAGMENT]); + ARRAY_SIZE(llvmpipe->constants[MESA_SHADER_FRAGMENT]), + llvmpipe->constants[MESA_SHADER_FRAGMENT]); if (setup->dirty & LP_SETUP_NEW_CONSTANTS) { for (unsigned i = 0; i < ARRAY_SIZE(setup->constants); ++i) { diff --git a/src/gallium/drivers/llvmpipe/lp_state_derived.c b/src/gallium/drivers/llvmpipe/lp_state_derived.c index d52b7a9dbb0..1de2d22198d 100644 --- a/src/gallium/drivers/llvmpipe/lp_state_derived.c +++ b/src/gallium/drivers/llvmpipe/lp_state_derived.c @@ -343,28 +343,28 @@ llvmpipe_update_derived(struct llvmpipe_context *llvmpipe) if (llvmpipe->dirty & LP_NEW_FS_CONSTANTS) lp_setup_set_fs_constants(llvmpipe->setup, - ARRAY_SIZE(llvmpipe->constants[PIPE_SHADER_FRAGMENT]), - llvmpipe->constants[PIPE_SHADER_FRAGMENT]); + ARRAY_SIZE(llvmpipe->constants[MESA_SHADER_FRAGMENT]), + llvmpipe->constants[MESA_SHADER_FRAGMENT]); if (llvmpipe->dirty & LP_NEW_FS_SSBOS) lp_setup_set_fs_ssbos(llvmpipe->setup, - ARRAY_SIZE(llvmpipe->ssbos[PIPE_SHADER_FRAGMENT]), - llvmpipe->ssbos[PIPE_SHADER_FRAGMENT], llvmpipe->fs_ssbo_write_mask); + ARRAY_SIZE(llvmpipe->ssbos[MESA_SHADER_FRAGMENT]), + llvmpipe->ssbos[MESA_SHADER_FRAGMENT], llvmpipe->fs_ssbo_write_mask); if (llvmpipe->dirty & LP_NEW_FS_IMAGES) lp_setup_set_fs_images(llvmpipe->setup, - ARRAY_SIZE(llvmpipe->images[PIPE_SHADER_FRAGMENT]), - llvmpipe->images[PIPE_SHADER_FRAGMENT]); + ARRAY_SIZE(llvmpipe->images[MESA_SHADER_FRAGMENT]), + llvmpipe->images[MESA_SHADER_FRAGMENT]); if (llvmpipe->dirty & (LP_NEW_SAMPLER_VIEW)) lp_setup_set_fragment_sampler_views(llvmpipe->setup, - llvmpipe->num_sampler_views[PIPE_SHADER_FRAGMENT], - llvmpipe->sampler_views[PIPE_SHADER_FRAGMENT]); + llvmpipe->num_sampler_views[MESA_SHADER_FRAGMENT], + llvmpipe->sampler_views[MESA_SHADER_FRAGMENT]); if (llvmpipe->dirty & (LP_NEW_SAMPLER)) lp_setup_set_fragment_sampler_state(llvmpipe->setup, - llvmpipe->num_samplers[PIPE_SHADER_FRAGMENT], - llvmpipe->samplers[PIPE_SHADER_FRAGMENT]); + llvmpipe->num_samplers[MESA_SHADER_FRAGMENT], + llvmpipe->samplers[MESA_SHADER_FRAGMENT]); if (llvmpipe->dirty & LP_NEW_VIEWPORT) { /* diff --git a/src/gallium/drivers/llvmpipe/lp_state_fs.c b/src/gallium/drivers/llvmpipe/lp_state_fs.c index 7db2456956a..e9f54773684 100644 --- a/src/gallium/drivers/llvmpipe/lp_state_fs.c +++ b/src/gallium/drivers/llvmpipe/lp_state_fs.c @@ -4263,7 +4263,7 @@ llvmpipe_set_constant_buffer(struct pipe_context *pipe, case PIPE_SHADER_COMPUTE: llvmpipe->cs_dirty |= LP_CSNEW_CONSTANTS; break; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: llvmpipe->dirty |= LP_NEW_FS_CONSTANTS; break; case PIPE_SHADER_TASK: @@ -4324,7 +4324,7 @@ llvmpipe_set_shader_buffers(struct pipe_context *pipe, case PIPE_SHADER_MESH: llvmpipe->dirty |= LP_NEW_MESH_SSBOS; break; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: llvmpipe->fs_ssbo_write_mask &= ~(((1 << count) - 1) << start_slot); llvmpipe->fs_ssbo_write_mask |= writable_bitmask << start_slot; llvmpipe->dirty |= LP_NEW_FS_SSBOS; @@ -4371,7 +4371,7 @@ llvmpipe_set_shader_images(struct pipe_context *pipe, case PIPE_SHADER_COMPUTE: llvmpipe->cs_dirty |= LP_CSNEW_IMAGES; break; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: llvmpipe->dirty |= LP_NEW_FS_IMAGES; break; case PIPE_SHADER_TASK: @@ -4623,7 +4623,7 @@ make_variant_key(struct llvmpipe_context *lp, for (unsigned i = 0; i < key->nr_samplers; ++i) { if (BITSET_TEST(nir->info.samplers_used, i)) { lp_sampler_static_sampler_state(&fs_sampler[i].sampler_state, - lp->samplers[PIPE_SHADER_FRAGMENT][i]); + lp->samplers[MESA_SHADER_FRAGMENT][i]); } } @@ -4641,7 +4641,7 @@ make_variant_key(struct llvmpipe_context *lp, */ if (BITSET_TEST(nir->info.textures_used, i)) { lp_sampler_static_texture_state(&fs_sampler[i].texture_state, - lp->sampler_views[PIPE_SHADER_FRAGMENT][i]); + lp->sampler_views[MESA_SHADER_FRAGMENT][i]); } } } else { @@ -4649,7 +4649,7 @@ make_variant_key(struct llvmpipe_context *lp, for (unsigned i = 0; i < key->nr_sampler_views; ++i) { if (BITSET_TEST(nir->info.samplers_used, i)) { lp_sampler_static_texture_state(&fs_sampler[i].texture_state, - lp->sampler_views[PIPE_SHADER_FRAGMENT][i]); + lp->sampler_views[MESA_SHADER_FRAGMENT][i]); } } } @@ -4662,7 +4662,7 @@ make_variant_key(struct llvmpipe_context *lp, for (unsigned i = 0; i < key->nr_images; ++i) { if (BITSET_TEST(nir->info.images_used, i)) { lp_sampler_static_texture_state_image(&lp_image[i].image_state, - &lp->images[PIPE_SHADER_FRAGMENT][i]); + &lp->images[MESA_SHADER_FRAGMENT][i]); } } diff --git a/src/gallium/drivers/llvmpipe/lp_state_sampler.c b/src/gallium/drivers/llvmpipe/lp_state_sampler.c index 9d82e1538cd..692bfce2dab 100644 --- a/src/gallium/drivers/llvmpipe/lp_state_sampler.c +++ b/src/gallium/drivers/llvmpipe/lp_state_sampler.c @@ -109,7 +109,7 @@ llvmpipe_bind_sampler_states(struct pipe_context *pipe, case PIPE_SHADER_COMPUTE: llvmpipe->cs_dirty |= LP_CSNEW_SAMPLER; break; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: llvmpipe->dirty |= LP_NEW_SAMPLER; break; case PIPE_SHADER_TASK: @@ -192,11 +192,11 @@ llvmpipe_set_sampler_views(struct pipe_context *pipe, case PIPE_SHADER_COMPUTE: llvmpipe->cs_dirty |= LP_CSNEW_SAMPLER_VIEW; break; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: llvmpipe->dirty |= LP_NEW_SAMPLER_VIEW; lp_setup_set_fragment_sampler_views(llvmpipe->setup, - llvmpipe->num_sampler_views[PIPE_SHADER_FRAGMENT], - llvmpipe->sampler_views[PIPE_SHADER_FRAGMENT]); + llvmpipe->num_sampler_views[MESA_SHADER_FRAGMENT], + llvmpipe->sampler_views[MESA_SHADER_FRAGMENT]); break; case PIPE_SHADER_TASK: llvmpipe->dirty |= LP_NEW_TASK_SAMPLER_VIEW; diff --git a/src/gallium/drivers/llvmpipe/lp_surface.c b/src/gallium/drivers/llvmpipe/lp_surface.c index 2f4799c5569..6ab545971b5 100644 --- a/src/gallium/drivers/llvmpipe/lp_surface.c +++ b/src/gallium/drivers/llvmpipe/lp_surface.c @@ -183,11 +183,11 @@ lp_blit(struct pipe_context *pipe, lp->min_samples); util_blitter_save_framebuffer(lp->blitter, &lp->framebuffer); util_blitter_save_fragment_sampler_states(lp->blitter, - lp->num_samplers[PIPE_SHADER_FRAGMENT], - (void**)lp->samplers[PIPE_SHADER_FRAGMENT]); + lp->num_samplers[MESA_SHADER_FRAGMENT], + (void**)lp->samplers[MESA_SHADER_FRAGMENT]); util_blitter_save_fragment_sampler_views(lp->blitter, - lp->num_sampler_views[PIPE_SHADER_FRAGMENT], - lp->sampler_views[PIPE_SHADER_FRAGMENT]); + lp->num_sampler_views[MESA_SHADER_FRAGMENT], + lp->sampler_views[MESA_SHADER_FRAGMENT]); util_blitter_save_render_condition(lp->blitter, lp->render_cond_query, lp->render_cond_cond, lp->render_cond_mode); diff --git a/src/gallium/drivers/llvmpipe/lp_texture.c b/src/gallium/drivers/llvmpipe/lp_texture.c index f1f1baa6db4..2290e9b1e2f 100644 --- a/src/gallium/drivers/llvmpipe/lp_texture.c +++ b/src/gallium/drivers/llvmpipe/lp_texture.c @@ -950,8 +950,8 @@ llvmpipe_transfer_map_ms(struct pipe_context *pipe, if ((usage & PIPE_MAP_WRITE) && (resource->bind & PIPE_BIND_CONSTANT_BUFFER)) { unsigned i; - for (i = 0; i < ARRAY_SIZE(llvmpipe->constants[PIPE_SHADER_FRAGMENT]); ++i) { - if (resource == llvmpipe->constants[PIPE_SHADER_FRAGMENT][i].buffer) { + for (i = 0; i < ARRAY_SIZE(llvmpipe->constants[MESA_SHADER_FRAGMENT]); ++i) { + if (resource == llvmpipe->constants[MESA_SHADER_FRAGMENT][i].buffer) { /* constants may have changed */ llvmpipe->dirty |= LP_NEW_FS_CONSTANTS; break; diff --git a/src/gallium/drivers/nouveau/codegen/nv50_ir_from_nir.cpp b/src/gallium/drivers/nouveau/codegen/nv50_ir_from_nir.cpp index 930f538dfdf..84739f58a92 100644 --- a/src/gallium/drivers/nouveau/codegen/nv50_ir_from_nir.cpp +++ b/src/gallium/drivers/nouveau/codegen/nv50_ir_from_nir.cpp @@ -3635,13 +3635,13 @@ nvir_nir_shader_compiler_options(int chipset, uint8_t shader_type) op.intel_vec4 = false; op.lower_uniforms_to_ubo = true; op.force_indirect_unrolling = (nir_variable_mode) ( - ((shader_type == PIPE_SHADER_FRAGMENT) ? nir_var_shader_out : 0) | + ((shader_type == MESA_SHADER_FRAGMENT) ? nir_var_shader_out : 0) | /* HW doesn't support indirect addressing of fragment program inputs * on Volta. The binary driver generates a function to handle every * possible indirection, and indirectly calls the function to handle * this instead. */ - ((chipset >= NVISA_GV100_CHIPSET && shader_type == PIPE_SHADER_FRAGMENT) ? nir_var_shader_in : 0) + ((chipset >= NVISA_GV100_CHIPSET && shader_type == MESA_SHADER_FRAGMENT) ? nir_var_shader_in : 0) ); op.force_indirect_unrolling_sampler = (chipset < NVISA_GF100_CHIPSET); op.max_unroll_iterations = 32; @@ -3691,25 +3691,25 @@ nvir_nir_shader_compiler_options(int chipset, uint8_t shader_type) static const nir_shader_compiler_options g80_nir_shader_compiler_options = nvir_nir_shader_compiler_options(NVISA_G80_CHIPSET, PIPE_SHADER_TYPES); static const nir_shader_compiler_options g80_fs_nir_shader_compiler_options = -nvir_nir_shader_compiler_options(NVISA_G80_CHIPSET, PIPE_SHADER_FRAGMENT); +nvir_nir_shader_compiler_options(NVISA_G80_CHIPSET, MESA_SHADER_FRAGMENT); static const nir_shader_compiler_options gf100_nir_shader_compiler_options = nvir_nir_shader_compiler_options(NVISA_GF100_CHIPSET, PIPE_SHADER_TYPES); static const nir_shader_compiler_options gf100_fs_nir_shader_compiler_options = -nvir_nir_shader_compiler_options(NVISA_GF100_CHIPSET, PIPE_SHADER_FRAGMENT); +nvir_nir_shader_compiler_options(NVISA_GF100_CHIPSET, MESA_SHADER_FRAGMENT); static const nir_shader_compiler_options gm107_nir_shader_compiler_options = nvir_nir_shader_compiler_options(NVISA_GM107_CHIPSET, PIPE_SHADER_TYPES); static const nir_shader_compiler_options gm107_fs_nir_shader_compiler_options = -nvir_nir_shader_compiler_options(NVISA_GM107_CHIPSET, PIPE_SHADER_FRAGMENT); +nvir_nir_shader_compiler_options(NVISA_GM107_CHIPSET, MESA_SHADER_FRAGMENT); static const nir_shader_compiler_options gv100_nir_shader_compiler_options = nvir_nir_shader_compiler_options(NVISA_GV100_CHIPSET, PIPE_SHADER_TYPES); static const nir_shader_compiler_options gv100_fs_nir_shader_compiler_options = -nvir_nir_shader_compiler_options(NVISA_GV100_CHIPSET, PIPE_SHADER_FRAGMENT); +nvir_nir_shader_compiler_options(NVISA_GV100_CHIPSET, MESA_SHADER_FRAGMENT); const nir_shader_compiler_options * nv50_ir_nir_shader_compiler_options(int chipset, uint8_t shader_type) { if (chipset >= NVISA_GV100_CHIPSET) { - if (shader_type == PIPE_SHADER_FRAGMENT) { + if (shader_type == MESA_SHADER_FRAGMENT) { return &gv100_fs_nir_shader_compiler_options; } else { return &gv100_nir_shader_compiler_options; @@ -3717,7 +3717,7 @@ nv50_ir_nir_shader_compiler_options(int chipset, uint8_t shader_type) } if (chipset >= NVISA_GM107_CHIPSET) { - if (shader_type == PIPE_SHADER_FRAGMENT) { + if (shader_type == MESA_SHADER_FRAGMENT) { return &gm107_fs_nir_shader_compiler_options; } else { return &gm107_nir_shader_compiler_options; @@ -3725,14 +3725,14 @@ nv50_ir_nir_shader_compiler_options(int chipset, uint8_t shader_type) } if (chipset >= NVISA_GF100_CHIPSET) { - if (shader_type == PIPE_SHADER_FRAGMENT) { + if (shader_type == MESA_SHADER_FRAGMENT) { return &gf100_fs_nir_shader_compiler_options; } else { return &gf100_nir_shader_compiler_options; } } - if (shader_type == PIPE_SHADER_FRAGMENT) { + if (shader_type == MESA_SHADER_FRAGMENT) { return &g80_fs_nir_shader_compiler_options; } else { return &g80_nir_shader_compiler_options; diff --git a/src/gallium/drivers/nouveau/codegen/nv50_ir_print.cpp b/src/gallium/drivers/nouveau/codegen/nv50_ir_print.cpp index 2fa75f70440..18a9912fb70 100644 --- a/src/gallium/drivers/nouveau/codegen/nv50_ir_print.cpp +++ b/src/gallium/drivers/nouveau/codegen/nv50_ir_print.cpp @@ -998,7 +998,7 @@ nv50_ir_prog_info_out_print(struct nv50_ir_prog_info_out *info_out) INFO(" \"instancesCount\":\"%d\"\n", info_out->prop.gp.instanceCount); INFO(" \"maxVertices\":\"%d\"\n", info_out->prop.gp.maxVertices); break; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: INFO(" \"fp\":{\n"); INFO(" \"numColourResults\":\"%d\"\n", info_out->prop.fp.numColourResults); INFO(" \"writesDepth\":\"%s\"\n", info_out->prop.fp.writesDepth ? "true" : "false"); diff --git a/src/gallium/drivers/nouveau/codegen/nv50_ir_serialize.cpp b/src/gallium/drivers/nouveau/codegen/nv50_ir_serialize.cpp index b8b92f3d6d1..f3fb47c84c6 100644 --- a/src/gallium/drivers/nouveau/codegen/nv50_ir_serialize.cpp +++ b/src/gallium/drivers/nouveau/codegen/nv50_ir_serialize.cpp @@ -119,7 +119,7 @@ nv50_ir_prog_info_out_serialize(struct blob *blob, case MESA_SHADER_GEOMETRY: blob_write_bytes(blob, &info_out->prop.gp, sizeof(info_out->prop.gp)); break; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: blob_write_bytes(blob, &info_out->prop.fp, sizeof(info_out->prop.fp)); break; case PIPE_SHADER_COMPUTE: @@ -239,7 +239,7 @@ nv50_ir_prog_info_out_deserialize(void *data, size_t size, size_t offset, case MESA_SHADER_GEOMETRY: blob_copy_bytes(&reader, &info_out->prop.gp, sizeof(info_out->prop.gp)); break; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: blob_copy_bytes(&reader, &info_out->prop.fp, sizeof(info_out->prop.fp)); break; case PIPE_SHADER_COMPUTE: diff --git a/src/gallium/drivers/nouveau/nv30/nv30_fragtex.c b/src/gallium/drivers/nouveau/nv30/nv30_fragtex.c index bf8c8958dbf..9f2f6bfaee5 100644 --- a/src/gallium/drivers/nouveau/nv30/nv30_fragtex.c +++ b/src/gallium/drivers/nouveau/nv30/nv30_fragtex.c @@ -204,7 +204,7 @@ nv30_set_sampler_views(struct pipe_context *pipe, enum pipe_shader_type shader, { assert(start == 0); switch (shader) { - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: nv30_fragtex_set_sampler_views(pipe, nr, views); break; case MESA_SHADER_VERTEX: diff --git a/src/gallium/drivers/nouveau/nv30/nv30_screen.c b/src/gallium/drivers/nouveau/nv30/nv30_screen.c index c6e34298dc7..bde9f299e6b 100644 --- a/src/gallium/drivers/nouveau/nv30/nv30_screen.c +++ b/src/gallium/drivers/nouveau/nv30/nv30_screen.c @@ -68,7 +68,7 @@ nv30_init_shader_caps(struct nv30_screen *screen) caps->max_temps = (eng3d->oclass >= NV40_3D_CLASS) ? 32 : 13; caps->supported_irs = (1 << PIPE_SHADER_IR_NIR) | (1 << PIPE_SHADER_IR_TGSI); - caps = (struct pipe_shader_caps *)&screen->base.base.shader_caps[PIPE_SHADER_FRAGMENT]; + caps = (struct pipe_shader_caps *)&screen->base.base.shader_caps[MESA_SHADER_FRAGMENT]; caps->max_instructions = caps->max_alu_instructions = diff --git a/src/gallium/drivers/nouveau/nv30/nv30_state.c b/src/gallium/drivers/nouveau/nv30/nv30_state.c index 7dae1fc663e..0b17266494c 100644 --- a/src/gallium/drivers/nouveau/nv30/nv30_state.c +++ b/src/gallium/drivers/nouveau/nv30/nv30_state.c @@ -355,7 +355,7 @@ nv30_set_constant_buffer(struct pipe_context *pipe, nv30->vertprog.constbuf_nr = size; nv30->dirty |= NV30_NEW_VERTCONST; } else - if (shader == PIPE_SHADER_FRAGMENT) { + if (shader == MESA_SHADER_FRAGMENT) { if (pass_reference) { pipe_resource_reference(&nv30->fragprog.constbuf, NULL); nv30->fragprog.constbuf = buf; diff --git a/src/gallium/drivers/nouveau/nv30/nv30_texture.c b/src/gallium/drivers/nouveau/nv30/nv30_texture.c index a6154960734..73c50afe9f2 100644 --- a/src/gallium/drivers/nouveau/nv30/nv30_texture.c +++ b/src/gallium/drivers/nouveau/nv30/nv30_texture.c @@ -195,7 +195,7 @@ nv30_bind_sampler_states(struct pipe_context *pipe, case MESA_SHADER_VERTEX: nv40_verttex_sampler_states_bind(pipe, num_samplers, samplers); break; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: nv30_fragtex_sampler_states_bind(pipe, num_samplers, samplers); break; default: diff --git a/src/gallium/drivers/nouveau/nv50/nv50_context.h b/src/gallium/drivers/nouveau/nv50/nv50_context.h index 6716732e6cb..eb9d7a14b44 100644 --- a/src/gallium/drivers/nouveau/nv50/nv50_context.h +++ b/src/gallium/drivers/nouveau/nv50/nv50_context.h @@ -248,7 +248,7 @@ nv50_context_shader_stage(unsigned pipe) { switch (pipe) { case MESA_SHADER_VERTEX: return NV50_SHADER_STAGE_VERTEX; - case PIPE_SHADER_FRAGMENT: return NV50_SHADER_STAGE_FRAGMENT; + case MESA_SHADER_FRAGMENT: return NV50_SHADER_STAGE_FRAGMENT; case MESA_SHADER_GEOMETRY: return NV50_SHADER_STAGE_GEOMETRY; case PIPE_SHADER_COMPUTE: return NV50_SHADER_STAGE_COMPUTE; default: diff --git a/src/gallium/drivers/nouveau/nv50/nv50_program.c b/src/gallium/drivers/nouveau/nv50/nv50_program.c index b39c400256a..16786c79356 100644 --- a/src/gallium/drivers/nouveau/nv50/nv50_program.c +++ b/src/gallium/drivers/nouveau/nv50/nv50_program.c @@ -260,7 +260,7 @@ nv50_program_assign_varying_slots(struct nv50_ir_prog_info_out *info) return nv50_vertprog_assign_slots(info); case MESA_SHADER_GEOMETRY: return nv50_vertprog_assign_slots(info); - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: return nv50_fragprog_assign_slots(info); case PIPE_SHADER_COMPUTE: return 0; @@ -406,7 +406,7 @@ nv50_program_translate(struct nv50_program *prog, uint16_t chipset, for (i = 0; i < info_out.io.cullDistances; ++i) prog->vp.clip_mode |= 1 << ((info_out.io.clipDistances + i) * 4); - if (prog->type == PIPE_SHADER_FRAGMENT) { + if (prog->type == MESA_SHADER_FRAGMENT) { if (info_out.prop.fp.writesDepth) { prog->fp.flags[0] |= NV50_3D_FP_CONTROL_EXPORTS_Z; prog->fp.flags[1] = 0x11; @@ -467,7 +467,7 @@ nv50_program_upload_code(struct nv50_context *nv50, struct nv50_program *prog) switch (prog->type) { case MESA_SHADER_VERTEX: heap = nv50->screen->vp_code_heap; break; case MESA_SHADER_GEOMETRY: heap = nv50->screen->gp_code_heap; break; - case PIPE_SHADER_FRAGMENT: heap = nv50->screen->fp_code_heap; break; + case MESA_SHADER_FRAGMENT: heap = nv50->screen->fp_code_heap; break; case PIPE_SHADER_COMPUTE: heap = nv50->screen->fp_code_heap; break; default: assert(!"invalid program type"); diff --git a/src/gallium/drivers/nouveau/nv50/nv50_state.c b/src/gallium/drivers/nouveau/nv50/nv50_state.c index 43761cfbc0b..94a461eda17 100644 --- a/src/gallium/drivers/nouveau/nv50/nv50_state.c +++ b/src/gallium/drivers/nouveau/nv50/nv50_state.c @@ -798,7 +798,7 @@ static void * nv50_fp_state_create(struct pipe_context *pipe, const struct pipe_shader_state *cso) { - return nv50_sp_state_create(pipe, cso, PIPE_SHADER_FRAGMENT); + return nv50_sp_state_create(pipe, cso, MESA_SHADER_FRAGMENT); } static void diff --git a/src/gallium/drivers/nouveau/nv50/nv50_surface.c b/src/gallium/drivers/nouveau/nv50/nv50_surface.c index 01b4076fc6e..6b2411bc739 100644 --- a/src/gallium/drivers/nouveau/nv50/nv50_surface.c +++ b/src/gallium/drivers/nouveau/nv50/nv50_surface.c @@ -867,7 +867,7 @@ nv50_blitter_make_fp(struct pipe_context *pipe, const int chipset = nouveau_screen(pipe->screen)->device->chipset; const nir_shader_compiler_options *options = - nv50_ir_nir_shader_compiler_options(chipset, PIPE_SHADER_FRAGMENT); + nv50_ir_nir_shader_compiler_options(chipset, MESA_SHADER_FRAGMENT); struct nir_builder b = nir_builder_init_simple_shader(MESA_SHADER_FRAGMENT, options, diff --git a/src/gallium/drivers/nouveau/nvc0/nvc0_context.h b/src/gallium/drivers/nouveau/nvc0/nvc0_context.h index 9fa45ee4ef5..64e6a9abb36 100644 --- a/src/gallium/drivers/nouveau/nvc0/nvc0_context.h +++ b/src/gallium/drivers/nouveau/nvc0/nvc0_context.h @@ -300,7 +300,7 @@ nvc0_shader_stage(unsigned pipe) case MESA_SHADER_TESS_CTRL: return 1; case MESA_SHADER_TESS_EVAL: return 2; case MESA_SHADER_GEOMETRY: return 3; - case PIPE_SHADER_FRAGMENT: return 4; + case MESA_SHADER_FRAGMENT: return 4; case PIPE_SHADER_COMPUTE: return 5; default: assert(!"invalid PIPE_SHADER type"); diff --git a/src/gallium/drivers/nouveau/nvc0/nvc0_program.c b/src/gallium/drivers/nouveau/nvc0/nvc0_program.c index 46d6488988f..9e969986cc4 100644 --- a/src/gallium/drivers/nouveau/nvc0/nvc0_program.c +++ b/src/gallium/drivers/nouveau/nvc0/nvc0_program.c @@ -193,7 +193,7 @@ nvc0_program_assign_varying_slots(struct nv50_ir_prog_info_out *info) if (ret) return ret; - if (info->type == PIPE_SHADER_FRAGMENT) + if (info->type == MESA_SHADER_FRAGMENT) ret = nvc0_fp_assign_output_slots(info); else ret = nvc0_sp_assign_output_slots(info); @@ -702,7 +702,7 @@ nvc0_program_translate(struct nvc0_program *prog, uint16_t chipset, case MESA_SHADER_GEOMETRY: ret = nvc0_gp_gen_header(prog, &info_out); break; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: ret = nvc0_fp_gen_header(prog, &info_out); break; case PIPE_SHADER_COMPUTE: diff --git a/src/gallium/drivers/nouveau/nvc0/nvc0_screen.c b/src/gallium/drivers/nouveau/nvc0/nvc0_screen.c index 2c5472f34f7..21aa5323b56 100644 --- a/src/gallium/drivers/nouveau/nvc0/nvc0_screen.c +++ b/src/gallium/drivers/nouveau/nvc0/nvc0_screen.c @@ -142,7 +142,7 @@ nvc0_init_shader_caps(struct nvc0_screen *screen) caps->max_sampler_views = (class_3d >= NVE4_3D_CLASS) ? 32 : 16; caps->max_shader_images = class_3d >= NVE4_3D_CLASS || - i == PIPE_SHADER_FRAGMENT || + i == MESA_SHADER_FRAGMENT || i == PIPE_SHADER_COMPUTE ? NVC0_MAX_IMAGES : 0; } } diff --git a/src/gallium/drivers/nouveau/nvc0/nvc0_state.c b/src/gallium/drivers/nouveau/nvc0/nvc0_state.c index 280e908efcb..c2ab4b85662 100644 --- a/src/gallium/drivers/nouveau/nvc0/nvc0_state.c +++ b/src/gallium/drivers/nouveau/nvc0/nvc0_state.c @@ -655,7 +655,7 @@ static void * nvc0_fp_state_create(struct pipe_context *pipe, const struct pipe_shader_state *cso) { - return nvc0_sp_state_create(pipe, cso, PIPE_SHADER_FRAGMENT); + return nvc0_sp_state_create(pipe, cso, MESA_SHADER_FRAGMENT); } static void diff --git a/src/gallium/drivers/panfrost/pan_blit.c b/src/gallium/drivers/panfrost/pan_blit.c index 5c3ff6a6a6b..d2e6418619f 100644 --- a/src/gallium/drivers/panfrost/pan_blit.c +++ b/src/gallium/drivers/panfrost/pan_blit.c @@ -51,13 +51,13 @@ panfrost_blitter_save(struct panfrost_context *ctx, if (blitter_op & PAN_SAVE_FRAGMENT_STATE) { if (blitter_op & PAN_SAVE_FRAGMENT_CONSTANT) util_blitter_save_fragment_constant_buffer_slot( - blitter, ctx->constant_buffer[PIPE_SHADER_FRAGMENT].cb); + blitter, ctx->constant_buffer[MESA_SHADER_FRAGMENT].cb); util_blitter_save_blend(blitter, ctx->blend); util_blitter_save_depth_stencil_alpha(blitter, ctx->depth_stencil); util_blitter_save_stencil_ref(blitter, &ctx->stencil_ref); util_blitter_save_fragment_shader(blitter, - ctx->uncompiled[PIPE_SHADER_FRAGMENT]); + ctx->uncompiled[MESA_SHADER_FRAGMENT]); util_blitter_save_sample_mask(blitter, ctx->sample_mask, ctx->min_samples); util_blitter_save_scissor(blitter, &ctx->scissor); @@ -68,11 +68,11 @@ panfrost_blitter_save(struct panfrost_context *ctx, if (blitter_op & PAN_SAVE_TEXTURES) { util_blitter_save_fragment_sampler_states( - blitter, ctx->sampler_count[PIPE_SHADER_FRAGMENT], - (void **)(&ctx->samplers[PIPE_SHADER_FRAGMENT])); + blitter, ctx->sampler_count[MESA_SHADER_FRAGMENT], + (void **)(&ctx->samplers[MESA_SHADER_FRAGMENT])); util_blitter_save_fragment_sampler_views( - blitter, ctx->sampler_view_count[PIPE_SHADER_FRAGMENT], - (struct pipe_sampler_view **)&ctx->sampler_views[PIPE_SHADER_FRAGMENT]); + blitter, ctx->sampler_view_count[MESA_SHADER_FRAGMENT], + (struct pipe_sampler_view **)&ctx->sampler_views[MESA_SHADER_FRAGMENT]); } if (!(blitter_op & PAN_DISABLE_RENDER_COND)) { diff --git a/src/gallium/drivers/panfrost/pan_cmdstream.c b/src/gallium/drivers/panfrost/pan_cmdstream.c index fa231c9df98..3e6a5f8332c 100644 --- a/src/gallium/drivers/panfrost/pan_cmdstream.c +++ b/src/gallium/drivers/panfrost/pan_cmdstream.c @@ -344,7 +344,7 @@ panfrost_emit_blend(struct panfrost_batch *batch, void *rts, } #if PAN_ARCH >= 6 - struct panfrost_compiled_shader *fs = ctx->prog[PIPE_SHADER_FRAGMENT]; + struct panfrost_compiled_shader *fs = ctx->prog[MESA_SHADER_FRAGMENT]; struct mali_internal_blend_packed *internal_blend_packed = (struct mali_internal_blend_packed *)&packed->opaque[2]; @@ -474,7 +474,7 @@ panfrost_prepare_fs_state(struct panfrost_context *ctx, uint64_t *blend_shaders, { struct pipe_rasterizer_state *rast = &ctx->rasterizer->base; const struct panfrost_zsa_state *zsa = ctx->depth_stencil; - struct panfrost_compiled_shader *fs = ctx->prog[PIPE_SHADER_FRAGMENT]; + struct panfrost_compiled_shader *fs = ctx->prog[MESA_SHADER_FRAGMENT]; struct panfrost_blend_state *so = ctx->blend; bool alpha_to_coverage = ctx->blend->base.alpha_to_coverage; bool msaa = rast->multisample; @@ -609,7 +609,7 @@ panfrost_emit_frag_shader(struct panfrost_context *ctx, { const struct panfrost_zsa_state *zsa = ctx->depth_stencil; const struct panfrost_rasterizer *rast = ctx->rasterizer; - struct panfrost_compiled_shader *fs = ctx->prog[PIPE_SHADER_FRAGMENT]; + struct panfrost_compiled_shader *fs = ctx->prog[MESA_SHADER_FRAGMENT]; /* We need to merge several several partial renderer state descriptors, * so stage to temporary storage rather than reading back write-combine @@ -657,10 +657,10 @@ static uint64_t panfrost_emit_frag_shader_meta(struct panfrost_batch *batch) { struct panfrost_context *ctx = batch->ctx; - struct panfrost_compiled_shader *ss = ctx->prog[PIPE_SHADER_FRAGMENT]; + struct panfrost_compiled_shader *ss = ctx->prog[MESA_SHADER_FRAGMENT]; - panfrost_batch_add_bo(batch, ss->bin.bo, PIPE_SHADER_FRAGMENT); - panfrost_batch_add_bo(batch, ss->state.bo, PIPE_SHADER_FRAGMENT); + panfrost_batch_add_bo(batch, ss->bin.bo, MESA_SHADER_FRAGMENT); + panfrost_batch_add_bo(batch, ss->state.bo, MESA_SHADER_FRAGMENT); struct pan_ptr xfer; @@ -855,7 +855,7 @@ panfrost_emit_depth_stencil(struct panfrost_batch *batch) struct panfrost_context *ctx = batch->ctx; const struct panfrost_zsa_state *zsa = ctx->depth_stencil; struct panfrost_rasterizer *rast = ctx->rasterizer; - struct panfrost_compiled_shader *fs = ctx->prog[PIPE_SHADER_FRAGMENT]; + struct panfrost_compiled_shader *fs = ctx->prog[MESA_SHADER_FRAGMENT]; bool back_enab = zsa->base.stencil[1].enabled; struct pan_ptr T = pan_pool_alloc_desc(&batch->pool.base, DEPTH_STENCIL); @@ -2682,7 +2682,7 @@ panfrost_emit_varying_descriptor(struct panfrost_batch *batch, { struct panfrost_context *ctx = batch->ctx; struct panfrost_compiled_shader *vs = ctx->prog[MESA_SHADER_VERTEX]; - struct panfrost_compiled_shader *fs = ctx->prog[PIPE_SHADER_FRAGMENT]; + struct panfrost_compiled_shader *fs = ctx->prog[MESA_SHADER_FRAGMENT]; uint16_t point_coord_mask = 0; @@ -2934,7 +2934,7 @@ panfrost_emit_varying_descriptors(struct panfrost_batch *batch) struct panfrost_compiled_shader *vs = batch->ctx->prog[MESA_SHADER_VERTEX]; struct panfrost_compiled_shader *fs = - batch->ctx->prog[PIPE_SHADER_FRAGMENT]; + batch->ctx->prog[MESA_SHADER_FRAGMENT]; const uint32_t vs_out_mask = vs->info.varyings.fixed_varyings; const uint32_t fs_in_mask = fs->info.varyings.fixed_varyings; @@ -2945,7 +2945,7 @@ panfrost_emit_varying_descriptors(struct panfrost_batch *batch) pan_pool_alloc_desc_array(&batch->pool.base, fs_in_slots, ATTRIBUTE); struct mali_attribute_packed *descs = bufs.cpu; - batch->nr_varying_attribs[PIPE_SHADER_FRAGMENT] = fs_in_slots; + batch->nr_varying_attribs[MESA_SHADER_FRAGMENT] = fs_in_slots; const uint32_t varying_size = panfrost_vertex_attribute_stride(vs, fs); @@ -2986,7 +2986,7 @@ panfrost_update_shader_state(struct panfrost_batch *batch, struct panfrost_context *ctx = batch->ctx; struct panfrost_compiled_shader *ss = ctx->prog[st]; - bool frag = (st == PIPE_SHADER_FRAGMENT); + bool frag = (st == MESA_SHADER_FRAGMENT); unsigned dirty_3d = ctx->dirty; unsigned dirty = ctx->dirty_shader[st]; @@ -3067,7 +3067,7 @@ panfrost_update_state_3d(struct panfrost_batch *batch) #if PAN_ARCH >= 9 if ((dirty & (PAN_DIRTY_ZS | PAN_DIRTY_RASTERIZER)) || - (ctx->dirty_shader[PIPE_SHADER_FRAGMENT] & PAN_DIRTY_STAGE_SHADER)) + (ctx->dirty_shader[MESA_SHADER_FRAGMENT] & PAN_DIRTY_STAGE_SHADER)) batch->depth_stencil = panfrost_emit_depth_stencil(batch); if (dirty & PAN_DIRTY_BLEND) @@ -3190,7 +3190,7 @@ panfrost_update_active_prim(struct panfrost_context *ctx, if ((ctx->dirty & PAN_DIRTY_RASTERIZER) || (prev_prim != new_prim)) { - panfrost_update_shader_variant(ctx, PIPE_SHADER_FRAGMENT); + panfrost_update_shader_variant(ctx, MESA_SHADER_FRAGMENT); } } @@ -3273,7 +3273,7 @@ panfrost_single_draw_direct(struct panfrost_batch *batch, panfrost_update_state_3d(batch); panfrost_update_shader_state(batch, MESA_SHADER_VERTEX); - panfrost_update_shader_state(batch, PIPE_SHADER_FRAGMENT); + panfrost_update_shader_state(batch, MESA_SHADER_FRAGMENT); panfrost_clean_state_3d(ctx); if (ctx->uncompiled[MESA_SHADER_VERTEX]->xfb) { @@ -3418,7 +3418,7 @@ panfrost_draw_indirect(struct pipe_context *pipe, panfrost_update_state_3d(batch); panfrost_update_shader_state(batch, MESA_SHADER_VERTEX); - panfrost_update_shader_state(batch, PIPE_SHADER_FRAGMENT); + panfrost_update_shader_state(batch, MESA_SHADER_FRAGMENT); panfrost_clean_state_3d(ctx); /* Increment transform feedback offsets */ @@ -4376,7 +4376,7 @@ batch_get_polygon_list(struct panfrost_batch *batch) batch->tiler_ctx.midgard.polygon_list = batch->polygon_list_bo->ptr.gpu; panfrost_batch_add_bo(batch, batch->polygon_list_bo, - PIPE_SHADER_FRAGMENT); + MESA_SHADER_FRAGMENT); if (init_polygon_list && dev->model->quirks.no_hierarchical_tiling) { assert(batch->polygon_list_bo->ptr.cpu); diff --git a/src/gallium/drivers/panfrost/pan_cmdstream.h b/src/gallium/drivers/panfrost/pan_cmdstream.h index 9dd0f694494..8831e855b2f 100644 --- a/src/gallium/drivers/panfrost/pan_cmdstream.h +++ b/src/gallium/drivers/panfrost/pan_cmdstream.h @@ -311,9 +311,9 @@ panfrost_emit_resources(struct panfrost_batch *batch, pan_make_resource_table(T, PAN_TABLE_IMAGE, batch->images[stage], util_last_bit(ctx->image_mask[stage])); - if (stage == PIPE_SHADER_FRAGMENT) { + if (stage == MESA_SHADER_FRAGMENT) { pan_make_resource_table(T, PAN_TABLE_ATTRIBUTE, batch->attribs[stage], - batch->nr_varying_attribs[PIPE_SHADER_FRAGMENT]); + batch->nr_varying_attribs[MESA_SHADER_FRAGMENT]); } else if (stage == MESA_SHADER_VERTEX) { pan_make_resource_table(T, PAN_TABLE_ATTRIBUTE, batch->attribs[stage], ctx->vertex->num_elements); diff --git a/src/gallium/drivers/panfrost/pan_context.c b/src/gallium/drivers/panfrost/pan_context.c index 0187bd45dce..536a35336a6 100644 --- a/src/gallium/drivers/panfrost/pan_context.c +++ b/src/gallium/drivers/panfrost/pan_context.c @@ -211,7 +211,7 @@ panfrost_get_blend(struct panfrost_batch *batch, unsigned rti) memcpy(pan_blend.constants, ctx->blend_color.color, sizeof(pan_blend.constants)); - struct panfrost_compiled_shader *ss = ctx->prog[PIPE_SHADER_FRAGMENT]; + struct panfrost_compiled_shader *ss = ctx->prog[MESA_SHADER_FRAGMENT]; /* Default for Midgard */ nir_alu_type col0_type = nir_type_float32; diff --git a/src/gallium/drivers/panfrost/pan_csf.c b/src/gallium/drivers/panfrost/pan_csf.c index b7d5f37bbda..2b4daeeccbe 100644 --- a/src/gallium/drivers/panfrost/pan_csf.c +++ b/src/gallium/drivers/panfrost/pan_csf.c @@ -905,13 +905,13 @@ csf_emit_shader_regs(struct panfrost_batch *batch, enum pipe_shader_type stage, { uint64_t resources = panfrost_emit_resources(batch, stage); - assert(stage == MESA_SHADER_VERTEX || stage == PIPE_SHADER_FRAGMENT || + assert(stage == MESA_SHADER_VERTEX || stage == MESA_SHADER_FRAGMENT || stage == PIPE_SHADER_COMPUTE); #if PAN_ARCH >= 12 - unsigned offset = (stage == PIPE_SHADER_FRAGMENT) ? 2 : 0; + unsigned offset = (stage == MESA_SHADER_FRAGMENT) ? 2 : 0; #else - unsigned offset = (stage == PIPE_SHADER_FRAGMENT) ? 4 : 0; + unsigned offset = (stage == MESA_SHADER_FRAGMENT) ? 4 : 0; #endif unsigned fau_count = DIV_ROUND_UP(batch->nr_push_uniforms[stage], 2); @@ -1115,7 +1115,7 @@ csf_emit_draw_state(struct panfrost_batch *batch, { struct panfrost_context *ctx = batch->ctx; struct panfrost_compiled_shader *vs = ctx->prog[MESA_SHADER_VERTEX]; - struct panfrost_compiled_shader *fs = ctx->prog[PIPE_SHADER_FRAGMENT]; + struct panfrost_compiled_shader *fs = ctx->prog[MESA_SHADER_FRAGMENT]; bool idvs = vs->info.vs.idvs; bool fs_required = panfrost_fs_required( @@ -1135,8 +1135,8 @@ csf_emit_draw_state(struct panfrost_batch *batch, panfrost_get_position_shader(batch, info)); if (fs_required) { - csf_emit_shader_regs(batch, PIPE_SHADER_FRAGMENT, - batch->rsd[PIPE_SHADER_FRAGMENT]); + csf_emit_shader_regs(batch, MESA_SHADER_FRAGMENT, + batch->rsd[MESA_SHADER_FRAGMENT]); } else { cs_move64_to(b, cs_sr_reg64(b, IDVS, FRAGMENT_SRT), 0); cs_move64_to(b, cs_sr_reg64(b, IDVS, FRAGMENT_FAU), 0); @@ -1180,7 +1180,7 @@ csf_emit_draw_state(struct panfrost_batch *batch, if (ctx->occlusion_query && ctx->active_queries) { struct panfrost_resource *rsrc = pan_resource(ctx->occlusion_query->rsrc); cs_move64_to(b, cs_sr_reg64(b, IDVS, OQ), rsrc->plane.base); - panfrost_batch_write_rsrc(ctx->batch, rsrc, PIPE_SHADER_FRAGMENT); + panfrost_batch_write_rsrc(ctx->batch, rsrc, MESA_SHADER_FRAGMENT); } cs_move32_to(b, cs_sr_reg32(b, IDVS, VARY_SIZE), diff --git a/src/gallium/drivers/panfrost/pan_jm.c b/src/gallium/drivers/panfrost/pan_jm.c index 87c3ee6430e..b82724e0833 100644 --- a/src/gallium/drivers/panfrost/pan_jm.c +++ b/src/gallium/drivers/panfrost/pan_jm.c @@ -543,11 +543,11 @@ jm_emit_tiler_draw(struct mali_draw_packed *out, struct panfrost_batch *batch, struct panfrost_resource *rsrc = pan_resource(ctx->occlusion_query->rsrc); cfg.occlusion = rsrc->plane.base; - panfrost_batch_write_rsrc(ctx->batch, rsrc, PIPE_SHADER_FRAGMENT); + panfrost_batch_write_rsrc(ctx->batch, rsrc, MESA_SHADER_FRAGMENT); } #if PAN_ARCH >= 9 - struct panfrost_compiled_shader *fs = ctx->prog[PIPE_SHADER_FRAGMENT]; + struct panfrost_compiled_shader *fs = ctx->prog[MESA_SHADER_FRAGMENT]; cfg.flags_0.multisample_enable = rast->multisample; cfg.flags_1.sample_mask = rast->multisample ? ctx->sample_mask : 0xFFFF; @@ -625,8 +625,8 @@ jm_emit_tiler_draw(struct mali_draw_packed *out, struct panfrost_batch *batch, cfg.flags_0.overdraw_alpha0 = panfrost_overdraw_alpha(ctx, 0); cfg.flags_0.overdraw_alpha1 = panfrost_overdraw_alpha(ctx, 1); - jm_emit_shader_env(batch, &cfg.shader, PIPE_SHADER_FRAGMENT, - batch->rsd[PIPE_SHADER_FRAGMENT]); + jm_emit_shader_env(batch, &cfg.shader, MESA_SHADER_FRAGMENT, + batch->rsd[MESA_SHADER_FRAGMENT]); } else { /* These operations need to be FORCE to benefit from the * depth-only pass optimizations. @@ -650,9 +650,9 @@ jm_emit_tiler_draw(struct mali_draw_packed *out, struct panfrost_batch *batch, } #else cfg.position = batch->varyings.pos; - cfg.state = batch->rsd[PIPE_SHADER_FRAGMENT]; - cfg.attributes = batch->attribs[PIPE_SHADER_FRAGMENT]; - cfg.attribute_buffers = batch->attrib_bufs[PIPE_SHADER_FRAGMENT]; + cfg.state = batch->rsd[MESA_SHADER_FRAGMENT]; + cfg.attributes = batch->attribs[MESA_SHADER_FRAGMENT]; + cfg.attribute_buffers = batch->attrib_bufs[MESA_SHADER_FRAGMENT]; cfg.viewport = batch->viewport; cfg.varyings = batch->varyings.fs; cfg.varying_buffers = cfg.varyings ? batch->varyings.bufs : 0; @@ -667,7 +667,7 @@ jm_emit_tiler_draw(struct mali_draw_packed *out, struct panfrost_batch *batch, cfg.flat_shading_vertex = rast->flatshade_first ^ (PAN_ARCH <= 5); } - jm_emit_draw_descs(batch, &cfg, PIPE_SHADER_FRAGMENT); + jm_emit_draw_descs(batch, &cfg, MESA_SHADER_FRAGMENT); #endif } } @@ -708,7 +708,7 @@ jm_emit_primitive(struct panfrost_batch *batch, cfg.job_task_split = 6; #else - struct panfrost_compiled_shader *fs = ctx->prog[PIPE_SHADER_FRAGMENT]; + struct panfrost_compiled_shader *fs = ctx->prog[MESA_SHADER_FRAGMENT]; cfg.allow_rotating_primitives = allow_rotating_primitives(fs, info); cfg.primitive_restart = info->primitive_restart; @@ -759,7 +759,7 @@ jm_emit_malloc_vertex_job(struct panfrost_batch *batch, { struct panfrost_context *ctx = batch->ctx; struct panfrost_compiled_shader *vs = ctx->prog[MESA_SHADER_VERTEX]; - struct panfrost_compiled_shader *fs = ctx->prog[PIPE_SHADER_FRAGMENT]; + struct panfrost_compiled_shader *fs = ctx->prog[MESA_SHADER_FRAGMENT]; bool fs_required = panfrost_fs_required( fs, ctx->blend, &ctx->pipe_framebuffer, ctx->depth_stencil); diff --git a/src/gallium/drivers/panfrost/pan_job.c b/src/gallium/drivers/panfrost/pan_job.c index 8726b75c255..9a4afbcecb2 100644 --- a/src/gallium/drivers/panfrost/pan_job.c +++ b/src/gallium/drivers/panfrost/pan_job.c @@ -67,7 +67,7 @@ panfrost_batch_add_surface(struct panfrost_batch *batch, if (surf->texture) { struct panfrost_resource *rsrc = pan_resource(surf->texture); pan_legalize_format(batch->ctx, rsrc, surf->format, true, false); - panfrost_batch_write_rsrc(batch, rsrc, PIPE_SHADER_FRAGMENT); + panfrost_batch_write_rsrc(batch, rsrc, MESA_SHADER_FRAGMENT); } } @@ -351,7 +351,7 @@ panfrost_batch_add_bo_old(struct panfrost_batch *batch, struct panfrost_bo *bo, static uint32_t panfrost_access_for_stage(enum pipe_shader_type stage) { - return (stage == PIPE_SHADER_FRAGMENT) ? PAN_BO_ACCESS_FRAGMENT + return (stage == MESA_SHADER_FRAGMENT) ? PAN_BO_ACCESS_FRAGMENT : PAN_BO_ACCESS_VERTEX_TILER; } @@ -447,7 +447,7 @@ panfrost_batch_get_scratchpad(struct panfrost_batch *batch, MESA_SHADER_VERTEX, "Thread local storage"); if (batch->scratchpad) - panfrost_batch_add_bo(batch, batch->scratchpad, PIPE_SHADER_FRAGMENT); + panfrost_batch_add_bo(batch, batch->scratchpad, MESA_SHADER_FRAGMENT); } return batch->scratchpad; diff --git a/src/gallium/drivers/panfrost/pan_screen.c b/src/gallium/drivers/panfrost/pan_screen.c index 300182b01fd..9160baf6c16 100644 --- a/src/gallium/drivers/panfrost/pan_screen.c +++ b/src/gallium/drivers/panfrost/pan_screen.c @@ -495,7 +495,7 @@ panfrost_init_shader_caps(struct panfrost_screen *screen) switch (i) { case MESA_SHADER_VERTEX: - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: case PIPE_SHADER_COMPUTE: break; default: @@ -515,7 +515,7 @@ panfrost_init_shader_caps(struct panfrost_screen *screen) caps->max_control_flow_depth = 1024; /* arbitrary */ /* Used as ABI on Midgard */ caps->max_inputs = dev->arch >= 9 ? 32 : 16; - caps->max_outputs = i == PIPE_SHADER_FRAGMENT ? 8 : PIPE_MAX_ATTRIBS; + caps->max_outputs = i == MESA_SHADER_FRAGMENT ? 8 : PIPE_MAX_ATTRIBS; caps->max_temps = 256; /* arbitrary */ caps->max_const_buffer0_size = 16 * 1024 * sizeof(float); STATIC_ASSERT(PAN_MAX_CONST_BUFFERS < 0x100); diff --git a/src/gallium/drivers/panfrost/pan_shader.c b/src/gallium/drivers/panfrost/pan_shader.c index 652db2c8ee2..0cc68e360e7 100644 --- a/src/gallium/drivers/panfrost/pan_shader.c +++ b/src/gallium/drivers/panfrost/pan_shader.c @@ -410,8 +410,8 @@ panfrost_update_shader_variant(struct panfrost_context *ctx, return; /* We need linking information, defer this */ - if ((type == PIPE_SHADER_FRAGMENT && !ctx->uncompiled[MESA_SHADER_VERTEX]) || - (type == MESA_SHADER_VERTEX && !ctx->uncompiled[PIPE_SHADER_FRAGMENT])) + if ((type == MESA_SHADER_FRAGMENT && !ctx->uncompiled[MESA_SHADER_VERTEX]) || + (type == MESA_SHADER_VERTEX && !ctx->uncompiled[MESA_SHADER_FRAGMENT])) return; /* Also defer, happens with GALLIUM_HUD */ @@ -450,13 +450,13 @@ panfrost_bind_vs_state(struct pipe_context *pctx, void *hwcso) /* Fragment shaders are linked with vertex shaders */ struct panfrost_context *ctx = pan_context(pctx); - panfrost_update_shader_variant(ctx, PIPE_SHADER_FRAGMENT); + panfrost_update_shader_variant(ctx, MESA_SHADER_FRAGMENT); } static void panfrost_bind_fs_state(struct pipe_context *pctx, void *hwcso) { - panfrost_bind_shader_state(pctx, hwcso, PIPE_SHADER_FRAGMENT); + panfrost_bind_shader_state(pctx, hwcso, MESA_SHADER_FRAGMENT); /* Vertex shaders are linked with fragment shaders */ struct panfrost_context *ctx = pan_context(pctx); diff --git a/src/gallium/drivers/r300/r300_fs.c b/src/gallium/drivers/r300/r300_fs.c index 2f679658acd..d4709687c05 100644 --- a/src/gallium/drivers/r300/r300_fs.c +++ b/src/gallium/drivers/r300/r300_fs.c @@ -204,7 +204,7 @@ static void r300_dummy_fragment_shader( struct ureg_src imm; /* Make a simple fragment shader which outputs (0, 0, 0, 1) */ - ureg = ureg_create(PIPE_SHADER_FRAGMENT); + ureg = ureg_create(MESA_SHADER_FRAGMENT); out = ureg_DECL_output(ureg, TGSI_SEMANTIC_COLOR, 0); imm = ureg_imm4f(ureg, 0, 0, 0, 1); diff --git a/src/gallium/drivers/r300/r300_screen.c b/src/gallium/drivers/r300/r300_screen.c index 187e143778b..2cf08c95e03 100644 --- a/src/gallium/drivers/r300/r300_screen.c +++ b/src/gallium/drivers/r300/r300_screen.c @@ -465,7 +465,7 @@ static void r300_init_shader_caps(struct r300_screen* r300screen) } caps->supported_irs = (1 << PIPE_SHADER_IR_NIR) | (1 << PIPE_SHADER_IR_TGSI); - caps = (struct pipe_shader_caps *)&r300screen->screen.shader_caps[PIPE_SHADER_FRAGMENT]; + caps = (struct pipe_shader_caps *)&r300screen->screen.shader_caps[MESA_SHADER_FRAGMENT]; caps->max_instructions = is_r500 || is_r400 ? 512 : 96; caps->max_alu_instructions = is_r500 || is_r400 ? 512 : 64; diff --git a/src/gallium/drivers/r300/r300_state.c b/src/gallium/drivers/r300/r300_state.c index 81e46a5e30d..3be4dca0677 100644 --- a/src/gallium/drivers/r300/r300_state.c +++ b/src/gallium/drivers/r300/r300_state.c @@ -1530,7 +1530,7 @@ static void r300_bind_sampler_states(struct pipe_context* pipe, assert(start == 0); - if (shader != PIPE_SHADER_FRAGMENT) + if (shader != MESA_SHADER_FRAGMENT) return; if (count > tex_units) @@ -1588,7 +1588,7 @@ static void r300_set_sampler_views(struct pipe_context* pipe, assert(start == 0); /* non-zero not handled yet */ - if (shader != PIPE_SHADER_FRAGMENT || count > tex_units) { + if (shader != MESA_SHADER_FRAGMENT || count > tex_units) { return; } @@ -2077,7 +2077,7 @@ static void r300_set_constant_buffer(struct pipe_context *pipe, case MESA_SHADER_VERTEX: cbuf = (struct r300_constant_buffer*)r300->vs_constants.state; break; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: cbuf = (struct r300_constant_buffer*)r300->fs_constants.state; break; default: @@ -2096,7 +2096,7 @@ static void r300_set_constant_buffer(struct pipe_context *pipe, return; } - if (shader == PIPE_SHADER_FRAGMENT || + if (shader == MESA_SHADER_FRAGMENT || (shader == MESA_SHADER_VERTEX && r300->screen->caps.has_tcl)) { cbuf->ptr = mapped; } @@ -2122,7 +2122,7 @@ static void r300_set_constant_buffer(struct pipe_context *pipe, draw_set_mapped_constant_buffer(r300->draw, MESA_SHADER_VERTEX, 0, mapped, cb->buffer_size); } - } else if (shader == PIPE_SHADER_FRAGMENT) { + } else if (shader == MESA_SHADER_FRAGMENT) { r300_mark_atom_dirty(r300, &r300->fs_constants); } } diff --git a/src/gallium/drivers/r600/evergreen_state.c b/src/gallium/drivers/r600/evergreen_state.c index 505655044fa..164a599773f 100644 --- a/src/gallium/drivers/r600/evergreen_state.c +++ b/src/gallium/drivers/r600/evergreen_state.c @@ -2378,7 +2378,7 @@ static void evergreen_emit_gs_constant_buffers(struct r600_context *rctx, struct static void evergreen_emit_ps_constant_buffers(struct r600_context *rctx, struct r600_atom *atom) { - evergreen_emit_constant_buffers(rctx, &rctx->constbuf_state[PIPE_SHADER_FRAGMENT], + evergreen_emit_constant_buffers(rctx, &rctx->constbuf_state[MESA_SHADER_FRAGMENT], EG_FETCH_CONSTANTS_OFFSET_PS, R_028140_ALU_CONST_BUFFER_SIZE_PS_0, R_028940_ALU_CONST_CACHE_PS_0, @@ -2507,7 +2507,7 @@ static void evergreen_emit_tes_sampler_views(struct r600_context *rctx, struct r static void evergreen_emit_ps_sampler_views(struct r600_context *rctx, struct r600_atom *atom) { - evergreen_emit_sampler_views(rctx, &rctx->samplers[PIPE_SHADER_FRAGMENT].views, + evergreen_emit_sampler_views(rctx, &rctx->samplers[MESA_SHADER_FRAGMENT].views, EG_FETCH_CONSTANTS_OFFSET_PS + R600_MAX_CONST_BUFFERS, 0); } @@ -2876,7 +2876,7 @@ static void evergreen_emit_tes_sampler_states(struct r600_context *rctx, struct static void evergreen_emit_ps_sampler_states(struct r600_context *rctx, struct r600_atom *atom) { - evergreen_emit_sampler_states(rctx, &rctx->samplers[PIPE_SHADER_FRAGMENT], 0, + evergreen_emit_sampler_states(rctx, &rctx->samplers[MESA_SHADER_FRAGMENT], 0, R_00A400_TD_PS_SAMPLER0_BORDER_INDEX, 0); } @@ -4437,11 +4437,11 @@ static void evergreen_set_shader_buffers(struct pipe_context *ctx, unsigned i, idx; unsigned old_mask; - if ((shader != PIPE_SHADER_FRAGMENT && + if ((shader != MESA_SHADER_FRAGMENT && shader != PIPE_SHADER_COMPUTE) || count == 0) return; - if (shader == PIPE_SHADER_FRAGMENT) + if (shader == MESA_SHADER_FRAGMENT) istate = &rctx->fragment_buffers; else if (shader == PIPE_SHADER_COMPUTE) istate = &rctx->compute_buffers; @@ -4519,7 +4519,7 @@ static void evergreen_set_shader_buffers(struct pipe_context *ctx, r600_mark_atom_dirty(rctx, &rctx->cb_misc_state.atom); } - if (shader == PIPE_SHADER_FRAGMENT) + if (shader == MESA_SHADER_FRAGMENT) r600_mark_atom_dirty(rctx, &istate->atom); } @@ -4539,17 +4539,17 @@ static void evergreen_set_shader_images(struct pipe_context *ctx, unsigned old_mask; struct r600_image_state *istate = NULL; int idx; - if (shader != PIPE_SHADER_FRAGMENT && shader != PIPE_SHADER_COMPUTE) + if (shader != MESA_SHADER_FRAGMENT && shader != PIPE_SHADER_COMPUTE) return; if (!count && !unbind_num_trailing_slots) return; - if (shader == PIPE_SHADER_FRAGMENT) + if (shader == MESA_SHADER_FRAGMENT) istate = &rctx->fragment_images; else if (shader == PIPE_SHADER_COMPUTE) istate = &rctx->compute_images; - assert (shader == PIPE_SHADER_FRAGMENT || shader == PIPE_SHADER_COMPUTE); + assert (shader == MESA_SHADER_FRAGMENT || shader == PIPE_SHADER_COMPUTE); old_mask = istate->enabled_mask; for (i = start_slot, idx = 0; i < start_slot + count; i++, idx++) { @@ -4733,7 +4733,7 @@ static void evergreen_set_shader_images(struct pipe_context *ctx, r600_mark_atom_dirty(rctx, &rctx->cb_misc_state.atom); } - if (shader == PIPE_SHADER_FRAGMENT) + if (shader == MESA_SHADER_FRAGMENT) r600_mark_atom_dirty(rctx, &istate->atom); } @@ -4820,7 +4820,7 @@ void evergreen_init_state_functions(struct r600_context *rctx) /* shader const */ r600_init_atom(rctx, &rctx->constbuf_state[MESA_SHADER_VERTEX].atom, id++, evergreen_emit_vs_constant_buffers, 0); r600_init_atom(rctx, &rctx->constbuf_state[MESA_SHADER_GEOMETRY].atom, id++, evergreen_emit_gs_constant_buffers, 0); - r600_init_atom(rctx, &rctx->constbuf_state[PIPE_SHADER_FRAGMENT].atom, id++, evergreen_emit_ps_constant_buffers, 0); + r600_init_atom(rctx, &rctx->constbuf_state[MESA_SHADER_FRAGMENT].atom, id++, evergreen_emit_ps_constant_buffers, 0); r600_init_atom(rctx, &rctx->constbuf_state[MESA_SHADER_TESS_CTRL].atom, id++, evergreen_emit_tcs_constant_buffers, 0); r600_init_atom(rctx, &rctx->constbuf_state[MESA_SHADER_TESS_EVAL].atom, id++, evergreen_emit_tes_constant_buffers, 0); r600_init_atom(rctx, &rctx->constbuf_state[PIPE_SHADER_COMPUTE].atom, id++, evergreen_emit_cs_constant_buffers, 0); @@ -4831,7 +4831,7 @@ void evergreen_init_state_functions(struct r600_context *rctx) r600_init_atom(rctx, &rctx->samplers[MESA_SHADER_GEOMETRY].states.atom, id++, evergreen_emit_gs_sampler_states, 0); r600_init_atom(rctx, &rctx->samplers[MESA_SHADER_TESS_CTRL].states.atom, id++, evergreen_emit_tcs_sampler_states, 0); r600_init_atom(rctx, &rctx->samplers[MESA_SHADER_TESS_EVAL].states.atom, id++, evergreen_emit_tes_sampler_states, 0); - r600_init_atom(rctx, &rctx->samplers[PIPE_SHADER_FRAGMENT].states.atom, id++, evergreen_emit_ps_sampler_states, 0); + r600_init_atom(rctx, &rctx->samplers[MESA_SHADER_FRAGMENT].states.atom, id++, evergreen_emit_ps_sampler_states, 0); r600_init_atom(rctx, &rctx->samplers[PIPE_SHADER_COMPUTE].states.atom, id++, evergreen_emit_cs_sampler_states, 0); /* resources */ r600_init_atom(rctx, &rctx->vertex_buffer_state.atom, id++, evergreen_fs_emit_vertex_buffers, 0); @@ -4840,7 +4840,7 @@ void evergreen_init_state_functions(struct r600_context *rctx) r600_init_atom(rctx, &rctx->samplers[MESA_SHADER_GEOMETRY].views.atom, id++, evergreen_emit_gs_sampler_views, 0); r600_init_atom(rctx, &rctx->samplers[MESA_SHADER_TESS_CTRL].views.atom, id++, evergreen_emit_tcs_sampler_views, 0); r600_init_atom(rctx, &rctx->samplers[MESA_SHADER_TESS_EVAL].views.atom, id++, evergreen_emit_tes_sampler_views, 0); - r600_init_atom(rctx, &rctx->samplers[PIPE_SHADER_FRAGMENT].views.atom, id++, evergreen_emit_ps_sampler_views, 0); + r600_init_atom(rctx, &rctx->samplers[MESA_SHADER_FRAGMENT].views.atom, id++, evergreen_emit_ps_sampler_views, 0); r600_init_atom(rctx, &rctx->samplers[PIPE_SHADER_COMPUTE].views.atom, id++, evergreen_emit_cs_sampler_views, 0); r600_init_atom(rctx, &rctx->vgt_state.atom, id++, r600_emit_vgt_state, 10); diff --git a/src/gallium/drivers/r600/r600_blit.c b/src/gallium/drivers/r600/r600_blit.c index 2197a16cb30..4a9db3c4fc4 100644 --- a/src/gallium/drivers/r600/r600_blit.c +++ b/src/gallium/drivers/r600/r600_blit.c @@ -75,7 +75,7 @@ static void r600_blitter_begin(struct pipe_context *ctx, enum r600_blitter_op op if (op & R600_SAVE_CONST_BUF0) { util_blitter_save_fragment_constant_buffer_slot(rctx->blitter, - &rctx->constbuf_state[PIPE_SHADER_FRAGMENT].cb[0]); + &rctx->constbuf_state[MESA_SHADER_FRAGMENT].cb[0]); } if (op & R600_SAVE_FRAMEBUFFER) @@ -83,12 +83,12 @@ static void r600_blitter_begin(struct pipe_context *ctx, enum r600_blitter_op op if (op & R600_SAVE_TEXTURES) { util_blitter_save_fragment_sampler_states( - rctx->blitter, util_last_bit(rctx->samplers[PIPE_SHADER_FRAGMENT].states.enabled_mask), - (void**)rctx->samplers[PIPE_SHADER_FRAGMENT].states.states); + rctx->blitter, util_last_bit(rctx->samplers[MESA_SHADER_FRAGMENT].states.enabled_mask), + (void**)rctx->samplers[MESA_SHADER_FRAGMENT].states.states); util_blitter_save_fragment_sampler_views( - rctx->blitter, util_last_bit(rctx->samplers[PIPE_SHADER_FRAGMENT].views.enabled_mask), - (struct pipe_sampler_view**)rctx->samplers[PIPE_SHADER_FRAGMENT].views.views); + rctx->blitter, util_last_bit(rctx->samplers[MESA_SHADER_FRAGMENT].views.enabled_mask), + (struct pipe_sampler_view**)rctx->samplers[MESA_SHADER_FRAGMENT].views.views); } if (op & R600_DISABLE_RENDER_COND) diff --git a/src/gallium/drivers/r600/r600_pipe.c b/src/gallium/drivers/r600/r600_pipe.c index 02118584ffe..3e5ece81b62 100644 --- a/src/gallium/drivers/r600/r600_pipe.c +++ b/src/gallium/drivers/r600/r600_pipe.c @@ -294,7 +294,7 @@ static void r600_init_shader_caps(struct r600_screen *rscreen) caps->max_tex_indirections = 16384; caps->max_control_flow_depth = 32; caps->max_inputs = i == MESA_SHADER_VERTEX ? 16 : 32; - caps->max_outputs = i == PIPE_SHADER_FRAGMENT ? 8 : 32; + caps->max_outputs = i == MESA_SHADER_FRAGMENT ? 8 : 32; caps->max_temps = 256; /* Max native temporaries. */ caps->max_const_buffer0_size = i == PIPE_SHADER_COMPUTE ? @@ -316,7 +316,7 @@ static void r600_init_shader_caps(struct r600_screen *rscreen) caps->max_shader_buffers = caps->max_shader_images = rscreen->b.family >= CHIP_CEDAR && - (i == PIPE_SHADER_FRAGMENT || i == PIPE_SHADER_COMPUTE) ? 8 : 0; + (i == MESA_SHADER_FRAGMENT || i == PIPE_SHADER_COMPUTE) ? 8 : 0; if (rscreen->b.family >= CHIP_CEDAR && rscreen->has_atomics) { diff --git a/src/gallium/drivers/r600/r600_pipe_common.c b/src/gallium/drivers/r600/r600_pipe_common.c index 631e63c9ebc..dc444615fb1 100644 --- a/src/gallium/drivers/r600/r600_pipe_common.c +++ b/src/gallium/drivers/r600/r600_pipe_common.c @@ -1212,7 +1212,7 @@ bool r600_common_screen_init(struct r600_common_screen *rscreen, uint8_t indirect_supported_mask = (uint8_t)BITFIELD_MASK(PIPE_SHADER_TYPES) & - ~BITFIELD_BIT(PIPE_SHADER_FRAGMENT); + ~BITFIELD_BIT(MESA_SHADER_FRAGMENT); rscreen->nir_options.support_indirect_inputs = indirect_supported_mask; rscreen->nir_options.support_indirect_outputs = indirect_supported_mask; diff --git a/src/gallium/drivers/r600/r600_pipe_common.h b/src/gallium/drivers/r600/r600_pipe_common.h index 2df65522ed6..de6ee8baa9c 100644 --- a/src/gallium/drivers/r600/r600_pipe_common.h +++ b/src/gallium/drivers/r600/r600_pipe_common.h @@ -49,7 +49,7 @@ struct u_log_context; /* Debug flags. */ #define DBG_VS (1 << MESA_SHADER_VERTEX) -#define DBG_PS (1 << PIPE_SHADER_FRAGMENT) +#define DBG_PS (1 << MESA_SHADER_FRAGMENT) #define DBG_GS (1 << MESA_SHADER_GEOMETRY) #define DBG_TCS (1 << MESA_SHADER_TESS_CTRL) #define DBG_TES (1 << MESA_SHADER_TESS_EVAL) diff --git a/src/gallium/drivers/r600/r600_shader.c b/src/gallium/drivers/r600/r600_shader.c index 4e6e644241f..4d8a4a1b9d8 100644 --- a/src/gallium/drivers/r600/r600_shader.c +++ b/src/gallium/drivers/r600/r600_shader.c @@ -261,7 +261,7 @@ int r600_pipe_shader_create(struct pipe_context *ctx, r600_update_vs_state(ctx, shader); } break; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: if (rctx->b.gfx_level >= EVERGREEN) { evergreen_update_ps_state(ctx, shader); } else { diff --git a/src/gallium/drivers/r600/r600_state.c b/src/gallium/drivers/r600/r600_state.c index 517971d3a64..380c9796f35 100644 --- a/src/gallium/drivers/r600/r600_state.c +++ b/src/gallium/drivers/r600/r600_state.c @@ -1751,7 +1751,7 @@ static void r600_emit_gs_constant_buffers(struct r600_context *rctx, struct r600 static void r600_emit_ps_constant_buffers(struct r600_context *rctx, struct r600_atom *atom) { - r600_emit_constant_buffers(rctx, &rctx->constbuf_state[PIPE_SHADER_FRAGMENT], + r600_emit_constant_buffers(rctx, &rctx->constbuf_state[MESA_SHADER_FRAGMENT], R600_FETCH_CONSTANTS_OFFSET_PS, R_028140_ALU_CONST_BUFFER_SIZE_PS_0, R_028940_ALU_CONST_CACHE_PS_0); @@ -1800,7 +1800,7 @@ static void r600_emit_gs_sampler_views(struct r600_context *rctx, struct r600_at static void r600_emit_ps_sampler_views(struct r600_context *rctx, struct r600_atom *atom) { - r600_emit_sampler_views(rctx, &rctx->samplers[PIPE_SHADER_FRAGMENT].views, R600_FETCH_CONSTANTS_OFFSET_PS + R600_MAX_CONST_BUFFERS); + r600_emit_sampler_views(rctx, &rctx->samplers[MESA_SHADER_FRAGMENT].views, R600_FETCH_CONSTANTS_OFFSET_PS + R600_MAX_CONST_BUFFERS); } static void r600_emit_sampler_states(struct r600_context *rctx, @@ -1883,7 +1883,7 @@ static void r600_emit_gs_sampler_states(struct r600_context *rctx, struct r600_a static void r600_emit_ps_sampler_states(struct r600_context *rctx, struct r600_atom *atom) { - r600_emit_sampler_states(rctx, &rctx->samplers[PIPE_SHADER_FRAGMENT], 0, R_00A400_TD_PS_SAMPLER0_BORDER_RED); + r600_emit_sampler_states(rctx, &rctx->samplers[MESA_SHADER_FRAGMENT], 0, R_00A400_TD_PS_SAMPLER0_BORDER_RED); } static void r600_emit_seamless_cube_map(struct r600_context *rctx, struct r600_atom *atom) @@ -3067,18 +3067,18 @@ void r600_init_state_functions(struct r600_context *rctx) /* shader const */ r600_init_atom(rctx, &rctx->constbuf_state[MESA_SHADER_VERTEX].atom, id++, r600_emit_vs_constant_buffers, 0); r600_init_atom(rctx, &rctx->constbuf_state[MESA_SHADER_GEOMETRY].atom, id++, r600_emit_gs_constant_buffers, 0); - r600_init_atom(rctx, &rctx->constbuf_state[PIPE_SHADER_FRAGMENT].atom, id++, r600_emit_ps_constant_buffers, 0); + r600_init_atom(rctx, &rctx->constbuf_state[MESA_SHADER_FRAGMENT].atom, id++, r600_emit_ps_constant_buffers, 0); /* sampler must be emitted before TA_CNTL_AUX otherwise DISABLE_CUBE_WRAP change * does not take effect (TA_CNTL_AUX emitted by r600_emit_seamless_cube_map) */ r600_init_atom(rctx, &rctx->samplers[MESA_SHADER_VERTEX].states.atom, id++, r600_emit_vs_sampler_states, 0); r600_init_atom(rctx, &rctx->samplers[MESA_SHADER_GEOMETRY].states.atom, id++, r600_emit_gs_sampler_states, 0); - r600_init_atom(rctx, &rctx->samplers[PIPE_SHADER_FRAGMENT].states.atom, id++, r600_emit_ps_sampler_states, 0); + r600_init_atom(rctx, &rctx->samplers[MESA_SHADER_FRAGMENT].states.atom, id++, r600_emit_ps_sampler_states, 0); /* resource */ r600_init_atom(rctx, &rctx->samplers[MESA_SHADER_VERTEX].views.atom, id++, r600_emit_vs_sampler_views, 0); r600_init_atom(rctx, &rctx->samplers[MESA_SHADER_GEOMETRY].views.atom, id++, r600_emit_gs_sampler_views, 0); - r600_init_atom(rctx, &rctx->samplers[PIPE_SHADER_FRAGMENT].views.atom, id++, r600_emit_ps_sampler_views, 0); + r600_init_atom(rctx, &rctx->samplers[MESA_SHADER_FRAGMENT].views.atom, id++, r600_emit_ps_sampler_views, 0); r600_init_atom(rctx, &rctx->vertex_buffer_state.atom, id++, r600_emit_vertex_buffers, 0); r600_init_atom(rctx, &rctx->vgt_state.atom, id++, r600_emit_vgt_state, 10); diff --git a/src/gallium/drivers/r600/r600_state_common.c b/src/gallium/drivers/r600/r600_state_common.c index 66933e5b62e..5212b905c41 100644 --- a/src/gallium/drivers/r600/r600_state_common.c +++ b/src/gallium/drivers/r600/r600_state_common.c @@ -745,7 +745,7 @@ static int r600_get_hw_atomic_count(const struct pipe_context *ctx, const struct r600_context *rctx = (struct r600_context *)ctx; int value = 0; switch (shader) { - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: case PIPE_SHADER_COMPUTE: default: break; @@ -815,10 +815,10 @@ static inline void r600_shader_selector_key(const struct pipe_context *ctx, key->gs.first_atomic_counter = r600_get_hw_atomic_count(ctx, MESA_SHADER_GEOMETRY); key->gs.tri_strip_adj_fix = rctx->gs_tri_strip_adj_fix; break; - case PIPE_SHADER_FRAGMENT: { + case MESA_SHADER_FRAGMENT: { if (rctx->ps_shader->info.images_declared) - key->ps.image_size_const_offset = util_last_bit(rctx->samplers[PIPE_SHADER_FRAGMENT].views.enabled_mask); - key->ps.first_atomic_counter = r600_get_hw_atomic_count(ctx, PIPE_SHADER_FRAGMENT); + key->ps.image_size_const_offset = util_last_bit(rctx->samplers[MESA_SHADER_FRAGMENT].views.enabled_mask); + key->ps.first_atomic_counter = r600_get_hw_atomic_count(ctx, MESA_SHADER_FRAGMENT); key->ps.color_two_side = rctx->rasterizer && rctx->rasterizer->two_side; key->ps.alpha_to_one = rctx->alpha_to_one && rctx->rasterizer && rctx->rasterizer->multisample_enable && @@ -866,7 +866,7 @@ r600_shader_precompile_key(const struct pipe_context *ctx, case MESA_SHADER_GEOMETRY: break; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: key->ps.image_size_const_offset = sel->info.file_max[TGSI_FILE_IMAGE]; /* This is used for gl_FragColor output expansion to the number @@ -1035,7 +1035,7 @@ static void *r600_create_shader_state(struct pipe_context *ctx, static void *r600_create_ps_state(struct pipe_context *ctx, const struct pipe_shader_state *state) { - return r600_create_shader_state(ctx, state, PIPE_SHADER_FRAGMENT); + return r600_create_shader_state(ctx, state, MESA_SHADER_FRAGMENT); } static void *r600_create_vs_state(struct pipe_context *ctx, @@ -1357,7 +1357,7 @@ void r600_update_driver_const_buffers(struct r600_context *rctx, bool compute_on } else if (info->ps_sample_pos_dirty) { - assert(sh == PIPE_SHADER_FRAGMENT); + assert(sh == MESA_SHADER_FRAGMENT); if (!size) { ptr = rctx->sample_positions; size = R600_UCP_SIZE; @@ -1397,7 +1397,7 @@ void r600_update_driver_const_buffers(struct r600_context *rctx, bool compute_on assert (size); if (sh == last_vertex_stage) memcpy(ptr, rctx->clip_state.state.ucp, R600_UCP_SIZE); - if (sh == PIPE_SHADER_FRAGMENT) + if (sh == MESA_SHADER_FRAGMENT) memcpy(ptr, rctx->sample_positions, R600_UCP_SIZE); if (sh == PIPE_SHADER_COMPUTE) memcpy(ptr, rctx->cs_block_grid_sizes, R600_CS_BLOCK_GRID_SIZE); @@ -1495,7 +1495,7 @@ void eg_setup_buffer_constants(struct r600_context *rctx, int shader_type) uint32_t *constants; uint32_t base_offset; - if (shader_type == PIPE_SHADER_FRAGMENT) { + if (shader_type == MESA_SHADER_FRAGMENT) { images = &rctx->fragment_images; } else if (shader_type == PIPE_SHADER_COMPUTE) { images = &rctx->compute_images; @@ -1552,7 +1552,7 @@ void r600_set_sample_locations_constant_buffer(struct r600_context *rctx) rctx->sample_positions[4*i + 3] = rctx->sample_positions[4*i + 1] - 0.5f; } - rctx->driver_consts[PIPE_SHADER_FRAGMENT].ps_sample_pos_dirty = true; + rctx->driver_consts[MESA_SHADER_FRAGMENT].ps_sample_pos_dirty = true; } static void update_shader_atom(struct pipe_context *ctx, @@ -1999,9 +1999,9 @@ static bool r600_update_derived_state(struct r600_context *rctx) need_buf_const = rctx->ps_shader->current->shader.uses_tex_buffers || rctx->ps_shader->current->shader.has_txq_cube_array_z_comp; if (need_buf_const) { if (rctx->b.gfx_level < EVERGREEN) - r600_setup_buffer_constants(rctx, PIPE_SHADER_FRAGMENT); + r600_setup_buffer_constants(rctx, MESA_SHADER_FRAGMENT); else - eg_setup_buffer_constants(rctx, PIPE_SHADER_FRAGMENT); + eg_setup_buffer_constants(rctx, MESA_SHADER_FRAGMENT); } } diff --git a/src/gallium/drivers/r600/sfn/sfn_assembler.cpp b/src/gallium/drivers/r600/sfn/sfn_assembler.cpp index f4e51604f16..559ada89c38 100644 --- a/src/gallium/drivers/r600/sfn/sfn_assembler.cpp +++ b/src/gallium/drivers/r600/sfn/sfn_assembler.cpp @@ -132,7 +132,7 @@ AssamblerVisitor::AssamblerVisitor(r600_shader *sh, const r600_shader_key& key, ps_alpha_to_one(key.ps.alpha_to_one), m_legacy_math_rules(legacy_math_rules) { - if (m_shader->processor_type == PIPE_SHADER_FRAGMENT) + if (m_shader->processor_type == MESA_SHADER_FRAGMENT) m_max_color_exports = MAX2(m_key.ps.nr_cbufs, 1); if (m_shader->processor_type == MESA_SHADER_VERTEX && m_shader->ninput > 0) @@ -741,7 +741,7 @@ AssamblerVisitor::visit(const FetchInstr& fetch_instr) } m_bc->cf_last->vpm = - (m_bc->type == PIPE_SHADER_FRAGMENT) && fetch_instr.has_fetch_flag(FetchInstr::vpm); + (m_bc->type == MESA_SHADER_FRAGMENT) && fetch_instr.has_fetch_flag(FetchInstr::vpm); m_bc->cf_last->barrier = 1; } @@ -820,7 +820,7 @@ AssamblerVisitor::visit(const RatInstr& instr) instr.data_swz(2) == PIPE_SWIZZLE_MAX); } - cf->vpm = m_bc->type == PIPE_SHADER_FRAGMENT; + cf->vpm = m_bc->type == MESA_SHADER_FRAGMENT; cf->barrier = 1; cf->mark = instr.need_ack(); cf->output.elem_size = instr.elm_size(); @@ -929,7 +929,7 @@ AssamblerVisitor::visit(const ControlFlowInstr& instr) emit_endif(); break; case ControlFlowInstr::cf_loop_begin: { - bool use_vpm = m_shader->processor_type == PIPE_SHADER_FRAGMENT && + bool use_vpm = m_shader->processor_type == MESA_SHADER_FRAGMENT && instr.has_instr_flag(Instr::vpm) && !instr.has_instr_flag(Instr::helper); emit_loop_begin(use_vpm); @@ -1005,7 +1005,7 @@ AssamblerVisitor::visit(const GDSInstr& instr) m_result = false; return; } - m_bc->cf_last->vpm = PIPE_SHADER_FRAGMENT == m_bc->type; + m_bc->cf_last->vpm = MESA_SHADER_FRAGMENT == m_bc->type; m_bc->cf_last->barrier = 1; } @@ -1130,7 +1130,7 @@ void AssamblerVisitor::emit_loop_begin(bool vpm) { r600_bytecode_add_cfinst(m_bc, CF_OP_LOOP_START_DX10); - m_bc->cf_last->vpm = vpm && m_bc->type == PIPE_SHADER_FRAGMENT; + m_bc->cf_last->vpm = vpm && m_bc->type == MESA_SHADER_FRAGMENT; m_jump_tracker.push(m_bc->cf_last, jt_loop); m_callstack.push(FC_LOOP); ++m_loop_nesting; diff --git a/src/gallium/drivers/r600/sfn/sfn_shader_fs.cpp b/src/gallium/drivers/r600/sfn/sfn_shader_fs.cpp index 2bad1fe25f1..cf02c9efe31 100644 --- a/src/gallium/drivers/r600/sfn/sfn_shader_fs.cpp +++ b/src/gallium/drivers/r600/sfn/sfn_shader_fs.cpp @@ -33,7 +33,7 @@ FragmentShader::FragmentShader(const r600_shader_key& key): void FragmentShader::do_get_shader_info(r600_shader *sh_info) { - sh_info->processor_type = PIPE_SHADER_FRAGMENT; + sh_info->processor_type = MESA_SHADER_FRAGMENT; sh_info->ps_color_export_mask = m_color_export_mask; sh_info->ps_export_highest = m_export_highest; diff --git a/src/gallium/drivers/radeonsi/si_barrier.c b/src/gallium/drivers/radeonsi/si_barrier.c index ab93bafef4c..dcccb559301 100644 --- a/src/gallium/drivers/radeonsi/si_barrier.c +++ b/src/gallium/drivers/radeonsi/si_barrier.c @@ -509,10 +509,10 @@ void si_barrier_before_internal_op(struct si_context *sctx, unsigned flags, } /* Don't sync if buffers are idle. */ - const unsigned ps_mask = SI_BIND_CONSTANT_BUFFER(PIPE_SHADER_FRAGMENT) | - SI_BIND_SHADER_BUFFER(PIPE_SHADER_FRAGMENT) | - SI_BIND_IMAGE_BUFFER(PIPE_SHADER_FRAGMENT) | - SI_BIND_SAMPLER_BUFFER(PIPE_SHADER_FRAGMENT); + const unsigned ps_mask = SI_BIND_CONSTANT_BUFFER(MESA_SHADER_FRAGMENT) | + SI_BIND_SHADER_BUFFER(MESA_SHADER_FRAGMENT) | + SI_BIND_IMAGE_BUFFER(MESA_SHADER_FRAGMENT) | + SI_BIND_SAMPLER_BUFFER(MESA_SHADER_FRAGMENT); const unsigned cs_mask = SI_BIND_CONSTANT_BUFFER(PIPE_SHADER_COMPUTE) | SI_BIND_SHADER_BUFFER(PIPE_SHADER_COMPUTE) | SI_BIND_IMAGE_BUFFER(PIPE_SHADER_COMPUTE) | diff --git a/src/gallium/drivers/radeonsi/si_blit.c b/src/gallium/drivers/radeonsi/si_blit.c index dd244ca6461..7710d2c35df 100644 --- a/src/gallium/drivers/radeonsi/si_blit.c +++ b/src/gallium/drivers/radeonsi/si_blit.c @@ -37,7 +37,7 @@ void si_blitter_begin(struct si_context *sctx, enum si_blitter_op op) if (op & SI_SAVE_FRAGMENT_STATE) { struct pipe_constant_buffer fs_cb = {}; - si_get_pipe_constant_buffer(sctx, PIPE_SHADER_FRAGMENT, 0, &fs_cb); + si_get_pipe_constant_buffer(sctx, MESA_SHADER_FRAGMENT, 0, &fs_cb); if (op & SI_SAVE_FRAGMENT_CONSTANT) util_blitter_save_fragment_constant_buffer_slot(sctx->blitter, &fs_cb); @@ -58,10 +58,10 @@ void si_blitter_begin(struct si_context *sctx, enum si_blitter_op op) if (op & SI_SAVE_TEXTURES) { util_blitter_save_fragment_sampler_states( - sctx->blitter, 2, (void **)sctx->samplers[PIPE_SHADER_FRAGMENT].sampler_states); + sctx->blitter, 2, (void **)sctx->samplers[MESA_SHADER_FRAGMENT].sampler_states); util_blitter_save_fragment_sampler_views(sctx->blitter, 2, - sctx->samplers[PIPE_SHADER_FRAGMENT].views); + sctx->samplers[MESA_SHADER_FRAGMENT].views); } if (op & SI_DISABLE_RENDER_COND) @@ -757,12 +757,12 @@ static void si_check_render_feedback(struct si_context *sctx) if (!si_any_colorbuffer_written(sctx)) return; - if (sctx->shaders[PIPE_SHADER_FRAGMENT].cso) { - struct si_shader_info *info = &sctx->shaders[PIPE_SHADER_FRAGMENT].cso->info; + if (sctx->shaders[MESA_SHADER_FRAGMENT].cso) { + struct si_shader_info *info = &sctx->shaders[MESA_SHADER_FRAGMENT].cso->info; - si_check_render_feedback_images(sctx, &sctx->images[PIPE_SHADER_FRAGMENT], + si_check_render_feedback_images(sctx, &sctx->images[MESA_SHADER_FRAGMENT], BITFIELD_MASK(info->base.num_images)); - si_check_render_feedback_textures(sctx, &sctx->samplers[PIPE_SHADER_FRAGMENT], + si_check_render_feedback_textures(sctx, &sctx->samplers[MESA_SHADER_FRAGMENT], info->base.textures_used); } @@ -863,7 +863,7 @@ void gfx6_decompress_textures(struct si_context *sctx, unsigned shader_mask) if (sctx->uses_bindless_images & shader_mask) si_decompress_resident_images(sctx); - if (shader_mask & BITFIELD_BIT(PIPE_SHADER_FRAGMENT)) { + if (shader_mask & BITFIELD_BIT(MESA_SHADER_FRAGMENT)) { if (sctx->ps_uses_fbfetch) { struct pipe_surface *cb0 = &sctx->framebuffer.state.cbufs[0]; si_decompress_color_texture(sctx, (struct si_texture *)cb0->texture, @@ -890,7 +890,7 @@ void gfx11_decompress_textures(struct si_context *sctx, unsigned shader_mask) if (sctx->uses_bindless_samplers & shader_mask) si_decompress_resident_depth_textures(sctx); - if (shader_mask & BITFIELD_BIT(PIPE_SHADER_FRAGMENT)) + if (shader_mask & BITFIELD_BIT(MESA_SHADER_FRAGMENT)) si_check_render_feedback(sctx); } @@ -1337,7 +1337,7 @@ void si_gfx_blit(struct pipe_context *ctx, const struct pipe_blit_info *info) fs = _mesa_hash_table_u64_search(sctx->ps_resolve_shaders, key.key); if (!fs) { struct ac_ps_resolve_options options = { - .nir_options = sctx->b.screen->nir_options[PIPE_SHADER_FRAGMENT], + .nir_options = sctx->b.screen->nir_options[MESA_SHADER_FRAGMENT], .info = &sctx->screen->info, .use_aco = sctx->screen->use_aco, .no_fmask = sctx->screen->debug_flags & DBG(NO_FMASK), diff --git a/src/gallium/drivers/radeonsi/si_descriptors.c b/src/gallium/drivers/radeonsi/si_descriptors.c index e8773e02a7b..03c434bafab 100644 --- a/src/gallium/drivers/radeonsi/si_descriptors.c +++ b/src/gallium/drivers/radeonsi/si_descriptors.c @@ -480,7 +480,7 @@ static void si_set_sampler_views(struct si_context *sctx, unsigned shader, } } - if (shader == PIPE_SHADER_FRAGMENT && + if (shader == MESA_SHADER_FRAGMENT && vi_dcc_enabled(tex, sview->base.u.tex.first_level) && p_atomic_read(&tex->framebuffers_bound)) sctx->need_check_render_feedback = true; @@ -791,7 +791,7 @@ static void si_set_shader_image(struct si_context *ctx, unsigned shader, unsigne images->display_dcc_store_mask &= ~(1u << slot); } - if (shader == PIPE_SHADER_FRAGMENT && vi_dcc_enabled(tex, level) && + if (shader == MESA_SHADER_FRAGMENT && vi_dcc_enabled(tex, level) && p_atomic_read(&tex->framebuffers_bound)) ctx->need_check_render_feedback = true; } @@ -1182,7 +1182,7 @@ static void si_set_constant_buffer(struct si_context *sctx, struct si_buffer_res void si_get_inline_uniform_state(union si_shader_key *key, enum pipe_shader_type shader, bool *inline_uniforms, uint32_t **inlined_values) { - if (shader == PIPE_SHADER_FRAGMENT) { + if (shader == MESA_SHADER_FRAGMENT) { *inline_uniforms = key->ps.opt.inline_uniforms; *inlined_values = key->ps.opt.inlined_uniform_values; } else { @@ -1201,7 +1201,7 @@ void si_invalidate_inlinable_uniforms(struct si_context *sctx, enum pipe_shader_ si_get_inline_uniform_state(&sctx->shaders[shader].key, shader, &inline_uniforms, &inlined_values); if (inline_uniforms) { - if (shader == PIPE_SHADER_FRAGMENT) + if (shader == MESA_SHADER_FRAGMENT) sctx->shaders[shader].key.ps.opt.inline_uniforms = false; else sctx->shaders[shader].key.ge.opt.inline_uniforms = false; @@ -1255,7 +1255,7 @@ static void si_set_inlinable_constants(struct pipe_context *ctx, if (!inline_uniforms) { /* It's the first time we set the constants. Always update shaders. */ - if (shader == PIPE_SHADER_FRAGMENT) + if (shader == MESA_SHADER_FRAGMENT) sctx->shaders[shader].key.ps.opt.inline_uniforms = true; else sctx->shaders[shader].key.ge.opt.inline_uniforms = true; @@ -2240,7 +2240,7 @@ static void si_emit_graphics_shader_pointers(struct si_context *sctx, unsigned i gfx12_push_consecutive_shader_pointers(sctx, SI_DESCS_SHADER_MASK(TESS_EVAL), sh_base[MESA_SHADER_TESS_EVAL], gfx); gfx12_push_consecutive_shader_pointers(sctx, SI_DESCS_SHADER_MASK(FRAGMENT), - sh_base[PIPE_SHADER_FRAGMENT], gfx); + sh_base[MESA_SHADER_FRAGMENT], gfx); gfx12_push_consecutive_shader_pointers(sctx, SI_DESCS_SHADER_MASK(TESS_CTRL), sh_base[MESA_SHADER_TESS_CTRL], gfx); gfx12_push_consecutive_shader_pointers(sctx, SI_DESCS_SHADER_MASK(GEOMETRY), @@ -2270,7 +2270,7 @@ static void si_emit_graphics_shader_pointers(struct si_context *sctx, unsigned i gfx11_push_consecutive_shader_pointers(sctx, SI_DESCS_SHADER_MASK(TESS_EVAL), sh_base[MESA_SHADER_TESS_EVAL], gfx); gfx11_push_consecutive_shader_pointers(sctx, SI_DESCS_SHADER_MASK(FRAGMENT), - sh_base[PIPE_SHADER_FRAGMENT], gfx); + sh_base[MESA_SHADER_FRAGMENT], gfx); gfx11_push_consecutive_shader_pointers(sctx, SI_DESCS_SHADER_MASK(TESS_CTRL), sh_base[MESA_SHADER_TESS_CTRL], gfx); gfx11_push_consecutive_shader_pointers(sctx, SI_DESCS_SHADER_MASK(GEOMETRY), @@ -2301,7 +2301,7 @@ static void si_emit_graphics_shader_pointers(struct si_context *sctx, unsigned i si_emit_consecutive_shader_pointers(sctx, SI_DESCS_SHADER_MASK(TESS_EVAL), sh_base[MESA_SHADER_TESS_EVAL], gfx); si_emit_consecutive_shader_pointers(sctx, SI_DESCS_SHADER_MASK(FRAGMENT), - sh_base[PIPE_SHADER_FRAGMENT], gfx); + sh_base[MESA_SHADER_FRAGMENT], gfx); si_emit_consecutive_shader_pointers(sctx, SI_DESCS_SHADER_MASK(TESS_CTRL), sh_base[MESA_SHADER_TESS_CTRL], gfx); si_emit_consecutive_shader_pointers(sctx, SI_DESCS_SHADER_MASK(GEOMETRY), @@ -2967,7 +2967,7 @@ void si_init_all_descriptors(struct si_context *sctx) si_set_user_data_base(sctx, MESA_SHADER_GEOMETRY, si_get_user_data_base(sctx->gfx_level, TESS_OFF, GS_OFF, NGG_OFF, MESA_SHADER_GEOMETRY)); - si_set_user_data_base(sctx, PIPE_SHADER_FRAGMENT, R_00B030_SPI_SHADER_USER_DATA_PS_0); + si_set_user_data_base(sctx, MESA_SHADER_FRAGMENT, R_00B030_SPI_SHADER_USER_DATA_PS_0); } void si_release_all_descriptors(struct si_context *sctx) diff --git a/src/gallium/drivers/radeonsi/si_get.c b/src/gallium/drivers/radeonsi/si_get.c index d74dfe3f2e8..124cfcac3e1 100644 --- a/src/gallium/drivers/radeonsi/si_get.c +++ b/src/gallium/drivers/radeonsi/si_get.c @@ -938,7 +938,7 @@ void si_init_shader_caps(struct si_screen *sscreen) caps->max_tex_indirections = caps->max_control_flow_depth = 16384; caps->max_inputs = i == MESA_SHADER_VERTEX ? SI_MAX_ATTRIBS : 32; - caps->max_outputs = i == PIPE_SHADER_FRAGMENT ? 8 : 32; + caps->max_outputs = i == MESA_SHADER_FRAGMENT ? 8 : 32; caps->max_temps = 256; /* Max native temporaries. */ caps->max_const_buffer0_size = 1 << 26; /* 64 MB */ caps->max_const_buffers = SI_NUM_CONST_BUFFERS; diff --git a/src/gallium/drivers/radeonsi/si_sqtt.c b/src/gallium/drivers/radeonsi/si_sqtt.c index cb78acc4088..f6c80fb6bae 100644 --- a/src/gallium/drivers/radeonsi/si_sqtt.c +++ b/src/gallium/drivers/radeonsi/si_sqtt.c @@ -720,7 +720,7 @@ si_sqtt_pipe_to_rgp_shader_stage(union si_shader_key *key, enum pipe_shader_type return RGP_HW_STAGE_VS; case MESA_SHADER_GEOMETRY: return RGP_HW_STAGE_GS; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: return RGP_HW_STAGE_PS; case PIPE_SHADER_COMPUTE: return RGP_HW_STAGE_CS; @@ -756,7 +756,7 @@ si_sqtt_add_code_object(struct si_context *sctx, continue; shader = &sctx->cs_shader_state.program->shader; hw_stage = RGP_HW_STAGE_CS; - } else if (i <= PIPE_SHADER_FRAGMENT) { + } else if (i <= MESA_SHADER_FRAGMENT) { if (!sctx->shaders[i].cso || !sctx->shaders[i].current) continue; shader = sctx->shaders[i].current; diff --git a/src/gallium/drivers/radeonsi/si_state.c b/src/gallium/drivers/radeonsi/si_state.c index 816faf8bc0a..a3cd7bcaefa 100644 --- a/src/gallium/drivers/radeonsi/si_state.c +++ b/src/gallium/drivers/radeonsi/si_state.c @@ -733,7 +733,7 @@ static bool si_check_blend_dst_sampler_noop(struct si_context *sctx) sel->info.writes_1_if_tex_is_1 != 0xff) { /* Now check if the texture is cleared to 1 */ int unit = sctx->shader.ps.cso->info.writes_1_if_tex_is_1 - 1; - struct si_samplers *samp = &sctx->samplers[PIPE_SHADER_FRAGMENT]; + struct si_samplers *samp = &sctx->samplers[MESA_SHADER_FRAGMENT]; if ((1u << unit) & samp->enabled_mask) { struct si_texture* tex = (struct si_texture*) samp->views[unit]->texture; if (tex->is_depth && @@ -1763,13 +1763,13 @@ static void si_bind_dsa_state(struct pipe_context *ctx, void *state) BITFIELD_BIT(MESA_SHADER_VERTEX) | BITFIELD_BIT(MESA_SHADER_TESS_EVAL) | BITFIELD_BIT(MESA_SHADER_GEOMETRY) | - BITFIELD_BIT(PIPE_SHADER_FRAGMENT); + BITFIELD_BIT(MESA_SHADER_FRAGMENT); } if (old_dsa->depth_enabled != dsa->depth_enabled || old_dsa->stencil_enabled != dsa->stencil_enabled) { si_ps_key_update_framebuffer_blend_dsa_rasterizer(sctx); - sctx->dirty_shaders_mask |= BITFIELD_BIT(PIPE_SHADER_FRAGMENT); + sctx->dirty_shaders_mask |= BITFIELD_BIT(MESA_SHADER_FRAGMENT); } if (sctx->occlusion_query_mode == SI_OCCLUSION_QUERY_MODE_PRECISE_BOOLEAN && @@ -2805,7 +2805,7 @@ static void si_set_framebuffer_state(struct pipe_context *ctx, BITFIELD_BIT(MESA_SHADER_VERTEX) | BITFIELD_BIT(MESA_SHADER_TESS_EVAL) | BITFIELD_BIT(MESA_SHADER_GEOMETRY) | - BITFIELD_BIT(PIPE_SHADER_FRAGMENT); + BITFIELD_BIT(MESA_SHADER_FRAGMENT); if (sctx->gfx_level < GFX12 && !sctx->decompression_enabled) { /* Prevent textures decompression when the framebuffer state @@ -3647,7 +3647,7 @@ static void si_set_min_samples(struct pipe_context *ctx, unsigned min_samples) sctx->ps_iter_samples = min_samples; si_ps_key_update_framebuffer_rasterizer_sample_shading(sctx); - sctx->dirty_shaders_mask |= BITFIELD_BIT(PIPE_SHADER_FRAGMENT); + sctx->dirty_shaders_mask |= BITFIELD_BIT(MESA_SHADER_FRAGMENT); si_update_ps_iter_samples(sctx); } diff --git a/src/gallium/drivers/radeonsi/si_state.h b/src/gallium/drivers/radeonsi/si_state.h index 924ac719dd6..48abfddd8e5 100644 --- a/src/gallium/drivers/radeonsi/si_state.h +++ b/src/gallium/drivers/radeonsi/si_state.h @@ -15,7 +15,7 @@ extern "C" { #endif -#define SI_NUM_GRAPHICS_SHADERS (PIPE_SHADER_FRAGMENT + 1) +#define SI_NUM_GRAPHICS_SHADERS (MESA_SHADER_FRAGMENT + 1) #define SI_NUM_SHADERS (PIPE_SHADER_COMPUTE + 1) #define SI_NUM_VERTEX_BUFFERS SI_MAX_ATTRIBS diff --git a/src/gallium/drivers/radeonsi/si_state_draw.cpp b/src/gallium/drivers/radeonsi/si_state_draw.cpp index 2b7c68d03c4..4a3f7aa3b05 100644 --- a/src/gallium/drivers/radeonsi/si_state_draw.cpp +++ b/src/gallium/drivers/radeonsi/si_state_draw.cpp @@ -49,7 +49,7 @@ static bool si_update_shaders(struct si_context *sctx) bool is_gs_state_changed = (sctx->dirty_shaders_mask & BITFIELD_BIT(MESA_SHADER_GEOMETRY)) != 0; bool is_ps_state_changed = - (sctx->dirty_shaders_mask & BITFIELD_BIT(PIPE_SHADER_FRAGMENT)) != 0; + (sctx->dirty_shaders_mask & BITFIELD_BIT(MESA_SHADER_FRAGMENT)) != 0; struct pipe_context *ctx = (struct pipe_context *)sctx; struct si_shader *old_vs = si_get_vs_inline(sctx, HAS_TESS, HAS_GS)->current; diff --git a/src/gallium/drivers/radeonsi/si_state_shaders.cpp b/src/gallium/drivers/radeonsi/si_state_shaders.cpp index ea3d43646ec..88bd7137d0e 100644 --- a/src/gallium/drivers/radeonsi/si_state_shaders.cpp +++ b/src/gallium/drivers/radeonsi/si_state_shaders.cpp @@ -2440,7 +2440,7 @@ void si_vs_ps_key_update_rast_prim_smooth_stipple(struct si_context *sctx) ps_key->ps.mono.poly_line_smoothing != old_poly_line_smoothing || ps_key->ps.mono.point_smoothing != old_point_smoothing || ps_key->ps.opt.force_front_face_input != old_force_front_face_input) - sctx->dirty_shaders_mask |= BITFIELD_BIT(PIPE_SHADER_FRAGMENT); + sctx->dirty_shaders_mask |= BITFIELD_BIT(MESA_SHADER_FRAGMENT); } static void si_get_vs_key_outputs(struct si_context *sctx, struct si_shader_selector *vs, @@ -2675,7 +2675,7 @@ void si_ps_key_update_framebuffer_blend_dsa_rasterizer(struct si_context *sctx) /* Update shaders only if the key changed. */ if (memcmp(&key->ps.part.epilog, &old_epilog, sizeof(old_epilog)) || key->ps.opt.prefer_mono != old_prefer_mono) { - sctx->dirty_shaders_mask |= BITFIELD_BIT(PIPE_SHADER_FRAGMENT); + sctx->dirty_shaders_mask |= BITFIELD_BIT(MESA_SHADER_FRAGMENT); } else { assert(memcmp(&key->ps, &old_key, sizeof(old_key)) == 0); } @@ -2698,7 +2698,7 @@ void si_ps_key_update_rasterizer(struct si_context *sctx) if (key->ps.part.prolog.flatshade_colors != old_flatshade_colors || key->ps.part.epilog.clamp_color != old_clamp_color) - sctx->dirty_shaders_mask |= BITFIELD_BIT(PIPE_SHADER_FRAGMENT); + sctx->dirty_shaders_mask |= BITFIELD_BIT(MESA_SHADER_FRAGMENT); } void si_ps_key_update_dsa(struct si_context *sctx) @@ -2813,7 +2813,7 @@ void si_ps_key_update_framebuffer_rasterizer_sample_shading(struct si_context *s /* Update shaders only if the key changed. */ if (memcmp(&key->ps.part.prolog, &old_prolog, sizeof(old_prolog)) || key->ps.mono.interpolate_at_sample_force_center != old_interpolate_at_sample_force_center) - sctx->dirty_shaders_mask |= BITFIELD_BIT(PIPE_SHADER_FRAGMENT); + sctx->dirty_shaders_mask |= BITFIELD_BIT(MESA_SHADER_FRAGMENT); } /* Compute the key for the hw shader variant */ @@ -3932,7 +3932,7 @@ static void si_bind_ps_shader(struct pipe_context *ctx, void *state) sctx->shader.ps.cso = sel; sctx->shader.ps.current = (sel && sel->variants_count) ? sel->variants[0] : NULL; - si_update_common_shader_state(sctx, sel, PIPE_SHADER_FRAGMENT); + si_update_common_shader_state(sctx, sel, MESA_SHADER_FRAGMENT); if (sel) { if (sctx->ia_multi_vgt_param_key.u.uses_tess) si_update_tess_uses_prim_id(sctx); diff --git a/src/gallium/drivers/softpipe/sp_context.c b/src/gallium/drivers/softpipe/sp_context.c index def0510174c..a1585a5d481 100644 --- a/src/gallium/drivers/softpipe/sp_context.c +++ b/src/gallium/drivers/softpipe/sp_context.c @@ -247,7 +247,7 @@ softpipe_create_context(struct pipe_screen *screen, } } - softpipe->fs_machine = tgsi_exec_machine_create(PIPE_SHADER_FRAGMENT); + softpipe->fs_machine = tgsi_exec_machine_create(MESA_SHADER_FRAGMENT); /* setup quad rendering stages */ softpipe->quad.shade = sp_quad_shade_stage(softpipe); diff --git a/src/gallium/drivers/softpipe/sp_quad_fs.c b/src/gallium/drivers/softpipe/sp_quad_fs.c index 08802868134..1c03b656b18 100644 --- a/src/gallium/drivers/softpipe/sp_quad_fs.c +++ b/src/gallium/drivers/softpipe/sp_quad_fs.c @@ -110,7 +110,7 @@ shade_quads(struct quad_stage *qs, unsigned i, nr_quads = 0; tgsi_exec_set_constant_buffers(machine, PIPE_MAX_CONSTANT_BUFFERS, - softpipe->mapped_constants[PIPE_SHADER_FRAGMENT]); + softpipe->mapped_constants[MESA_SHADER_FRAGMENT]); machine->InterpCoefs = quads[0]->coef; diff --git a/src/gallium/drivers/softpipe/sp_screen.c b/src/gallium/drivers/softpipe/sp_screen.c index 3d4904fb7a7..6e85cd23b34 100644 --- a/src/gallium/drivers/softpipe/sp_screen.c +++ b/src/gallium/drivers/softpipe/sp_screen.c @@ -212,7 +212,7 @@ softpipe_init_shader_caps(struct softpipe_screen *sp_screen) break; } FALLTHROUGH; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: case PIPE_SHADER_COMPUTE: tgsi_exec_init_shader_caps(caps); break; diff --git a/src/gallium/drivers/softpipe/sp_state_derived.c b/src/gallium/drivers/softpipe/sp_state_derived.c index a7db73bdae2..6d539f110de 100644 --- a/src/gallium/drivers/softpipe/sp_state_derived.c +++ b/src/gallium/drivers/softpipe/sp_state_derived.c @@ -304,7 +304,7 @@ update_tgsi_samplers( struct softpipe_context *softpipe ) set_shader_sampler(softpipe, MESA_SHADER_VERTEX, softpipe->vs->max_sampler); - set_shader_sampler(softpipe, PIPE_SHADER_FRAGMENT, + set_shader_sampler(softpipe, MESA_SHADER_FRAGMENT, softpipe->fs_variant->info.file_max[TGSI_FILE_SAMPLER]); if (softpipe->gs) { set_shader_sampler(softpipe, MESA_SHADER_GEOMETRY, @@ -345,9 +345,9 @@ update_fragment_shader(struct softpipe_context *softpipe, unsigned prim) softpipe->fs_variant->prepare(softpipe->fs_variant, softpipe->fs_machine, (struct tgsi_sampler *) softpipe-> - tgsi.sampler[PIPE_SHADER_FRAGMENT], - (struct tgsi_image *)softpipe->tgsi.image[PIPE_SHADER_FRAGMENT], - (struct tgsi_buffer *)softpipe->tgsi.buffer[PIPE_SHADER_FRAGMENT]); + tgsi.sampler[MESA_SHADER_FRAGMENT], + (struct tgsi_image *)softpipe->tgsi.image[MESA_SHADER_FRAGMENT], + (struct tgsi_buffer *)softpipe->tgsi.buffer[MESA_SHADER_FRAGMENT]); } else { softpipe->fs_variant = NULL; diff --git a/src/gallium/drivers/softpipe/sp_surface.c b/src/gallium/drivers/softpipe/sp_surface.c index 2f4b7b992bd..1ed9b42fb1d 100644 --- a/src/gallium/drivers/softpipe/sp_surface.c +++ b/src/gallium/drivers/softpipe/sp_surface.c @@ -90,11 +90,11 @@ static void sp_blit(struct pipe_context *pipe, /*util_blitter_save_sample_mask(sp->blitter, sp->sample_mask);*/ util_blitter_save_framebuffer(sp->blitter, &sp->framebuffer); util_blitter_save_fragment_sampler_states(sp->blitter, - sp->num_samplers[PIPE_SHADER_FRAGMENT], - (void**)sp->samplers[PIPE_SHADER_FRAGMENT]); + sp->num_samplers[MESA_SHADER_FRAGMENT], + (void**)sp->samplers[MESA_SHADER_FRAGMENT]); util_blitter_save_fragment_sampler_views(sp->blitter, - sp->num_sampler_views[PIPE_SHADER_FRAGMENT], - sp->sampler_views[PIPE_SHADER_FRAGMENT]); + sp->num_sampler_views[MESA_SHADER_FRAGMENT], + sp->sampler_views[MESA_SHADER_FRAGMENT]); util_blitter_save_render_condition(sp->blitter, sp->render_cond_query, sp->render_cond_cond, sp->render_cond_mode); util_blitter_blit(sp->blitter, info, NULL); diff --git a/src/gallium/drivers/softpipe/sp_tex_sample.c b/src/gallium/drivers/softpipe/sp_tex_sample.c index 57e3720123f..4adb6e37cd5 100644 --- a/src/gallium/drivers/softpipe/sp_tex_sample.c +++ b/src/gallium/drivers/softpipe/sp_tex_sample.c @@ -3556,7 +3556,7 @@ compute_lambda_func softpipe_get_lambda_func(const struct pipe_sampler_view *view, enum pipe_shader_type shader) { - if (shader != PIPE_SHADER_FRAGMENT) + if (shader != MESA_SHADER_FRAGMENT) return compute_lambda_vert; switch (view->target) { diff --git a/src/gallium/drivers/svga/svga_draw.c b/src/gallium/drivers/svga/svga_draw.c index 8fbb7327f86..778b67732f9 100644 --- a/src/gallium/drivers/svga/svga_draw.c +++ b/src/gallium/drivers/svga/svga_draw.c @@ -375,7 +375,7 @@ svga_validate_sampler_resources(struct svga_context *svga, } } - if (shader == PIPE_SHADER_FRAGMENT && + if (shader == MESA_SHADER_FRAGMENT && svga->curr.rast->templ.poly_stipple_enable) { const unsigned unit = svga_fs_variant(svga->state.hw_draw.fs)->pstipple_sampler_unit; diff --git a/src/gallium/drivers/svga/svga_pipe_blit.c b/src/gallium/drivers/svga/svga_pipe_blit.c index dce04f081fb..f84ed168e45 100644 --- a/src/gallium/drivers/svga/svga_pipe_blit.c +++ b/src/gallium/drivers/svga/svga_pipe_blit.c @@ -624,11 +624,11 @@ try_blit(struct svga_context *svga, const struct pipe_blit_info *blit_info) util_blitter_save_sample_mask(svga->blitter, svga->curr.sample_mask, 0); util_blitter_save_framebuffer(svga->blitter, &svga->curr.framebuffer.base); util_blitter_save_fragment_sampler_states(svga->blitter, - svga->curr.num_samplers[PIPE_SHADER_FRAGMENT], - (void**)svga->curr.sampler[PIPE_SHADER_FRAGMENT]); + svga->curr.num_samplers[MESA_SHADER_FRAGMENT], + (void**)svga->curr.sampler[MESA_SHADER_FRAGMENT]); util_blitter_save_fragment_sampler_views(svga->blitter, - svga->curr.num_sampler_views[PIPE_SHADER_FRAGMENT], - svga->curr.sampler_views[PIPE_SHADER_FRAGMENT]); + svga->curr.num_sampler_views[MESA_SHADER_FRAGMENT], + svga->curr.sampler_views[MESA_SHADER_FRAGMENT]); if (!can_create_src_view) { struct pipe_resource template; diff --git a/src/gallium/drivers/svga/svga_pipe_clear.c b/src/gallium/drivers/svga/svga_pipe_clear.c index c9488ddafe7..41d292dfe8a 100644 --- a/src/gallium/drivers/svga/svga_pipe_clear.c +++ b/src/gallium/drivers/svga/svga_pipe_clear.c @@ -42,7 +42,7 @@ begin_blit(struct svga_context *svga) util_blitter_save_stencil_ref(svga->blitter, &svga->curr.stencil_ref); util_blitter_save_sample_mask(svga->blitter, svga->curr.sample_mask, 0); util_blitter_save_fragment_constant_buffer_slot(svga->blitter, - &svga->curr.constbufs[PIPE_SHADER_FRAGMENT][0]); + &svga->curr.constbufs[MESA_SHADER_FRAGMENT][0]); } diff --git a/src/gallium/drivers/svga/svga_pipe_constants.c b/src/gallium/drivers/svga/svga_pipe_constants.c index 40fd87e4743..4a4d1ae939b 100644 --- a/src/gallium/drivers/svga/svga_pipe_constants.c +++ b/src/gallium/drivers/svga/svga_pipe_constants.c @@ -66,7 +66,7 @@ svga_set_constant_buffer(struct pipe_context *pipe, svga->curr.constbufs[shader][index].user_buffer = NULL; /* not used */ if (index == 0) { - if (shader == PIPE_SHADER_FRAGMENT) + if (shader == MESA_SHADER_FRAGMENT) svga->dirty |= SVGA_NEW_FS_CONSTS; else if (shader == MESA_SHADER_VERTEX) svga->dirty |= SVGA_NEW_VS_CONSTS; @@ -79,7 +79,7 @@ svga_set_constant_buffer(struct pipe_context *pipe, else if (shader == PIPE_SHADER_COMPUTE) svga->dirty |= SVGA_NEW_CS_CONSTS; } else { - if (shader == PIPE_SHADER_FRAGMENT) + if (shader == MESA_SHADER_FRAGMENT) svga->dirty |= SVGA_NEW_FS_CONST_BUFFER; else if (shader == MESA_SHADER_VERTEX) svga->dirty |= SVGA_NEW_VS_CONST_BUFFER; diff --git a/src/gallium/drivers/svga/svga_pipe_fs.c b/src/gallium/drivers/svga/svga_pipe_fs.c index 895ca9d9612..b15fa058e65 100644 --- a/src/gallium/drivers/svga/svga_pipe_fs.c +++ b/src/gallium/drivers/svga/svga_pipe_fs.c @@ -29,7 +29,7 @@ svga_create_fs_state(struct pipe_context *pipe, SVGA_STATS_TIME_PUSH(svga_sws(svga), SVGA_STATS_TIME_CREATEFS); fs = (struct svga_fragment_shader *) - svga_create_shader(pipe, templ, PIPE_SHADER_FRAGMENT, + svga_create_shader(pipe, templ, MESA_SHADER_FRAGMENT, sizeof(struct svga_fragment_shader)); if (!fs) goto done; @@ -67,7 +67,7 @@ svga_bind_fs_state(struct pipe_context *pipe, void *shader) svga->dirty |= SVGA_NEW_FS; /* Check if shader uses samplers */ - svga_set_curr_shader_use_samplers_flag(svga, PIPE_SHADER_FRAGMENT, + svga_set_curr_shader_use_samplers_flag(svga, MESA_SHADER_FRAGMENT, svga_shader_use_samplers(&fs->base)); } diff --git a/src/gallium/drivers/svga/svga_pipe_sampler.c b/src/gallium/drivers/svga/svga_pipe_sampler.c index 5883dcef498..8efa8debdc2 100644 --- a/src/gallium/drivers/svga/svga_pipe_sampler.c +++ b/src/gallium/drivers/svga/svga_pipe_sampler.c @@ -286,7 +286,7 @@ svga_bind_sampler_states(struct pipe_context *pipe, assert(start + num <= PIPE_MAX_SAMPLERS); /* Pre-VGPU10 only supports FS textures */ - if (!svga_have_vgpu10(svga) && shader != PIPE_SHADER_FRAGMENT) + if (!svga_have_vgpu10(svga) && shader != MESA_SHADER_FRAGMENT) return; for (unsigned i = 0; i < num; i++) { @@ -404,7 +404,7 @@ svga_set_sampler_views(struct pipe_context *pipe, assert(start + num <= ARRAY_SIZE(svga->curr.sampler_views[shader])); /* Pre-VGPU10 only supports FS textures */ - if (!svga_have_vgpu10(svga) && shader != PIPE_SHADER_FRAGMENT) { + if (!svga_have_vgpu10(svga) && shader != MESA_SHADER_FRAGMENT) { for (unsigned i = 0; i < num; i++) { struct pipe_sampler_view *view = views[i]; pipe_sampler_view_reference(&view, NULL); diff --git a/src/gallium/drivers/svga/svga_screen.c b/src/gallium/drivers/svga/svga_screen.c index 37c4780df8f..31185d35496 100644 --- a/src/gallium/drivers/svga/svga_screen.c +++ b/src/gallium/drivers/svga/svga_screen.c @@ -195,7 +195,7 @@ svga_get_compiler_options(struct pipe_screen *pscreen, else if (sws->have_vgpu10) return &svga_vgpu10_compiler_options; else { - if (shader == PIPE_SHADER_FRAGMENT) + if (shader == MESA_SHADER_FRAGMENT) return &svga_vgpu9_fragment_compiler_options; else return &svga_vgpu9_vertex_compiler_options; @@ -228,7 +228,7 @@ vgpu9_init_shader_caps(struct svga_screen *svgascreen) caps->indirect_const_addr = true; caps->supported_irs = (1 << PIPE_SHADER_IR_TGSI) | (1 << PIPE_SHADER_IR_NIR); - caps = (struct pipe_shader_caps *)&svgascreen->screen.shader_caps[PIPE_SHADER_FRAGMENT]; + caps = (struct pipe_shader_caps *)&svgascreen->screen.shader_caps[MESA_SHADER_FRAGMENT]; caps->max_instructions = caps->max_alu_instructions = @@ -284,7 +284,7 @@ vgpu10_init_shader_caps(struct svga_screen *svgascreen) caps->max_control_flow_depth = 64; switch (i) { - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: caps->max_inputs = VGPU10_MAX_PS_INPUTS; caps->max_outputs = VGPU10_MAX_PS_OUTPUTS; break; diff --git a/src/gallium/drivers/svga/svga_shader.c b/src/gallium/drivers/svga/svga_shader.c index 5353bc9e22f..c90515d0bca 100644 --- a/src/gallium/drivers/svga/svga_shader.c +++ b/src/gallium/drivers/svga/svga_shader.c @@ -776,7 +776,7 @@ svga_new_shader_variant(struct svga_context *svga, enum pipe_shader_type type) struct svga_shader_variant *variant; switch (type) { - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: variant = CALLOC(1, sizeof(struct svga_fs_variant)); break; case MESA_SHADER_GEOMETRY: diff --git a/src/gallium/drivers/svga/svga_shader.h b/src/gallium/drivers/svga/svga_shader.h index b7584a716f5..281896b985f 100644 --- a/src/gallium/drivers/svga/svga_shader.h +++ b/src/gallium/drivers/svga/svga_shader.h @@ -536,7 +536,7 @@ svga_shader_type(enum pipe_shader_type shader) return SVGA3D_SHADERTYPE_VS; case MESA_SHADER_GEOMETRY: return SVGA3D_SHADERTYPE_GS; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: return SVGA3D_SHADERTYPE_PS; case MESA_SHADER_TESS_CTRL: return SVGA3D_SHADERTYPE_HS; diff --git a/src/gallium/drivers/svga/svga_state_constants.c b/src/gallium/drivers/svga/svga_state_constants.c index fb47e85a32d..efd32668986 100644 --- a/src/gallium/drivers/svga/svga_state_constants.c +++ b/src/gallium/drivers/svga/svga_state_constants.c @@ -146,7 +146,7 @@ svga_get_extra_fs_constants(const struct svga_context *svga, float *dest) unsigned count = 0; count += svga_get_extra_constants_common(svga, variant, - PIPE_SHADER_FRAGMENT, dest); + MESA_SHADER_FRAGMENT, dest); assert(count <= MAX_EXTRA_CONSTS); @@ -409,7 +409,7 @@ emit_const_range(struct svga_context *svga, enum pipe_error ret; assert(shader == MESA_SHADER_VERTEX || - shader == PIPE_SHADER_FRAGMENT); + shader == MESA_SHADER_FRAGMENT); assert(!svga_have_vgpu10(svga)); #if MESA_DEBUG @@ -576,7 +576,7 @@ emit_consts_vgpu9(struct svga_context *svga, enum pipe_shader_type shader) variant = svga->state.hw_draw.vs; count = svga_get_extra_vs_constants(svga, (float *) extras); break; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: variant = svga->state.hw_draw.fs; count = svga_get_extra_fs_constants(svga, (float *) extras); break; @@ -885,7 +885,7 @@ emit_consts_vgpu10(struct svga_context *svga, enum pipe_shader_type shader) assert(shader == MESA_SHADER_VERTEX || shader == MESA_SHADER_GEOMETRY || - shader == PIPE_SHADER_FRAGMENT || + shader == MESA_SHADER_FRAGMENT || shader == MESA_SHADER_TESS_CTRL || shader == MESA_SHADER_TESS_EVAL || shader == PIPE_SHADER_COMPUTE); @@ -897,7 +897,7 @@ emit_consts_vgpu10(struct svga_context *svga, enum pipe_shader_type shader) variant = svga->state.hw_draw.vs; extra_count = svga_get_extra_vs_constants(svga, (float *) extras); break; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: variant = svga->state.hw_draw.fs; extra_count = svga_get_extra_fs_constants(svga, (float *) extras); break; @@ -1053,9 +1053,9 @@ emit_fs_consts(struct svga_context *svga, uint64_t dirty) /* SVGA_NEW_FS_CONSTS */ if (svga_have_vgpu10(svga)) { - ret = emit_consts_vgpu10(svga, PIPE_SHADER_FRAGMENT); + ret = emit_consts_vgpu10(svga, MESA_SHADER_FRAGMENT); } else { - ret = emit_consts_vgpu9(svga, PIPE_SHADER_FRAGMENT); + ret = emit_consts_vgpu9(svga, MESA_SHADER_FRAGMENT); } return ret; @@ -1075,7 +1075,7 @@ emit_fs_constbuf(struct svga_context *svga, uint64_t dirty) /* SVGA_NEW_FS_CONSTBUF */ assert(svga_have_vgpu10(svga)); - ret = emit_constbuf_vgpu10(svga, PIPE_SHADER_FRAGMENT); + ret = emit_constbuf_vgpu10(svga, MESA_SHADER_FRAGMENT); return ret; } @@ -1451,7 +1451,7 @@ update_rawbuf(struct svga_context *svga, uint64 dirty) { uint64_t rawbuf_dirtybit[] = { SVGA_NEW_VS_RAW_BUFFER, /* MESA_SHADER_VERTEX */ - SVGA_NEW_FS_RAW_BUFFER, /* PIPE_SHADER_FRAGMENT */ + SVGA_NEW_FS_RAW_BUFFER, /* MESA_SHADER_FRAGMENT */ SVGA_NEW_GS_RAW_BUFFER, /* MESA_SHADER_GEOMETRY */ SVGA_NEW_TCS_RAW_BUFFER, /* MESA_SHADER_TESS_CTRL */ SVGA_NEW_TES_RAW_BUFFER, /* MESA_SHADER_TESS_EVAL */ diff --git a/src/gallium/drivers/svga/svga_state_fs.c b/src/gallium/drivers/svga/svga_state_fs.c index d1569dfedc5..07b8d23a2f3 100644 --- a/src/gallium/drivers/svga/svga_state_fs.c +++ b/src/gallium/drivers/svga/svga_state_fs.c @@ -45,7 +45,7 @@ get_dummy_fragment_shader(void) struct ureg_src src; struct ureg_dst dst; - ureg = ureg_create(PIPE_SHADER_FRAGMENT); + ureg = ureg_create(MESA_SHADER_FRAGMENT); if (!ureg) return NULL; @@ -101,7 +101,7 @@ make_fs_key(const struct svga_context *svga, struct svga_fragment_shader *fs, struct svga_compile_key *key) { - const enum pipe_shader_type shader = PIPE_SHADER_FRAGMENT; + const enum pipe_shader_type shader = MESA_SHADER_FRAGMENT; unsigned i; memset(key, 0, sizeof *key); diff --git a/src/gallium/drivers/svga/svga_state_sampler.c b/src/gallium/drivers/svga/svga_state_sampler.c index cd47b319661..8cc9b9be589 100644 --- a/src/gallium/drivers/svga/svga_state_sampler.c +++ b/src/gallium/drivers/svga/svga_state_sampler.c @@ -355,7 +355,7 @@ update_sampler_resources(struct svga_context *svga, uint64_t dirty) surface = svga_resource_handle(sv->base.texture); ret = SVGA3D_vgpu10_SetShaderResources( svga->swc, - svga_shader_type(PIPE_SHADER_FRAGMENT), + svga_shader_type(MESA_SHADER_FRAGMENT), unit, /* startView */ 1, &sv->id, @@ -395,7 +395,7 @@ update_samplers(struct svga_context *svga, uint64_t dirty ) const struct svga_sampler_state *sampler = svga->curr.sampler[shader][i]; /* _NEW_FS */ - if (shader == PIPE_SHADER_FRAGMENT) { + if (shader == MESA_SHADER_FRAGMENT) { struct svga_fs_variant *fs = svga_fs_variant(svga->state.hw_draw.fs); @@ -493,7 +493,7 @@ update_samplers(struct svga_context *svga, uint64_t dirty ) return PIPE_OK; /* probably out of memory */ } - if (svga->state.hw_draw.samplers[PIPE_SHADER_FRAGMENT][unit] + if (svga->state.hw_draw.samplers[MESA_SHADER_FRAGMENT][unit] != sampler->id[0]) { ret = SVGA3D_vgpu10_SetSamplers(svga->swc, 1, /* count */ @@ -504,10 +504,10 @@ update_samplers(struct svga_context *svga, uint64_t dirty ) return ret; /* save the polygon stipple sampler in the hw draw state */ - svga->state.hw_draw.samplers[PIPE_SHADER_FRAGMENT][unit] = + svga->state.hw_draw.samplers[MESA_SHADER_FRAGMENT][unit] = sampler->id[0]; } - svga->state.hw_draw.num_samplers[PIPE_SHADER_FRAGMENT]++; + svga->state.hw_draw.num_samplers[MESA_SHADER_FRAGMENT]++; } return ret; diff --git a/src/gallium/drivers/svga/svga_state_tgsi_transform.c b/src/gallium/drivers/svga/svga_state_tgsi_transform.c index ff3d0ac0ac5..551ee94ffd9 100644 --- a/src/gallium/drivers/svga/svga_state_tgsi_transform.c +++ b/src/gallium/drivers/svga/svga_state_tgsi_transform.c @@ -53,7 +53,7 @@ bind_shader(struct svga_context *svga, case MESA_SHADER_VERTEX: svga->pipe.bind_vs_state(&svga->pipe, shader); break; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: /** * Avoid pipe->bind_fs_state call because it goes through aapoint * layer. We loose linked list of all transformed shaders if aapoint @@ -88,7 +88,7 @@ create_shader(struct svga_context *svga, switch (shader_type) { case MESA_SHADER_VERTEX: return svga->pipe.create_vs_state(&svga->pipe, state); - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: /** * Avoid pipe->create_fs_state call because it goes through aapoint * layer. We loose linked list of all transformed shaders if aapoint diff --git a/src/gallium/drivers/svga/svga_state_tss.c b/src/gallium/drivers/svga/svga_state_tss.c index 4d9003f33b2..04f0c910e7d 100644 --- a/src/gallium/drivers/svga/svga_state_tss.c +++ b/src/gallium/drivers/svga/svga_state_tss.c @@ -25,7 +25,7 @@ void svga_cleanup_tss_binding(struct svga_context *svga) { - const enum pipe_shader_type shader = PIPE_SHADER_FRAGMENT; + const enum pipe_shader_type shader = MESA_SHADER_FRAGMENT; unsigned i; for (i = 0; i < ARRAY_SIZE(svga->state.hw_draw.views); i++) { @@ -123,7 +123,7 @@ emit_tex_binding_unit(struct svga_context *svga, static enum pipe_error update_tss_binding(struct svga_context *svga, uint64_t dirty ) { - const enum pipe_shader_type shader = PIPE_SHADER_FRAGMENT; + const enum pipe_shader_type shader = MESA_SHADER_FRAGMENT; bool reemit = svga->rebind.flags.texture_samplers; unsigned i; unsigned count = MAX2(svga->curr.num_sampler_views[shader], @@ -365,7 +365,7 @@ emit_tss_unit(struct svga_context *svga, unsigned unit, static enum pipe_error update_tss(struct svga_context *svga, uint64_t dirty ) { - const enum pipe_shader_type shader = PIPE_SHADER_FRAGMENT; + const enum pipe_shader_type shader = MESA_SHADER_FRAGMENT; unsigned i; struct ts_queue queue; diff --git a/src/gallium/drivers/svga/svga_swtnl_draw.c b/src/gallium/drivers/svga/svga_swtnl_draw.c index 89993bd575c..bd6df9ad6ea 100644 --- a/src/gallium/drivers/svga/svga_swtnl_draw.c +++ b/src/gallium/drivers/svga/svga_swtnl_draw.c @@ -165,7 +165,7 @@ svga_init_swtnl(struct svga_context *svga) util_blitter_cache_all_shaders(svga->blitter); const nir_alu_type bool_type = - screen->screen.shader_caps[PIPE_SHADER_FRAGMENT].integers ? + screen->screen.shader_caps[MESA_SHADER_FRAGMENT].integers ? nir_type_bool32 : nir_type_float32; if (!screen->haveLineSmooth) diff --git a/src/gallium/drivers/svga/svga_tgsi.c b/src/gallium/drivers/svga/svga_tgsi.c index fb36bb9209f..202af324fe2 100644 --- a/src/gallium/drivers/svga/svga_tgsi.c +++ b/src/gallium/drivers/svga/svga_tgsi.c @@ -126,7 +126,7 @@ svga_shader_emit_header(struct svga_shader_emitter *emit) memset(&header, 0, sizeof header); switch (emit->unit) { - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: header.value = SVGA3D_PS_30; break; case MESA_SHADER_VERTEX: @@ -173,7 +173,7 @@ svga_tgsi_vgpu9_translate(struct svga_context *svga, emit.imm_start = emit.info.file_max[TGSI_FILE_CONSTANT] + 1; - if (unit == PIPE_SHADER_FRAGMENT) + if (unit == MESA_SHADER_FRAGMENT) emit.imm_start += key->num_unnormalized_coords; if (unit == MESA_SHADER_VERTEX) { @@ -219,7 +219,7 @@ svga_tgsi_vgpu9_translate(struct svga_context *svga, memcpy(&variant->key, key, sizeof(*key)); variant->id = UTIL_BITMASK_INVALID_INDEX; - if (unit == PIPE_SHADER_FRAGMENT) { + if (unit == MESA_SHADER_FRAGMENT) { struct svga_fs_variant *fs_variant = svga_fs_variant(variant); fs_variant->pstipple_sampler_unit = emit.pstipple_sampler_unit; @@ -433,7 +433,7 @@ svga_tgsi_scan_shader(struct svga_shader *shader) /* Convert TGSI outputs semantic. * Fragment shader does not have varying outputs but fragment results. */ - if (shader->stage == PIPE_SHADER_FRAGMENT) { + if (shader->stage == MESA_SHADER_FRAGMENT) { for (unsigned i = 0; i < info->num_outputs; i++) { info->output_semantic_name[i] = svga_tgsi_to_gl_frag_result_semantic( @@ -455,7 +455,7 @@ svga_tgsi_scan_shader(struct svga_shader *shader) info->constbuf0_num_uniforms = tgsi_info->const_file_max[0] + 1; switch (tgsi_info->processor) { - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: info->fs.color0_writes_all_cbufs = tgsi_info->properties[TGSI_PROPERTY_FS_COLOR0_WRITES_ALL_CBUFS]; break; diff --git a/src/gallium/drivers/svga/svga_tgsi_decl_sm30.c b/src/gallium/drivers/svga/svga_tgsi_decl_sm30.c index b404cfc14bc..fc08919ab9d 100644 --- a/src/gallium/drivers/svga/svga_tgsi_decl_sm30.c +++ b/src/gallium/drivers/svga/svga_tgsi_decl_sm30.c @@ -312,7 +312,7 @@ ps30_output(struct svga_shader_emitter *emit, { switch (semantic.Name) { case TGSI_SEMANTIC_COLOR: - if (emit->unit == PIPE_SHADER_FRAGMENT) { + if (emit->unit == MESA_SHADER_FRAGMENT) { if (emit->key.fs.white_fragments) { /* Used for XOR logicop mode */ emit->output_map[idx] = dst_register(SVGA3DREG_TEMP, @@ -565,7 +565,7 @@ svga_translate_decl_sm30(struct svga_shader_emitter *emit, switch (decl->Declaration.File) { case TGSI_FILE_SAMPLER: - assert (emit->unit == PIPE_SHADER_FRAGMENT); + assert (emit->unit == MESA_SHADER_FRAGMENT); /* just keep track of the number of samplers here. * Will emit the declaration in the helpers function. */ diff --git a/src/gallium/drivers/svga/svga_tgsi_insn.c b/src/gallium/drivers/svga/svga_tgsi_insn.c index 7f3e1c5b1db..c4c44c6d13d 100644 --- a/src/gallium/drivers/svga/svga_tgsi_insn.c +++ b/src/gallium/drivers/svga/svga_tgsi_insn.c @@ -202,7 +202,7 @@ translate_src_register(const struct svga_shader_emitter *emit, /* Indirect addressing. */ if (reg->Register.Indirect) { - if (emit->unit == PIPE_SHADER_FRAGMENT) { + if (emit->unit == MESA_SHADER_FRAGMENT) { /* Pixel shaders have only loop registers for relative * addressing into inputs. Ignore the redundant address * register, the contents of aL should be in sync with it. @@ -1566,7 +1566,7 @@ emit_cmp(struct svga_shader_emitter *emit, return emit_conditional(emit, PIPE_FUNC_LESS, dst, src0, zero, src1, src2); } else { - assert(emit->unit == PIPE_SHADER_FRAGMENT); + assert(emit->unit == MESA_SHADER_FRAGMENT); /* CMP DST, SRC0, SRC2, SRC1 */ return submit_op3(emit, inst_token(SVGA3DOP_CMP), dst, @@ -1996,7 +1996,7 @@ emit_mov(struct svga_shader_emitter *emit, const struct tgsi_full_src_register *src = &insn->Src[0]; const struct tgsi_full_dst_register *dst = &insn->Dst[0]; - if (emit->unit == PIPE_SHADER_FRAGMENT && + if (emit->unit == MESA_SHADER_FRAGMENT && dst->Register.File == TGSI_FILE_OUTPUT && dst->Register.Index == 0 && src->Register.File == TGSI_FILE_CONSTANT && @@ -2144,7 +2144,7 @@ emit_arl(struct svga_shader_emitter *emit, const struct tgsi_full_instruction *insn) { ++emit->current_arl; - if (emit->unit == PIPE_SHADER_FRAGMENT) { + if (emit->unit == MESA_SHADER_FRAGMENT) { /* MOVA not present in pixel shader instruction set. * Ignore this instruction altogether since it is * only used for loop counters -- and for that @@ -3086,7 +3086,7 @@ emit_ps_postamble(struct svga_shader_emitter *emit) /* Potentially override output colors with white for XOR * logicop workaround. */ - if (emit->unit == PIPE_SHADER_FRAGMENT && + if (emit->unit == MESA_SHADER_FRAGMENT && emit->key.fs.white_fragments) { struct src_register one = get_one_immediate(emit); @@ -3095,7 +3095,7 @@ emit_ps_postamble(struct svga_shader_emitter *emit) emit->true_color_output[i], one)) return false; - } else if (emit->unit == PIPE_SHADER_FRAGMENT && + } else if (emit->unit == MESA_SHADER_FRAGMENT && i < emit->key.fs.write_color0_to_n_cbufs) { /* Write temp color output [0] to true output [i] */ if (!submit_op1(emit, inst_token(SVGA3DOP_MOV), @@ -3475,7 +3475,7 @@ emit_adjusted_vertex_attribs(struct svga_shader_emitter *emit) static bool needs_to_create_common_immediate(const struct svga_shader_emitter *emit) { - if (emit->unit == PIPE_SHADER_FRAGMENT) { + if (emit->unit == MESA_SHADER_FRAGMENT) { if (emit->key.fs.light_twoside) return true; @@ -3655,7 +3655,7 @@ svga_shader_emit_helpers(struct svga_shader_emitter *emit) create_arl_consts(emit); } - if (emit->unit == PIPE_SHADER_FRAGMENT) { + if (emit->unit == MESA_SHADER_FRAGMENT) { if (!svga_shader_emit_samplers_decl(emit)) return false; @@ -3702,7 +3702,7 @@ svga_shader_emit_instructions(struct svga_shader_emitter *emit, bool helpers_emitted = false; unsigned line_nr = 0; - if (emit->unit == PIPE_SHADER_FRAGMENT && emit->key.fs.pstipple) { + if (emit->unit == MESA_SHADER_FRAGMENT && emit->key.fs.pstipple) { unsigned unit; new_tokens = util_pstipple_create_fragment_shader(tokens, &unit, 0, diff --git a/src/gallium/drivers/svga/svga_tgsi_vgpu10.c b/src/gallium/drivers/svga/svga_tgsi_vgpu10.c index e2b1e9f6b0a..54b2a790df5 100644 --- a/src/gallium/drivers/svga/svga_tgsi_vgpu10.c +++ b/src/gallium/drivers/svga/svga_tgsi_vgpu10.c @@ -663,7 +663,7 @@ check_register_index(struct svga_shader_emitter_v10 *emit, index >= emit->max_vs_inputs) || (emit->unit == MESA_SHADER_GEOMETRY && index >= emit->max_gs_inputs) || - (emit->unit == PIPE_SHADER_FRAGMENT && + (emit->unit == MESA_SHADER_FRAGMENT && index >= VGPU10_MAX_PS_INPUTS) || (emit->unit == MESA_SHADER_TESS_CTRL && index >= VGPU11_MAX_HS_INPUT_CONTROL_POINTS) || @@ -686,7 +686,7 @@ check_register_index(struct svga_shader_emitter_v10 *emit, index >= emit->max_vs_outputs) || (emit->unit == MESA_SHADER_GEOMETRY && index >= VGPU10_MAX_GS_OUTPUTS) || - (emit->unit == PIPE_SHADER_FRAGMENT && + (emit->unit == MESA_SHADER_FRAGMENT && index >= VGPU10_MAX_PS_OUTPUTS) || (emit->unit == MESA_SHADER_TESS_CTRL && index >= VGPU11_MAX_HS_OUTPUTS + 2) || @@ -819,7 +819,7 @@ translate_shader_type(unsigned type) return VGPU10_VERTEX_SHADER; case MESA_SHADER_GEOMETRY: return VGPU10_GEOMETRY_SHADER; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: return VGPU10_PIXEL_SHADER; case MESA_SHADER_TESS_CTRL: return VGPU10_HULL_SHADER; @@ -1320,7 +1320,7 @@ emit_dst_register(struct svga_shader_emitter_v10 *emit, index = emit->gs.viewport_index_tmp_index; } } - else if (emit->unit == PIPE_SHADER_FRAGMENT) { + else if (emit->unit == MESA_SHADER_FRAGMENT) { if (sem_name == TGSI_SEMANTIC_POSITION) { /* Fragment depth output register */ operand0.value = 0; @@ -1561,7 +1561,7 @@ emit_src_register(struct svga_shader_emitter_v10 *emit, operand0.value = operand1.value = 0; - if (emit->unit == PIPE_SHADER_FRAGMENT){ + if (emit->unit == MESA_SHADER_FRAGMENT){ if (file == TGSI_FILE_INPUT) { if (index == emit->fs.face_input_index) { /* Replace INPUT[FACE] with TEMP[FACE] */ @@ -4104,7 +4104,7 @@ emit_fragdepth_output_declaration(struct svga_shader_emitter_v10 *emit) VGPU10OperandToken0 operand0; VGPU10NameToken name_token; - assert(emit->unit == PIPE_SHADER_FRAGMENT); + assert(emit->unit == MESA_SHADER_FRAGMENT); opcode0.value = operand0.value = name_token.value = 0; @@ -4128,7 +4128,7 @@ emit_samplemask_output_declaration(struct svga_shader_emitter_v10 *emit) VGPU10OperandToken0 operand0; VGPU10NameToken name_token; - assert(emit->unit == PIPE_SHADER_FRAGMENT); + assert(emit->unit == MESA_SHADER_FRAGMENT); assert(emit->version >= 41); opcode0.value = operand0.value = name_token.value = 0; @@ -4227,7 +4227,7 @@ emit_vertex_output_declaration(struct svga_shader_emitter_v10 *emit, unsigned name, type; unsigned final_mask = VGPU10_OPERAND_4_COMPONENT_MASK_ALL; - assert(emit->unit != PIPE_SHADER_FRAGMENT && + assert(emit->unit != MESA_SHADER_FRAGMENT && emit->unit != PIPE_SHADER_COMPUTE); switch (semantic_name) { @@ -4731,7 +4731,7 @@ emit_system_value_declaration(struct svga_shader_emitter_v10 *emit, map_tgsi_semantic_to_sgn_name(semantic_name)); break; case TGSI_SEMANTIC_SAMPLEID: - assert(emit->unit == PIPE_SHADER_FRAGMENT); + assert(emit->unit == MESA_SHADER_FRAGMENT); emit->fs.sample_id_sys_index = index; index = alloc_system_value_index(emit, index); emit_input_declaration(emit, VGPU10_OPCODE_DCL_INPUT_PS_SIV, @@ -4791,7 +4791,7 @@ emit_system_value_declaration(struct svga_shader_emitter_v10 *emit, * rather than just a generic input name ("v#") so no need to remap the * index value. */ - assert(emit->unit == PIPE_SHADER_FRAGMENT); + assert(emit->unit == MESA_SHADER_FRAGMENT); assert(emit->version >= 50); emit->fs.sample_mask_in_sys_index = index; emit_input_declaration(emit, VGPU10_OPCODE_DCL_INPUT, @@ -5494,7 +5494,7 @@ emit_input_declarations(struct svga_shader_emitter_v10 *emit) emit->info.indirect_files & (1 << TGSI_FILE_INPUT) ? true : false; switch (emit->unit) { - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: emit_fs_input_declarations(emit); break; case MESA_SHADER_GEOMETRY: @@ -5534,7 +5534,7 @@ emit_output_declarations(struct svga_shader_emitter_v10 *emit) emit->info.indirect_files & (1 << TGSI_FILE_OUTPUT) ? true : false; switch (emit->unit) { - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: emit_fs_output_declarations(emit); break; case MESA_SHADER_GEOMETRY: @@ -5559,7 +5559,7 @@ emit_output_declarations(struct svga_shader_emitter_v10 *emit) if (emit->vposition.so_index != INVALID_INDEX && emit->vposition.out_index != INVALID_INDEX) { - assert(emit->unit != PIPE_SHADER_FRAGMENT); + assert(emit->unit != MESA_SHADER_FRAGMENT); /* Emit the declaration for the non-adjusted vertex position * for stream output purpose @@ -5575,7 +5575,7 @@ emit_output_declarations(struct svga_shader_emitter_v10 *emit) if (emit->clip_dist_so_index != INVALID_INDEX && emit->clip_dist_out_index != INVALID_INDEX) { - assert(emit->unit != PIPE_SHADER_FRAGMENT); + assert(emit->unit != MESA_SHADER_FRAGMENT); /* Emit the declaration for the clip distance shadow copy which * will be used for stream output purpose and for clip distance @@ -5719,7 +5719,7 @@ emit_temporaries_declaration(struct svga_shader_emitter_v10 *emit) emit->gs.viewport_index_tmp_index = total_temps++; } } - else if (emit->unit == PIPE_SHADER_FRAGMENT) { + else if (emit->unit == MESA_SHADER_FRAGMENT) { if (emit->key.fs.alpha_func != SVGA3D_CMP_ALWAYS || emit->key.fs.write_color0_to_n_cbufs > 1) { /* Allocate a temp to hold the output color */ @@ -5990,7 +5990,7 @@ emit_constant_declaration(struct svga_shader_emitter_v10 *emit) /* user-defined clip planes */ if (emit->key.clip_plane_enable) { unsigned n = util_bitcount(emit->key.clip_plane_enable); - assert(emit->unit != PIPE_SHADER_FRAGMENT && + assert(emit->unit != MESA_SHADER_FRAGMENT && emit->unit != PIPE_SHADER_COMPUTE); for (i = 0; i < n; i++) { emit->clip_plane_const[i] = total_consts++; @@ -6781,7 +6781,7 @@ emit_clip_distance_declarations(struct svga_shader_emitter_v10 *emit) unsigned index = emit->num_outputs; unsigned plane_mask; - assert(emit->unit != PIPE_SHADER_FRAGMENT); + assert(emit->unit != MESA_SHADER_FRAGMENT); assert(num_clip_planes <= 8); if (emit->clip_mode != CLIP_LEGACY && @@ -9975,7 +9975,7 @@ emit_mov(struct svga_shader_emitter_v10 *emit, const struct tgsi_full_src_register *src = &inst->Src[0]; const struct tgsi_full_dst_register *dst = &inst->Dst[0]; - if (emit->unit == PIPE_SHADER_FRAGMENT && + if (emit->unit == MESA_SHADER_FRAGMENT && dst->Register.File == TGSI_FILE_OUTPUT && dst->Register.Index == 0 && src->Register.File == TGSI_FILE_CONSTANT && @@ -11577,7 +11577,7 @@ emit_vertex(struct svga_shader_emitter_v10 *emit, static void emit_frontface_instructions(struct svga_shader_emitter_v10 *emit) { - assert(emit->unit == PIPE_SHADER_FRAGMENT); + assert(emit->unit == MESA_SHADER_FRAGMENT); if (emit->fs.face_input_index != INVALID_INDEX) { /* convert vgpu10 boolean face register to gallium +/-1 value */ @@ -11606,7 +11606,7 @@ emit_frontface_instructions(struct svga_shader_emitter_v10 *emit) static void emit_fragcoord_instructions(struct svga_shader_emitter_v10 *emit) { - assert(emit->unit == PIPE_SHADER_FRAGMENT); + assert(emit->unit == MESA_SHADER_FRAGMENT); if (emit->fs.fragcoord_input_index != INVALID_INDEX) { struct tgsi_full_dst_register tmp_dst = @@ -11653,7 +11653,7 @@ emit_fragcoord_instructions(struct svga_shader_emitter_v10 *emit) static void emit_sample_position_instructions(struct svga_shader_emitter_v10 *emit) { - assert(emit->unit == PIPE_SHADER_FRAGMENT); + assert(emit->unit == MESA_SHADER_FRAGMENT); if (emit->fs.sample_pos_sys_index != INVALID_INDEX) { assert(emit->version >= 41); @@ -11811,7 +11811,7 @@ emit_vertex_attrib_instructions(struct svga_shader_emitter_v10 *emit) static void emit_default_layer_instructions(struct svga_shader_emitter_v10 *emit) { - assert(emit->unit == PIPE_SHADER_FRAGMENT); + assert(emit->unit == MESA_SHADER_FRAGMENT); /* immediate for default layer index 0 */ if (emit->fs.layer_input_index != INVALID_INDEX) { @@ -12195,7 +12195,7 @@ emit_pre_helpers(struct svga_shader_emitter_v10 *emit) emit_atomic_buf_declarations(emit); } - if (emit->unit != PIPE_SHADER_FRAGMENT && + if (emit->unit != MESA_SHADER_FRAGMENT && emit->unit != PIPE_SHADER_COMPUTE) { /* * Declare clip distance output registers for ClipVertex or @@ -12216,7 +12216,7 @@ emit_pre_helpers(struct svga_shader_emitter_v10 *emit) } } - if (emit->unit == PIPE_SHADER_FRAGMENT && + if (emit->unit == MESA_SHADER_FRAGMENT && emit->key.fs.alpha_func != SVGA3D_CMP_ALWAYS) { float alpha = emit->key.fs.alpha_ref; emit->fs.alpha_ref_index = @@ -12234,7 +12234,7 @@ emit_pre_helpers(struct svga_shader_emitter_v10 *emit) emit_tcs_default_control_point_output(emit); } - if (emit->unit == PIPE_SHADER_FRAGMENT) { + if (emit->unit == MESA_SHADER_FRAGMENT) { emit_frontface_instructions(emit); emit_fragcoord_instructions(emit); emit_sample_position_instructions(emit); @@ -12327,7 +12327,7 @@ emit_alpha_test_instructions(struct svga_shader_emitter_v10 *emit, struct tgsi_full_dst_register color_dst = make_dst_output_reg(emit->fs.color_out_index[0]); - assert(emit->unit == PIPE_SHADER_FRAGMENT); + assert(emit->unit == MESA_SHADER_FRAGMENT); /* dst = src0 'alpha_func' src1 */ emit_comparison(emit, emit->key.fs.alpha_func, &tmp_dst, @@ -12376,7 +12376,7 @@ emit_broadcast_color_instructions(struct svga_shader_emitter_v10 *emit, color_src = make_src_temp_reg(fs_color_tmp_index); } - assert(emit->unit == PIPE_SHADER_FRAGMENT); + assert(emit->unit == MESA_SHADER_FRAGMENT); for (unsigned i = 0; i < n; i++) { unsigned output_reg = emit->fs.color_out_index[i]; @@ -12406,7 +12406,7 @@ emit_post_helpers(struct svga_shader_emitter_v10 *emit) if (emit->unit == MESA_SHADER_VERTEX) { emit_vertex_instructions(emit); } - else if (emit->unit == PIPE_SHADER_FRAGMENT) { + else if (emit->unit == MESA_SHADER_FRAGMENT) { const unsigned fs_color_tmp_index = emit->fs.color_tmp_index; assert(!(emit->key.fs.white_fragments && @@ -12826,7 +12826,7 @@ compute_input_mapping(struct svga_context *svga, { struct svga_shader *prevShader = NULL; /* shader in the previous stage */ - if (unit == PIPE_SHADER_FRAGMENT) { + if (unit == MESA_SHADER_FRAGMENT) { prevShader = svga->curr.gs ? &svga->curr.gs->base : (svga->curr.tes ? &svga->curr.tes->base : &svga->curr.vs->base); @@ -12922,7 +12922,7 @@ svga_tgsi_vgpu10_translate(struct svga_context *svga, assert(unit == MESA_SHADER_VERTEX || unit == MESA_SHADER_GEOMETRY || - unit == PIPE_SHADER_FRAGMENT || + unit == MESA_SHADER_FRAGMENT || unit == MESA_SHADER_TESS_CTRL || unit == MESA_SHADER_TESS_EVAL || unit == PIPE_SHADER_COMPUTE); @@ -13050,7 +13050,7 @@ svga_tgsi_vgpu10_translate(struct svga_context *svga, emit->key.fs.alpha_func = SVGA3D_CMP_ALWAYS; } - if (unit == PIPE_SHADER_FRAGMENT) { + if (unit == MESA_SHADER_FRAGMENT) { if (key->fs.light_twoside) { tokens = transform_fs_twoside(tokens); } @@ -13182,7 +13182,7 @@ svga_tgsi_vgpu10_translate(struct svga_context *svga, variant->extra_const_start--; } - if (unit == PIPE_SHADER_FRAGMENT) { + if (unit == MESA_SHADER_FRAGMENT) { struct svga_fs_variant *fs_variant = svga_fs_variant(variant); fs_variant->pstipple_sampler_unit = emit->fs.pstipple_sampler_unit; diff --git a/src/gallium/drivers/v3d/v3d_blit.c b/src/gallium/drivers/v3d/v3d_blit.c index d5a2ffaa70d..dc057d77670 100644 --- a/src/gallium/drivers/v3d/v3d_blit.c +++ b/src/gallium/drivers/v3d/v3d_blit.c @@ -42,7 +42,7 @@ void v3d_blitter_save(struct v3d_context *v3d, enum v3d_blitter_op op) { util_blitter_save_fragment_constant_buffer_slot(v3d->blitter, - v3d->constbuf[PIPE_SHADER_FRAGMENT].cb); + v3d->constbuf[MESA_SHADER_FRAGMENT].cb); util_blitter_save_vertex_buffers(v3d->blitter, v3d->vertexbuf.vb, v3d->vertexbuf.count); util_blitter_save_vertex_elements(v3d->blitter, v3d->vtx); util_blitter_save_vertex_shader(v3d->blitter, v3d->prog.bind_vs); @@ -65,11 +65,11 @@ v3d_blitter_save(struct v3d_context *v3d, enum v3d_blitter_op op) if (op & V3D_SAVE_TEXTURES) { util_blitter_save_scissor(v3d->blitter, &v3d->scissor); util_blitter_save_fragment_sampler_states(v3d->blitter, - v3d->tex[PIPE_SHADER_FRAGMENT].num_samplers, - (void **)v3d->tex[PIPE_SHADER_FRAGMENT].samplers); + v3d->tex[MESA_SHADER_FRAGMENT].num_samplers, + (void **)v3d->tex[MESA_SHADER_FRAGMENT].samplers); util_blitter_save_fragment_sampler_views(v3d->blitter, - v3d->tex[PIPE_SHADER_FRAGMENT].num_textures, - v3d->tex[PIPE_SHADER_FRAGMENT].textures); + v3d->tex[MESA_SHADER_FRAGMENT].num_textures, + v3d->tex[MESA_SHADER_FRAGMENT].textures); } if (!(op & V3D_DISABLE_RENDER_COND)) { @@ -661,7 +661,7 @@ v3d_get_sand8_fs(struct pipe_context *pctx, int cpp) return *cached_shader; const struct nir_shader_compiler_options *options = - pscreen->nir_options[PIPE_SHADER_FRAGMENT]; + pscreen->nir_options[MESA_SHADER_FRAGMENT]; nir_builder b = nir_builder_init_simple_shader(MESA_SHADER_FRAGMENT, options, "%s", name); @@ -837,12 +837,12 @@ v3d_sand8_blit(struct pipe_context *pctx, struct pipe_blit_info *info) .buffer_size = sizeof(sand8_stride), }; - pctx->set_constant_buffer(pctx, PIPE_SHADER_FRAGMENT, 0, false, + pctx->set_constant_buffer(pctx, MESA_SHADER_FRAGMENT, 0, false, &cb_uniforms); struct pipe_constant_buffer saved_fs_cb1 = { 0 }; pipe_resource_reference(&saved_fs_cb1.buffer, - v3d->constbuf[PIPE_SHADER_FRAGMENT].cb[1].buffer); - memcpy(&saved_fs_cb1, &v3d->constbuf[PIPE_SHADER_FRAGMENT].cb[1], + v3d->constbuf[MESA_SHADER_FRAGMENT].cb[1].buffer); + memcpy(&saved_fs_cb1, &v3d->constbuf[MESA_SHADER_FRAGMENT].cb[1], sizeof(struct pipe_constant_buffer)); struct pipe_constant_buffer cb_src = { .buffer = info->src.resource, @@ -850,13 +850,13 @@ v3d_sand8_blit(struct pipe_context *pctx, struct pipe_blit_info *info) .buffer_size = (src->bo->size - src->slices[info->src.level].offset), }; - pctx->set_constant_buffer(pctx, PIPE_SHADER_FRAGMENT, 1, false, + pctx->set_constant_buffer(pctx, MESA_SHADER_FRAGMENT, 1, false, &cb_src); /* Unbind the textures, to make sure we don't try to recurse into the * shadow blit. */ - pctx->set_sampler_views(pctx, PIPE_SHADER_FRAGMENT, 0, 0, 0, NULL); - pctx->bind_sampler_states(pctx, PIPE_SHADER_FRAGMENT, 0, 0, NULL); + pctx->set_sampler_views(pctx, MESA_SHADER_FRAGMENT, 0, 0, 0, NULL); + pctx->bind_sampler_states(pctx, MESA_SHADER_FRAGMENT, 0, 0, NULL); util_blitter_custom_shader(v3d->blitter, &dst_surf, width, height, v3d_get_sand8_vs(pctx), @@ -866,7 +866,7 @@ v3d_sand8_blit(struct pipe_context *pctx, struct pipe_blit_info *info) util_blitter_restore_constant_buffer_state(v3d->blitter); /* Restore cb1 (util_blitter doesn't handle this one). */ - pctx->set_constant_buffer(pctx, PIPE_SHADER_FRAGMENT, 1, true, + pctx->set_constant_buffer(pctx, MESA_SHADER_FRAGMENT, 1, true, &saved_fs_cb1); pipe_resource_reference(&dst_surf.texture, NULL); @@ -966,7 +966,7 @@ v3d_get_sand30_fs(struct pipe_context *pctx) return v3d->sand30_blit_fs; const struct nir_shader_compiler_options *options = - pscreen->nir_options[PIPE_SHADER_FRAGMENT]; + pscreen->nir_options[MESA_SHADER_FRAGMENT]; nir_builder b = nir_builder_init_simple_shader(MESA_SHADER_FRAGMENT, options, @@ -1144,13 +1144,13 @@ v3d_sand30_blit(struct pipe_context *pctx, struct pipe_blit_info *info) .buffer_size = sizeof(sand30_stride), }; - pctx->set_constant_buffer(pctx, PIPE_SHADER_FRAGMENT, 0, false, + pctx->set_constant_buffer(pctx, MESA_SHADER_FRAGMENT, 0, false, &cb_uniforms); struct pipe_constant_buffer saved_fs_cb1 = { 0 }; pipe_resource_reference(&saved_fs_cb1.buffer, - v3d->constbuf[PIPE_SHADER_FRAGMENT].cb[1].buffer); - memcpy(&saved_fs_cb1, &v3d->constbuf[PIPE_SHADER_FRAGMENT].cb[1], + v3d->constbuf[MESA_SHADER_FRAGMENT].cb[1].buffer); + memcpy(&saved_fs_cb1, &v3d->constbuf[MESA_SHADER_FRAGMENT].cb[1], sizeof(struct pipe_constant_buffer)); struct pipe_constant_buffer cb_src = { .buffer = info->src.resource, @@ -1158,14 +1158,14 @@ v3d_sand30_blit(struct pipe_context *pctx, struct pipe_blit_info *info) .buffer_size = (src->bo->size - src->slices[info->src.level].offset), }; - pctx->set_constant_buffer(pctx, PIPE_SHADER_FRAGMENT, 1, false, + pctx->set_constant_buffer(pctx, MESA_SHADER_FRAGMENT, 1, false, &cb_src); /* Unbind the textures, to make sure we don't try to recurse into the * shadow blit. */ - pctx->set_sampler_views(pctx, PIPE_SHADER_FRAGMENT, 0, 0, 0, + pctx->set_sampler_views(pctx, MESA_SHADER_FRAGMENT, 0, 0, 0, NULL); - pctx->bind_sampler_states(pctx, PIPE_SHADER_FRAGMENT, 0, 0, NULL); + pctx->bind_sampler_states(pctx, MESA_SHADER_FRAGMENT, 0, 0, NULL); util_blitter_custom_shader(v3d->blitter, &dst_surf, width, height, v3d_get_sand30_vs(pctx), @@ -1175,7 +1175,7 @@ v3d_sand30_blit(struct pipe_context *pctx, struct pipe_blit_info *info) util_blitter_restore_constant_buffer_state(v3d->blitter); /* Restore cb1 (util_blitter doesn't handle this one). */ - pctx->set_constant_buffer(pctx, PIPE_SHADER_FRAGMENT, 1, true, + pctx->set_constant_buffer(pctx, MESA_SHADER_FRAGMENT, 1, true, &saved_fs_cb1); pipe_resource_reference(&dst_surf.texture, NULL); diff --git a/src/gallium/drivers/v3d/v3d_context.c b/src/gallium/drivers/v3d/v3d_context.c index 889bd7fb753..2aa75a0e757 100644 --- a/src/gallium/drivers/v3d/v3d_context.c +++ b/src/gallium/drivers/v3d/v3d_context.c @@ -245,7 +245,7 @@ v3d_flag_dirty_sampler_state(struct v3d_context *v3d, case MESA_SHADER_GEOMETRY: v3d->dirty |= V3D_DIRTY_GEOMTEX; break; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: v3d->dirty |= V3D_DIRTY_FRAGTEX; break; case PIPE_SHADER_COMPUTE: diff --git a/src/gallium/drivers/v3d/v3d_program.c b/src/gallium/drivers/v3d/v3d_program.c index ae2ce5d8cb9..4aad99150ea 100644 --- a/src/gallium/drivers/v3d/v3d_program.c +++ b/src/gallium/drivers/v3d/v3d_program.c @@ -605,7 +605,7 @@ v3d_update_compiled_fs(struct v3d_context *v3d, uint8_t prim_mode) } memset(key, 0, sizeof(*key)); - v3d_setup_shared_key(v3d, &key->base, &v3d->tex[PIPE_SHADER_FRAGMENT]); + v3d_setup_shared_key(v3d, &key->base, &v3d->tex[MESA_SHADER_FRAGMENT]); key->ucp_enables = v3d->rasterizer->base.clip_plane_enable; key->is_points = (prim_mode == MESA_PRIM_POINTS); key->is_lines = (prim_mode >= MESA_PRIM_LINES && diff --git a/src/gallium/drivers/v3d/v3d_screen.c b/src/gallium/drivers/v3d/v3d_screen.c index b393cff680d..5bb50705be4 100644 --- a/src/gallium/drivers/v3d/v3d_screen.c +++ b/src/gallium/drivers/v3d/v3d_screen.c @@ -125,7 +125,7 @@ v3d_init_shader_caps(struct v3d_screen *screen) switch (i) { case MESA_SHADER_VERTEX: - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: case MESA_SHADER_GEOMETRY: break; case PIPE_SHADER_COMPUTE: @@ -149,7 +149,7 @@ v3d_init_shader_caps(struct v3d_screen *screen) case MESA_SHADER_GEOMETRY: caps->max_inputs = V3D_MAX_GS_INPUTS / 4; break; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: caps->max_inputs = V3D_MAX_FS_INPUTS / 4; break; default: @@ -157,7 +157,7 @@ v3d_init_shader_caps(struct v3d_screen *screen) } caps->max_outputs = - i == PIPE_SHADER_FRAGMENT ? 4 : V3D_MAX_FS_INPUTS / 4; + i == MESA_SHADER_FRAGMENT ? 4 : V3D_MAX_FS_INPUTS / 4; caps->max_temps = 256; /* GL_MAX_PROGRAM_TEMPORARIES_ARB */ /* Note: Limited by the offset size in diff --git a/src/gallium/drivers/v3d/v3dx_draw.c b/src/gallium/drivers/v3d/v3dx_draw.c index 5364a9426da..985068114de 100644 --- a/src/gallium/drivers/v3d/v3dx_draw.c +++ b/src/gallium/drivers/v3d/v3dx_draw.c @@ -320,7 +320,7 @@ v3d_emit_wait_for_tf_if_needed(struct v3d_context *v3d, struct v3d_job *job) * read the resource then we could also avoid emitting * the wait. */ - if (s == PIPE_SHADER_FRAGMENT) + if (s == MESA_SHADER_FRAGMENT) continue; if (v3d_state_reads_resource(v3d, prsc, s)) { @@ -691,7 +691,7 @@ v3d_emit_gl_shader_state(struct v3d_context *v3d, /* Upload the uniforms to the indirect CL first */ struct v3d_cl_reloc fs_uniforms = v3d_write_uniforms(v3d, job, v3d->prog.fs, - PIPE_SHADER_FRAGMENT); + MESA_SHADER_FRAGMENT); struct v3d_cl_reloc gs_uniforms = { NULL, 0 }; struct v3d_cl_reloc gs_bin_uniforms = { NULL, 0 }; diff --git a/src/gallium/drivers/vc4/vc4_blit.c b/src/gallium/drivers/vc4/vc4_blit.c index b61093465ab..9f9d621c8dd 100644 --- a/src/gallium/drivers/vc4/vc4_blit.c +++ b/src/gallium/drivers/vc4/vc4_blit.c @@ -194,7 +194,7 @@ void vc4_blitter_save(struct vc4_context *vc4) { util_blitter_save_fragment_constant_buffer_slot(vc4->blitter, - vc4->constbuf[PIPE_SHADER_FRAGMENT].cb); + vc4->constbuf[MESA_SHADER_FRAGMENT].cb); util_blitter_save_vertex_buffers(vc4->blitter, vc4->vertexbuf.vb, vc4->vertexbuf.count); util_blitter_save_vertex_elements(vc4->blitter, vc4->vtx); @@ -263,7 +263,7 @@ static void *vc4_get_yuv_fs(struct pipe_context *pctx, int cpp) return *cached_shader; const struct nir_shader_compiler_options *options = - pscreen->nir_options[PIPE_SHADER_FRAGMENT]; + pscreen->nir_options[MESA_SHADER_FRAGMENT]; nir_builder b = nir_builder_init_simple_shader(MESA_SHADER_FRAGMENT, options, "%s", name); @@ -385,20 +385,20 @@ vc4_yuv_blit(struct pipe_context *pctx, struct pipe_blit_info *info) .user_buffer = &stride, .buffer_size = sizeof(stride), }; - pctx->set_constant_buffer(pctx, PIPE_SHADER_FRAGMENT, 0, false, &cb_uniforms); + pctx->set_constant_buffer(pctx, MESA_SHADER_FRAGMENT, 0, false, &cb_uniforms); struct pipe_constant_buffer cb_src = { .buffer = info->src.resource, .buffer_offset = src->slices[info->src.level].offset, .buffer_size = (src->bo->size - src->slices[info->src.level].offset), }; - pctx->set_constant_buffer(pctx, PIPE_SHADER_FRAGMENT, 1, false, &cb_src); + pctx->set_constant_buffer(pctx, MESA_SHADER_FRAGMENT, 1, false, &cb_src); /* Unbind the textures, to make sure we don't try to recurse into the * shadow blit. */ - pctx->set_sampler_views(pctx, PIPE_SHADER_FRAGMENT, 0, 0, 0, NULL); - pctx->bind_sampler_states(pctx, PIPE_SHADER_FRAGMENT, 0, 0, NULL); + pctx->set_sampler_views(pctx, MESA_SHADER_FRAGMENT, 0, 0, 0, NULL); + pctx->bind_sampler_states(pctx, MESA_SHADER_FRAGMENT, 0, 0, NULL); util_blitter_custom_shader(vc4->blitter, &dst_surf, width, height, vc4_get_yuv_vs(pctx), @@ -408,7 +408,7 @@ vc4_yuv_blit(struct pipe_context *pctx, struct pipe_blit_info *info) util_blitter_restore_constant_buffer_state(vc4->blitter); /* Restore cb1 (util_blitter doesn't handle this one). */ struct pipe_constant_buffer cb_disabled = { 0 }; - pctx->set_constant_buffer(pctx, PIPE_SHADER_FRAGMENT, 1, false, &cb_disabled); + pctx->set_constant_buffer(pctx, MESA_SHADER_FRAGMENT, 1, false, &cb_disabled); pipe_resource_reference(&dst_surf.texture, NULL); diff --git a/src/gallium/drivers/vc4/vc4_draw.c b/src/gallium/drivers/vc4/vc4_draw.c index 29fe7a2103d..07d178ceb6a 100644 --- a/src/gallium/drivers/vc4/vc4_draw.c +++ b/src/gallium/drivers/vc4/vc4_draw.c @@ -240,7 +240,7 @@ vc4_emit_gl_shader_state(struct vc4_context *vc4, } vc4_write_uniforms(vc4, vc4->prog.fs, - &vc4->constbuf[PIPE_SHADER_FRAGMENT], + &vc4->constbuf[MESA_SHADER_FRAGMENT], &vc4->fragtex); vc4_write_uniforms(vc4, vc4->prog.vs, &vc4->constbuf[MESA_SHADER_VERTEX], diff --git a/src/gallium/drivers/vc4/vc4_program.c b/src/gallium/drivers/vc4/vc4_program.c index d623e64c4bb..cfa487e4bff 100644 --- a/src/gallium/drivers/vc4/vc4_program.c +++ b/src/gallium/drivers/vc4/vc4_program.c @@ -2801,7 +2801,7 @@ vc4_update_compiled_fs(struct vc4_context *vc4, uint8_t prim_mode) PIPE_SPRITE_COORD_UPPER_LEFT); } - key->ubo_1_size = vc4->constbuf[PIPE_SHADER_FRAGMENT].cb[1].buffer_size; + key->ubo_1_size = vc4->constbuf[MESA_SHADER_FRAGMENT].cb[1].buffer_size; struct vc4_compiled_shader *old_fs = vc4->prog.fs; vc4->prog.fs = vc4_get_compiled_shader(vc4, QSTAGE_FRAG, &key->base); diff --git a/src/gallium/drivers/vc4/vc4_screen.c b/src/gallium/drivers/vc4/vc4_screen.c index 27807dbb6cb..f7fc285f66c 100644 --- a/src/gallium/drivers/vc4/vc4_screen.c +++ b/src/gallium/drivers/vc4/vc4_screen.c @@ -135,11 +135,11 @@ vc4_has_feature(struct vc4_screen *screen, uint32_t feature) static void vc4_init_shader_caps(struct vc4_screen *screen) { - for (unsigned i = 0; i <= PIPE_SHADER_FRAGMENT; i++) { + for (unsigned i = 0; i <= MESA_SHADER_FRAGMENT; i++) { struct pipe_shader_caps *caps = (struct pipe_shader_caps *)&screen->base.shader_caps[i]; - if (i != MESA_SHADER_VERTEX && i != PIPE_SHADER_FRAGMENT) + if (i != MESA_SHADER_VERTEX && i != MESA_SHADER_FRAGMENT) continue; caps->max_instructions = @@ -149,7 +149,7 @@ vc4_init_shader_caps(struct vc4_screen *screen) caps->max_control_flow_depth = screen->has_control_flow; caps->max_inputs = 8; - caps->max_outputs = i == PIPE_SHADER_FRAGMENT ? 1 : 8; + caps->max_outputs = i == MESA_SHADER_FRAGMENT ? 1 : 8; caps->max_temps = 256; /* GL_MAX_PROGRAM_TEMPORARIES_ARB */ caps->max_const_buffer0_size = 16 * 1024 * sizeof(float); caps->max_const_buffers = 1; diff --git a/src/gallium/drivers/vc4/vc4_state.c b/src/gallium/drivers/vc4/vc4_state.c index 2050834e419..370c6a0a4ca 100644 --- a/src/gallium/drivers/vc4/vc4_state.c +++ b/src/gallium/drivers/vc4/vc4_state.c @@ -436,7 +436,7 @@ static struct vc4_texture_stateobj * vc4_get_stage_tex(struct vc4_context *vc4, enum pipe_shader_type shader) { switch (shader) { - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: vc4->dirty |= VC4_DIRTY_FRAGTEX; return &vc4->fragtex; break; diff --git a/src/gallium/drivers/virgl/virgl_context.c b/src/gallium/drivers/virgl/virgl_context.c index d83adce00be..41689d3ead8 100644 --- a/src/gallium/drivers/virgl/virgl_context.c +++ b/src/gallium/drivers/virgl/virgl_context.c @@ -800,7 +800,7 @@ static void *virgl_create_gs_state(struct pipe_context *ctx, static void *virgl_create_fs_state(struct pipe_context *ctx, const struct pipe_shader_state *shader) { - return virgl_shader_encoder(ctx, shader, PIPE_SHADER_FRAGMENT); + return virgl_shader_encoder(ctx, shader, MESA_SHADER_FRAGMENT); } static void @@ -896,7 +896,7 @@ static void virgl_bind_fs_state(struct pipe_context *ctx, uint32_t handle = (unsigned long)vss; struct virgl_context *vctx = virgl_context(ctx); - virgl_encode_bind_shader(vctx, handle, PIPE_SHADER_FRAGMENT); + virgl_encode_bind_shader(vctx, handle, MESA_SHADER_FRAGMENT); } static void virgl_clear(struct pipe_context *ctx, @@ -1410,7 +1410,7 @@ static void virgl_set_shader_buffers(struct pipe_context *ctx, } } - uint32_t max_shader_buffer = (shader == PIPE_SHADER_FRAGMENT || shader == PIPE_SHADER_COMPUTE) ? + uint32_t max_shader_buffer = (shader == MESA_SHADER_FRAGMENT || shader == PIPE_SHADER_COMPUTE) ? rs->caps.caps.v2.max_shader_buffer_frag_compute : rs->caps.caps.v2.max_shader_buffer_other_stages; if (!max_shader_buffer) @@ -1469,7 +1469,7 @@ static void virgl_set_shader_images(struct pipe_context *ctx, } } - uint32_t max_shader_images = (shader == PIPE_SHADER_FRAGMENT || shader == PIPE_SHADER_COMPUTE) ? + uint32_t max_shader_images = (shader == MESA_SHADER_FRAGMENT || shader == PIPE_SHADER_COMPUTE) ? rs->caps.caps.v2.max_shader_image_frag_compute : rs->caps.caps.v2.max_shader_image_other_stages; if (!max_shader_images) diff --git a/src/gallium/drivers/virgl/virgl_encode.c b/src/gallium/drivers/virgl/virgl_encode.c index b6ffdbabef0..0dabe4469d5 100644 --- a/src/gallium/drivers/virgl/virgl_encode.c +++ b/src/gallium/drivers/virgl/virgl_encode.c @@ -1479,7 +1479,7 @@ int virgl_encode_link_shader(struct virgl_context *ctx, uint32_t *handles) { virgl_encoder_write_cmd_dword(ctx, VIRGL_CMD0(VIRGL_CCMD_LINK_SHADER, 0, VIRGL_LINK_SHADER_SIZE)); virgl_encoder_write_dword(ctx->cbuf, handles[MESA_SHADER_VERTEX]); - virgl_encoder_write_dword(ctx->cbuf, handles[PIPE_SHADER_FRAGMENT]); + virgl_encoder_write_dword(ctx->cbuf, handles[MESA_SHADER_FRAGMENT]); virgl_encoder_write_dword(ctx->cbuf, handles[MESA_SHADER_GEOMETRY]); virgl_encoder_write_dword(ctx->cbuf, handles[MESA_SHADER_TESS_CTRL]); virgl_encoder_write_dword(ctx->cbuf, handles[MESA_SHADER_TESS_EVAL]); diff --git a/src/gallium/drivers/virgl/virgl_screen.c b/src/gallium/drivers/virgl/virgl_screen.c index 904c64a2191..7252e2ba698 100644 --- a/src/gallium/drivers/virgl/virgl_screen.c +++ b/src/gallium/drivers/virgl/virgl_screen.c @@ -203,7 +203,7 @@ virgl_init_shader_caps(struct virgl_screen *vscreen) vscreen->caps.caps.v2.max_vertex_attribs : 32); switch (i) { - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: caps->max_outputs = vscreen->caps.caps.v1.max_render_targets; break; case MESA_SHADER_TESS_CTRL: @@ -238,14 +238,14 @@ virgl_init_shader_caps(struct virgl_screen *vscreen) int max_shader_buffers = VIRGL_SHADER_STAGE_CAP_V2(max_shader_storage_blocks, i); if (max_shader_buffers != INT_MAX) { caps->max_shader_buffers = max_shader_buffers; - } else if (i == PIPE_SHADER_FRAGMENT || i == PIPE_SHADER_COMPUTE) { + } else if (i == MESA_SHADER_FRAGMENT || i == PIPE_SHADER_COMPUTE) { caps->max_shader_buffers = vscreen->caps.caps.v2.max_shader_buffer_frag_compute; } else { caps->max_shader_buffers = vscreen->caps.caps.v2.max_shader_buffer_other_stages; } caps->max_shader_images = - i == PIPE_SHADER_FRAGMENT || i == PIPE_SHADER_COMPUTE ? + i == MESA_SHADER_FRAGMENT || i == PIPE_SHADER_COMPUTE ? vscreen->caps.caps.v2.max_shader_image_frag_compute : vscreen->caps.caps.v2.max_shader_image_other_stages; diff --git a/src/gallium/drivers/virgl/virgl_screen.h b/src/gallium/drivers/virgl/virgl_screen.h index b11d756e14b..2f81c497cb2 100644 --- a/src/gallium/drivers/virgl/virgl_screen.h +++ b/src/gallium/drivers/virgl/virgl_screen.h @@ -101,7 +101,7 @@ virgl_shader_stage_convert(enum pipe_shader_type type) return VIRGL_SHADER_TESS_EVAL; case MESA_SHADER_GEOMETRY: return VIRGL_SHADER_GEOMETRY; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: return VIRGL_SHADER_FRAGMENT; case PIPE_SHADER_COMPUTE: return VIRGL_SHADER_COMPUTE; diff --git a/src/gallium/drivers/virgl/virgl_tgsi.c b/src/gallium/drivers/virgl/virgl_tgsi.c index cf28e16e6c8..fc6dddb2422 100644 --- a/src/gallium/drivers/virgl/virgl_tgsi.c +++ b/src/gallium/drivers/virgl/virgl_tgsi.c @@ -122,7 +122,7 @@ virgl_tgsi_transform_declaration(struct tgsi_transform_context *ctx, break; case TGSI_SEMANTIC_COLOR: /* Vertex front/backface color output also has issues with writemasking */ - if (vtctx->base.processor != PIPE_SHADER_FRAGMENT) + if (vtctx->base.processor != MESA_SHADER_FRAGMENT) vtctx->writemask_fixup_outs[vtctx->num_writemask_fixups++] = decl->Range.First; break; } diff --git a/src/gallium/frontends/d3d10umd/Device.cpp b/src/gallium/frontends/d3d10umd/Device.cpp index 20c86e0ba10..101a1210856 100644 --- a/src/gallium/frontends/d3d10umd/Device.cpp +++ b/src/gallium/frontends/d3d10umd/Device.cpp @@ -136,7 +136,7 @@ CreateDevice(D3D10DDI_HADAPTER hAdapter, // IN pDevice->cso = cso_create_context(pipe, CSO_NO_VBUF); pDevice->empty_vs = CreateEmptyShader(pDevice, MESA_SHADER_VERTEX); - pDevice->empty_fs = CreateEmptyShader(pDevice, PIPE_SHADER_FRAGMENT); + pDevice->empty_fs = CreateEmptyShader(pDevice, MESA_SHADER_FRAGMENT); pipe->bind_vs_state(pipe, pDevice->empty_vs); pipe->bind_fs_state(pipe, pDevice->empty_fs); @@ -338,7 +338,7 @@ DestroyDevice(D3D10DDI_HDEVICE hDevice) // IN pipe->bind_vs_state(pipe, NULL); cso_destroy_context(pDevice->cso); - DeleteEmptyShader(pDevice, PIPE_SHADER_FRAGMENT, pDevice->empty_fs); + DeleteEmptyShader(pDevice, MESA_SHADER_FRAGMENT, pDevice->empty_fs); DeleteEmptyShader(pDevice, MESA_SHADER_VERTEX, pDevice->empty_vs); util_unreference_framebuffer_state(&pDevice->fb); @@ -353,7 +353,7 @@ DestroyDevice(D3D10DDI_HDEVICE hDevice) // IN static struct pipe_sampler_view * sampler_views[PIPE_MAX_SHADER_SAMPLER_VIEWS]; memset(sampler_views, 0, sizeof sampler_views); - pipe->set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0, + pipe->set_sampler_views(pipe, MESA_SHADER_FRAGMENT, 0, PIPE_MAX_SHADER_SAMPLER_VIEWS, 0, sampler_views); pipe->set_sampler_views(pipe, MESA_SHADER_VERTEX, 0, PIPE_MAX_SHADER_SAMPLER_VIEWS, 0, sampler_views); diff --git a/src/gallium/frontends/d3d10umd/Shader.cpp b/src/gallium/frontends/d3d10umd/Shader.cpp index ebf62ac2de5..b2fa899341d 100644 --- a/src/gallium/frontends/d3d10umd/Shader.cpp +++ b/src/gallium/frontends/d3d10umd/Shader.cpp @@ -86,7 +86,7 @@ CreateEmptyShader(Device *pDevice, void *handle; switch (processor) { - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: handle = pipe->create_fs_state(pipe, &state); break; case MESA_SHADER_VERTEX: @@ -130,7 +130,7 @@ DeleteEmptyShader(Device *pDevice, assert(handle != NULL); switch (processor) { - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: pipe->delete_fs_state(pipe, handle); break; case MESA_SHADER_VERTEX: @@ -300,7 +300,7 @@ DestroyShader(D3D10DDI_HDEVICE hDevice, // IN if (pShader->handle) { switch (pShader->type) { - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: pipe->delete_fs_state(pipe, pShader->handle); break; case MESA_SHADER_VERTEX: @@ -996,7 +996,7 @@ CreatePixelShader(D3D10DDI_HDEVICE hDevice, // IN struct pipe_context *pipe = CastPipeContext(hDevice); Shader *pShader = CastShader(hShader); - pShader->type = PIPE_SHADER_FRAGMENT; + pShader->type = MESA_SHADER_FRAGMENT; pShader->output_resolved = true; memset(&pShader->state, 0, sizeof pShader->state); @@ -1056,7 +1056,7 @@ PsSetShaderResources(D3D10DDI_HDEVICE hDevice, { LOG_ENTRYPOINT(); - SetShaderResources(PIPE_SHADER_FRAGMENT, hDevice, Offset, NumViews, phShaderResourceViews); + SetShaderResources(MESA_SHADER_FRAGMENT, hDevice, Offset, NumViews, phShaderResourceViews); } @@ -1079,7 +1079,7 @@ PsSetConstantBuffers(D3D10DDI_HDEVICE hDevice, { LOG_ENTRYPOINT(); - SetConstantBuffers(PIPE_SHADER_FRAGMENT, + SetConstantBuffers(MESA_SHADER_FRAGMENT, hDevice, StartBuffer, NumBuffers, phBuffers); } @@ -1101,7 +1101,7 @@ PsSetSamplers(D3D10DDI_HDEVICE hDevice, // { LOG_ENTRYPOINT(); - SetSamplers(PIPE_SHADER_FRAGMENT, hDevice, Offset, NumSamplers, phSamplers); + SetSamplers(MESA_SHADER_FRAGMENT, hDevice, Offset, NumSamplers, phSamplers); } diff --git a/src/gallium/frontends/d3d10umd/ShaderTGSI.c b/src/gallium/frontends/d3d10umd/ShaderTGSI.c index 9b8f57a2db9..838087f5672 100644 --- a/src/gallium/frontends/d3d10umd/ShaderTGSI.c +++ b/src/gallium/frontends/d3d10umd/ShaderTGSI.c @@ -1275,7 +1275,7 @@ Shader_tgsi_translate(const unsigned *code, /* Header. */ switch (parser.header.type) { case D3D10_SB_PIXEL_SHADER: - ureg = ureg_create(PIPE_SHADER_FRAGMENT); + ureg = ureg_create(MESA_SHADER_FRAGMENT); break; case D3D10_SB_VERTEX_SHADER: ureg = ureg_create(MESA_SHADER_VERTEX); diff --git a/src/gallium/include/pipe/p_context.h b/src/gallium/include/pipe/p_context.h index 81b79c7ba97..b4ab3e58a1a 100644 --- a/src/gallium/include/pipe/p_context.h +++ b/src/gallium/include/pipe/p_context.h @@ -350,7 +350,7 @@ struct pipe_context { * position contains the corresponding \c pipe_shader_state* * or \c pipe_compute_state*, or \c NULL. * E.g. You can retrieve the fragment shader handle with - * \c handles[PIPE_SHADER_FRAGMENT] + * \c handles[MESA_SHADER_FRAGMENT] */ void (*link_shader)(struct pipe_context *, void** handles); /*@}*/ diff --git a/src/gallium/tools/trace/dump_state.py b/src/gallium/tools/trace/dump_state.py index 9096c5ce2e9..bce4fcda110 100755 --- a/src/gallium/tools/trace/dump_state.py +++ b/src/gallium/tools/trace/dump_state.py @@ -418,7 +418,7 @@ class Context(Dispatcher): return self._state.tes if shader == 'MESA_SHADER_GEOMETRY': return self._state.gs - if shader == 'PIPE_SHADER_FRAGMENT': + if shader == 'MESA_SHADER_FRAGMENT': return self._state.fs assert False diff --git a/src/intel/compiler/brw_compiler.c b/src/intel/compiler/brw_compiler.c index 75b1eac69c2..e448f873a55 100644 --- a/src/intel/compiler/brw_compiler.c +++ b/src/intel/compiler/brw_compiler.c @@ -85,7 +85,7 @@ const struct nir_shader_compiler_options brw_scalar_nir_options = { .scalarize_ddx = true, .support_indirect_inputs = BITFIELD_BIT(MESA_SHADER_TESS_CTRL) | BITFIELD_BIT(MESA_SHADER_TESS_EVAL) | - BITFIELD_BIT(PIPE_SHADER_FRAGMENT), + BITFIELD_BIT(MESA_SHADER_FRAGMENT), .support_indirect_outputs = (uint8_t)BITFIELD_MASK(PIPE_SHADER_TYPES), .per_view_unique_driver_locations = true, .compact_view_index = true, diff --git a/src/mesa/state_tracker/st_atom_constbuf.c b/src/mesa/state_tracker/st_atom_constbuf.c index 26074494534..7ba9151d9df 100644 --- a/src/mesa/state_tracker/st_atom_constbuf.c +++ b/src/mesa/state_tracker/st_atom_constbuf.c @@ -78,14 +78,14 @@ st_upload_constants(struct st_context *st, struct gl_program *prog, gl_shader_st struct gl_program_parameter_list *params = prog->Parameters; assert(shader_type == MESA_SHADER_VERTEX || - shader_type == PIPE_SHADER_FRAGMENT || + shader_type == MESA_SHADER_FRAGMENT || shader_type == MESA_SHADER_GEOMETRY || shader_type == MESA_SHADER_TESS_CTRL || shader_type == MESA_SHADER_TESS_EVAL || shader_type == PIPE_SHADER_COMPUTE); /* update the ATI constants before rendering */ - if (shader_type == PIPE_SHADER_FRAGMENT && prog->ati_fs) { + if (shader_type == MESA_SHADER_FRAGMENT && prog->ati_fs) { struct ati_fragment_shader *ati_fs = prog->ati_fs; unsigned c; @@ -323,7 +323,7 @@ st_bind_fs_ubos(struct st_context *st) struct gl_program *prog = st->ctx->_Shader->CurrentProgram[MESA_SHADER_FRAGMENT]; - st_bind_ubos(st, prog, PIPE_SHADER_FRAGMENT); + st_bind_ubos(st, prog, MESA_SHADER_FRAGMENT); } void diff --git a/src/mesa/state_tracker/st_atom_image.c b/src/mesa/state_tracker/st_atom_image.c index fa698f2f2a6..7a60d1b3b55 100644 --- a/src/mesa/state_tracker/st_atom_image.c +++ b/src/mesa/state_tracker/st_atom_image.c @@ -188,7 +188,7 @@ void st_bind_fs_images(struct st_context *st) struct gl_program *prog = st->ctx->_Shader->CurrentProgram[MESA_SHADER_FRAGMENT]; - st_bind_images(st, prog, PIPE_SHADER_FRAGMENT); + st_bind_images(st, prog, MESA_SHADER_FRAGMENT); } void st_bind_gs_images(struct st_context *st) diff --git a/src/mesa/state_tracker/st_atom_sampler.c b/src/mesa/state_tracker/st_atom_sampler.c index a16c410b7d7..6055f5c9bbd 100644 --- a/src/mesa/state_tracker/st_atom_sampler.c +++ b/src/mesa/state_tracker/st_atom_sampler.c @@ -410,7 +410,7 @@ st_update_fragment_samplers(struct st_context *st) const struct gl_context *ctx = st->ctx; update_shader_samplers(st, - PIPE_SHADER_FRAGMENT, + MESA_SHADER_FRAGMENT, ctx->FragmentProgram._Current, st->state.frag_samplers, &st->state.num_frag_samplers); diff --git a/src/mesa/state_tracker/st_atom_storagebuf.c b/src/mesa/state_tracker/st_atom_storagebuf.c index 815453d406d..eb13b101326 100644 --- a/src/mesa/state_tracker/st_atom_storagebuf.c +++ b/src/mesa/state_tracker/st_atom_storagebuf.c @@ -104,7 +104,7 @@ void st_bind_fs_ssbos(struct st_context *st) struct gl_program *prog = st->ctx->_Shader->CurrentProgram[MESA_SHADER_FRAGMENT]; - st_bind_ssbos(st, prog, PIPE_SHADER_FRAGMENT); + st_bind_ssbos(st, prog, MESA_SHADER_FRAGMENT); } void st_bind_gs_ssbos(struct st_context *st) diff --git a/src/mesa/state_tracker/st_atom_texture.c b/src/mesa/state_tracker/st_atom_texture.c index 0dab06912e3..7cd7626ed81 100644 --- a/src/mesa/state_tracker/st_atom_texture.c +++ b/src/mesa/state_tracker/st_atom_texture.c @@ -354,7 +354,7 @@ st_update_fragment_textures(struct st_context *st) { const struct gl_context *ctx = st->ctx; - update_textures(st, PIPE_SHADER_FRAGMENT, + update_textures(st, MESA_SHADER_FRAGMENT, ctx->FragmentProgram._Current); } diff --git a/src/mesa/state_tracker/st_cb_bitmap.c b/src/mesa/state_tracker/st_cb_bitmap.c index 4f6bb48df9a..32a9059568f 100644 --- a/src/mesa/state_tracker/st_cb_bitmap.c +++ b/src/mesa/state_tracker/st_cb_bitmap.c @@ -237,7 +237,7 @@ setup_render_state(struct gl_context *ctx, samplers[i] = &st->state.frag_samplers[i]; } samplers[fpv->bitmap_sampler] = &st->bitmap.sampler; - cso_set_samplers(cso, PIPE_SHADER_FRAGMENT, num, + cso_set_samplers(cso, MESA_SHADER_FRAGMENT, num, (const struct pipe_sampler_state **) samplers); } @@ -246,13 +246,13 @@ setup_render_state(struct gl_context *ctx, unsigned extra_sampler_views = 0; struct pipe_sampler_view *sampler_views[PIPE_MAX_SAMPLERS]; unsigned num_views = - st_get_sampler_views(st, PIPE_SHADER_FRAGMENT, fp, sampler_views, &extra_sampler_views); + st_get_sampler_views(st, MESA_SHADER_FRAGMENT, fp, sampler_views, &extra_sampler_views); num_views = MAX2(fpv->bitmap_sampler + 1, num_views); sampler_views[fpv->bitmap_sampler] = sv; - pipe->set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0, num_views, 0, + pipe->set_sampler_views(pipe, MESA_SHADER_FRAGMENT, 0, num_views, 0, sampler_views); - st->state.num_sampler_views[PIPE_SHADER_FRAGMENT] = num_views; + st->state.num_sampler_views[MESA_SHADER_FRAGMENT] = num_views; for (unsigned i = 0; i < num_views; i++) pipe->sampler_view_release(pipe, sampler_views[i]); @@ -283,7 +283,7 @@ restore_render_state(struct gl_context *ctx) * use them. */ cso_restore_state(cso, CSO_UNBIND_FS_SAMPLERVIEWS); - st->state.num_sampler_views[PIPE_SHADER_FRAGMENT] = 0; + st->state.num_sampler_views[MESA_SHADER_FRAGMENT] = 0; ctx->Array.NewVertexElements = true; ctx->NewDriverState |= ST_NEW_VERTEX_ARRAYS | diff --git a/src/mesa/state_tracker/st_cb_clear.c b/src/mesa/state_tracker/st_cb_clear.c index d6fa72871a3..8f8a8cb7062 100644 --- a/src/mesa/state_tracker/st_cb_clear.c +++ b/src/mesa/state_tracker/st_cb_clear.c @@ -113,7 +113,7 @@ set_clearcolor_fs(struct st_context *st, union pipe_color_union *color) .user_buffer = color->f, .buffer_size = 4 * sizeof(float), }; - st->pipe->set_constant_buffer(st->pipe, PIPE_SHADER_FRAGMENT, 0, + st->pipe->set_constant_buffer(st->pipe, MESA_SHADER_FRAGMENT, 0, false, &cb); if (!st->clear.fs) { diff --git a/src/mesa/state_tracker/st_cb_drawpixels.c b/src/mesa/state_tracker/st_cb_drawpixels.c index bdd6539fd07..35c7ccf5ab8 100644 --- a/src/mesa/state_tracker/st_cb_drawpixels.c +++ b/src/mesa/state_tracker/st_cb_drawpixels.c @@ -834,12 +834,12 @@ draw_textured_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z, if (sv[1]) samplers[fpv->pixelmap_sampler] = &sampler; - cso_set_samplers(cso, PIPE_SHADER_FRAGMENT, num, samplers); + cso_set_samplers(cso, MESA_SHADER_FRAGMENT, num, samplers); } else { /* drawing a depth/stencil image */ const struct pipe_sampler_state *samplers[2] = {&sampler, &sampler}; - cso_set_samplers(cso, PIPE_SHADER_FRAGMENT, num_sampler_view, samplers); + cso_set_samplers(cso, MESA_SHADER_FRAGMENT, num_sampler_view, samplers); } } @@ -852,7 +852,7 @@ draw_textured_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z, unsigned extra_sampler_views = 0; /* drawing a color image */ unsigned num_views = - st_get_sampler_views(st, PIPE_SHADER_FRAGMENT, + st_get_sampler_views(st, MESA_SHADER_FRAGMENT, ctx->FragmentProgram._Current, sampler_views, &extra_sampler_views); num_views = MAX3(fpv->drawpix_sampler + 1, fpv->pixelmap_sampler + 1, @@ -861,9 +861,9 @@ draw_textured_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z, sampler_views[fpv->drawpix_sampler] = sv[0]; if (sv[1]) sampler_views[fpv->pixelmap_sampler] = sv[1]; - pipe->set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0, num_views, 0, + pipe->set_sampler_views(pipe, MESA_SHADER_FRAGMENT, 0, num_views, 0, sampler_views); - st->state.num_sampler_views[PIPE_SHADER_FRAGMENT] = num_views; + st->state.num_sampler_views[MESA_SHADER_FRAGMENT] = num_views; /* release YUV views back to driver */ u_foreach_bit (i, extra_sampler_views) { @@ -871,10 +871,10 @@ draw_textured_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z, } } else { /* drawing a depth/stencil image */ - pipe->set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0, num_sampler_view, + pipe->set_sampler_views(pipe, MESA_SHADER_FRAGMENT, 0, num_sampler_view, 0, sv); - st->state.num_sampler_views[PIPE_SHADER_FRAGMENT] = - MAX2(st->state.num_sampler_views[PIPE_SHADER_FRAGMENT], num_sampler_view); + st->state.num_sampler_views[MESA_SHADER_FRAGMENT] = + MAX2(st->state.num_sampler_views[MESA_SHADER_FRAGMENT], num_sampler_view); } /* viewport state: viewport matching window dims */ @@ -925,7 +925,7 @@ draw_textured_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z, * use them. */ cso_restore_state(cso, CSO_UNBIND_FS_SAMPLERVIEWS); - st->state.num_sampler_views[PIPE_SHADER_FRAGMENT] = 0; + st->state.num_sampler_views[MESA_SHADER_FRAGMENT] = 0; ctx->Array.NewVertexElements = true; ctx->NewDriverState |= ST_NEW_VERTEX_ARRAYS | diff --git a/src/mesa/state_tracker/st_cb_readpixels.c b/src/mesa/state_tracker/st_cb_readpixels.c index 375942b4353..4fc33c05e4a 100644 --- a/src/mesa/state_tracker/st_cb_readpixels.c +++ b/src/mesa/state_tracker/st_cb_readpixels.c @@ -189,14 +189,14 @@ try_pbo_readpixels(struct st_context *st, struct gl_renderbuffer *rb, if (sampler_view == NULL) goto fail; - pipe->set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0, 1, 0, + pipe->set_sampler_views(pipe, MESA_SHADER_FRAGMENT, 0, 1, 0, &sampler_view); - st->state.num_sampler_views[PIPE_SHADER_FRAGMENT] = - MAX2(st->state.num_sampler_views[PIPE_SHADER_FRAGMENT], 1); + st->state.num_sampler_views[MESA_SHADER_FRAGMENT] = + MAX2(st->state.num_sampler_views[MESA_SHADER_FRAGMENT], 1); pipe_sampler_view_release(sampler_view); - cso_set_samplers(cso, PIPE_SHADER_FRAGMENT, 1, samplers); + cso_set_samplers(cso, MESA_SHADER_FRAGMENT, 1, samplers); } /* Set up destination image */ @@ -212,7 +212,7 @@ try_pbo_readpixels(struct st_context *st, struct gl_renderbuffer *rb, image.u.buf.size = (addr.last_element - addr.first_element + 1) * addr.bytes_per_pixel; - pipe->set_shader_images(pipe, PIPE_SHADER_FRAGMENT, 0, 1, 0, &image); + pipe->set_shader_images(pipe, MESA_SHADER_FRAGMENT, 0, 1, 0, &image); } /* Set up no-attachment framebuffer */ @@ -257,7 +257,7 @@ fail: * use them. */ cso_restore_state(cso, CSO_UNBIND_FS_SAMPLERVIEWS | CSO_UNBIND_FS_IMAGE0); - st->state.num_sampler_views[PIPE_SHADER_FRAGMENT] = 0; + st->state.num_sampler_views[MESA_SHADER_FRAGMENT] = 0; st->ctx->Array.NewVertexElements = true; st->ctx->NewDriverState |= ST_NEW_FS_CONSTANTS | diff --git a/src/mesa/state_tracker/st_cb_texture.c b/src/mesa/state_tracker/st_cb_texture.c index 59e9bdab9f1..5b2119e7ba9 100644 --- a/src/mesa/state_tracker/st_cb_texture.c +++ b/src/mesa/state_tracker/st_cb_texture.c @@ -1785,10 +1785,10 @@ try_pbo_upload_common(struct gl_context *ctx, if (sampler_view == NULL) goto fail; - pipe->set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0, 1, 0, + pipe->set_sampler_views(pipe, MESA_SHADER_FRAGMENT, 0, 1, 0, &sampler_view); - st->state.num_sampler_views[PIPE_SHADER_FRAGMENT] = - MAX2(st->state.num_sampler_views[PIPE_SHADER_FRAGMENT], 1); + st->state.num_sampler_views[MESA_SHADER_FRAGMENT] = + MAX2(st->state.num_sampler_views[MESA_SHADER_FRAGMENT], 1); pipe_sampler_view_release(sampler_view); } @@ -1830,7 +1830,7 @@ fail: * use them. */ cso_restore_state(cso, CSO_UNBIND_FS_SAMPLERVIEWS); - st->state.num_sampler_views[PIPE_SHADER_FRAGMENT] = 0; + st->state.num_sampler_views[MESA_SHADER_FRAGMENT] = 0; ctx->Array.NewVertexElements = true; ctx->NewDriverState |= ST_NEW_VERTEX_ARRAYS | @@ -2050,10 +2050,10 @@ try_pbo_download(struct st_context *st, if (sampler_view == NULL) goto fail; - pipe->set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0, 1, 0, &sampler_view); + pipe->set_sampler_views(pipe, MESA_SHADER_FRAGMENT, 0, 1, 0, &sampler_view); pipe->sampler_view_release(pipe, sampler_view); - cso_set_samplers(cso, PIPE_SHADER_FRAGMENT, 1, samplers); + cso_set_samplers(cso, MESA_SHADER_FRAGMENT, 1, samplers); } /* Set up destination image */ @@ -2069,7 +2069,7 @@ try_pbo_download(struct st_context *st, image.u.buf.size = (addr.last_element - addr.first_element + 1) * addr.bytes_per_pixel; - pipe->set_shader_images(pipe, PIPE_SHADER_FRAGMENT, 0, 1, 0, &image); + pipe->set_shader_images(pipe, MESA_SHADER_FRAGMENT, 0, 1, 0, &image); } /* Set up no-attachment framebuffer */ @@ -2112,7 +2112,7 @@ fail: * use them. */ cso_restore_state(cso, CSO_UNBIND_FS_SAMPLERVIEWS | CSO_UNBIND_FS_IMAGE0); - st->state.num_sampler_views[PIPE_SHADER_FRAGMENT] = 0; + st->state.num_sampler_views[MESA_SHADER_FRAGMENT] = 0; st->ctx->Array.NewVertexElements = true; st->ctx->NewDriverState |= ST_NEW_FS_CONSTANTS | diff --git a/src/mesa/state_tracker/st_context.c b/src/mesa/state_tracker/st_context.c index b20d1949efc..288b8b613d0 100644 --- a/src/mesa/state_tracker/st_context.c +++ b/src/mesa/state_tracker/st_context.c @@ -286,7 +286,7 @@ free_zombie_shaders(struct st_context *st) st->ctx->NewDriverState |= ST_NEW_VS_STATE; st->pipe->delete_vs_state(st->pipe, entry->shader); break; - case PIPE_SHADER_FRAGMENT: + case MESA_SHADER_FRAGMENT: st->ctx->NewDriverState |= ST_NEW_FS_STATE; st->pipe->delete_fs_state(st->pipe, entry->shader); break; @@ -627,7 +627,7 @@ st_create_context_priv(struct gl_context *ctx, struct pipe_context *pipe, screen->caps.call_finalize_nir_in_linker; st->has_hw_atomics = - screen->shader_caps[PIPE_SHADER_FRAGMENT].max_hw_atomic_counters + screen->shader_caps[MESA_SHADER_FRAGMENT].max_hw_atomic_counters ? true : false; st->validate_all_dirty_states = diff --git a/src/mesa/state_tracker/st_extensions.c b/src/mesa/state_tracker/st_extensions.c index ba4b25ab0e5..f859490a7cc 100644 --- a/src/mesa/state_tracker/st_extensions.c +++ b/src/mesa/state_tracker/st_extensions.c @@ -239,7 +239,7 @@ void st_init_limits(struct pipe_screen *screen, if (!screen->caps.point_size_fixed) pc->MaxUniformComponents -= 4; - } else if (sh == PIPE_SHADER_FRAGMENT) { + } else if (sh == MESA_SHADER_FRAGMENT) { if (!screen->caps.alpha_test) pc->MaxUniformComponents -= 4; } @@ -1290,7 +1290,7 @@ void st_init_extensions(struct pipe_screen *screen, } else { /* Optional integer support for GLSL 1.2. */ if (screen->shader_caps[MESA_SHADER_VERTEX].integers && - screen->shader_caps[PIPE_SHADER_FRAGMENT].integers) { + screen->shader_caps[MESA_SHADER_FRAGMENT].integers) { consts->NativeIntegers = GL_TRUE; extensions->EXT_shader_integer_mix = GL_TRUE; @@ -1567,7 +1567,7 @@ void st_init_extensions(struct pipe_screen *screen, * prefer to disable varying packing rather than run the risk of varying * packing preventing a shader from running. */ - if (screen->shader_caps[PIPE_SHADER_FRAGMENT].max_tex_indirections <= 8) { + if (screen->shader_caps[MESA_SHADER_FRAGMENT].max_tex_indirections <= 8) { /* We can't disable varying packing if transform feedback is available, * because transform feedback code assumes a packed varying layout. */ @@ -1840,7 +1840,7 @@ void st_init_extensions(struct pipe_screen *screen, screen->caps.allow_draw_out_of_order; consts->GLThreadNopCheckFramebufferStatus = options->glthread_nop_check_framebuffer_status; - if (screen->shader_caps[PIPE_SHADER_FRAGMENT].integers && + if (screen->shader_caps[MESA_SHADER_FRAGMENT].integers && extensions->ARB_stencil_texturing && screen->caps.doubles && !(screen->nir_options[MESA_SHADER_FRAGMENT]->lower_doubles_options & diff --git a/src/mesa/state_tracker/st_pbo.c b/src/mesa/state_tracker/st_pbo.c index 9aa86849e05..bec8ccb344e 100644 --- a/src/mesa/state_tracker/st_pbo.c +++ b/src/mesa/state_tracker/st_pbo.c @@ -260,7 +260,7 @@ st_pbo_draw(struct st_context *st, const struct st_pbo_addresses *addr, cb.buffer_offset = 0; cb.buffer_size = sizeof(addr->constants); - pipe->set_constant_buffer(pipe, PIPE_SHADER_FRAGMENT, 0, false, &cb); + pipe->set_constant_buffer(pipe, MESA_SHADER_FRAGMENT, 0, false, &cb); pipe_resource_reference(&cb.buffer, NULL); } @@ -641,7 +641,7 @@ st_init_pbo_helpers(struct st_context *st) st->pbo.upload_enabled = screen->caps.texture_buffer_objects && screen->caps.texture_buffer_offset_alignment >= 1 && - screen->shader_caps[PIPE_SHADER_FRAGMENT].integers; + screen->shader_caps[MESA_SHADER_FRAGMENT].integers; if (!st->pbo.upload_enabled) return; @@ -649,7 +649,7 @@ st_init_pbo_helpers(struct st_context *st) st->pbo.upload_enabled && screen->caps.sampler_view_target && screen->caps.framebuffer_no_attachment && - screen->shader_caps[PIPE_SHADER_FRAGMENT].max_shader_images >= 1; + screen->shader_caps[MESA_SHADER_FRAGMENT].max_shader_images >= 1; st->pbo.rgba_only = screen->caps.buffer_sampler_view_rgba_only;