void vbo_exec_vtx_init( struct vbo_exec_context *exec ) { struct gl_context *ctx = exec->ctx; struct vbo_context *vbo = vbo_context(ctx); GLuint i; /* Allocate a buffer object. Will just reuse this object * continuously, unless vbo_use_buffer_objects() is called to enable * use of real VBOs. */ _mesa_reference_buffer_object(ctx, &exec->vtx.bufferobj, ctx->Shared->NullBufferObj); ASSERT(!exec->vtx.buffer_map); exec->vtx.buffer_map = _mesa_align_malloc(VBO_VERT_BUFFER_SIZE, 64); exec->vtx.buffer_ptr = exec->vtx.buffer_map; vbo_exec_vtxfmt_init( exec ); _mesa_noop_vtxfmt_init(&exec->vtxfmt_noop); for (i = 0 ; i < VBO_ATTRIB_MAX ; i++) { ASSERT(i < Elements(exec->vtx.attrsz)); exec->vtx.attrsz[i] = 0; ASSERT(i < Elements(exec->vtx.attrtype)); exec->vtx.attrtype[i] = GL_FLOAT; ASSERT(i < Elements(exec->vtx.active_sz)); exec->vtx.active_sz[i] = 0; } for (i = 0 ; i < VERT_ATTRIB_MAX; i++) { ASSERT(i < Elements(exec->vtx.inputs)); ASSERT(i < Elements(exec->vtx.arrays)); exec->vtx.inputs[i] = &exec->vtx.arrays[i]; } { struct gl_client_array *arrays = exec->vtx.arrays; unsigned i; memcpy(arrays, &vbo->currval[VBO_ATTRIB_POS], VERT_ATTRIB_FF_MAX * sizeof(arrays[0])); for (i = 0; i < VERT_ATTRIB_FF_MAX; ++i) { struct gl_client_array *array; array = &arrays[VERT_ATTRIB_FF(i)]; array->BufferObj = NULL; _mesa_reference_buffer_object(ctx, &array->BufferObj, vbo->currval[VBO_ATTRIB_POS+i].BufferObj); } memcpy(arrays + VERT_ATTRIB_GENERIC(0), &vbo->currval[VBO_ATTRIB_GENERIC0], VERT_ATTRIB_GENERIC_MAX * sizeof(arrays[0])); for (i = 0; i < VERT_ATTRIB_GENERIC_MAX; ++i) { struct gl_client_array *array; array = &arrays[VERT_ATTRIB_GENERIC(i)]; array->BufferObj = NULL; _mesa_reference_buffer_object(ctx, &array->BufferObj, vbo->currval[VBO_ATTRIB_GENERIC0+i].BufferObj); } } exec->vtx.vertex_size = 0; exec->begin_vertices_flags = FLUSH_UPDATE_CURRENT; }
static HRESULT WINAPI drm_create_adapter( int fd, ID3DAdapter9 **ppAdapter ) { struct d3dadapter9drm_context *ctx = CALLOC_STRUCT(d3dadapter9drm_context); HRESULT hr; int i, different_device; const char *paths[] = { getenv("D3D9_DRIVERS_PATH"), getenv("D3D9_DRIVERS_DIR"), PIPE_SEARCH_DIR }; if (!ctx) { return E_OUTOFMEMORY; } ctx->base.destroy = drm_destroy; fd = loader_get_user_preferred_fd(fd, &different_device); ctx->base.linear_framebuffer = !!different_device; /* use pipe-loader to dlopen appropriate drm driver */ if (!pipe_loader_drm_probe_fd(&ctx->dev, fd, FALSE)) { DBG("Failed to probe drm fd %d.\n", fd); FREE(ctx); close(fd); return D3DERR_DRIVERINTERNALERROR; } /* use pipe-loader to create a drm screen (hal) */ ctx->base.hal = NULL; for (i = 0; !ctx->base.hal && i < Elements(paths); ++i) { if (!paths[i]) { continue; } ctx->base.hal = pipe_loader_create_screen(ctx->dev, paths[i]); } if (!ctx->base.hal) { DBG("Unable to load requested driver.\n"); pipe_loader_release(&ctx->dev, 1); FREE(ctx); return D3DERR_DRIVERINTERNALERROR; } /* wrap it to create a software screen that can share resources */ if (pipe_loader_sw_probe_wrapped(&ctx->swdev, ctx->base.hal)) { ctx->base.ref = NULL; for (i = 0; !ctx->base.ref && i < Elements(paths); ++i) { if (!paths[i]) { continue; } ctx->base.ref = pipe_loader_create_screen(ctx->swdev, paths[i]); } } if (!ctx->base.ref) { DBG("Couldn't wrap drm screen to swrast screen. Software devices " "will be unavailable.\n"); } /* read out PCI info */ read_descriptor(&ctx->base, fd); /* create and return new ID3DAdapter9 */ hr = NineAdapter9_new(&ctx->base, (struct NineAdapter9 **)ppAdapter); if (FAILED(hr)) { if (ctx->swdev) { pipe_loader_release(&ctx->swdev, 1); } pipe_loader_release(&ctx->dev, 1); FREE(ctx); return hr; } return D3D_OK; }
/** * Return ARB_v/f_prog-style input attrib string. */ static const char * arb_input_attrib_string(GLint index, GLenum progType) { /* * These strings should match the VERT_ATTRIB_x and VARYING_SLOT_x tokens. */ static const char *const vertAttribs[] = { "vertex.position", "vertex.weight", "vertex.normal", "vertex.color.primary", "vertex.color.secondary", "vertex.fogcoord", "vertex.(six)", /* VERT_ATTRIB_COLOR_INDEX */ "vertex.(seven)", /* VERT_ATTRIB_EDGEFLAG */ "vertex.texcoord[0]", "vertex.texcoord[1]", "vertex.texcoord[2]", "vertex.texcoord[3]", "vertex.texcoord[4]", "vertex.texcoord[5]", "vertex.texcoord[6]", "vertex.texcoord[7]", "vertex.(sixteen)", /* VERT_ATTRIB_POINT_SIZE */ "vertex.attrib[0]", "vertex.attrib[1]", "vertex.attrib[2]", "vertex.attrib[3]", "vertex.attrib[4]", "vertex.attrib[5]", "vertex.attrib[6]", "vertex.attrib[7]", "vertex.attrib[8]", "vertex.attrib[9]", "vertex.attrib[10]", "vertex.attrib[11]", "vertex.attrib[12]", "vertex.attrib[13]", "vertex.attrib[14]", "vertex.attrib[15]" /* MAX_VARYING = 16 */ }; static const char *const fragAttribs[] = { "fragment.position", "fragment.color.primary", "fragment.color.secondary", "fragment.fogcoord", "fragment.texcoord[0]", "fragment.texcoord[1]", "fragment.texcoord[2]", "fragment.texcoord[3]", "fragment.texcoord[4]", "fragment.texcoord[5]", "fragment.texcoord[6]", "fragment.texcoord[7]", "fragment.(twelve)", /* VARYING_SLOT_PSIZ */ "fragment.(thirteen)", /* VARYING_SLOT_BFC0 */ "fragment.(fourteen)", /* VARYING_SLOT_BFC1 */ "fragment.(fifteen)", /* VARYING_SLOT_EDGE */ "fragment.(sixteen)", /* VARYING_SLOT_CLIP_VERTEX */ "fragment.(seventeen)", /* VARYING_SLOT_CLIP_DIST0 */ "fragment.(eighteen)", /* VARYING_SLOT_CLIP_DIST1 */ "fragment.(nineteen)", /* VARYING_SLOT_PRIMITIVE_ID */ "fragment.(twenty)", /* VARYING_SLOT_LAYER */ "fragment.(twenty-one)", /* VARYING_SLOT_FACE */ "fragment.(twenty-two)", /* VARYING_SLOT_PNTC */ "fragment.varying[0]", "fragment.varying[1]", "fragment.varying[2]", "fragment.varying[3]", "fragment.varying[4]", "fragment.varying[5]", "fragment.varying[6]", "fragment.varying[7]", "fragment.varying[8]", "fragment.varying[9]", "fragment.varying[10]", "fragment.varying[11]", "fragment.varying[12]", "fragment.varying[13]", "fragment.varying[14]", "fragment.varying[15]", "fragment.varying[16]", "fragment.varying[17]", "fragment.varying[18]", "fragment.varying[19]", "fragment.varying[20]", "fragment.varying[21]", "fragment.varying[22]", "fragment.varying[23]", "fragment.varying[24]", "fragment.varying[25]", "fragment.varying[26]", "fragment.varying[27]", "fragment.varying[28]", "fragment.varying[29]", "fragment.varying[30]", "fragment.varying[31]", /* MAX_VARYING = 32 */ }; /* sanity checks */ STATIC_ASSERT(Elements(vertAttribs) == VERT_ATTRIB_MAX); STATIC_ASSERT(Elements(fragAttribs) == VARYING_SLOT_MAX); assert(strcmp(vertAttribs[VERT_ATTRIB_TEX0], "vertex.texcoord[0]") == 0); assert(strcmp(vertAttribs[VERT_ATTRIB_GENERIC15], "vertex.attrib[15]") == 0); assert(strcmp(fragAttribs[VARYING_SLOT_TEX0], "fragment.texcoord[0]") == 0); assert(strcmp(fragAttribs[VARYING_SLOT_VAR0+15], "fragment.varying[15]") == 0); if (progType == GL_VERTEX_PROGRAM_ARB) { assert(index < Elements(vertAttribs)); return vertAttribs[index]; } else { assert(progType == GL_FRAGMENT_PROGRAM_ARB); assert(index < Elements(fragAttribs)); return fragAttribs[index]; } }
static struct st_context * st_create_context_priv( struct gl_context *ctx, struct pipe_context *pipe, const struct st_config_options *options) { struct pipe_screen *screen = pipe->screen; uint i; struct st_context *st = ST_CALLOC_STRUCT( st_context ); st->options = *options; ctx->st = st; st->ctx = ctx; st->pipe = pipe; /* XXX: this is one-off, per-screen init: */ st_debug_init(); /* state tracker needs the VBO module */ _vbo_CreateContext(ctx); st->dirty.mesa = ~0; st->dirty.st = ~0; /* Create upload manager for vertex data for glBitmap, glDrawPixels, * glClear, etc. */ st->uploader = u_upload_create(st->pipe, 65536, 4, PIPE_BIND_VERTEX_BUFFER); if (!screen->get_param(screen, PIPE_CAP_USER_INDEX_BUFFERS)) { st->indexbuf_uploader = u_upload_create(st->pipe, 128 * 1024, 4, PIPE_BIND_INDEX_BUFFER); } if (!screen->get_param(screen, PIPE_CAP_USER_CONSTANT_BUFFERS)) { unsigned alignment = screen->get_param(screen, PIPE_CAP_CONSTANT_BUFFER_OFFSET_ALIGNMENT); st->constbuf_uploader = u_upload_create(pipe, 128 * 1024, alignment, PIPE_BIND_CONSTANT_BUFFER); } st->cso_context = cso_create_context(pipe); st_init_atoms( st ); st_init_bitmap(st); st_init_clear(st); st_init_draw( st ); /* Choose texture target for glDrawPixels, glBitmap, renderbuffers */ if (pipe->screen->get_param(pipe->screen, PIPE_CAP_NPOT_TEXTURES)) st->internal_target = PIPE_TEXTURE_2D; else st->internal_target = PIPE_TEXTURE_RECT; /* Vertex element objects used for drawing rectangles for glBitmap, * glDrawPixels, glClear, etc. */ for (i = 0; i < Elements(st->velems_util_draw); i++) { memset(&st->velems_util_draw[i], 0, sizeof(struct pipe_vertex_element)); st->velems_util_draw[i].src_offset = i * 4 * sizeof(float); st->velems_util_draw[i].instance_divisor = 0; st->velems_util_draw[i].vertex_buffer_index = cso_get_aux_vertex_buffer_slot(st->cso_context); st->velems_util_draw[i].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT; } /* we want all vertex data to be placed in buffer objects */ vbo_use_buffer_objects(ctx); /* make sure that no VBOs are left mapped when we're drawing. */ vbo_always_unmap_buffers(ctx); /* Need these flags: */ st->ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE; st->ctx->VertexProgram._MaintainTnlProgram = GL_TRUE; st->pixel_xfer.cache = _mesa_new_program_cache(); 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, PIPE_BIND_SAMPLER_VIEW); st->prefer_blit_based_texture_transfer = screen->get_param(screen, PIPE_CAP_PREFER_BLIT_BASED_TEXTURE_TRANSFER); st->needs_texcoord_semantic = screen->get_param(screen, PIPE_CAP_TGSI_TEXCOORD); 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)); st->has_time_elapsed = screen->get_param(screen, PIPE_CAP_QUERY_TIME_ELAPSED); /* GL limits and extensions */ st_init_limits(st->pipe->screen, &ctx->Const, &ctx->Extensions); st_init_extensions(st->pipe->screen, &ctx->Const, &ctx->Extensions, &st->options, ctx->Mesa_DXTn); /* 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; } } /* called after _mesa_create_context/_mesa_init_point, fix default user * settable max point size up */ st->ctx->Point.MaxSize = MAX2(ctx->Const.MaxPointSize, ctx->Const.MaxPointSizeAA); _mesa_compute_version(ctx); 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. */ st_destroy_context_priv(st); return NULL; } _mesa_initialize_dispatch_tables(ctx); _mesa_initialize_vbo_vtxfmt(ctx); return st; }
NS_IMETHODIMP HTMLFieldSetElement::GetElements(nsIDOMHTMLCollection** aElements) { NS_ADDREF(*aElements = Elements()); return NS_OK; }
/** * Called via glUniform*() functions. */ extern "C" void _mesa_uniform(struct gl_context *ctx, struct gl_shader_program *shProg, GLint location, GLsizei count, const GLvoid *values, GLenum type) { unsigned loc, offset; unsigned components; unsigned src_components; enum glsl_base_type basicType; struct gl_uniform_storage *uni; if (!validate_uniform_parameters(ctx, shProg, location, count, &loc, &offset, "glUniform", false)) return; uni = &shProg->UniformStorage[loc]; /* Verify that the types are compatible. */ switch (type) { case GL_FLOAT: basicType = GLSL_TYPE_FLOAT; src_components = 1; break; case GL_FLOAT_VEC2: basicType = GLSL_TYPE_FLOAT; src_components = 2; break; case GL_FLOAT_VEC3: basicType = GLSL_TYPE_FLOAT; src_components = 3; break; case GL_FLOAT_VEC4: basicType = GLSL_TYPE_FLOAT; src_components = 4; break; case GL_UNSIGNED_INT: basicType = GLSL_TYPE_UINT; src_components = 1; break; case GL_UNSIGNED_INT_VEC2: basicType = GLSL_TYPE_UINT; src_components = 2; break; case GL_UNSIGNED_INT_VEC3: basicType = GLSL_TYPE_UINT; src_components = 3; break; case GL_UNSIGNED_INT_VEC4: basicType = GLSL_TYPE_UINT; src_components = 4; break; case GL_INT: basicType = GLSL_TYPE_INT; src_components = 1; break; case GL_INT_VEC2: basicType = GLSL_TYPE_INT; src_components = 2; break; case GL_INT_VEC3: basicType = GLSL_TYPE_INT; src_components = 3; break; case GL_INT_VEC4: basicType = GLSL_TYPE_INT; src_components = 4; break; case GL_BOOL: case GL_BOOL_VEC2: case GL_BOOL_VEC3: case GL_BOOL_VEC4: case GL_FLOAT_MAT2: case GL_FLOAT_MAT2x3: case GL_FLOAT_MAT2x4: case GL_FLOAT_MAT3x2: case GL_FLOAT_MAT3: case GL_FLOAT_MAT3x4: case GL_FLOAT_MAT4x2: case GL_FLOAT_MAT4x3: case GL_FLOAT_MAT4: default: _mesa_problem(NULL, "Invalid type in %s", __func__); return; } if (uni->type->is_sampler()) { components = 1; } else { components = uni->type->vector_elements; } bool match; switch (uni->type->base_type) { case GLSL_TYPE_BOOL: match = true; break; case GLSL_TYPE_SAMPLER: match = (basicType == GLSL_TYPE_INT); break; default: match = (basicType == uni->type->base_type); break; } if (uni->type->is_matrix() || components != src_components || !match) { _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(type mismatch)"); return; } if (ctx->Shader.Flags & GLSL_UNIFORMS) { log_uniform(values, basicType, components, 1, count, false, shProg, location, uni); } /* Page 100 (page 116 of the PDF) of the OpenGL 3.0 spec says: * * "Setting a sampler's value to i selects texture image unit number * i. The values of i range from zero to the implementation- dependent * maximum supported number of texture image units." * * In addition, table 2.3, "Summary of GL errors," on page 17 (page 33 of * the PDF) says: * * "Error Description Offending command * ignored? * ... * INVALID_VALUE Numeric argument out of range Yes" * * Based on that, when an invalid sampler is specified, we generate a * GL_INVALID_VALUE error and ignore the command. */ if (uni->type->is_sampler()) { int i; for (i = 0; i < count; i++) { const unsigned texUnit = ((unsigned *) values)[i]; /* check that the sampler (tex unit index) is legal */ if (texUnit >= ctx->Const.MaxCombinedTextureImageUnits) { _mesa_error(ctx, GL_INVALID_VALUE, "glUniform1i(invalid sampler/tex unit index for " "uniform %d)", location); return; } } } /* Page 82 (page 96 of the PDF) of the OpenGL 2.1 spec says: * * "When loading N elements starting at an arbitrary position k in a * uniform declared as an array, elements k through k + N - 1 in the * array will be replaced with the new values. Values for any array * element that exceeds the highest array element index used, as * reported by GetActiveUniform, will be ignored by the GL." * * Clamp 'count' to a valid value. Note that for non-arrays a count > 1 * will have already generated an error. */ if (uni->array_elements != 0) { count = MIN2(count, (int) (uni->array_elements - offset)); } FLUSH_VERTICES(ctx, _NEW_PROGRAM_CONSTANTS); /* Store the data in the "actual type" backing storage for the uniform. */ if (!uni->type->is_boolean()) { memcpy(&uni->storage[components * offset], values, sizeof(uni->storage[0]) * components * count); } else { const union gl_constant_value *src = (const union gl_constant_value *) values; union gl_constant_value *dst = &uni->storage[components * offset]; const unsigned elems = components * count; unsigned i; for (i = 0; i < elems; i++) { if (basicType == GLSL_TYPE_FLOAT) { dst[i].i = src[i].f != 0.0f ? 1 : 0; } else { dst[i].i = src[i].i != 0 ? 1 : 0; } } } uni->initialized = true; _mesa_propagate_uniforms_to_driver_storage(uni, offset, count); /* If the uniform is a sampler, do the extra magic necessary to propagate * the changes through. */ if (uni->type->is_sampler()) { int i; bool flushed = false; for (i = 0; i < MESA_SHADER_TYPES; i++) { struct gl_shader *const sh = shProg->_LinkedShaders[i]; int j; /* If the shader stage doesn't use the sampler uniform, skip this. */ if (sh == NULL || !uni->sampler[i].active) continue; for (j = 0; j < count; j++) { sh->SamplerUnits[uni->sampler[i].index + offset + j] = ((unsigned *) values)[j]; } struct gl_program *const prog = sh->Program; assert(sizeof(prog->SamplerUnits) == sizeof(sh->SamplerUnits)); /* Determine if any of the samplers used by this shader stage have * been modified. */ bool changed = false; for (unsigned j = 0; j < Elements(prog->SamplerUnits); j++) { if ((sh->active_samplers & (1U << j)) != 0 && (prog->SamplerUnits[j] != sh->SamplerUnits[j])) { changed = true; break; } } if (changed) { if (!flushed) { FLUSH_VERTICES(ctx, _NEW_TEXTURE | _NEW_PROGRAM); flushed = true; } memcpy(prog->SamplerUnits, sh->SamplerUnits, sizeof(sh->SamplerUnits)); _mesa_update_shader_textures_used(shProg, prog); if (ctx->Driver.SamplerUniformChange) ctx->Driver.SamplerUniformChange(ctx, prog->Target, prog); } } } }
static boolean parse_declaration( struct translate_ctx *ctx ) { struct tgsi_full_declaration decl; uint file; struct parsed_dcl_bracket brackets[2]; int num_brackets; uint writemask; const char *cur; uint advance; boolean is_vs_input; boolean is_imm_array; assert(Elements(semantic_names) == TGSI_SEMANTIC_COUNT); assert(Elements(interpolate_names) == TGSI_INTERPOLATE_COUNT); if (!eat_white( &ctx->cur )) { report_error( ctx, "Syntax error" ); return FALSE; } if (!parse_register_dcl( ctx, &file, brackets, &num_brackets)) return FALSE; if (!parse_opt_writemask( ctx, &writemask )) return FALSE; decl = tgsi_default_full_declaration(); decl.Declaration.File = file; decl.Declaration.UsageMask = writemask; if (num_brackets == 1) { decl.Range.First = brackets[0].first; decl.Range.Last = brackets[0].last; } else { decl.Range.First = brackets[1].first; decl.Range.Last = brackets[1].last; decl.Declaration.Dimension = 1; decl.Dim.Index2D = brackets[0].first; } is_vs_input = (file == TGSI_FILE_INPUT && ctx->processor == TGSI_PROCESSOR_VERTEX); is_imm_array = (file == TGSI_FILE_IMMEDIATE_ARRAY); cur = ctx->cur; eat_opt_white( &cur ); if (*cur == ',' && !is_vs_input) { uint i, j; cur++; eat_opt_white( &cur ); if (file == TGSI_FILE_RESOURCE) { for (i = 0; i < TGSI_TEXTURE_COUNT; i++) { if (str_match_no_case(&cur, texture_names[i])) { if (!is_digit_alpha_underscore(cur)) { decl.Resource.Resource = i; break; } } } if (i == TGSI_TEXTURE_COUNT) { report_error(ctx, "Expected texture target"); return FALSE; } eat_opt_white( &cur ); if (*cur != ',') { report_error( ctx, "Expected `,'" ); return FALSE; } ++cur; eat_opt_white( &cur ); for (j = 0; j < 4; ++j) { for (i = 0; i < PIPE_TYPE_COUNT; ++i) { if (str_match_no_case(&cur, type_names[i])) { if (!is_digit_alpha_underscore(cur)) { switch (j) { case 0: decl.Resource.ReturnTypeX = i; break; case 1: decl.Resource.ReturnTypeY = i; break; case 2: decl.Resource.ReturnTypeZ = i; break; case 3: decl.Resource.ReturnTypeW = i; break; default: assert(0); } break; } } } if (i == PIPE_TYPE_COUNT) { if (j == 0 || j > 2) { report_error(ctx, "Expected type name"); return FALSE; } break; } else { const char *cur2 = cur; eat_opt_white( &cur2 ); if (*cur2 == ',') { cur2++; eat_opt_white( &cur2 ); cur = cur2; continue; } else break; } } if (j < 4) { decl.Resource.ReturnTypeY = decl.Resource.ReturnTypeZ = decl.Resource.ReturnTypeW = decl.Resource.ReturnTypeX; } ctx->cur = cur; } else { for (i = 0; i < TGSI_SEMANTIC_COUNT; i++) { if (str_match_no_case( &cur, semantic_names[i] )) { const char *cur2 = cur; uint index; if (is_digit_alpha_underscore( cur )) continue; eat_opt_white( &cur2 ); if (*cur2 == '[') { cur2++; eat_opt_white( &cur2 ); if (!parse_uint( &cur2, &index )) { report_error( ctx, "Expected literal integer" ); return FALSE; } eat_opt_white( &cur2 ); if (*cur2 != ']') { report_error( ctx, "Expected `]'" ); return FALSE; } cur2++; decl.Semantic.Index = index; cur = cur2; } decl.Declaration.Semantic = 1; decl.Semantic.Name = i; ctx->cur = cur; break; } } } } else if (is_imm_array) { unsigned i; float *vals_itr; /* we have our immediate data */ if (*cur != '{') { report_error( ctx, "Immediate array without data" ); return FALSE; } ++cur; ctx->cur = cur; decl.ImmediateData.u = MALLOC(sizeof(union tgsi_immediate_data) * 4 * (decl.Range.Last + 1)); vals_itr = (float*)decl.ImmediateData.u; for (i = 0; i <= decl.Range.Last; ++i) { if (!parse_immediate_data(ctx, vals_itr)) { FREE(decl.ImmediateData.u); return FALSE; } vals_itr += 4; eat_opt_white( &ctx->cur ); if (*ctx->cur != ',') { if (i != decl.Range.Last) { report_error( ctx, "Not enough data in immediate array!" ); FREE(decl.ImmediateData.u); return FALSE; } } else ++ctx->cur; } eat_opt_white( &ctx->cur ); if (*ctx->cur != '}') { FREE(decl.ImmediateData.u); report_error( ctx, "Immediate array data missing closing '}'" ); return FALSE; } ++ctx->cur; } cur = ctx->cur; eat_opt_white( &cur ); if (*cur == ',' && !is_vs_input) { uint i; cur++; eat_opt_white( &cur ); for (i = 0; i < TGSI_INTERPOLATE_COUNT; i++) { if (str_match_no_case( &cur, interpolate_names[i] )) { if (is_digit_alpha_underscore( cur )) continue; decl.Declaration.Interpolate = i; ctx->cur = cur; break; } } if (i == TGSI_INTERPOLATE_COUNT) { report_error( ctx, "Expected semantic or interpolate attribute" ); return FALSE; } } advance = tgsi_build_full_declaration( &decl, ctx->tokens_cur, ctx->header, (uint) (ctx->tokens_end - ctx->tokens_cur) ); if (is_imm_array) FREE(decl.ImmediateData.u); if (advance == 0) return FALSE; ctx->tokens_cur += advance; return TRUE; }
static int Integrate(creal epsrel, creal epsabs, cint flags, number mineval, cnumber maxeval, ccount key, real *integral, real *error, real *prob) { TYPEDEFREGION; count dim, comp; int fail = 1; Rule rule; Totals totals[NCOMP]; Region *anchor = NULL, *region = NULL; if( VERBOSE > 1 ) { char s[256]; sprintf(s, "Cuhre input parameters:\n" " ndim " COUNT "\n ncomp " COUNT "\n" " epsrel " REAL "\n epsabs " REAL "\n" " flags %d\n mineval " NUMBER "\n maxeval " NUMBER "\n" " key " COUNT, ndim_, ncomp_, epsrel, epsabs, flags, mineval, maxeval, key); Print(s); } #ifdef MLVERSION if( setjmp(abort_) ) goto abort; #endif if( key == 13 && ndim_ == 2 ) Rule13Alloc(&rule); else if( key == 11 && ndim_ == 3 ) Rule11Alloc(&rule); else if( key == 9 ) Rule9Alloc(&rule); else if( key == 7 ) Rule7Alloc(&rule); else { if( ndim_ == 2 ) Rule13Alloc(&rule); else if( ndim_ == 3 ) Rule11Alloc(&rule); else Rule9Alloc(&rule); } Alloc(rule.x, rule.n*(ndim_ + ncomp_)); rule.f = rule.x + rule.n*ndim_; mineval = IMax(mineval, rule.n + 1); Alloc(anchor, 1); anchor->next = NULL; anchor->div = 0; for( dim = 0; dim < ndim_; ++dim ) { Bounds *b = &anchor->bounds[dim]; b->lower = 0; b->upper = 1; } Sample(&rule, anchor, flags); for( comp = 0; comp < ncomp_; ++comp ) { Totals *tot = &totals[comp]; Result *r = &anchor->result[comp]; tot->avg = tot->lastavg = tot->guess = r->avg; tot->err = tot->lasterr = r->err; tot->weightsum = 1/Max(Sq(r->err), NOTZERO); tot->avgsum = tot->weightsum*r->avg; tot->chisq = tot->chisqsum = tot->chisum = 0; } for( nregions_ = 1; ; ++nregions_ ) { count maxcomp, bisectdim; real maxratio, maxerr; Region *regionL, *regionR, *reg, **parent, **par; Bounds *bL, *bR; if( VERBOSE ) { char s[128 + 128*NCOMP], *p = s; p += sprintf(p, "\n" "Iteration " COUNT ": " NUMBER " integrand evaluations so far", nregions_, neval_); for( comp = 0; comp < ncomp_; ++comp ) { cTotals *tot = &totals[comp]; p += sprintf(p, "\n[" COUNT "] " REAL " +- " REAL " \tchisq " REAL " (" COUNT " df)", comp + 1, tot->avg, tot->err, tot->chisq, nregions_ - 1); } Print(s); } maxratio = -INFTY; maxcomp = 0; for( comp = 0; comp < ncomp_; ++comp ) { creal ratio = totals[comp].err/MaxErr(totals[comp].avg); if( ratio > maxratio ) { maxratio = ratio; maxcomp = comp; } } if( maxratio <= 1 && neval_ >= mineval ) { fail = 0; break; } if( neval_ >= maxeval ) break; maxerr = -INFTY; parent = &anchor; region = anchor; for( par = &anchor; (reg = *par); par = ®->next ) { creal err = reg->result[maxcomp].err; if( err > maxerr ) { maxerr = err; parent = par; region = reg; } } Alloc(regionL, 1); Alloc(regionR, 1); *parent = regionL; regionL->next = regionR; regionR->next = region->next; regionL->div = regionR->div = region->div + 1; VecCopy(regionL->bounds, region->bounds); VecCopy(regionR->bounds, region->bounds); bisectdim = region->result[maxcomp].bisectdim; bL = ®ionL->bounds[bisectdim]; bR = ®ionR->bounds[bisectdim]; bL->upper = bR->lower = .5*(bL->upper + bL->lower); Sample(&rule, regionL, flags); Sample(&rule, regionR, flags); for( comp = 0; comp < ncomp_; ++comp ) { cResult *r = ®ion->result[comp]; Result *rL = ®ionL->result[comp]; Result *rR = ®ionR->result[comp]; Totals *tot = &totals[comp]; real diff, err, w, avg, sigsq; tot->lastavg += diff = rL->avg + rR->avg - r->avg; diff = fabs(.25*diff); err = rL->err + rR->err; if( err > 0 ) { creal c = 1 + 2*diff/err; rL->err *= c; rR->err *= c; } rL->err += diff; rR->err += diff; tot->lasterr += rL->err + rR->err - r->err; tot->weightsum += w = 1/Max(Sq(tot->lasterr), NOTZERO); sigsq = 1/tot->weightsum; tot->avgsum += w*tot->lastavg; avg = sigsq*tot->avgsum; tot->chisum += w *= tot->lastavg - tot->guess; tot->chisqsum += w*tot->lastavg; tot->chisq = tot->chisqsum - avg*tot->chisum; if( LAST ) { tot->avg = tot->lastavg; tot->err = tot->lasterr; } else { tot->avg = avg; tot->err = sqrt(sigsq); } } free(region); region = NULL; } for( comp = 0; comp < ncomp_; ++comp ) { cTotals *tot = &totals[comp]; integral[comp] = tot->avg; error[comp] = tot->err; prob[comp] = ChiSquare(tot->chisq, nregions_ - 1); } #ifdef MLVERSION if( REGIONS ) { MLPutFunction(stdlink, "List", 2); MLPutFunction(stdlink, "List", nregions_); for( region = anchor; region; region = region->next ) { real lower[NDIM], upper[NDIM]; for( dim = 0; dim < ndim_; ++dim ) { cBounds *b = ®ion->bounds[dim]; lower[dim] = b->lower; upper[dim] = b->upper; } MLPutFunction(stdlink, "Cuba`Cuhre`region", 3); MLPutRealList(stdlink, lower, ndim_); MLPutRealList(stdlink, upper, ndim_); MLPutFunction(stdlink, "List", ncomp_); for( comp = 0; comp < ncomp_; ++comp ) { cResult *r = ®ion->result[comp]; real res[] = {r->avg, r->err}; MLPutRealList(stdlink, res, Elements(res)); } } } #endif #ifdef MLVERSION abort: #endif if( region ) free(region); while( (region = anchor) ) { anchor = anchor->next; free(region); } free(rule.x); RuleFree(&rule); return fail; }
/** * Sample the texture/mipmap using given image filter and mip filter. * data0_ptr and data1_ptr point to the two mipmap levels to sample * from. width0/1_vec, height0/1_vec, depth0/1_vec indicate their sizes. * If we're using nearest miplevel sampling the '1' values will be null/unused. */ static void lp_build_sample_mipmap(struct lp_build_sample_context *bld, unsigned img_filter, unsigned mip_filter, LLVMValueRef s, LLVMValueRef t, LLVMValueRef r, LLVMValueRef ilevel0, LLVMValueRef ilevel1, LLVMValueRef lod_fpart, LLVMValueRef colors_lo_var, LLVMValueRef colors_hi_var) { LLVMBuilderRef builder = bld->gallivm->builder; LLVMValueRef size0; LLVMValueRef size1; LLVMValueRef row_stride0_vec; LLVMValueRef row_stride1_vec; LLVMValueRef img_stride0_vec; LLVMValueRef img_stride1_vec; LLVMValueRef data_ptr0; LLVMValueRef data_ptr1; LLVMValueRef colors0_lo, colors0_hi; LLVMValueRef colors1_lo, colors1_hi; /* sample the first mipmap level */ lp_build_mipmap_level_sizes(bld, ilevel0, &size0, &row_stride0_vec, &img_stride0_vec); data_ptr0 = lp_build_get_mipmap_level(bld, ilevel0); if (img_filter == PIPE_TEX_FILTER_NEAREST) { lp_build_sample_image_nearest(bld, size0, row_stride0_vec, img_stride0_vec, data_ptr0, s, t, r, &colors0_lo, &colors0_hi); } else { assert(img_filter == PIPE_TEX_FILTER_LINEAR); lp_build_sample_image_linear(bld, size0, row_stride0_vec, img_stride0_vec, data_ptr0, s, t, r, &colors0_lo, &colors0_hi); } /* Store the first level's colors in the output variables */ LLVMBuildStore(builder, colors0_lo, colors_lo_var); LLVMBuildStore(builder, colors0_hi, colors_hi_var); if (mip_filter == PIPE_TEX_MIPFILTER_LINEAR) { LLVMValueRef h16_scale = lp_build_const_float(bld->gallivm, 256.0); LLVMTypeRef i32_type = LLVMIntTypeInContext(bld->gallivm->context, 32); struct lp_build_if_state if_ctx; LLVMValueRef need_lerp; lod_fpart = LLVMBuildFMul(builder, lod_fpart, h16_scale, ""); lod_fpart = LLVMBuildFPToSI(builder, lod_fpart, i32_type, "lod_fpart.fixed16"); /* need_lerp = lod_fpart > 0 */ need_lerp = LLVMBuildICmp(builder, LLVMIntSGT, lod_fpart, LLVMConstNull(i32_type), "need_lerp"); lp_build_if(&if_ctx, bld->gallivm, need_lerp); { struct lp_build_context h16_bld; lp_build_context_init(&h16_bld, bld->gallivm, lp_type_ufixed(16)); /* sample the second mipmap level */ lp_build_mipmap_level_sizes(bld, ilevel1, &size1, &row_stride1_vec, &img_stride1_vec); data_ptr1 = lp_build_get_mipmap_level(bld, ilevel1); if (img_filter == PIPE_TEX_FILTER_NEAREST) { lp_build_sample_image_nearest(bld, size1, row_stride1_vec, img_stride1_vec, data_ptr1, s, t, r, &colors1_lo, &colors1_hi); } else { lp_build_sample_image_linear(bld, size1, row_stride1_vec, img_stride1_vec, data_ptr1, s, t, r, &colors1_lo, &colors1_hi); } /* interpolate samples from the two mipmap levels */ lod_fpart = LLVMBuildTrunc(builder, lod_fpart, h16_bld.elem_type, ""); lod_fpart = lp_build_broadcast_scalar(&h16_bld, lod_fpart); #if HAVE_LLVM == 0x208 /* This is a work-around for a bug in LLVM 2.8. * Evidently, something goes wrong in the construction of the * lod_fpart short[8] vector. Adding this no-effect shuffle seems * to force the vector to be properly constructed. * Tested with mesa-demos/src/tests/mipmap_limits.c (press t, f). */ { LLVMValueRef shuffles[8], shuffle; int i; assert(h16_bld.type.length <= Elements(shuffles)); for (i = 0; i < h16_bld.type.length; i++) shuffles[i] = lp_build_const_int32(bld->gallivm, 2 * (i & 1)); shuffle = LLVMConstVector(shuffles, h16_bld.type.length); lod_fpart = LLVMBuildShuffleVector(builder, lod_fpart, lod_fpart, shuffle, ""); } #endif colors0_lo = lp_build_lerp(&h16_bld, lod_fpart, colors0_lo, colors1_lo); colors0_hi = lp_build_lerp(&h16_bld, lod_fpart, colors0_hi, colors1_hi); LLVMBuildStore(builder, colors0_lo, colors_lo_var); LLVMBuildStore(builder, colors0_hi, colors_hi_var); } lp_build_endif(&if_ctx); } }
JSObject* CryptoBuffer::ToUint8Array(JSContext* aCx) const { return Uint8Array::Create(aCx, Length(), Elements()); }
JSObject* CryptoBuffer::ToArrayBuffer(JSContext* aCx) const { return ArrayBuffer::Create(aCx, Length(), Elements()); }
/** * Handle state changes. * Called just prior to drawing anything (pipe::draw_arrays(), etc). * * Hopefully this will remain quite simple, otherwise need to pull in * something like the state tracker mechanism. */ void llvmpipe_update_derived( struct llvmpipe_context *llvmpipe ) { struct llvmpipe_screen *lp_screen = llvmpipe_screen(llvmpipe->pipe.screen); /* Check for updated textures. */ if (llvmpipe->tex_timestamp != lp_screen->timestamp) { llvmpipe->tex_timestamp = lp_screen->timestamp; llvmpipe->dirty |= LP_NEW_SAMPLER_VIEW; } if (llvmpipe->dirty & (LP_NEW_RASTERIZER | LP_NEW_FS | LP_NEW_VS)) compute_vertex_info( llvmpipe ); if (llvmpipe->dirty & (LP_NEW_FS | LP_NEW_FRAMEBUFFER | LP_NEW_BLEND | LP_NEW_SCISSOR | LP_NEW_DEPTH_STENCIL_ALPHA | LP_NEW_RASTERIZER | LP_NEW_SAMPLER | LP_NEW_SAMPLER_VIEW | LP_NEW_OCCLUSION_QUERY)) llvmpipe_update_fs( llvmpipe ); if (llvmpipe->dirty & (LP_NEW_FS | LP_NEW_RASTERIZER)) llvmpipe_update_setup( llvmpipe ); if (llvmpipe->dirty & LP_NEW_BLEND_COLOR) lp_setup_set_blend_color(llvmpipe->setup, &llvmpipe->blend_color); if (llvmpipe->dirty & LP_NEW_SCISSOR) lp_setup_set_scissors(llvmpipe->setup, llvmpipe->scissors); if (llvmpipe->dirty & LP_NEW_DEPTH_STENCIL_ALPHA) { lp_setup_set_alpha_ref_value(llvmpipe->setup, llvmpipe->depth_stencil->alpha.ref_value); lp_setup_set_stencil_ref_values(llvmpipe->setup, llvmpipe->stencil_ref.ref_value); } if (llvmpipe->dirty & LP_NEW_CONSTANTS) lp_setup_set_fs_constants(llvmpipe->setup, Elements(llvmpipe->constants[PIPE_SHADER_FRAGMENT]), llvmpipe->constants[PIPE_SHADER_FRAGMENT]); if (llvmpipe->dirty & (LP_NEW_SAMPLER_VIEW)) lp_setup_set_fragment_sampler_views(llvmpipe->setup, llvmpipe->num_sampler_views[PIPE_SHADER_FRAGMENT], llvmpipe->sampler_views[PIPE_SHADER_FRAGMENT]); if (llvmpipe->dirty & (LP_NEW_SAMPLER)) lp_setup_set_fragment_sampler_state(llvmpipe->setup, llvmpipe->num_samplers[PIPE_SHADER_FRAGMENT], llvmpipe->samplers[PIPE_SHADER_FRAGMENT]); llvmpipe->dirty = 0; }
/** * Translate a geometry program to create a new variant. */ static struct st_gp_variant * st_translate_geometry_program(struct st_context *st, struct st_geometry_program *stgp, const struct st_gp_variant_key *key) { GLuint inputMapping[VARYING_SLOT_MAX]; GLuint outputMapping[VARYING_SLOT_MAX]; struct pipe_context *pipe = st->pipe; GLuint attr; GLbitfield64 inputsRead; GLuint vslot = 0; uint gs_num_inputs = 0; uint gs_builtin_inputs = 0; uint gs_array_offset = 0; ubyte gs_output_semantic_name[PIPE_MAX_SHADER_OUTPUTS]; ubyte gs_output_semantic_index[PIPE_MAX_SHADER_OUTPUTS]; uint gs_num_outputs = 0; GLint i; GLuint maxSlot = 0; struct ureg_program *ureg; struct st_gp_variant *gpv; gpv = CALLOC_STRUCT(st_gp_variant); if (!gpv) return NULL; if (!stgp->glsl_to_tgsi) { _mesa_remove_output_reads(&stgp->Base.Base, PROGRAM_OUTPUT); } ureg = ureg_create( TGSI_PROCESSOR_GEOMETRY ); if (ureg == NULL) { free(gpv); return NULL; } /* which vertex output goes to the first geometry input */ vslot = 0; memset(inputMapping, 0, sizeof(inputMapping)); memset(outputMapping, 0, sizeof(outputMapping)); /* * Convert Mesa program inputs to TGSI input register semantics. */ inputsRead = stgp->Base.Base.InputsRead; for (attr = 0; attr < VARYING_SLOT_MAX; attr++) { if ((inputsRead & BITFIELD64_BIT(attr)) != 0) { const GLuint slot = gs_num_inputs; gs_num_inputs++; inputMapping[attr] = slot; stgp->input_map[slot + gs_array_offset] = vslot - gs_builtin_inputs; stgp->input_to_index[attr] = vslot; stgp->index_to_input[vslot] = attr; ++vslot; if (attr != VARYING_SLOT_PRIMITIVE_ID) { gs_array_offset += 2; } else ++gs_builtin_inputs; #if 0 debug_printf("input map at %d = %d\n", slot + gs_array_offset, stgp->input_map[slot + gs_array_offset]); #endif switch (attr) { case VARYING_SLOT_PRIMITIVE_ID: stgp->input_semantic_name[slot] = TGSI_SEMANTIC_PRIMID; stgp->input_semantic_index[slot] = 0; break; case VARYING_SLOT_POS: stgp->input_semantic_name[slot] = TGSI_SEMANTIC_POSITION; stgp->input_semantic_index[slot] = 0; break; case VARYING_SLOT_COL0: stgp->input_semantic_name[slot] = TGSI_SEMANTIC_COLOR; stgp->input_semantic_index[slot] = 0; break; case VARYING_SLOT_COL1: stgp->input_semantic_name[slot] = TGSI_SEMANTIC_COLOR; stgp->input_semantic_index[slot] = 1; break; case VARYING_SLOT_FOGC: stgp->input_semantic_name[slot] = TGSI_SEMANTIC_FOG; stgp->input_semantic_index[slot] = 0; break; case VARYING_SLOT_CLIP_VERTEX: stgp->input_semantic_name[slot] = TGSI_SEMANTIC_CLIPVERTEX; stgp->input_semantic_index[slot] = 0; break; case VARYING_SLOT_CLIP_DIST0: stgp->input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST; stgp->input_semantic_index[slot] = 0; break; case VARYING_SLOT_CLIP_DIST1: stgp->input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST; stgp->input_semantic_index[slot] = 1; break; case VARYING_SLOT_PSIZ: stgp->input_semantic_name[slot] = TGSI_SEMANTIC_PSIZE; stgp->input_semantic_index[slot] = 0; break; case VARYING_SLOT_TEX0: case VARYING_SLOT_TEX1: case VARYING_SLOT_TEX2: case VARYING_SLOT_TEX3: case VARYING_SLOT_TEX4: case VARYING_SLOT_TEX5: case VARYING_SLOT_TEX6: case VARYING_SLOT_TEX7: stgp->input_semantic_name[slot] = st->needs_texcoord_semantic ? TGSI_SEMANTIC_TEXCOORD : TGSI_SEMANTIC_GENERIC; stgp->input_semantic_index[slot] = (attr - VARYING_SLOT_TEX0); break; case VARYING_SLOT_VAR0: default: assert(attr >= VARYING_SLOT_VAR0 && attr < VARYING_SLOT_MAX); stgp->input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC; stgp->input_semantic_index[slot] = st->needs_texcoord_semantic ? (attr - VARYING_SLOT_VAR0) : (attr - VARYING_SLOT_TEX0); break; } } } /* initialize output semantics to defaults */ for (i = 0; i < PIPE_MAX_SHADER_OUTPUTS; i++) { gs_output_semantic_name[i] = TGSI_SEMANTIC_GENERIC; gs_output_semantic_index[i] = 0; } /* * Determine number of outputs, the (default) output register * mapping and the semantic information for each output. */ for (attr = 0; attr < VARYING_SLOT_MAX; attr++) { if (stgp->Base.Base.OutputsWritten & BITFIELD64_BIT(attr)) { GLuint slot; slot = gs_num_outputs; gs_num_outputs++; outputMapping[attr] = slot; switch (attr) { case VARYING_SLOT_POS: assert(slot == 0); gs_output_semantic_name[slot] = TGSI_SEMANTIC_POSITION; gs_output_semantic_index[slot] = 0; break; case VARYING_SLOT_COL0: gs_output_semantic_name[slot] = TGSI_SEMANTIC_COLOR; gs_output_semantic_index[slot] = 0; break; case VARYING_SLOT_COL1: gs_output_semantic_name[slot] = TGSI_SEMANTIC_COLOR; gs_output_semantic_index[slot] = 1; break; case VARYING_SLOT_BFC0: gs_output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR; gs_output_semantic_index[slot] = 0; break; case VARYING_SLOT_BFC1: gs_output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR; gs_output_semantic_index[slot] = 1; break; case VARYING_SLOT_FOGC: gs_output_semantic_name[slot] = TGSI_SEMANTIC_FOG; gs_output_semantic_index[slot] = 0; break; case VARYING_SLOT_PSIZ: gs_output_semantic_name[slot] = TGSI_SEMANTIC_PSIZE; gs_output_semantic_index[slot] = 0; break; case VARYING_SLOT_CLIP_VERTEX: gs_output_semantic_name[slot] = TGSI_SEMANTIC_CLIPVERTEX; gs_output_semantic_index[slot] = 0; break; case VARYING_SLOT_CLIP_DIST0: gs_output_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST; gs_output_semantic_index[slot] = 0; break; case VARYING_SLOT_CLIP_DIST1: gs_output_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST; gs_output_semantic_index[slot] = 1; break; case VARYING_SLOT_LAYER: gs_output_semantic_name[slot] = TGSI_SEMANTIC_LAYER; gs_output_semantic_index[slot] = 0; break; case VARYING_SLOT_PRIMITIVE_ID: gs_output_semantic_name[slot] = TGSI_SEMANTIC_PRIMID; gs_output_semantic_index[slot] = 0; break; case VARYING_SLOT_VIEWPORT: gs_output_semantic_name[slot] = TGSI_SEMANTIC_VIEWPORT_INDEX; gs_output_semantic_index[slot] = 0; break; case VARYING_SLOT_TEX0: case VARYING_SLOT_TEX1: case VARYING_SLOT_TEX2: case VARYING_SLOT_TEX3: case VARYING_SLOT_TEX4: case VARYING_SLOT_TEX5: case VARYING_SLOT_TEX6: case VARYING_SLOT_TEX7: gs_output_semantic_name[slot] = st->needs_texcoord_semantic ? TGSI_SEMANTIC_TEXCOORD : TGSI_SEMANTIC_GENERIC; gs_output_semantic_index[slot] = (attr - VARYING_SLOT_TEX0); break; case VARYING_SLOT_VAR0: default: assert(slot < Elements(gs_output_semantic_name)); assert(attr >= VARYING_SLOT_VAR0); gs_output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC; gs_output_semantic_index[slot] = st->needs_texcoord_semantic ? (attr - VARYING_SLOT_VAR0) : (attr - VARYING_SLOT_TEX0); break; } } } /* find max output slot referenced to compute gs_num_outputs */ for (attr = 0; attr < VARYING_SLOT_MAX; attr++) { if (outputMapping[attr] != ~0 && outputMapping[attr] > maxSlot) maxSlot = outputMapping[attr]; } gs_num_outputs = maxSlot + 1; #if 0 /* debug */ { GLuint i; printf("outputMapping? %d\n", outputMapping ? 1 : 0); if (outputMapping) { printf("attr -> slot\n"); for (i = 0; i < 16; i++) { printf(" %2d %3d\n", i, outputMapping[i]); } } printf("slot sem_name sem_index\n"); for (i = 0; i < gs_num_outputs; i++) { printf(" %2d %d %d\n", i, gs_output_semantic_name[i], gs_output_semantic_index[i]); } } #endif /* free old shader state, if any */ if (stgp->tgsi.tokens) { st_free_tokens(stgp->tgsi.tokens); stgp->tgsi.tokens = NULL; } ureg_property_gs_input_prim(ureg, stgp->Base.InputType); ureg_property_gs_output_prim(ureg, stgp->Base.OutputType); ureg_property_gs_max_vertices(ureg, stgp->Base.VerticesOut); ureg_property_gs_invocations(ureg, stgp->Base.Invocations); if (stgp->glsl_to_tgsi) st_translate_program(st->ctx, TGSI_PROCESSOR_GEOMETRY, ureg, stgp->glsl_to_tgsi, &stgp->Base.Base, /* inputs */ gs_num_inputs, inputMapping, stgp->input_semantic_name, stgp->input_semantic_index, NULL, NULL, /* outputs */ gs_num_outputs, outputMapping, gs_output_semantic_name, gs_output_semantic_index, FALSE, FALSE); else st_translate_mesa_program(st->ctx, TGSI_PROCESSOR_GEOMETRY, ureg, &stgp->Base.Base, /* inputs */ gs_num_inputs, inputMapping, stgp->input_semantic_name, stgp->input_semantic_index, NULL, /* outputs */ gs_num_outputs, outputMapping, gs_output_semantic_name, gs_output_semantic_index, FALSE, FALSE); stgp->num_inputs = gs_num_inputs; stgp->tgsi.tokens = ureg_get_tokens( ureg, NULL ); ureg_destroy( ureg ); if (stgp->glsl_to_tgsi) { st_translate_stream_output_info(stgp->glsl_to_tgsi, outputMapping, &stgp->tgsi.stream_output); } /* fill in new variant */ gpv->driver_shader = pipe->create_gs_state(pipe, &stgp->tgsi); gpv->key = *key; if ((ST_DEBUG & DEBUG_TGSI) && (ST_DEBUG & DEBUG_MESA)) { _mesa_print_program(&stgp->Base.Base); debug_printf("\n"); } if (ST_DEBUG & DEBUG_TGSI) { tgsi_dump(stgp->tgsi.tokens, 0); debug_printf("\n"); } return gpv; }
#include "piglit-framework.h" #include "piglit-util.h" #include "rg-teximage-common.h" #define WIDTH 256 #define HEIGHT 256 static float rgba_image[4 * WIDTH * HEIGHT]; static const GLenum internal_formats[] = { GL_COMPRESSED_RG_RGTC2, GL_COMPRESSED_SIGNED_RG_RGTC2, GL_RG, GL_RGBA, }; GLuint tex[Elements(internal_formats)]; const unsigned num_tex = Elements(tex); GLboolean pass = GL_TRUE; int piglit_width = WIDTH * Elements(tex); int piglit_height = HEIGHT; int piglit_window_mode = GLUT_RGB | GLUT_DOUBLE; void piglit_init(int argc, char **argv) { unsigned i; GLfloat result[4 * WIDTH * HEIGHT]; piglit_require_extension("GL_ARB_texture_compression_rgtc");
/** * Do additional "completeness" testing of a framebuffer object. */ static void intel_validate_framebuffer(struct gl_context *ctx, struct gl_framebuffer *fb) { struct intel_context *intel = intel_context(ctx); const struct intel_renderbuffer *depthRb = intel_get_renderbuffer(fb, BUFFER_DEPTH); const struct intel_renderbuffer *stencilRb = intel_get_renderbuffer(fb, BUFFER_STENCIL); struct intel_mipmap_tree *depth_mt = NULL, *stencil_mt = NULL; int i; DBG("%s() on fb %p (%s)\n", __FUNCTION__, fb, (fb == ctx->DrawBuffer ? "drawbuffer" : (fb == ctx->ReadBuffer ? "readbuffer" : "other buffer"))); if (depthRb) depth_mt = depthRb->mt; if (stencilRb) { stencil_mt = stencilRb->mt; if (stencil_mt->stencil_mt) stencil_mt = stencil_mt->stencil_mt; } if (depth_mt && stencil_mt) { if (depth_mt == stencil_mt) { /* For true packed depth/stencil (not faked on prefers-separate-stencil * hardware) we need to be sure they're the same level/layer, since * we'll be emitting a single packet describing the packed setup. */ if (depthRb->mt_level != stencilRb->mt_level || depthRb->mt_layer != stencilRb->mt_layer) { DBG("depth image level/layer %d/%d != stencil image %d/%d\n", depthRb->mt_level, depthRb->mt_layer, stencilRb->mt_level, stencilRb->mt_layer); fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT; } } else { if (!intel->has_separate_stencil) { DBG("separate stencil unsupported\n"); fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT; } if (stencil_mt->format != MESA_FORMAT_S8) { DBG("separate stencil is %s instead of S8\n", _mesa_get_format_name(stencil_mt->format)); fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT; } if (intel->gen < 7 && depth_mt->hiz_mt == NULL) { /* Before Gen7, separate depth and stencil buffers can be used * only if HiZ is enabled. From the Sandybridge PRM, Volume 2, * Part 1, Bit 3DSTATE_DEPTH_BUFFER.SeparateStencilBufferEnable: * [DevSNB]: This field must be set to the same value (enabled * or disabled) as Hierarchical Depth Buffer Enable. */ DBG("separate stencil without HiZ\n"); fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED; } } } for (i = 0; i < Elements(fb->Attachment); i++) { struct gl_renderbuffer *rb; struct intel_renderbuffer *irb; if (fb->Attachment[i].Type == GL_NONE) continue; /* A supported attachment will have a Renderbuffer set either * from being a Renderbuffer or being a texture that got the * intel_wrap_texture() treatment. */ rb = fb->Attachment[i].Renderbuffer; if (rb == NULL) { DBG("attachment without renderbuffer\n"); fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT; continue; } if (fb->Attachment[i].Type == GL_TEXTURE) { const struct gl_texture_image *img = _mesa_get_attachment_teximage_const(&fb->Attachment[i]); if (img->Border) { DBG("texture with border\n"); fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT; continue; } } irb = intel_renderbuffer(rb); if (irb == NULL) { DBG("software rendering renderbuffer\n"); fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT; continue; } if (!intel->vtbl.render_target_supported(intel, rb)) { DBG("Unsupported HW texture/renderbuffer format attached: %s\n", _mesa_get_format_name(intel_rb_format(irb))); fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT; } } }
/** * Emit instructions to move sampling parameters to the message registers. */ static int vs_add_sampler_params(struct toy_compiler *tc, int msg_type, int base_mrf, struct toy_src coords, int num_coords, struct toy_src bias_or_lod, struct toy_src ref_or_si, struct toy_src ddx, struct toy_src ddy, int num_derivs) { const unsigned coords_writemask = (1 << num_coords) - 1; struct toy_dst m[3]; int num_params, i; assert(num_coords <= 4); assert(num_derivs <= 3 && num_derivs <= num_coords); for (i = 0; i < Elements(m); i++) m[i] = tdst(TOY_FILE_MRF, base_mrf + i, 0); switch (msg_type) { case GEN6_MSG_SAMPLER_SAMPLE_L: tc_MOV(tc, tdst_writemask(m[0], coords_writemask), coords); tc_MOV(tc, tdst_writemask(m[1], TOY_WRITEMASK_X), bias_or_lod); num_params = 5; break; case GEN6_MSG_SAMPLER_SAMPLE_D: tc_MOV(tc, tdst_writemask(m[0], coords_writemask), coords); tc_MOV(tc, tdst_writemask(m[1], TOY_WRITEMASK_XZ), tsrc_swizzle(ddx, 0, 0, 1, 1)); tc_MOV(tc, tdst_writemask(m[1], TOY_WRITEMASK_YW), tsrc_swizzle(ddy, 0, 0, 1, 1)); if (num_derivs > 2) { tc_MOV(tc, tdst_writemask(m[2], TOY_WRITEMASK_X), tsrc_swizzle1(ddx, 2)); tc_MOV(tc, tdst_writemask(m[2], TOY_WRITEMASK_Y), tsrc_swizzle1(ddy, 2)); } num_params = 4 + num_derivs * 2; break; case GEN6_MSG_SAMPLER_SAMPLE_L_C: tc_MOV(tc, tdst_writemask(m[0], coords_writemask), coords); tc_MOV(tc, tdst_writemask(m[1], TOY_WRITEMASK_X), ref_or_si); tc_MOV(tc, tdst_writemask(m[1], TOY_WRITEMASK_Y), bias_or_lod); num_params = 6; break; case GEN6_MSG_SAMPLER_LD: assert(num_coords <= 3); tc_MOV(tc, tdst_writemask(tdst_d(m[0]), coords_writemask), coords); tc_MOV(tc, tdst_writemask(tdst_d(m[0]), TOY_WRITEMASK_W), bias_or_lod); if (tc->dev->gen >= ILO_GEN(7)) { num_params = 4; } else { tc_MOV(tc, tdst_writemask(tdst_d(m[1]), TOY_WRITEMASK_X), ref_or_si); num_params = 5; } break; case GEN6_MSG_SAMPLER_RESINFO: tc_MOV(tc, tdst_writemask(tdst_d(m[0]), TOY_WRITEMASK_X), bias_or_lod); num_params = 1; break; default: tc_fail(tc, "unknown sampler opcode"); num_params = 0; break; } return (num_params + 3) / 4; }
static boolean drm_display_program(struct native_display *ndpy, int crtc_idx, struct native_surface *nsurf, uint x, uint y, const struct native_connector **nconns, int num_nconns, const struct native_mode *nmode) { struct drm_display *drmdpy = drm_display(ndpy); struct drm_surface *drmsurf = drm_surface(nsurf); const struct drm_mode *drmmode = drm_mode(nmode); uint32_t connector_ids[32]; uint32_t buffer_id; drmModeModeInfo mode_tmp, *mode; int i; if (num_nconns > Elements(connector_ids)) { _eglLog(_EGL_WARNING, "too many connectors (%d)", num_nconns); num_nconns = Elements(connector_ids); } if (drmsurf) { if (!drm_surface_init_framebuffers(&drmsurf->base, FALSE)) return FALSE; buffer_id = drmsurf->front_fb.buffer_id; /* the mode argument of drmModeSetCrtc is not constified */ mode_tmp = drmmode->mode; mode = &mode_tmp; } else { /* disable the CRTC */ buffer_id = 0; mode = NULL; num_nconns = 0; } for (i = 0; i < num_nconns; i++) { struct drm_connector *drmconn = drm_connector(nconns[i]); connector_ids[i] = drmconn->connector->connector_id; } if (!drm_display_set_crtc(&drmdpy->base, crtc_idx, buffer_id, x, y, connector_ids, num_nconns, mode)) { _eglLog(_EGL_WARNING, "failed to set CRTC %d", crtc_idx); return FALSE; } if (drmdpy->shown_surfaces[crtc_idx]) drmdpy->shown_surfaces[crtc_idx]->is_shown = FALSE; drmdpy->shown_surfaces[crtc_idx] = drmsurf; /* remember the settings for buffer swapping */ if (drmsurf) { uint32_t crtc_id = drmdpy->saved_crtcs[crtc_idx].crtc->crtc_id; struct drm_crtc *drmcrtc = &drmsurf->current_crtc; if (drmcrtc->crtc) drmModeFreeCrtc(drmcrtc->crtc); drmcrtc->crtc = drmModeGetCrtc(drmdpy->fd, crtc_id); assert(num_nconns < Elements(drmcrtc->connectors)); memcpy(drmcrtc->connectors, connector_ids, sizeof(*connector_ids) * num_nconns); drmcrtc->num_connectors = num_nconns; drmsurf->is_shown = TRUE; } return TRUE; }
static void transform_inst(struct tgsi_transform_context *ctx, struct tgsi_full_instruction *inst) { struct vs_transform_context *vsctx = (struct vs_transform_context *) ctx; struct tgsi_full_instruction new_inst; unsigned i; if (!vsctx->first_instruction) { vsctx->first_instruction = TRUE; /* Insert the generic output for WPOS. */ emit_output(ctx, TGSI_SEMANTIC_GENERIC, vsctx->last_generic + 1, TGSI_INTERPOLATE_PERSPECTIVE, vsctx->num_outputs); /* Find a free temp for POSITION. */ for (i = 0; i < Elements(vsctx->temp_used); i++) { if (!vsctx->temp_used[i]) { emit_temp(ctx, i); vsctx->pos_temp = i; break; } } } if (inst->Instruction.Opcode == TGSI_OPCODE_END) { /* MOV OUT[pos_output], TEMP[pos_temp]; */ new_inst = tgsi_default_full_instruction(); new_inst.Instruction.Opcode = TGSI_OPCODE_MOV; new_inst.Instruction.NumDstRegs = 1; new_inst.Dst[0].Register.File = TGSI_FILE_OUTPUT; new_inst.Dst[0].Register.Index = vsctx->pos_output; new_inst.Dst[0].Register.WriteMask = TGSI_WRITEMASK_XYZW; new_inst.Instruction.NumSrcRegs = 1; new_inst.Src[0].Register.File = TGSI_FILE_TEMPORARY; new_inst.Src[0].Register.Index = vsctx->pos_temp; ctx->emit_instruction(ctx, &new_inst); /* MOV OUT[n-1], TEMP[pos_temp]; */ new_inst = tgsi_default_full_instruction(); new_inst.Instruction.Opcode = TGSI_OPCODE_MOV; new_inst.Instruction.NumDstRegs = 1; new_inst.Dst[0].Register.File = TGSI_FILE_OUTPUT; new_inst.Dst[0].Register.Index = vsctx->num_outputs - 1; new_inst.Dst[0].Register.WriteMask = TGSI_WRITEMASK_XYZW; new_inst.Instruction.NumSrcRegs = 1; new_inst.Src[0].Register.File = TGSI_FILE_TEMPORARY; new_inst.Src[0].Register.Index = vsctx->pos_temp; ctx->emit_instruction(ctx, &new_inst); vsctx->end_instruction = TRUE; } else { /* Not an END instruction. */ /* Fix writes to outputs. */ for (i = 0; i < inst->Instruction.NumDstRegs; i++) { struct tgsi_full_dst_register *dst = &inst->Dst[i]; if (dst->Register.File == TGSI_FILE_OUTPUT) { if (dst->Register.Index == vsctx->pos_output) { /* Replace writes to OUT[pos_output] with TEMP[pos_temp]. */ dst->Register.File = TGSI_FILE_TEMPORARY; dst->Register.Index = vsctx->pos_temp; } else { /* Not a position, good... * Since we were changing the indices of output decls, * we must redirect writes into them too. */ dst->Register.Index = vsctx->out_remap[dst->Register.Index]; } } } /* Inserting 2 instructions before the END opcode moves all following * labels by 2. Subroutines are always after the END opcode so * they're always moved. */ if (inst->Instruction.Opcode == TGSI_OPCODE_CAL) { inst->Label.Label += 2; } /* The labels of the following opcodes are moved only after * the END opcode. */ if (vsctx->end_instruction && (inst->Instruction.Opcode == TGSI_OPCODE_IF || inst->Instruction.Opcode == TGSI_OPCODE_ELSE || inst->Instruction.Opcode == TGSI_OPCODE_BGNLOOP || inst->Instruction.Opcode == TGSI_OPCODE_ENDLOOP)) { inst->Label.Label += 2; } } ctx->emit_instruction(ctx, inst); }
/** * Use pipe_screen::get_param() to query PIPE_CAP_ values to determine * which GL extensions are supported. * Quite a few extensions are always supported because they are standard * features or can be built on top of other gallium features. * Some fine tuning may still be needed. */ void st_init_extensions(struct st_context *st) { struct pipe_screen *screen = st->pipe->screen; struct gl_context *ctx = st->ctx; int i, glsl_feature_level; GLboolean *extensions = (GLboolean *) &ctx->Extensions; static const struct st_extension_cap_mapping cap_mapping[] = { { o(ARB_base_instance), PIPE_CAP_START_INSTANCE }, { o(ARB_depth_clamp), PIPE_CAP_DEPTH_CLIP_DISABLE }, { o(ARB_depth_texture), PIPE_CAP_TEXTURE_SHADOW_MAP }, { o(ARB_draw_buffers_blend), PIPE_CAP_INDEP_BLEND_FUNC }, { o(ARB_draw_instanced), PIPE_CAP_TGSI_INSTANCEID }, { o(ARB_fragment_program_shadow), PIPE_CAP_TEXTURE_SHADOW_MAP }, { o(ARB_instanced_arrays), PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR }, { o(ARB_occlusion_query), PIPE_CAP_OCCLUSION_QUERY }, { o(ARB_occlusion_query2), PIPE_CAP_OCCLUSION_QUERY }, { o(ARB_point_sprite), PIPE_CAP_POINT_SPRITE }, { o(ARB_seamless_cube_map), PIPE_CAP_SEAMLESS_CUBE_MAP }, { o(ARB_shader_stencil_export), PIPE_CAP_SHADER_STENCIL_EXPORT }, { o(ARB_shader_texture_lod), PIPE_CAP_SM3 }, { o(ARB_shadow), PIPE_CAP_TEXTURE_SHADOW_MAP }, { o(ARB_texture_mirror_clamp_to_edge), PIPE_CAP_TEXTURE_MIRROR_CLAMP }, { o(ARB_texture_non_power_of_two), PIPE_CAP_NPOT_TEXTURES }, { o(ARB_timer_query), PIPE_CAP_QUERY_TIMESTAMP }, { o(ARB_transform_feedback2), PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME }, { o(ARB_transform_feedback3), PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME }, { o(EXT_blend_equation_separate), PIPE_CAP_BLEND_EQUATION_SEPARATE }, { o(EXT_draw_buffers2), PIPE_CAP_INDEP_BLEND_ENABLE }, { o(EXT_stencil_two_side), PIPE_CAP_TWO_SIDED_STENCIL }, { o(EXT_texture_array), PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS }, { o(EXT_texture_filter_anisotropic), PIPE_CAP_ANISOTROPIC_FILTER }, { o(EXT_texture_mirror_clamp), PIPE_CAP_TEXTURE_MIRROR_CLAMP }, { o(EXT_texture_swizzle), PIPE_CAP_TEXTURE_SWIZZLE }, { o(EXT_transform_feedback), PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS }, { o(AMD_seamless_cubemap_per_texture), PIPE_CAP_SEAMLESS_CUBE_MAP_PER_TEXTURE }, { o(ATI_separate_stencil), PIPE_CAP_TWO_SIDED_STENCIL }, { o(ATI_texture_mirror_once), PIPE_CAP_TEXTURE_MIRROR_CLAMP }, { o(NV_conditional_render), PIPE_CAP_CONDITIONAL_RENDER }, { o(NV_texture_barrier), PIPE_CAP_TEXTURE_BARRIER }, /* GL_NV_point_sprite is not supported by gallium because we don't * support the GL_POINT_SPRITE_R_MODE_NV option. */ { o(MESA_texture_array), PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS }, { o(OES_standard_derivatives), PIPE_CAP_SM3 }, { o(ARB_texture_cube_map_array), PIPE_CAP_CUBE_MAP_ARRAY }, { o(ARB_texture_multisample), PIPE_CAP_TEXTURE_MULTISAMPLE } }; /* Required: render target and sampler support */ static const struct st_extension_format_mapping rendertarget_mapping[] = { { { o(ARB_texture_float) }, { PIPE_FORMAT_R32G32B32A32_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT } }, { { o(ARB_texture_rgb10_a2ui) }, { PIPE_FORMAT_B10G10R10A2_UINT } }, { { o(EXT_framebuffer_sRGB) }, { PIPE_FORMAT_A8B8G8R8_SRGB, PIPE_FORMAT_B8G8R8A8_SRGB }, GL_TRUE }, /* at least one format must be supported */ { { o(EXT_packed_float) }, { PIPE_FORMAT_R11G11B10_FLOAT } }, { { o(EXT_texture_integer) }, { PIPE_FORMAT_R32G32B32A32_UINT, PIPE_FORMAT_R32G32B32A32_SINT } }, { { o(ARB_texture_rg) }, { PIPE_FORMAT_R8_UNORM, PIPE_FORMAT_R8G8_UNORM } }, }; /* Required: depth stencil and sampler support */ static const struct st_extension_format_mapping depthstencil_mapping[] = { { { o(ARB_depth_buffer_float) }, { PIPE_FORMAT_Z32_FLOAT, PIPE_FORMAT_Z32_FLOAT_S8X24_UINT } }, { { o(EXT_packed_depth_stencil) }, { PIPE_FORMAT_S8_UINT_Z24_UNORM, PIPE_FORMAT_Z24_UNORM_S8_UINT }, GL_TRUE }, /* at least one format must be supported */ }; /* Required: sampler support */ static const struct st_extension_format_mapping texture_mapping[] = { { { o(ARB_texture_compression_rgtc) }, { PIPE_FORMAT_RGTC1_UNORM, PIPE_FORMAT_RGTC1_SNORM, PIPE_FORMAT_RGTC2_UNORM, PIPE_FORMAT_RGTC2_SNORM } }, { { o(EXT_texture_compression_latc) }, { PIPE_FORMAT_LATC1_UNORM, PIPE_FORMAT_LATC1_SNORM, PIPE_FORMAT_LATC2_UNORM, PIPE_FORMAT_LATC2_SNORM } }, { { o(EXT_texture_compression_s3tc), o(ANGLE_texture_compression_dxt) }, { PIPE_FORMAT_DXT1_RGB, PIPE_FORMAT_DXT1_RGBA, PIPE_FORMAT_DXT3_RGBA, PIPE_FORMAT_DXT5_RGBA } }, { { o(EXT_texture_shared_exponent) }, { PIPE_FORMAT_R9G9B9E5_FLOAT } }, { { o(EXT_texture_snorm) }, { PIPE_FORMAT_R8G8B8A8_SNORM } }, { { o(EXT_texture_sRGB), o(EXT_texture_sRGB_decode) }, { PIPE_FORMAT_A8B8G8R8_SRGB, PIPE_FORMAT_B8G8R8A8_SRGB }, GL_TRUE }, /* at least one format must be supported */ { { o(ATI_texture_compression_3dc) }, { PIPE_FORMAT_LATC2_UNORM } }, { { o(MESA_ycbcr_texture) }, { PIPE_FORMAT_UYVY, PIPE_FORMAT_YUYV }, GL_TRUE }, /* at least one format must be supported */ { { o(OES_compressed_ETC1_RGB8_texture) }, { PIPE_FORMAT_ETC1_RGB8 } }, }; /* Required: vertex fetch support. */ static const struct st_extension_format_mapping vertex_mapping[] = { { { o(ARB_vertex_type_2_10_10_10_rev) }, { PIPE_FORMAT_R10G10B10A2_UNORM, PIPE_FORMAT_B10G10R10A2_UNORM, PIPE_FORMAT_R10G10B10A2_SNORM, PIPE_FORMAT_B10G10R10A2_SNORM, PIPE_FORMAT_R10G10B10A2_USCALED, PIPE_FORMAT_B10G10R10A2_USCALED, PIPE_FORMAT_R10G10B10A2_SSCALED, PIPE_FORMAT_B10G10R10A2_SSCALED } }, }; static const struct st_extension_format_mapping tbo_rgb32[] = { { {o(ARB_texture_buffer_object_rgb32) }, { PIPE_FORMAT_R32G32B32_FLOAT, PIPE_FORMAT_R32G32B32_UINT, PIPE_FORMAT_R32G32B32_SINT, } }, }; /* * Extensions that are supported by all Gallium drivers: */ ctx->Extensions.ARB_ES2_compatibility = GL_TRUE; ctx->Extensions.ARB_draw_elements_base_vertex = GL_TRUE; ctx->Extensions.ARB_explicit_attrib_location = GL_TRUE; ctx->Extensions.ARB_fragment_coord_conventions = GL_TRUE; ctx->Extensions.ARB_fragment_program = GL_TRUE; ctx->Extensions.ARB_fragment_shader = GL_TRUE; ctx->Extensions.ARB_half_float_pixel = GL_TRUE; ctx->Extensions.ARB_half_float_vertex = GL_TRUE; ctx->Extensions.ARB_internalformat_query = GL_TRUE; ctx->Extensions.ARB_map_buffer_range = GL_TRUE; ctx->Extensions.ARB_texture_border_clamp = GL_TRUE; /* XXX temp */ ctx->Extensions.ARB_texture_cube_map = GL_TRUE; ctx->Extensions.ARB_texture_env_combine = GL_TRUE; ctx->Extensions.ARB_texture_env_crossbar = GL_TRUE; ctx->Extensions.ARB_texture_env_dot3 = GL_TRUE; ctx->Extensions.ARB_vertex_program = GL_TRUE; ctx->Extensions.ARB_vertex_shader = GL_TRUE; ctx->Extensions.EXT_blend_color = GL_TRUE; ctx->Extensions.EXT_blend_func_separate = GL_TRUE; ctx->Extensions.EXT_blend_minmax = GL_TRUE; ctx->Extensions.EXT_framebuffer_blit = GL_TRUE; ctx->Extensions.EXT_gpu_program_parameters = GL_TRUE; ctx->Extensions.EXT_pixel_buffer_object = GL_TRUE; ctx->Extensions.EXT_point_parameters = GL_TRUE; ctx->Extensions.EXT_provoking_vertex = GL_TRUE; /* IMPORTANT: * Don't enable EXT_separate_shader_objects. It disallows a certain * optimization in the GLSL compiler and therefore is considered * harmful. */ ctx->Extensions.EXT_separate_shader_objects = GL_FALSE; ctx->Extensions.EXT_texture_env_dot3 = GL_TRUE; ctx->Extensions.EXT_vertex_array_bgra = GL_TRUE; ctx->Extensions.ATI_texture_env_combine3 = GL_TRUE; ctx->Extensions.MESA_pack_invert = GL_TRUE; ctx->Extensions.NV_fog_distance = GL_TRUE; ctx->Extensions.NV_texture_env_combine4 = GL_TRUE; ctx->Extensions.NV_texture_rectangle = GL_TRUE; ctx->Extensions.NV_vdpau_interop = GL_TRUE; ctx->Extensions.OES_EGL_image = GL_TRUE; ctx->Extensions.OES_EGL_image_external = GL_TRUE; ctx->Extensions.OES_draw_texture = GL_TRUE; /* Expose the extensions which directly correspond to gallium caps. */ for (i = 0; i < Elements(cap_mapping); i++) { if (screen->get_param(screen, cap_mapping[i].cap)) { extensions[cap_mapping[i].extension_offset] = GL_TRUE; } } /* Expose the extensions which directly correspond to gallium formats. */ init_format_extensions(st, rendertarget_mapping, Elements(rendertarget_mapping), PIPE_TEXTURE_2D, PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW); init_format_extensions(st, depthstencil_mapping, Elements(depthstencil_mapping), PIPE_TEXTURE_2D, PIPE_BIND_DEPTH_STENCIL | PIPE_BIND_SAMPLER_VIEW); init_format_extensions(st, texture_mapping, Elements(texture_mapping), PIPE_TEXTURE_2D, PIPE_BIND_SAMPLER_VIEW); init_format_extensions(st, vertex_mapping, Elements(vertex_mapping), PIPE_BUFFER, PIPE_BIND_VERTEX_BUFFER); /* Figure out GLSL support. */ glsl_feature_level = screen->get_param(screen, PIPE_CAP_GLSL_FEATURE_LEVEL); if (glsl_feature_level >= 140) { ctx->Const.GLSLVersion = 140; } else if (glsl_feature_level >= 130) { ctx->Const.GLSLVersion = 130; } else { ctx->Const.GLSLVersion = 120; } _mesa_override_glsl_version(st->ctx); if (st->options.force_glsl_version > 0 && st->options.force_glsl_version <= ctx->Const.GLSLVersion) { ctx->Const.ForceGLSLVersion = st->options.force_glsl_version; } if (ctx->Const.GLSLVersion >= 130) { ctx->Const.NativeIntegers = GL_TRUE; ctx->Const.MaxClipPlanes = 8; /* Extensions that either depend on GLSL 1.30 or are a subset thereof. */ ctx->Extensions.ARB_conservative_depth = GL_TRUE; ctx->Extensions.ARB_shading_language_packing = GL_TRUE; ctx->Extensions.OES_depth_texture_cube_map = GL_TRUE; ctx->Extensions.ARB_shading_language_420pack = GL_TRUE; if (!st->options.disable_shader_bit_encoding) { ctx->Extensions.ARB_shader_bit_encoding = GL_TRUE; } } else { /* Optional integer support for GLSL 1.2. */ if (screen->get_shader_param(screen, PIPE_SHADER_VERTEX, PIPE_SHADER_CAP_INTEGERS) && screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT, PIPE_SHADER_CAP_INTEGERS)) { ctx->Const.NativeIntegers = GL_TRUE; } } /* Below are the cases which cannot be moved into tables easily. */ if (!ctx->Mesa_DXTn && !st->options.force_s3tc_enable) { ctx->Extensions.EXT_texture_compression_s3tc = GL_FALSE; ctx->Extensions.ANGLE_texture_compression_dxt = GL_FALSE; } if (screen->get_shader_param(screen, PIPE_SHADER_GEOMETRY, PIPE_SHADER_CAP_MAX_INSTRUCTIONS) > 0) { #if 0 /* XXX re-enable when GLSL compiler again supports geometry shaders */ ctx->Extensions.ARB_geometry_shader4 = GL_TRUE; #endif } ctx->Extensions.NV_primitive_restart = GL_TRUE; if (!screen->get_param(screen, PIPE_CAP_PRIMITIVE_RESTART)) { ctx->Const.PrimitiveRestartInSoftware = GL_TRUE; } /* ARB_color_buffer_float. */ if (screen->get_param(screen, PIPE_CAP_VERTEX_COLOR_UNCLAMPED)) { ctx->Extensions.ARB_color_buffer_float = GL_TRUE; if (!screen->get_param(screen, PIPE_CAP_VERTEX_COLOR_CLAMPED)) { st->clamp_vert_color_in_shader = TRUE; } if (!screen->get_param(screen, PIPE_CAP_FRAGMENT_COLOR_CLAMPED)) { st->clamp_frag_color_in_shader = 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; } } if (screen->fence_finish) { ctx->Extensions.ARB_sync = GL_TRUE; } /* Maximum sample count. */ for (i = 16; i > 0; --i) { enum pipe_format pformat = st_choose_format(st, GL_RGBA, GL_NONE, GL_NONE, PIPE_TEXTURE_2D, i, PIPE_BIND_RENDER_TARGET, FALSE); if (pformat != PIPE_FORMAT_NONE) { ctx->Const.MaxSamples = i; ctx->Const.MaxColorTextureSamples = i; break; } } for (i = ctx->Const.MaxSamples; i > 0; --i) { enum pipe_format pformat = st_choose_format(st, GL_DEPTH_STENCIL, GL_NONE, GL_NONE, PIPE_TEXTURE_2D, i, PIPE_BIND_DEPTH_STENCIL, FALSE); if (pformat != PIPE_FORMAT_NONE) { ctx->Const.MaxDepthTextureSamples = i; break; } } for (i = ctx->Const.MaxSamples; i > 0; --i) { enum pipe_format pformat = st_choose_format(st, GL_RGBA_INTEGER, GL_NONE, GL_NONE, PIPE_TEXTURE_2D, i, PIPE_BIND_RENDER_TARGET, FALSE); if (pformat != PIPE_FORMAT_NONE) { ctx->Const.MaxIntegerSamples = i; break; } } if (ctx->Const.MaxSamples == 1) { /* one sample doesn't really make sense */ ctx->Const.MaxSamples = 0; } else if (ctx->Const.MaxSamples >= 2) { ctx->Extensions.EXT_framebuffer_multisample = GL_TRUE; ctx->Extensions.EXT_framebuffer_multisample_blit_scaled = GL_TRUE; } if (ctx->Const.MaxDualSourceDrawBuffers > 0 && !st->options.disable_blend_func_extended) ctx->Extensions.ARB_blend_func_extended = GL_TRUE; st->has_time_elapsed = screen->get_param(screen, PIPE_CAP_QUERY_TIME_ELAPSED); if (st->has_time_elapsed || ctx->Extensions.ARB_timer_query) { ctx->Extensions.EXT_timer_query = GL_TRUE; } if (ctx->Extensions.ARB_transform_feedback2 && ctx->Extensions.ARB_draw_instanced) { ctx->Extensions.ARB_transform_feedback_instanced = GL_TRUE; } if (st->options.force_glsl_extensions_warn) ctx->Const.ForceGLSLExtensionsWarn = 1; if (st->options.disable_glsl_line_continuations) ctx->Const.DisableGLSLLineContinuations = 1; ctx->Const.MinMapBufferAlignment = screen->get_param(screen, PIPE_CAP_MIN_MAP_BUFFER_ALIGNMENT); if (ctx->Const.MinMapBufferAlignment >= 64) { ctx->Extensions.ARB_map_buffer_alignment = GL_TRUE; } if (screen->get_param(screen, PIPE_CAP_TEXTURE_BUFFER_OBJECTS)) { ctx->Extensions.ARB_texture_buffer_object = GL_TRUE; ctx->Const.MaxTextureBufferSize = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_BUFFER_SIZE), (1u << 31) - 1); ctx->Const.TextureBufferOffsetAlignment = screen->get_param(screen, PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT); if (ctx->Const.TextureBufferOffsetAlignment) ctx->Extensions.ARB_texture_buffer_range = GL_TRUE; init_format_extensions(st, tbo_rgb32, Elements(tbo_rgb32), PIPE_BUFFER, PIPE_BIND_SAMPLER_VIEW); } if (screen->get_param(screen, PIPE_CAP_MIXED_FRAMEBUFFER_SIZES) && ctx->Extensions.EXT_packed_depth_stencil) { ctx->Extensions.ARB_framebuffer_object = GL_TRUE; } /* Unpacking a varying in the fragment shader costs 1 texture indirection. * If the number of available texture indirections is very limited, then we * prefer to disable varying packing rather than run the risk of varying * packing preventing a shader from running. */ if (screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT, PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS) <= 8) { /* We can't disable varying packing if transform feedback is available, * because transform feedback code assumes a packed varying layout. */ if (!ctx->Extensions.EXT_transform_feedback) ctx->Const.DisableVaryingPacking = GL_TRUE; } }
void r300_draw_init_vertex_shader(struct r300_context *r300, struct r300_vertex_shader *vs) { struct draw_context *draw = r300->draw; struct pipe_shader_state new_vs; struct tgsi_shader_info info; struct vs_transform_context transform; const uint newLen = tgsi_num_tokens(vs->state.tokens) + 100 /* XXX */; unsigned i; tgsi_scan_shader(vs->state.tokens, &info); new_vs.tokens = tgsi_alloc_tokens(newLen); if (new_vs.tokens == NULL) return; memset(&transform, 0, sizeof(transform)); for (i = 0; i < Elements(transform.out_remap); i++) { transform.out_remap[i] = i; } transform.last_generic = -1; transform.base.transform_instruction = transform_inst; transform.base.transform_declaration = transform_decl; for (i = 0; i < info.num_outputs; i++) { unsigned index = info.output_semantic_index[i]; switch (info.output_semantic_name[i]) { case TGSI_SEMANTIC_COLOR: assert(index < 2); transform.color_used[index] = TRUE; break; case TGSI_SEMANTIC_BCOLOR: assert(index < 2); transform.bcolor_used[index] = TRUE; break; } } tgsi_transform_shader(vs->state.tokens, (struct tgsi_token*)new_vs.tokens, newLen, &transform.base); #if 0 printf("----------------------------------------------\norig shader:\n"); tgsi_dump(vs->state.tokens, 0); printf("----------------------------------------------\nnew shader:\n"); tgsi_dump(new_vs.tokens, 0); printf("----------------------------------------------\n"); #endif /* Free old tokens. */ FREE((void*)vs->state.tokens); vs->draw_vs = draw_create_vertex_shader(draw, &new_vs); /* Instead of duplicating and freeing the tokens, copy the pointer directly. */ vs->state.tokens = new_vs.tokens; /* Init the VS output table for the rasterizer. */ r300_init_vs_outputs(r300, vs); /* Make the last generic be WPOS. */ vs->outputs.wpos = vs->outputs.generic[transform.last_generic + 1]; vs->outputs.generic[transform.last_generic + 1] = ATTR_UNUSED; }
const char *ir_expression::operator_string(ir_expression_operation op) { assert((unsigned int) op < Elements(operator_strs)); assert(Elements(operator_strs) == (ir_quadop_vector + 1)); return operator_strs[op]; }
/** * Use pipe_screen::get_param() to query PIPE_CAP_ values to determine * which GL extensions are supported. * Quite a few extensions are always supported because they are standard * features or can be built on top of other gallium features. * Some fine tuning may still be needed. */ void st_init_extensions(struct st_context *st) { struct pipe_screen *screen = st->pipe->screen; struct gl_context *ctx = st->ctx; int i, glsl_feature_level; GLboolean *extensions = (GLboolean *) &ctx->Extensions; static const struct st_extension_cap_mapping cap_mapping[] = { { o(ARB_base_instance), PIPE_CAP_START_INSTANCE }, { o(ARB_depth_clamp), PIPE_CAP_DEPTH_CLIP_DISABLE }, { o(ARB_depth_texture), PIPE_CAP_TEXTURE_SHADOW_MAP }, { o(ARB_draw_buffers_blend), PIPE_CAP_INDEP_BLEND_FUNC }, { o(ARB_draw_instanced), PIPE_CAP_TGSI_INSTANCEID }, { o(ARB_fragment_program_shadow), PIPE_CAP_TEXTURE_SHADOW_MAP }, { o(ARB_instanced_arrays), PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR }, { o(ARB_occlusion_query), PIPE_CAP_OCCLUSION_QUERY }, { o(ARB_occlusion_query2), PIPE_CAP_OCCLUSION_QUERY }, { o(ARB_point_sprite), PIPE_CAP_POINT_SPRITE }, { o(ARB_seamless_cube_map), PIPE_CAP_SEAMLESS_CUBE_MAP }, { o(ARB_shader_stencil_export), PIPE_CAP_SHADER_STENCIL_EXPORT }, { o(ARB_shader_texture_lod), PIPE_CAP_SM3 }, { o(ARB_shadow), PIPE_CAP_TEXTURE_SHADOW_MAP }, { o(ARB_texture_non_power_of_two), PIPE_CAP_NPOT_TEXTURES }, { o(ARB_transform_feedback2), PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME }, { o(EXT_blend_equation_separate), PIPE_CAP_BLEND_EQUATION_SEPARATE }, { o(EXT_draw_buffers2), PIPE_CAP_INDEP_BLEND_ENABLE }, { o(EXT_shadow_funcs), PIPE_CAP_TEXTURE_SHADOW_MAP }, { o(EXT_stencil_two_side), PIPE_CAP_TWO_SIDED_STENCIL }, { o(EXT_texture_array), PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS }, { o(EXT_texture_filter_anisotropic), PIPE_CAP_ANISOTROPIC_FILTER }, { o(EXT_texture_mirror_clamp), PIPE_CAP_TEXTURE_MIRROR_CLAMP }, { o(EXT_texture_swizzle), PIPE_CAP_TEXTURE_SWIZZLE }, { o(EXT_timer_query), PIPE_CAP_TIMER_QUERY }, { o(EXT_transform_feedback), PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS }, { o(AMD_seamless_cubemap_per_texture), PIPE_CAP_SEAMLESS_CUBE_MAP_PER_TEXTURE }, { o(ATI_separate_stencil), PIPE_CAP_TWO_SIDED_STENCIL }, { o(ATI_texture_mirror_once), PIPE_CAP_TEXTURE_MIRROR_CLAMP }, { o(NV_conditional_render), PIPE_CAP_CONDITIONAL_RENDER }, { o(NV_texture_barrier), PIPE_CAP_TEXTURE_BARRIER }, /* GL_NV_point_sprite is not supported by gallium because we don't * support the GL_POINT_SPRITE_R_MODE_NV option. */ { o(MESA_texture_array), PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS }, }; /* Required: render target and sampler support */ static const struct st_extension_format_mapping rendertarget_mapping[] = { { { o(ARB_texture_float) }, { PIPE_FORMAT_R32G32B32A32_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT } }, { { o(ARB_texture_rgb10_a2ui) }, { PIPE_FORMAT_B10G10R10A2_UINT } }, { { o(EXT_framebuffer_sRGB) }, { PIPE_FORMAT_A8B8G8R8_SRGB, PIPE_FORMAT_B8G8R8A8_SRGB }, GL_TRUE }, /* at least one format must be supported */ { { o(EXT_packed_float) }, { PIPE_FORMAT_R11G11B10_FLOAT } }, { { o(EXT_texture_integer) }, { PIPE_FORMAT_R32G32B32A32_UINT, PIPE_FORMAT_R32G32B32A32_SINT } }, }; /* Required: depth stencil and sampler support */ static const struct st_extension_format_mapping depthstencil_mapping[] = { { { o(ARB_depth_buffer_float) }, { PIPE_FORMAT_Z32_FLOAT, PIPE_FORMAT_Z32_FLOAT_S8X24_UINT } }, { { o(ARB_framebuffer_object), o(EXT_packed_depth_stencil) }, { PIPE_FORMAT_S8_UINT_Z24_UNORM, PIPE_FORMAT_Z24_UNORM_S8_UINT }, GL_TRUE }, /* at least one format must be supported */ }; /* Required: sampler support */ static const struct st_extension_format_mapping texture_mapping[] = { { { o(ARB_texture_compression_rgtc) }, { PIPE_FORMAT_RGTC1_UNORM, PIPE_FORMAT_RGTC1_SNORM, PIPE_FORMAT_RGTC2_UNORM, PIPE_FORMAT_RGTC2_SNORM } }, { { o(ARB_texture_rg) }, { PIPE_FORMAT_R8G8_UNORM } }, { { o(EXT_texture_compression_latc) }, { PIPE_FORMAT_LATC1_UNORM, PIPE_FORMAT_LATC1_SNORM, PIPE_FORMAT_LATC2_UNORM, PIPE_FORMAT_LATC2_SNORM } }, { { o(EXT_texture_compression_s3tc), o(S3_s3tc) }, { PIPE_FORMAT_DXT1_RGB, PIPE_FORMAT_DXT1_RGBA, PIPE_FORMAT_DXT3_RGBA, PIPE_FORMAT_DXT5_RGBA } }, { { o(EXT_texture_shared_exponent) }, { PIPE_FORMAT_R9G9B9E5_FLOAT } }, { { o(EXT_texture_snorm) }, { PIPE_FORMAT_R8G8B8A8_SNORM } }, { { o(EXT_texture_sRGB), o(EXT_texture_sRGB_decode) }, { PIPE_FORMAT_A8B8G8R8_SRGB, PIPE_FORMAT_B8G8R8A8_SRGB }, GL_TRUE }, /* at least one format must be supported */ { { o(ATI_texture_compression_3dc) }, { PIPE_FORMAT_LATC2_UNORM } }, { { o(MESA_ycbcr_texture) }, { PIPE_FORMAT_UYVY, PIPE_FORMAT_YUYV }, GL_TRUE }, /* at least one format must be supported */ { { o(OES_compressed_ETC1_RGB8_texture) }, { PIPE_FORMAT_ETC1_RGB8 } }, }; /* Required: vertex fetch support. */ static const struct st_extension_format_mapping vertex_mapping[] = { { { o(ARB_vertex_type_2_10_10_10_rev) }, { PIPE_FORMAT_R10G10B10A2_UNORM, PIPE_FORMAT_B10G10R10A2_UNORM, PIPE_FORMAT_R10G10B10A2_SNORM, PIPE_FORMAT_B10G10R10A2_SNORM, PIPE_FORMAT_R10G10B10A2_USCALED, PIPE_FORMAT_B10G10R10A2_USCALED, PIPE_FORMAT_R10G10B10A2_SSCALED, PIPE_FORMAT_B10G10R10A2_SSCALED } }, }; /* * Extensions that are supported by all Gallium drivers: */ ctx->Extensions.ARB_ES2_compatibility = GL_TRUE; ctx->Extensions.ARB_copy_buffer = GL_TRUE; ctx->Extensions.ARB_draw_elements_base_vertex = GL_TRUE; ctx->Extensions.ARB_explicit_attrib_location = GL_TRUE; ctx->Extensions.ARB_fragment_coord_conventions = GL_TRUE; ctx->Extensions.ARB_fragment_program = GL_TRUE; ctx->Extensions.ARB_fragment_shader = GL_TRUE; ctx->Extensions.ARB_half_float_pixel = GL_TRUE; ctx->Extensions.ARB_half_float_vertex = GL_TRUE; ctx->Extensions.ARB_map_buffer_range = GL_TRUE; ctx->Extensions.ARB_sampler_objects = GL_TRUE; ctx->Extensions.ARB_shader_objects = GL_TRUE; ctx->Extensions.ARB_shading_language_100 = GL_TRUE; ctx->Extensions.ARB_texture_border_clamp = GL_TRUE; /* XXX temp */ ctx->Extensions.ARB_texture_cube_map = GL_TRUE; ctx->Extensions.ARB_texture_env_combine = GL_TRUE; ctx->Extensions.ARB_texture_env_crossbar = GL_TRUE; ctx->Extensions.ARB_texture_env_dot3 = GL_TRUE; ctx->Extensions.ARB_texture_storage = GL_TRUE; ctx->Extensions.ARB_vertex_array_object = GL_TRUE; ctx->Extensions.ARB_vertex_program = GL_TRUE; ctx->Extensions.ARB_vertex_shader = GL_TRUE; ctx->Extensions.ARB_window_pos = GL_TRUE; ctx->Extensions.EXT_blend_color = GL_TRUE; ctx->Extensions.EXT_blend_func_separate = GL_TRUE; ctx->Extensions.EXT_blend_minmax = GL_TRUE; ctx->Extensions.EXT_framebuffer_blit = GL_TRUE; ctx->Extensions.EXT_framebuffer_object = GL_TRUE; ctx->Extensions.EXT_framebuffer_multisample = GL_TRUE; ctx->Extensions.EXT_fog_coord = GL_TRUE; ctx->Extensions.EXT_gpu_program_parameters = GL_TRUE; ctx->Extensions.EXT_pixel_buffer_object = GL_TRUE; ctx->Extensions.EXT_point_parameters = GL_TRUE; ctx->Extensions.EXT_provoking_vertex = GL_TRUE; ctx->Extensions.EXT_secondary_color = GL_TRUE; ctx->Extensions.EXT_separate_shader_objects = GL_TRUE; ctx->Extensions.EXT_texture_env_dot3 = GL_TRUE; ctx->Extensions.EXT_vertex_array_bgra = GL_TRUE; ctx->Extensions.APPLE_vertex_array_object = GL_TRUE; ctx->Extensions.ATI_texture_env_combine3 = GL_TRUE; ctx->Extensions.MESA_pack_invert = GL_TRUE; ctx->Extensions.NV_blend_square = GL_TRUE; ctx->Extensions.NV_fog_distance = GL_TRUE; ctx->Extensions.NV_texgen_reflection = GL_TRUE; ctx->Extensions.NV_texture_env_combine4 = GL_TRUE; ctx->Extensions.NV_texture_rectangle = GL_TRUE; #if 0 /* possibly could support the following two */ ctx->Extensions.NV_vertex_program = GL_TRUE; ctx->Extensions.NV_vertex_program1_1 = GL_TRUE; #endif #if FEATURE_OES_EGL_image ctx->Extensions.OES_EGL_image = GL_TRUE; if (ctx->API != API_OPENGL) ctx->Extensions.OES_EGL_image_external = GL_TRUE; #endif #if FEATURE_OES_draw_texture ctx->Extensions.OES_draw_texture = GL_TRUE; #endif /* Expose the extensions which directly correspond to gallium caps. */ for (i = 0; i < Elements(cap_mapping); i++) { if (screen->get_param(screen, cap_mapping[i].cap)) { extensions[cap_mapping[i].extension_offset] = GL_TRUE; } } /* Expose the extensions which directly correspond to gallium formats. */ init_format_extensions(st, rendertarget_mapping, Elements(rendertarget_mapping), PIPE_TEXTURE_2D, PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW); init_format_extensions(st, depthstencil_mapping, Elements(depthstencil_mapping), PIPE_TEXTURE_2D, PIPE_BIND_DEPTH_STENCIL | PIPE_BIND_SAMPLER_VIEW); init_format_extensions(st, texture_mapping, Elements(texture_mapping), PIPE_TEXTURE_2D, PIPE_BIND_SAMPLER_VIEW); init_format_extensions(st, vertex_mapping, Elements(vertex_mapping), PIPE_BUFFER, PIPE_BIND_VERTEX_BUFFER); /* Figure out GLSL support. */ glsl_feature_level = screen->get_param(screen, PIPE_CAP_GLSL_FEATURE_LEVEL); if (glsl_feature_level >= 130) { ctx->Const.GLSLVersion = 130; } else { ctx->Const.GLSLVersion = 120; } _mesa_override_glsl_version(st->ctx); if (ctx->Const.GLSLVersion >= 130) { ctx->Const.NativeIntegers = GL_TRUE; ctx->Const.MaxClipPlanes = 8; /* Extensions that only depend on GLSL 1.3. */ ctx->Extensions.ARB_conservative_depth = GL_TRUE; } else { /* Optional integer support for GLSL 1.2. */ if (screen->get_shader_param(screen, PIPE_SHADER_VERTEX, PIPE_SHADER_CAP_INTEGERS) && screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT, PIPE_SHADER_CAP_INTEGERS)) { ctx->Const.NativeIntegers = GL_TRUE; } } /* Below are the cases which cannot be moved into tables easily. */ if (!ctx->Mesa_DXTn && !st_get_s3tc_override()) { ctx->Extensions.EXT_texture_compression_s3tc = GL_FALSE; ctx->Extensions.S3_s3tc = GL_FALSE; } if (ctx->Const.NativeIntegers) { ctx->Extensions.ARB_shader_bit_encoding = GL_TRUE; } if (screen->get_shader_param(screen, PIPE_SHADER_GEOMETRY, PIPE_SHADER_CAP_MAX_INSTRUCTIONS) > 0) { #if 0 /* XXX re-enable when GLSL compiler again supports geometry shaders */ ctx->Extensions.ARB_geometry_shader4 = GL_TRUE; #endif } ctx->Extensions.NV_primitive_restart = GL_TRUE; if (!screen->get_param(screen, PIPE_CAP_PRIMITIVE_RESTART)) { ctx->Const.PrimitiveRestartInSoftware = GL_TRUE; } if (screen->get_param(screen, PIPE_CAP_VERTEX_COLOR_UNCLAMPED)) { ctx->Extensions.ARB_color_buffer_float = GL_TRUE; if (!screen->get_param(screen, PIPE_CAP_VERTEX_COLOR_CLAMPED)) { st->clamp_vert_color_in_shader = TRUE; } if (!screen->get_param(screen, PIPE_CAP_FRAGMENT_COLOR_CLAMPED)) { st->clamp_frag_color_in_shader = TRUE; } } if (screen->fence_finish) { ctx->Extensions.ARB_sync = GL_TRUE; } /* Maximum sample count. */ for (i = 16; i > 0; --i) { if (screen->is_format_supported(screen, PIPE_FORMAT_B8G8R8A8_UNORM, PIPE_TEXTURE_2D, i, PIPE_BIND_RENDER_TARGET)) { ctx->Const.MaxSamples = i; break; } } if (ctx->Const.MaxDualSourceDrawBuffers > 0) ctx->Extensions.ARB_blend_func_extended = GL_TRUE; }
static int Integrate(This *t, real *integral, real *error, real *prob) { TYPEDEFREGION; Totals totals[NCOMP]; real nneed, weight; count dim, comp, iter, pass = 0, err, iregion; number nwant, nmin = INT_MAX; int fail; if( VERBOSE > 1 ) { char s[512]; sprintf(s, "Divonne input parameters:\n" " ndim " COUNT "\n ncomp " COUNT "\n" " epsrel " REAL "\n epsabs " REAL "\n" " flags %d\n seed %d\n" " mineval " NUMBER "\n maxeval " NUMBER "\n" " key1 %d\n key2 %d\n key3 %d\n maxpass " COUNT "\n" " border " REAL "\n maxchisq " REAL "\n mindeviation " REAL "\n" " ngiven " NUMBER "\n nextra " NUMBER, t->ndim, t->ncomp, t->epsrel, t->epsabs, t->flags, t->seed, t->mineval, t->maxeval, t->key1, t->key2, t->key3, t->maxpass, t->border.lower, t->maxchisq, t->mindeviation, t->ngiven, t->nextra); Print(s); } if( BadComponent(t) ) return -2; if( BadDimension(t, t->key1) || BadDimension(t, t->key2) || ((t->key3 & -2) && BadDimension(t, t->key3)) ) return -1; t->neval_opt = t->neval_cut = 0; t->size = CHUNKSIZE; MemAlloc(t->voidregion, t->size*sizeof(Region)); for( dim = 0; dim < t->ndim; ++dim ) { Bounds *b = &RegionPtr(0)->bounds[dim]; b->lower = 0; b->upper = 1; } RuleIni(&t->rule7); RuleIni(&t->rule9); RuleIni(&t->rule11); RuleIni(&t->rule13); SamplesIni(&t->samples[0]); SamplesIni(&t->samples[1]); SamplesIni(&t->samples[2]); if( (fail = setjmp(t->abort)) ) goto abort; t->epsabs = Max(t->epsabs, NOTZERO); /* Step 1: partition the integration region */ if( VERBOSE ) Print("Partitioning phase:"); if( IsSobol(t->key1) || IsSobol(t->key2) || IsSobol(t->key3) ) IniRandom(t); SamplesLookup(t, &t->samples[0], t->key1, (number)47, (number)INT_MAX, (number)0); SamplesAlloc(t, &t->samples[0]); t->totals = totals; Zap(totals); t->phase = 1; Explore(t, 0, &t->samples[0], INIDEPTH, 1); for( iter = 1; ; ++iter ) { Totals *maxtot; count valid; for( comp = 0; comp < t->ncomp; ++comp ) { Totals *tot = &totals[comp]; tot->avg = tot->spreadsq = 0; tot->spread = tot->secondspread = -INFTY; } for( iregion = 0; iregion < t->nregions; ++iregion ) { Region *region = RegionPtr(iregion); for( comp = 0; comp < t->ncomp; ++comp ) { cResult *r = ®ion->result[comp]; Totals *tot = &totals[comp]; tot->avg += r->avg; tot->spreadsq += Sq(r->spread); if( r->spread > tot->spread ) { tot->secondspread = tot->spread; tot->spread = r->spread; tot->iregion = iregion; } else if( r->spread > tot->secondspread ) tot->secondspread = r->spread; } } maxtot = totals; valid = 0; for( comp = 0; comp < t->ncomp; ++comp ) { Totals *tot = &totals[comp]; integral[comp] = tot->avg; valid += tot->avg == tot->avg; if( tot->spreadsq > maxtot->spreadsq ) maxtot = tot; tot->spread = sqrt(tot->spreadsq); error[comp] = tot->spread*t->samples[0].weight; } if( VERBOSE ) { char s[128 + 64*NCOMP], *p = s; p += sprintf(p, "\n" "Iteration " COUNT " (pass " COUNT "): " COUNT " regions\n" NUMBER7 " integrand evaluations so far,\n" NUMBER7 " in optimizing regions,\n" NUMBER7 " in finding cuts", iter, pass, t->nregions, t->neval, t->neval_opt, t->neval_cut); for( comp = 0; comp < t->ncomp; ++comp ) p += sprintf(p, "\n[" COUNT "] " REAL " +- " REAL, comp + 1, integral[comp], error[comp]); Print(s); } if( valid == 0 ) goto abort; /* all NaNs */ if( t->neval > t->maxeval ) break; nneed = maxtot->spread/MaxErr(maxtot->avg); if( nneed < MAXPRIME ) { cnumber n = t->neval + t->nregions*(number)ceil(nneed); if( n < nmin ) { nmin = n; pass = 0; } else if( ++pass > t->maxpass && n >= t->mineval ) break; } Split(t, maxtot->iregion, DEPTH); } /* Step 2: do a "full" integration on each region */ /* nneed = t->samples[0].neff + 1; */ nneed = 2*t->samples[0].neff; for( comp = 0; comp < t->ncomp; ++comp ) { Totals *tot = &totals[comp]; creal maxerr = MaxErr(tot->avg); tot->nneed = tot->spread/maxerr; nneed = Max(nneed, tot->nneed); tot->maxerrsq = Sq(maxerr); tot->mindevsq = tot->maxerrsq*Sq(t->mindeviation); } nwant = (number)Min(ceil(nneed), MARKMASK/40.); err = SamplesLookup(t, &t->samples[1], t->key2, nwant, (t->maxeval - t->neval)/t->nregions + 1, t->samples[0].n + 1); /* the number of points needed to reach the desired accuracy */ fail = Unmark(err)*t->nregions; if( Marked(err) ) { if( VERBOSE ) Print("\nNot enough samples left for main integration."); for( comp = 0; comp < t->ncomp; ++comp ) prob[comp] = -999; weight = t->samples[0].weight; } else { bool can_adjust = (t->key3 == 1 && t->samples[1].sampler != SampleRule && (t->key2 < 0 || t->samples[1].neff < MAXPRIME)); count df, nlimit; SamplesAlloc(t, &t->samples[1]); if( VERBOSE ) { char s[128]; sprintf(s, "\nMain integration on " COUNT " regions with " NUMBER " samples per region.", t->nregions, t->samples[1].neff); Print(s); } ResClear(integral); ResClear(error); ResClear(prob); nlimit = t->maxeval - t->nregions*t->samples[1].n; df = 0; for( iregion = 0; iregion < t->nregions; ++iregion ) { Region *region = RegionPtr(iregion); char s[64*NDIM + 256*NCOMP], *p = s; int todo; refine: t->phase = 2; t->samples[1].sampler(t, &t->samples[1], region->bounds, region->vol); if( can_adjust ) for( comp = 0; comp < t->ncomp; ++comp ) totals[comp].spreadsq -= Sq(region->result[comp].spread); nlimit += t->samples[1].n; todo = 0; for( comp = 0; comp < t->ncomp; ++comp ) { cResult *r = ®ion->result[comp]; Totals *tot = &totals[comp]; t->samples[0].avg[comp] = r->avg; t->samples[0].err[comp] = r->err; if( t->neval < nlimit ) { creal avg2 = t->samples[1].avg[comp]; creal err2 = t->samples[1].err[comp]; creal diffsq = Sq(avg2 - r->avg); #define Var(s) Sq((s.err[comp] == 0) ? r->spread*s.weight : s.err[comp]) if( err2*tot->nneed > r->spread || diffsq > Max(t->maxchisq*(Var(t->samples[0]) + Var(t->samples[1])), EPS*Sq(avg2)) ) { if( t->key3 && diffsq > tot->mindevsq ) { if( t->key3 == 1 ) { ccount xregion = t->nregions; if( VERBOSE > 2 ) Print("\nSplit"); t->phase = 1; Explore(t, iregion, &t->samples[1], POSTDEPTH, 2); if( can_adjust ) { number nnew; count ireg, xreg; for( ireg = iregion, xreg = xregion; ireg < t->nregions; ireg = xreg++ ) { cResult *result = RegionPtr(ireg)->result; count c; for( c = 0; c < t->ncomp; ++c ) totals[c].spreadsq += Sq(result[c].spread); } nnew = (tot->spreadsq/Sq(MARKMASK) > tot->maxerrsq) ? MARKMASK : (number)ceil(sqrt(tot->spreadsq/tot->maxerrsq)); if( nnew > nwant + nwant/64 ) { ccount err = SamplesLookup(t, &t->samples[1], t->key2, nnew, (t->maxeval - t->neval)/t->nregions + 1, t->samples[1].n); fail += Unmark(err)*t->nregions; nwant = nnew; SamplesFree(&t->samples[1]); SamplesAlloc(t, &t->samples[1]); if( t->key2 > 0 && t->samples[1].neff >= MAXPRIME ) can_adjust = false; if( VERBOSE > 2 ) { char s[128]; sprintf(s, "Sampling remaining " COUNT " regions with " NUMBER " points per region.", t->nregions, t->samples[1].neff); Print(s); } } } goto refine; } todo |= 3; } todo |= 1; } } } if( can_adjust ) { for( comp = 0; comp < t->ncomp; ++comp ) totals[comp].maxerrsq -= Sq(region->result[comp].spread*t->samples[1].weight); } switch( todo ) { case 1: /* get spread right */ Explore(t, iregion, &t->samples[1], 0, 2); break; case 3: /* sample region again with more points */ if( SamplesIniQ(&t->samples[2]) ) { SamplesLookup(t, &t->samples[2], t->key3, nwant, (number)INT_MAX, (number)0); SamplesAlloc(t, &t->samples[2]); } t->phase = 3; t->samples[2].sampler(t, &t->samples[2], region->bounds, region->vol); Explore(t, iregion, &t->samples[2], 0, 2); ++region->depth; /* misused for df here */ ++df; } ++region->depth; /* misused for df here */ if( VERBOSE > 2 ) { for( dim = 0; dim < t->ndim; ++dim ) { cBounds *b = ®ion->bounds[dim]; p += sprintf(p, (dim == 0) ? "\nRegion (" REALF ") - (" REALF ")" : "\n (" REALF ") - (" REALF ")", b->lower, b->upper); } } for( comp = 0; comp < t->ncomp; ++comp ) { Result *r = ®ion->result[comp]; creal x1 = t->samples[0].avg[comp]; creal s1 = Var(t->samples[0]); creal x2 = t->samples[1].avg[comp]; creal s2 = Var(t->samples[1]); creal r2 = (s1 == 0) ? Sq(t->samples[1].neff*t->samples[0].weight) : s2/s1; real norm = 1 + r2; real avg = x2 + r2*x1; real sigsq = s2; real chisq = Sq(x2 - x1); real chiden = s1 + s2; if( todo == 3 ) { creal x3 = t->samples[2].avg[comp]; creal s3 = Var(t->samples[2]); creal r3 = (s2 == 0) ? Sq(t->samples[2].neff*t->samples[1].weight) : s3/s2; norm = 1 + r3*norm; avg = x3 + r3*avg; sigsq = s3; chisq = s1*Sq(x3 - x2) + s2*Sq(x3 - x1) + s3*chisq; chiden = s1*s2 + s3*chiden; } avg = LAST ? r->avg : (sigsq *= norm = 1/norm, avg*norm); if( chisq > EPS ) chisq /= Max(chiden, NOTZERO); #define Out(s) s.avg[comp], r->spread*s.weight, s.err[comp] if( VERBOSE > 2 ) { p += sprintf(p, "\n[" COUNT "] " REAL " +- " REAL "(" REAL ")\n " REAL " +- " REAL "(" REAL ")", comp + 1, Out(t->samples[0]), Out(t->samples[1])); if( todo == 3 ) p += sprintf(p, "\n " REAL " +- " REAL "(" REAL ")", Out(t->samples[2])); p += sprintf(p, " \tchisq " REAL, chisq); } integral[comp] += avg; error[comp] += sigsq; prob[comp] += chisq; r->avg = avg; r->spread = sqrt(sigsq); r->chisq = chisq; } if( VERBOSE > 2 ) Print(s); } for( comp = 0; comp < t->ncomp; ++comp ) error[comp] = sqrt(error[comp]); df += t->nregions; if( VERBOSE > 2 ) { char s[16 + 128*NCOMP], *p = s; p += sprintf(p, "\nTotals:"); for( comp = 0; comp < t->ncomp; ++comp ) p += sprintf(p, "\n[" COUNT "] " REAL " +- " REAL " \tchisq " REAL " (" COUNT " df)", comp + 1, integral[comp], error[comp], prob[comp], df); Print(s); } for( comp = 0; comp < t->ncomp; ++comp ) prob[comp] = ChiSquare(prob[comp], df); weight = 1; } #ifdef MLVERSION if( REGIONS ) { MLPutFunction(stdlink, "List", 2); MLPutFunction(stdlink, "List", t->nregions); for( iregion = 0; iregion < t->nregions; ++iregion ) { Region *region = RegionPtr(iregion); cBounds *b = region->bounds; real lower[NDIM], upper[NDIM]; for( dim = 0; dim < t->ndim; ++dim ) { lower[dim] = b[dim].lower; upper[dim] = b[dim].upper; } MLPutFunction(stdlink, "Cuba`Divonne`region", 4); MLPutRealList(stdlink, lower, t->ndim); MLPutRealList(stdlink, upper, t->ndim); MLPutFunction(stdlink, "List", t->ncomp); for( comp = 0; comp < t->ncomp; ++comp ) { cResult *r = ®ion->result[comp]; real res[] = {r->avg, r->spread*weight, r->chisq}; MLPutRealList(stdlink, res, Elements(res)); } MLPutInteger(stdlink, region->depth); /* misused for df */ } } #endif abort: SamplesFree(&t->samples[2]); SamplesFree(&t->samples[1]); SamplesFree(&t->samples[0]); RuleFree(&t->rule13); RuleFree(&t->rule11); RuleFree(&t->rule9); RuleFree(&t->rule7); free(t->voidregion); return fail; }
/** * Return mask ? a : b; * * mask is a bitwise mask, composed of 0 or ~0 for each element. Any other value * will yield unpredictable results. */ LLVMValueRef lp_build_select(struct lp_build_context *bld, LLVMValueRef mask, LLVMValueRef a, LLVMValueRef b) { LLVMBuilderRef builder = bld->gallivm->builder; LLVMContextRef lc = bld->gallivm->context; struct lp_type type = bld->type; LLVMValueRef res; assert(lp_check_value(type, a)); assert(lp_check_value(type, b)); if(a == b) return a; if (type.length == 1) { mask = LLVMBuildTrunc(builder, mask, LLVMInt1TypeInContext(lc), ""); res = LLVMBuildSelect(builder, mask, a, b, ""); } else if (0) { /* Generate a vector select. * * XXX: Using vector selects would avoid emitting intrinsics, but they aren't * properly supported yet. * * LLVM 3.0 includes experimental support provided the -promote-elements * options is passed to LLVM's command line (e.g., via * llvm::cl::ParseCommandLineOptions), but resulting code quality is much * worse, probably because some optimization passes don't know how to * handle vector selects. * * See also: * - http://lists.cs.uiuc.edu/pipermail/llvmdev/2011-October/043659.html */ /* Convert the mask to a vector of booleans. * XXX: There are two ways to do this. Decide what's best. */ if (1) { LLVMTypeRef bool_vec_type = LLVMVectorType(LLVMInt1TypeInContext(lc), type.length); mask = LLVMBuildTrunc(builder, mask, bool_vec_type, ""); } else { mask = LLVMBuildICmp(builder, LLVMIntNE, mask, LLVMConstNull(bld->int_vec_type), ""); } res = LLVMBuildSelect(builder, mask, a, b, ""); } else if (((util_cpu_caps.has_sse4_1 && type.width * type.length == 128) || (util_cpu_caps.has_avx && type.width * type.length == 256 && type.width >= 32)) && !LLVMIsConstant(a) && !LLVMIsConstant(b) && !LLVMIsConstant(mask)) { const char *intrinsic; LLVMTypeRef arg_type; LLVMValueRef args[3]; /* * There's only float blend in AVX but can just cast i32/i64 * to float. */ if (type.width * type.length == 256) { if (type.width == 64) { intrinsic = "llvm.x86.avx.blendv.pd.256"; arg_type = LLVMVectorType(LLVMDoubleTypeInContext(lc), 4); } else { intrinsic = "llvm.x86.avx.blendv.ps.256"; arg_type = LLVMVectorType(LLVMFloatTypeInContext(lc), 8); } } else if (type.floating && type.width == 64) { intrinsic = "llvm.x86.sse41.blendvpd"; arg_type = LLVMVectorType(LLVMDoubleTypeInContext(lc), 2); } else if (type.floating && type.width == 32) { intrinsic = "llvm.x86.sse41.blendvps"; arg_type = LLVMVectorType(LLVMFloatTypeInContext(lc), 4); } else { intrinsic = "llvm.x86.sse41.pblendvb"; arg_type = LLVMVectorType(LLVMInt8TypeInContext(lc), 16); } if (arg_type != bld->int_vec_type) { mask = LLVMBuildBitCast(builder, mask, arg_type, ""); } if (arg_type != bld->vec_type) { a = LLVMBuildBitCast(builder, a, arg_type, ""); b = LLVMBuildBitCast(builder, b, arg_type, ""); } args[0] = b; args[1] = a; args[2] = mask; res = lp_build_intrinsic(builder, intrinsic, arg_type, args, Elements(args)); if (arg_type != bld->vec_type) { res = LLVMBuildBitCast(builder, res, bld->vec_type, ""); } } else { res = lp_build_select_bitwise(bld, mask, a, b); } return res; }
/** * Make a list of per-vertex functions to call for each glArrayElement call. * These functions access the array data (i.e. glVertex, glColor, glNormal, * etc). * Note: this may be called during display list construction. */ static void _ae_update_state( struct gl_context *ctx ) { AEcontext *actx = AE_CONTEXT(ctx); AEarray *aa = actx->arrays; AEattrib *at = actx->attribs; GLuint i; struct gl_array_object *arrayObj = ctx->Array.ArrayObj; actx->nr_vbos = 0; /* conventional vertex arrays */ if (arrayObj->Index.Enabled) { aa->array = &arrayObj->Index; aa->offset = IndexFuncs[TYPE_IDX(aa->array->Type)]; check_vbo(actx, aa->array->BufferObj); aa++; } if (arrayObj->EdgeFlag.Enabled) { aa->array = &arrayObj->EdgeFlag; aa->offset = _gloffset_EdgeFlagv; check_vbo(actx, aa->array->BufferObj); aa++; } if (arrayObj->Normal.Enabled) { aa->array = &arrayObj->Normal; aa->offset = NormalFuncs[TYPE_IDX(aa->array->Type)]; check_vbo(actx, aa->array->BufferObj); aa++; } if (arrayObj->Color.Enabled) { aa->array = &arrayObj->Color; aa->offset = ColorFuncs[aa->array->Size-3][TYPE_IDX(aa->array->Type)]; check_vbo(actx, aa->array->BufferObj); aa++; } if (arrayObj->SecondaryColor.Enabled) { aa->array = &arrayObj->SecondaryColor; aa->offset = SecondaryColorFuncs[TYPE_IDX(aa->array->Type)]; check_vbo(actx, aa->array->BufferObj); aa++; } if (arrayObj->FogCoord.Enabled) { aa->array = &arrayObj->FogCoord; aa->offset = FogCoordFuncs[TYPE_IDX(aa->array->Type)]; check_vbo(actx, aa->array->BufferObj); aa++; } for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) { struct gl_client_array *attribArray = &arrayObj->TexCoord[i]; if (attribArray->Enabled) { /* NOTE: we use generic glVertexAttribNV functions here. * If we ever remove GL_NV_vertex_program this will have to change. */ at->array = attribArray; ASSERT(!at->array->Normalized); at->func = AttribFuncsNV[at->array->Normalized] [at->array->Size-1] [TYPE_IDX(at->array->Type)]; at->index = VERT_ATTRIB_TEX0 + i; check_vbo(actx, at->array->BufferObj); at++; } } /* generic vertex attribute arrays */ for (i = 1; i < Elements(arrayObj->VertexAttrib); i++) { /* skip zero! */ struct gl_client_array *attribArray = &arrayObj->VertexAttrib[i]; if (attribArray->Enabled) { at->array = attribArray; /* Note: we can't grab the _glapi_Dispatch->VertexAttrib1fvNV * function pointer here (for float arrays) since the pointer may * change from one execution of _ae_ArrayElement() to * the next. Doing so caused UT to break. */ if (ctx->VertexProgram._Enabled && ctx->VertexProgram.Current->IsNVProgram) { at->func = AttribFuncsNV[at->array->Normalized] [at->array->Size-1] [TYPE_IDX(at->array->Type)]; } else { GLint intOrNorm; if (at->array->Integer) intOrNorm = 2; else if (at->array->Normalized) intOrNorm = 1; else intOrNorm = 0; at->func = AttribFuncsARB[intOrNorm] [at->array->Size-1] [TYPE_IDX(at->array->Type)]; } at->index = i; check_vbo(actx, at->array->BufferObj); at++; } } /* finally, vertex position */ if (arrayObj->VertexAttrib[0].Enabled) { /* Use glVertex(v) instead of glVertexAttrib(0, v) to be sure it's * issued as the last (provoking) attribute). */ aa->array = &arrayObj->VertexAttrib[0]; assert(aa->array->Size >= 2); /* XXX fix someday? */ aa->offset = VertexFuncs[aa->array->Size-2][TYPE_IDX(aa->array->Type)]; check_vbo(actx, aa->array->BufferObj); aa++; } else if (arrayObj->Vertex.Enabled) { aa->array = &arrayObj->Vertex; aa->offset = VertexFuncs[aa->array->Size-2][TYPE_IDX(aa->array->Type)]; check_vbo(actx, aa->array->BufferObj); aa++; } check_vbo(actx, ctx->Array.ElementArrayBufferObj); ASSERT(at - actx->attribs <= VERT_ATTRIB_MAX); ASSERT(aa - actx->arrays < 32); at->func = NULL; /* terminate the list */ aa->offset = -1; /* terminate the list */ actx->NewState = 0; }
[PIPE_PRIM_POINTS] = V_028A6C_OUTPRIM_TYPE_POINTLIST, [PIPE_PRIM_LINES] = V_028A6C_OUTPRIM_TYPE_LINESTRIP, [PIPE_PRIM_LINE_LOOP] = V_028A6C_OUTPRIM_TYPE_LINESTRIP, [PIPE_PRIM_LINE_STRIP] = V_028A6C_OUTPRIM_TYPE_LINESTRIP, [PIPE_PRIM_TRIANGLES] = V_028A6C_OUTPRIM_TYPE_TRISTRIP, [PIPE_PRIM_TRIANGLE_STRIP] = V_028A6C_OUTPRIM_TYPE_TRISTRIP, [PIPE_PRIM_TRIANGLE_FAN] = V_028A6C_OUTPRIM_TYPE_TRISTRIP, [PIPE_PRIM_QUADS] = V_028A6C_OUTPRIM_TYPE_TRISTRIP, [PIPE_PRIM_QUAD_STRIP] = V_028A6C_OUTPRIM_TYPE_TRISTRIP, [PIPE_PRIM_POLYGON] = V_028A6C_OUTPRIM_TYPE_TRISTRIP, [PIPE_PRIM_LINES_ADJACENCY] = V_028A6C_OUTPRIM_TYPE_LINESTRIP, [PIPE_PRIM_LINE_STRIP_ADJACENCY] = V_028A6C_OUTPRIM_TYPE_LINESTRIP, [PIPE_PRIM_TRIANGLES_ADJACENCY] = V_028A6C_OUTPRIM_TYPE_TRISTRIP, [PIPE_PRIM_TRIANGLE_STRIP_ADJACENCY] = V_028A6C_OUTPRIM_TYPE_TRISTRIP }; assert(mode < Elements(prim_conv)); return prim_conv[mode]; } static bool si_update_draw_info_state(struct r600_context *rctx, const struct pipe_draw_info *info) { struct si_pm4_state *pm4 = si_pm4_alloc_state(rctx); struct si_shader *vs = &rctx->vs_shader->current->shader; unsigned prim = si_conv_pipe_prim(info->mode); unsigned gs_out_prim = r600_conv_prim_to_gs_out(info->mode); unsigned ls_mask = 0; if (pm4 == NULL) return false;
/** * Return ARB_v/f_prog-style output attrib string. */ static const char * arb_output_attrib_string(GLint index, GLenum progType) { /* * These strings should match the VARYING_SLOT_x and FRAG_RESULT_x tokens. */ static const char *const vertResults[] = { "result.position", "result.color.primary", "result.color.secondary", "result.fogcoord", "result.texcoord[0]", "result.texcoord[1]", "result.texcoord[2]", "result.texcoord[3]", "result.texcoord[4]", "result.texcoord[5]", "result.texcoord[6]", "result.texcoord[7]", "result.pointsize", /* VARYING_SLOT_PSIZ */ "result.(thirteen)", /* VARYING_SLOT_BFC0 */ "result.(fourteen)", /* VARYING_SLOT_BFC1 */ "result.(fifteen)", /* VARYING_SLOT_EDGE */ "result.(sixteen)", /* VARYING_SLOT_CLIP_VERTEX */ "result.(seventeen)", /* VARYING_SLOT_CLIP_DIST0 */ "result.(eighteen)", /* VARYING_SLOT_CLIP_DIST1 */ "result.(nineteen)", /* VARYING_SLOT_PRIMITIVE_ID */ "result.(twenty)", /* VARYING_SLOT_LAYER */ "result.(twenty-one)", /* VARYING_SLOT_FACE */ "result.(twenty-two)", /* VARYING_SLOT_PNTC */ "result.varying[0]", "result.varying[1]", "result.varying[2]", "result.varying[3]", "result.varying[4]", "result.varying[5]", "result.varying[6]", "result.varying[7]", "result.varying[8]", "result.varying[9]", "result.varying[10]", "result.varying[11]", "result.varying[12]", "result.varying[13]", "result.varying[14]", "result.varying[15]", "result.varying[16]", "result.varying[17]", "result.varying[18]", "result.varying[19]", "result.varying[20]", "result.varying[21]", "result.varying[22]", "result.varying[23]", "result.varying[24]", "result.varying[25]", "result.varying[26]", "result.varying[27]", "result.varying[28]", "result.varying[29]", "result.varying[30]", "result.varying[31]", /* MAX_VARYING = 32 */ }; static const char *const fragResults[] = { "result.depth", /* FRAG_RESULT_DEPTH */ "result.(one)", /* FRAG_RESULT_STENCIL */ "result.color", /* FRAG_RESULT_COLOR */ "result.samplemask", /* FRAG_RESULT_SAMPLE_MASK */ "result.color[0]", /* FRAG_RESULT_DATA0 (named for GLSL's gl_FragData) */ "result.color[1]", "result.color[2]", "result.color[3]", "result.color[4]", "result.color[5]", "result.color[6]", "result.color[7]" /* MAX_DRAW_BUFFERS = 8 */ }; /* sanity checks */ STATIC_ASSERT(Elements(vertResults) == VARYING_SLOT_MAX); STATIC_ASSERT(Elements(fragResults) == FRAG_RESULT_MAX); assert(strcmp(vertResults[VARYING_SLOT_POS], "result.position") == 0); assert(strcmp(vertResults[VARYING_SLOT_VAR0], "result.varying[0]") == 0); assert(strcmp(fragResults[FRAG_RESULT_DATA0], "result.color[0]") == 0); if (progType == GL_VERTEX_PROGRAM_ARB) { assert(index < Elements(vertResults)); return vertResults[index]; } else { assert(progType == GL_FRAGMENT_PROGRAM_ARB); assert(index < Elements(fragResults)); return fragResults[index]; } }
static void generate_110_uniforms(exec_list *instructions, struct _mesa_glsl_parse_state *state, bool add_deprecated) { glsl_symbol_table *const symtab = state->symbols; if (add_deprecated) { for (unsigned i = 0 ; i < Elements(builtin_110_deprecated_uniforms) ; i++) { add_builtin_variable(instructions, symtab, & builtin_110_deprecated_uniforms[i]); } } if (add_deprecated) { add_builtin_constant(instructions, symtab, "gl_MaxLights", state->Const.MaxLights); add_builtin_constant(instructions, symtab, "gl_MaxClipPlanes", state->Const.MaxClipPlanes); add_builtin_constant(instructions, symtab, "gl_MaxTextureUnits", state->Const.MaxTextureUnits); add_builtin_constant(instructions, symtab, "gl_MaxTextureCoords", state->Const.MaxTextureCoords); } add_builtin_constant(instructions, symtab, "gl_MaxVertexAttribs", state->Const.MaxVertexAttribs); add_builtin_constant(instructions, symtab, "gl_MaxVertexUniformComponents", state->Const.MaxVertexUniformComponents); add_builtin_constant(instructions, symtab, "gl_MaxVaryingFloats", state->Const.MaxVaryingFloats); add_builtin_constant(instructions, symtab, "gl_MaxVertexTextureImageUnits", state->Const.MaxVertexTextureImageUnits); add_builtin_constant(instructions, symtab, "gl_MaxCombinedTextureImageUnits", state->Const.MaxCombinedTextureImageUnits); add_builtin_constant(instructions, symtab, "gl_MaxTextureImageUnits", state->Const.MaxTextureImageUnits); add_builtin_constant(instructions, symtab, "gl_MaxFragmentUniformComponents", state->Const.MaxFragmentUniformComponents); if (add_deprecated) { const glsl_type *const mat4_array_type = glsl_type::get_array_instance(glsl_type::mat4_type, state->Const.MaxTextureCoords); add_uniform(instructions, symtab, "gl_TextureMatrix", mat4_array_type); add_uniform(instructions, symtab, "gl_TextureMatrixInverse", mat4_array_type); add_uniform(instructions, symtab, "gl_TextureMatrixTranspose", mat4_array_type); add_uniform(instructions, symtab, "gl_TextureMatrixInverseTranspose", mat4_array_type); } add_uniform(instructions, symtab, "gl_DepthRange", symtab->get_type("gl_DepthRangeParameters")); if (add_deprecated) { add_uniform(instructions, symtab, "gl_ClipPlane", glsl_type::get_array_instance(glsl_type::vec4_type, state->Const.MaxClipPlanes)); add_uniform(instructions, symtab, "gl_Point", symtab->get_type("gl_PointParameters")); const glsl_type *const material_parameters_type = symtab->get_type("gl_MaterialParameters"); add_uniform(instructions, symtab, "gl_FrontMaterial", material_parameters_type); add_uniform(instructions, symtab, "gl_BackMaterial", material_parameters_type); const glsl_type *const light_source_array_type = glsl_type::get_array_instance(symtab->get_type("gl_LightSourceParameters"), state->Const.MaxLights); add_uniform(instructions, symtab, "gl_LightSource", light_source_array_type); const glsl_type *const light_model_products_type = symtab->get_type("gl_LightModelProducts"); add_uniform(instructions, symtab, "gl_FrontLightModelProduct", light_model_products_type); add_uniform(instructions, symtab, "gl_BackLightModelProduct", light_model_products_type); const glsl_type *const light_products_type = glsl_type::get_array_instance(symtab->get_type("gl_LightProducts"), state->Const.MaxLights); add_uniform(instructions, symtab, "gl_FrontLightProduct", light_products_type); add_uniform(instructions, symtab, "gl_BackLightProduct", light_products_type); add_uniform(instructions, symtab, "gl_TextureEnvColor", glsl_type::get_array_instance(glsl_type::vec4_type, state->Const.MaxTextureUnits)); const glsl_type *const texcoords_vec4 = glsl_type::get_array_instance(glsl_type::vec4_type, state->Const.MaxTextureCoords); add_uniform(instructions, symtab, "gl_EyePlaneS", texcoords_vec4); add_uniform(instructions, symtab, "gl_EyePlaneT", texcoords_vec4); add_uniform(instructions, symtab, "gl_EyePlaneR", texcoords_vec4); add_uniform(instructions, symtab, "gl_EyePlaneQ", texcoords_vec4); add_uniform(instructions, symtab, "gl_ObjectPlaneS", texcoords_vec4); add_uniform(instructions, symtab, "gl_ObjectPlaneT", texcoords_vec4); add_uniform(instructions, symtab, "gl_ObjectPlaneR", texcoords_vec4); add_uniform(instructions, symtab, "gl_ObjectPlaneQ", texcoords_vec4); add_uniform(instructions, symtab, "gl_Fog", symtab->get_type("gl_FogParameters")); } /* Mesa-internal current attrib state */ const glsl_type *const vert_attribs = glsl_type::get_array_instance(glsl_type::vec4_type, VERT_ATTRIB_MAX); add_uniform(instructions, symtab, "gl_CurrentAttribVertMESA", vert_attribs); const glsl_type *const frag_attribs = glsl_type::get_array_instance(glsl_type::vec4_type, FRAG_ATTRIB_MAX); add_uniform(instructions, symtab, "gl_CurrentAttribFragMESA", frag_attribs); }
static void gen6_emit_draw_dynamic_samplers(struct ilo_render *r, const struct ilo_state_vector *vec, int shader_type, struct ilo_render_draw_session *session) { const struct ilo_sampler_cso * const *samplers = vec->sampler[shader_type].cso; const struct pipe_sampler_view * const *views = (const struct pipe_sampler_view **) vec->view[shader_type].states; uint32_t *sampler_state, *border_color_state; int sampler_count; bool emit_border_color = false; bool skip = false; ILO_DEV_ASSERT(r->dev, 6, 7.5); /* SAMPLER_BORDER_COLOR_STATE and SAMPLER_STATE */ switch (shader_type) { case PIPE_SHADER_VERTEX: if (DIRTY(VS) || DIRTY(SAMPLER_VS) || DIRTY(VIEW_VS)) { sampler_state = &r->state.vs.SAMPLER_STATE; border_color_state = r->state.vs.SAMPLER_BORDER_COLOR_STATE; if (DIRTY(VS) || DIRTY(SAMPLER_VS)) emit_border_color = true; sampler_count = (vec->vs) ? ilo_shader_get_kernel_param(vec->vs, ILO_KERNEL_SAMPLER_COUNT) : 0; session->sampler_vs_changed = true; } else { skip = true; } break; case PIPE_SHADER_FRAGMENT: if (DIRTY(FS) || DIRTY(SAMPLER_FS) || DIRTY(VIEW_FS)) { sampler_state = &r->state.wm.SAMPLER_STATE; border_color_state = r->state.wm.SAMPLER_BORDER_COLOR_STATE; if (DIRTY(VS) || DIRTY(SAMPLER_FS)) emit_border_color = true; sampler_count = (vec->fs) ? ilo_shader_get_kernel_param(vec->fs, ILO_KERNEL_SAMPLER_COUNT) : 0; session->sampler_fs_changed = true; } else { skip = true; } break; default: skip = true; break; } if (skip) return; assert(sampler_count <= Elements(vec->view[shader_type].states) && sampler_count <= Elements(vec->sampler[shader_type].cso)); if (emit_border_color) { int i; for (i = 0; i < sampler_count; i++) { border_color_state[i] = (samplers[i]) ? gen6_SAMPLER_BORDER_COLOR_STATE(r->builder, samplers[i]) : 0; } } *sampler_state = gen6_SAMPLER_STATE(r->builder, samplers, views, border_color_state, sampler_count); }
int main(int argc, char **argv) { int ret = 0, n = 1; const char *filename; struct tgsi_token toks[65536]; struct tgsi_parse_context parse; struct ir3_shader_variant v; struct ir3_shader_key key = {}; const char *info; void *ptr; size_t size; fd_mesa_debug |= FD_DBG_DISASM; /* cmdline args which impact shader variant get spit out in a * comment on the first line.. a quick/dirty way to preserve * that info so when ir3test recompiles the shader with a new * compiler version, we use the same shader-key settings: */ debug_printf("; options:"); while (n < argc) { if (!strcmp(argv[n], "--verbose")) { fd_mesa_debug |= FD_DBG_OPTDUMP | FD_DBG_MSGS | FD_DBG_OPTMSGS; n++; continue; } if (!strcmp(argv[n], "--binning-pass")) { debug_printf(" %s", argv[n]); key.binning_pass = true; n++; continue; } if (!strcmp(argv[n], "--color-two-side")) { debug_printf(" %s", argv[n]); key.color_two_side = true; n++; continue; } if (!strcmp(argv[n], "--half-precision")) { debug_printf(" %s", argv[n]); key.half_precision = true; n++; continue; } if (!strcmp(argv[n], "--alpha")) { debug_printf(" %s", argv[n]); key.alpha = true; n++; continue; } if (!strcmp(argv[n], "--saturate-s")) { debug_printf(" %s %s", argv[n], argv[n+1]); key.vsaturate_s = key.fsaturate_s = strtol(argv[n+1], NULL, 0); n += 2; continue; } if (!strcmp(argv[n], "--saturate-t")) { debug_printf(" %s %s", argv[n], argv[n+1]); key.vsaturate_t = key.fsaturate_t = strtol(argv[n+1], NULL, 0); n += 2; continue; } if (!strcmp(argv[n], "--saturate-r")) { debug_printf(" %s %s", argv[n], argv[n+1]); key.vsaturate_r = key.fsaturate_r = strtol(argv[n+1], NULL, 0); n += 2; continue; } if (!strcmp(argv[n], "--nocp")) { fd_mesa_debug |= FD_DBG_NOCP; n++; continue; } if (!strcmp(argv[n], "--help")) { print_usage(); return 0; } break; } debug_printf("\n"); filename = argv[n]; memset(&v, 0, sizeof(v)); v.key = key; ret = read_file(filename, &ptr, &size); if (ret) { print_usage(); return ret; } if (!tgsi_text_translate(ptr, toks, Elements(toks))) errx(1, "could not parse `%s'", filename); tgsi_parse_init(&parse, toks); switch (parse.FullHeader.Processor.Processor) { case TGSI_PROCESSOR_FRAGMENT: v.type = SHADER_FRAGMENT; break; case TGSI_PROCESSOR_VERTEX: v.type = SHADER_VERTEX; break; case TGSI_PROCESSOR_COMPUTE: v.type = SHADER_COMPUTE; break; } if (!(fd_mesa_debug & FD_DBG_NOOPT)) { /* with new compiler: */ info = "new compiler"; ret = ir3_compile_shader(&v, toks, key, true); if (ret) { reset_variant(&v, "new compiler failed, trying without copy propagation!"); info = "new compiler (no copy propagation)"; ret = ir3_compile_shader(&v, toks, key, false); if (ret) reset_variant(&v, "new compiler failed, trying fallback!\n"); } } if (ret) { info = "old compiler"; ret = ir3_compile_shader_old(&v, toks, key); } if (ret) { fprintf(stderr, "old compiler failed!\n"); return ret; } dump_info(&v, info); }