#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>
* \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;
static void
one_time_fini(void)
{
- _mesa_destroy_shader_compiler();
+ glsl_type_singleton_decref();
_mesa_locale_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");
+ _mesa_debug(ctx, "Mesa " PACKAGE_VERSION " DEBUG build" MESA_GIT_SHA1 "\n");
}
#endif
+
+ /* 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();
}
/* per-API 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;
}
/* 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",
* \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 */
projects / mesa.git / blobdiff