#include "st_cb_blit.h"
#include "st_cb_bufferobjects.h"
#include "st_cb_clear.h"
+#include "st_cb_compute.h"
#include "st_cb_condrender.h"
+#include "st_cb_copyimage.h"
#include "st_cb_drawpixels.h"
#include "st_cb_rasterpos.h"
#include "st_cb_drawtex.h"
DEBUG_GET_ONCE_BOOL_OPTION(mesa_mvp_dp4, "MESA_MVP_DP4", FALSE)
+/**
+ * Called via ctx->Driver.Enable()
+ */
+static void st_Enable(struct gl_context * ctx, GLenum cap, GLboolean state)
+{
+ struct st_context *st = st_context(ctx);
+
+ switch (cap) {
+ case GL_DEBUG_OUTPUT:
+ st_enable_debug_output(st, state);
+ break;
+ default:
+ break;
+ }
+}
+
+
+/**
+ * Called via ctx->Driver.QueryMemoryInfo()
+ */
+static void
+st_query_memory_info(struct gl_context *ctx, struct gl_memory_info *out)
+{
+ struct pipe_screen *screen = st_context(ctx)->pipe->screen;
+ struct pipe_memory_info info;
+
+ assert(screen->query_memory_info);
+ if (!screen->query_memory_info)
+ return;
+
+ screen->query_memory_info(screen, &info);
+
+ out->total_device_memory = info.total_device_memory;
+ out->avail_device_memory = info.avail_device_memory;
+ out->total_staging_memory = info.total_staging_memory;
+ out->avail_staging_memory = info.avail_staging_memory;
+ out->device_memory_evicted = info.device_memory_evicted;
+ out->nr_device_memory_evictions = info.nr_device_memory_evictions;
+}
+
+
/**
* Called via ctx->Driver.UpdateState()
*/
-void st_invalidate_state(struct gl_context * ctx, GLuint new_state)
+void st_invalidate_state(struct gl_context * ctx, GLbitfield new_state)
{
struct st_context *st = st_context(ctx);
st->dirty.st |= ST_NEW_VERTEX_PROGRAM;
}
+ /* Invalidate render and compute pipelines. */
st->dirty.mesa |= new_state;
st->dirty.st |= ST_NEW_MESA;
+ st->dirty_cp.mesa |= new_state;
+ st->dirty_cp.st |= ST_NEW_MESA;
/* This is the only core Mesa module we depend upon.
* No longer use swrast, swsetup, tnl.
st_destroy_drawpix(st);
st_destroy_drawtex(st);
st_destroy_perfmon(st);
+ st_destroy_pbo_upload(st);
for (shader = 0; shader < ARRAY_SIZE(st->state.sampler_views); shader++) {
for (i = 0; i < ARRAY_SIZE(st->state.sampler_views[0]); i++) {
u_upload_destroy(st->constbuf_uploader);
}
+ /* free glDrawPixels cache data */
+ free(st->drawpix_cache.image);
+ pipe_resource_reference(&st->drawpix_cache.texture, NULL);
+
cso_destroy_context(st->cso_context);
free( st );
}
/* state tracker needs the VBO module */
_vbo_CreateContext(ctx);
+ /* Initialize render and compute pipelines flags */
st->dirty.mesa = ~0;
st->dirty.st = ~0;
+ st->dirty_cp.mesa = ~0;
+ st->dirty_cp.st = ~0;
/* Create upload manager for vertex data for glBitmap, glDrawPixels,
* glClear, etc.
*/
- st->uploader = u_upload_create(st->pipe, 65536, 4, PIPE_BIND_VERTEX_BUFFER);
+ st->uploader = u_upload_create(st->pipe, 65536, PIPE_BIND_VERTEX_BUFFER,
+ PIPE_USAGE_STREAM);
if (!screen->get_param(screen, PIPE_CAP_USER_INDEX_BUFFERS)) {
- st->indexbuf_uploader = u_upload_create(st->pipe, 128 * 1024, 4,
- PIPE_BIND_INDEX_BUFFER);
+ st->indexbuf_uploader = u_upload_create(st->pipe, 128 * 1024,
+ PIPE_BIND_INDEX_BUFFER,
+ PIPE_USAGE_STREAM);
}
- if (!screen->get_param(screen, PIPE_CAP_USER_CONSTANT_BUFFERS)) {
- unsigned alignment =
- screen->get_param(screen, PIPE_CAP_CONSTANT_BUFFER_OFFSET_ALIGNMENT);
-
- st->constbuf_uploader = u_upload_create(pipe, 128 * 1024, alignment,
- PIPE_BIND_CONSTANT_BUFFER);
- }
+ if (!screen->get_param(screen, PIPE_CAP_USER_CONSTANT_BUFFERS))
+ st->constbuf_uploader = u_upload_create(pipe, 128 * 1024,
+ PIPE_BIND_CONSTANT_BUFFER,
+ PIPE_USAGE_STREAM);
st->cso_context = cso_create_context(pipe);
st_init_atoms( st );
- st_init_bitmap(st);
st_init_clear(st);
st_init_draw( st );
+ st_init_pbo_upload(st);
/* Choose texture target for glDrawPixels, glBitmap, renderbuffers */
if (pipe->screen->get_param(pipe->screen, PIPE_CAP_NPOT_TEXTURES))
else
st->internal_target = PIPE_TEXTURE_RECT;
- /* Vertex element objects used for drawing rectangles for glBitmap,
- * glDrawPixels, glClear, etc.
+ /* Setup vertex element info for 'struct st_util_vertex'.
*/
- for (i = 0; i < ARRAY_SIZE(st->velems_util_draw); i++) {
- memset(&st->velems_util_draw[i], 0, sizeof(struct pipe_vertex_element));
- st->velems_util_draw[i].src_offset = i * 4 * sizeof(float);
- st->velems_util_draw[i].instance_divisor = 0;
- st->velems_util_draw[i].vertex_buffer_index =
- cso_get_aux_vertex_buffer_slot(st->cso_context);
- st->velems_util_draw[i].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
+ {
+ const unsigned slot = cso_get_aux_vertex_buffer_slot(st->cso_context);
+
+ /* If this assertion ever fails all state tracker calls to
+ * cso_get_aux_vertex_buffer_slot() should be audited. This
+ * particular call would have to be moved to just before each
+ * drawing call.
+ */
+ assert(slot == 0);
+
+ STATIC_ASSERT(sizeof(struct st_util_vertex) == 9 * sizeof(float));
+
+ memset(&st->util_velems, 0, sizeof(st->util_velems));
+ st->util_velems[0].src_offset = 0;
+ st->util_velems[0].vertex_buffer_index = slot;
+ st->util_velems[0].src_format = PIPE_FORMAT_R32G32B32_FLOAT;
+ st->util_velems[1].src_offset = 3 * sizeof(float);
+ st->util_velems[1].vertex_buffer_index = slot;
+ st->util_velems[1].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
+ st->util_velems[2].src_offset = 7 * sizeof(float);
+ st->util_velems[2].vertex_buffer_index = slot;
+ st->util_velems[2].src_format = PIPE_FORMAT_R32G32_FLOAT;
}
/* we want all vertex data to be placed in buffer objects */
/* Need these flags:
*/
- st->ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
-
- st->ctx->VertexProgram._MaintainTnlProgram = GL_TRUE;
+ ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
- st->pixel_xfer.cache = _mesa_new_program_cache();
+ ctx->VertexProgram._MaintainTnlProgram = GL_TRUE;
st->has_stencil_export =
screen->get_param(screen, PIPE_CAP_SHADER_STENCIL_EXPORT);
PIPE_BIND_SAMPLER_VIEW);
st->prefer_blit_based_texture_transfer = screen->get_param(screen,
PIPE_CAP_PREFER_BLIT_BASED_TEXTURE_TRANSFER);
-
+ st->force_persample_in_shader =
+ screen->get_param(screen, PIPE_CAP_SAMPLE_SHADING) &&
+ !screen->get_param(screen, PIPE_CAP_FORCE_PERSAMPLE_INTERP);
+ st->has_shareable_shaders = screen->get_param(screen,
+ PIPE_CAP_SHAREABLE_SHADERS);
st->needs_texcoord_semantic =
screen->get_param(screen, PIPE_CAP_TGSI_TEXCOORD);
st->apply_texture_swizzle_to_border_color =
PIPE_QUIRK_TEXTURE_BORDER_COLOR_SWIZZLE_R600));
st->has_time_elapsed =
screen->get_param(screen, PIPE_CAP_QUERY_TIME_ELAPSED);
+ st->has_half_float_packing =
+ screen->get_param(screen, PIPE_CAP_TGSI_PACK_HALF_FLOAT);
+ st->has_multi_draw_indirect =
+ screen->get_param(screen, PIPE_CAP_MULTI_DRAW_INDIRECT);
/* GL limits and extensions */
st_init_limits(st->pipe->screen, &ctx->Const, &ctx->Extensions);
st_init_extensions(st->pipe->screen, &ctx->Const,
&ctx->Extensions, &st->options, ctx->Mesa_DXTn);
- if (st_init_perfmon(st)) {
- /* GL_AMD_performance_monitor is only enabled when the underlying
- * driver expose GPU hardware performance counters. */
+ if (st_have_perfmon(st)) {
ctx->Extensions.AMD_performance_monitor = GL_TRUE;
}
/* called after _mesa_create_context/_mesa_init_point, fix default user
* settable max point size up
*/
- st->ctx->Point.MaxSize = MAX2(ctx->Const.MaxPointSize,
- ctx->Const.MaxPointSizeAA);
+ ctx->Point.MaxSize = MAX2(ctx->Const.MaxPointSize,
+ ctx->Const.MaxPointSizeAA);
/* For vertex shaders, make sure not to emit saturate when SM 3.0 is not supported */
ctx->Const.ShaderCompilerOptions[MESA_SHADER_VERTEX].EmitNoSat = !st->has_shader_model3;
+ if (!ctx->Extensions.ARB_gpu_shader5) {
+ for (i = 0; i < MESA_SHADER_STAGES; i++)
+ ctx->Const.ShaderCompilerOptions[i].EmitNoIndirectSampler = true;
+ }
+
+ /* Set which shader types can be compiled at link time. */
+ st->shader_has_one_variant[MESA_SHADER_VERTEX] =
+ st->has_shareable_shaders &&
+ !st->clamp_vert_color_in_shader;
+
+ st->shader_has_one_variant[MESA_SHADER_FRAGMENT] =
+ st->has_shareable_shaders &&
+ !st->clamp_frag_color_in_shader &&
+ !st->force_persample_in_shader;
+
+ st->shader_has_one_variant[MESA_SHADER_TESS_CTRL] = st->has_shareable_shaders;
+ st->shader_has_one_variant[MESA_SHADER_TESS_EVAL] = st->has_shareable_shaders;
+ st->shader_has_one_variant[MESA_SHADER_GEOMETRY] = st->has_shareable_shaders;
+
_mesa_compute_version(ctx);
if (ctx->Version == 0) {
f->NewArray = ST_NEW_VERTEX_ARRAYS;
f->NewRasterizerDiscard = ST_NEW_RASTERIZER;
f->NewUniformBuffer = ST_NEW_UNIFORM_BUFFER;
+ f->NewDefaultTessLevels = ST_NEW_TESS_STATE;
+ f->NewTextureBuffer = ST_NEW_SAMPLER_VIEWS;
+ f->NewAtomicBuffer = ST_NEW_ATOMIC_BUFFER;
+ f->NewShaderStorageBuffer = ST_NEW_STORAGE_BUFFER;
+ f->NewImageUnits = ST_NEW_IMAGE_UNITS;
}
struct st_context *st_create_context(gl_api api, struct pipe_context *pipe,
struct st_context *st;
memset(&funcs, 0, sizeof(funcs));
- st_init_driver_functions(&funcs);
+ st_init_driver_functions(pipe->screen, &funcs);
ctx = _mesa_create_context(api, visual, shareCtx, &funcs);
if (!ctx) {
st_reference_fragprog(st, &st->fp, NULL);
st_reference_geomprog(st, &st->gp, NULL);
st_reference_vertprog(st, &st->vp, NULL);
+ st_reference_tesscprog(st, &st->tcp, NULL);
+ st_reference_tesseprog(st, &st->tep, NULL);
+ st_reference_compprog(st, &st->cp, NULL);
/* release framebuffer surfaces */
for (i = 0; i < PIPE_MAX_COLOR_BUFS; i++) {
pipe_surface_reference(&st->state.framebuffer.cbufs[i], NULL);
}
pipe_surface_reference(&st->state.framebuffer.zsbuf, NULL);
+ pipe_sampler_view_reference(&st->pixel_xfer.pixelmap_sampler_view, NULL);
+ pipe_resource_reference(&st->pixel_xfer.pixelmap_texture, NULL);
- pipe->set_index_buffer(pipe, NULL);
-
- for (i = 0; i < PIPE_SHADER_TYPES; i++) {
- pipe->set_constant_buffer(pipe, i, 0, NULL);
- }
-
- _mesa_delete_program_cache(st->ctx, st->pixel_xfer.cache);
-
- _vbo_DestroyContext(st->ctx);
+ _vbo_DestroyContext(ctx);
st_destroy_program_variants(st);
free(ctx);
}
+static void
+st_emit_string_marker(struct gl_context *ctx, const GLchar *string, GLsizei len)
+{
+ struct st_context *st = ctx->st;
+ st->pipe->emit_string_marker(st->pipe, string, len);
+}
-void st_init_driver_functions(struct dd_function_table *functions)
+void st_init_driver_functions(struct pipe_screen *screen,
+ struct dd_function_table *functions)
{
_mesa_init_shader_object_functions(functions);
_mesa_init_sampler_object_functions(functions);
- functions->Accum = _mesa_accum;
-
st_init_blit_functions(functions);
- st_init_bufferobject_functions(functions);
+ st_init_bufferobject_functions(screen, functions);
st_init_clear_functions(functions);
st_init_bitmap_functions(functions);
+ st_init_copy_image_functions(functions);
st_init_drawpixels_functions(functions);
st_init_rasterpos_functions(functions);
st_init_readpixels_functions(functions);
st_init_texture_functions(functions);
st_init_texture_barrier_functions(functions);
- st_init_flush_functions(functions);
+ st_init_flush_functions(screen, functions);
st_init_string_functions(functions);
st_init_viewport_functions(functions);
+ st_init_compute_functions(functions);
st_init_xformfb_functions(functions);
st_init_syncobj_functions(functions);
st_init_vdpau_functions(functions);
+ if (screen->get_param(screen, PIPE_CAP_STRING_MARKER))
+ functions->EmitStringMarker = st_emit_string_marker;
+
+ functions->Enable = st_Enable;
functions->UpdateState = st_invalidate_state;
+ functions->QueryMemoryInfo = st_query_memory_info;
}
projects / mesa.git / blobdiff