#include "util/u_upload_mgr.h"
#include "util/u_vbuf.h"
#include "cso_cache/cso_context.h"
+#include "compiler/glsl/glsl_parser_extras.h"
DEBUG_GET_ONCE_BOOL_OPTION(mesa_mvp_dp4, "MESA_MVP_DP4", FALSE)
st_common_program(ctx->TessEvalProgram._Current);
struct st_common_program *gp =
st_common_program(ctx->GeometryProgram._Current);
- struct st_fragment_program *fp =
- st_fragment_program(ctx->FragmentProgram._Current);
- struct st_compute_program *cp =
- st_compute_program(ctx->ComputeProgram._Current);
+ struct st_common_program *fp =
+ st_common_program(ctx->FragmentProgram._Current);
+ struct st_common_program *cp =
+ st_common_program(ctx->ComputeProgram._Current);
uint64_t active_shader_states = 0;
if (vp)
_NEW_POINT))
st->dirty |= ST_NEW_RASTERIZER;
+ if ((new_state & _NEW_LIGHT) &&
+ (st->lower_flatshade || st->lower_two_sided_color))
+ st->dirty |= ST_NEW_FS_STATE;
+
if (new_state & _NEW_PROJECTION &&
st_user_clip_planes_enabled(ctx))
st->dirty |= ST_NEW_CLIP_STATE;
if (new_state & _NEW_CURRENT_ATTRIB && st_vp_uses_current_values(ctx))
st->dirty |= ST_NEW_VERTEX_ARRAYS;
+ if (st->clamp_frag_depth_in_shader && (new_state & _NEW_VIEWPORT)) {
+ if (ctx->GeometryProgram._Current)
+ st->dirty |= ST_NEW_GS_CONSTANTS;
+ else if (ctx->TessEvalProgram._Current)
+ st->dirty |= ST_NEW_TES_CONSTANTS;
+ else
+ st->dirty |= ST_NEW_VS_CONSTANTS;
+ st->dirty |= ST_NEW_FS_CONSTANTS;
+ }
+
/* Update the vertex shader if ctx->Light._ClampVertexColor was changed. */
- if (st->clamp_vert_color_in_shader && (new_state & _NEW_LIGHT))
+ if (st->clamp_vert_color_in_shader && (new_state & _NEW_LIGHT)) {
st->dirty |= ST_NEW_VS_STATE;
+ if (st->ctx->API == API_OPENGL_COMPAT && ctx->Version >= 32) {
+ st->dirty |= ST_NEW_GS_STATE | ST_NEW_TES_STATE;
+ }
+ }
/* Which shaders are dirty will be determined manually. */
if (new_state & _NEW_PROGRAM) {
/* We need a mutex since this function may be called from one thread
* while free_zombie_resource_views() is called from another.
*/
- mtx_lock(&st->zombie_sampler_views.mutex);
+ simple_mtx_lock(&st->zombie_sampler_views.mutex);
LIST_ADDTAIL(&entry->node, &st->zombie_sampler_views.list.node);
- mtx_unlock(&st->zombie_sampler_views.mutex);
+ simple_mtx_unlock(&st->zombie_sampler_views.mutex);
}
/* We need a mutex since this function may be called from one thread
* while free_zombie_shaders() is called from another.
*/
- mtx_lock(&st->zombie_shaders.mutex);
+ simple_mtx_lock(&st->zombie_shaders.mutex);
LIST_ADDTAIL(&entry->node, &st->zombie_shaders.list.node);
- mtx_unlock(&st->zombie_shaders.mutex);
+ simple_mtx_unlock(&st->zombie_shaders.mutex);
}
return;
}
- mtx_lock(&st->zombie_sampler_views.mutex);
+ simple_mtx_lock(&st->zombie_sampler_views.mutex);
LIST_FOR_EACH_ENTRY_SAFE(entry, next,
&st->zombie_sampler_views.list.node, node) {
assert(LIST_IS_EMPTY(&st->zombie_sampler_views.list.node));
- mtx_unlock(&st->zombie_sampler_views.mutex);
+ simple_mtx_unlock(&st->zombie_sampler_views.mutex);
}
return;
}
- mtx_lock(&st->zombie_shaders.mutex);
+ simple_mtx_lock(&st->zombie_shaders.mutex);
LIST_FOR_EACH_ENTRY_SAFE(entry, next,
&st->zombie_shaders.list.node, node) {
assert(LIST_IS_EMPTY(&st->zombie_shaders.list.node));
- mtx_unlock(&st->zombie_shaders.mutex);
+ simple_mtx_unlock(&st->zombie_shaders.mutex);
}
f->NewFramebufferSRGB = ST_NEW_FB_STATE;
f->NewScissorRect = ST_NEW_SCISSOR;
f->NewScissorTest = ST_NEW_SCISSOR | ST_NEW_RASTERIZER;
- f->NewAlphaTest = ST_NEW_DSA;
+
+ if (st->lower_alpha_test)
+ f->NewAlphaTest = ST_NEW_FS_STATE;
+ else
+ f->NewAlphaTest = ST_NEW_DSA;
+
f->NewBlend = ST_NEW_BLEND;
f->NewBlendColor = ST_NEW_BLEND_COLOR;
f->NewColorMask = ST_NEW_BLEND;
f->NewClipControl = ST_NEW_VIEWPORT | ST_NEW_RASTERIZER;
f->NewClipPlane = ST_NEW_CLIP_STATE;
- f->NewClipPlaneEnable = ST_NEW_RASTERIZER;
- f->NewDepthClamp = ST_NEW_RASTERIZER;
+
+ if (st->clamp_frag_depth_in_shader) {
+ f->NewClipControl |= ST_NEW_VS_STATE | ST_NEW_GS_STATE |
+ ST_NEW_TES_STATE;
+
+ f->NewDepthClamp = ST_NEW_FS_STATE | ST_NEW_VS_STATE |
+ ST_NEW_GS_STATE | ST_NEW_TES_STATE;
+ } else {
+ f->NewDepthClamp = ST_NEW_RASTERIZER;
+ }
+
+ if (st->lower_ucp)
+ f->NewClipPlaneEnable = ST_NEW_VS_STATE;
+ else
+ f->NewClipPlaneEnable = ST_NEW_RASTERIZER;
+
f->NewLineState = ST_NEW_RASTERIZER;
f->NewPolygonState = ST_NEW_RASTERIZER;
f->NewPolygonStipple = ST_NEW_POLY_STIPPLE;
ctx->Const.PackedDriverUniformStorage =
screen->get_param(screen, PIPE_CAP_PACKED_UNIFORMS);
+ ctx->Const.BitmapUsesRed =
+ screen->is_format_supported(screen, PIPE_FORMAT_R8_UNORM,
+ PIPE_TEXTURE_2D, 0, 0,
+ PIPE_BIND_SAMPLER_VIEW);
+
st->has_stencil_export =
screen->get_param(screen, PIPE_CAP_SHADER_STENCIL_EXPORT);
- st->has_shader_model3 = screen->get_param(screen, PIPE_CAP_SM3);
st->has_etc1 = screen->is_format_supported(screen, PIPE_FORMAT_ETC1_RGB8,
PIPE_TEXTURE_2D, 0, 0,
PIPE_BIND_SAMPLER_VIEW);
screen->get_param(screen, PIPE_CAP_INDEP_BLEND_FUNC);
st->needs_rgb_dst_alpha_override =
screen->get_param(screen, PIPE_CAP_RGB_OVERRIDE_DST_ALPHA_BLEND);
+ st->has_signed_vertex_buffer_offset =
+ screen->get_param(screen, PIPE_CAP_SIGNED_VERTEX_BUFFER_OFFSET);
+ st->lower_flatshade =
+ !screen->get_param(screen, PIPE_CAP_FLATSHADE);
+ st->lower_alpha_test =
+ !screen->get_param(screen, PIPE_CAP_ALPHA_TEST);
+ st->lower_point_size =
+ !screen->get_param(screen, PIPE_CAP_POINT_SIZE_FIXED);
+ st->lower_two_sided_color =
+ !screen->get_param(screen, PIPE_CAP_TWO_SIDED_COLOR);
+ st->lower_ucp =
+ !screen->get_param(screen, PIPE_CAP_CLIP_PLANES);
st->has_hw_atomics =
screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
PIPE_CAP_MAX_TEXTURE_UPLOAD_MEMORY_BUDGET));
/* GL limits and extensions */
- st_init_limits(pipe->screen, &ctx->Const, &ctx->Extensions, ctx->API);
+ st_init_limits(pipe->screen, &ctx->Const, &ctx->Extensions);
st_init_extensions(pipe->screen, &ctx->Const,
&ctx->Extensions, &st->options, ctx->API);
}
}
+ if (screen->get_param(screen, PIPE_CAP_DEPTH_CLIP_DISABLE) == 2)
+ st->clamp_frag_depth_in_shader = true;
+
/* called after _mesa_create_context/_mesa_init_point, fix default user
* settable max point size up
*/
* is not supported
*/
ctx->Const.ShaderCompilerOptions[MESA_SHADER_VERTEX].EmitNoSat =
- !st->has_shader_model3;
+ !screen->get_param(screen, PIPE_CAP_VERTEX_SHADER_SATURATE);
- if (!ctx->Extensions.ARB_gpu_shader5) {
+ if (ctx->Const.GLSLVersion < 400) {
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->clamp_frag_depth_in_shader &&
+ !st->clamp_vert_color_in_shader &&
+ !st->lower_point_size &&
+ !st->lower_ucp;
st->shader_has_one_variant[MESA_SHADER_FRAGMENT] =
st->has_shareable_shaders &&
+ !st->lower_flatshade &&
+ !st->lower_alpha_test &&
!st->clamp_frag_color_in_shader &&
- !st->force_persample_in_shader;
+ !st->clamp_frag_depth_in_shader &&
+ !st->force_persample_in_shader &&
+ !st->lower_two_sided_color;
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;
+ st->shader_has_one_variant[MESA_SHADER_TESS_EVAL] =
+ st->has_shareable_shaders &&
+ !st->clamp_frag_depth_in_shader &&
+ !st->clamp_vert_color_in_shader;
+ st->shader_has_one_variant[MESA_SHADER_GEOMETRY] =
+ st->has_shareable_shaders &&
+ !st->clamp_frag_depth_in_shader &&
+ !st->clamp_vert_color_in_shader;
st->shader_has_one_variant[MESA_SHADER_COMPUTE] = st->has_shareable_shaders;
st->bitmap.cache.empty = true;
LIST_INITHEAD(&st->winsys_buffers);
LIST_INITHEAD(&st->zombie_sampler_views.list.node);
- mtx_init(&st->zombie_sampler_views.mutex, mtx_plain);
+ simple_mtx_init(&st->zombie_sampler_views.mutex, mtx_plain);
LIST_INITHEAD(&st->zombie_shaders.list.node);
- mtx_init(&st->zombie_shaders.mutex, mtx_plain);
+ simple_mtx_init(&st->zombie_shaders.mutex, mtx_plain);
return st;
}
st_texture_release_context_sampler_view(st, st_texture_object(texObj));
}
+static void
+destroy_framebuffer_attachment_sampler_cb(GLuint id, void *data, void *userData)
+{
+ struct gl_framebuffer* glfb = (struct gl_framebuffer*) data;
+ struct st_context *st = (struct st_context *) userData;
+
+ for (unsigned i = 0; i < BUFFER_COUNT; i++) {
+ struct gl_renderbuffer_attachment *att = &glfb->Attachment[i];
+ if (att->Texture) {
+ st_texture_release_context_sampler_view(st, st_texture_object(att->Texture));
+ }
+ }
+}
void
st_destroy_context(struct st_context *st)
st_context_free_zombie_objects(st);
- mtx_destroy(&st->zombie_sampler_views.mutex);
- mtx_destroy(&st->zombie_shaders.mutex);
+ simple_mtx_destroy(&st->zombie_sampler_views.mutex);
+ simple_mtx_destroy(&st->zombie_shaders.mutex);
- st_reference_fragprog(st, &st->fp, NULL);
+ st_reference_prog(st, &st->fp, NULL);
st_reference_prog(st, &st->gp, NULL);
st_reference_vertprog(st, &st->vp, NULL);
st_reference_prog(st, &st->tcp, NULL);
st_reference_prog(st, &st->tep, NULL);
- st_reference_compprog(st, &st->cp, NULL);
+ st_reference_prog(st, &st->cp, NULL);
/* release framebuffer in the winsys buffers list */
LIST_FOR_EACH_ENTRY_SAFE_REV(stfb, next, &st->winsys_buffers, head) {
st_framebuffer_reference(&stfb, NULL);
}
+ _mesa_HashWalk(ctx->Shared->FrameBuffers, destroy_framebuffer_attachment_sampler_cb, st);
+
pipe_sampler_view_reference(&st->pixel_xfer.pixelmap_sampler_view, NULL);
pipe_resource_reference(&st->pixel_xfer.pixelmap_texture, NULL);
st_destroy_program_variants(st);
- _mesa_free_context_data(ctx);
+ _mesa_free_context_data(ctx, false);
/* This will free the st_context too, so 'st' must not be accessed
* afterwards. */