/** * Set renderer fragment shader. * * This function modifies fragment_shader state. */ static void renderer_set_fs(struct renderer *r, RendererFs id) { /* create as needed */ if (!r->cached_fs[id]) { void *fs = NULL; switch (id) { case RENDERER_FS_COLOR: fs = util_make_fragment_passthrough_shader(r->pipe, TGSI_SEMANTIC_COLOR, TGSI_INTERPOLATE_PERSPECTIVE, TRUE); break; case RENDERER_FS_TEXTURE: fs = util_make_fragment_tex_shader(r->pipe, TGSI_TEXTURE_2D, TGSI_INTERPOLATE_LINEAR); break; case RENDERER_FS_SCISSOR: fs = create_scissor_fs(r->pipe); break; case RENDERER_FS_WHITE: fs = create_white_fs(r->pipe); break; default: assert(!"Unknown renderer fs id"); break; } r->cached_fs[id] = fs; } cso_set_fragment_shader_handle(r->cso, r->cached_fs[id]); }
static void null_sampler_view(struct pipe_context *ctx, unsigned tgsi_tex_target) { struct cso_context *cso; struct pipe_resource *cb; void *fs, *vs; bool pass = true; /* 2 expected colors: */ static const float expected_tex[] = {0, 0, 0, 1, 0, 0, 0, 0}; static const float expected_buf[] = {0, 0, 0, 0}; const float *expected = tgsi_tex_target == TGSI_TEXTURE_BUFFER ? expected_buf : expected_tex; unsigned num_expected = tgsi_tex_target == TGSI_TEXTURE_BUFFER ? 1 : 2; if (tgsi_tex_target == TGSI_TEXTURE_BUFFER && !ctx->screen->get_param(ctx->screen, PIPE_CAP_TEXTURE_BUFFER_OBJECTS)) { util_report_result_helper(SKIP, "%s: %s", __func__, tgsi_texture_names[tgsi_tex_target]); return; } cso = cso_create_context(ctx, 0); cb = util_create_texture2d(ctx->screen, 256, 256, PIPE_FORMAT_R8G8B8A8_UNORM, 0); util_set_common_states_and_clear(cso, ctx, cb); ctx->set_sampler_views(ctx, PIPE_SHADER_FRAGMENT, 0, 1, NULL); /* Fragment shader. */ fs = util_make_fragment_tex_shader(ctx, tgsi_tex_target, TGSI_INTERPOLATE_LINEAR, TGSI_RETURN_TYPE_FLOAT, TGSI_RETURN_TYPE_FLOAT, false, false); cso_set_fragment_shader_handle(cso, fs); /* Vertex shader. */ vs = util_set_passthrough_vertex_shader(cso, ctx, false); util_draw_fullscreen_quad(cso); /* Probe pixels. */ pass = pass && util_probe_rect_rgba_multi(ctx, cb, 0, 0, cb->width0, cb->height0, expected, num_expected); /* Cleanup. */ cso_destroy_context(cso); ctx->delete_vs_state(ctx, vs); ctx->delete_fs_state(ctx, fs); pipe_resource_reference(&cb, NULL); util_report_result_helper(pass, "%s: %s", __func__, tgsi_texture_names[tgsi_tex_target]); }
static INLINE void *blitter_get_fs_texfetch_col(struct blitter_context_priv *ctx, unsigned tex_target) { struct pipe_context *pipe = ctx->base.pipe; assert(tex_target < PIPE_MAX_TEXTURE_TYPES); /* Create the fragment shader on-demand. */ if (!ctx->fs_texfetch_col[tex_target]) { unsigned tgsi_tex = pipe_tex_to_tgsi_tex(tex_target); ctx->fs_texfetch_col[tex_target] = util_make_fragment_tex_shader(pipe, tgsi_tex, TGSI_INTERPOLATE_LINEAR); } return ctx->fs_texfetch_col[tex_target]; }
/** * Helper function to set the fragment shaders. */ static INLINE void set_fragment_shader(struct gen_mipmap_state *ctx, uint type, boolean output_depth) { if (output_depth) { if (!ctx->fs_depth[type]) ctx->fs_depth[type] = util_make_fragment_tex_shader_writedepth(ctx->pipe, type, TGSI_INTERPOLATE_LINEAR); cso_set_fragment_shader_handle(ctx->cso, ctx->fs_depth[type]); } else { if (!ctx->fs_color[type]) ctx->fs_color[type] = util_make_fragment_tex_shader(ctx->pipe, type, TGSI_INTERPOLATE_LINEAR); cso_set_fragment_shader_handle(ctx->cso, ctx->fs_color[type]); } }
static void init_prog(struct program *p) { struct pipe_surface surf_tmpl; int ret; /* find a hardware device */ ret = pipe_loader_probe(&p->dev, 1); assert(ret); /* init a pipe screen */ p->screen = pipe_loader_create_screen(p->dev, PIPE_SEARCH_DIR); assert(p->screen); /* create the pipe driver context and cso context */ p->pipe = p->screen->context_create(p->screen, NULL); p->cso = cso_create_context(p->pipe); /* set clear color */ p->clear_color.f[0] = 0.3; p->clear_color.f[1] = 0.1; p->clear_color.f[2] = 0.3; p->clear_color.f[3] = 1.0; /* vertex buffer */ { float vertices[4][2][4] = { { { 0.9f, 0.9f, 0.0f, 1.0f }, { 1.0f, 1.0f, 0.0f, 1.0f } }, { { -0.9f, 0.9f, 0.0f, 1.0f }, { 0.0f, 1.0f, 0.0f, 1.0f } }, { { -0.9f, -0.9f, 0.0f, 1.0f }, { 0.0f, 0.0f, 1.0f, 1.0f } }, { { 0.9f, -0.9f, 0.0f, 1.0f }, { 1.0f, 0.0f, 1.0f, 1.0f } } }; p->vbuf = pipe_buffer_create(p->screen, PIPE_BIND_VERTEX_BUFFER, PIPE_USAGE_DEFAULT, sizeof(vertices)); pipe_buffer_write(p->pipe, p->vbuf, 0, sizeof(vertices), vertices); } /* render target texture */ { struct pipe_resource tmplt; memset(&tmplt, 0, sizeof(tmplt)); tmplt.target = PIPE_TEXTURE_2D; tmplt.format = PIPE_FORMAT_B8G8R8A8_UNORM; /* All drivers support this */ tmplt.width0 = WIDTH; tmplt.height0 = HEIGHT; tmplt.depth0 = 1; tmplt.array_size = 1; tmplt.last_level = 0; tmplt.bind = PIPE_BIND_RENDER_TARGET; p->target = p->screen->resource_create(p->screen, &tmplt); } /* sampler texture */ { uint32_t *ptr; struct pipe_transfer *t; struct pipe_resource t_tmplt; struct pipe_sampler_view v_tmplt; struct pipe_box box; memset(&t_tmplt, 0, sizeof(t_tmplt)); t_tmplt.target = PIPE_TEXTURE_2D; t_tmplt.format = PIPE_FORMAT_B8G8R8A8_UNORM; /* All drivers support this */ t_tmplt.width0 = 2; t_tmplt.height0 = 2; t_tmplt.depth0 = 1; t_tmplt.array_size = 1; t_tmplt.last_level = 0; t_tmplt.bind = PIPE_BIND_RENDER_TARGET; p->tex = p->screen->resource_create(p->screen, &t_tmplt); memset(&box, 0, sizeof(box)); box.width = 2; box.height = 2; ptr = p->pipe->transfer_map(p->pipe, p->tex, 0, PIPE_TRANSFER_WRITE, &box, &t); ptr[0] = 0xffff0000; ptr[1] = 0xff0000ff; ptr[2] = 0xff00ff00; ptr[3] = 0xffffff00; p->pipe->transfer_unmap(p->pipe, t); u_sampler_view_default_template(&v_tmplt, p->tex, p->tex->format); p->view = p->pipe->create_sampler_view(p->pipe, p->tex, &v_tmplt); } /* disabled blending/masking */ memset(&p->blend, 0, sizeof(p->blend)); p->blend.rt[0].colormask = PIPE_MASK_RGBA; /* no-op depth/stencil/alpha */ memset(&p->depthstencil, 0, sizeof(p->depthstencil)); /* rasterizer */ memset(&p->rasterizer, 0, sizeof(p->rasterizer)); p->rasterizer.cull_face = PIPE_FACE_NONE; p->rasterizer.half_pixel_center = 1; p->rasterizer.bottom_edge_rule = 1; p->rasterizer.depth_clip = 1; /* sampler */ memset(&p->sampler, 0, sizeof(p->sampler)); p->sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE; p->sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE; p->sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE; p->sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE; p->sampler.min_img_filter = PIPE_TEX_MIPFILTER_LINEAR; p->sampler.mag_img_filter = PIPE_TEX_MIPFILTER_LINEAR; p->sampler.normalized_coords = 1; surf_tmpl.format = PIPE_FORMAT_B8G8R8A8_UNORM; /* All drivers support this */ surf_tmpl.u.tex.level = 0; surf_tmpl.u.tex.first_layer = 0; surf_tmpl.u.tex.last_layer = 0; /* drawing destination */ memset(&p->framebuffer, 0, sizeof(p->framebuffer)); p->framebuffer.width = WIDTH; p->framebuffer.height = HEIGHT; p->framebuffer.nr_cbufs = 1; p->framebuffer.cbufs[0] = p->pipe->create_surface(p->pipe, p->target, &surf_tmpl); /* viewport, depth isn't really needed */ { float x = 0; float y = 0; float z = FAR; float half_width = (float)WIDTH / 2.0f; float half_height = (float)HEIGHT / 2.0f; float half_depth = ((float)FAR - (float)NEAR) / 2.0f; float scale, bias; if (FLIP) { scale = -1.0f; bias = (float)HEIGHT; } else { scale = 1.0f; bias = 0.0f; } p->viewport.scale[0] = half_width; p->viewport.scale[1] = half_height * scale; p->viewport.scale[2] = half_depth; p->viewport.translate[0] = half_width + x; p->viewport.translate[1] = (half_height + y) * scale + bias; p->viewport.translate[2] = half_depth + z; } /* vertex elements state */ memset(p->velem, 0, sizeof(p->velem)); p->velem[0].src_offset = 0 * 4 * sizeof(float); /* offset 0, first element */ p->velem[0].instance_divisor = 0; p->velem[0].vertex_buffer_index = 0; p->velem[0].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT; p->velem[1].src_offset = 1 * 4 * sizeof(float); /* offset 16, second element */ p->velem[1].instance_divisor = 0; p->velem[1].vertex_buffer_index = 0; p->velem[1].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT; /* vertex shader */ { const uint semantic_names[] = { TGSI_SEMANTIC_POSITION, TGSI_SEMANTIC_GENERIC }; const uint semantic_indexes[] = { 0, 0 }; p->vs = util_make_vertex_passthrough_shader(p->pipe, 2, semantic_names, semantic_indexes, FALSE); } /* fragment shader */ p->fs = util_make_fragment_tex_shader(p->pipe, TGSI_TEXTURE_2D, TGSI_INTERPOLATE_LINEAR); }
static void setup_shaders(struct renderer *ctx) { struct pipe_context *pipe = ctx->pipe; /* fragment shader */ ctx->fs = util_make_fragment_tex_shader(pipe, TGSI_TEXTURE_2D); }