#include "glheader.h"
-#include "imports.h"
+
#include "accum.h"
#include "api_exec.h"
#include "api_loopback.h"
#include "blend.h"
#include "buffers.h"
#include "bufferobj.h"
+#include "conservativeraster.h"
#include "context.h"
#include "cpuinfo.h"
#include "debug.h"
#include "shared.h"
#include "shaderobj.h"
#include "shaderimage.h"
+#include "state.h"
#include "util/debug.h"
#include "util/disk_cache.h"
#include "util/strtod.h"
#include "stencil.h"
+#include "shaderimage.h"
#include "texcompress_s3tc.h"
#include "texstate.h"
#include "transformfeedback.h"
#endif
#include "compiler/glsl_types.h"
+#include "compiler/glsl/builtin_functions.h"
#include "compiler/glsl/glsl_parser_extras.h"
#include <stdbool.h>
+#include "util/u_memory.h"
#ifndef MESA_VERBOSE
{
if (MESA_VERBOSE & VERBOSE_SWAPBUFFERS)
_mesa_debug(ctx, "SwapBuffers\n");
- FLUSH_CURRENT( ctx, 0 );
+ FLUSH_VERTICES(ctx, 0);
if (ctx->Driver.Flush) {
ctx->Driver.Flush(ctx);
}
* \param stencilBits requested minimum bits per stencil buffer value
* \param accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits number
* of bits per color component in accum buffer.
- * \param indexBits number of bits per pixel if \p rgbFlag is GL_FALSE
* \param redBits number of bits per color component in frame buffer for RGB(A)
* mode. We always use 8 in core Mesa though.
* \param greenBits same as above.
assert(accumBlueBits >= 0);
assert(accumAlphaBits >= 0);
- vis->rgbMode = GL_TRUE;
vis->doubleBufferMode = dbFlag;
vis->stereoMode = stereoFlag;
vis->alphaBits = alphaBits;
vis->rgbBits = redBits + greenBits + blueBits;
- vis->indexBits = 0;
vis->depthBits = depthBits;
vis->stencilBits = stencilBits;
vis->accumBlueBits = accumBlueBits;
vis->accumAlphaBits = accumAlphaBits;
- vis->haveAccumBuffer = accumRedBits > 0;
- vis->haveDepthBuffer = depthBits > 0;
- vis->haveStencilBuffer = stencilBits > 0;
-
vis->numAuxBuffers = 0;
vis->level = 0;
vis->sampleBuffers = numSamples > 0 ? 1 : 0;
/*@{*/
-/**
- * One-time initialization mutex lock.
- *
- * \sa Used by one_time_init().
- */
-mtx_t OneTimeLock = _MTX_INITIALIZER_NP;
-
-
/**
* Calls all the various one-time-fini functions in Mesa
*/
static void
one_time_fini(void)
{
- _mesa_destroy_shader_compiler();
+ glsl_type_singleton_decref();
_mesa_locale_fini();
}
/**
- * Calls all the various one-time-init functions in Mesa.
- *
- * While holding a global mutex lock, calls several initialization functions,
- * and sets the glapi callbacks if the \c MESA_DEBUG environment variable is
- * defined.
- *
- * \sa _math_init().
+ * Calls all the various one-time-init functions in Mesa
*/
+
static void
-one_time_init( struct gl_context *ctx )
+one_time_init(void)
{
- static GLbitfield api_init_mask = 0x0;
-
- mtx_lock(&OneTimeLock);
-
- /* truly one-time init */
- if (!api_init_mask) {
- GLuint i;
+ GLuint i;
- STATIC_ASSERT(sizeof(GLbyte) == 1);
- STATIC_ASSERT(sizeof(GLubyte) == 1);
- STATIC_ASSERT(sizeof(GLshort) == 2);
- STATIC_ASSERT(sizeof(GLushort) == 2);
- STATIC_ASSERT(sizeof(GLint) == 4);
- STATIC_ASSERT(sizeof(GLuint) == 4);
+ STATIC_ASSERT(sizeof(GLbyte) == 1);
+ STATIC_ASSERT(sizeof(GLubyte) == 1);
+ STATIC_ASSERT(sizeof(GLshort) == 2);
+ STATIC_ASSERT(sizeof(GLushort) == 2);
+ STATIC_ASSERT(sizeof(GLint) == 4);
+ STATIC_ASSERT(sizeof(GLuint) == 4);
- _mesa_locale_init();
+ _mesa_locale_init();
- _mesa_one_time_init_extension_overrides(ctx);
+ _mesa_one_time_init_extension_overrides();
- _mesa_get_cpu_features();
+ _mesa_get_cpu_features();
- for (i = 0; i < 256; i++) {
- _mesa_ubyte_to_float_color_tab[i] = (float) i / 255.0F;
- }
+ for (i = 0; i < 256; i++) {
+ _mesa_ubyte_to_float_color_tab[i] = (float) i / 255.0F;
+ }
- atexit(one_time_fini);
+ atexit(one_time_fini);
#if defined(DEBUG)
- if (MESA_VERBOSE != 0) {
- _mesa_debug(ctx, "Mesa " PACKAGE_VERSION " DEBUG build"
-#ifdef MESA_GIT_SHA1
- " (" MESA_GIT_SHA1 ")"
-#endif
- "\n");
- }
-#endif
+ if (MESA_VERBOSE != 0) {
+ _mesa_debug(NULL, "Mesa " PACKAGE_VERSION " DEBUG build" MESA_GIT_SHA1 "\n");
}
+#endif
- /* per-API one-time init */
- if (!(api_init_mask & (1 << ctx->API))) {
- _mesa_init_remap_table();
- }
+ /* Take a glsl type reference for the duration of libGL's life to avoid
+ * unecessary creation/destruction of glsl types.
+ */
+ glsl_type_singleton_init_or_ref();
+
+ _mesa_init_remap_table();
+}
+
+/**
+ * One-time initialization flag
+ *
+ * \sa Used by _mesa_initialize().
+ */
+static once_flag init_once = ONCE_FLAG_INIT;
- api_init_mask |= 1 << ctx->API;
- mtx_unlock(&OneTimeLock);
+/**
+ * Calls all the various one-time-init functions in Mesa.
+ *
+ * While holding a global mutex lock, calls several initialization functions,
+ * and sets the glapi callbacks if the \c MESA_DEBUG environment variable is
+ * defined.
+ *
+ * \sa _math_init().
+ */
+void
+_mesa_initialize(void)
+{
+ call_once(&init_once, one_time_init);
}
/* Constants, may be overriden (usually only reduced) by device drivers */
consts->MaxTextureMbytes = MAX_TEXTURE_MBYTES;
- consts->MaxTextureLevels = MAX_TEXTURE_LEVELS;
+ consts->MaxTextureSize = 1 << (MAX_TEXTURE_LEVELS - 1);
consts->Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS;
consts->MaxCubeTextureLevels = MAX_CUBE_TEXTURE_LEVELS;
consts->MaxTextureRectSize = MAX_TEXTURE_RECT_SIZE;
consts->MaxProgramMatrices = MAX_PROGRAM_MATRICES;
consts->MaxProgramMatrixStackDepth = MAX_PROGRAM_MATRIX_STACK_DEPTH;
+ /* Set the absolute minimum possible GLSL version. API_OPENGL_CORE can
+ * mean an OpenGL 3.0 forward-compatible context, so that implies a minimum
+ * possible version of 1.30. Otherwise, the minimum possible version 1.20.
+ * Since Mesa unconditionally advertises GL_ARB_shading_language_100 and
+ * GL_ARB_shader_objects, every driver has GLSL 1.20... even if they don't
+ * advertise any extensions to enable any shader stages (e.g.,
+ * GL_ARB_vertex_shader).
+ */
+ consts->GLSLVersion = api == API_OPENGL_CORE ? 130 : 120;
+ consts->GLSLVersionCompat = consts->GLSLVersion;
+
+ consts->GLSLLowerConstArrays = true;
+
/* Assume that if GLSL 1.30+ (or GLSL ES 3.00+) is supported that
* gl_VertexID is implemented using a native hardware register with OpenGL
* semantics.
consts->Program[MESA_SHADER_GEOMETRY].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
consts->MaxGeometryOutputVertices = MAX_GEOMETRY_OUTPUT_VERTICES;
consts->MaxGeometryTotalOutputComponents = MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS;
-
- /* Shading language version */
- consts->GLSLVersion = 120;
- _mesa_override_glsl_version(consts);
+ consts->MaxGeometryShaderInvocations = MAX_GEOMETRY_SHADER_INVOCATIONS;
#ifdef DEBUG
consts->GenerateTemporaryNames = true;
consts->MaxComputeVariableGroupSize[1] = 512;
consts->MaxComputeVariableGroupSize[2] = 64;
consts->MaxComputeVariableGroupInvocations = 512;
+
+ /** GL_NV_conservative_raster */
+ consts->MaxSubpixelPrecisionBiasBits = 0;
+
+ /** GL_NV_conservative_raster_dilate */
+ consts->ConservativeRasterDilateRange[0] = 0.0;
+ consts->ConservativeRasterDilateRange[1] = 0.0;
+ consts->ConservativeRasterDilateGranularity = 0.0;
+
+ consts->glBeginEndBufferSize = 512 * 1024;
}
/* Texture size checks */
- assert(ctx->Const.MaxTextureLevels <= MAX_TEXTURE_LEVELS);
+ assert(ctx->Const.MaxTextureSize <= (1 << (MAX_TEXTURE_LEVELS - 1)));
assert(ctx->Const.Max3DTextureLevels <= MAX_3D_TEXTURE_LEVELS);
assert(ctx->Const.MaxCubeTextureLevels <= MAX_CUBE_TEXTURE_LEVELS);
assert(ctx->Const.MaxTextureRectSize <= MAX_TEXTURE_RECT_SIZE);
assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS);
/* Max texture size should be <= max viewport size (render to texture) */
- assert((1U << (ctx->Const.MaxTextureLevels - 1))
- <= ctx->Const.MaxViewportWidth);
- assert((1U << (ctx->Const.MaxTextureLevels - 1))
- <= ctx->Const.MaxViewportHeight);
+ assert(ctx->Const.MaxTextureSize <= ctx->Const.MaxViewportWidth);
+ assert(ctx->Const.MaxTextureSize <= ctx->Const.MaxViewportHeight);
assert(ctx->Const.MaxDrawBuffers <= MAX_DRAW_BUFFERS);
_mesa_init_bbox( ctx );
_mesa_init_buffer_objects( ctx );
_mesa_init_color( ctx );
+ _mesa_init_conservative_raster( ctx );
_mesa_init_current( ctx );
_mesa_init_depth( ctx );
_mesa_init_debug( ctx );
if (ctx) {
_mesa_error(ctx, GL_INVALID_OPERATION, "%s(invalid call)", name);
}
-#if defined(DEBUG)
+#ifndef NDEBUG
else if (getenv("MESA_DEBUG") || getenv("LIBGL_DEBUG")) {
fprintf(stderr,
"GL User Error: gl%s called without a rendering context\n",
_mesa_override_gl_version(ctx);
/* misc one-time initializations */
- one_time_init(ctx);
+ _mesa_initialize();
/* Plug in driver functions and context pointer here.
* This is important because when we call alloc_shared_state() below
* \sa _mesa_initialize_context() and init_attrib_groups().
*/
void
-_mesa_free_context_data( struct gl_context *ctx )
+_mesa_free_context_data(struct gl_context *ctx)
{
if (!_mesa_get_current_context()){
/* No current context, but we may need one in order to delete
_mesa_reference_vao(ctx, &ctx->Array.VAO, NULL);
_mesa_reference_vao(ctx, &ctx->Array.DefaultVAO, NULL);
+ _mesa_reference_vao(ctx, &ctx->Array._EmptyVAO, NULL);
+ _mesa_reference_vao(ctx, &ctx->Array._DrawVAO, NULL);
_mesa_free_attrib_data(ctx);
_mesa_free_buffer_objects(ctx);
_mesa_free_eval_data( ctx );
_mesa_free_texture_data( ctx );
+ _mesa_free_image_textures(ctx);
_mesa_free_matrix_data( ctx );
_mesa_free_pipeline_data(ctx);
_mesa_free_program_data(ctx);
free(ctx->VersionString);
+ ralloc_free(ctx->SoftFP64);
+
/* unbind the context if it's currently bound */
if (ctx == _mesa_get_current_context()) {
_mesa_make_current(NULL, NULL, NULL);
}
+
+ /* Do this after unbinding context to ensure any thread is finished. */
+ if (ctx->shader_builtin_ref) {
+ _mesa_glsl_builtin_functions_decref();
+ ctx->shader_builtin_ref = false;
+ }
+
+ free(ctx->Const.SpirVExtensions);
}
ctxvis->foo != bufvis->foo) \
return GL_FALSE
- check_component(redMask);
- check_component(greenMask);
- check_component(blueMask);
+ check_component(redShift);
+ check_component(greenShift);
+ check_component(blueShift);
+ check_component(redBits);
+ check_component(greenBits);
+ check_component(blueBits);
check_component(depthBits);
check_component(stencilBits);
check_context_limits(ctx);
+ _mesa_update_vertex_processing_mode(ctx);
+
/* According to GL_MESA_configless_context the default value of
* glDrawBuffers depends on the config of the first surface it is bound to.
* For GLES it is always GL_BACK which has a magic interpretation.
_mesa_flush(curCtx);
}
- /* We used to call _glapi_check_multithread() here. Now do it in drivers */
+ /* Call this periodically to detect when the user has begun using
+ * GL rendering from multiple threads.
+ */
+ _glapi_check_multithread();
if (!newCtx) {
_glapi_set_dispatch(NULL); /* none current */
* changed since the last time this FBO was bound).
*/
_mesa_update_draw_buffers(newCtx);
+ _mesa_update_allow_draw_out_of_order(newCtx);
}
if (!newCtx->ReadBuffer || _mesa_is_winsys_fbo(newCtx->ReadBuffer)) {
_mesa_reference_framebuffer(&newCtx->ReadBuffer, readBuffer);
_mesa_flush(struct gl_context *ctx)
{
FLUSH_VERTICES( ctx, 0 );
- FLUSH_CURRENT( ctx, 0 );
if (ctx->Driver.Flush) {
ctx->Driver.Flush(ctx);
}
ASSERT_OUTSIDE_BEGIN_END(ctx);
FLUSH_VERTICES(ctx, 0);
- FLUSH_CURRENT(ctx, 0);
if (ctx->Driver.Finish) {
ctx->Driver.Finish(ctx);
projects / mesa.git / blobdiff