#include "main/imports.h"
-#include "main/api_noop.h"
#include "main/macros.h"
#include "main/simple_list.h"
#include "brw_context.h"
#include "brw_state.h"
#include "intel_span.h"
#include "tnl/t_pipeline.h"
+#include "glsl/ralloc.h"
/***************************************
* Mesa's Driver Functions
brw_init_queryobj_functions(functions);
}
-GLboolean brwCreateContext( int api,
- const struct gl_config *mesaVis,
- __DRIcontext *driContextPriv,
- void *sharedContextPrivate)
+bool
+brwCreateContext(int api,
+ const struct gl_config *mesaVis,
+ __DRIcontext *driContextPriv,
+ void *sharedContextPrivate)
{
struct dd_function_table functions;
- struct brw_context *brw = (struct brw_context *) CALLOC_STRUCT(brw_context);
+ struct brw_context *brw = rzalloc(NULL, struct brw_context);
struct intel_context *intel = &brw->intel;
struct gl_context *ctx = &intel->ctx;
unsigned i;
if (!brw) {
printf("%s: failed to alloc context\n", __FUNCTION__);
- return GL_FALSE;
+ return false;
}
- brwInitVtbl( brw );
brwInitDriverFunctions( &functions );
if (!intelInitContext( intel, api, mesaVis, driContextPriv,
sharedContextPrivate, &functions )) {
printf("%s: failed to init intel context\n", __FUNCTION__);
FREE(brw);
- return GL_FALSE;
+ return false;
}
+ brwInitVtbl( brw );
+
/* Initialize swrast, tnl driver tables: */
intelInitSpanFuncs(ctx);
ctx->Const.MaxVertexTextureImageUnits +
ctx->Const.MaxTextureImageUnits;
- /* Mesa limits textures to 4kx4k; it would be nice to fix that someday
- */
- ctx->Const.MaxTextureLevels = 13;
+ ctx->Const.MaxTextureLevels = 14; /* 8192 */
+ if (ctx->Const.MaxTextureLevels > MAX_TEXTURE_LEVELS)
+ ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS;
ctx->Const.Max3DTextureLevels = 9;
ctx->Const.MaxCubeTextureLevels = 12;
+ /* minimum maximum. Users are likely to run into memory problems
+ * even at this size, since 64 * 2048 * 2048 * 4 = 1GB and we can't
+ * address that much.
+ */
+ ctx->Const.MaxArrayTextureLayers = 64;
ctx->Const.MaxTextureRectSize = (1<<12);
ctx->Const.MaxTextureMaxAnisotropy = 16.0;
/* We want the GLSL compiler to emit code that uses condition codes */
for (i = 0; i <= MESA_SHADER_FRAGMENT; i++) {
- ctx->ShaderCompilerOptions[i].EmitCondCodes = GL_TRUE;
- ctx->ShaderCompilerOptions[i].EmitNVTempInitialization = GL_TRUE;
- ctx->ShaderCompilerOptions[i].EmitNoNoise = GL_TRUE;
- ctx->ShaderCompilerOptions[i].EmitNoMainReturn = GL_TRUE;
- ctx->ShaderCompilerOptions[i].EmitNoIndirectInput = GL_TRUE;
- ctx->ShaderCompilerOptions[i].EmitNoIndirectOutput = GL_TRUE;
+ ctx->ShaderCompilerOptions[i].MaxIfDepth = intel->gen < 6 ? 16 : UINT_MAX;
+ ctx->ShaderCompilerOptions[i].EmitCondCodes = true;
+ ctx->ShaderCompilerOptions[i].EmitNVTempInitialization = true;
+ ctx->ShaderCompilerOptions[i].EmitNoNoise = true;
+ ctx->ShaderCompilerOptions[i].EmitNoMainReturn = true;
+ ctx->ShaderCompilerOptions[i].EmitNoIndirectInput = true;
+ ctx->ShaderCompilerOptions[i].EmitNoIndirectOutput = true;
ctx->ShaderCompilerOptions[i].EmitNoIndirectUniform =
(i == MESA_SHADER_FRAGMENT);
ctx->ShaderCompilerOptions[i].EmitNoIndirectTemp =
(i == MESA_SHADER_FRAGMENT);
+ ctx->ShaderCompilerOptions[i].LowerClipDistance = true;
}
ctx->Const.VertexProgram.MaxNativeInstructions = (16 * 1024);
but we're not sure how it's actually done for vertex order,
that affect provoking vertex decision. Always use last vertex
convention for quad primitive which works as expected for now. */
- if (intel->gen == 6)
- ctx->Const.QuadsFollowProvokingVertexConvention = GL_FALSE;
+ if (intel->gen >= 6)
+ ctx->Const.QuadsFollowProvokingVertexConvention = false;
if (intel->is_g4x || intel->gen >= 5) {
- brw->CMD_VF_STATISTICS = CMD_VF_STATISTICS_GM45;
+ brw->CMD_VF_STATISTICS = GM45_3DSTATE_VF_STATISTICS;
brw->CMD_PIPELINE_SELECT = CMD_PIPELINE_SELECT_GM45;
- brw->has_surface_tile_offset = GL_TRUE;
+ brw->has_surface_tile_offset = true;
if (intel->gen < 6)
- brw->has_compr4 = GL_TRUE;
- brw->has_aa_line_parameters = GL_TRUE;
- brw->has_pln = GL_TRUE;
+ brw->has_compr4 = true;
+ brw->has_aa_line_parameters = true;
+ brw->has_pln = true;
} else {
- brw->CMD_VF_STATISTICS = CMD_VF_STATISTICS_965;
+ brw->CMD_VF_STATISTICS = GEN4_3DSTATE_VF_STATISTICS;
brw->CMD_PIPELINE_SELECT = CMD_PIPELINE_SELECT_965;
}
/* WM maximum threads is number of EUs times number of threads per EU. */
if (intel->gen >= 7) {
- if (IS_IVB_GT1(intel->intelScreen->deviceID)) {
- brw->wm_max_threads = 86;
- brw->vs_max_threads = 36;
- } else if (IS_IVB_GT2(intel->intelScreen->deviceID)) {
- brw->wm_max_threads = 86;
- brw->vs_max_threads = 128;
+ if (intel->gt == 1) {
+ brw->max_wm_threads = 86;
+ brw->max_vs_threads = 36;
+ brw->max_gs_threads = 36;
+ brw->urb.size = 128;
+ brw->urb.max_vs_entries = 512;
+ brw->urb.max_gs_entries = 192;
+ } else if (intel->gt == 2) {
+ brw->max_wm_threads = 86;
+ brw->max_vs_threads = 128;
+ brw->max_gs_threads = 128;
+ brw->urb.size = 256;
+ brw->urb.max_vs_entries = 704;
+ brw->urb.max_gs_entries = 320;
} else {
assert(!"Unknown gen7 device.");
}
} else if (intel->gen == 6) {
- if (IS_GT2(intel->intelScreen->deviceID)) {
+ if (intel->gt == 2) {
/* This could possibly be 80, but is supposed to require
* disabling of WIZ hashing (bit 6 of GT_MODE, 0x20d0) and a
* GPU reset to change.
*/
- brw->wm_max_threads = 40;
- brw->vs_max_threads = 60;
+ brw->max_wm_threads = 40;
+ brw->max_vs_threads = 60;
+ brw->max_gs_threads = 60;
brw->urb.size = 64; /* volume 5c.5 section 5.1 */
- brw->urb.max_vs_entries = 128; /* volume 2a (see 3DSTATE_URB) */
+ brw->urb.max_vs_entries = 256; /* volume 2a (see 3DSTATE_URB) */
} else {
- brw->wm_max_threads = 40;
- brw->vs_max_threads = 24;
+ brw->max_wm_threads = 40;
+ brw->max_vs_threads = 24;
+ brw->max_gs_threads = 21; /* conservative; 24 if rendering disabled */
brw->urb.size = 32; /* volume 5c.5 section 5.1 */
- brw->urb.max_vs_entries = 256; /* volume 2a (see 3DSTATE_URB) */
+ brw->urb.max_vs_entries = 128; /* volume 2a (see 3DSTATE_URB) */
}
} else if (intel->gen == 5) {
brw->urb.size = 1024;
- brw->vs_max_threads = 72;
- brw->wm_max_threads = 12 * 6;
+ brw->max_vs_threads = 72;
+ brw->max_gs_threads = 32;
+ brw->max_wm_threads = 12 * 6;
} else if (intel->is_g4x) {
brw->urb.size = 384;
- brw->vs_max_threads = 32;
- brw->wm_max_threads = 10 * 5;
+ brw->max_vs_threads = 32;
+ brw->max_gs_threads = 2;
+ brw->max_wm_threads = 10 * 5;
} else if (intel->gen < 6) {
brw->urb.size = 256;
- brw->vs_max_threads = 16;
- brw->wm_max_threads = 8 * 4;
- brw->has_negative_rhw_bug = GL_TRUE;
- }
-
- if (INTEL_DEBUG & DEBUG_SINGLE_THREAD) {
- brw->vs_max_threads = 1;
- brw->wm_max_threads = 1;
+ brw->max_vs_threads = 16;
+ brw->max_gs_threads = 2;
+ brw->max_wm_threads = 8 * 4;
+ brw->has_negative_rhw_bug = true;
}
brw_init_state( brw );
brw->emit_state_always = 0;
- ctx->VertexProgram._MaintainTnlProgram = GL_TRUE;
- ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
+ intel->batch.need_workaround_flush = true;
+
+ ctx->VertexProgram._MaintainTnlProgram = true;
+ ctx->FragmentProgram._MaintainTexEnvProgram = true;
brw_draw_init( brw );
- return GL_TRUE;
+ brw->new_vs_backend = (getenv("INTEL_OLD_VS") == NULL);
+
+ /* If we're using the new shader backend, we require integer uniforms
+ * stored as actual integers.
+ */
+ if (brw->new_vs_backend) {
+ ctx->Const.NativeIntegers = true;
+ ctx->Const.UniformBooleanTrue = 1;
+ }
+
+ return true;
}
projects / mesa.git / blobdiff