2007-05-24 10:41:34 +01:00
|
|
|
/**************************************************************************
|
2017-11-10 17:58:28 +00:00
|
|
|
*
|
s/Tungsten Graphics/VMware/
Tungsten Graphics Inc. was acquired by VMware Inc. in 2008. Leaving the
old copyright name is creating unnecessary confusion, hence this change.
This was the sed script I used:
$ cat tg2vmw.sed
# Run as:
#
# git reset --hard HEAD && find include scons src -type f -not -name 'sed*' -print0 | xargs -0 sed -i -f tg2vmw.sed
#
# Rename copyrights
s/Tungsten Gra\(ph\|hp\)ics,\? [iI]nc\.\?\(, Cedar Park\)\?\(, Austin\)\?\(, \(Texas\|TX\)\)\?\.\?/VMware, Inc./g
/Copyright/s/Tungsten Graphics\(,\? [iI]nc\.\)\?\(, Cedar Park\)\?\(, Austin\)\?\(, \(Texas\|TX\)\)\?\.\?/VMware, Inc./
s/TUNGSTEN GRAPHICS/VMWARE/g
# Rename emails
s/alanh@tungstengraphics.com/alanh@vmware.com/
s/jens@tungstengraphics.com/jowen@vmware.com/g
s/jrfonseca-at-tungstengraphics-dot-com/jfonseca-at-vmware-dot-com/
s/jrfonseca\?@tungstengraphics.com/jfonseca@vmware.com/g
s/keithw\?@tungstengraphics.com/keithw@vmware.com/g
s/michel@tungstengraphics.com/daenzer@vmware.com/g
s/thomas-at-tungstengraphics-dot-com/thellstom-at-vmware-dot-com/
s/zack@tungstengraphics.com/zackr@vmware.com/
# Remove dead links
s@Tungsten Graphics (http://www.tungstengraphics.com)@Tungsten Graphics@g
# C string src/gallium/state_trackers/vega/api_misc.c
s/"Tungsten Graphics, Inc"/"VMware, Inc"/
Reviewed-by: Brian Paul <brianp@vmware.com>
2014-01-17 16:27:50 +00:00
|
|
|
* Copyright 2007 VMware, Inc.
|
2007-05-24 10:41:34 +01:00
|
|
|
* All Rights Reserved.
|
2017-11-10 17:58:28 +00:00
|
|
|
*
|
2007-05-24 10:41:34 +01:00
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
|
* copy of this software and associated documentation files (the
|
|
|
|
* "Software"), to deal in the Software without restriction, including
|
|
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
|
|
* distribute, sub license, and/or sell copies of the Software, and to
|
|
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
|
|
* the following conditions:
|
2017-11-10 17:58:28 +00:00
|
|
|
*
|
2007-05-24 10:41:34 +01:00
|
|
|
* The above copyright notice and this permission notice (including the
|
|
|
|
* next paragraph) shall be included in all copies or substantial portions
|
|
|
|
* of the Software.
|
2017-11-10 17:58:28 +00:00
|
|
|
*
|
2007-05-24 10:41:34 +01:00
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
|
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
|
s/Tungsten Graphics/VMware/
Tungsten Graphics Inc. was acquired by VMware Inc. in 2008. Leaving the
old copyright name is creating unnecessary confusion, hence this change.
This was the sed script I used:
$ cat tg2vmw.sed
# Run as:
#
# git reset --hard HEAD && find include scons src -type f -not -name 'sed*' -print0 | xargs -0 sed -i -f tg2vmw.sed
#
# Rename copyrights
s/Tungsten Gra\(ph\|hp\)ics,\? [iI]nc\.\?\(, Cedar Park\)\?\(, Austin\)\?\(, \(Texas\|TX\)\)\?\.\?/VMware, Inc./g
/Copyright/s/Tungsten Graphics\(,\? [iI]nc\.\)\?\(, Cedar Park\)\?\(, Austin\)\?\(, \(Texas\|TX\)\)\?\.\?/VMware, Inc./
s/TUNGSTEN GRAPHICS/VMWARE/g
# Rename emails
s/alanh@tungstengraphics.com/alanh@vmware.com/
s/jens@tungstengraphics.com/jowen@vmware.com/g
s/jrfonseca-at-tungstengraphics-dot-com/jfonseca-at-vmware-dot-com/
s/jrfonseca\?@tungstengraphics.com/jfonseca@vmware.com/g
s/keithw\?@tungstengraphics.com/keithw@vmware.com/g
s/michel@tungstengraphics.com/daenzer@vmware.com/g
s/thomas-at-tungstengraphics-dot-com/thellstom-at-vmware-dot-com/
s/zack@tungstengraphics.com/zackr@vmware.com/
# Remove dead links
s@Tungsten Graphics (http://www.tungstengraphics.com)@Tungsten Graphics@g
# C string src/gallium/state_trackers/vega/api_misc.c
s/"Tungsten Graphics, Inc"/"VMware, Inc"/
Reviewed-by: Brian Paul <brianp@vmware.com>
2014-01-17 16:27:50 +00:00
|
|
|
* IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
|
2007-05-24 10:41:34 +01:00
|
|
|
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
|
|
|
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
|
|
|
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
2017-11-10 17:58:28 +00:00
|
|
|
*
|
2007-05-24 10:41:34 +01:00
|
|
|
**************************************************************************/
|
|
|
|
|
2007-08-17 15:27:18 +01:00
|
|
|
#include "main/imports.h"
|
2011-12-03 17:04:18 +00:00
|
|
|
#include "main/accum.h"
|
2012-11-16 18:30:19 +00:00
|
|
|
#include "main/api_exec.h"
|
2007-11-01 23:46:04 +00:00
|
|
|
#include "main/context.h"
|
2017-02-05 00:20:51 +00:00
|
|
|
#include "main/glthread.h"
|
2011-04-10 19:48:28 +01:00
|
|
|
#include "main/samplerobj.h"
|
2010-06-11 03:23:03 +01:00
|
|
|
#include "main/shaderobj.h"
|
2012-11-16 18:30:19 +00:00
|
|
|
#include "main/version.h"
|
|
|
|
#include "main/vtxfmt.h"
|
2014-03-23 16:01:38 +00:00
|
|
|
#include "main/hash.h"
|
2010-08-05 05:17:13 +01:00
|
|
|
#include "program/prog_cache.h"
|
2007-08-17 15:27:18 +01:00
|
|
|
#include "vbo/vbo.h"
|
2008-06-17 21:27:36 +01:00
|
|
|
#include "glapi/glapi.h"
|
2017-07-11 07:06:11 +01:00
|
|
|
#include "st_manager.h"
|
2010-02-07 11:20:52 +00:00
|
|
|
#include "st_context.h"
|
2009-10-05 15:50:11 +01:00
|
|
|
#include "st_debug.h"
|
2008-03-20 20:50:17 +00:00
|
|
|
#include "st_cb_bitmap.h"
|
2008-03-18 23:16:23 +00:00
|
|
|
#include "st_cb_blit.h"
|
2008-03-20 20:50:17 +00:00
|
|
|
#include "st_cb_bufferobjects.h"
|
2007-08-02 17:29:50 +01:00
|
|
|
#include "st_cb_clear.h"
|
2016-01-03 14:41:48 +00:00
|
|
|
#include "st_cb_compute.h"
|
2009-12-31 21:47:21 +00:00
|
|
|
#include "st_cb_condrender.h"
|
2015-08-24 01:55:20 +01:00
|
|
|
#include "st_cb_copyimage.h"
|
2007-08-02 21:21:16 +01:00
|
|
|
#include "st_cb_drawpixels.h"
|
2008-06-20 15:09:59 +01:00
|
|
|
#include "st_cb_rasterpos.h"
|
2008-08-13 01:02:44 +01:00
|
|
|
#include "st_cb_drawtex.h"
|
2010-02-25 15:10:47 +00:00
|
|
|
#include "st_cb_eglimage.h"
|
2007-08-09 19:27:44 +01:00
|
|
|
#include "st_cb_fbo.h"
|
2007-09-17 21:24:11 +01:00
|
|
|
#include "st_cb_feedback.h"
|
2017-07-12 23:45:10 +01:00
|
|
|
#include "st_cb_memoryobjects.h"
|
2013-03-03 20:14:18 +00:00
|
|
|
#include "st_cb_msaa.h"
|
2014-07-04 12:02:06 +01:00
|
|
|
#include "st_cb_perfmon.h"
|
2008-03-24 17:55:29 +00:00
|
|
|
#include "st_cb_program.h"
|
2007-08-11 19:57:37 +01:00
|
|
|
#include "st_cb_queryobj.h"
|
2007-08-10 18:37:21 +01:00
|
|
|
#include "st_cb_readpixels.h"
|
2017-10-17 01:09:46 +01:00
|
|
|
#include "st_cb_semaphoreobjects.h"
|
2007-08-06 22:49:11 +01:00
|
|
|
#include "st_cb_texture.h"
|
2010-05-11 04:11:21 +01:00
|
|
|
#include "st_cb_xformfb.h"
|
2007-08-10 12:57:14 +01:00
|
|
|
#include "st_cb_flush.h"
|
2011-03-05 19:32:28 +00:00
|
|
|
#include "st_cb_syncobj.h"
|
2007-08-10 16:42:26 +01:00
|
|
|
#include "st_cb_strings.h"
|
2011-03-08 10:32:35 +00:00
|
|
|
#include "st_cb_texturebarrier.h"
|
2010-05-21 20:37:23 +01:00
|
|
|
#include "st_cb_viewport.h"
|
2007-05-24 10:41:34 +01:00
|
|
|
#include "st_atom.h"
|
|
|
|
#include "st_draw.h"
|
2007-11-06 01:04:30 +00:00
|
|
|
#include "st_extensions.h"
|
2008-02-08 21:54:18 +00:00
|
|
|
#include "st_gen_mipmap.h"
|
2016-04-26 03:35:10 +01:00
|
|
|
#include "st_pbo.h"
|
2007-05-24 10:41:34 +01:00
|
|
|
#include "st_program.h"
|
2016-10-03 16:57:50 +01:00
|
|
|
#include "st_sampler_view.h"
|
2017-11-27 06:01:01 +00:00
|
|
|
#include "st_shader_cache.h"
|
2013-05-15 14:10:11 +01:00
|
|
|
#include "st_vdpau.h"
|
2014-03-23 16:01:38 +00:00
|
|
|
#include "st_texture.h"
|
2019-03-07 16:21:53 +00:00
|
|
|
#include "st_util.h"
|
2007-06-14 18:23:43 +01:00
|
|
|
#include "pipe/p_context.h"
|
2018-09-06 04:10:57 +01:00
|
|
|
#include "util/u_cpu_detect.h"
|
2010-02-02 14:42:17 +00:00
|
|
|
#include "util/u_inlines.h"
|
2012-04-13 18:27:45 +01:00
|
|
|
#include "util/u_upload_mgr.h"
|
2017-02-10 00:12:22 +00:00
|
|
|
#include "util/u_vbuf.h"
|
2008-03-12 00:54:31 +00:00
|
|
|
#include "cso_cache/cso_context.h"
|
2007-05-24 10:41:34 +01:00
|
|
|
|
2007-08-10 18:37:21 +01:00
|
|
|
|
2010-08-06 22:09:51 +01:00
|
|
|
DEBUG_GET_ONCE_BOOL_OPTION(mesa_mvp_dp4, "MESA_MVP_DP4", FALSE)
|
2010-08-06 01:13:41 +01:00
|
|
|
|
|
|
|
|
2016-01-04 22:31:05 +00:00
|
|
|
/**
|
|
|
|
* Called via ctx->Driver.Enable()
|
|
|
|
*/
|
2017-11-10 17:58:28 +00:00
|
|
|
static void
|
|
|
|
st_Enable(struct gl_context *ctx, GLenum cap, GLboolean state)
|
2016-01-04 22:31:05 +00:00
|
|
|
{
|
|
|
|
struct st_context *st = st_context(ctx);
|
|
|
|
|
|
|
|
switch (cap) {
|
|
|
|
case GL_DEBUG_OUTPUT:
|
2016-07-07 08:25:31 +01:00
|
|
|
case GL_DEBUG_OUTPUT_SYNCHRONOUS:
|
|
|
|
st_update_debug_callback(st);
|
2016-01-04 22:31:05 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-02-02 00:27:55 +00:00
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-03-07 16:21:53 +00:00
|
|
|
static uint64_t
|
2016-08-02 15:59:41 +01:00
|
|
|
st_get_active_states(struct gl_context *ctx)
|
|
|
|
{
|
|
|
|
struct st_vertex_program *vp =
|
|
|
|
st_vertex_program(ctx->VertexProgram._Current);
|
2017-04-30 15:05:42 +01:00
|
|
|
struct st_common_program *tcp =
|
|
|
|
st_common_program(ctx->TessCtrlProgram._Current);
|
|
|
|
struct st_common_program *tep =
|
|
|
|
st_common_program(ctx->TessEvalProgram._Current);
|
|
|
|
struct st_common_program *gp =
|
|
|
|
st_common_program(ctx->GeometryProgram._Current);
|
2016-08-02 15:59:41 +01:00
|
|
|
struct st_fragment_program *fp =
|
|
|
|
st_fragment_program(ctx->FragmentProgram._Current);
|
|
|
|
struct st_compute_program *cp =
|
|
|
|
st_compute_program(ctx->ComputeProgram._Current);
|
|
|
|
uint64_t active_shader_states = 0;
|
|
|
|
|
|
|
|
if (vp)
|
|
|
|
active_shader_states |= vp->affected_states;
|
|
|
|
if (tcp)
|
|
|
|
active_shader_states |= tcp->affected_states;
|
|
|
|
if (tep)
|
|
|
|
active_shader_states |= tep->affected_states;
|
|
|
|
if (gp)
|
|
|
|
active_shader_states |= gp->affected_states;
|
|
|
|
if (fp)
|
|
|
|
active_shader_states |= fp->affected_states;
|
|
|
|
if (cp)
|
|
|
|
active_shader_states |= cp->affected_states;
|
|
|
|
|
|
|
|
/* Mark non-shader-resource shader states as "always active". */
|
|
|
|
return active_shader_states | ~ST_ALL_SHADER_RESOURCES;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-06-07 03:14:54 +01:00
|
|
|
void
|
|
|
|
st_invalidate_buffers(struct st_context *st)
|
|
|
|
{
|
|
|
|
st->dirty |= ST_NEW_BLEND |
|
|
|
|
ST_NEW_DSA |
|
|
|
|
ST_NEW_FB_STATE |
|
2018-06-15 02:56:28 +01:00
|
|
|
ST_NEW_SAMPLE_STATE |
|
2017-06-07 03:14:54 +01:00
|
|
|
ST_NEW_SAMPLE_SHADING |
|
|
|
|
ST_NEW_FS_STATE |
|
|
|
|
ST_NEW_POLY_STIPPLE |
|
|
|
|
ST_NEW_VIEWPORT |
|
|
|
|
ST_NEW_RASTERIZER |
|
|
|
|
ST_NEW_SCISSOR |
|
|
|
|
ST_NEW_WINDOW_RECTANGLES;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-03-07 16:21:53 +00:00
|
|
|
static inline bool
|
|
|
|
st_vp_uses_current_values(const struct gl_context *ctx)
|
|
|
|
{
|
|
|
|
const uint64_t inputs = ctx->VertexProgram._Current->info.inputs_read;
|
|
|
|
return _mesa_draw_current_bits(ctx) & inputs;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-10-31 17:08:07 +00:00
|
|
|
/**
|
|
|
|
* Called via ctx->Driver.UpdateState()
|
|
|
|
*/
|
2017-06-07 03:14:54 +01:00
|
|
|
static void
|
2017-11-10 17:58:28 +00:00
|
|
|
st_invalidate_state(struct gl_context *ctx)
|
2007-05-24 10:41:34 +01:00
|
|
|
{
|
2017-06-07 03:19:13 +01:00
|
|
|
GLbitfield new_state = ctx->NewState;
|
2007-05-24 10:41:34 +01:00
|
|
|
struct st_context *st = st_context(ctx);
|
|
|
|
|
2016-07-17 17:38:38 +01:00
|
|
|
if (new_state & _NEW_BUFFERS) {
|
2017-06-07 03:14:54 +01:00
|
|
|
st_invalidate_buffers(st);
|
2016-07-17 17:38:38 +01:00
|
|
|
} else {
|
|
|
|
/* These set a subset of flags set by _NEW_BUFFERS, so we only have to
|
|
|
|
* check them when _NEW_BUFFERS isn't set.
|
|
|
|
*/
|
|
|
|
if (new_state & _NEW_PROGRAM)
|
2016-07-17 19:59:42 +01:00
|
|
|
st->dirty |= ST_NEW_RASTERIZER;
|
2016-07-17 17:38:38 +01:00
|
|
|
|
|
|
|
if (new_state & _NEW_FOG)
|
|
|
|
st->dirty |= ST_NEW_FS_STATE;
|
|
|
|
|
|
|
|
if (new_state & _NEW_FRAG_CLAMP) {
|
|
|
|
if (st->clamp_frag_color_in_shader)
|
|
|
|
st->dirty |= ST_NEW_FS_STATE;
|
|
|
|
else
|
|
|
|
st->dirty |= ST_NEW_RASTERIZER;
|
|
|
|
}
|
2012-01-23 02:11:17 +00:00
|
|
|
}
|
|
|
|
|
2017-06-10 01:14:15 +01:00
|
|
|
if (new_state & (_NEW_LIGHT |
|
2017-06-10 11:18:34 +01:00
|
|
|
_NEW_POINT))
|
2017-06-10 01:14:15 +01:00
|
|
|
st->dirty |= ST_NEW_RASTERIZER;
|
2012-01-23 02:11:17 +00:00
|
|
|
|
2017-06-10 11:09:43 +01:00
|
|
|
if (new_state & _NEW_PROJECTION &&
|
2016-08-02 14:17:27 +01:00
|
|
|
st_user_clip_planes_enabled(ctx))
|
2016-07-17 17:38:38 +01:00
|
|
|
st->dirty |= ST_NEW_CLIP_STATE;
|
|
|
|
|
|
|
|
if (new_state & _NEW_PIXEL)
|
|
|
|
st->dirty |= ST_NEW_PIXEL_TRANSFER;
|
|
|
|
|
2018-12-22 15:49:16 +00:00
|
|
|
if (new_state & _NEW_CURRENT_ATTRIB && st_vp_uses_current_values(ctx))
|
2016-07-17 17:38:38 +01:00
|
|
|
st->dirty |= ST_NEW_VERTEX_ARRAYS;
|
|
|
|
|
|
|
|
/* Update the vertex shader if ctx->Light._ClampVertexColor was changed. */
|
|
|
|
if (st->clamp_vert_color_in_shader && (new_state & _NEW_LIGHT))
|
|
|
|
st->dirty |= ST_NEW_VS_STATE;
|
2007-10-31 17:08:07 +00:00
|
|
|
|
2016-07-17 19:37:58 +01:00
|
|
|
/* Which shaders are dirty will be determined manually. */
|
|
|
|
if (new_state & _NEW_PROGRAM) {
|
|
|
|
st->gfx_shaders_may_be_dirty = true;
|
|
|
|
st->compute_shader_may_be_dirty = true;
|
2016-08-02 15:59:41 +01:00
|
|
|
/* This will mask out unused shader resources. */
|
|
|
|
st->active_states = st_get_active_states(ctx);
|
2016-07-17 19:37:58 +01:00
|
|
|
}
|
|
|
|
|
2017-03-23 21:42:56 +00:00
|
|
|
if (new_state & _NEW_TEXTURE_OBJECT) {
|
2016-08-02 15:59:41 +01:00
|
|
|
st->dirty |= st->active_states &
|
|
|
|
(ST_NEW_SAMPLER_VIEWS |
|
|
|
|
ST_NEW_SAMPLERS |
|
|
|
|
ST_NEW_IMAGE_UNITS);
|
2016-08-31 22:44:01 +01:00
|
|
|
if (ctx->FragmentProgram._Current &&
|
2016-10-19 03:23:37 +01:00
|
|
|
ctx->FragmentProgram._Current->ExternalSamplersUsed) {
|
2016-08-31 22:44:01 +01:00
|
|
|
st->dirty |= ST_NEW_FS_STATE;
|
|
|
|
}
|
|
|
|
}
|
2007-05-24 10:41:34 +01:00
|
|
|
}
|
|
|
|
|
2014-09-09 16:56:47 +01:00
|
|
|
|
|
|
|
static void
|
2017-01-20 01:26:42 +00:00
|
|
|
st_destroy_context_priv(struct st_context *st, bool destroy_pipe)
|
2014-09-09 16:56:47 +01:00
|
|
|
{
|
2017-11-15 23:32:22 +00:00
|
|
|
uint i;
|
2014-09-09 16:56:47 +01:00
|
|
|
|
2017-11-10 17:58:28 +00:00
|
|
|
st_destroy_atoms(st);
|
|
|
|
st_destroy_draw(st);
|
2014-09-09 16:56:47 +01:00
|
|
|
st_destroy_clear(st);
|
|
|
|
st_destroy_bitmap(st);
|
|
|
|
st_destroy_drawpix(st);
|
|
|
|
st_destroy_drawtex(st);
|
2014-07-04 12:02:06 +01:00
|
|
|
st_destroy_perfmon(st);
|
2016-04-26 03:35:10 +01:00
|
|
|
st_destroy_pbo_helpers(st);
|
2017-05-12 13:15:29 +01:00
|
|
|
st_destroy_bound_texture_handles(st);
|
|
|
|
st_destroy_bound_image_handles(st);
|
2014-09-09 16:56:47 +01:00
|
|
|
|
2017-11-15 23:32:22 +00:00
|
|
|
for (i = 0; i < ARRAY_SIZE(st->state.frag_sampler_views); i++) {
|
|
|
|
pipe_sampler_view_release(st->pipe,
|
|
|
|
&st->state.frag_sampler_views[i]);
|
2014-09-09 16:56:47 +01:00
|
|
|
}
|
|
|
|
|
2016-06-08 12:22:52 +01:00
|
|
|
/* free glReadPixels cache data */
|
|
|
|
st_invalidate_readpix_cache(st);
|
2018-09-01 01:58:10 +01:00
|
|
|
util_throttle_deinit(st->pipe->screen, &st->throttle);
|
2016-06-08 12:22:52 +01:00
|
|
|
|
2014-12-07 13:21:41 +00:00
|
|
|
cso_destroy_context(st->cso_context);
|
2017-01-20 01:26:42 +00:00
|
|
|
|
|
|
|
if (st->pipe && destroy_pipe)
|
|
|
|
st->pipe->destroy(st->pipe);
|
|
|
|
|
2017-11-10 17:58:28 +00:00
|
|
|
free(st);
|
2014-09-09 16:56:47 +01:00
|
|
|
}
|
|
|
|
|
2017-11-10 17:54:11 +00:00
|
|
|
|
2017-11-10 17:58:28 +00:00
|
|
|
static void
|
|
|
|
st_init_driver_flags(struct st_context *st)
|
2017-11-10 17:54:11 +00:00
|
|
|
{
|
|
|
|
struct gl_driver_flags *f = &st->ctx->DriverFlags;
|
|
|
|
|
|
|
|
f->NewArray = ST_NEW_VERTEX_ARRAYS;
|
|
|
|
f->NewRasterizerDiscard = ST_NEW_RASTERIZER;
|
|
|
|
f->NewTileRasterOrder = ST_NEW_RASTERIZER;
|
|
|
|
f->NewUniformBuffer = ST_NEW_UNIFORM_BUFFER;
|
|
|
|
f->NewDefaultTessLevels = ST_NEW_TESS_STATE;
|
|
|
|
|
|
|
|
/* Shader resources */
|
|
|
|
f->NewTextureBuffer = ST_NEW_SAMPLER_VIEWS;
|
|
|
|
if (st->has_hw_atomics)
|
2017-11-03 02:23:01 +00:00
|
|
|
f->NewAtomicBuffer = ST_NEW_HW_ATOMICS | ST_NEW_CS_ATOMICS;
|
2017-11-10 17:54:11 +00:00
|
|
|
else
|
|
|
|
f->NewAtomicBuffer = ST_NEW_ATOMIC_BUFFER;
|
|
|
|
f->NewShaderStorageBuffer = ST_NEW_STORAGE_BUFFER;
|
|
|
|
f->NewImageUnits = ST_NEW_IMAGE_UNITS;
|
|
|
|
|
|
|
|
f->NewShaderConstants[MESA_SHADER_VERTEX] = ST_NEW_VS_CONSTANTS;
|
|
|
|
f->NewShaderConstants[MESA_SHADER_TESS_CTRL] = ST_NEW_TCS_CONSTANTS;
|
|
|
|
f->NewShaderConstants[MESA_SHADER_TESS_EVAL] = ST_NEW_TES_CONSTANTS;
|
|
|
|
f->NewShaderConstants[MESA_SHADER_GEOMETRY] = ST_NEW_GS_CONSTANTS;
|
|
|
|
f->NewShaderConstants[MESA_SHADER_FRAGMENT] = ST_NEW_FS_CONSTANTS;
|
|
|
|
f->NewShaderConstants[MESA_SHADER_COMPUTE] = ST_NEW_CS_CONSTANTS;
|
|
|
|
|
|
|
|
f->NewWindowRectangles = ST_NEW_WINDOW_RECTANGLES;
|
|
|
|
f->NewFramebufferSRGB = ST_NEW_FB_STATE;
|
|
|
|
f->NewScissorRect = ST_NEW_SCISSOR;
|
|
|
|
f->NewScissorTest = ST_NEW_SCISSOR | ST_NEW_RASTERIZER;
|
|
|
|
f->NewAlphaTest = ST_NEW_DSA;
|
|
|
|
f->NewBlend = ST_NEW_BLEND;
|
|
|
|
f->NewBlendColor = ST_NEW_BLEND_COLOR;
|
|
|
|
f->NewColorMask = ST_NEW_BLEND;
|
|
|
|
f->NewDepth = ST_NEW_DSA;
|
|
|
|
f->NewLogicOp = ST_NEW_BLEND;
|
|
|
|
f->NewStencil = ST_NEW_DSA;
|
|
|
|
f->NewMultisampleEnable = ST_NEW_BLEND | ST_NEW_RASTERIZER |
|
2018-06-15 02:56:28 +01:00
|
|
|
ST_NEW_SAMPLE_STATE | ST_NEW_SAMPLE_SHADING;
|
2017-11-10 17:54:11 +00:00
|
|
|
f->NewSampleAlphaToXEnable = ST_NEW_BLEND;
|
2018-06-15 02:56:28 +01:00
|
|
|
f->NewSampleMask = ST_NEW_SAMPLE_STATE;
|
|
|
|
f->NewSampleLocations = ST_NEW_SAMPLE_STATE;
|
2017-11-10 17:54:11 +00:00
|
|
|
f->NewSampleShading = ST_NEW_SAMPLE_SHADING;
|
|
|
|
|
|
|
|
/* This depends on what the gallium driver wants. */
|
|
|
|
if (st->force_persample_in_shader) {
|
|
|
|
f->NewMultisampleEnable |= ST_NEW_FS_STATE;
|
|
|
|
f->NewSampleShading |= ST_NEW_FS_STATE;
|
|
|
|
} else {
|
|
|
|
f->NewSampleShading |= ST_NEW_RASTERIZER;
|
|
|
|
}
|
|
|
|
|
|
|
|
f->NewClipControl = ST_NEW_VIEWPORT | ST_NEW_RASTERIZER;
|
|
|
|
f->NewClipPlane = ST_NEW_CLIP_STATE;
|
|
|
|
f->NewClipPlaneEnable = ST_NEW_RASTERIZER;
|
|
|
|
f->NewDepthClamp = ST_NEW_RASTERIZER;
|
|
|
|
f->NewLineState = ST_NEW_RASTERIZER;
|
|
|
|
f->NewPolygonState = ST_NEW_RASTERIZER;
|
|
|
|
f->NewPolygonStipple = ST_NEW_POLY_STIPPLE;
|
|
|
|
f->NewViewport = ST_NEW_VIEWPORT;
|
2018-04-27 15:43:00 +01:00
|
|
|
f->NewNvConservativeRasterization = ST_NEW_RASTERIZER;
|
|
|
|
f->NewNvConservativeRasterizationParams = ST_NEW_RASTERIZER;
|
2017-11-10 17:54:11 +00:00
|
|
|
}
|
|
|
|
|
2014-09-09 16:56:47 +01:00
|
|
|
|
2007-11-05 23:15:43 +00:00
|
|
|
static struct st_context *
|
2017-11-10 17:58:28 +00:00
|
|
|
st_create_context_priv(struct gl_context *ctx, struct pipe_context *pipe,
|
|
|
|
const struct st_config_options *options, bool no_error)
|
2007-05-24 10:41:34 +01:00
|
|
|
{
|
2012-04-24 16:04:18 +01:00
|
|
|
struct pipe_screen *screen = pipe->screen;
|
2008-03-12 00:54:31 +00:00
|
|
|
uint i;
|
2017-11-10 17:58:28 +00:00
|
|
|
struct st_context *st = ST_CALLOC_STRUCT( st_context);
|
|
|
|
|
2012-04-12 01:30:03 +01:00
|
|
|
st->options = *options;
|
|
|
|
|
2007-05-24 10:41:34 +01:00
|
|
|
ctx->st = st;
|
|
|
|
|
|
|
|
st->ctx = ctx;
|
2007-06-14 18:23:43 +01:00
|
|
|
st->pipe = pipe;
|
2007-05-24 10:41:34 +01:00
|
|
|
|
2007-10-31 17:35:50 +00:00
|
|
|
/* state tracker needs the VBO module */
|
|
|
|
_vbo_CreateContext(ctx);
|
|
|
|
|
2016-07-17 17:38:38 +01:00
|
|
|
st->dirty = ST_ALL_STATES_MASK;
|
2007-05-24 10:41:34 +01:00
|
|
|
|
2017-04-30 00:20:19 +01:00
|
|
|
st->can_bind_const_buffer_as_vertex =
|
|
|
|
screen->get_param(screen, PIPE_CAP_CAN_BIND_CONST_BUFFER_AS_VERTEX);
|
2012-04-24 19:16:50 +01:00
|
|
|
|
2017-10-20 17:55:48 +01:00
|
|
|
/* st/mesa always uploads zero-stride vertex attribs, and other user
|
|
|
|
* vertex buffers are only possible with a compatibility profile.
|
|
|
|
* So tell the u_vbuf module that user VBOs are not possible with the Core
|
|
|
|
* profile, so that u_vbuf is bypassed completely if there is nothing else
|
|
|
|
* to do.
|
2017-02-10 00:12:22 +00:00
|
|
|
*/
|
|
|
|
unsigned vbuf_flags =
|
|
|
|
ctx->API == API_OPENGL_CORE ? U_VBUF_FLAG_NO_USER_VBOS : 0;
|
|
|
|
st->cso_context = cso_create_context(pipe, vbuf_flags);
|
2007-09-14 09:08:58 +01:00
|
|
|
|
2017-11-10 17:58:28 +00:00
|
|
|
st_init_atoms(st);
|
2008-04-03 19:54:32 +01:00
|
|
|
st_init_clear(st);
|
2016-04-26 03:35:10 +01:00
|
|
|
st_init_pbo_helpers(st);
|
2007-08-03 03:40:19 +01:00
|
|
|
|
2013-10-17 16:28:17 +01:00
|
|
|
/* Choose texture target for glDrawPixels, glBitmap, renderbuffers */
|
|
|
|
if (pipe->screen->get_param(pipe->screen, PIPE_CAP_NPOT_TEXTURES))
|
2010-08-06 06:39:21 +01:00
|
|
|
st->internal_target = PIPE_TEXTURE_2D;
|
|
|
|
else
|
|
|
|
st->internal_target = PIPE_TEXTURE_RECT;
|
|
|
|
|
2016-02-16 17:22:31 +00:00
|
|
|
/* Setup vertex element info for 'struct st_util_vertex'.
|
2012-08-17 21:33:31 +01:00
|
|
|
*/
|
2016-02-16 17:22:31 +00:00
|
|
|
{
|
|
|
|
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;
|
2018-05-08 22:31:46 +01:00
|
|
|
st->util_velems[0].vertex_buffer_index = 0;
|
2016-02-16 17:22:31 +00:00
|
|
|
st->util_velems[0].src_format = PIPE_FORMAT_R32G32B32_FLOAT;
|
|
|
|
st->util_velems[1].src_offset = 3 * sizeof(float);
|
2018-05-08 22:31:46 +01:00
|
|
|
st->util_velems[1].vertex_buffer_index = 0;
|
2016-02-16 17:22:31 +00:00
|
|
|
st->util_velems[1].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
|
|
|
|
st->util_velems[2].src_offset = 7 * sizeof(float);
|
2018-05-08 22:31:46 +01:00
|
|
|
st->util_velems[2].vertex_buffer_index = 0;
|
2016-02-16 17:22:31 +00:00
|
|
|
st->util_velems[2].src_format = PIPE_FORMAT_R32G32_FLOAT;
|
2010-03-09 14:09:01 +00:00
|
|
|
}
|
|
|
|
|
2007-08-17 15:27:18 +01:00
|
|
|
/* we want all vertex data to be placed in buffer objects */
|
|
|
|
vbo_use_buffer_objects(ctx);
|
|
|
|
|
2011-10-26 00:41:12 +01:00
|
|
|
|
|
|
|
/* make sure that no VBOs are left mapped when we're drawing. */
|
|
|
|
vbo_always_unmap_buffers(ctx);
|
|
|
|
|
2007-08-06 20:53:28 +01:00
|
|
|
/* Need these flags:
|
|
|
|
*/
|
2016-02-16 17:22:32 +00:00
|
|
|
ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
|
2007-08-06 20:53:28 +01:00
|
|
|
|
2016-02-16 17:22:32 +00:00
|
|
|
ctx->VertexProgram._MaintainTnlProgram = GL_TRUE;
|
2007-08-17 00:33:49 +01:00
|
|
|
|
2017-06-29 03:39:22 +01:00
|
|
|
if (no_error)
|
|
|
|
ctx->Const.ContextFlags |= GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR;
|
|
|
|
|
2017-08-18 06:51:48 +01:00
|
|
|
ctx->Const.PackedDriverUniformStorage =
|
|
|
|
screen->get_param(screen, PIPE_CAP_PACKED_UNIFORMS);
|
|
|
|
|
2012-07-09 04:08:36 +01:00
|
|
|
st->has_stencil_export =
|
|
|
|
screen->get_param(screen, PIPE_CAP_SHADER_STENCIL_EXPORT);
|
2013-01-31 21:30:44 +00:00
|
|
|
st->has_shader_model3 = screen->get_param(screen, PIPE_CAP_SM3);
|
2014-08-02 20:38:25 +01:00
|
|
|
st->has_etc1 = screen->is_format_supported(screen, PIPE_FORMAT_ETC1_RGB8,
|
2018-05-23 23:46:19 +01:00
|
|
|
PIPE_TEXTURE_2D, 0, 0,
|
2014-08-02 20:38:25 +01:00
|
|
|
PIPE_BIND_SAMPLER_VIEW);
|
2015-02-16 07:27:37 +00:00
|
|
|
st->has_etc2 = screen->is_format_supported(screen, PIPE_FORMAT_ETC2_RGB8,
|
2018-05-23 23:46:19 +01:00
|
|
|
PIPE_TEXTURE_2D, 0, 0,
|
2015-02-16 07:27:37 +00:00
|
|
|
PIPE_BIND_SAMPLER_VIEW);
|
2018-02-13 03:25:29 +00:00
|
|
|
st->has_astc_2d_ldr =
|
|
|
|
screen->is_format_supported(screen, PIPE_FORMAT_ASTC_4x4_SRGB,
|
2018-05-23 23:46:19 +01:00
|
|
|
PIPE_TEXTURE_2D, 0, 0, PIPE_BIND_SAMPLER_VIEW);
|
2013-03-14 16:18:43 +00:00
|
|
|
st->prefer_blit_based_texture_transfer = screen->get_param(screen,
|
|
|
|
PIPE_CAP_PREFER_BLIT_BASED_TEXTURE_TRANSFER);
|
2015-10-19 23:12:53 +01:00
|
|
|
st->force_persample_in_shader =
|
|
|
|
screen->get_param(screen, PIPE_CAP_SAMPLE_SHADING) &&
|
|
|
|
!screen->get_param(screen, PIPE_CAP_FORCE_PERSAMPLE_INTERP);
|
2015-09-27 22:36:59 +01:00
|
|
|
st->has_shareable_shaders = screen->get_param(screen,
|
|
|
|
PIPE_CAP_SHAREABLE_SHADERS);
|
2013-03-15 21:11:31 +00:00
|
|
|
st->needs_texcoord_semantic =
|
|
|
|
screen->get_param(screen, PIPE_CAP_TGSI_TEXCOORD);
|
2013-04-12 12:42:01 +01:00
|
|
|
st->apply_texture_swizzle_to_border_color =
|
|
|
|
!!(screen->get_param(screen, PIPE_CAP_TEXTURE_BORDER_COLOR_QUIRK) &
|
|
|
|
(PIPE_QUIRK_TEXTURE_BORDER_COLOR_SWIZZLE_NV50 |
|
|
|
|
PIPE_QUIRK_TEXTURE_BORDER_COLOR_SWIZZLE_R600));
|
2014-08-03 03:20:31 +01:00
|
|
|
st->has_time_elapsed =
|
|
|
|
screen->get_param(screen, PIPE_CAP_QUERY_TIME_ELAPSED);
|
2015-10-29 06:52:57 +00:00
|
|
|
st->has_half_float_packing =
|
|
|
|
screen->get_param(screen, PIPE_CAP_TGSI_PACK_HALF_FLOAT);
|
2015-12-31 19:11:07 +00:00
|
|
|
st->has_multi_draw_indirect =
|
|
|
|
screen->get_param(screen, PIPE_CAP_MULTI_DRAW_INDIRECT);
|
gallium: Add the ability to query a single pipeline statistics counter
Gallium historically has treated pipeline statistics queries as a single
query, PIPE_QUERY_PIPELINE_STATISTICS, which returns a block of 11
values. This was originally patterned after the D3D1x API. Much later,
Brian introduced an OpenGL extension that exposed these counters - but
it exposes 11 separate queries, each of which returns a single value.
Today, st/mesa simply queries all 11 values, and returns a single value.
While pipeline statistics counters aren't typically performance
critical, this is still not a great fit. A D3D1x->GL translator might
request all 11 counters by creating 11 separate GL queries...which
Gallium would map to reads of all 11 values each time, resulting in a
total 121 counter reads. That's not ideal.
This patch adds a new cap, PIPE_CAP_QUERY_PIPELINE_STATISTICS_SINGLE,
and corresponding query type PIPE_QUERY_PIPELINE_STATISTICS_SINGLE.
When calling create_query(), q->index should be set to one of the
PIPE_STAT_QUERY_* enums to select a counter. Unlike the block query,
this returns the value in pipe_query_result::u64 (as it's a single
value) instead of the pipe_query_data_pipeline_statistics group.
We update st/mesa to expose ARB_pipeline_statistics_query if either
capability is set, preferring the new SINGLE variant when available.
Thanks to Roland, Ilia, and Marek for helping me sort this out.
Reviewed-by: Marek Olšák <marek.olsak@amd.com>
Reviewed-by: Tapani Pälli <tapani.palli@intel.com>
2018-09-28 10:21:47 +01:00
|
|
|
st->has_single_pipe_stat =
|
|
|
|
screen->get_param(screen, PIPE_CAP_QUERY_PIPELINE_STATISTICS_SINGLE);
|
st/mesa: Optionally override RGB/RGBX dst alpha blend factors
Intel's blending hardware does not properly return 1.0 for destination
alpha for RGBX formats; it requires the factors to be overridden to
either zero or one. Broadcom vc4 and v3d also could use this override.
While overriding these factors is safe in general, Nouveau and Radeon
would prefer not to. Their blending hardware already returns correct
values for RGB/RGBX formats, and would like to avoid the resulting
per-buffer blending and independent blend factors (rgb != a) since it
can cause additional overhead.
I considered simply handling this in the driver, but it's not as nice.
pipe_blend_state doesn't have any format information, so we'd need the
hardware blend state to depend on both pipe_blend_state and
pipe_framebuffer_state. Furthermore, Intel GPUs don't have a native
RGBX_SNORM format, so I avoid exposing one, which makes Gallium fall
back to RGBA_SNORM. The pipe_surfaces we get in the driver have an RGBA
format, making it impossible to tell that there shouldn't be an alpha
channel. One could argue that st not handling it in that case is a bug.
To work around this, we'd have to expose RGBX pipe formats, mapped to
RGBA hardware formats, and add format swizzling special cases. All
doable, but it ends up being more code than I'd like.
st_atom_blend already has access to the right information and it's
trivial to accomplish there, so we just add a cap bit and do that.
Reviewed-by: Marek Olšák <marek.olsak@amd.com>
Reviewed-by: Eric Anholt <eric@anholt.net>
2018-07-22 07:40:16 +01:00
|
|
|
st->has_indep_blend_func =
|
|
|
|
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);
|
2013-03-15 21:11:31 +00:00
|
|
|
|
2017-11-01 04:30:13 +00:00
|
|
|
st->has_hw_atomics =
|
|
|
|
screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
|
2017-11-10 17:58:28 +00:00
|
|
|
PIPE_SHADER_CAP_MAX_HW_ATOMIC_COUNTERS)
|
|
|
|
? true : false;
|
2017-11-01 04:30:13 +00:00
|
|
|
|
2018-09-01 01:58:10 +01:00
|
|
|
util_throttle_init(&st->throttle,
|
|
|
|
screen->get_param(screen,
|
|
|
|
PIPE_CAP_MAX_TEXTURE_UPLOAD_MEMORY_BUDGET));
|
|
|
|
|
2007-11-06 01:04:30 +00:00
|
|
|
/* GL limits and extensions */
|
2018-02-23 19:42:41 +00:00
|
|
|
st_init_limits(pipe->screen, &ctx->Const, &ctx->Extensions, ctx->API);
|
2016-08-12 19:37:02 +01:00
|
|
|
st_init_extensions(pipe->screen, &ctx->Const,
|
2017-10-19 21:22:15 +01:00
|
|
|
&ctx->Extensions, &st->options, ctx->API);
|
2014-08-03 03:20:31 +01:00
|
|
|
|
2015-11-25 11:19:03 +00:00
|
|
|
if (st_have_perfmon(st)) {
|
2014-07-04 12:02:06 +01:00
|
|
|
ctx->Extensions.AMD_performance_monitor = GL_TRUE;
|
|
|
|
}
|
|
|
|
|
2014-08-03 03:20:31 +01:00
|
|
|
/* Enable shader-based fallbacks for ARB_color_buffer_float if needed. */
|
|
|
|
if (screen->get_param(screen, PIPE_CAP_VERTEX_COLOR_UNCLAMPED)) {
|
|
|
|
if (!screen->get_param(screen, PIPE_CAP_VERTEX_COLOR_CLAMPED)) {
|
|
|
|
st->clamp_vert_color_in_shader = GL_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!screen->get_param(screen, PIPE_CAP_FRAGMENT_COLOR_CLAMPED)) {
|
|
|
|
st->clamp_frag_color_in_shader = GL_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* For drivers which cannot do color clamping, it's better to just
|
|
|
|
* disable ARB_color_buffer_float in the core profile, because
|
|
|
|
* the clamping is deprecated there anyway. */
|
|
|
|
if (ctx->API == API_OPENGL_CORE &&
|
|
|
|
(st->clamp_frag_color_in_shader || st->clamp_vert_color_in_shader)) {
|
|
|
|
st->clamp_vert_color_in_shader = GL_FALSE;
|
|
|
|
st->clamp_frag_color_in_shader = GL_FALSE;
|
|
|
|
ctx->Extensions.ARB_color_buffer_float = GL_FALSE;
|
|
|
|
}
|
|
|
|
}
|
2007-08-22 03:15:00 +01:00
|
|
|
|
2014-08-03 03:36:19 +01:00
|
|
|
/* called after _mesa_create_context/_mesa_init_point, fix default user
|
|
|
|
* settable max point size up
|
|
|
|
*/
|
2016-02-16 17:22:32 +00:00
|
|
|
ctx->Point.MaxSize = MAX2(ctx->Const.MaxPointSize,
|
|
|
|
ctx->Const.MaxPointSizeAA);
|
2017-11-10 17:58:28 +00:00
|
|
|
/* 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;
|
2014-08-03 03:36:19 +01:00
|
|
|
|
2015-06-29 07:48:52 +01:00
|
|
|
if (!ctx->Extensions.ARB_gpu_shader5) {
|
|
|
|
for (i = 0; i < MESA_SHADER_STAGES; i++)
|
|
|
|
ctx->Const.ShaderCompilerOptions[i].EmitNoIndirectSampler = true;
|
|
|
|
}
|
|
|
|
|
2015-09-27 23:04:39 +01:00
|
|
|
/* 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;
|
2016-06-07 22:03:38 +01:00
|
|
|
st->shader_has_one_variant[MESA_SHADER_COMPUTE] = st->has_shareable_shaders;
|
2015-09-27 23:04:39 +01:00
|
|
|
|
2017-04-09 15:45:00 +01:00
|
|
|
st->bitmap.cache.empty = true;
|
|
|
|
|
2017-11-06 15:20:35 +00:00
|
|
|
_mesa_override_extensions(ctx);
|
2012-11-16 18:30:19 +00:00
|
|
|
_mesa_compute_version(ctx);
|
|
|
|
|
2014-09-09 16:56:47 +01:00
|
|
|
if (ctx->Version == 0) {
|
|
|
|
/* This can happen when a core profile was requested, but the driver
|
|
|
|
* does not support some features of GL 3.1 or later.
|
|
|
|
*/
|
2017-01-20 01:26:42 +00:00
|
|
|
st_destroy_context_priv(st, false);
|
2014-09-09 16:56:47 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-01-18 00:49:57 +00:00
|
|
|
_mesa_initialize_dispatch_tables(ctx);
|
2012-11-16 18:30:19 +00:00
|
|
|
_mesa_initialize_vbo_vtxfmt(ctx);
|
2017-06-04 22:09:44 +01:00
|
|
|
st_init_driver_flags(st);
|
2012-11-16 18:30:19 +00:00
|
|
|
|
2017-07-12 05:55:13 +01:00
|
|
|
/* Initialize context's winsys buffers list */
|
|
|
|
LIST_INITHEAD(&st->winsys_buffers);
|
|
|
|
|
2007-05-24 10:41:34 +01:00
|
|
|
return st;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-11-10 17:58:28 +00:00
|
|
|
struct st_context *
|
|
|
|
st_create_context(gl_api api, struct pipe_context *pipe,
|
|
|
|
const struct gl_config *visual,
|
|
|
|
struct st_context *share,
|
|
|
|
const struct st_config_options *options,
|
|
|
|
bool no_error)
|
2007-11-01 23:46:04 +00:00
|
|
|
{
|
2010-10-12 17:26:10 +01:00
|
|
|
struct gl_context *ctx;
|
|
|
|
struct gl_context *shareCtx = share ? share->ctx : NULL;
|
2007-11-05 23:15:43 +00:00
|
|
|
struct dd_function_table funcs;
|
2014-09-09 16:56:47 +01:00
|
|
|
struct st_context *st;
|
2007-11-05 23:15:43 +00:00
|
|
|
|
2018-09-06 04:10:57 +01:00
|
|
|
util_cpu_detect();
|
|
|
|
|
2007-11-05 23:15:43 +00:00
|
|
|
memset(&funcs, 0, sizeof(funcs));
|
2015-04-29 14:05:19 +01:00
|
|
|
st_init_driver_functions(pipe->screen, &funcs);
|
2007-11-05 23:15:43 +00:00
|
|
|
|
2016-06-07 17:33:48 +01:00
|
|
|
ctx = calloc(1, sizeof(struct gl_context));
|
|
|
|
if (!ctx)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (!_mesa_initialize_context(ctx, api, visual, shareCtx, &funcs)) {
|
|
|
|
free(ctx);
|
2011-07-11 15:42:15 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
2007-11-05 23:15:43 +00:00
|
|
|
|
2017-03-10 11:19:50 +00:00
|
|
|
st_debug_init();
|
|
|
|
|
|
|
|
if (pipe->screen->get_disk_shader_cache &&
|
|
|
|
!(ST_DEBUG & DEBUG_TGSI))
|
2017-02-20 22:00:49 +00:00
|
|
|
ctx->Cache = pipe->screen->get_disk_shader_cache(pipe->screen);
|
|
|
|
|
2009-05-05 12:12:28 +01:00
|
|
|
/* XXX: need a capability bit in gallium to query if the pipe
|
|
|
|
* driver prefers DP4 or MUL/MAD for vertex transformation.
|
|
|
|
*/
|
2010-08-06 01:13:41 +01:00
|
|
|
if (debug_get_option_mesa_mvp_dp4())
|
2014-08-03 03:31:56 +01:00
|
|
|
ctx->Const.ShaderCompilerOptions[MESA_SHADER_VERTEX].OptimizeForAOS = GL_TRUE;
|
2009-05-05 12:12:28 +01:00
|
|
|
|
2017-06-29 03:39:22 +01:00
|
|
|
st = st_create_context_priv(ctx, pipe, options, no_error);
|
2014-09-09 16:56:47 +01:00
|
|
|
if (!st) {
|
|
|
|
_mesa_destroy_context(ctx);
|
2008-05-16 23:04:30 +01:00
|
|
|
}
|
|
|
|
|
2014-09-09 16:56:47 +01:00
|
|
|
return st;
|
2007-05-24 10:41:34 +01:00
|
|
|
}
|
|
|
|
|
2014-03-23 16:01:38 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Callback to release the sampler view attached to a texture object.
|
|
|
|
* Called by _mesa_HashWalk().
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
destroy_tex_sampler_cb(GLuint id, void *data, void *userData)
|
|
|
|
{
|
|
|
|
struct gl_texture_object *texObj = (struct gl_texture_object *) data;
|
|
|
|
struct st_context *st = (struct st_context *) userData;
|
|
|
|
|
|
|
|
st_texture_release_sampler_view(st, st_texture_object(texObj));
|
|
|
|
}
|
2017-11-10 17:58:28 +00:00
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
st_destroy_context(struct st_context *st)
|
2007-11-05 23:15:43 +00:00
|
|
|
{
|
2010-10-12 17:26:10 +01:00
|
|
|
struct gl_context *ctx = st->ctx;
|
2017-07-11 07:06:11 +01:00
|
|
|
struct st_framebuffer *stfb, *next;
|
|
|
|
|
|
|
|
GET_CURRENT_CONTEXT(curctx);
|
|
|
|
|
2017-11-10 17:58:28 +00:00
|
|
|
if (curctx == NULL) {
|
2017-07-11 07:06:11 +01:00
|
|
|
/* No current context, but we need one to release
|
|
|
|
* renderbuffer surface when we release framebuffer.
|
|
|
|
* So temporarily bind the context.
|
|
|
|
*/
|
|
|
|
_mesa_make_current(ctx, NULL, NULL);
|
|
|
|
}
|
2008-04-17 18:12:44 +01:00
|
|
|
|
2017-03-16 12:09:19 +00:00
|
|
|
/* This must be called first so that glthread has a chance to finish */
|
|
|
|
_mesa_glthread_destroy(ctx);
|
|
|
|
|
2014-03-23 16:01:38 +00:00
|
|
|
_mesa_HashWalk(ctx->Shared->TexObjects, destroy_tex_sampler_cb, st);
|
|
|
|
|
2008-05-20 21:38:22 +01:00
|
|
|
st_reference_fragprog(st, &st->fp, NULL);
|
2017-04-30 15:05:42 +01:00
|
|
|
st_reference_prog(st, &st->gp, NULL);
|
2008-05-20 21:38:22 +01:00
|
|
|
st_reference_vertprog(st, &st->vp, NULL);
|
2017-04-30 15:05:42 +01:00
|
|
|
st_reference_prog(st, &st->tcp, NULL);
|
|
|
|
st_reference_prog(st, &st->tep, NULL);
|
2016-01-07 21:02:43 +00:00
|
|
|
st_reference_compprog(st, &st->cp, NULL);
|
2008-05-20 21:38:22 +01:00
|
|
|
|
2017-07-11 07:06:11 +01:00
|
|
|
/* release framebuffer in the winsys buffers list */
|
|
|
|
LIST_FOR_EACH_ENTRY_SAFE_REV(stfb, next, &st->winsys_buffers, head) {
|
|
|
|
st_framebuffer_reference(&stfb, NULL);
|
|
|
|
}
|
|
|
|
|
2015-10-04 01:38:55 +01:00
|
|
|
pipe_sampler_view_reference(&st->pixel_xfer.pixelmap_sampler_view, NULL);
|
|
|
|
pipe_resource_reference(&st->pixel_xfer.pixelmap_texture, NULL);
|
2008-04-17 18:12:44 +01:00
|
|
|
|
2016-02-16 17:22:32 +00:00
|
|
|
_vbo_DestroyContext(ctx);
|
2008-09-16 15:51:28 +01:00
|
|
|
|
2010-12-14 00:20:12 +00:00
|
|
|
st_destroy_program_variants(st);
|
|
|
|
|
2007-11-05 23:15:43 +00:00
|
|
|
_mesa_free_context_data(ctx);
|
2008-04-24 19:11:24 +01:00
|
|
|
|
2012-04-25 11:41:13 +01:00
|
|
|
/* This will free the st_context too, so 'st' must not be accessed
|
|
|
|
* afterwards. */
|
2017-01-20 01:26:42 +00:00
|
|
|
st_destroy_context_priv(st, true);
|
2012-04-25 11:41:13 +01:00
|
|
|
st = NULL;
|
2008-04-24 19:11:24 +01:00
|
|
|
|
2010-02-19 16:58:49 +00:00
|
|
|
free(ctx);
|
2007-11-05 23:15:43 +00:00
|
|
|
}
|
|
|
|
|
2017-11-10 17:58:28 +00:00
|
|
|
|
2015-08-10 16:41:29 +01:00
|
|
|
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);
|
|
|
|
}
|
2007-11-05 23:15:43 +00:00
|
|
|
|
2017-11-10 17:58:28 +00:00
|
|
|
|
2017-02-05 00:20:51 +00:00
|
|
|
static void
|
2017-06-21 19:45:38 +01:00
|
|
|
st_set_background_context(struct gl_context *ctx,
|
|
|
|
struct util_queue_monitoring *queue_info)
|
2017-02-05 00:20:51 +00:00
|
|
|
{
|
|
|
|
struct st_context *st = ctx->st;
|
|
|
|
struct st_manager *smapi =
|
2017-11-10 17:58:28 +00:00
|
|
|
(struct st_manager *) st->iface.st_context_private;
|
2017-02-05 00:20:51 +00:00
|
|
|
|
|
|
|
assert(smapi->set_background_context);
|
2017-06-21 19:45:38 +01:00
|
|
|
smapi->set_background_context(&st->iface, queue_info);
|
2017-02-05 00:20:51 +00:00
|
|
|
}
|
|
|
|
|
2017-11-10 17:58:28 +00:00
|
|
|
|
2017-07-12 23:45:24 +01:00
|
|
|
static void
|
|
|
|
st_get_device_uuid(struct gl_context *ctx, char *uuid)
|
|
|
|
{
|
|
|
|
struct pipe_screen *screen = st_context(ctx)->pipe->screen;
|
|
|
|
|
|
|
|
assert(GL_UUID_SIZE_EXT >= PIPE_UUID_SIZE);
|
|
|
|
memset(uuid, 0, GL_UUID_SIZE_EXT);
|
|
|
|
screen->get_device_uuid(screen, uuid);
|
|
|
|
}
|
|
|
|
|
2017-11-10 17:58:28 +00:00
|
|
|
|
2017-07-12 23:45:24 +01:00
|
|
|
static void
|
|
|
|
st_get_driver_uuid(struct gl_context *ctx, char *uuid)
|
|
|
|
{
|
|
|
|
struct pipe_screen *screen = st_context(ctx)->pipe->screen;
|
|
|
|
|
|
|
|
assert(GL_UUID_SIZE_EXT >= PIPE_UUID_SIZE);
|
|
|
|
memset(uuid, 0, GL_UUID_SIZE_EXT);
|
|
|
|
screen->get_driver_uuid(screen, uuid);
|
|
|
|
}
|
|
|
|
|
2017-11-10 17:58:28 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
st_init_driver_functions(struct pipe_screen *screen,
|
|
|
|
struct dd_function_table *functions)
|
2007-08-06 20:53:28 +01:00
|
|
|
{
|
2011-04-10 19:48:28 +01:00
|
|
|
_mesa_init_sampler_object_functions(functions);
|
2007-11-07 15:18:50 +00:00
|
|
|
|
2018-03-25 18:16:54 +01:00
|
|
|
st_init_draw_functions(functions);
|
2008-03-18 23:16:23 +00:00
|
|
|
st_init_blit_functions(functions);
|
2016-01-09 23:05:58 +00:00
|
|
|
st_init_bufferobject_functions(screen, functions);
|
2007-08-06 20:53:28 +01:00
|
|
|
st_init_clear_functions(functions);
|
2008-06-17 20:13:34 +01:00
|
|
|
st_init_bitmap_functions(functions);
|
2015-08-24 01:55:20 +01:00
|
|
|
st_init_copy_image_functions(functions);
|
2007-08-06 20:53:28 +01:00
|
|
|
st_init_drawpixels_functions(functions);
|
2008-06-17 20:13:34 +01:00
|
|
|
st_init_rasterpos_functions(functions);
|
2009-09-22 08:00:24 +01:00
|
|
|
|
|
|
|
st_init_drawtex_functions(functions);
|
|
|
|
|
2010-02-25 15:10:47 +00:00
|
|
|
st_init_eglimage_functions(functions);
|
|
|
|
|
2007-08-09 19:27:44 +01:00
|
|
|
st_init_fbo_functions(functions);
|
2007-09-17 21:24:11 +01:00
|
|
|
st_init_feedback_functions(functions);
|
2017-07-12 23:45:10 +01:00
|
|
|
st_init_memoryobject_functions(functions);
|
2013-03-03 20:14:18 +00:00
|
|
|
st_init_msaa_functions(functions);
|
2014-07-04 12:02:06 +01:00
|
|
|
st_init_perfmon_functions(functions);
|
2007-08-06 20:53:28 +01:00
|
|
|
st_init_program_functions(functions);
|
2007-08-11 19:57:37 +01:00
|
|
|
st_init_query_functions(functions);
|
2009-12-31 21:47:21 +00:00
|
|
|
st_init_cond_render_functions(functions);
|
2007-08-10 18:37:21 +01:00
|
|
|
st_init_readpixels_functions(functions);
|
2017-10-17 01:09:46 +01:00
|
|
|
st_init_semaphoreobject_functions(functions);
|
2007-08-06 20:53:28 +01:00
|
|
|
st_init_texture_functions(functions);
|
2011-03-08 10:32:35 +00:00
|
|
|
st_init_texture_barrier_functions(functions);
|
2015-04-29 14:05:19 +01:00
|
|
|
st_init_flush_functions(screen, functions);
|
2007-08-10 16:42:26 +01:00
|
|
|
st_init_string_functions(functions);
|
2010-05-21 20:37:23 +01:00
|
|
|
st_init_viewport_functions(functions);
|
2016-01-03 14:41:48 +00:00
|
|
|
st_init_compute_functions(functions);
|
2007-10-31 17:08:07 +00:00
|
|
|
|
2010-05-11 04:11:21 +01:00
|
|
|
st_init_xformfb_functions(functions);
|
2011-03-05 19:32:28 +00:00
|
|
|
st_init_syncobj_functions(functions);
|
2010-05-11 04:11:21 +01:00
|
|
|
|
2013-05-15 14:10:11 +01:00
|
|
|
st_init_vdpau_functions(functions);
|
|
|
|
|
2015-08-10 16:41:29 +01:00
|
|
|
if (screen->get_param(screen, PIPE_CAP_STRING_MARKER))
|
|
|
|
functions->EmitStringMarker = st_emit_string_marker;
|
|
|
|
|
2016-01-04 22:31:05 +00:00
|
|
|
functions->Enable = st_Enable;
|
2007-10-31 17:08:07 +00:00
|
|
|
functions->UpdateState = st_invalidate_state;
|
2016-02-02 00:27:55 +00:00
|
|
|
functions->QueryMemoryInfo = st_query_memory_info;
|
2017-02-05 00:20:51 +00:00
|
|
|
functions->SetBackgroundContext = st_set_background_context;
|
2018-01-25 20:09:00 +00:00
|
|
|
functions->GetDriverUuid = st_get_driver_uuid;
|
|
|
|
functions->GetDeviceUuid = st_get_device_uuid;
|
2017-11-27 06:01:01 +00:00
|
|
|
|
|
|
|
/* GL_ARB_get_program_binary */
|
|
|
|
functions->GetProgramBinaryDriverSHA1 = st_get_program_binary_driver_sha1;
|
2018-02-13 03:25:51 +00:00
|
|
|
|
|
|
|
enum pipe_shader_ir preferred_ir = (enum pipe_shader_ir)
|
|
|
|
screen->get_shader_param(screen, PIPE_SHADER_VERTEX,
|
|
|
|
PIPE_SHADER_CAP_PREFERRED_IR);
|
|
|
|
if (preferred_ir == PIPE_SHADER_IR_NIR) {
|
2018-04-20 00:20:53 +01:00
|
|
|
functions->ShaderCacheSerializeDriverBlob = st_serialise_nir_program;
|
2018-03-01 02:29:54 +00:00
|
|
|
functions->ProgramBinarySerializeDriverBlob =
|
|
|
|
st_serialise_nir_program_binary;
|
2018-02-13 03:25:51 +00:00
|
|
|
functions->ProgramBinaryDeserializeDriverBlob =
|
|
|
|
st_deserialise_nir_program;
|
|
|
|
} else {
|
2018-04-20 00:20:53 +01:00
|
|
|
functions->ShaderCacheSerializeDriverBlob = st_serialise_tgsi_program;
|
2018-03-01 02:29:54 +00:00
|
|
|
functions->ProgramBinarySerializeDriverBlob =
|
|
|
|
st_serialise_tgsi_program_binary;
|
2018-02-13 03:25:51 +00:00
|
|
|
functions->ProgramBinaryDeserializeDriverBlob =
|
|
|
|
st_deserialise_tgsi_program;
|
|
|
|
}
|
2007-08-06 20:53:28 +01:00
|
|
|
}
|