diff options
Diffstat (limited to 'mesalib/src')
113 files changed, 3698 insertions, 2360 deletions
diff --git a/mesalib/src/gallium/auxiliary/util/u_debug_symbol.c b/mesalib/src/gallium/auxiliary/util/u_debug_symbol.c index bae9be87a..3d2f8ebc3 100644 --- a/mesalib/src/gallium/auxiliary/util/u_debug_symbol.c +++ b/mesalib/src/gallium/auxiliary/util/u_debug_symbol.c @@ -152,7 +152,9 @@ debug_symbol_name_dbghelp(const void *addr, char* buf, unsigned size) #endif #ifdef __GLIBC__ +#ifndef __UCLIBC__ #include <execinfo.h> +#endif /* This can only provide dynamic symbols, or binary offsets into a file. * diff --git a/mesalib/src/gallium/auxiliary/util/u_format_tests.c b/mesalib/src/gallium/auxiliary/util/u_format_tests.c index 457fda6c8..d34860886 100644 --- a/mesalib/src/gallium/auxiliary/util/u_format_tests.c +++ b/mesalib/src/gallium/auxiliary/util/u_format_tests.c @@ -66,8 +66,13 @@ {{ 0, 0, 0, 0}, { 0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}}} +#ifdef __GNUC__ +#define NAN __builtin_nan("") +#define INF __builtin_inf() +#else #define NAN (0.0 / 0.0) #define INF (1.0 / 0.0) +#endif /** * Test cases. diff --git a/mesalib/src/glsl/ast.h b/mesalib/src/glsl/ast.h index 4438b85bb..de3f2dfeb 100644 --- a/mesalib/src/glsl/ast.h +++ b/mesalib/src/glsl/ast.h @@ -513,6 +513,12 @@ public: * is used to note these cases when no type is specified. */ int invariant; + + /** + * Flag indicating that these declarators are in a uniform block, + * allowing UBO type qualifiers. + */ + bool ubo_qualifiers_valid; }; diff --git a/mesalib/src/glsl/ast_to_hir.cpp b/mesalib/src/glsl/ast_to_hir.cpp index bbe8f0596..1c54991cf 100644 --- a/mesalib/src/glsl/ast_to_hir.cpp +++ b/mesalib/src/glsl/ast_to_hir.cpp @@ -1917,7 +1917,8 @@ static void apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual, ir_variable *var, struct _mesa_glsl_parse_state *state, - YYLTYPE *loc) + YYLTYPE *loc, + bool ubo_qualifiers_valid) { if (qual->flags.q.invariant) { if (var->used) { @@ -2010,24 +2011,10 @@ apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual, if (var->interpolation != INTERP_QUALIFIER_NONE && !(state->target == vertex_shader && var->mode == ir_var_out) && !(state->target == fragment_shader && var->mode == ir_var_in)) { - const char *qual_string = NULL; - switch (var->interpolation) { - case INTERP_QUALIFIER_FLAT: - qual_string = "flat"; - break; - case INTERP_QUALIFIER_NOPERSPECTIVE: - qual_string = "noperspective"; - break; - case INTERP_QUALIFIER_SMOOTH: - qual_string = "smooth"; - break; - } - _mesa_glsl_error(loc, state, "interpolation qualifier `%s' can only be applied to " "vertex shader outputs and fragment shader inputs.", - qual_string); - + var->interpolation_string()); } var->pixel_center_integer = qual->flags.q.pixel_center_integer; @@ -2191,6 +2178,23 @@ apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual, var->depth_layout = ir_depth_layout_unchanged; else var->depth_layout = ir_depth_layout_none; + + if (qual->flags.q.std140 || + qual->flags.q.packed || + qual->flags.q.shared) { + _mesa_glsl_error(loc, state, + "uniform block layout qualifiers std140, packed, and " + "shared can only be applied to uniform blocks, not " + "members"); + } + + if (!ubo_qualifiers_valid && + (qual->flags.q.row_major || qual->flags.q.column_major)) { + _mesa_glsl_error(loc, state, + "uniform block layout qualifiers row_major and " + "column_major can only be applied to uniform block " + "members"); + } } /** @@ -2611,7 +2615,7 @@ ast_declarator_list::hir(exec_list *instructions, } apply_type_qualifier_to_variable(& this->type->qualifier, var, state, - & loc); + & loc, this->ubo_qualifiers_valid); if (this->type->qualifier.flags.q.invariant) { if ((state->target == vertex_shader) && !(var->mode == ir_var_out || @@ -3028,7 +3032,8 @@ ast_parameter_declarator::hir(exec_list *instructions, /* Apply any specified qualifiers to the parameter declaration. Note that * for function parameters the default mode is 'in'. */ - apply_type_qualifier_to_variable(& this->type->qualifier, var, state, & loc); + apply_type_qualifier_to_variable(& this->type->qualifier, var, state, & loc, + false); /* From page 17 (page 23 of the PDF) of the GLSL 1.20 spec: * @@ -3989,6 +3994,25 @@ ast_struct_specifier::hir(exec_list *instructions, return NULL; } +static struct gl_uniform_block * +get_next_uniform_block(struct _mesa_glsl_parse_state *state) +{ + if (state->num_uniform_blocks >= state->uniform_block_array_size) { + state->uniform_block_array_size *= 2; + if (state->uniform_block_array_size <= 4) + state->uniform_block_array_size = 4; + + state->uniform_blocks = reralloc(state, + state->uniform_blocks, + struct gl_uniform_block, + state->uniform_block_array_size); + } + + memset(&state->uniform_blocks[state->num_uniform_blocks], + 0, sizeof(*state->uniform_blocks)); + return &state->uniform_blocks[state->num_uniform_blocks++]; +} + ir_rvalue * ast_uniform_block::hir(exec_list *instructions, struct _mesa_glsl_parse_state *state) @@ -3997,6 +4021,62 @@ ast_uniform_block::hir(exec_list *instructions, * need to turn those into ir_variables with an association * with this uniform block. */ + struct gl_uniform_block *ubo = get_next_uniform_block(state); + ubo->Name = ralloc_strdup(state->uniform_blocks, this->block_name); + + unsigned int num_variables = 0; + foreach_list_typed(ast_declarator_list, decl_list, link, &declarations) { + foreach_list_const(node, &decl_list->declarations) { + num_variables++; + } + } + + bool block_row_major = this->layout.flags.q.row_major; + + ubo->Uniforms = rzalloc_array(state->uniform_blocks, + struct gl_uniform_buffer_variable, + num_variables); + + foreach_list_typed(ast_declarator_list, decl_list, link, &declarations) { + exec_list declared_variables; + + decl_list->hir(&declared_variables, state); + + foreach_list_const(node, &declared_variables) { + struct ir_variable *var = (ir_variable *)node; + + struct gl_uniform_buffer_variable *ubo_var = + &ubo->Uniforms[ubo->NumUniforms++]; + + var->uniform_block = ubo - state->uniform_blocks; + + ubo_var->Name = ralloc_strdup(state->uniform_blocks, var->name); + ubo_var->Type = var->type; + ubo_var->Buffer = ubo - state->uniform_blocks; + ubo_var->Offset = 0; /* Assigned at link time. */ + ubo_var->RowMajor = block_row_major; + if (decl_list->type->qualifier.flags.q.row_major) + ubo_var->RowMajor = true; + else if (decl_list->type->qualifier.flags.q.column_major) + ubo_var->RowMajor = false; + + /* From the GL_ARB_uniform_buffer_object spec: + * + * "Sampler types are not allowed inside of uniform + * blocks. All other types, arrays, and structures + * allowed for uniforms are allowed within a uniform + * block." + */ + if (var->type->contains_sampler()) { + YYLTYPE loc = decl_list->get_location(); + _mesa_glsl_error(&loc, state, + "Uniform in non-default uniform block contains sampler\n"); + } + } + + instructions->append_list(&declared_variables); + } + return NULL; } diff --git a/mesalib/src/glsl/builtin_types.h b/mesalib/src/glsl/builtin_types.h index 8c136e4ab..d75c56261 100644 --- a/mesalib/src/glsl/builtin_types.h +++ b/mesalib/src/glsl/builtin_types.h @@ -63,7 +63,12 @@ const glsl_type glsl_type::builtin_core_types[] = { }; const glsl_type *const glsl_type::bool_type = & builtin_core_types[0]; +const glsl_type *const glsl_type::bvec2_type = & builtin_core_types[1]; +const glsl_type *const glsl_type::bvec3_type = & builtin_core_types[2]; +const glsl_type *const glsl_type::bvec4_type = & builtin_core_types[3]; const glsl_type *const glsl_type::int_type = & builtin_core_types[4]; +const glsl_type *const glsl_type::ivec2_type = & builtin_core_types[5]; +const glsl_type *const glsl_type::ivec3_type = & builtin_core_types[6]; const glsl_type *const glsl_type::ivec4_type = & builtin_core_types[7]; const glsl_type *const glsl_type::float_type = & builtin_core_types[8]; const glsl_type *const glsl_type::vec2_type = & builtin_core_types[9]; diff --git a/mesalib/src/glsl/glcpp/glcpp-parse.y b/mesalib/src/glsl/glcpp/glcpp-parse.y index c0c1ca197..bf6f3ad01 100644 --- a/mesalib/src/glsl/glcpp/glcpp-parse.y +++ b/mesalib/src/glsl/glcpp/glcpp-parse.y @@ -213,7 +213,7 @@ expanded_line: parser->new_line_number = $2; ralloc_asprintf_rewrite_tail (&parser->output, &parser->output_length, - "#line %" PRIiMAX, + "#line %" PRIiMAX "\n", $2); } | LINE_EXPANDED integer_constant integer_constant NEWLINE { @@ -223,7 +223,7 @@ expanded_line: parser->new_source_number = $3; ralloc_asprintf_rewrite_tail (&parser->output, &parser->output_length, - "#line %" PRIiMAX " %" PRIiMAX, + "#line %" PRIiMAX " %" PRIiMAX "\n", $2, $3); } ; diff --git a/mesalib/src/glsl/glsl_parser.yy b/mesalib/src/glsl/glsl_parser.yy index 337337591..f61d6b8dd 100644 --- a/mesalib/src/glsl/glsl_parser.yy +++ b/mesalib/src/glsl/glsl_parser.yy @@ -301,7 +301,7 @@ pragma_statement: | PRAGMA_OPTIMIZE_OFF EOL | PRAGMA_INVARIANT_ALL EOL { - if (state->language_version < 120) { + if (state->language_version < 120 && !state->Const.GLSL_100ES) { _mesa_glsl_warning(& @1, state, "pragma `invariant(all)' not supported in %s", state->version_string); @@ -1967,6 +1967,7 @@ member_declaration: type->specifier = $3; $$ = new(ctx) ast_declarator_list(type); $$->set_location(yylloc); + $$->ubo_qualifiers_valid = true; $$->declarations.push_degenerate_list_at_head(& $4->link); } @@ -1980,6 +1981,7 @@ member_declaration: type->specifier = $2; $$ = new(ctx) ast_declarator_list(type); $$->set_location(yylloc); + $$->ubo_qualifiers_valid = true; $$->declarations.push_degenerate_list_at_head(& $3->link); } diff --git a/mesalib/src/glsl/glsl_parser_extras.cpp b/mesalib/src/glsl/glsl_parser_extras.cpp index d9ee406cf..7a9b22197 100644 --- a/mesalib/src/glsl/glsl_parser_extras.cpp +++ b/mesalib/src/glsl/glsl_parser_extras.cpp @@ -27,6 +27,7 @@ extern "C" { #include "main/core.h" /* for struct gl_context */ +#include "main/context.h" } #include "ralloc.h" @@ -90,19 +91,17 @@ _mesa_glsl_parse_state::_mesa_glsl_parse_state(struct gl_context *_ctx, */ this->Const.GLSL_100ES = (ctx->API == API_OPENGLES2) || ctx->Extensions.ARB_ES2_compatibility; - this->Const.GLSL_110 = (ctx->API == API_OPENGL); - this->Const.GLSL_120 = (ctx->API == API_OPENGL) - && (ctx->Const.GLSLVersion >= 120); - this->Const.GLSL_130 = (ctx->API == API_OPENGL) - && (ctx->Const.GLSLVersion >= 130); - this->Const.GLSL_140 = (ctx->API == API_OPENGL) - && (ctx->Const.GLSLVersion >= 140); + bool is_desktop_gl = _mesa_is_desktop_gl(ctx); + this->Const.GLSL_110 = is_desktop_gl; + this->Const.GLSL_120 = is_desktop_gl && (ctx->Const.GLSLVersion >= 120); + this->Const.GLSL_130 = is_desktop_gl && (ctx->Const.GLSLVersion >= 130); + this->Const.GLSL_140 = is_desktop_gl && (ctx->Const.GLSLVersion >= 140); const unsigned lowest_version = (ctx->API == API_OPENGLES2) || ctx->Extensions.ARB_ES2_compatibility ? 100 : 110; const unsigned highest_version = - (ctx->API == API_OPENGL) ? ctx->Const.GLSLVersion : 100; + is_desktop_gl ? ctx->Const.GLSLVersion : 100; char *supported = ralloc_strdup(this, ""); for (unsigned ver = lowest_version; ver <= highest_version; ver += 10) { @@ -773,6 +772,7 @@ ast_declarator_list::ast_declarator_list(ast_fully_specified_type *type) { this->type = type; this->invariant = false; + this->ubo_qualifiers_valid = false; } void diff --git a/mesalib/src/glsl/glsl_parser_extras.h b/mesalib/src/glsl/glsl_parser_extras.h index d97217ef9..fc5d11cb9 100644 --- a/mesalib/src/glsl/glsl_parser_extras.h +++ b/mesalib/src/glsl/glsl_parser_extras.h @@ -82,6 +82,10 @@ struct _mesa_glsl_parse_state { exec_list translation_unit; glsl_symbol_table *symbols; + unsigned num_uniform_blocks; + unsigned uniform_block_array_size; + struct gl_uniform_block *uniform_blocks; + bool es_shader; unsigned language_version; const char *version_string; diff --git a/mesalib/src/glsl/glsl_types.cpp b/mesalib/src/glsl/glsl_types.cpp index 8a34b8eb0..3d7866058 100644 --- a/mesalib/src/glsl/glsl_types.cpp +++ b/mesalib/src/glsl/glsl_types.cpp @@ -628,3 +628,223 @@ glsl_type::can_implicitly_convert_to(const glsl_type *desired) const && this->is_integer() && this->vector_elements == desired->vector_elements; } + +unsigned +glsl_type::std140_base_alignment(bool row_major) const +{ + /* (1) If the member is a scalar consuming <N> basic machine units, the + * base alignment is <N>. + * + * (2) If the member is a two- or four-component vector with components + * consuming <N> basic machine units, the base alignment is 2<N> or + * 4<N>, respectively. + * + * (3) If the member is a three-component vector with components consuming + * <N> basic machine units, the base alignment is 4<N>. + */ + if (this->is_scalar() || this->is_vector()) { + switch (this->vector_elements) { + case 1: + return 4; + case 2: + return 8; + case 3: + case 4: + return 16; + } + } + + /* (4) If the member is an array of scalars or vectors, the base alignment + * and array stride are set to match the base alignment of a single + * array element, according to rules (1), (2), and (3), and rounded up + * to the base alignment of a vec4. The array may have padding at the + * end; the base offset of the member following the array is rounded up + * to the next multiple of the base alignment. + * + * (6) If the member is an array of <S> column-major matrices with <C> + * columns and <R> rows, the matrix is stored identically to a row of + * <S>*<C> column vectors with <R> components each, according to rule + * (4). + * + * (8) If the member is an array of <S> row-major matrices with <C> columns + * and <R> rows, the matrix is stored identically to a row of <S>*<R> + * row vectors with <C> components each, according to rule (4). + * + * (10) If the member is an array of <S> structures, the <S> elements of + * the array are laid out in order, according to rule (9). + */ + if (this->is_array()) { + if (this->fields.array->is_scalar() || + this->fields.array->is_vector() || + this->fields.array->is_matrix()) { + return MAX2(this->fields.array->std140_base_alignment(row_major), 16); + } else { + assert(this->fields.array->is_record()); + return this->fields.array->std140_base_alignment(row_major); + } + } + + /* (5) If the member is a column-major matrix with <C> columns and + * <R> rows, the matrix is stored identically to an array of + * <C> column vectors with <R> components each, according to + * rule (4). + * + * (7) If the member is a row-major matrix with <C> columns and <R> + * rows, the matrix is stored identically to an array of <R> + * row vectors with <C> components each, according to rule (4). + */ + if (this->is_matrix()) { + const struct glsl_type *vec_type; + if (row_major) { + vec_type = get_instance(GLSL_TYPE_FLOAT, this->vector_elements, 1); + } else { + vec_type = get_instance(GLSL_TYPE_FLOAT, this->matrix_columns, 1); + } + + return vec_type->std140_base_alignment(false); + } + + /* (9) If the member is a structure, the base alignment of the + * structure is <N>, where <N> is the largest base alignment + * value of any of its members, and rounded up to the base + * alignment of a vec4. The individual members of this + * sub-structure are then assigned offsets by applying this set + * of rules recursively, where the base offset of the first + * member of the sub-structure is equal to the aligned offset + * of the structure. The structure may have padding at the end; + * the base offset of the member following the sub-structure is + * rounded up to the next multiple of the base alignment of the + * structure. + */ + if (this->is_record()) { + unsigned base_alignment = 16; + for (unsigned i = 0; i < this->length; i++) { + const struct glsl_type *field_type = this->fields.structure[i].type; + base_alignment = MAX2(base_alignment, + field_type->std140_base_alignment(row_major)); + } + return base_alignment; + } + + assert(!"not reached"); + return -1; +} + +static unsigned +align(unsigned val, unsigned align) +{ + return (val + align - 1) / align * align; +} + +unsigned +glsl_type::std140_size(bool row_major) const +{ + /* (1) If the member is a scalar consuming <N> basic machine units, the + * base alignment is <N>. + * + * (2) If the member is a two- or four-component vector with components + * consuming <N> basic machine units, the base alignment is 2<N> or + * 4<N>, respectively. + * + * (3) If the member is a three-component vector with components consuming + * <N> basic machine units, the base alignment is 4<N>. + */ + if (this->is_scalar() || this->is_vector()) { + return this->vector_elements * 4; + } + + /* (5) If the member is a column-major matrix with <C> columns and + * <R> rows, the matrix is stored identically to an array of + * <C> column vectors with <R> components each, according to + * rule (4). + * + * (6) If the member is an array of <S> column-major matrices with <C> + * columns and <R> rows, the matrix is stored identically to a row of + * <S>*<C> column vectors with <R> components each, according to rule + * (4). + * + * (7) If the member is a row-major matrix with <C> columns and <R> + * rows, the matrix is stored identically to an array of <R> + * row vectors with <C> components each, according to rule (4). + * + * (8) If the member is an array of <S> row-major matrices with <C> columns + * and <R> rows, the matrix is stored identically to a row of <S>*<R> + * row vectors with <C> components each, according to rule (4). + */ + if (this->is_matrix() || (this->is_array() && + this->fields.array->is_matrix())) { + const struct glsl_type *element_type; + const struct glsl_type *vec_type; + unsigned int array_len; + + if (this->is_array()) { + element_type = this->fields.array; + array_len = this->length; + } else { + element_type = this; + array_len = 1; + } + + if (row_major) { + vec_type = get_instance(GLSL_TYPE_FLOAT, + element_type->matrix_columns, 1); + array_len *= element_type->vector_elements; + } else { + vec_type = get_instance(GLSL_TYPE_FLOAT, + element_type->vector_elements, 1); + array_len *= element_type->matrix_columns; + } + const glsl_type *array_type = glsl_type::get_array_instance(vec_type, + array_len); + + return array_type->std140_size(false); + } + + /* (4) If the member is an array of scalars or vectors, the base alignment + * and array stride are set to match the base alignment of a single + * array element, according to rules (1), (2), and (3), and rounded up + * to the base alignment of a vec4. The array may have padding at the + * end; the base offset of the member following the array is rounded up + * to the next multiple of the base alignment. + * + * (10) If the member is an array of <S> structures, the <S> elements of + * the array are laid out in order, according to rule (9). + */ + if (this->is_array()) { + if (this->fields.array->is_record()) { + return this->length * this->fields.array->std140_size(row_major); + } else { + unsigned element_base_align = + this->fields.array->std140_base_alignment(row_major); + return this->length * MAX2(element_base_align, 16); + } + } + + /* (9) If the member is a structure, the base alignment of the + * structure is <N>, where <N> is the largest base alignment + * value of any of its members, and rounded up to the base + * alignment of a vec4. The individual members of this + * sub-structure are then assigned offsets by applying this set + * of rules recursively, where the base offset of the first + * member of the sub-structure is equal to the aligned offset + * of the structure. The structure may have padding at the end; + * the base offset of the member following the sub-structure is + * rounded up to the next multiple of the base alignment of the + * structure. + */ + if (this->is_record()) { + unsigned size = 0; + for (unsigned i = 0; i < this->length; i++) { + const struct glsl_type *field_type = this->fields.structure[i].type; + unsigned align = field_type->std140_base_alignment(row_major); + size = (size + align - 1) / align * align; + size += field_type->std140_size(row_major); + } + size = align(size, + this->fields.structure[0].type->std140_base_alignment(row_major)); + return size; + } + + assert(!"not reached"); + return -1; +} diff --git a/mesalib/src/glsl/glsl_types.h b/mesalib/src/glsl/glsl_types.h index 48d41d7f8..915d1a22b 100644 --- a/mesalib/src/glsl/glsl_types.h +++ b/mesalib/src/glsl/glsl_types.h @@ -152,6 +152,8 @@ struct glsl_type { static const glsl_type *const error_type; static const glsl_type *const void_type; static const glsl_type *const int_type; + static const glsl_type *const ivec2_type; + static const glsl_type *const ivec3_type; static const glsl_type *const ivec4_type; static const glsl_type *const uint_type; static const glsl_type *const uvec2_type; @@ -162,6 +164,9 @@ struct glsl_type { static const glsl_type *const vec3_type; static const glsl_type *const vec4_type; static const glsl_type *const bool_type; + static const glsl_type *const bvec2_type; + static const glsl_type *const bvec3_type; + static const glsl_type *const bvec4_type; static const glsl_type *const mat2_type; static const glsl_type *const mat2x3_type; static const glsl_type *const mat2x4_type; @@ -243,6 +248,19 @@ struct glsl_type { unsigned component_slots() const; /** + * Alignment in bytes of the start of this type in a std140 uniform + * block. + */ + unsigned std140_base_alignment(bool row_major) const; + + /** Size in bytes of this type in a std140 uniform block. + * + * Note that this is not GL_UNIFORM_SIZE (which is the number of + * elements in the array) + */ + unsigned std140_size(bool row_major) const; + + /** * \brief Can this type be implicitly converted to another? * * \return True if the types are identical or if this type can be converted diff --git a/mesalib/src/glsl/ir.cpp b/mesalib/src/glsl/ir.cpp index 1c9eec6e2..b0e38d820 100644 --- a/mesalib/src/glsl/ir.cpp +++ b/mesalib/src/glsl/ir.cpp @@ -1491,6 +1491,7 @@ ir_variable::ir_variable(const struct glsl_type *type, const char *name, this->explicit_location = false; this->has_initializer = false; this->location = -1; + this->uniform_block = -1; this->warn_extension = NULL; this->constant_value = NULL; this->constant_initializer = NULL; diff --git a/mesalib/src/glsl/ir.h b/mesalib/src/glsl/ir.h index 9bbf3b7ef..f019837d5 100644 --- a/mesalib/src/glsl/ir.h +++ b/mesalib/src/glsl/ir.h @@ -453,7 +453,8 @@ public: * - Vertex shader output: one of the values from \c gl_vert_result. * - Fragment shader input: one of the values from \c gl_frag_attrib. * - Fragment shader output: one of the values from \c gl_frag_result. - * - Uniforms: Per-stage uniform slot number. + * - Uniforms: Per-stage uniform slot number for default uniform block. + * - Uniforms: Index within the uniform block definition for UBO members. * - Other: This field is not currently used. * * If the variable is a uniform, shader input, or shader output, and the @@ -462,6 +463,16 @@ public: int location; /** + * Uniform block number for uniforms. + * + * This index is into the shader's list of uniform blocks, not the + * linked program's merged list. + * + * If the variable is not in a uniform block, the value will be -1. + */ + int uniform_block; + + /** * output index for dual source blending. */ int index; @@ -1016,7 +1027,7 @@ enum ir_expression_operation { /** * A sentinel marking the last of all operations. */ - ir_last_opcode = ir_last_binop + ir_last_opcode = ir_quadop_vector }; class ir_expression : public ir_rvalue { diff --git a/mesalib/src/glsl/ir_clone.cpp b/mesalib/src/glsl/ir_clone.cpp index 591fe7b77..4314efa76 100644 --- a/mesalib/src/glsl/ir_clone.cpp +++ b/mesalib/src/glsl/ir_clone.cpp @@ -54,6 +54,7 @@ ir_variable::clone(void *mem_ctx, struct hash_table *ht) const var->interpolation = this->interpolation; var->location = this->location; var->index = this->index; + var->uniform_block = this->uniform_block; var->warn_extension = this->warn_extension; var->origin_upper_left = this->origin_upper_left; var->pixel_center_integer = this->pixel_center_integer; diff --git a/mesalib/src/glsl/ir_set_program_inouts.cpp b/mesalib/src/glsl/ir_set_program_inouts.cpp index a7415c7e3..e5de07e01 100644 --- a/mesalib/src/glsl/ir_set_program_inouts.cpp +++ b/mesalib/src/glsl/ir_set_program_inouts.cpp @@ -26,8 +26,8 @@ * * Sets the InputsRead and OutputsWritten of Mesa programs. * - * Additionally, for fragment shaders, sets the InterpQualifier array and - * IsCentroid bitfield. + * Additionally, for fragment shaders, sets the InterpQualifier array, the + * IsCentroid bitfield, and the UsesDFdy flag. * * Mesa programs (gl_program, not gl_shader_program) have a set of * flags indicating which varyings are read and written. Computing @@ -61,6 +61,8 @@ public: virtual ir_visitor_status visit_enter(ir_dereference_array *); virtual ir_visitor_status visit_enter(ir_function_signature *); + virtual ir_visitor_status visit_enter(ir_expression *); + virtual ir_visitor_status visit_enter(ir_discard *); virtual ir_visitor_status visit(ir_dereference_variable *); virtual ir_visitor_status visit(ir_variable *); @@ -169,6 +171,28 @@ ir_set_program_inouts_visitor::visit_enter(ir_function_signature *ir) return visit_continue_with_parent; } +ir_visitor_status +ir_set_program_inouts_visitor::visit_enter(ir_expression *ir) +{ + if (is_fragment_shader && ir->operation == ir_unop_dFdy) { + gl_fragment_program *fprog = (gl_fragment_program *) prog; + fprog->UsesDFdy = true; + } + return visit_continue; +} + +ir_visitor_status +ir_set_program_inouts_visitor::visit_enter(ir_discard *) +{ + /* discards are only allowed in fragment shaders. */ + assert(is_fragment_shader); + + gl_fragment_program *fprog = (gl_fragment_program *) prog; + fprog->UsesKill = true; + + return visit_continue; +} + void do_set_program_inouts(exec_list *instructions, struct gl_program *prog, bool is_fragment_shader) @@ -179,9 +203,11 @@ do_set_program_inouts(exec_list *instructions, struct gl_program *prog, prog->OutputsWritten = 0; prog->SystemValuesRead = 0; if (is_fragment_shader) { - memset(((gl_fragment_program *) prog)->InterpQualifier, 0, - sizeof(((gl_fragment_program *) prog)->InterpQualifier)); - ((gl_fragment_program *) prog)->IsCentroid = 0; + gl_fragment_program *fprog = (gl_fragment_program *) prog; + memset(fprog->InterpQualifier, 0, sizeof(fprog->InterpQualifier)); + fprog->IsCentroid = 0; + fprog->UsesDFdy = false; + fprog->UsesKill = false; } visit_list_elements(&v, instructions); } diff --git a/mesalib/src/glsl/ir_uniform.h b/mesalib/src/glsl/ir_uniform.h index 225da3fc5..913c53773 100644 --- a/mesalib/src/glsl/ir_uniform.h +++ b/mesalib/src/glsl/ir_uniform.h @@ -119,6 +119,40 @@ struct gl_uniform_storage { * uniform if the \c ::driver_storage interface is not used. */ union gl_constant_value *storage; + + /** Fields for GL_ARB_uniform_buffer_object + * @{ + */ + + /** + * GL_UNIFORM_BLOCK_INDEX: index of the uniform block containing + * the uniform, or -1 for the default uniform block. Note that the + * index is into the linked program's UniformBlocks[] array, not + * the linked shader's. + */ + int block_index; + + /** GL_UNIFORM_OFFSET: byte offset within the uniform block, or -1. */ + int offset; + + /** + * GL_UNIFORM_MATRIX_STRIDE: byte stride between columns or rows of + * a matrix. Set to 0 for non-matrices in UBOs, or -1 for uniforms + * in the default uniform block. + */ + int matrix_stride; + + /** + * GL_UNIFORM_ARRAY_STRIDE: byte stride between elements of the + * array. Set to zero for non-arrays in UBOs, or -1 for uniforms + * in the default uniform block. + */ + int array_stride; + + /** GL_UNIFORM_ROW_MAJOR: true iff it's a row-major matrix in a UBO */ + bool row_major; + + /** @} */ }; #ifdef __cplusplus diff --git a/mesalib/src/glsl/link_uniforms.cpp b/mesalib/src/glsl/link_uniforms.cpp index 92e2a1fa5..d7ef5d4d2 100644 --- a/mesalib/src/glsl/link_uniforms.cpp +++ b/mesalib/src/glsl/link_uniforms.cpp @@ -27,6 +27,13 @@ #include "ir_uniform.h" #include "glsl_symbol_table.h" #include "program/hash_table.h" +#include "program.h" + +static inline unsigned int +align(unsigned int a, unsigned int align) +{ + return (a + align - 1) / align * align; +} /** * \file link_uniforms.cpp @@ -216,6 +223,28 @@ public: this->shader_shadow_samplers = 0; } + void set_and_process(struct gl_shader_program *prog, + ir_variable *var) + { + ubo_var = NULL; + if (var->uniform_block != -1) { + struct gl_uniform_block *block = + &prog->UniformBlocks[var->uniform_block]; + + ubo_block_index = var->uniform_block; + ubo_var_index = var->location; + ubo_var = &block->Uniforms[var->location]; + ubo_byte_offset = ubo_var->Offset; + } + + process(var); + } + + struct gl_uniform_buffer_variable *ubo_var; + int ubo_block_index; + int ubo_var_index; + int ubo_byte_offset; + private: virtual void visit_field(const glsl_type *type, const char *name) { @@ -291,6 +320,25 @@ private: this->uniforms[id].num_driver_storage = 0; this->uniforms[id].driver_storage = NULL; this->uniforms[id].storage = this->values; + if (this->ubo_var) { + this->uniforms[id].block_index = this->ubo_block_index; + + unsigned alignment = type->std140_base_alignment(ubo_var->RowMajor); + this->ubo_byte_offset = align(this->ubo_byte_offset, alignment); + this->uniforms[id].offset = this->ubo_byte_offset; + this->ubo_byte_offset += type->std140_size(ubo_var->RowMajor); + + this->uniforms[id].array_stride = 0; + this->uniforms[id].matrix_stride = 0; + this->uniforms[id].row_major = base_type->is_matrix() && + ubo_var->RowMajor; + } else { + this->uniforms[id].block_index = -1; + this->uniforms[id].offset = -1; + this->uniforms[id].array_stride = -1; + this->uniforms[id].matrix_stride = -1; + this->uniforms[id].row_major = false; + } this->values += values_for_type(type); } @@ -316,6 +364,125 @@ public: unsigned shader_shadow_samplers; }; +/** + * Merges a uniform block into an array of uniform blocks that may or + * may not already contain a copy of it. + * + * Returns the index of the new block in the array. + */ +int +link_cross_validate_uniform_block(void *mem_ctx, + struct gl_uniform_block **linked_blocks, + unsigned int *num_linked_blocks, + struct gl_uniform_block *new_block) +{ + for (unsigned int i = 0; i < *num_linked_blocks; i++) { + struct gl_uniform_block *old_block = &(*linked_blocks)[i]; + if (strcmp(old_block->Name, new_block->Name) == 0) { + if (old_block->NumUniforms != new_block->NumUniforms) { + return -1; + } + + for (unsigned j = 0; j < old_block->NumUniforms; j++) { + if (strcmp(old_block->Uniforms[j].Name, + new_block->Uniforms[j].Name) != 0) + return -1; + + if (old_block->Uniforms[j].Offset != + new_block->Uniforms[j].Offset) + return -1; + + if (old_block->Uniforms[j].RowMajor != + new_block->Uniforms[j].RowMajor) + return -1; + } + return i; + } + } + + *linked_blocks = reralloc(mem_ctx, *linked_blocks, + struct gl_uniform_block, + *num_linked_blocks + 1); + int linked_block_index = (*num_linked_blocks)++; + struct gl_uniform_block *linked_block = &(*linked_blocks)[linked_block_index]; + + memcpy(linked_block, new_block, sizeof(*new_block)); + linked_block->Uniforms = ralloc_array(*linked_blocks, + struct gl_uniform_buffer_variable, + linked_block->NumUniforms); + + memcpy(linked_block->Uniforms, + new_block->Uniforms, + sizeof(*linked_block->Uniforms) * linked_block->NumUniforms); + + for (unsigned int i = 0; i < linked_block->NumUniforms; i++) { + struct gl_uniform_buffer_variable *ubo_var = + &linked_block->Uniforms[i]; + + ubo_var->Name = ralloc_strdup(*linked_blocks, ubo_var->Name); + } + + return linked_block_index; +} + +/** + * Walks the IR and update the references to uniform blocks in the + * ir_variables to point at linked shader's list (previously, they + * would point at the uniform block list in one of the pre-linked + * shaders). + */ +static bool +link_update_uniform_buffer_variables(struct gl_shader *shader) +{ + foreach_list(node, shader->ir) { + ir_variable *const var = ((ir_instruction *) node)->as_variable(); + + if ((var == NULL) || (var->uniform_block == -1)) + continue; + + assert(var->mode == ir_var_uniform); + + bool found = false; + for (unsigned i = 0; i < shader->NumUniformBlocks; i++) { + for (unsigned j = 0; j < shader->UniformBlocks[i].NumUniforms; j++) { + if (!strcmp(var->name, shader->UniformBlocks[i].Uniforms[j].Name)) { + found = true; + var->uniform_block = i; + var->location = j; + break; + } + } + if (found) + break; + } + assert(found); + } + + return true; +} + +void +link_assign_uniform_block_offsets(struct gl_shader *shader) +{ + for (unsigned b = 0; b < shader->NumUniformBlocks; b++) { + struct gl_uniform_block *block = &shader->UniformBlocks[b]; + + unsigned offset = 0; + for (unsigned int i = 0; i < block->NumUniforms; i++) { + struct gl_uniform_buffer_variable *ubo_var = &block->Uniforms[i]; + const struct glsl_type *type = ubo_var->Type; + + unsigned alignment = type->std140_base_alignment(ubo_var->RowMajor); + unsigned size = type->std140_size(ubo_var->RowMajor); + + offset = align(offset, alignment); + ubo_var->Offset = offset; + offset += size; + } + block->UniformBufferSize = offset; + } +} + void link_assign_uniform_locations(struct gl_shader_program *prog) { @@ -340,6 +507,14 @@ link_assign_uniform_locations(struct gl_shader_program *prog) */ memset(prog->SamplerUnits, 0, sizeof(prog->SamplerUnits)); + for (unsigned i = 0; i < MESA_SHADER_TYPES; i++) { + if (prog->_LinkedShaders[i] == NULL) + continue; + + if (!link_update_uniform_buffer_variables(prog->_LinkedShaders[i])) + return; + } + /* First pass: Count the uniform resources used by the user-defined * uniforms. While this happens, each active uniform will have an index * assigned to it. @@ -412,7 +587,7 @@ link_assign_uniform_locations(struct gl_shader_program *prog) if (strncmp("gl_", var->name, 3) == 0) continue; - parcel.process(var); + parcel.set_and_process(prog, var); } prog->_LinkedShaders[i]->active_samplers = parcel.shader_samplers_used; diff --git a/mesalib/src/glsl/linker.cpp b/mesalib/src/glsl/linker.cpp index f06298cf6..bfdde4023 100644 --- a/mesalib/src/glsl/linker.cpp +++ b/mesalib/src/glsl/linker.cpp @@ -581,6 +581,48 @@ cross_validate_uniforms(struct gl_shader_program *prog) MESA_SHADER_TYPES, true); } +/** + * Accumulates the array of prog->UniformBlocks and checks that all + * definitons of blocks agree on their contents. + */ +static bool +interstage_cross_validate_uniform_blocks(struct gl_shader_program *prog) +{ + unsigned max_num_uniform_blocks = 0; + for (unsigned i = 0; i < MESA_SHADER_TYPES; i++) { + if (prog->_LinkedShaders[i]) + max_num_uniform_blocks += prog->_LinkedShaders[i]->NumUniformBlocks; + } + + for (unsigned i = 0; i < MESA_SHADER_TYPES; i++) { + struct gl_shader *sh = prog->_LinkedShaders[i]; + + prog->UniformBlockStageIndex[i] = ralloc_array(prog, int, + max_num_uniform_blocks); + for (unsigned int j = 0; j < max_num_uniform_blocks; j++) + prog->UniformBlockStageIndex[i][j] = -1; + + if (sh == NULL) + continue; + + for (unsigned int j = 0; j < sh->NumUniformBlocks; j++) { + int index = link_cross_validate_uniform_block(prog, + &prog->UniformBlocks, + &prog->NumUniformBlocks, + &sh->UniformBlocks[j]); + + if (index == -1) { + linker_error(prog, "uniform block `%s' has mismatching definitions", + sh->UniformBlocks[j].Name); + return false; + } + + prog->UniformBlockStageIndex[i][index] = j; + } + } + + return true; +} /** * Validate that outputs from one stage match inputs of another @@ -910,7 +952,6 @@ public: } }; - /** * Combine a group of shaders for a single stage to generate a linked shader * @@ -925,11 +966,33 @@ link_intrastage_shaders(void *mem_ctx, struct gl_shader **shader_list, unsigned num_shaders) { + struct gl_uniform_block *uniform_blocks = NULL; + unsigned num_uniform_blocks = 0; + /* Check that global variables defined in multiple shaders are consistent. */ if (!cross_validate_globals(prog, shader_list, num_shaders, false)) return NULL; + /* Check that uniform blocks between shaders for a stage agree. */ + for (unsigned i = 0; i < num_shaders; i++) { + struct gl_shader *sh = shader_list[i]; + + for (unsigned j = 0; j < shader_list[i]->NumUniformBlocks; j++) { + link_assign_uniform_block_offsets(shader_list[i]); + + int index = link_cross_validate_uniform_block(mem_ctx, + &uniform_blocks, + &num_uniform_blocks, + &sh->UniformBlocks[j]); + if (index == -1) { + linker_error(prog, "uniform block `%s' has mismatching definitions", + sh->UniformBlocks[j].Name); + return NULL; + } + } + } + /* Check that there is only a single definition of each function signature * across all shaders. */ @@ -997,6 +1060,10 @@ link_intrastage_shaders(void *mem_ctx, linked->ir = new(linked) exec_list; clone_ir_list(mem_ctx, linked->ir, main->ir); + linked->UniformBlocks = uniform_blocks; + linked->NumUniformBlocks = num_uniform_blocks; + ralloc_steal(linked, linked->UniformBlocks); + populate_symbol_table(linked); /* The a pointer to the main function in the final linked shader (i.e., the @@ -1100,6 +1167,13 @@ update_array_sizes(struct gl_shader_program *prog) !var->type->is_array()) continue; + /* GL_ARB_uniform_buffer_object says that std140 uniforms + * will not be eliminated. Since we always do std140, just + * don't resize arrays in UBOs. + */ + if (var->uniform_block != -1) + continue; + unsigned int size = var->max_array_access; for (unsigned j = 0; j < MESA_SHADER_TYPES; j++) { if (prog->_LinkedShaders[j] == NULL) @@ -2289,11 +2363,17 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog) prog->Validated = false; prog->_Used = false; - if (prog->InfoLog != NULL) - ralloc_free(prog->InfoLog); - + ralloc_free(prog->InfoLog); prog->InfoLog = ralloc_strdup(NULL, ""); + ralloc_free(prog->UniformBlocks); + prog->UniformBlocks = NULL; + prog->NumUniformBlocks = 0; + for (int i = 0; i < MESA_SHADER_TYPES; i++) { + ralloc_free(prog->UniformBlockStageIndex[i]); + prog->UniformBlockStageIndex[i] = NULL; + } + /* Separate the shaders into groups based on their type. */ struct gl_shader **vert_shader_list; @@ -2422,6 +2502,9 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog) } } + if (!interstage_cross_validate_uniform_blocks(prog)) + goto done; + /* Do common optimization before assigning storage for attributes, * uniforms, and varyings. Later optimization could possibly make * some of that unused. diff --git a/mesalib/src/glsl/linker.h b/mesalib/src/glsl/linker.h index d0aaf3e1e..7d2e98a15 100644 --- a/mesalib/src/glsl/linker.h +++ b/mesalib/src/glsl/linker.h @@ -40,6 +40,15 @@ link_assign_uniform_locations(struct gl_shader_program *prog); extern void link_set_uniform_initializers(struct gl_shader_program *prog); +extern int +link_cross_validate_uniform_block(void *mem_ctx, + struct gl_uniform_block **linked_blocks, + unsigned int *num_linked_blocks, + struct gl_uniform_block *new_block); + +void +link_assign_uniform_block_offsets(struct gl_shader *shader); + /** * Class for processing all of the leaf fields of an uniform * diff --git a/mesalib/src/glsl/lower_vector.cpp b/mesalib/src/glsl/lower_vector.cpp index 57963a121..0cd6909db 100644 --- a/mesalib/src/glsl/lower_vector.cpp +++ b/mesalib/src/glsl/lower_vector.cpp @@ -183,7 +183,7 @@ lower_vector_visitor::handle_rvalue(ir_rvalue **rvalue) if (assigned > 0) { ir_constant *const c = new(mem_ctx) ir_constant(glsl_type::get_instance(expr->type->base_type, - assigned, 0), + assigned, 1), &d); ir_dereference *const lhs = new(mem_ctx) ir_dereference_variable(temp); ir_assignment *const assign = diff --git a/mesalib/src/glsl/opt_dead_code.cpp b/mesalib/src/glsl/opt_dead_code.cpp index 0578f1737..de8475f95 100644 --- a/mesalib/src/glsl/opt_dead_code.cpp +++ b/mesalib/src/glsl/opt_dead_code.cpp @@ -95,9 +95,15 @@ do_dead_code(exec_list *instructions, bool uniform_locations_assigned) /* uniform initializers are precious, and could get used by another * stage. Also, once uniform locations have been assigned, the * declaration cannot be deleted. + * + * Also, GL_ARB_uniform_buffer_object says that std140 + * uniforms will not be eliminated. Since we always do + * std140, just don't eliminate uniforms in UBOs. */ if (entry->var->mode == ir_var_uniform && - (uniform_locations_assigned || entry->var->constant_value)) + (uniform_locations_assigned || + entry->var->constant_value || + entry->var->uniform_block != -1)) continue; entry->var->remove(); diff --git a/mesalib/src/glsl/strtod.c b/mesalib/src/glsl/strtod.c index a876e138b..47c1f0ed6 100644 --- a/mesalib/src/glsl/strtod.c +++ b/mesalib/src/glsl/strtod.c @@ -45,7 +45,7 @@ double glsl_strtod(const char *s, char **end) { #if defined(_GNU_SOURCE) && !defined(__CYGWIN__) && !defined(__FreeBSD__) && \ - !defined(__HAIKU__) + !defined(__HAIKU__) && !defined(__UCLIBC__) static locale_t loc = NULL; if (!loc) { loc = newlocale(LC_CTYPE_MASK, "C", NULL); diff --git a/mesalib/src/mesa/Android.gen.mk b/mesalib/src/mesa/Android.gen.mk index 2ea8cc433..5443bb99f 100644 --- a/mesalib/src/mesa/Android.gen.mk +++ b/mesalib/src/mesa/Android.gen.mk @@ -28,12 +28,19 @@ LOCAL_MODULE_CLASS := STATIC_LIBRARIES endif intermediates := $(call local-intermediates-dir) -mydir := $(call my-dir) +# This is the list of auto-generated files: sources and headers sources := \ + main/enums.c \ + main/api_exec_es1.c \ main/api_exec_es1_dispatch.h \ main/api_exec_es1_remap_helper.h \ + main/api_exec_es2.c \ main/api_exec_es2_dispatch.h \ + program/program_parse.tab.c \ + program/lex.yy.c \ + main/dispatch.h \ + main/remap_helper.h \ main/api_exec_es2_remap_helper.h LOCAL_SRC_FILES := $(filter-out $(sources), $(LOCAL_SRC_FILES)) @@ -65,37 +72,49 @@ es_hdr_deps := \ $(wildcard $(glapi)/*.py) \ $(wildcard $(glapi)/*.xml) +define local-l-to-c + @mkdir -p $(dir $@) + @echo "Mesa Lex: $(PRIVATE_MODULE) <= $<" + $(hide) $(LEX) -o$@ $< +endef + +define local-y-to-c-and-h + @mkdir -p $(dir $@) + @echo "Mesa Yacc: $(PRIVATE_MODULE) <= $<" + $(hide) $(YACC) -o $@ $< +endef + define es-gen @mkdir -p $(dir $@) @echo "Gen ES: $(PRIVATE_MODULE) <= $(notdir $(@))" $(hide) $(PRIVATE_SCRIPT) $(1) $(PRIVATE_XML) > $@ endef -define generate-local - @echo "generate local sources" - $(hide) $(MESA_PYTHON2) $(glapi)/gl_enums.py -f $(glapi)/gl_and_es_API.xml > $(mydir)/main/enums.c - $(hide) $(MESA_PYTHON2) $(glapi)/gl_table.py -m remap_table -f $(glapi)/gl_and_es_API.xml > $(mydir)/main/dispatch.h - $(hide) $(MESA_PYTHON2) $(glapi)/remap_helper.py -f $(glapi)/gl_API.xml > $(mydir)/main/remap_helper.h - $(hide) $(MESA_PYTHON2) $(mydir)/main/es_generator.py -V GLES1.1 -S $(mydir)/main/APIspec.xml > $(mydir)/main/api_exec_es1.c - $(hide) $(MESA_PYTHON2) $(mydir)/main/es_generator.py -V GLES2.0 -S $(mydir)/main/APIspec.xml > $(mydir)/main/api_exec_es2.c - - @echo "Mesa Lex : $(PRIVATE_MODULE)" - $(hide) $(LEX) -o $(mydir)/program/lex.yy.c $(mydir)/program/program_lexer.l - @echo "Mesa Yacc: $(PRIVATE_MODULE)" - $(hide) $(YACC) -d -o $(mydir)/program/program_parse.tab.c $(mydir)/program/program_parse.y -endef - +$(intermediates)/main/api_exec_%.c: PRIVATE_SCRIPT := $(MESA_PYTHON2) $(LOCAL_PATH)/main/es_generator.py +$(intermediates)/main/api_exec_%.c: PRIVATE_XML := -S $(LOCAL_PATH)/main/APIspec.xml $(intermediates)/main/api_exec_%_dispatch.h: PRIVATE_SCRIPT := $(MESA_PYTHON2) $(glapi)/gl_table.py $(intermediates)/main/api_exec_%_dispatch.h: PRIVATE_XML := -f $(glapi)/gl_and_es_API.xml $(intermediates)/main/api_exec_%_remap_helper.h: PRIVATE_SCRIPT := $(MESA_PYTHON2) $(glapi)/remap_helper.py $(intermediates)/main/api_exec_%_remap_helper.h: PRIVATE_XML := -f $(glapi)/gl_and_es_API.xml +$(intermediates)/main/api_exec_es1.c: $(es_src_deps) + $(call es-gen, -V GLES1.1) + +$(intermediates)/main/api_exec_es2.c: $(es_src_deps) + $(call es-gen, -V GLES2.0) + $(intermediates)/main/api_exec_%_dispatch.h: $(es_hdr_deps) $(call es-gen, -c $* -m remap_table) $(intermediates)/main/api_exec_%_remap_helper.h: $(es_hdr_deps) $(call es-gen, -c $*) +$(intermediates)/program/program_parse.tab.c: $(LOCAL_PATH)/program/program_parse.y + $(local-y-to-c-and-h) + +$(intermediates)/program/lex.yy.c: $(LOCAL_PATH)/program/program_lexer.l + $(local-l-to-c) + $(intermediates)/main/git_sha1.h: @mkdir -p $(dir $@) @echo "GIT-SHA1: $(PRIVATE_MODULE) <= git" @@ -115,4 +134,21 @@ $(intermediates)/x86/matypes.h: $(matypes_deps) @mkdir -p $(dir $@) @echo "MATYPES: $(PRIVATE_MODULE) <= $(notdir $@)" $(hide) $< > $@ - $(call generate-local) + +$(intermediates)/main/dispatch.h: PRIVATE_SCRIPT := $(MESA_PYTHON2) $(glapi)/gl_table.py +$(intermediates)/main/dispatch.h: PRIVATE_XML := -f $(glapi)/gl_and_es_API.xml + +$(intermediates)/main/dispatch.h: $(es_hdr_deps) + $(call es-gen, $* -m remap_table) + +$(intermediates)/main/remap_helper.h: PRIVATE_SCRIPT := $(MESA_PYTHON2) $(glapi)/remap_helper.py +$(intermediates)/main/remap_helper.h: PRIVATE_XML := -f $(glapi)/gl_API.xml + +$(intermediates)/main/remap_helper.h: $(es_hdr_deps) + $(call es-gen, $*) + +$(intermediates)/main/enums.c: PRIVATE_SCRIPT :=$(MESA_PYTHON2) $(glapi)/gl_enums.py +$(intermediates)/main/enums.c: PRIVATE_XML := -f $(glapi)/gl_and_es_API.xml + +$(intermediates)/main/enums.c: $(es_src_deps) + $(call es-gen) diff --git a/mesalib/src/mesa/Android.mk b/mesalib/src/mesa/Android.mk index 115db4703..4b62b8194 100644 --- a/mesalib/src/mesa/Android.mk +++ b/mesalib/src/mesa/Android.mk @@ -31,7 +31,6 @@ LOCAL_PATH := $(call my-dir) # MESA_GALLIUM_FILES # MESA_FILES # X86_FILES -SRCDIR = . include $(LOCAL_PATH)/sources.mak common_CFLAGS := \ diff --git a/mesalib/src/mesa/Makefile.am b/mesalib/src/mesa/Makefile.am index 2b023d727..2ec57ea91 100644 --- a/mesalib/src/mesa/Makefile.am +++ b/mesalib/src/mesa/Makefile.am @@ -95,7 +95,7 @@ program/lex.yy.c: program/program_lexer.l noinst_LTLIBRARIES = libmesa.la libmesagallium.la -SRCDIR = $(top_srcdir)/src/mesa +SRCDIR = $(top_srcdir)/src/mesa/ include sources.mak AM_CPPFLAGS = $(API_DEFINES) $(DEFINES) $(INCLUDE_DIRS) @@ -131,9 +131,6 @@ libmesagallium_la_SOURCES = \ libmesagallium_la_LIBADD = $(top_builddir)/src/glsl/libglsl.la libmesagallium_la_LDFLAGS = -install-exec-local: - $(MAKE) -f $(srcdir)/Makefile.old install - # Provide compatibility with scripts for the old Mesa build system for # a while by putting a link to the library in the current directory. all-local: libmesa.la libmesagallium.la @@ -149,3 +146,7 @@ pkgconfig_DATA = osmesa.pc else pkgconfig_DATA = gl.pc endif + +# Emacs tags +tags: + etags `find . -name \*.[ch]` $(TOP)/include/GL/*.h diff --git a/mesalib/src/mesa/Makefile.old b/mesalib/src/mesa/Makefile.old deleted file mode 100644 index 3266a5de0..000000000 --- a/mesalib/src/mesa/Makefile.old +++ /dev/null @@ -1,27 +0,0 @@ -# src/mesa/Makefile - -TOP = ../.. -include $(TOP)/configs/current - -SRCDIR = . -include sources.mak - -default: - -###################################################################### -# Installation rules - -install: default $(DRICORE_INSTALL_TARGET) - @for driver in $(DRIVER_DIRS) ; do \ - case "$$driver" in \ - osmesa) $(MAKE) -f Makefile.old install-osmesa || exit 1 ;; \ - esac ; \ - done - -install-osmesa: default - $(MINSTALL) $(TOP)/$(LIB_DIR)/$(OSMESA_LIB_GLOB) \ - $(DESTDIR)$(INSTALL_LIB_DIR) - -# Emacs tags -tags: - etags `find . -name \*.[ch]` $(TOP)/include/GL/*.h diff --git a/mesalib/src/mesa/SConscript b/mesalib/src/mesa/SConscript index 906c57962..a3cbc16de 100644 --- a/mesalib/src/mesa/SConscript +++ b/mesalib/src/mesa/SConscript @@ -80,6 +80,7 @@ main_sources = [ 'main/framebuffer.c', 'main/get.c', 'main/getstring.c', + 'main/glformats.c', 'main/hash.c', 'main/hint.c', 'main/histogram.c', diff --git a/mesalib/src/mesa/drivers/common/meta.c b/mesalib/src/mesa/drivers/common/meta.c index cf2d05337..6846bbc60 100644 --- a/mesalib/src/mesa/drivers/common/meta.c +++ b/mesalib/src/mesa/drivers/common/meta.c @@ -46,6 +46,7 @@ #include "main/fbobject.h" #include "main/feedback.h" #include "main/formats.h" +#include "main/glformats.h" #include "main/image.h" #include "main/macros.h" #include "main/matrix.h" @@ -1847,7 +1848,7 @@ meta_glsl_clear_init(struct gl_context *ctx, struct clear_state *clear) clear->ColorLocation = _mesa_GetUniformLocationARB(clear->ShaderProg, "color"); - if (ctx->API == API_OPENGL && ctx->Const.GLSLVersion >= 130) { + if (_mesa_is_desktop_gl(ctx) && ctx->Const.GLSLVersion >= 130) { vs = compile_shader_with_debug(ctx, GL_VERTEX_SHADER, vs_int_source); fs = compile_shader_with_debug(ctx, GL_FRAGMENT_SHADER, fs_int_source); @@ -2280,8 +2281,7 @@ _mesa_meta_DrawPixels(struct gl_context *ctx, * Determine if we can do the glDrawPixels with texture mapping. */ fallback = GL_FALSE; - if (ctx->_ImageTransferState || - ctx->Fog.Enabled) { + if (ctx->Fog.Enabled) { fallback = GL_TRUE; } @@ -2316,6 +2316,7 @@ _mesa_meta_DrawPixels(struct gl_context *ctx, texIntFormat = GL_ALPHA; metaExtraSave = (MESA_META_COLOR_MASK | MESA_META_DEPTH_TEST | + MESA_META_PIXEL_TRANSFER | MESA_META_SHADER | MESA_META_STENCIL_TEST); } diff --git a/mesalib/src/mesa/drivers/dri/common/drirc b/mesalib/src/mesa/drivers/dri/common/drirc index 2d9287852..cf13cdb80 100644 --- a/mesalib/src/mesa/drivers/dri/common/drirc +++ b/mesalib/src/mesa/drivers/dri/common/drirc @@ -2,15 +2,25 @@ <device screen="0" driver="i965"> <application name="Unigine Sanctuary" executable="Sanctuary"> <option name="force_glsl_extensions_warn" value="true" /> + <option name="disable_blend_func_extended" value="true" /> </application> <application name="Unigine Tropics" executable="Tropics"> <option name="force_glsl_extensions_warn" value="true" /> + <option name="disable_blend_func_extended" value="true" /> </application> <application name="Unigine Heaven (32-bit)" executable="heaven_x86"> <option name="force_glsl_extensions_warn" value="true" /> + <option name="disable_blend_func_extended" value="true" /> </application> <application name="Unigine Heaven (64-bit)" executable="heaven_x64"> <option name="force_glsl_extensions_warn" value="true" /> + <option name="disable_blend_func_extended" value="true" /> + </application> + <application name="Unigine OilRush (32-bit)" executable="OilRush_x86"> + <option name="disable_blend_func_extended" value="true" /> + </application> + <application name="Unigine OilRush (64-bit)" executable="OilRush_x64"> + <option name="disable_blend_func_extended" value="true" /> </application> </device> </driconf> diff --git a/mesalib/src/mesa/drivers/dri/common/xmlpool/options.h b/mesalib/src/mesa/drivers/dri/common/xmlpool/options.h index 75c887e5d..a20e3d12d 100644 --- a/mesalib/src/mesa/drivers/dri/common/xmlpool/options.h +++ b/mesalib/src/mesa/drivers/dri/common/xmlpool/options.h @@ -636,3 +636,13 @@ DRI_CONF_OPT_BEGIN(force_glsl_extensions_warn,bool,def) \ DRI_CONF_DESC(fr,"Force GLSL extension default behavior to 'warn'") \ DRI_CONF_DESC(sv,"Force GLSL extension default behavior to 'warn'") \ DRI_CONF_OPT_END + +#define DRI_CONF_DISABLE_BLEND_FUNC_EXTENDED(def) \ +DRI_CONF_OPT_BEGIN(disable_blend_func_extended,bool,def) \ + DRI_CONF_DESC(en,"Disable dual source blending") \ + DRI_CONF_DESC(de,"Disable dual source blending") \ + DRI_CONF_DESC(es,"Disable dual source blending") \ + DRI_CONF_DESC(nl,"Disable dual source blending") \ + DRI_CONF_DESC(fr,"Disable dual source blending") \ + DRI_CONF_DESC(sv,"Disable dual source blending") \ +DRI_CONF_OPT_END diff --git a/mesalib/src/mesa/main/api_exec.c b/mesalib/src/mesa/main/api_exec.c index 19e7f9807..81be46d5f 100644 --- a/mesalib/src/mesa/main/api_exec.c +++ b/mesalib/src/mesa/main/api_exec.c @@ -120,7 +120,7 @@ * \param exec dispatch table. */ struct _glapi_table * -_mesa_create_exec_table(void) +_mesa_create_exec_table(struct gl_context *ctx) { struct _glapi_table *exec; @@ -133,7 +133,10 @@ _mesa_create_exec_table(void) #endif /* load the dispatch slots we understand */ - SET_AlphaFunc(exec, _mesa_AlphaFunc); + if (ctx->API != API_OPENGL_CORE) { + SET_AlphaFunc(exec, _mesa_AlphaFunc); + } + SET_BlendFunc(exec, _mesa_BlendFunc); SET_Clear(exec, _mesa_Clear); SET_ClearColor(exec, _mesa_ClearColor); @@ -149,42 +152,62 @@ _mesa_create_exec_table(void) SET_Finish(exec, _mesa_Finish); SET_Flush(exec, _mesa_Flush); SET_FrontFace(exec, _mesa_FrontFace); - SET_Frustum(exec, _mesa_Frustum); + if (ctx->API != API_OPENGL_CORE) { + SET_Frustum(exec, _mesa_Frustum); + } SET_GetError(exec, _mesa_GetError); SET_GetFloatv(exec, _mesa_GetFloatv); SET_GetString(exec, _mesa_GetString); - SET_LineStipple(exec, _mesa_LineStipple); + if (ctx->API != API_OPENGL_CORE) { + SET_LineStipple(exec, _mesa_LineStipple); + } SET_LineWidth(exec, _mesa_LineWidth); - SET_LoadIdentity(exec, _mesa_LoadIdentity); - SET_LoadMatrixf(exec, _mesa_LoadMatrixf); + if (ctx->API != API_OPENGL_CORE) { + SET_LoadIdentity(exec, _mesa_LoadIdentity); + SET_LoadMatrixf(exec, _mesa_LoadMatrixf); + } SET_LogicOp(exec, _mesa_LogicOp); - SET_MatrixMode(exec, _mesa_MatrixMode); - SET_MultMatrixf(exec, _mesa_MultMatrixf); - SET_Ortho(exec, _mesa_Ortho); + if (ctx->API != API_OPENGL_CORE) { + SET_MatrixMode(exec, _mesa_MatrixMode); + SET_MultMatrixf(exec, _mesa_MultMatrixf); + SET_Ortho(exec, _mesa_Ortho); + } SET_PixelStorei(exec, _mesa_PixelStorei); - SET_PopMatrix(exec, _mesa_PopMatrix); - SET_PushMatrix(exec, _mesa_PushMatrix); - SET_Rotatef(exec, _mesa_Rotatef); - SET_Scalef(exec, _mesa_Scalef); + if (ctx->API != API_OPENGL_CORE) { + SET_PopMatrix(exec, _mesa_PopMatrix); + SET_PushMatrix(exec, _mesa_PushMatrix); + SET_Rotatef(exec, _mesa_Rotatef); + SET_Scalef(exec, _mesa_Scalef); + } SET_Scissor(exec, _mesa_Scissor); - SET_ShadeModel(exec, _mesa_ShadeModel); + if (ctx->API != API_OPENGL_CORE) { + SET_ShadeModel(exec, _mesa_ShadeModel); + } SET_StencilFunc(exec, _mesa_StencilFunc); SET_StencilMask(exec, _mesa_StencilMask); SET_StencilOp(exec, _mesa_StencilOp); - SET_TexEnvfv(exec, _mesa_TexEnvfv); - SET_TexEnvi(exec, _mesa_TexEnvi); + if (ctx->API != API_OPENGL_CORE) { + SET_TexEnvfv(exec, _mesa_TexEnvfv); + SET_TexEnvi(exec, _mesa_TexEnvi); + } SET_TexImage2D(exec, _mesa_TexImage2D); SET_TexParameteri(exec, _mesa_TexParameteri); - SET_Translatef(exec, _mesa_Translatef); + if (ctx->API != API_OPENGL_CORE) { + SET_Translatef(exec, _mesa_Translatef); + } SET_Viewport(exec, _mesa_Viewport); - _mesa_init_accum_dispatch(exec); - _mesa_init_dlist_dispatch(exec); + if (ctx->API != API_OPENGL_CORE) { + _mesa_init_accum_dispatch(exec); + _mesa_init_dlist_dispatch(exec); + } SET_ClearDepth(exec, _mesa_ClearDepth); - SET_ClearIndex(exec, _mesa_ClearIndex); - SET_ClipPlane(exec, _mesa_ClipPlane); - SET_ColorMaterial(exec, _mesa_ColorMaterial); + if (ctx->API != API_OPENGL_CORE) { + SET_ClearIndex(exec, _mesa_ClearIndex); + SET_ClipPlane(exec, _mesa_ClipPlane); + SET_ColorMaterial(exec, _mesa_ColorMaterial); + } SET_DepthFunc(exec, _mesa_DepthFunc); SET_DepthMask(exec, _mesa_DepthMask); SET_DepthRange(exec, _mesa_DepthRange); @@ -192,43 +215,53 @@ _mesa_create_exec_table(void) _mesa_init_drawpix_dispatch(exec); _mesa_init_feedback_dispatch(exec); - SET_FogCoordPointerEXT(exec, _mesa_FogCoordPointerEXT); - SET_Fogf(exec, _mesa_Fogf); - SET_Fogfv(exec, _mesa_Fogfv); - SET_Fogi(exec, _mesa_Fogi); - SET_Fogiv(exec, _mesa_Fogiv); - SET_GetClipPlane(exec, _mesa_GetClipPlane); + if (ctx->API != API_OPENGL_CORE) { + SET_FogCoordPointerEXT(exec, _mesa_FogCoordPointerEXT); + SET_Fogf(exec, _mesa_Fogf); + SET_Fogfv(exec, _mesa_Fogfv); + SET_Fogi(exec, _mesa_Fogi); + SET_Fogiv(exec, _mesa_Fogiv); + SET_GetClipPlane(exec, _mesa_GetClipPlane); + } SET_GetBooleanv(exec, _mesa_GetBooleanv); SET_GetDoublev(exec, _mesa_GetDoublev); SET_GetIntegerv(exec, _mesa_GetIntegerv); - SET_GetLightfv(exec, _mesa_GetLightfv); - SET_GetLightiv(exec, _mesa_GetLightiv); - SET_GetMaterialfv(exec, _mesa_GetMaterialfv); - SET_GetMaterialiv(exec, _mesa_GetMaterialiv); - SET_GetPolygonStipple(exec, _mesa_GetPolygonStipple); - SET_GetTexEnvfv(exec, _mesa_GetTexEnvfv); - SET_GetTexEnviv(exec, _mesa_GetTexEnviv); + if (ctx->API != API_OPENGL_CORE) { + SET_GetLightfv(exec, _mesa_GetLightfv); + SET_GetLightiv(exec, _mesa_GetLightiv); + SET_GetMaterialfv(exec, _mesa_GetMaterialfv); + SET_GetMaterialiv(exec, _mesa_GetMaterialiv); + SET_GetPolygonStipple(exec, _mesa_GetPolygonStipple); + SET_GetTexEnvfv(exec, _mesa_GetTexEnvfv); + SET_GetTexEnviv(exec, _mesa_GetTexEnviv); + } SET_GetTexLevelParameterfv(exec, _mesa_GetTexLevelParameterfv); SET_GetTexLevelParameteriv(exec, _mesa_GetTexLevelParameteriv); SET_GetTexParameterfv(exec, _mesa_GetTexParameterfv); SET_GetTexParameteriv(exec, _mesa_GetTexParameteriv); SET_GetTexImage(exec, _mesa_GetTexImage); SET_Hint(exec, _mesa_Hint); - SET_IndexMask(exec, _mesa_IndexMask); + if (ctx->API != API_OPENGL_CORE) { + SET_IndexMask(exec, _mesa_IndexMask); + } SET_IsEnabled(exec, _mesa_IsEnabled); - SET_LightModelf(exec, _mesa_LightModelf); - SET_LightModelfv(exec, _mesa_LightModelfv); - SET_LightModeli(exec, _mesa_LightModeli); - SET_LightModeliv(exec, _mesa_LightModeliv); - SET_Lightf(exec, _mesa_Lightf); - SET_Lightfv(exec, _mesa_Lightfv); - SET_Lighti(exec, _mesa_Lighti); - SET_Lightiv(exec, _mesa_Lightiv); - SET_LoadMatrixd(exec, _mesa_LoadMatrixd); + if (ctx->API != API_OPENGL_CORE) { + SET_LightModelf(exec, _mesa_LightModelf); + SET_LightModelfv(exec, _mesa_LightModelfv); + SET_LightModeli(exec, _mesa_LightModeli); + SET_LightModeliv(exec, _mesa_LightModeliv); + SET_Lightf(exec, _mesa_Lightf); + SET_Lightfv(exec, _mesa_Lightfv); + SET_Lighti(exec, _mesa_Lighti); + SET_Lightiv(exec, _mesa_Lightiv); + SET_LoadMatrixd(exec, _mesa_LoadMatrixd); + } _mesa_init_eval_dispatch(exec); - SET_MultMatrixd(exec, _mesa_MultMatrixd); + if (ctx->API != API_OPENGL_CORE) { + SET_MultMatrixd(exec, _mesa_MultMatrixd); + } _mesa_init_pixel_dispatch(exec); @@ -236,17 +269,21 @@ _mesa_create_exec_table(void) SET_PointSize(exec, _mesa_PointSize); SET_PolygonMode(exec, _mesa_PolygonMode); SET_PolygonOffset(exec, _mesa_PolygonOffset); - SET_PolygonStipple(exec, _mesa_PolygonStipple); + if (ctx->API != API_OPENGL_CORE) { + SET_PolygonStipple(exec, _mesa_PolygonStipple); + } _mesa_init_attrib_dispatch(exec); _mesa_init_rastpos_dispatch(exec); SET_ReadPixels(exec, _mesa_ReadPixels); - SET_Rotated(exec, _mesa_Rotated); - SET_Scaled(exec, _mesa_Scaled); - SET_SecondaryColorPointerEXT(exec, _mesa_SecondaryColorPointerEXT); - SET_TexEnvf(exec, _mesa_TexEnvf); - SET_TexEnviv(exec, _mesa_TexEnviv); + if (ctx->API != API_OPENGL_CORE) { + SET_Rotated(exec, _mesa_Rotated); + SET_Scaled(exec, _mesa_Scaled); + SET_SecondaryColorPointerEXT(exec, _mesa_SecondaryColorPointerEXT); + SET_TexEnvf(exec, _mesa_TexEnvf); + SET_TexEnviv(exec, _mesa_TexEnviv); + } _mesa_init_texgen_dispatch(exec); @@ -254,32 +291,42 @@ _mesa_create_exec_table(void) SET_TexParameterf(exec, _mesa_TexParameterf); SET_TexParameterfv(exec, _mesa_TexParameterfv); SET_TexParameteriv(exec, _mesa_TexParameteriv); - SET_Translated(exec, _mesa_Translated); + if (ctx->API != API_OPENGL_CORE) { + SET_Translated(exec, _mesa_Translated); + } /* 1.1 */ SET_BindTexture(exec, _mesa_BindTexture); SET_DeleteTextures(exec, _mesa_DeleteTextures); SET_GenTextures(exec, _mesa_GenTextures); #if _HAVE_FULL_GL - SET_AreTexturesResident(exec, _mesa_AreTexturesResident); - SET_ColorPointer(exec, _mesa_ColorPointer); + if (ctx->API != API_OPENGL_CORE) { + SET_AreTexturesResident(exec, _mesa_AreTexturesResident); + SET_ColorPointer(exec, _mesa_ColorPointer); + } SET_CopyTexImage1D(exec, _mesa_CopyTexImage1D); SET_CopyTexImage2D(exec, _mesa_CopyTexImage2D); SET_CopyTexSubImage1D(exec, _mesa_CopyTexSubImage1D); SET_CopyTexSubImage2D(exec, _mesa_CopyTexSubImage2D); - SET_DisableClientState(exec, _mesa_DisableClientState); - SET_EdgeFlagPointer(exec, _mesa_EdgeFlagPointer); - SET_EnableClientState(exec, _mesa_EnableClientState); - SET_GetPointerv(exec, _mesa_GetPointerv); - SET_IndexPointer(exec, _mesa_IndexPointer); - SET_InterleavedArrays(exec, _mesa_InterleavedArrays); + if (ctx->API != API_OPENGL_CORE) { + SET_DisableClientState(exec, _mesa_DisableClientState); + SET_EdgeFlagPointer(exec, _mesa_EdgeFlagPointer); + SET_EnableClientState(exec, _mesa_EnableClientState); + SET_GetPointerv(exec, _mesa_GetPointerv); + SET_IndexPointer(exec, _mesa_IndexPointer); + SET_InterleavedArrays(exec, _mesa_InterleavedArrays); + } SET_IsTexture(exec, _mesa_IsTexture); - SET_NormalPointer(exec, _mesa_NormalPointer); - SET_PrioritizeTextures(exec, _mesa_PrioritizeTextures); - SET_TexCoordPointer(exec, _mesa_TexCoordPointer); + if (ctx->API != API_OPENGL_CORE) { + SET_NormalPointer(exec, _mesa_NormalPointer); + SET_PrioritizeTextures(exec, _mesa_PrioritizeTextures); + SET_TexCoordPointer(exec, _mesa_TexCoordPointer); + } SET_TexSubImage1D(exec, _mesa_TexSubImage1D); SET_TexSubImage2D(exec, _mesa_TexSubImage2D); - SET_VertexPointer(exec, _mesa_VertexPointer); + if (ctx->API != API_OPENGL_CORE) { + SET_VertexPointer(exec, _mesa_VertexPointer); + } #endif /* 1.2 */ @@ -327,31 +374,37 @@ _mesa_create_exec_table(void) /* 11. GL_EXT_histogram */ #if 0 - SET_GetHistogramEXT(exec, _mesa_GetHistogram); - SET_GetHistogramParameterfvEXT(exec, _mesa_GetHistogramParameterfv); - SET_GetHistogramParameterivEXT(exec, _mesa_GetHistogramParameteriv); - SET_GetMinmaxEXT(exec, _mesa_GetMinmax); - SET_GetMinmaxParameterfvEXT(exec, _mesa_GetMinmaxParameterfv); - SET_GetMinmaxParameterivEXT(exec, _mesa_GetMinmaxParameteriv); + if (ctx->API != API_OPENGL_CORE) { + SET_GetHistogramEXT(exec, _mesa_GetHistogram); + SET_GetHistogramParameterfvEXT(exec, _mesa_GetHistogramParameterfv); + SET_GetHistogramParameterivEXT(exec, _mesa_GetHistogramParameteriv); + SET_GetMinmaxEXT(exec, _mesa_GetMinmax); + SET_GetMinmaxParameterfvEXT(exec, _mesa_GetMinmaxParameterfv); + SET_GetMinmaxParameterivEXT(exec, _mesa_GetMinmaxParameteriv); + } #endif /* 14. SGI_color_table */ #if 0 - SET_ColorTableSGI(exec, _mesa_ColorTable); - SET_ColorSubTableSGI(exec, _mesa_ColorSubTable); - SET_GetColorTableSGI(exec, _mesa_GetColorTable); - SET_GetColorTableParameterfvSGI(exec, _mesa_GetColorTableParameterfv); - SET_GetColorTableParameterivSGI(exec, _mesa_GetColorTableParameteriv); + if (ctx->API != API_OPENGL_CORE) { + SET_ColorTableSGI(exec, _mesa_ColorTable); + SET_ColorSubTableSGI(exec, _mesa_ColorSubTable); + SET_GetColorTableSGI(exec, _mesa_GetColorTable); + SET_GetColorTableParameterfvSGI(exec, _mesa_GetColorTableParameterfv); + SET_GetColorTableParameterivSGI(exec, _mesa_GetColorTableParameteriv); + } #endif /* 30. GL_EXT_vertex_array */ #if _HAVE_FULL_GL - SET_ColorPointerEXT(exec, _mesa_ColorPointerEXT); - SET_EdgeFlagPointerEXT(exec, _mesa_EdgeFlagPointerEXT); - SET_IndexPointerEXT(exec, _mesa_IndexPointerEXT); - SET_NormalPointerEXT(exec, _mesa_NormalPointerEXT); - SET_TexCoordPointerEXT(exec, _mesa_TexCoordPointerEXT); - SET_VertexPointerEXT(exec, _mesa_VertexPointerEXT); + if (ctx->API != API_OPENGL_CORE) { + SET_ColorPointerEXT(exec, _mesa_ColorPointerEXT); + SET_EdgeFlagPointerEXT(exec, _mesa_EdgeFlagPointerEXT); + SET_IndexPointerEXT(exec, _mesa_IndexPointerEXT); + SET_NormalPointerEXT(exec, _mesa_NormalPointerEXT); + SET_TexCoordPointerEXT(exec, _mesa_TexCoordPointerEXT); + SET_VertexPointerEXT(exec, _mesa_VertexPointerEXT); + } #endif /* 37. GL_EXT_blend_minmax */ @@ -483,10 +536,12 @@ _mesa_create_exec_table(void) /* ARB 3. GL_ARB_transpose_matrix */ #if _HAVE_FULL_GL - SET_LoadTransposeMatrixdARB(exec, _mesa_LoadTransposeMatrixdARB); - SET_LoadTransposeMatrixfARB(exec, _mesa_LoadTransposeMatrixfARB); - SET_MultTransposeMatrixdARB(exec, _mesa_MultTransposeMatrixdARB); - SET_MultTransposeMatrixfARB(exec, _mesa_MultTransposeMatrixfARB); + if (ctx->API != API_OPENGL_CORE) { + SET_LoadTransposeMatrixdARB(exec, _mesa_LoadTransposeMatrixdARB); + SET_LoadTransposeMatrixfARB(exec, _mesa_LoadTransposeMatrixfARB); + SET_MultTransposeMatrixdARB(exec, _mesa_MultTransposeMatrixdARB); + SET_MultTransposeMatrixfARB(exec, _mesa_MultTransposeMatrixfARB); + } #endif /* ARB 5. GL_ARB_multisample */ diff --git a/mesalib/src/mesa/main/api_exec.h b/mesalib/src/mesa/main/api_exec.h index 29c953f31..100e97273 100644 --- a/mesalib/src/mesa/main/api_exec.h +++ b/mesalib/src/mesa/main/api_exec.h @@ -28,12 +28,13 @@ struct _glapi_table; +struct gl_context; extern struct _glapi_table * _mesa_alloc_dispatch_table(int size); extern struct _glapi_table * -_mesa_create_exec_table(void); +_mesa_create_exec_table(struct gl_context *ctx); extern struct _glapi_table * _mesa_create_exec_table_es1(void); diff --git a/mesalib/src/mesa/main/api_validate.c b/mesalib/src/mesa/main/api_validate.c index ece0a2b4a..eaf614bdc 100644 --- a/mesalib/src/mesa/main/api_validate.c +++ b/mesalib/src/mesa/main/api_validate.c @@ -128,6 +128,7 @@ check_valid_to_render(struct gl_context *ctx, const char *function) #if FEATURE_GL case API_OPENGL: + case API_OPENGL_CORE: { const struct gl_shader_program *vsProg = ctx->Shader.CurrentVertexProgram; diff --git a/mesalib/src/mesa/main/arbprogram.c b/mesalib/src/mesa/main/arbprogram.c index b83369d9e..ae91fd5a3 100644 --- a/mesalib/src/mesa/main/arbprogram.c +++ b/mesalib/src/mesa/main/arbprogram.c @@ -138,12 +138,12 @@ _mesa_BindProgram(GLenum target, GLuint id) /* bind newProg */ if (target == GL_VERTEX_PROGRAM_ARB) { /* == GL_VERTEX_PROGRAM_NV */ _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current, - (struct gl_vertex_program *) newProg); + gl_vertex_program(newProg)); } else if (target == GL_FRAGMENT_PROGRAM_NV || target == GL_FRAGMENT_PROGRAM_ARB) { _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current, - (struct gl_fragment_program *) newProg); + gl_fragment_program(newProg)); } /* Never null pointers */ diff --git a/mesalib/src/mesa/main/arrayobj.h b/mesalib/src/mesa/main/arrayobj.h index e5270fa2c..4f89064bb 100644 --- a/mesalib/src/mesa/main/arrayobj.h +++ b/mesalib/src/mesa/main/arrayobj.h @@ -30,6 +30,7 @@ #include "glheader.h" #include "mtypes.h" +#include "glformats.h" struct gl_context; diff --git a/mesalib/src/mesa/main/context.c b/mesalib/src/mesa/main/context.c index d5ccce076..7616eb78b 100644 --- a/mesalib/src/mesa/main/context.c +++ b/mesalib/src/mesa/main/context.c @@ -404,8 +404,6 @@ one_time_init( struct gl_context *ctx ) _mesa_get_cpu_features(); - _mesa_init_sqrt_table(); - /* context dependence is never a one-time thing... */ _mesa_init_get_hash(ctx); @@ -433,7 +431,7 @@ one_time_init( struct gl_context *ctx ) * when an app is linked to libGLES*, there are not enough dynamic * entries. */ - if (ctx->API == API_OPENGL) + if (_mesa_is_desktop_gl(ctx)) _mesa_init_remap_table(); } @@ -628,7 +626,7 @@ _mesa_init_constants(struct gl_context *ctx) #endif /* Shading language version */ - if (ctx->API == API_OPENGL) { + if (_mesa_is_desktop_gl(ctx)) { ctx->Const.GLSLVersion = 120; _mesa_override_glsl_version(ctx); } @@ -844,7 +842,10 @@ update_default_objects(struct gl_context *ctx) static int generic_nop(void) { - _mesa_warning(NULL, "User called no-op dispatch function (an unsupported extension function?)"); + GET_CURRENT_CONTEXT(ctx); + _mesa_error(ctx, GL_INVALID_OPERATION, + "unsupported function called " + "(unsupported extension or deprecated function?)"); return 0; } @@ -961,7 +962,8 @@ _mesa_initialize_context(struct gl_context *ctx, switch (ctx->API) { #if FEATURE_GL case API_OPENGL: - ctx->Exec = _mesa_create_exec_table(); + case API_OPENGL_CORE: + ctx->Exec = _mesa_create_exec_table(ctx); break; #endif #if FEATURE_ES1 @@ -1006,6 +1008,7 @@ _mesa_initialize_context(struct gl_context *ctx, switch (ctx->API) { case API_OPENGL: + case API_OPENGL_CORE: #if FEATURE_dlist ctx->Save = _mesa_create_save_table(); if (!ctx->Save) { @@ -1455,8 +1458,8 @@ _mesa_make_current( struct gl_context *newCtx, _glapi_set_dispatch(newCtx->CurrentDispatch); if (drawBuffer && readBuffer) { - ASSERT(drawBuffer->Name == 0); - ASSERT(readBuffer->Name == 0); + ASSERT(_mesa_is_winsys_fbo(drawBuffer)); + ASSERT(_mesa_is_winsys_fbo(readBuffer)); _mesa_reference_framebuffer(&newCtx->WinSysDrawBuffer, drawBuffer); _mesa_reference_framebuffer(&newCtx->WinSysReadBuffer, readBuffer); @@ -1464,7 +1467,7 @@ _mesa_make_current( struct gl_context *newCtx, * Only set the context's Draw/ReadBuffer fields if they're NULL * or not bound to a user-created FBO. */ - if (!newCtx->DrawBuffer || newCtx->DrawBuffer->Name == 0) { + if (!newCtx->DrawBuffer || _mesa_is_winsys_fbo(newCtx->DrawBuffer)) { _mesa_reference_framebuffer(&newCtx->DrawBuffer, drawBuffer); /* Update the FBO's list of drawbuffers/renderbuffers. * For winsys FBOs this comes from the GL state (which may have @@ -1472,7 +1475,7 @@ _mesa_make_current( struct gl_context *newCtx, */ _mesa_update_draw_buffers(newCtx); } - if (!newCtx->ReadBuffer || newCtx->ReadBuffer->Name == 0) { + if (!newCtx->ReadBuffer || _mesa_is_winsys_fbo(newCtx->ReadBuffer)) { _mesa_reference_framebuffer(&newCtx->ReadBuffer, readBuffer); } diff --git a/mesalib/src/mesa/main/context.h b/mesalib/src/mesa/main/context.h index a66dd5076..6b7dafa78 100644 --- a/mesalib/src/mesa/main/context.h +++ b/mesalib/src/mesa/main/context.h @@ -290,6 +290,26 @@ do { \ /*@}*/ +/** + * Checks if the context is for Desktop GL (Compatibility or Core) + */ +static inline GLboolean +_mesa_is_desktop_gl(const struct gl_context *ctx) +{ + return ctx->API == API_OPENGL || ctx->API == API_OPENGL_CORE; +} + + +/** + * Checks if the context is for any GLES version + */ +static inline GLboolean +_mesa_is_gles(const struct gl_context *ctx) +{ + return ctx->API == API_OPENGLES || ctx->API == API_OPENGLES2; +} + + #ifdef __cplusplus } #endif diff --git a/mesalib/src/mesa/main/dlist.c b/mesalib/src/mesa/main/dlist.c index 40961b15c..510fd1e18 100644 --- a/mesalib/src/mesa/main/dlist.c +++ b/mesalib/src/mesa/main/dlist.c @@ -51,6 +51,7 @@ #endif #include "framebuffer.h" #include "glapi/glapi.h" +#include "glformats.h" #include "hash.h" #include "image.h" #include "light.h" diff --git a/mesalib/src/mesa/main/drawpix.c b/mesalib/src/mesa/main/drawpix.c index fdcbcccde..bd9837fdd 100644 --- a/mesalib/src/mesa/main/drawpix.c +++ b/mesalib/src/mesa/main/drawpix.c @@ -35,6 +35,8 @@ #include "pbo.h" #include "state.h" #include "dispatch.h" +#include "glformats.h" +#include "fbobject.h" #if FEATURE_drawpix @@ -89,7 +91,7 @@ _mesa_DrawPixels( GLsizei width, GLsizei height, * input), NVIDIA's implementation also just returns this error despite * exposing GL_EXT_texture_integer, just return an error regardless. */ - if (_mesa_is_integer_format(format)) { + if (_mesa_is_enum_format_integer(format)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glDrawPixels(integer format)"); goto end; } @@ -239,7 +241,8 @@ _mesa_CopyPixels( GLint srcx, GLint srcy, GLsizei width, GLsizei height, goto end; } - if (ctx->ReadBuffer->Name != 0 && ctx->ReadBuffer->Visual.samples > 0) { + if (_mesa_is_user_fbo(ctx->ReadBuffer) && + ctx->ReadBuffer->Visual.samples > 0) { _mesa_error(ctx, GL_INVALID_OPERATION, "glCopyPixels(multisample FBO)"); goto end; diff --git a/mesalib/src/mesa/main/extensions.c b/mesalib/src/mesa/main/extensions.c index 0675ce75d..a7b481ca7 100644 --- a/mesalib/src/mesa/main/extensions.c +++ b/mesalib/src/mesa/main/extensions.c @@ -41,7 +41,9 @@ enum { DISABLE = 0, - GL = 1 << API_OPENGL, + GLL = 1 << API_OPENGL, /* GL Legacy / Compatibility */ + GLC = 1 << API_OPENGL_CORE, /* GL Core */ + GL = (1 << API_OPENGL) | (1 << API_OPENGL_CORE), ES1 = 1 << API_OPENGLES, ES2 = 1 << API_OPENGLES2, }; diff --git a/mesalib/src/mesa/main/fbobject.c b/mesalib/src/mesa/main/fbobject.c index 4370c7218..eb03b0918 100644 --- a/mesalib/src/mesa/main/fbobject.c +++ b/mesalib/src/mesa/main/fbobject.c @@ -38,8 +38,8 @@ #include "fbobject.h" #include "formats.h" #include "framebuffer.h" +#include "glformats.h" #include "hash.h" -#include "image.h" #include "macros.h" #include "mfeatures.h" #include "mtypes.h" @@ -164,10 +164,10 @@ get_framebuffer_target(struct gl_context *ctx, GLenum target) { switch (target) { case GL_DRAW_FRAMEBUFFER: - return ctx->Extensions.EXT_framebuffer_blit && ctx->API == API_OPENGL + return ctx->Extensions.EXT_framebuffer_blit && _mesa_is_desktop_gl(ctx) ? ctx->DrawBuffer : NULL; case GL_READ_FRAMEBUFFER: - return ctx->Extensions.EXT_framebuffer_blit && ctx->API == API_OPENGL + return ctx->Extensions.EXT_framebuffer_blit && _mesa_is_desktop_gl(ctx) ? ctx->ReadBuffer : NULL; case GL_FRAMEBUFFER_EXT: return ctx->DrawBuffer; @@ -221,7 +221,7 @@ _mesa_get_attachment(struct gl_context *ctx, struct gl_framebuffer *fb, } return &fb->Attachment[BUFFER_COLOR0 + i]; case GL_DEPTH_STENCIL_ATTACHMENT: - if (ctx->API != API_OPENGL) + if (!_mesa_is_desktop_gl(ctx)) return NULL; /* fall-through */ case GL_DEPTH_ATTACHMENT_EXT: @@ -817,7 +817,7 @@ _mesa_test_framebuffer_completeness(struct gl_context *ctx, } #if FEATURE_GL - if (ctx->API == API_OPENGL && !ctx->Extensions.ARB_ES2_compatibility) { + if (_mesa_is_desktop_gl(ctx) && !ctx->Extensions.ARB_ES2_compatibility) { /* Check that all DrawBuffers are present */ for (j = 0; j < ctx->Const.MaxDrawBuffers; j++) { if (fb->ColorDrawBuffer[j] != GL_NONE) { @@ -2289,7 +2289,7 @@ _mesa_GetFramebufferAttachmentParameterivEXT(GLenum target, GLenum attachment, ASSERT_OUTSIDE_BEGIN_END(ctx); /* The error differs in GL and GLES. */ - err = ctx->API == API_OPENGL ? GL_INVALID_OPERATION : GL_INVALID_ENUM; + err = _mesa_is_desktop_gl(ctx) ? GL_INVALID_OPERATION : GL_INVALID_ENUM; buffer = get_framebuffer_target(ctx, target); if (!buffer) { @@ -2309,7 +2309,7 @@ _mesa_GetFramebufferAttachmentParameterivEXT(GLenum target, GLenum attachment, * OES_framebuffer_object spec refers to the EXT_framebuffer_object * spec. */ - if (ctx->API != API_OPENGL || !ctx->Extensions.ARB_framebuffer_object) { + if (!_mesa_is_desktop_gl(ctx) || !ctx->Extensions.ARB_framebuffer_object) { _mesa_error(ctx, GL_INVALID_OPERATION, "glGetFramebufferAttachmentParameteriv(bound FBO = 0)"); return; @@ -2357,7 +2357,7 @@ _mesa_GetFramebufferAttachmentParameterivEXT(GLenum target, GLenum attachment, } else { assert(att->Type == GL_NONE); - if (ctx->API == API_OPENGL) { + if (_mesa_is_desktop_gl(ctx)) { *params = 0; } else { _mesa_error(ctx, GL_INVALID_ENUM, @@ -2633,6 +2633,116 @@ compatible_color_datatypes(gl_format srcFormat, gl_format dstFormat) /** + * Return the equivalent non-generic internal format. + * This is useful for comparing whether two internal formats are semantically + * equivalent. + */ +static GLenum +get_nongeneric_internalformat(GLenum format) +{ + switch (format) { + /* GL 1.1 formats. */ + case 4: + case GL_RGBA: + return GL_RGBA8; + + case 3: + case GL_RGB: + return GL_RGB8; + + case 2: + case GL_LUMINANCE_ALPHA: + return GL_LUMINANCE8_ALPHA8; + + case 1: + case GL_LUMINANCE: + return GL_LUMINANCE8; + + case GL_ALPHA: + return GL_ALPHA8; + + case GL_INTENSITY: + return GL_INTENSITY8; + + /* GL_ARB_texture_rg */ + case GL_RED: + return GL_R8; + + case GL_RG: + return GL_RG8; + + /* GL_EXT_texture_sRGB */ + case GL_SRGB: + return GL_SRGB8; + + case GL_SRGB_ALPHA: + return GL_SRGB8_ALPHA8; + + case GL_SLUMINANCE: + return GL_SLUMINANCE8; + + case GL_SLUMINANCE_ALPHA: + return GL_SLUMINANCE8_ALPHA8; + + /* GL_EXT_texture_snorm */ + case GL_RGBA_SNORM: + return GL_RGBA8_SNORM; + + case GL_RGB_SNORM: + return GL_RGB8_SNORM; + + case GL_RG_SNORM: + return GL_RG8_SNORM; + + case GL_RED_SNORM: + return GL_R8_SNORM; + + case GL_LUMINANCE_ALPHA_SNORM: + return GL_LUMINANCE8_ALPHA8_SNORM; + + case GL_LUMINANCE_SNORM: + return GL_LUMINANCE8_SNORM; + + case GL_ALPHA_SNORM: + return GL_ALPHA8_SNORM; + + case GL_INTENSITY_SNORM: + return GL_INTENSITY8_SNORM; + + default: + return format; + } +} + + +static GLboolean +compatible_resolve_formats(const struct gl_renderbuffer *colorReadRb, + const struct gl_renderbuffer *colorDrawRb) +{ + /* The simple case where we know the backing formats are the same. + */ + if (colorReadRb->Format == colorDrawRb->Format) { + return GL_TRUE; + } + + /* The Mesa formats are different, so we must check whether the internal + * formats are compatible. + * + * Under some circumstances, the user may request e.g. two GL_RGBA8 + * textures and get two entirely different Mesa formats like RGBA8888 and + * ARGB8888. Drivers behaving like that should be able to cope with + * non-matching formats by themselves, because it's not the user's fault. + */ + if (get_nongeneric_internalformat(colorReadRb->InternalFormat) == + get_nongeneric_internalformat(colorDrawRb->InternalFormat)) { + return GL_TRUE; + } + + return GL_FALSE; +} + + +/** * Blit rectangular region, optionally from one framebuffer to another. * * Note, if the src buffer is multisampled and the dest is not, this is @@ -2798,7 +2908,7 @@ _mesa_BlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, /* color formats must match */ if (colorReadRb && colorDrawRb && - colorReadRb->Format != colorDrawRb->Format) { + !compatible_resolve_formats(colorReadRb, colorDrawRb)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glBlitFramebufferEXT(bad src/dst multisample pixel formats)"); return; diff --git a/mesalib/src/mesa/main/ffvertex_prog.c b/mesalib/src/mesa/main/ffvertex_prog.c index 557768311..e5ab20145 100644 --- a/mesalib/src/mesa/main/ffvertex_prog.c +++ b/mesalib/src/mesa/main/ffvertex_prog.c @@ -1572,7 +1572,7 @@ static void build_array_pointsize( struct tnl_program *p ) static void build_tnl_program( struct tnl_program *p ) { - /* Emit the program, starting with modelviewproject: + /* Emit the program, starting with the modelview, projection transforms: */ build_hpos(p); @@ -1658,7 +1658,6 @@ create_new_program( const struct state_key *key, /** * Return a vertex program which implements the current fixed-function * transform/lighting/texgen operations. - * XXX move this into core mesa (main/) */ struct gl_vertex_program * _mesa_get_fixed_func_vertex_program(struct gl_context *ctx) @@ -1672,16 +1671,15 @@ _mesa_get_fixed_func_vertex_program(struct gl_context *ctx) /* Look for an already-prepared program for this state: */ - prog = (struct gl_vertex_program *) - _mesa_search_program_cache(ctx->VertexProgram.Cache, &key, sizeof(key)); + prog = gl_vertex_program( + _mesa_search_program_cache(ctx->VertexProgram.Cache, &key, sizeof(key))); if (!prog) { /* OK, we'll have to build a new one */ if (0) printf("Build new TNL program\n"); - prog = (struct gl_vertex_program *) - ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0); + prog = gl_vertex_program(ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0)); if (!prog) return NULL; diff --git a/mesalib/src/mesa/main/format_pack.c b/mesalib/src/mesa/main/format_pack.c index 7f0bda127..be6c026e8 100644 --- a/mesalib/src/mesa/main/format_pack.c +++ b/mesalib/src/mesa/main/format_pack.c @@ -1005,6 +1005,32 @@ pack_float_ARGB2101010(const GLfloat src[4], void *dst) } +/* MESA_FORMAT_ABGR2101010_UINT */ + +static void +pack_ubyte_ABGR2101010_UINT(const GLubyte src[4], void *dst) +{ + GLuint *d = ((GLuint *) dst); + GLushort r = UBYTE_TO_USHORT(src[RCOMP]); + GLushort g = UBYTE_TO_USHORT(src[GCOMP]); + GLushort b = UBYTE_TO_USHORT(src[BCOMP]); + GLushort a = UBYTE_TO_USHORT(src[ACOMP]); + *d = PACK_COLOR_2101010_US(a, b, g, r); +} + +static void +pack_float_ABGR2101010_UINT(const GLfloat src[4], void *dst) +{ + GLuint *d = ((GLuint *) dst); + GLushort r, g, b, a; + UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]); + UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]); + UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]); + UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]); + *d = PACK_COLOR_2101010_US(a, b, g, r); +} + + /* MESA_FORMAT_SRGB8 */ static void @@ -1696,6 +1722,7 @@ _mesa_get_pack_ubyte_rgba_function(gl_format format) table[MESA_FORMAT_RG1616] = pack_ubyte_RG1616; table[MESA_FORMAT_RG1616_REV] = pack_ubyte_RG1616_REV; table[MESA_FORMAT_ARGB2101010] = pack_ubyte_ARGB2101010; + table[MESA_FORMAT_ABGR2101010_UINT] = pack_ubyte_ABGR2101010_UINT; /* should never convert RGBA to these formats */ table[MESA_FORMAT_Z24_S8] = NULL; @@ -1841,6 +1868,7 @@ _mesa_get_pack_float_rgba_function(gl_format format) table[MESA_FORMAT_RG1616] = pack_float_RG1616; table[MESA_FORMAT_RG1616_REV] = pack_float_RG1616_REV; table[MESA_FORMAT_ARGB2101010] = pack_float_ARGB2101010; + table[MESA_FORMAT_ABGR2101010_UINT] = pack_float_ABGR2101010_UINT; /* should never convert RGBA to these formats */ table[MESA_FORMAT_Z24_S8] = NULL; diff --git a/mesalib/src/mesa/main/format_unpack.c b/mesalib/src/mesa/main/format_unpack.c index c42bac19c..529c416a8 100644 --- a/mesalib/src/mesa/main/format_unpack.c +++ b/mesalib/src/mesa/main/format_unpack.c @@ -610,6 +610,20 @@ unpack_ARGB2101010(const void *src, GLfloat dst[][4], GLuint n) static void +unpack_ABGR2101010_UINT(const void *src, GLfloat dst[][4], GLuint n) +{ + const GLuint *s = ((const GLuint *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = (GLfloat)((s[i] >> 0) & 0x3ff); + dst[i][GCOMP] = (GLfloat)((s[i] >> 10) & 0x3ff); + dst[i][BCOMP] = (GLfloat)((s[i] >> 20) & 0x3ff); + dst[i][ACOMP] = (GLfloat)((s[i] >> 30) & 0x03); + } +} + + +static void unpack_Z24_S8(const void *src, GLfloat dst[][4], GLuint n) { /* only return Z, not stencil data */ @@ -1499,6 +1513,7 @@ get_unpack_rgba_function(gl_format format) table[MESA_FORMAT_RG1616] = unpack_RG1616; table[MESA_FORMAT_RG1616_REV] = unpack_RG1616_REV; table[MESA_FORMAT_ARGB2101010] = unpack_ARGB2101010; + table[MESA_FORMAT_ABGR2101010_UINT] = unpack_ABGR2101010_UINT; table[MESA_FORMAT_Z24_S8] = unpack_Z24_S8; table[MESA_FORMAT_S8_Z24] = unpack_S8_Z24; table[MESA_FORMAT_Z16] = unpack_Z16; @@ -2139,6 +2154,32 @@ unpack_int_rgba_RGBA_INT8(const GLbyte *src, GLuint dst[][4], GLuint n) } static void +unpack_int_rgba_ARGB8888(const GLbyte *src, GLuint dst[][4], GLuint n) +{ + unsigned int i; + + for (i = 0; i < n; i++) { + dst[i][RCOMP] = (GLubyte) src[i * 4 + 2]; + dst[i][GCOMP] = (GLubyte) src[i * 4 + 1]; + dst[i][BCOMP] = (GLubyte) src[i * 4 + 0]; + dst[i][ACOMP] = (GLubyte) src[i * 4 + 3]; + } +} + +static void +unpack_int_rgba_XRGB8888(const GLbyte *src, GLuint dst[][4], GLuint n) +{ + unsigned int i; + + for (i = 0; i < n; i++) { + dst[i][RCOMP] = (GLubyte) src[i * 4 + 2]; + dst[i][GCOMP] = (GLubyte) src[i * 4 + 1]; + dst[i][BCOMP] = (GLubyte) src[i * 4 + 0]; + dst[i][ACOMP] = (GLubyte) 0xff; + } +} + +static void unpack_int_rgba_RGB_UINT32(const GLuint *src, GLuint dst[][4], GLuint n) { unsigned int i; @@ -2563,6 +2604,20 @@ unpack_int_rgba_ARGB2101010_UINT(const GLuint *src, GLuint dst[][4], GLuint n) } } +static void +unpack_int_rgba_ABGR2101010_UINT(const GLuint *src, GLuint dst[][4], GLuint n) +{ + unsigned int i; + + for (i = 0; i < n; i++) { + GLuint tmp = src[i]; + dst[i][0] = (tmp >> 0) & 0x3ff; + dst[i][1] = (tmp >> 10) & 0x3ff; + dst[i][2] = (tmp >> 20) & 0x3ff; + dst[i][3] = (tmp >> 30) & 0x3; + } +} + void _mesa_unpack_uint_rgba_row(gl_format format, GLuint n, const void *src, GLuint dst[][4]) @@ -2590,6 +2645,14 @@ _mesa_unpack_uint_rgba_row(gl_format format, GLuint n, unpack_int_rgba_RGBA_INT8(src, dst, n); break; + case MESA_FORMAT_ARGB8888: + unpack_int_rgba_ARGB8888(src, dst, n); + break; + + case MESA_FORMAT_XRGB8888: + unpack_int_rgba_XRGB8888(src, dst, n); + break; + case MESA_FORMAT_RGB_UINT32: case MESA_FORMAT_RGB_INT32: unpack_int_rgba_RGB_UINT32(src, dst, n); @@ -2725,6 +2788,11 @@ _mesa_unpack_uint_rgba_row(gl_format format, GLuint n, case MESA_FORMAT_ARGB2101010_UINT: unpack_int_rgba_ARGB2101010_UINT(src, dst, n); break; + + case MESA_FORMAT_ABGR2101010_UINT: + unpack_int_rgba_ABGR2101010_UINT(src, dst, n); + break; + default: _mesa_problem(NULL, "%s: bad format %s", __FUNCTION__, _mesa_get_format_name(format)); diff --git a/mesalib/src/mesa/main/formats.c b/mesalib/src/mesa/main/formats.c index c65c9c2e1..1fa641c92 100644 --- a/mesalib/src/mesa/main/formats.c +++ b/mesalib/src/mesa/main/formats.c @@ -28,6 +28,7 @@ #include "formats.h" #include "mfeatures.h" #include "macros.h" +#include "glformats.h" /** @@ -1519,6 +1520,15 @@ static struct gl_format_info format_info[MESA_FORMAT_COUNT] = 0, 0, 0, 0, 0, 1, 1, 4 }, + { + MESA_FORMAT_ABGR2101010_UINT, + "MESA_FORMAT_ABGR2101010_UINT", + GL_RGBA, + GL_UNSIGNED_INT, + 10, 10, 10, 2, + 0, 0, 0, 0, 0, + 1, 1, 4 + }, }; @@ -1712,6 +1722,17 @@ _mesa_is_format_integer_color(gl_format format) /** + * Is the given format an unsigned integer format? + */ +GLboolean +_mesa_is_format_unsigned(gl_format format) +{ + const struct gl_format_info *info = _mesa_get_format_info(format); + return _mesa_is_type_unsigned(info->DataType); +} + + +/** * Return color encoding for given format. * \return GL_LINEAR or GL_SRGB */ @@ -2491,6 +2512,7 @@ _mesa_format_to_type_and_comps(gl_format format, return; case MESA_FORMAT_ARGB2101010_UINT: + case MESA_FORMAT_ABGR2101010_UINT: *datatype = GL_UNSIGNED_INT_2_10_10_10_REV; *comps = 4; return; @@ -2916,6 +2938,11 @@ _mesa_format_matches_format_and_type(gl_format gl_format, type == GL_UNSIGNED_INT_2_10_10_10_REV && !swapBytes); + case MESA_FORMAT_ABGR2101010_UINT: + return (format == GL_RGBA_INTEGER_EXT && + type == GL_UNSIGNED_INT_2_10_10_10_REV && + !swapBytes); + case MESA_FORMAT_RGB9_E5_FLOAT: return format == GL_RGB && type == GL_UNSIGNED_INT_5_9_9_9_REV && !swapBytes; @@ -2933,3 +2960,4 @@ _mesa_format_matches_format_and_type(gl_format gl_format, return GL_FALSE; } + diff --git a/mesalib/src/mesa/main/formats.h b/mesalib/src/mesa/main/formats.h index 3a694a813..1843eb6fc 100644 --- a/mesalib/src/mesa/main/formats.h +++ b/mesalib/src/mesa/main/formats.h @@ -276,6 +276,7 @@ typedef enum MESA_FORMAT_Z32_FLOAT_X24S8, MESA_FORMAT_ARGB2101010_UINT, + MESA_FORMAT_ABGR2101010_UINT, MESA_FORMAT_COUNT } gl_format; @@ -311,6 +312,9 @@ _mesa_is_format_packed_depth_stencil(gl_format format); extern GLboolean _mesa_is_format_integer_color(gl_format format); +extern GLboolean +_mesa_is_format_unsigned(gl_format format); + extern GLenum _mesa_get_format_color_encoding(gl_format format); @@ -346,7 +350,6 @@ _mesa_format_matches_format_and_type(gl_format gl_format, GLenum format, GLenum type, GLboolean swapBytes); - #ifdef __cplusplus } #endif diff --git a/mesalib/src/mesa/main/framebuffer.c b/mesalib/src/mesa/main/framebuffer.c index ea14148de..13887f8f5 100644 --- a/mesalib/src/mesa/main/framebuffer.c +++ b/mesalib/src/mesa/main/framebuffer.c @@ -347,7 +347,7 @@ _mesa_resizebuffers( struct gl_context *ctx ) GLuint newWidth, newHeight; struct gl_framebuffer *buffer = ctx->WinSysDrawBuffer; - assert(buffer->Name == 0); + assert(_mesa_is_winsys_fbo(buffer)); /* ask device driver for size of output buffer */ ctx->Driver.GetBufferSize( buffer, &newWidth, &newHeight ); @@ -364,7 +364,7 @@ _mesa_resizebuffers( struct gl_context *ctx ) GLuint newWidth, newHeight; struct gl_framebuffer *buffer = ctx->WinSysReadBuffer; - assert(buffer->Name == 0); + assert(_mesa_is_winsys_fbo(buffer)); /* ask device driver for size of read buffer */ ctx->Driver.GetBufferSize( buffer, &newWidth, &newHeight ); @@ -444,7 +444,7 @@ _mesa_update_draw_buffer_bounds(struct gl_context *ctx) if (!buffer) return; - if (buffer->Name) { + if (_mesa_is_user_fbo(buffer)) { /* user-created framebuffer size depends on the renderbuffers */ update_framebuffer_size(ctx, buffer); } @@ -517,6 +517,13 @@ _mesa_update_framebuffer_visual(struct gl_context *ctx, const GLenum baseFormat = _mesa_get_format_base_format(rb->Format); const gl_format fmt = rb->Format; + /* Grab samples and sampleBuffers from any attachment point (assuming + * the framebuffer is complete, we'll get the same answer from all + * attachments). + */ + fb->Visual.samples = rb->NumSamples; + fb->Visual.sampleBuffers = rb->NumSamples > 0 ? 1 : 0; + if (_mesa_is_legal_color_format(ctx, baseFormat)) { fb->Visual.redBits = _mesa_get_format_bits(fmt, GL_RED_BITS); fb->Visual.greenBits = _mesa_get_format_bits(fmt, GL_GREEN_BITS); @@ -524,8 +531,6 @@ _mesa_update_framebuffer_visual(struct gl_context *ctx, fb->Visual.alphaBits = _mesa_get_format_bits(fmt, GL_ALPHA_BITS); fb->Visual.rgbBits = fb->Visual.redBits + fb->Visual.greenBits + fb->Visual.blueBits; - fb->Visual.samples = rb->NumSamples; - fb->Visual.sampleBuffers = rb->NumSamples > 0 ? 1 : 0; if (_mesa_get_format_color_encoding(fmt) == GL_SRGB) fb->Visual.sRGBCapable = ctx->Extensions.EXT_framebuffer_sRGB; break; diff --git a/mesalib/src/mesa/main/get.c b/mesalib/src/mesa/main/get.c index 15de321e4..b9c98fb22 100644 --- a/mesalib/src/mesa/main/get.c +++ b/mesalib/src/mesa/main/get.c @@ -391,6 +391,7 @@ extra_NV_read_buffer_api_gl[] = { #define API_OPENGL_BIT (1 << API_OPENGL) #define API_OPENGLES_BIT (1 << API_OPENGLES) #define API_OPENGLES2_BIT (1 << API_OPENGLES2) +#define API_OPENGL_CORE_BIT (1 << API_OPENGL_CORE) /* This is the big table describing all the enums we accept in * glGet*v(). The table is partitioned into six parts: enums @@ -405,7 +406,9 @@ extra_NV_read_buffer_api_gl[] = { static const struct value_desc values[] = { /* Enums shared between OpenGL, GLES1 and GLES2 */ { 0, 0, TYPE_API_MASK, - API_OPENGL_BIT | API_OPENGLES_BIT | API_OPENGLES2_BIT, NO_EXTRA}, + API_OPENGL_BIT | API_OPENGLES_BIT | API_OPENGLES2_BIT | + API_OPENGL_CORE_BIT, + NO_EXTRA}, { GL_ALPHA_BITS, BUFFER_INT(Visual.alphaBits), extra_new_buffers }, { GL_BLEND, CONTEXT_BIT0(Color.BlendEnabled), NO_EXTRA }, { GL_BLEND_SRC, CONTEXT_ENUM(Color.Blend[0].SrcRGB), NO_EXTRA }, @@ -534,7 +537,7 @@ static const struct value_desc values[] = { #if FEATURE_GL || FEATURE_ES1 /* Enums in OpenGL and GLES1 */ - { 0, 0, TYPE_API_MASK, API_OPENGL_BIT | API_OPENGLES_BIT, NO_EXTRA }, + { 0, 0, TYPE_API_MASK, API_OPENGL_BIT | API_OPENGLES_BIT | API_OPENGL_CORE_BIT, NO_EXTRA }, { GL_MAX_LIGHTS, CONTEXT_INT(Const.MaxLights), NO_EXTRA }, { GL_LIGHT0, CONTEXT_BOOL(Light.Light[0].Enabled), NO_EXTRA }, { GL_LIGHT1, CONTEXT_BOOL(Light.Light[1].Enabled), NO_EXTRA }, @@ -796,7 +799,7 @@ static const struct value_desc values[] = { #if FEATURE_GL /* Remaining enums are only in OpenGL */ - { 0, 0, TYPE_API_MASK, API_OPENGL_BIT, NO_EXTRA }, + { 0, 0, TYPE_API_MASK, API_OPENGL_BIT | API_OPENGL_CORE_BIT, NO_EXTRA }, { GL_ACCUM_RED_BITS, BUFFER_INT(Visual.accumRedBits), NO_EXTRA }, { GL_ACCUM_GREEN_BITS, BUFFER_INT(Visual.accumGreenBits), NO_EXTRA }, { GL_ACCUM_BLUE_BITS, BUFFER_INT(Visual.accumBlueBits), NO_EXTRA }, @@ -1887,7 +1890,7 @@ check_extra(struct gl_context *ctx, const char *func, const struct value_desc *d } break; case EXTRA_API_GL: - if (ctx->API == API_OPENGL) { + if (_mesa_is_desktop_gl(ctx)) { total++; enabled++; } diff --git a/mesalib/src/mesa/main/getstring.c b/mesalib/src/mesa/main/getstring.c index 2f445aaf9..c6f400af5 100644 --- a/mesalib/src/mesa/main/getstring.c +++ b/mesalib/src/mesa/main/getstring.c @@ -41,6 +41,7 @@ shading_language_version(struct gl_context *ctx) { switch (ctx->API) { case API_OPENGL: + case API_OPENGL_CORE: if (!ctx->Extensions.ARB_shader_objects) { _mesa_error(ctx, GL_INVALID_ENUM, "glGetString"); return (const GLubyte *) 0; diff --git a/mesalib/src/mesa/main/glformats.c b/mesalib/src/mesa/main/glformats.c new file mode 100644 index 000000000..4fe0ae078 --- /dev/null +++ b/mesalib/src/mesa/main/glformats.c @@ -0,0 +1,1329 @@ +/* + * Mesa 3-D graphics library + * + * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. + * Copyright (c) 2008-2009 VMware, Inc. + * Copyright (c) 2012 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + + +#include "context.h" +#include "glformats.h" + + +/** + * \return GL_TRUE if type is packed pixel type, GL_FALSE otherwise. + */ +GLboolean +_mesa_type_is_packed(GLenum type) +{ + switch (type) { + case GL_UNSIGNED_BYTE_3_3_2: + case GL_UNSIGNED_BYTE_2_3_3_REV: + case MESA_UNSIGNED_BYTE_4_4: + case GL_UNSIGNED_SHORT_5_6_5: + case GL_UNSIGNED_SHORT_5_6_5_REV: + case GL_UNSIGNED_SHORT_4_4_4_4: + case GL_UNSIGNED_SHORT_4_4_4_4_REV: + case GL_UNSIGNED_SHORT_5_5_5_1: + case GL_UNSIGNED_SHORT_1_5_5_5_REV: + case GL_UNSIGNED_INT_8_8_8_8: + case GL_UNSIGNED_INT_8_8_8_8_REV: + case GL_UNSIGNED_INT_10_10_10_2: + case GL_UNSIGNED_INT_2_10_10_10_REV: + case GL_UNSIGNED_SHORT_8_8_MESA: + case GL_UNSIGNED_SHORT_8_8_REV_MESA: + case GL_UNSIGNED_INT_24_8_EXT: + case GL_UNSIGNED_INT_5_9_9_9_REV: + case GL_UNSIGNED_INT_10F_11F_11F_REV: + case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: + return GL_TRUE; + } + + return GL_FALSE; +} + + +/** + * Get the size of a GL data type. + * + * \param type GL data type. + * + * \return the size, in bytes, of the given data type, 0 if a GL_BITMAP, or -1 + * if an invalid type enum. + */ +GLint +_mesa_sizeof_type(GLenum type) +{ + switch (type) { + case GL_BITMAP: + return 0; + case GL_UNSIGNED_BYTE: + return sizeof(GLubyte); + case GL_BYTE: + return sizeof(GLbyte); + case GL_UNSIGNED_SHORT: + return sizeof(GLushort); + case GL_SHORT: + return sizeof(GLshort); + case GL_UNSIGNED_INT: + return sizeof(GLuint); + case GL_INT: + return sizeof(GLint); + case GL_FLOAT: + return sizeof(GLfloat); + case GL_DOUBLE: + return sizeof(GLdouble); + case GL_HALF_FLOAT_ARB: + return sizeof(GLhalfARB); + case GL_FIXED: + return sizeof(GLfixed); + default: + return -1; + } +} + + +/** + * Same as _mesa_sizeof_type() but also accepting the packed pixel + * format data types. + */ +GLint +_mesa_sizeof_packed_type(GLenum type) +{ + switch (type) { + case GL_BITMAP: + return 0; + case GL_UNSIGNED_BYTE: + return sizeof(GLubyte); + case GL_BYTE: + return sizeof(GLbyte); + case GL_UNSIGNED_SHORT: + return sizeof(GLushort); + case GL_SHORT: + return sizeof(GLshort); + case GL_UNSIGNED_INT: + return sizeof(GLuint); + case GL_INT: + return sizeof(GLint); + case GL_HALF_FLOAT_ARB: + return sizeof(GLhalfARB); + case GL_FLOAT: + return sizeof(GLfloat); + case GL_UNSIGNED_BYTE_3_3_2: + case GL_UNSIGNED_BYTE_2_3_3_REV: + case MESA_UNSIGNED_BYTE_4_4: + return sizeof(GLubyte); + case GL_UNSIGNED_SHORT_5_6_5: + case GL_UNSIGNED_SHORT_5_6_5_REV: + case GL_UNSIGNED_SHORT_4_4_4_4: + case GL_UNSIGNED_SHORT_4_4_4_4_REV: + case GL_UNSIGNED_SHORT_5_5_5_1: + case GL_UNSIGNED_SHORT_1_5_5_5_REV: + case GL_UNSIGNED_SHORT_8_8_MESA: + case GL_UNSIGNED_SHORT_8_8_REV_MESA: + return sizeof(GLushort); + case GL_UNSIGNED_INT_8_8_8_8: + case GL_UNSIGNED_INT_8_8_8_8_REV: + case GL_UNSIGNED_INT_10_10_10_2: + case GL_UNSIGNED_INT_2_10_10_10_REV: + case GL_UNSIGNED_INT_24_8_EXT: + case GL_UNSIGNED_INT_5_9_9_9_REV: + case GL_UNSIGNED_INT_10F_11F_11F_REV: + return sizeof(GLuint); + case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: + return 8; + default: + return -1; + } +} + + +/** + * Get the number of components in a pixel format. + * + * \param format pixel format. + * + * \return the number of components in the given format, or -1 if a bad format. + */ +GLint +_mesa_components_in_format(GLenum format) +{ + switch (format) { + case GL_COLOR_INDEX: + case GL_STENCIL_INDEX: + case GL_DEPTH_COMPONENT: + case GL_RED: + case GL_RED_INTEGER_EXT: + case GL_GREEN: + case GL_GREEN_INTEGER_EXT: + case GL_BLUE: + case GL_BLUE_INTEGER_EXT: + case GL_ALPHA: + case GL_ALPHA_INTEGER_EXT: + case GL_LUMINANCE: + case GL_LUMINANCE_INTEGER_EXT: + case GL_INTENSITY: + return 1; + + case GL_LUMINANCE_ALPHA: + case GL_LUMINANCE_ALPHA_INTEGER_EXT: + case GL_RG: + case GL_YCBCR_MESA: + case GL_DEPTH_STENCIL_EXT: + case GL_DUDV_ATI: + case GL_DU8DV8_ATI: + case GL_RG_INTEGER: + return 2; + + case GL_RGB: + case GL_BGR: + case GL_RGB_INTEGER_EXT: + case GL_BGR_INTEGER_EXT: + return 3; + + case GL_RGBA: + case GL_BGRA: + case GL_ABGR_EXT: + case GL_RGBA_INTEGER_EXT: + case GL_BGRA_INTEGER_EXT: + return 4; + + default: + return -1; + } +} + + +/** + * Get the bytes per pixel of pixel format type pair. + * + * \param format pixel format. + * \param type pixel type. + * + * \return bytes per pixel, or -1 if a bad format or type was given. + */ +GLint +_mesa_bytes_per_pixel(GLenum format, GLenum type) +{ + GLint comps = _mesa_components_in_format(format); + if (comps < 0) + return -1; + + switch (type) { + case GL_BITMAP: + return 0; /* special case */ + case GL_BYTE: + case GL_UNSIGNED_BYTE: + return comps * sizeof(GLubyte); + case GL_SHORT: + case GL_UNSIGNED_SHORT: + return comps * sizeof(GLshort); + case GL_INT: + case GL_UNSIGNED_INT: + return comps * sizeof(GLint); + case GL_FLOAT: + return comps * sizeof(GLfloat); + case GL_HALF_FLOAT_ARB: + return comps * sizeof(GLhalfARB); + case GL_UNSIGNED_BYTE_3_3_2: + case GL_UNSIGNED_BYTE_2_3_3_REV: + if (format == GL_RGB || format == GL_BGR || + format == GL_RGB_INTEGER_EXT || format == GL_BGR_INTEGER_EXT) + return sizeof(GLubyte); + else + return -1; /* error */ + case GL_UNSIGNED_SHORT_5_6_5: + case GL_UNSIGNED_SHORT_5_6_5_REV: + if (format == GL_RGB || format == GL_BGR || + format == GL_RGB_INTEGER_EXT || format == GL_BGR_INTEGER_EXT) + return sizeof(GLushort); + else + return -1; /* error */ + case GL_UNSIGNED_SHORT_4_4_4_4: + case GL_UNSIGNED_SHORT_4_4_4_4_REV: + case GL_UNSIGNED_SHORT_5_5_5_1: + case GL_UNSIGNED_SHORT_1_5_5_5_REV: + if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT || + format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT) + return sizeof(GLushort); + else + return -1; + case GL_UNSIGNED_INT_8_8_8_8: + case GL_UNSIGNED_INT_8_8_8_8_REV: + case GL_UNSIGNED_INT_10_10_10_2: + case GL_UNSIGNED_INT_2_10_10_10_REV: + if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT || + format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT) + return sizeof(GLuint); + else + return -1; + case GL_UNSIGNED_SHORT_8_8_MESA: + case GL_UNSIGNED_SHORT_8_8_REV_MESA: + if (format == GL_YCBCR_MESA) + return sizeof(GLushort); + else + return -1; + case GL_UNSIGNED_INT_24_8_EXT: + if (format == GL_DEPTH_STENCIL_EXT) + return sizeof(GLuint); + else + return -1; + case GL_UNSIGNED_INT_5_9_9_9_REV: + if (format == GL_RGB) + return sizeof(GLuint); + else + return -1; + case GL_UNSIGNED_INT_10F_11F_11F_REV: + if (format == GL_RGB) + return sizeof(GLuint); + else + return -1; + case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: + if (format == GL_DEPTH_STENCIL) + return 8; + else + return -1; + default: + return -1; + } +} + + +/** + * Test if the given format is an integer (non-normalized) format. + */ +GLboolean +_mesa_is_enum_format_integer(GLenum format) +{ + switch (format) { + /* generic integer formats */ + case GL_RED_INTEGER_EXT: + case GL_GREEN_INTEGER_EXT: + case GL_BLUE_INTEGER_EXT: + case GL_ALPHA_INTEGER_EXT: + case GL_RGB_INTEGER_EXT: + case GL_RGBA_INTEGER_EXT: + case GL_BGR_INTEGER_EXT: + case GL_BGRA_INTEGER_EXT: + case GL_LUMINANCE_INTEGER_EXT: + case GL_LUMINANCE_ALPHA_INTEGER_EXT: + case GL_RG_INTEGER: + /* specific integer formats */ + case GL_RGBA32UI_EXT: + case GL_RGB32UI_EXT: + case GL_RG32UI: + case GL_R32UI: + case GL_ALPHA32UI_EXT: + case GL_INTENSITY32UI_EXT: + case GL_LUMINANCE32UI_EXT: + case GL_LUMINANCE_ALPHA32UI_EXT: + case GL_RGBA16UI_EXT: + case GL_RGB16UI_EXT: + case GL_RG16UI: + case GL_R16UI: + case GL_ALPHA16UI_EXT: + case GL_INTENSITY16UI_EXT: + case GL_LUMINANCE16UI_EXT: + case GL_LUMINANCE_ALPHA16UI_EXT: + case GL_RGBA8UI_EXT: + case GL_RGB8UI_EXT: + case GL_RG8UI: + case GL_R8UI: + case GL_ALPHA8UI_EXT: + case GL_INTENSITY8UI_EXT: + case GL_LUMINANCE8UI_EXT: + case GL_LUMINANCE_ALPHA8UI_EXT: + case GL_RGBA32I_EXT: + case GL_RGB32I_EXT: + case GL_RG32I: + case GL_R32I: + case GL_ALPHA32I_EXT: + case GL_INTENSITY32I_EXT: + case GL_LUMINANCE32I_EXT: + case GL_LUMINANCE_ALPHA32I_EXT: + case GL_RGBA16I_EXT: + case GL_RGB16I_EXT: + case GL_RG16I: + case GL_R16I: + case GL_ALPHA16I_EXT: + case GL_INTENSITY16I_EXT: + case GL_LUMINANCE16I_EXT: + case GL_LUMINANCE_ALPHA16I_EXT: + case GL_RGBA8I_EXT: + case GL_RGB8I_EXT: + case GL_RG8I: + case GL_R8I: + case GL_ALPHA8I_EXT: + case GL_INTENSITY8I_EXT: + case GL_LUMINANCE8I_EXT: + case GL_LUMINANCE_ALPHA8I_EXT: + case GL_RGB10_A2UI: + return GL_TRUE; + default: + return GL_FALSE; + } +} + + +/** + * Test if the given type is an integer (non-normalized) format. + */ +GLboolean +_mesa_is_type_integer(GLenum type) +{ + switch (type) { + case GL_INT: + case GL_UNSIGNED_INT: + case GL_SHORT: + case GL_UNSIGNED_SHORT: + case GL_BYTE: + case GL_UNSIGNED_BYTE: + return GL_TRUE; + default: + return GL_FALSE; + } +} + + +/** + * Test if the given format or type is an integer (non-normalized) format. + */ +extern GLboolean +_mesa_is_enum_format_or_type_integer(GLenum format, GLenum type) +{ + return _mesa_is_enum_format_integer(format) || _mesa_is_type_integer(type); +} + + +GLboolean +_mesa_is_type_unsigned(GLenum type) +{ + switch (type) { + case GL_UNSIGNED_INT: + case GL_UNSIGNED_INT_8_8_8_8: + case GL_UNSIGNED_INT_8_8_8_8_REV: + case GL_UNSIGNED_INT_10_10_10_2: + case GL_UNSIGNED_INT_2_10_10_10_REV: + + case GL_UNSIGNED_SHORT: + case GL_UNSIGNED_SHORT_4_4_4_4: + case GL_UNSIGNED_SHORT_5_5_5_1: + case GL_UNSIGNED_SHORT_5_6_5: + case GL_UNSIGNED_SHORT_5_6_5_REV: + case GL_UNSIGNED_SHORT_4_4_4_4_REV: + case GL_UNSIGNED_SHORT_1_5_5_5_REV: + case GL_UNSIGNED_SHORT_8_8_MESA: + case GL_UNSIGNED_SHORT_8_8_REV_MESA: + + case GL_UNSIGNED_BYTE: + case GL_UNSIGNED_BYTE_3_3_2: + case GL_UNSIGNED_BYTE_2_3_3_REV: + return GL_TRUE; + + default: + return GL_FALSE; + } +} + + +/** + * Test if the given image format is a color/RGBA format (i.e., not color + * index, depth, stencil, etc). + * \param format the image format value (may by an internal texture format) + * \return GL_TRUE if its a color/RGBA format, GL_FALSE otherwise. + */ +GLboolean +_mesa_is_color_format(GLenum format) +{ + switch (format) { + case GL_RED: + case GL_GREEN: + case GL_BLUE: + case GL_ALPHA: + case GL_ALPHA4: + case GL_ALPHA8: + case GL_ALPHA12: + case GL_ALPHA16: + case 1: + case GL_LUMINANCE: + case GL_LUMINANCE4: + case GL_LUMINANCE8: + case GL_LUMINANCE12: + case GL_LUMINANCE16: + case 2: + case GL_LUMINANCE_ALPHA: + case GL_LUMINANCE4_ALPHA4: + case GL_LUMINANCE6_ALPHA2: + case GL_LUMINANCE8_ALPHA8: + case GL_LUMINANCE12_ALPHA4: + case GL_LUMINANCE12_ALPHA12: + case GL_LUMINANCE16_ALPHA16: + case GL_INTENSITY: + case GL_INTENSITY4: + case GL_INTENSITY8: + case GL_INTENSITY12: + case GL_INTENSITY16: + case GL_R8: + case GL_R16: + case GL_RG: + case GL_RG8: + case GL_RG16: + case 3: + case GL_RGB: + case GL_BGR: + case GL_R3_G3_B2: + case GL_RGB4: + case GL_RGB5: + case GL_RGB565: + case GL_RGB8: + case GL_RGB10: + case GL_RGB12: + case GL_RGB16: + case 4: + case GL_ABGR_EXT: + case GL_RGBA: + case GL_BGRA: + case GL_RGBA2: + case GL_RGBA4: + case GL_RGB5_A1: + case GL_RGBA8: + case GL_RGB10_A2: + case GL_RGBA12: + case GL_RGBA16: + /* float texture formats */ + case GL_ALPHA16F_ARB: + case GL_ALPHA32F_ARB: + case GL_LUMINANCE16F_ARB: + case GL_LUMINANCE32F_ARB: + case GL_LUMINANCE_ALPHA16F_ARB: + case GL_LUMINANCE_ALPHA32F_ARB: + case GL_INTENSITY16F_ARB: + case GL_INTENSITY32F_ARB: + case GL_R16F: + case GL_R32F: + case GL_RG16F: + case GL_RG32F: + case GL_RGB16F_ARB: + case GL_RGB32F_ARB: + case GL_RGBA16F_ARB: + case GL_RGBA32F_ARB: + /* compressed formats */ + case GL_COMPRESSED_ALPHA: + case GL_COMPRESSED_LUMINANCE: + case GL_COMPRESSED_LUMINANCE_ALPHA: + case GL_COMPRESSED_INTENSITY: + case GL_COMPRESSED_RED: + case GL_COMPRESSED_RG: + case GL_COMPRESSED_RGB: + case GL_COMPRESSED_RGBA: + case GL_RGB_S3TC: + case GL_RGB4_S3TC: + case GL_RGBA_S3TC: + case GL_RGBA4_S3TC: + case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: + case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: + case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: + case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: + case GL_COMPRESSED_RGB_FXT1_3DFX: + case GL_COMPRESSED_RGBA_FXT1_3DFX: +#if FEATURE_EXT_texture_sRGB + case GL_SRGB_EXT: + case GL_SRGB8_EXT: + case GL_SRGB_ALPHA_EXT: + case GL_SRGB8_ALPHA8_EXT: + case GL_SLUMINANCE_ALPHA_EXT: + case GL_SLUMINANCE8_ALPHA8_EXT: + case GL_SLUMINANCE_EXT: + case GL_SLUMINANCE8_EXT: + case GL_COMPRESSED_SRGB_EXT: + case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT: + case GL_COMPRESSED_SRGB_ALPHA_EXT: + case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: + case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: + case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: + case GL_COMPRESSED_SLUMINANCE_EXT: + case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT: +#endif /* FEATURE_EXT_texture_sRGB */ + case GL_COMPRESSED_RED_RGTC1: + case GL_COMPRESSED_SIGNED_RED_RGTC1: + case GL_COMPRESSED_RG_RGTC2: + case GL_COMPRESSED_SIGNED_RG_RGTC2: + case GL_COMPRESSED_LUMINANCE_LATC1_EXT: + case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT: + case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT: + case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT: + case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI: + case GL_ETC1_RGB8_OES: + /* generic integer formats */ + case GL_RED_INTEGER_EXT: + case GL_GREEN_INTEGER_EXT: + case GL_BLUE_INTEGER_EXT: + case GL_ALPHA_INTEGER_EXT: + case GL_RGB_INTEGER_EXT: + case GL_RGBA_INTEGER_EXT: + case GL_BGR_INTEGER_EXT: + case GL_BGRA_INTEGER_EXT: + case GL_RG_INTEGER: + case GL_LUMINANCE_INTEGER_EXT: + case GL_LUMINANCE_ALPHA_INTEGER_EXT: + /* sized integer formats */ + case GL_RGBA32UI_EXT: + case GL_RGB32UI_EXT: + case GL_RG32UI: + case GL_R32UI: + case GL_ALPHA32UI_EXT: + case GL_INTENSITY32UI_EXT: + case GL_LUMINANCE32UI_EXT: + case GL_LUMINANCE_ALPHA32UI_EXT: + case GL_RGBA16UI_EXT: + case GL_RGB16UI_EXT: + case GL_RG16UI: + case GL_R16UI: + case GL_ALPHA16UI_EXT: + case GL_INTENSITY16UI_EXT: + case GL_LUMINANCE16UI_EXT: + case GL_LUMINANCE_ALPHA16UI_EXT: + case GL_RGBA8UI_EXT: + case GL_RGB8UI_EXT: + case GL_RG8UI: + case GL_R8UI: + case GL_ALPHA8UI_EXT: + case GL_INTENSITY8UI_EXT: + case GL_LUMINANCE8UI_EXT: + case GL_LUMINANCE_ALPHA8UI_EXT: + case GL_RGBA32I_EXT: + case GL_RGB32I_EXT: + case GL_RG32I: + case GL_R32I: + case GL_ALPHA32I_EXT: + case GL_INTENSITY32I_EXT: + case GL_LUMINANCE32I_EXT: + case GL_LUMINANCE_ALPHA32I_EXT: + case GL_RGBA16I_EXT: + case GL_RGB16I_EXT: + case GL_RG16I: + case GL_R16I: + case GL_ALPHA16I_EXT: + case GL_INTENSITY16I_EXT: + case GL_LUMINANCE16I_EXT: + case GL_LUMINANCE_ALPHA16I_EXT: + case GL_RGBA8I_EXT: + case GL_RGB8I_EXT: + case GL_RG8I: + case GL_R8I: + case GL_ALPHA8I_EXT: + case GL_INTENSITY8I_EXT: + case GL_LUMINANCE8I_EXT: + case GL_LUMINANCE_ALPHA8I_EXT: + /* signed, normalized texture formats */ + case GL_RED_SNORM: + case GL_R8_SNORM: + case GL_R16_SNORM: + case GL_RG_SNORM: + case GL_RG8_SNORM: + case GL_RG16_SNORM: + case GL_RGB_SNORM: + case GL_RGB8_SNORM: + case GL_RGB16_SNORM: + case GL_RGBA_SNORM: + case GL_RGBA8_SNORM: + case GL_RGBA16_SNORM: + case GL_ALPHA_SNORM: + case GL_ALPHA8_SNORM: + case GL_ALPHA16_SNORM: + case GL_LUMINANCE_SNORM: + case GL_LUMINANCE8_SNORM: + case GL_LUMINANCE16_SNORM: + case GL_LUMINANCE_ALPHA_SNORM: + case GL_LUMINANCE8_ALPHA8_SNORM: + case GL_LUMINANCE16_ALPHA16_SNORM: + case GL_INTENSITY_SNORM: + case GL_INTENSITY8_SNORM: + case GL_INTENSITY16_SNORM: + case GL_RGB9_E5: + case GL_R11F_G11F_B10F: + case GL_RGB10_A2UI: + return GL_TRUE; + case GL_YCBCR_MESA: /* not considered to be RGB */ + /* fall-through */ + default: + return GL_FALSE; + } +} + + +/** + * Test if the given image format is a depth component format. + */ +GLboolean +_mesa_is_depth_format(GLenum format) +{ + switch (format) { + case GL_DEPTH_COMPONENT: + case GL_DEPTH_COMPONENT16: + case GL_DEPTH_COMPONENT24: + case GL_DEPTH_COMPONENT32: + case GL_DEPTH_COMPONENT32F: + return GL_TRUE; + default: + return GL_FALSE; + } +} + + +/** + * Test if the given image format is a stencil format. + */ +GLboolean +_mesa_is_stencil_format(GLenum format) +{ + switch (format) { + case GL_STENCIL_INDEX: + return GL_TRUE; + default: + return GL_FALSE; + } +} + + +/** + * Test if the given image format is a YCbCr format. + */ +GLboolean +_mesa_is_ycbcr_format(GLenum format) +{ + switch (format) { + case GL_YCBCR_MESA: + return GL_TRUE; + default: + return GL_FALSE; + } +} + + +/** + * Test if the given image format is a depth+stencil format. + */ +GLboolean +_mesa_is_depthstencil_format(GLenum format) +{ + switch (format) { + case GL_DEPTH24_STENCIL8_EXT: + case GL_DEPTH_STENCIL_EXT: + case GL_DEPTH32F_STENCIL8: + return GL_TRUE; + default: + return GL_FALSE; + } +} + + +/** + * Test if the given image format is a depth or stencil format. + */ +GLboolean +_mesa_is_depth_or_stencil_format(GLenum format) +{ + switch (format) { + case GL_DEPTH_COMPONENT: + case GL_DEPTH_COMPONENT16: + case GL_DEPTH_COMPONENT24: + case GL_DEPTH_COMPONENT32: + case GL_STENCIL_INDEX: + case GL_STENCIL_INDEX1_EXT: + case GL_STENCIL_INDEX4_EXT: + case GL_STENCIL_INDEX8_EXT: + case GL_STENCIL_INDEX16_EXT: + case GL_DEPTH_STENCIL_EXT: + case GL_DEPTH24_STENCIL8_EXT: + case GL_DEPTH_COMPONENT32F: + case GL_DEPTH32F_STENCIL8: + return GL_TRUE; + default: + return GL_FALSE; + } +} + + +/** + * Test if the given image format is a dudv format. + */ +GLboolean +_mesa_is_dudv_format(GLenum format) +{ + switch (format) { + case GL_DUDV_ATI: + case GL_DU8DV8_ATI: + return GL_TRUE; + default: + return GL_FALSE; + } +} + + +/** + * Test if an image format is a supported compressed format. + * \param format the internal format token provided by the user. + * \return GL_TRUE if compressed, GL_FALSE if uncompressed + */ +GLboolean +_mesa_is_compressed_format(struct gl_context *ctx, GLenum format) +{ + switch (format) { + case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: + case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: + case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: + case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: + return ctx->Extensions.EXT_texture_compression_s3tc; + case GL_RGB_S3TC: + case GL_RGB4_S3TC: + case GL_RGBA_S3TC: + case GL_RGBA4_S3TC: + return ctx->Extensions.S3_s3tc; + case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT: + case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: + case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: + case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: + return ctx->Extensions.EXT_texture_sRGB + && ctx->Extensions.EXT_texture_compression_s3tc; + case GL_COMPRESSED_RGB_FXT1_3DFX: + case GL_COMPRESSED_RGBA_FXT1_3DFX: + return ctx->Extensions.TDFX_texture_compression_FXT1; + case GL_COMPRESSED_RED_RGTC1: + case GL_COMPRESSED_SIGNED_RED_RGTC1: + case GL_COMPRESSED_RG_RGTC2: + case GL_COMPRESSED_SIGNED_RG_RGTC2: + return ctx->Extensions.ARB_texture_compression_rgtc; + case GL_COMPRESSED_LUMINANCE_LATC1_EXT: + case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT: + case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT: + case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT: + return ctx->Extensions.EXT_texture_compression_latc; + case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI: + return ctx->Extensions.ATI_texture_compression_3dc; + case GL_ETC1_RGB8_OES: + return ctx->Extensions.OES_compressed_ETC1_RGB8_texture; +#if FEATURE_ES + case GL_PALETTE4_RGB8_OES: + case GL_PALETTE4_RGBA8_OES: + case GL_PALETTE4_R5_G6_B5_OES: + case GL_PALETTE4_RGBA4_OES: + case GL_PALETTE4_RGB5_A1_OES: + case GL_PALETTE8_RGB8_OES: + case GL_PALETTE8_RGBA8_OES: + case GL_PALETTE8_R5_G6_B5_OES: + case GL_PALETTE8_RGBA4_OES: + case GL_PALETTE8_RGB5_A1_OES: + return ctx->API == API_OPENGLES; +#endif + default: + return GL_FALSE; + } +} + + +/** + * Convert various base formats to the cooresponding integer format. + */ +GLenum +_mesa_base_format_to_integer_format(GLenum format) +{ + switch(format) { + case GL_RED: + return GL_RED_INTEGER; + case GL_GREEN: + return GL_GREEN_INTEGER; + case GL_BLUE: + return GL_BLUE_INTEGER; + case GL_RG: + return GL_RG_INTEGER; + case GL_RGB: + return GL_RGB_INTEGER; + case GL_RGBA: + return GL_RGBA_INTEGER; + case GL_BGR: + return GL_BGR_INTEGER; + case GL_BGRA: + return GL_BGRA_INTEGER; + case GL_ALPHA: + return GL_ALPHA_INTEGER; + case GL_LUMINANCE: + return GL_LUMINANCE_INTEGER_EXT; + case GL_LUMINANCE_ALPHA: + return GL_LUMINANCE_ALPHA_INTEGER_EXT; + } + + return format; +} + + +/** + * Does the given base texture/renderbuffer format have the channel + * named by 'pname'? + */ +GLboolean +_mesa_base_format_has_channel(GLenum base_format, GLenum pname) +{ + switch (pname) { + case GL_TEXTURE_RED_SIZE: + case GL_TEXTURE_RED_TYPE: + case GL_RENDERBUFFER_RED_SIZE_EXT: + case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE: + if (base_format == GL_RED || + base_format == GL_RG || + base_format == GL_RGB || + base_format == GL_RGBA) { + return GL_TRUE; + } + return GL_FALSE; + case GL_TEXTURE_GREEN_SIZE: + case GL_TEXTURE_GREEN_TYPE: + case GL_RENDERBUFFER_GREEN_SIZE_EXT: + case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: + if (base_format == GL_RG || + base_format == GL_RGB || + base_format == GL_RGBA) { + return GL_TRUE; + } + return GL_FALSE; + case GL_TEXTURE_BLUE_SIZE: + case GL_TEXTURE_BLUE_TYPE: + case GL_RENDERBUFFER_BLUE_SIZE_EXT: + case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: + if (base_format == GL_RGB || + base_format == GL_RGBA) { + return GL_TRUE; + } + return GL_FALSE; + case GL_TEXTURE_ALPHA_SIZE: + case GL_TEXTURE_ALPHA_TYPE: + case GL_RENDERBUFFER_ALPHA_SIZE_EXT: + case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: + if (base_format == GL_RGBA || + base_format == GL_ALPHA || + base_format == GL_LUMINANCE_ALPHA) { + return GL_TRUE; + } + return GL_FALSE; + case GL_TEXTURE_LUMINANCE_SIZE: + case GL_TEXTURE_LUMINANCE_TYPE: + if (base_format == GL_LUMINANCE || + base_format == GL_LUMINANCE_ALPHA) { + return GL_TRUE; + } + return GL_FALSE; + case GL_TEXTURE_INTENSITY_SIZE: + case GL_TEXTURE_INTENSITY_TYPE: + if (base_format == GL_INTENSITY) { + return GL_TRUE; + } + return GL_FALSE; + case GL_TEXTURE_DEPTH_SIZE: + case GL_TEXTURE_DEPTH_TYPE: + case GL_RENDERBUFFER_DEPTH_SIZE_EXT: + case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: + if (base_format == GL_DEPTH_STENCIL || + base_format == GL_DEPTH_COMPONENT) { + return GL_TRUE; + } + return GL_FALSE; + case GL_RENDERBUFFER_STENCIL_SIZE_EXT: + case GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: + if (base_format == GL_DEPTH_STENCIL || + base_format == GL_STENCIL_INDEX) { + return GL_TRUE; + } + return GL_FALSE; + default: + _mesa_warning(NULL, "%s: Unexpected channel token 0x%x\n", + __FUNCTION__, pname); + return GL_FALSE; + } + + return GL_FALSE; +} + + +/** + * Do error checking of format/type combinations for glReadPixels, + * glDrawPixels and glTex[Sub]Image. Note that depending on the format + * and type values, we may either generate GL_INVALID_OPERATION or + * GL_INVALID_ENUM. + * + * \param format pixel format. + * \param type pixel type. + * + * \return GL_INVALID_ENUM, GL_INVALID_OPERATION or GL_NO_ERROR + */ +GLenum +_mesa_error_check_format_and_type(const struct gl_context *ctx, + GLenum format, GLenum type) +{ + /* special type-based checks (see glReadPixels, glDrawPixels error lists) */ + switch (type) { + case GL_BITMAP: + if (format != GL_COLOR_INDEX && format != GL_STENCIL_INDEX) { + return GL_INVALID_ENUM; + } + break; + + case GL_UNSIGNED_BYTE_3_3_2: + case GL_UNSIGNED_BYTE_2_3_3_REV: + case GL_UNSIGNED_SHORT_5_6_5: + case GL_UNSIGNED_SHORT_5_6_5_REV: + if (format == GL_RGB) { + break; /* OK */ + } + if (format == GL_RGB_INTEGER_EXT && + ctx->Extensions.ARB_texture_rgb10_a2ui) { + break; /* OK */ + } + return GL_INVALID_OPERATION; + + case GL_UNSIGNED_SHORT_4_4_4_4: + case GL_UNSIGNED_SHORT_4_4_4_4_REV: + case GL_UNSIGNED_SHORT_5_5_5_1: + case GL_UNSIGNED_SHORT_1_5_5_5_REV: + case GL_UNSIGNED_INT_8_8_8_8: + case GL_UNSIGNED_INT_8_8_8_8_REV: + case GL_UNSIGNED_INT_10_10_10_2: + case GL_UNSIGNED_INT_2_10_10_10_REV: + if (format == GL_RGBA || + format == GL_BGRA || + format == GL_ABGR_EXT) { + break; /* OK */ + } + if ((format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT) && + ctx->Extensions.ARB_texture_rgb10_a2ui) { + break; /* OK */ + } + return GL_INVALID_OPERATION; + + case GL_UNSIGNED_INT_24_8: + if (!ctx->Extensions.EXT_packed_depth_stencil) { + return GL_INVALID_ENUM; + } + if (format != GL_DEPTH_STENCIL) { + return GL_INVALID_OPERATION; + } + return GL_NO_ERROR; + + case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: + if (!ctx->Extensions.ARB_depth_buffer_float) { + return GL_INVALID_ENUM; + } + if (format != GL_DEPTH_STENCIL) { + return GL_INVALID_OPERATION; + } + return GL_NO_ERROR; + + case GL_UNSIGNED_INT_10F_11F_11F_REV: + if (!ctx->Extensions.EXT_packed_float) { + return GL_INVALID_ENUM; + } + if (format != GL_RGB) { + return GL_INVALID_OPERATION; + } + return GL_NO_ERROR; + + default: + ; /* fall-through */ + } + + /* now, for each format, check the type for compatibility */ + switch (format) { + case GL_COLOR_INDEX: + case GL_STENCIL_INDEX: + switch (type) { + case GL_BITMAP: + case GL_BYTE: + case GL_UNSIGNED_BYTE: + case GL_SHORT: + case GL_UNSIGNED_SHORT: + case GL_INT: + case GL_UNSIGNED_INT: + case GL_FLOAT: + return GL_NO_ERROR; + case GL_HALF_FLOAT: + return ctx->Extensions.ARB_half_float_pixel + ? GL_NO_ERROR : GL_INVALID_ENUM; + default: + return GL_INVALID_ENUM; + } + + case GL_RED: + case GL_GREEN: + case GL_BLUE: + case GL_ALPHA: +#if 0 /* not legal! see table 3.6 of the 1.5 spec */ + case GL_INTENSITY: +#endif + case GL_LUMINANCE: + case GL_LUMINANCE_ALPHA: + case GL_DEPTH_COMPONENT: + switch (type) { + case GL_BYTE: + case GL_UNSIGNED_BYTE: + case GL_SHORT: + case GL_UNSIGNED_SHORT: + case GL_INT: + case GL_UNSIGNED_INT: + case GL_FLOAT: + return GL_NO_ERROR; + case GL_HALF_FLOAT: + return ctx->Extensions.ARB_half_float_pixel + ? GL_NO_ERROR : GL_INVALID_ENUM; + default: + return GL_INVALID_ENUM; + } + + case GL_RG: + if (!ctx->Extensions.ARB_texture_rg) + return GL_INVALID_ENUM; + switch (type) { + case GL_BYTE: + case GL_UNSIGNED_BYTE: + case GL_SHORT: + case GL_UNSIGNED_SHORT: + case GL_INT: + case GL_UNSIGNED_INT: + case GL_FLOAT: + return GL_NO_ERROR; + case GL_HALF_FLOAT: + return ctx->Extensions.ARB_half_float_pixel + ? GL_NO_ERROR : GL_INVALID_ENUM; + default: + return GL_INVALID_ENUM; + } + + case GL_RGB: + switch (type) { + case GL_BYTE: + case GL_UNSIGNED_BYTE: + case GL_SHORT: + case GL_UNSIGNED_SHORT: + case GL_INT: + case GL_UNSIGNED_INT: + case GL_FLOAT: + case GL_UNSIGNED_BYTE_3_3_2: + case GL_UNSIGNED_BYTE_2_3_3_REV: + case GL_UNSIGNED_SHORT_5_6_5: + case GL_UNSIGNED_SHORT_5_6_5_REV: + return GL_NO_ERROR; + case GL_HALF_FLOAT: + return ctx->Extensions.ARB_half_float_pixel + ? GL_NO_ERROR : GL_INVALID_ENUM; + case GL_UNSIGNED_INT_5_9_9_9_REV: + return ctx->Extensions.EXT_texture_shared_exponent + ? GL_NO_ERROR : GL_INVALID_ENUM; + case GL_UNSIGNED_INT_10F_11F_11F_REV: + return ctx->Extensions.EXT_packed_float + ? GL_NO_ERROR : GL_INVALID_ENUM; + default: + return GL_INVALID_ENUM; + } + + case GL_BGR: + switch (type) { + /* NOTE: no packed types are supported with BGR. That's + * intentional, according to the GL spec. + */ + case GL_BYTE: + case GL_UNSIGNED_BYTE: + case GL_SHORT: + case GL_UNSIGNED_SHORT: + case GL_INT: + case GL_UNSIGNED_INT: + case GL_FLOAT: + return GL_NO_ERROR; + case GL_HALF_FLOAT: + return ctx->Extensions.ARB_half_float_pixel + ? GL_NO_ERROR : GL_INVALID_ENUM; + default: + return GL_INVALID_ENUM; + } + + case GL_RGBA: + case GL_BGRA: + case GL_ABGR_EXT: + switch (type) { + case GL_BYTE: + case GL_UNSIGNED_BYTE: + case GL_SHORT: + case GL_UNSIGNED_SHORT: + case GL_INT: + case GL_UNSIGNED_INT: + case GL_FLOAT: + case GL_UNSIGNED_SHORT_4_4_4_4: + case GL_UNSIGNED_SHORT_4_4_4_4_REV: + case GL_UNSIGNED_SHORT_5_5_5_1: + case GL_UNSIGNED_SHORT_1_5_5_5_REV: + case GL_UNSIGNED_INT_8_8_8_8: + case GL_UNSIGNED_INT_8_8_8_8_REV: + case GL_UNSIGNED_INT_10_10_10_2: + case GL_UNSIGNED_INT_2_10_10_10_REV: + return GL_NO_ERROR; + case GL_HALF_FLOAT: + return ctx->Extensions.ARB_half_float_pixel + ? GL_NO_ERROR : GL_INVALID_ENUM; + default: + return GL_INVALID_ENUM; + } + + case GL_YCBCR_MESA: + if (!ctx->Extensions.MESA_ycbcr_texture) + return GL_INVALID_ENUM; + if (type == GL_UNSIGNED_SHORT_8_8_MESA || + type == GL_UNSIGNED_SHORT_8_8_REV_MESA) + return GL_NO_ERROR; + else + return GL_INVALID_OPERATION; + + case GL_DEPTH_STENCIL_EXT: + if (ctx->Extensions.EXT_packed_depth_stencil && + type == GL_UNSIGNED_INT_24_8) + return GL_NO_ERROR; + else if (ctx->Extensions.ARB_depth_buffer_float && + type == GL_FLOAT_32_UNSIGNED_INT_24_8_REV) + return GL_NO_ERROR; + else + return GL_INVALID_ENUM; + + case GL_DUDV_ATI: + case GL_DU8DV8_ATI: + if (!ctx->Extensions.ATI_envmap_bumpmap) + return GL_INVALID_ENUM; + switch (type) { + case GL_BYTE: + case GL_UNSIGNED_BYTE: + case GL_SHORT: + case GL_UNSIGNED_SHORT: + case GL_INT: + case GL_UNSIGNED_INT: + case GL_FLOAT: + return GL_NO_ERROR; + default: + return GL_INVALID_ENUM; + } + + /* integer-valued formats */ + case GL_RED_INTEGER_EXT: + case GL_GREEN_INTEGER_EXT: + case GL_BLUE_INTEGER_EXT: + case GL_ALPHA_INTEGER_EXT: + case GL_RG_INTEGER: + switch (type) { + case GL_BYTE: + case GL_UNSIGNED_BYTE: + case GL_SHORT: + case GL_UNSIGNED_SHORT: + case GL_INT: + case GL_UNSIGNED_INT: + return (ctx->VersionMajor >= 3 || + ctx->Extensions.EXT_texture_integer) + ? GL_NO_ERROR : GL_INVALID_ENUM; + default: + return GL_INVALID_ENUM; + } + + case GL_RGB_INTEGER_EXT: + switch (type) { + case GL_BYTE: + case GL_UNSIGNED_BYTE: + case GL_SHORT: + case GL_UNSIGNED_SHORT: + case GL_INT: + case GL_UNSIGNED_INT: + return (ctx->VersionMajor >= 3 || + ctx->Extensions.EXT_texture_integer) + ? GL_NO_ERROR : GL_INVALID_ENUM; + case GL_UNSIGNED_BYTE_3_3_2: + case GL_UNSIGNED_BYTE_2_3_3_REV: + case GL_UNSIGNED_SHORT_5_6_5: + case GL_UNSIGNED_SHORT_5_6_5_REV: + return ctx->Extensions.ARB_texture_rgb10_a2ui + ? GL_NO_ERROR : GL_INVALID_ENUM; + default: + return GL_INVALID_ENUM; + } + + case GL_BGR_INTEGER_EXT: + switch (type) { + case GL_BYTE: + case GL_UNSIGNED_BYTE: + case GL_SHORT: + case GL_UNSIGNED_SHORT: + case GL_INT: + case GL_UNSIGNED_INT: + /* NOTE: no packed formats w/ BGR format */ + return (ctx->VersionMajor >= 3 || + ctx->Extensions.EXT_texture_integer) + ? GL_NO_ERROR : GL_INVALID_ENUM; + default: + return GL_INVALID_ENUM; + } + + case GL_RGBA_INTEGER_EXT: + case GL_BGRA_INTEGER_EXT: + switch (type) { + case GL_BYTE: + case GL_UNSIGNED_BYTE: + case GL_SHORT: + case GL_UNSIGNED_SHORT: + case GL_INT: + case GL_UNSIGNED_INT: + return (ctx->VersionMajor >= 3 || + ctx->Extensions.EXT_texture_integer) + ? GL_NO_ERROR : GL_INVALID_ENUM; + case GL_UNSIGNED_SHORT_4_4_4_4: + case GL_UNSIGNED_SHORT_4_4_4_4_REV: + case GL_UNSIGNED_SHORT_5_5_5_1: + case GL_UNSIGNED_SHORT_1_5_5_5_REV: + case GL_UNSIGNED_INT_8_8_8_8: + case GL_UNSIGNED_INT_8_8_8_8_REV: + case GL_UNSIGNED_INT_10_10_10_2: + case GL_UNSIGNED_INT_2_10_10_10_REV: + return ctx->Extensions.ARB_texture_rgb10_a2ui + ? GL_NO_ERROR : GL_INVALID_ENUM; + default: + return GL_INVALID_ENUM; + } + + case GL_LUMINANCE_INTEGER_EXT: + case GL_LUMINANCE_ALPHA_INTEGER_EXT: + switch (type) { + case GL_BYTE: + case GL_UNSIGNED_BYTE: + case GL_SHORT: + case GL_UNSIGNED_SHORT: + case GL_INT: + case GL_UNSIGNED_INT: + return ctx->Extensions.EXT_texture_integer + ? GL_NO_ERROR : GL_INVALID_ENUM; + default: + return GL_INVALID_ENUM; + } + + default: + return GL_INVALID_ENUM; + } + return GL_NO_ERROR; +} diff --git a/mesalib/src/mesa/main/glformats.h b/mesalib/src/mesa/main/glformats.h new file mode 100644 index 000000000..d553eae0a --- /dev/null +++ b/mesalib/src/mesa/main/glformats.h @@ -0,0 +1,103 @@ +/* + * Mesa 3-D graphics library + * + * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. + * Copyright (c) 2008-2009 VMware, Inc. + * Copyright (c) 2012 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#ifndef GLFORMATS_H +#define GLFORMATS_H + + +#include <GL/gl.h> + + +#ifdef __cplusplus +extern "C" { +#endif + +extern GLboolean +_mesa_type_is_packed(GLenum type); + +extern GLint +_mesa_sizeof_type( GLenum type ); + +extern GLint +_mesa_sizeof_packed_type( GLenum type ); + +extern GLint +_mesa_components_in_format( GLenum format ); + +extern GLint +_mesa_bytes_per_pixel( GLenum format, GLenum type ); + +extern GLboolean +_mesa_is_type_integer(GLenum type); + +extern GLboolean +_mesa_is_type_unsigned(GLenum type); + +extern GLboolean +_mesa_is_enum_format_integer(GLenum format); + +extern GLboolean +_mesa_is_enum_format_or_type_integer(GLenum format, GLenum type); + +extern GLboolean +_mesa_is_color_format(GLenum format); + +extern GLboolean +_mesa_is_depth_format(GLenum format); + +extern GLboolean +_mesa_is_stencil_format(GLenum format); + +extern GLboolean +_mesa_is_ycbcr_format(GLenum format); + +extern GLboolean +_mesa_is_depthstencil_format(GLenum format); + +extern GLboolean +_mesa_is_depth_or_stencil_format(GLenum format); + +extern GLboolean +_mesa_is_dudv_format(GLenum format); + +extern GLboolean +_mesa_is_compressed_format(struct gl_context *ctx, GLenum format); + +extern GLenum +_mesa_base_format_to_integer_format(GLenum format); + +extern GLboolean +_mesa_base_format_has_channel(GLenum base_format, GLenum pname); + +extern GLenum +_mesa_error_check_format_and_type(const struct gl_context *ctx, + GLenum format, GLenum type); + + +#ifdef __cplusplus +} +#endif + +#endif /* GLFORMATS_H */ diff --git a/mesalib/src/mesa/main/image.c b/mesalib/src/mesa/main/image.c index 678dfeb2b..91b720373 100644 --- a/mesalib/src/mesa/main/image.c +++ b/mesalib/src/mesa/main/image.c @@ -32,6 +32,7 @@ #include "glheader.h" #include "colormac.h" +#include "glformats.h" #include "image.h" #include "imports.h" #include "macros.h" @@ -41,40 +42,6 @@ /** - * \return GL_TRUE if type is packed pixel type, GL_FALSE otherwise. - */ -GLboolean -_mesa_type_is_packed(GLenum type) -{ - switch (type) { - case GL_UNSIGNED_BYTE_3_3_2: - case GL_UNSIGNED_BYTE_2_3_3_REV: - case MESA_UNSIGNED_BYTE_4_4: - case GL_UNSIGNED_SHORT_5_6_5: - case GL_UNSIGNED_SHORT_5_6_5_REV: - case GL_UNSIGNED_SHORT_4_4_4_4: - case GL_UNSIGNED_SHORT_4_4_4_4_REV: - case GL_UNSIGNED_SHORT_5_5_5_1: - case GL_UNSIGNED_SHORT_1_5_5_5_REV: - case GL_UNSIGNED_INT_8_8_8_8: - case GL_UNSIGNED_INT_8_8_8_8_REV: - case GL_UNSIGNED_INT_10_10_10_2: - case GL_UNSIGNED_INT_2_10_10_10_REV: - case GL_UNSIGNED_SHORT_8_8_MESA: - case GL_UNSIGNED_SHORT_8_8_REV_MESA: - case GL_UNSIGNED_INT_24_8_EXT: - case GL_UNSIGNED_INT_5_9_9_9_REV: - case GL_UNSIGNED_INT_10F_11F_11F_REV: - case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: - return GL_TRUE; - } - - return GL_FALSE; -} - - - -/** * Flip the order of the 2 bytes in each word in the given array. * * \param p array. @@ -110,1178 +77,6 @@ _mesa_swap4( GLuint *p, GLuint n ) /** - * Get the size of a GL data type. - * - * \param type GL data type. - * - * \return the size, in bytes, of the given data type, 0 if a GL_BITMAP, or -1 - * if an invalid type enum. - */ -GLint -_mesa_sizeof_type( GLenum type ) -{ - switch (type) { - case GL_BITMAP: - return 0; - case GL_UNSIGNED_BYTE: - return sizeof(GLubyte); - case GL_BYTE: - return sizeof(GLbyte); - case GL_UNSIGNED_SHORT: - return sizeof(GLushort); - case GL_SHORT: - return sizeof(GLshort); - case GL_UNSIGNED_INT: - return sizeof(GLuint); - case GL_INT: - return sizeof(GLint); - case GL_FLOAT: - return sizeof(GLfloat); - case GL_DOUBLE: - return sizeof(GLdouble); - case GL_HALF_FLOAT_ARB: - return sizeof(GLhalfARB); - case GL_FIXED: - return sizeof(GLfixed); - default: - return -1; - } -} - - -/** - * Same as _mesa_sizeof_type() but also accepting the packed pixel - * format data types. - */ -GLint -_mesa_sizeof_packed_type( GLenum type ) -{ - switch (type) { - case GL_BITMAP: - return 0; - case GL_UNSIGNED_BYTE: - return sizeof(GLubyte); - case GL_BYTE: - return sizeof(GLbyte); - case GL_UNSIGNED_SHORT: - return sizeof(GLushort); - case GL_SHORT: - return sizeof(GLshort); - case GL_UNSIGNED_INT: - return sizeof(GLuint); - case GL_INT: - return sizeof(GLint); - case GL_HALF_FLOAT_ARB: - return sizeof(GLhalfARB); - case GL_FLOAT: - return sizeof(GLfloat); - case GL_UNSIGNED_BYTE_3_3_2: - case GL_UNSIGNED_BYTE_2_3_3_REV: - case MESA_UNSIGNED_BYTE_4_4: - return sizeof(GLubyte); - case GL_UNSIGNED_SHORT_5_6_5: - case GL_UNSIGNED_SHORT_5_6_5_REV: - case GL_UNSIGNED_SHORT_4_4_4_4: - case GL_UNSIGNED_SHORT_4_4_4_4_REV: - case GL_UNSIGNED_SHORT_5_5_5_1: - case GL_UNSIGNED_SHORT_1_5_5_5_REV: - case GL_UNSIGNED_SHORT_8_8_MESA: - case GL_UNSIGNED_SHORT_8_8_REV_MESA: - return sizeof(GLushort); - case GL_UNSIGNED_INT_8_8_8_8: - case GL_UNSIGNED_INT_8_8_8_8_REV: - case GL_UNSIGNED_INT_10_10_10_2: - case GL_UNSIGNED_INT_2_10_10_10_REV: - case GL_UNSIGNED_INT_24_8_EXT: - case GL_UNSIGNED_INT_5_9_9_9_REV: - case GL_UNSIGNED_INT_10F_11F_11F_REV: - return sizeof(GLuint); - case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: - return 8; - default: - return -1; - } -} - - -/** - * Get the number of components in a pixel format. - * - * \param format pixel format. - * - * \return the number of components in the given format, or -1 if a bad format. - */ -GLint -_mesa_components_in_format( GLenum format ) -{ - switch (format) { - case GL_COLOR_INDEX: - case GL_STENCIL_INDEX: - case GL_DEPTH_COMPONENT: - case GL_RED: - case GL_RED_INTEGER_EXT: - case GL_GREEN: - case GL_GREEN_INTEGER_EXT: - case GL_BLUE: - case GL_BLUE_INTEGER_EXT: - case GL_ALPHA: - case GL_ALPHA_INTEGER_EXT: - case GL_LUMINANCE: - case GL_LUMINANCE_INTEGER_EXT: - case GL_INTENSITY: - return 1; - - case GL_LUMINANCE_ALPHA: - case GL_LUMINANCE_ALPHA_INTEGER_EXT: - case GL_RG: - case GL_YCBCR_MESA: - case GL_DEPTH_STENCIL_EXT: - case GL_DUDV_ATI: - case GL_DU8DV8_ATI: - case GL_RG_INTEGER: - return 2; - - case GL_RGB: - case GL_BGR: - case GL_RGB_INTEGER_EXT: - case GL_BGR_INTEGER_EXT: - return 3; - - case GL_RGBA: - case GL_BGRA: - case GL_ABGR_EXT: - case GL_RGBA_INTEGER_EXT: - case GL_BGRA_INTEGER_EXT: - return 4; - - default: - return -1; - } -} - - -/** - * Get the bytes per pixel of pixel format type pair. - * - * \param format pixel format. - * \param type pixel type. - * - * \return bytes per pixel, or -1 if a bad format or type was given. - */ -GLint -_mesa_bytes_per_pixel( GLenum format, GLenum type ) -{ - GLint comps = _mesa_components_in_format( format ); - if (comps < 0) - return -1; - - switch (type) { - case GL_BITMAP: - return 0; /* special case */ - case GL_BYTE: - case GL_UNSIGNED_BYTE: - return comps * sizeof(GLubyte); - case GL_SHORT: - case GL_UNSIGNED_SHORT: - return comps * sizeof(GLshort); - case GL_INT: - case GL_UNSIGNED_INT: - return comps * sizeof(GLint); - case GL_FLOAT: - return comps * sizeof(GLfloat); - case GL_HALF_FLOAT_ARB: - return comps * sizeof(GLhalfARB); - case GL_UNSIGNED_BYTE_3_3_2: - case GL_UNSIGNED_BYTE_2_3_3_REV: - if (format == GL_RGB || format == GL_BGR || - format == GL_RGB_INTEGER_EXT || format == GL_BGR_INTEGER_EXT) - return sizeof(GLubyte); - else - return -1; /* error */ - case GL_UNSIGNED_SHORT_5_6_5: - case GL_UNSIGNED_SHORT_5_6_5_REV: - if (format == GL_RGB || format == GL_BGR || - format == GL_RGB_INTEGER_EXT || format == GL_BGR_INTEGER_EXT) - return sizeof(GLushort); - else - return -1; /* error */ - case GL_UNSIGNED_SHORT_4_4_4_4: - case GL_UNSIGNED_SHORT_4_4_4_4_REV: - case GL_UNSIGNED_SHORT_5_5_5_1: - case GL_UNSIGNED_SHORT_1_5_5_5_REV: - if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT || - format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT) - return sizeof(GLushort); - else - return -1; - case GL_UNSIGNED_INT_8_8_8_8: - case GL_UNSIGNED_INT_8_8_8_8_REV: - case GL_UNSIGNED_INT_10_10_10_2: - case GL_UNSIGNED_INT_2_10_10_10_REV: - if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT || - format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT) - return sizeof(GLuint); - else - return -1; - case GL_UNSIGNED_SHORT_8_8_MESA: - case GL_UNSIGNED_SHORT_8_8_REV_MESA: - if (format == GL_YCBCR_MESA) - return sizeof(GLushort); - else - return -1; - case GL_UNSIGNED_INT_24_8_EXT: - if (format == GL_DEPTH_STENCIL_EXT) - return sizeof(GLuint); - else - return -1; - case GL_UNSIGNED_INT_5_9_9_9_REV: - if (format == GL_RGB) - return sizeof(GLuint); - else - return -1; - case GL_UNSIGNED_INT_10F_11F_11F_REV: - if (format == GL_RGB) - return sizeof(GLuint); - else - return -1; - case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: - if (format == GL_DEPTH_STENCIL) - return 8; - else - return -1; - default: - return -1; - } -} - - -/** - * Do error checking of format/type combinations for glReadPixels, - * glDrawPixels and glTex[Sub]Image. Note that depending on the format - * and type values, we may either generate GL_INVALID_OPERATION or - * GL_INVALID_ENUM. - * - * \param format pixel format. - * \param type pixel type. - * - * \return GL_INVALID_ENUM, GL_INVALID_OPERATION or GL_NO_ERROR - */ -GLenum -_mesa_error_check_format_and_type(const struct gl_context *ctx, - GLenum format, GLenum type) -{ - /* special type-based checks (see glReadPixels, glDrawPixels error lists) */ - switch (type) { - case GL_BITMAP: - if (format != GL_COLOR_INDEX && format != GL_STENCIL_INDEX) { - return GL_INVALID_ENUM; - } - break; - - case GL_UNSIGNED_BYTE_3_3_2: - case GL_UNSIGNED_BYTE_2_3_3_REV: - case GL_UNSIGNED_SHORT_5_6_5: - case GL_UNSIGNED_SHORT_5_6_5_REV: - if (format == GL_RGB) { - break; /* OK */ - } - if (format == GL_RGB_INTEGER_EXT && - ctx->Extensions.ARB_texture_rgb10_a2ui) { - break; /* OK */ - } - return GL_INVALID_OPERATION; - - case GL_UNSIGNED_SHORT_4_4_4_4: - case GL_UNSIGNED_SHORT_4_4_4_4_REV: - case GL_UNSIGNED_SHORT_5_5_5_1: - case GL_UNSIGNED_SHORT_1_5_5_5_REV: - case GL_UNSIGNED_INT_8_8_8_8: - case GL_UNSIGNED_INT_8_8_8_8_REV: - case GL_UNSIGNED_INT_10_10_10_2: - case GL_UNSIGNED_INT_2_10_10_10_REV: - if (format == GL_RGBA || - format == GL_BGRA || - format == GL_ABGR_EXT) { - break; /* OK */ - } - if ((format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT) && - ctx->Extensions.ARB_texture_rgb10_a2ui) { - break; /* OK */ - } - return GL_INVALID_OPERATION; - - case GL_UNSIGNED_INT_24_8: - if (!ctx->Extensions.EXT_packed_depth_stencil) { - return GL_INVALID_ENUM; - } - if (format != GL_DEPTH_STENCIL) { - return GL_INVALID_OPERATION; - } - return GL_NO_ERROR; - - case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: - if (!ctx->Extensions.ARB_depth_buffer_float) { - return GL_INVALID_ENUM; - } - if (format != GL_DEPTH_STENCIL) { - return GL_INVALID_OPERATION; - } - return GL_NO_ERROR; - - case GL_UNSIGNED_INT_10F_11F_11F_REV: - if (!ctx->Extensions.EXT_packed_float) { - return GL_INVALID_ENUM; - } - if (format != GL_RGB) { - return GL_INVALID_OPERATION; - } - return GL_NO_ERROR; - - default: - ; /* fall-through */ - } - - /* now, for each format, check the type for compatibility */ - switch (format) { - case GL_COLOR_INDEX: - case GL_STENCIL_INDEX: - switch (type) { - case GL_BITMAP: - case GL_BYTE: - case GL_UNSIGNED_BYTE: - case GL_SHORT: - case GL_UNSIGNED_SHORT: - case GL_INT: - case GL_UNSIGNED_INT: - case GL_FLOAT: - return GL_NO_ERROR; - case GL_HALF_FLOAT: - return ctx->Extensions.ARB_half_float_pixel - ? GL_NO_ERROR : GL_INVALID_ENUM; - default: - return GL_INVALID_ENUM; - } - - case GL_RED: - case GL_GREEN: - case GL_BLUE: - case GL_ALPHA: -#if 0 /* not legal! see table 3.6 of the 1.5 spec */ - case GL_INTENSITY: -#endif - case GL_LUMINANCE: - case GL_LUMINANCE_ALPHA: - case GL_DEPTH_COMPONENT: - switch (type) { - case GL_BYTE: - case GL_UNSIGNED_BYTE: - case GL_SHORT: - case GL_UNSIGNED_SHORT: - case GL_INT: - case GL_UNSIGNED_INT: - case GL_FLOAT: - return GL_NO_ERROR; - case GL_HALF_FLOAT: - return ctx->Extensions.ARB_half_float_pixel - ? GL_NO_ERROR : GL_INVALID_ENUM; - default: - return GL_INVALID_ENUM; - } - - case GL_RG: - if (!ctx->Extensions.ARB_texture_rg) - return GL_INVALID_ENUM; - switch (type) { - case GL_BYTE: - case GL_UNSIGNED_BYTE: - case GL_SHORT: - case GL_UNSIGNED_SHORT: - case GL_INT: - case GL_UNSIGNED_INT: - case GL_FLOAT: - return GL_NO_ERROR; - case GL_HALF_FLOAT: - return ctx->Extensions.ARB_half_float_pixel - ? GL_NO_ERROR : GL_INVALID_ENUM; - default: - return GL_INVALID_ENUM; - } - - case GL_RGB: - switch (type) { - case GL_BYTE: - case GL_UNSIGNED_BYTE: - case GL_SHORT: - case GL_UNSIGNED_SHORT: - case GL_INT: - case GL_UNSIGNED_INT: - case GL_FLOAT: - case GL_UNSIGNED_BYTE_3_3_2: - case GL_UNSIGNED_BYTE_2_3_3_REV: - case GL_UNSIGNED_SHORT_5_6_5: - case GL_UNSIGNED_SHORT_5_6_5_REV: - return GL_NO_ERROR; - case GL_HALF_FLOAT: - return ctx->Extensions.ARB_half_float_pixel - ? GL_NO_ERROR : GL_INVALID_ENUM; - case GL_UNSIGNED_INT_5_9_9_9_REV: - return ctx->Extensions.EXT_texture_shared_exponent - ? GL_NO_ERROR : GL_INVALID_ENUM; - case GL_UNSIGNED_INT_10F_11F_11F_REV: - return ctx->Extensions.EXT_packed_float - ? GL_NO_ERROR : GL_INVALID_ENUM; - default: - return GL_INVALID_ENUM; - } - - case GL_BGR: - switch (type) { - /* NOTE: no packed types are supported with BGR. That's - * intentional, according to the GL spec. - */ - case GL_BYTE: - case GL_UNSIGNED_BYTE: - case GL_SHORT: - case GL_UNSIGNED_SHORT: - case GL_INT: - case GL_UNSIGNED_INT: - case GL_FLOAT: - return GL_NO_ERROR; - case GL_HALF_FLOAT: - return ctx->Extensions.ARB_half_float_pixel - ? GL_NO_ERROR : GL_INVALID_ENUM; - default: - return GL_INVALID_ENUM; - } - - case GL_RGBA: - case GL_BGRA: - case GL_ABGR_EXT: - switch (type) { - case GL_BYTE: - case GL_UNSIGNED_BYTE: - case GL_SHORT: - case GL_UNSIGNED_SHORT: - case GL_INT: - case GL_UNSIGNED_INT: - case GL_FLOAT: - case GL_UNSIGNED_SHORT_4_4_4_4: - case GL_UNSIGNED_SHORT_4_4_4_4_REV: - case GL_UNSIGNED_SHORT_5_5_5_1: - case GL_UNSIGNED_SHORT_1_5_5_5_REV: - case GL_UNSIGNED_INT_8_8_8_8: - case GL_UNSIGNED_INT_8_8_8_8_REV: - case GL_UNSIGNED_INT_10_10_10_2: - case GL_UNSIGNED_INT_2_10_10_10_REV: - return GL_NO_ERROR; - case GL_HALF_FLOAT: - return ctx->Extensions.ARB_half_float_pixel - ? GL_NO_ERROR : GL_INVALID_ENUM; - default: - return GL_INVALID_ENUM; - } - - case GL_YCBCR_MESA: - if (!ctx->Extensions.MESA_ycbcr_texture) - return GL_INVALID_ENUM; - if (type == GL_UNSIGNED_SHORT_8_8_MESA || - type == GL_UNSIGNED_SHORT_8_8_REV_MESA) - return GL_NO_ERROR; - else - return GL_INVALID_OPERATION; - - case GL_DEPTH_STENCIL_EXT: - if (ctx->Extensions.EXT_packed_depth_stencil && - type == GL_UNSIGNED_INT_24_8) - return GL_NO_ERROR; - else if (ctx->Extensions.ARB_depth_buffer_float && - type == GL_FLOAT_32_UNSIGNED_INT_24_8_REV) - return GL_NO_ERROR; - else - return GL_INVALID_ENUM; - - case GL_DUDV_ATI: - case GL_DU8DV8_ATI: - if (!ctx->Extensions.ATI_envmap_bumpmap) - return GL_INVALID_ENUM; - switch (type) { - case GL_BYTE: - case GL_UNSIGNED_BYTE: - case GL_SHORT: - case GL_UNSIGNED_SHORT: - case GL_INT: - case GL_UNSIGNED_INT: - case GL_FLOAT: - return GL_NO_ERROR; - default: - return GL_INVALID_ENUM; - } - - /* integer-valued formats */ - case GL_RED_INTEGER_EXT: - case GL_GREEN_INTEGER_EXT: - case GL_BLUE_INTEGER_EXT: - case GL_ALPHA_INTEGER_EXT: - case GL_RG_INTEGER: - switch (type) { - case GL_BYTE: - case GL_UNSIGNED_BYTE: - case GL_SHORT: - case GL_UNSIGNED_SHORT: - case GL_INT: - case GL_UNSIGNED_INT: - return (ctx->VersionMajor >= 3 || - ctx->Extensions.EXT_texture_integer) - ? GL_NO_ERROR : GL_INVALID_ENUM; - default: - return GL_INVALID_ENUM; - } - - case GL_RGB_INTEGER_EXT: - switch (type) { - case GL_BYTE: - case GL_UNSIGNED_BYTE: - case GL_SHORT: - case GL_UNSIGNED_SHORT: - case GL_INT: - case GL_UNSIGNED_INT: - return (ctx->VersionMajor >= 3 || - ctx->Extensions.EXT_texture_integer) - ? GL_NO_ERROR : GL_INVALID_ENUM; - case GL_UNSIGNED_BYTE_3_3_2: - case GL_UNSIGNED_BYTE_2_3_3_REV: - case GL_UNSIGNED_SHORT_5_6_5: - case GL_UNSIGNED_SHORT_5_6_5_REV: - return ctx->Extensions.ARB_texture_rgb10_a2ui - ? GL_NO_ERROR : GL_INVALID_ENUM; - default: - return GL_INVALID_ENUM; - } - - case GL_BGR_INTEGER_EXT: - switch (type) { - case GL_BYTE: - case GL_UNSIGNED_BYTE: - case GL_SHORT: - case GL_UNSIGNED_SHORT: - case GL_INT: - case GL_UNSIGNED_INT: - /* NOTE: no packed formats w/ BGR format */ - return (ctx->VersionMajor >= 3 || - ctx->Extensions.EXT_texture_integer) - ? GL_NO_ERROR : GL_INVALID_ENUM; - default: - return GL_INVALID_ENUM; - } - - case GL_RGBA_INTEGER_EXT: - case GL_BGRA_INTEGER_EXT: - switch (type) { - case GL_BYTE: - case GL_UNSIGNED_BYTE: - case GL_SHORT: - case GL_UNSIGNED_SHORT: - case GL_INT: - case GL_UNSIGNED_INT: - return (ctx->VersionMajor >= 3 || - ctx->Extensions.EXT_texture_integer) - ? GL_NO_ERROR : GL_INVALID_ENUM; - case GL_UNSIGNED_SHORT_4_4_4_4: - case GL_UNSIGNED_SHORT_4_4_4_4_REV: - case GL_UNSIGNED_SHORT_5_5_5_1: - case GL_UNSIGNED_SHORT_1_5_5_5_REV: - case GL_UNSIGNED_INT_8_8_8_8: - case GL_UNSIGNED_INT_8_8_8_8_REV: - case GL_UNSIGNED_INT_10_10_10_2: - case GL_UNSIGNED_INT_2_10_10_10_REV: - return ctx->Extensions.ARB_texture_rgb10_a2ui - ? GL_NO_ERROR : GL_INVALID_ENUM; - default: - return GL_INVALID_ENUM; - } - - case GL_LUMINANCE_INTEGER_EXT: - case GL_LUMINANCE_ALPHA_INTEGER_EXT: - switch (type) { - case GL_BYTE: - case GL_UNSIGNED_BYTE: - case GL_SHORT: - case GL_UNSIGNED_SHORT: - case GL_INT: - case GL_UNSIGNED_INT: - return ctx->Extensions.EXT_texture_integer - ? GL_NO_ERROR : GL_INVALID_ENUM; - default: - return GL_INVALID_ENUM; - } - - default: - return GL_INVALID_ENUM; - } - return GL_NO_ERROR; -} - - -/** - * Test if the given image format is a color/RGBA format (i.e., not color - * index, depth, stencil, etc). - * \param format the image format value (may by an internal texture format) - * \return GL_TRUE if its a color/RGBA format, GL_FALSE otherwise. - */ -GLboolean -_mesa_is_color_format(GLenum format) -{ - switch (format) { - case GL_RED: - case GL_GREEN: - case GL_BLUE: - case GL_ALPHA: - case GL_ALPHA4: - case GL_ALPHA8: - case GL_ALPHA12: - case GL_ALPHA16: - case 1: - case GL_LUMINANCE: - case GL_LUMINANCE4: - case GL_LUMINANCE8: - case GL_LUMINANCE12: - case GL_LUMINANCE16: - case 2: - case GL_LUMINANCE_ALPHA: - case GL_LUMINANCE4_ALPHA4: - case GL_LUMINANCE6_ALPHA2: - case GL_LUMINANCE8_ALPHA8: - case GL_LUMINANCE12_ALPHA4: - case GL_LUMINANCE12_ALPHA12: - case GL_LUMINANCE16_ALPHA16: - case GL_INTENSITY: - case GL_INTENSITY4: - case GL_INTENSITY8: - case GL_INTENSITY12: - case GL_INTENSITY16: - case GL_R8: - case GL_R16: - case GL_RG: - case GL_RG8: - case GL_RG16: - case 3: - case GL_RGB: - case GL_BGR: - case GL_R3_G3_B2: - case GL_RGB4: - case GL_RGB5: - case GL_RGB565: - case GL_RGB8: - case GL_RGB10: - case GL_RGB12: - case GL_RGB16: - case 4: - case GL_ABGR_EXT: - case GL_RGBA: - case GL_BGRA: - case GL_RGBA2: - case GL_RGBA4: - case GL_RGB5_A1: - case GL_RGBA8: - case GL_RGB10_A2: - case GL_RGBA12: - case GL_RGBA16: - /* float texture formats */ - case GL_ALPHA16F_ARB: - case GL_ALPHA32F_ARB: - case GL_LUMINANCE16F_ARB: - case GL_LUMINANCE32F_ARB: - case GL_LUMINANCE_ALPHA16F_ARB: - case GL_LUMINANCE_ALPHA32F_ARB: - case GL_INTENSITY16F_ARB: - case GL_INTENSITY32F_ARB: - case GL_R16F: - case GL_R32F: - case GL_RG16F: - case GL_RG32F: - case GL_RGB16F_ARB: - case GL_RGB32F_ARB: - case GL_RGBA16F_ARB: - case GL_RGBA32F_ARB: - /* compressed formats */ - case GL_COMPRESSED_ALPHA: - case GL_COMPRESSED_LUMINANCE: - case GL_COMPRESSED_LUMINANCE_ALPHA: - case GL_COMPRESSED_INTENSITY: - case GL_COMPRESSED_RED: - case GL_COMPRESSED_RG: - case GL_COMPRESSED_RGB: - case GL_COMPRESSED_RGBA: - case GL_RGB_S3TC: - case GL_RGB4_S3TC: - case GL_RGBA_S3TC: - case GL_RGBA4_S3TC: - case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: - case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: - case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: - case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: - case GL_COMPRESSED_RGB_FXT1_3DFX: - case GL_COMPRESSED_RGBA_FXT1_3DFX: -#if FEATURE_EXT_texture_sRGB - case GL_SRGB_EXT: - case GL_SRGB8_EXT: - case GL_SRGB_ALPHA_EXT: - case GL_SRGB8_ALPHA8_EXT: - case GL_SLUMINANCE_ALPHA_EXT: - case GL_SLUMINANCE8_ALPHA8_EXT: - case GL_SLUMINANCE_EXT: - case GL_SLUMINANCE8_EXT: - case GL_COMPRESSED_SRGB_EXT: - case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT: - case GL_COMPRESSED_SRGB_ALPHA_EXT: - case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: - case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: - case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: - case GL_COMPRESSED_SLUMINANCE_EXT: - case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT: -#endif /* FEATURE_EXT_texture_sRGB */ - case GL_COMPRESSED_RED_RGTC1: - case GL_COMPRESSED_SIGNED_RED_RGTC1: - case GL_COMPRESSED_RG_RGTC2: - case GL_COMPRESSED_SIGNED_RG_RGTC2: - case GL_COMPRESSED_LUMINANCE_LATC1_EXT: - case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT: - case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT: - case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT: - case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI: - case GL_ETC1_RGB8_OES: - /* generic integer formats */ - case GL_RED_INTEGER_EXT: - case GL_GREEN_INTEGER_EXT: - case GL_BLUE_INTEGER_EXT: - case GL_ALPHA_INTEGER_EXT: - case GL_RGB_INTEGER_EXT: - case GL_RGBA_INTEGER_EXT: - case GL_BGR_INTEGER_EXT: - case GL_BGRA_INTEGER_EXT: - case GL_RG_INTEGER: - case GL_LUMINANCE_INTEGER_EXT: - case GL_LUMINANCE_ALPHA_INTEGER_EXT: - /* sized integer formats */ - case GL_RGBA32UI_EXT: - case GL_RGB32UI_EXT: - case GL_RG32UI: - case GL_R32UI: - case GL_ALPHA32UI_EXT: - case GL_INTENSITY32UI_EXT: - case GL_LUMINANCE32UI_EXT: - case GL_LUMINANCE_ALPHA32UI_EXT: - case GL_RGBA16UI_EXT: - case GL_RGB16UI_EXT: - case GL_RG16UI: - case GL_R16UI: - case GL_ALPHA16UI_EXT: - case GL_INTENSITY16UI_EXT: - case GL_LUMINANCE16UI_EXT: - case GL_LUMINANCE_ALPHA16UI_EXT: - case GL_RGBA8UI_EXT: - case GL_RGB8UI_EXT: - case GL_RG8UI: - case GL_R8UI: - case GL_ALPHA8UI_EXT: - case GL_INTENSITY8UI_EXT: - case GL_LUMINANCE8UI_EXT: - case GL_LUMINANCE_ALPHA8UI_EXT: - case GL_RGBA32I_EXT: - case GL_RGB32I_EXT: - case GL_RG32I: - case GL_R32I: - case GL_ALPHA32I_EXT: - case GL_INTENSITY32I_EXT: - case GL_LUMINANCE32I_EXT: - case GL_LUMINANCE_ALPHA32I_EXT: - case GL_RGBA16I_EXT: - case GL_RGB16I_EXT: - case GL_RG16I: - case GL_R16I: - case GL_ALPHA16I_EXT: - case GL_INTENSITY16I_EXT: - case GL_LUMINANCE16I_EXT: - case GL_LUMINANCE_ALPHA16I_EXT: - case GL_RGBA8I_EXT: - case GL_RGB8I_EXT: - case GL_RG8I: - case GL_R8I: - case GL_ALPHA8I_EXT: - case GL_INTENSITY8I_EXT: - case GL_LUMINANCE8I_EXT: - case GL_LUMINANCE_ALPHA8I_EXT: - /* signed, normalized texture formats */ - case GL_RED_SNORM: - case GL_R8_SNORM: - case GL_R16_SNORM: - case GL_RG_SNORM: - case GL_RG8_SNORM: - case GL_RG16_SNORM: - case GL_RGB_SNORM: - case GL_RGB8_SNORM: - case GL_RGB16_SNORM: - case GL_RGBA_SNORM: - case GL_RGBA8_SNORM: - case GL_RGBA16_SNORM: - case GL_ALPHA_SNORM: - case GL_ALPHA8_SNORM: - case GL_ALPHA16_SNORM: - case GL_LUMINANCE_SNORM: - case GL_LUMINANCE8_SNORM: - case GL_LUMINANCE16_SNORM: - case GL_LUMINANCE_ALPHA_SNORM: - case GL_LUMINANCE8_ALPHA8_SNORM: - case GL_LUMINANCE16_ALPHA16_SNORM: - case GL_INTENSITY_SNORM: - case GL_INTENSITY8_SNORM: - case GL_INTENSITY16_SNORM: - case GL_RGB9_E5: - case GL_R11F_G11F_B10F: - case GL_RGB10_A2UI: - return GL_TRUE; - case GL_YCBCR_MESA: /* not considered to be RGB */ - /* fall-through */ - default: - return GL_FALSE; - } -} - - -/** - * Test if the given image format is a depth component format. - */ -GLboolean -_mesa_is_depth_format(GLenum format) -{ - switch (format) { - case GL_DEPTH_COMPONENT: - case GL_DEPTH_COMPONENT16: - case GL_DEPTH_COMPONENT24: - case GL_DEPTH_COMPONENT32: - case GL_DEPTH_COMPONENT32F: - return GL_TRUE; - default: - return GL_FALSE; - } -} - - -/** - * Test if the given image format is a stencil format. - */ -GLboolean -_mesa_is_stencil_format(GLenum format) -{ - switch (format) { - case GL_STENCIL_INDEX: - return GL_TRUE; - default: - return GL_FALSE; - } -} - - -/** - * Test if the given image format is a YCbCr format. - */ -GLboolean -_mesa_is_ycbcr_format(GLenum format) -{ - switch (format) { - case GL_YCBCR_MESA: - return GL_TRUE; - default: - return GL_FALSE; - } -} - - -/** - * Test if the given image format is a depth+stencil format. - */ -GLboolean -_mesa_is_depthstencil_format(GLenum format) -{ - switch (format) { - case GL_DEPTH24_STENCIL8_EXT: - case GL_DEPTH_STENCIL_EXT: - case GL_DEPTH32F_STENCIL8: - return GL_TRUE; - default: - return GL_FALSE; - } -} - - -/** - * Test if the given image format is a depth or stencil format. - */ -GLboolean -_mesa_is_depth_or_stencil_format(GLenum format) -{ - switch (format) { - case GL_DEPTH_COMPONENT: - case GL_DEPTH_COMPONENT16: - case GL_DEPTH_COMPONENT24: - case GL_DEPTH_COMPONENT32: - case GL_STENCIL_INDEX: - case GL_STENCIL_INDEX1_EXT: - case GL_STENCIL_INDEX4_EXT: - case GL_STENCIL_INDEX8_EXT: - case GL_STENCIL_INDEX16_EXT: - case GL_DEPTH_STENCIL_EXT: - case GL_DEPTH24_STENCIL8_EXT: - case GL_DEPTH_COMPONENT32F: - case GL_DEPTH32F_STENCIL8: - return GL_TRUE; - default: - return GL_FALSE; - } -} - - -/** - * Test if the given image format is a dudv format. - */ -GLboolean -_mesa_is_dudv_format(GLenum format) -{ - switch (format) { - case GL_DUDV_ATI: - case GL_DU8DV8_ATI: - return GL_TRUE; - default: - return GL_FALSE; - } -} - - -/** - * Test if the given format is an integer (non-normalized) format. - */ -GLboolean -_mesa_is_integer_format(GLenum format) -{ - switch (format) { - /* generic integer formats */ - case GL_RED_INTEGER_EXT: - case GL_GREEN_INTEGER_EXT: - case GL_BLUE_INTEGER_EXT: - case GL_ALPHA_INTEGER_EXT: - case GL_RGB_INTEGER_EXT: - case GL_RGBA_INTEGER_EXT: - case GL_BGR_INTEGER_EXT: - case GL_BGRA_INTEGER_EXT: - case GL_LUMINANCE_INTEGER_EXT: - case GL_LUMINANCE_ALPHA_INTEGER_EXT: - case GL_RG_INTEGER: - /* specific integer formats */ - case GL_RGBA32UI_EXT: - case GL_RGB32UI_EXT: - case GL_RG32UI: - case GL_R32UI: - case GL_ALPHA32UI_EXT: - case GL_INTENSITY32UI_EXT: - case GL_LUMINANCE32UI_EXT: - case GL_LUMINANCE_ALPHA32UI_EXT: - case GL_RGBA16UI_EXT: - case GL_RGB16UI_EXT: - case GL_RG16UI: - case GL_R16UI: - case GL_ALPHA16UI_EXT: - case GL_INTENSITY16UI_EXT: - case GL_LUMINANCE16UI_EXT: - case GL_LUMINANCE_ALPHA16UI_EXT: - case GL_RGBA8UI_EXT: - case GL_RGB8UI_EXT: - case GL_RG8UI: - case GL_R8UI: - case GL_ALPHA8UI_EXT: - case GL_INTENSITY8UI_EXT: - case GL_LUMINANCE8UI_EXT: - case GL_LUMINANCE_ALPHA8UI_EXT: - case GL_RGBA32I_EXT: - case GL_RGB32I_EXT: - case GL_RG32I: - case GL_R32I: - case GL_ALPHA32I_EXT: - case GL_INTENSITY32I_EXT: - case GL_LUMINANCE32I_EXT: - case GL_LUMINANCE_ALPHA32I_EXT: - case GL_RGBA16I_EXT: - case GL_RGB16I_EXT: - case GL_RG16I: - case GL_R16I: - case GL_ALPHA16I_EXT: - case GL_INTENSITY16I_EXT: - case GL_LUMINANCE16I_EXT: - case GL_LUMINANCE_ALPHA16I_EXT: - case GL_RGBA8I_EXT: - case GL_RGB8I_EXT: - case GL_RG8I: - case GL_R8I: - case GL_ALPHA8I_EXT: - case GL_INTENSITY8I_EXT: - case GL_LUMINANCE8I_EXT: - case GL_LUMINANCE_ALPHA8I_EXT: - case GL_RGB10_A2UI: - return GL_TRUE; - default: - return GL_FALSE; - } -} - - -/** - * Test if an image format is a supported compressed format. - * \param format the internal format token provided by the user. - * \return GL_TRUE if compressed, GL_FALSE if uncompressed - */ -GLboolean -_mesa_is_compressed_format(struct gl_context *ctx, GLenum format) -{ - switch (format) { - case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: - case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: - case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: - case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: - return ctx->Extensions.EXT_texture_compression_s3tc; - case GL_RGB_S3TC: - case GL_RGB4_S3TC: - case GL_RGBA_S3TC: - case GL_RGBA4_S3TC: - return ctx->Extensions.S3_s3tc; - case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT: - case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: - case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: - case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: - return ctx->Extensions.EXT_texture_sRGB - && ctx->Extensions.EXT_texture_compression_s3tc; - case GL_COMPRESSED_RGB_FXT1_3DFX: - case GL_COMPRESSED_RGBA_FXT1_3DFX: - return ctx->Extensions.TDFX_texture_compression_FXT1; - case GL_COMPRESSED_RED_RGTC1: - case GL_COMPRESSED_SIGNED_RED_RGTC1: - case GL_COMPRESSED_RG_RGTC2: - case GL_COMPRESSED_SIGNED_RG_RGTC2: - return ctx->Extensions.ARB_texture_compression_rgtc; - case GL_COMPRESSED_LUMINANCE_LATC1_EXT: - case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT: - case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT: - case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT: - return ctx->Extensions.EXT_texture_compression_latc; - case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI: - return ctx->Extensions.ATI_texture_compression_3dc; - case GL_ETC1_RGB8_OES: - return ctx->Extensions.OES_compressed_ETC1_RGB8_texture; -#if FEATURE_ES - case GL_PALETTE4_RGB8_OES: - case GL_PALETTE4_RGBA8_OES: - case GL_PALETTE4_R5_G6_B5_OES: - case GL_PALETTE4_RGBA4_OES: - case GL_PALETTE4_RGB5_A1_OES: - case GL_PALETTE8_RGB8_OES: - case GL_PALETTE8_RGBA8_OES: - case GL_PALETTE8_R5_G6_B5_OES: - case GL_PALETTE8_RGBA4_OES: - case GL_PALETTE8_RGB5_A1_OES: - return ctx->API == API_OPENGLES; -#endif - default: - return GL_FALSE; - } -} - - -/** - * Does the given base texture/renderbuffer format have the channel - * named by 'pname'? - */ -GLboolean -_mesa_base_format_has_channel(GLenum base_format, GLenum pname) -{ - switch (pname) { - case GL_TEXTURE_RED_SIZE: - case GL_TEXTURE_RED_TYPE: - case GL_RENDERBUFFER_RED_SIZE_EXT: - case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE: - if (base_format == GL_RED || - base_format == GL_RG || - base_format == GL_RGB || - base_format == GL_RGBA) { - return GL_TRUE; - } - return GL_FALSE; - case GL_TEXTURE_GREEN_SIZE: - case GL_TEXTURE_GREEN_TYPE: - case GL_RENDERBUFFER_GREEN_SIZE_EXT: - case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: - if (base_format == GL_RG || - base_format == GL_RGB || - base_format == GL_RGBA) { - return GL_TRUE; - } - return GL_FALSE; - case GL_TEXTURE_BLUE_SIZE: - case GL_TEXTURE_BLUE_TYPE: - case GL_RENDERBUFFER_BLUE_SIZE_EXT: - case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: - if (base_format == GL_RGB || - base_format == GL_RGBA) { - return GL_TRUE; - } - return GL_FALSE; - case GL_TEXTURE_ALPHA_SIZE: - case GL_TEXTURE_ALPHA_TYPE: - case GL_RENDERBUFFER_ALPHA_SIZE_EXT: - case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: - if (base_format == GL_RGBA || - base_format == GL_ALPHA || - base_format == GL_LUMINANCE_ALPHA) { - return GL_TRUE; - } - return GL_FALSE; - case GL_TEXTURE_LUMINANCE_SIZE: - case GL_TEXTURE_LUMINANCE_TYPE: - if (base_format == GL_LUMINANCE || - base_format == GL_LUMINANCE_ALPHA) { - return GL_TRUE; - } - return GL_FALSE; - case GL_TEXTURE_INTENSITY_SIZE: - case GL_TEXTURE_INTENSITY_TYPE: - if (base_format == GL_INTENSITY) { - return GL_TRUE; - } - return GL_FALSE; - case GL_TEXTURE_DEPTH_SIZE: - case GL_TEXTURE_DEPTH_TYPE: - case GL_RENDERBUFFER_DEPTH_SIZE_EXT: - case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: - if (base_format == GL_DEPTH_STENCIL || - base_format == GL_DEPTH_COMPONENT) { - return GL_TRUE; - } - return GL_FALSE; - case GL_RENDERBUFFER_STENCIL_SIZE_EXT: - case GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: - if (base_format == GL_DEPTH_STENCIL || - base_format == GL_STENCIL_INDEX) { - return GL_TRUE; - } - return GL_FALSE; - default: - _mesa_warning(NULL, "%s: Unexpected channel token 0x%x\n", - __FUNCTION__, pname); - return GL_FALSE; - } - - return GL_FALSE; -} - - -/** * Return the byte offset of a specific pixel in an image (1D, 2D or 3D). * * Pixel unpacking/packing parameters are observed according to \p packing. diff --git a/mesalib/src/mesa/main/image.h b/mesalib/src/mesa/main/image.h index f1ed88379..7e92790b7 100644 --- a/mesalib/src/mesa/main/image.h +++ b/mesalib/src/mesa/main/image.h @@ -38,55 +38,6 @@ _mesa_swap2( GLushort *p, GLuint n ); extern void _mesa_swap4( GLuint *p, GLuint n ); -extern GLboolean -_mesa_type_is_packed(GLenum type); - -extern GLint -_mesa_sizeof_type( GLenum type ); - -extern GLint -_mesa_sizeof_packed_type( GLenum type ); - -extern GLint -_mesa_components_in_format( GLenum format ); - -extern GLint -_mesa_bytes_per_pixel( GLenum format, GLenum type ); - -extern GLenum -_mesa_error_check_format_and_type(const struct gl_context *ctx, - GLenum format, GLenum type); - -extern GLboolean -_mesa_is_color_format(GLenum format); - -extern GLboolean -_mesa_is_depth_format(GLenum format); - -extern GLboolean -_mesa_is_stencil_format(GLenum format); - -extern GLboolean -_mesa_is_ycbcr_format(GLenum format); - -extern GLboolean -_mesa_is_depthstencil_format(GLenum format); - -extern GLboolean -_mesa_is_depth_or_stencil_format(GLenum format); - -extern GLboolean -_mesa_is_dudv_format(GLenum format); - -extern GLboolean -_mesa_is_integer_format(GLenum format); - -extern GLboolean -_mesa_is_compressed_format(struct gl_context *ctx, GLenum format); - -extern GLboolean -_mesa_base_format_has_channel(GLenum base_format, GLenum pname); - extern GLintptr _mesa_image_offset( GLuint dimensions, const struct gl_pixelstore_attrib *packing, diff --git a/mesalib/src/mesa/main/imports.c b/mesalib/src/mesa/main/imports.c index 2d592a68e..0d6b56a51 100644 --- a/mesalib/src/mesa/main/imports.c +++ b/mesalib/src/mesa/main/imports.c @@ -223,19 +223,6 @@ _mesa_realloc(void *oldBuffer, size_t oldSize, size_t newSize) return newBuffer; } -/** - * Fill memory with a constant 16bit word. - * \param dst destination pointer. - * \param val value. - * \param n number of words. - */ -void -_mesa_memset16( unsigned short *dst, unsigned short val, size_t n ) -{ - while (n-- > 0) - *dst++ = val; -} - /*@}*/ @@ -243,213 +230,6 @@ _mesa_memset16( unsigned short *dst, unsigned short val, size_t n ) /** \name Math */ /*@{*/ -/** Wrapper around sqrt() */ -double -_mesa_sqrtd(double x) -{ - return sqrt(x); -} - - -/* - * A High Speed, Low Precision Square Root - * by Paul Lalonde and Robert Dawson - * from "Graphics Gems", Academic Press, 1990 - * - * SPARC implementation of a fast square root by table - * lookup. - * SPARC floating point format is as follows: - * - * BIT 31 30 23 22 0 - * sign exponent mantissa - */ -static short sqrttab[0x100]; /* declare table of square roots */ - -void -_mesa_init_sqrt_table(void) -{ -#if defined(USE_IEEE) && !defined(DEBUG) - unsigned short i; - fi_type fi; /* to access the bits of a float in C quickly */ - /* we use a union defined in glheader.h */ - - for(i=0; i<= 0x7f; i++) { - fi.i = 0; - - /* - * Build a float with the bit pattern i as mantissa - * and an exponent of 0, stored as 127 - */ - - fi.i = (i << 16) | (127 << 23); - fi.f = _mesa_sqrtd(fi.f); - - /* - * Take the square root then strip the first 7 bits of - * the mantissa into the table - */ - - sqrttab[i] = (fi.i & 0x7fffff) >> 16; - - /* - * Repeat the process, this time with an exponent of - * 1, stored as 128 - */ - - fi.i = 0; - fi.i = (i << 16) | (128 << 23); - fi.f = sqrt(fi.f); - sqrttab[i+0x80] = (fi.i & 0x7fffff) >> 16; - } -#else - (void) sqrttab; /* silence compiler warnings */ -#endif /*HAVE_FAST_MATH*/ -} - - -/** - * Single precision square root. - */ -float -_mesa_sqrtf( float x ) -{ -#if defined(USE_IEEE) && !defined(DEBUG) - fi_type num; - /* to access the bits of a float in C - * we use a union from glheader.h */ - - short e; /* the exponent */ - if (x == 0.0F) return 0.0F; /* check for square root of 0 */ - num.f = x; - e = (num.i >> 23) - 127; /* get the exponent - on a SPARC the */ - /* exponent is stored with 127 added */ - num.i &= 0x7fffff; /* leave only the mantissa */ - if (e & 0x01) num.i |= 0x800000; - /* the exponent is odd so we have to */ - /* look it up in the second half of */ - /* the lookup table, so we set the */ - /* high bit */ - e >>= 1; /* divide the exponent by two */ - /* note that in C the shift */ - /* operators are sign preserving */ - /* for signed operands */ - /* Do the table lookup, based on the quaternary mantissa, - * then reconstruct the result back into a float - */ - num.i = ((sqrttab[num.i >> 16]) << 16) | ((e + 127) << 23); - - return num.f; -#else - return (float) _mesa_sqrtd((double) x); -#endif -} - - -/** - inv_sqrt - A single precision 1/sqrt routine for IEEE format floats. - written by Josh Vanderhoof, based on newsgroup posts by James Van Buskirk - and Vesa Karvonen. -*/ -float -_mesa_inv_sqrtf(float n) -{ -#if defined(USE_IEEE) && !defined(DEBUG) - float r0, x0, y0; - float r1, x1, y1; - float r2, x2, y2; -#if 0 /* not used, see below -BP */ - float r3, x3, y3; -#endif - fi_type u; - unsigned int magic; - - /* - Exponent part of the magic number - - - We want to: - 1. subtract the bias from the exponent, - 2. negate it - 3. divide by two (rounding towards -inf) - 4. add the bias back - - Which is the same as subtracting the exponent from 381 and dividing - by 2. - - floor(-(x - 127) / 2) + 127 = floor((381 - x) / 2) - */ - - magic = 381 << 23; - - /* - Significand part of magic number - - - With the current magic number, "(magic - u.i) >> 1" will give you: - - for 1 <= u.f <= 2: 1.25 - u.f / 4 - for 2 <= u.f <= 4: 1.00 - u.f / 8 - - This isn't a bad approximation of 1/sqrt. The maximum difference from - 1/sqrt will be around .06. After three Newton-Raphson iterations, the - maximum difference is less than 4.5e-8. (Which is actually close - enough to make the following bias academic...) - - To get a better approximation you can add a bias to the magic - number. For example, if you subtract 1/2 of the maximum difference in - the first approximation (.03), you will get the following function: - - for 1 <= u.f <= 2: 1.22 - u.f / 4 - for 2 <= u.f <= 3.76: 0.97 - u.f / 8 - for 3.76 <= u.f <= 4: 0.72 - u.f / 16 - (The 3.76 to 4 range is where the result is < .5.) - - This is the closest possible initial approximation, but with a maximum - error of 8e-11 after three NR iterations, it is still not perfect. If - you subtract 0.0332281 instead of .03, the maximum error will be - 2.5e-11 after three NR iterations, which should be about as close as - is possible. - - for 1 <= u.f <= 2: 1.2167719 - u.f / 4 - for 2 <= u.f <= 3.73: 0.9667719 - u.f / 8 - for 3.73 <= u.f <= 4: 0.7167719 - u.f / 16 - - */ - - magic -= (int)(0.0332281 * (1 << 25)); - - u.f = n; - u.i = (magic - u.i) >> 1; - - /* - Instead of Newton-Raphson, we use Goldschmidt's algorithm, which - allows more parallelism. From what I understand, the parallelism - comes at the cost of less precision, because it lets error - accumulate across iterations. - */ - x0 = 1.0f; - y0 = 0.5f * n; - r0 = u.f; - - x1 = x0 * r0; - y1 = y0 * r0 * r0; - r1 = 1.5f - y1; - - x2 = x1 * r1; - y2 = y1 * r1 * r1; - r2 = 1.5f - y2; - -#if 1 - return x2 * r2; /* we can stop here, and be conformant -BP */ -#else - x3 = x2 * r2; - y3 = y2 * r2 * r2; - r3 = 1.5f - y3; - - return x3 * r3; -#endif -#else - return (float) (1.0 / sqrt(n)); -#endif -} #ifndef __GNUC__ /** @@ -762,7 +542,7 @@ float _mesa_strtof( const char *s, char **end ) { #if defined(_GNU_SOURCE) && !defined(__CYGWIN__) && !defined(__FreeBSD__) && \ - !defined(ANDROID) && !defined(__HAIKU__) + !defined(ANDROID) && !defined(__HAIKU__) && !defined(__UCLIBC__) static locale_t loc = NULL; if (!loc) { loc = newlocale(LC_CTYPE_MASK, "C", NULL); diff --git a/mesalib/src/mesa/main/imports.h b/mesalib/src/mesa/main/imports.h index c0b6cecea..73913b5ab 100644 --- a/mesalib/src/mesa/main/imports.h +++ b/mesalib/src/mesa/main/imports.h @@ -99,21 +99,13 @@ typedef union { GLfloat f; GLint i; } fi_type; /*** *** SQRTF: single-precision square root ***/ -#if 0 /* _mesa_sqrtf() not accurate enough - temporarily disabled */ -# define SQRTF(X) _mesa_sqrtf(X) -#else -# define SQRTF(X) (float) sqrt((float) (X)) -#endif +#define SQRTF(X) (float) sqrt((float) (X)) /*** *** INV_SQRTF: single-precision inverse square root ***/ -#if 0 -#define INV_SQRTF(X) _mesa_inv_sqrt(X) -#else -#define INV_SQRTF(X) (1.0F / SQRTF(X)) /* this is faster on a P4 */ -#endif +#define INV_SQRTF(X) (1.0F / SQRTF(X)) /** @@ -127,7 +119,7 @@ typedef union { GLfloat f; GLint i; } fi_type; #define asinf(f) ((float) asin(f)) #define atan2f(x,y) ((float) atan2(x,y)) #define atanf(f) ((float) atan(f)) -#define cielf(f) ((float) ciel(f)) +#define ceilf(f) ((float) ceil(f)) #define cosf(f) ((float) cos(f)) #define coshf(f) ((float) cosh(f)) #define expf(f) ((float) exp(f)) @@ -566,21 +558,6 @@ _mesa_exec_free( void *addr ); extern void * _mesa_realloc( void *oldBuffer, size_t oldSize, size_t newSize ); -extern void -_mesa_memset16( unsigned short *dst, unsigned short val, size_t n ); - -extern double -_mesa_sqrtd(double x); - -extern float -_mesa_sqrtf(float x); - -extern float -_mesa_inv_sqrtf(float x); - -extern void -_mesa_init_sqrt_table(void); - #ifndef FFS_DEFINED #define FFS_DEFINED 1 diff --git a/mesalib/src/mesa/main/matrix.c b/mesalib/src/mesa/main/matrix.c index f479a22b0..b09fa4d3d 100644 --- a/mesalib/src/mesa/main/matrix.c +++ b/mesalib/src/mesa/main/matrix.c @@ -658,8 +658,7 @@ void _mesa_update_modelview_project( struct gl_context *ctx, GLuint new_state ) * \param dirtyFlag dirty flag. * * Allocates an array of \p maxDepth elements for the matrix stack and calls - * _math_matrix_ctr() and _math_matrix_alloc_inv() for each element to - * initialize it. + * _math_matrix_ctr() for each element to initialize it. */ static void init_matrix_stack( struct gl_matrix_stack *stack, @@ -674,7 +673,6 @@ init_matrix_stack( struct gl_matrix_stack *stack, stack->Stack = (GLmatrix *) CALLOC(maxDepth * sizeof(GLmatrix)); for (i = 0; i < maxDepth; i++) { _math_matrix_ctr(&stack->Stack[i]); - _math_matrix_alloc_inv(&stack->Stack[i]); } stack->Top = stack->Stack; } diff --git a/mesalib/src/mesa/main/mipmap.c b/mesalib/src/mesa/main/mipmap.c index 250d3c6dc..9f531ae20 100644 --- a/mesalib/src/mesa/main/mipmap.c +++ b/mesalib/src/mesa/main/mipmap.c @@ -29,6 +29,7 @@ #include "imports.h" #include "formats.h" +#include "glformats.h" #include "mipmap.h" #include "mtypes.h" #include "teximage.h" diff --git a/mesalib/src/mesa/main/mtypes.h b/mesalib/src/mesa/main/mtypes.h index 1f74e6a83..7d7213f4d 100644 --- a/mesalib/src/mesa/main/mtypes.h +++ b/mesalib/src/mesa/main/mtypes.h @@ -2011,6 +2011,7 @@ struct gl_fragment_program { struct gl_program Base; /**< base class */ GLboolean UsesKill; /**< shader uses KIL instruction */ + GLboolean UsesDFdy; /**< shader uses DDY instruction */ GLboolean OriginUpperLeft; GLboolean PixelCenterInteger; enum gl_frag_depth_layout FragDepthLayout; @@ -2215,6 +2216,15 @@ struct gl_shader */ unsigned num_uniform_components; + /** + * This shader's uniform block information. + * + * The offsets of the variables are assigned only for shaders in a program's + * _LinkedShaders[]. + */ + struct gl_uniform_block *UniformBlocks; + unsigned NumUniformBlocks; + struct exec_list *ir; struct glsl_symbol_table *symbols; @@ -2236,6 +2246,37 @@ typedef enum MESA_SHADER_TYPES = 3 } gl_shader_type; +struct gl_uniform_buffer_variable +{ + char *Name; + const struct glsl_type *Type; + unsigned int Buffer; + unsigned int Offset; + GLboolean RowMajor; +}; + +struct gl_uniform_block +{ + /** Declared name of the uniform block */ + char *Name; + + /** Array of supplemental information about UBO ir_variables. */ + struct gl_uniform_buffer_variable *Uniforms; + GLuint NumUniforms; + + /** + * Index (GL_UNIFORM_BLOCK_BINDING) into ctx->UniformBufferBindings[] to use + * with glBindBufferBase to bind a buffer object to this uniform block. When + * updated in the program, _NEW_BUFFER_OBJECT will be set. + */ + GLuint Binding; + + /** + * Minimum size of a buffer object to back this uniform buffer + * (GL_UNIFORM_BLOCK_DATA_SIZE). + */ + GLuint UniformBufferSize; +}; /** * A GLSL program object. @@ -2319,6 +2360,18 @@ struct gl_shader_program unsigned NumUserUniformStorage; struct gl_uniform_storage *UniformStorage; + struct gl_uniform_block *UniformBlocks; + unsigned NumUniformBlocks; + + /** + * Indices into the _LinkedShaders's UniformBlocks[] array for each stage + * they're used in, or -1. + * + * This is used to maintain the Binding values of the stage's UniformBlocks[] + * and to answer the GL_UNIFORM_BLOCK_REFERENCED_BY_*_SHADER queries. + */ + int *UniformBlockStageIndex[MESA_SHADER_TYPES]; + /** * Map of active uniform names to locations * @@ -3281,9 +3334,10 @@ struct gl_debug_state */ typedef enum { - API_OPENGL, + API_OPENGL, /* legacy / compatibility contexts */ API_OPENGLES, - API_OPENGLES2 + API_OPENGLES2, + API_OPENGL_CORE, } gl_api; /** diff --git a/mesalib/src/mesa/main/nvprogram.c b/mesalib/src/mesa/main/nvprogram.c index dae11566e..fc5749afc 100644 --- a/mesalib/src/mesa/main/nvprogram.c +++ b/mesalib/src/mesa/main/nvprogram.c @@ -71,7 +71,7 @@ _mesa_ExecuteProgramNV(GLenum target, GLuint id, const GLfloat *params) FLUSH_VERTICES(ctx, _NEW_PROGRAM); - vprog = (struct gl_vertex_program *) _mesa_lookup_program(ctx, id); + vprog = gl_vertex_program(_mesa_lookup_program(ctx, id)); if (!vprog || vprog->Base.Target != GL_VERTEX_STATE_PROGRAM_NV) { _mesa_error(ctx, GL_INVALID_OPERATION, "glExecuteProgramNV"); @@ -627,10 +627,9 @@ _mesa_LoadProgramNV(GLenum target, GLuint id, GLsizei len, if ((target == GL_VERTEX_PROGRAM_NV || target == GL_VERTEX_STATE_PROGRAM_NV) && ctx->Extensions.NV_vertex_program) { - struct gl_vertex_program *vprog = (struct gl_vertex_program *) prog; + struct gl_vertex_program *vprog = gl_vertex_program(prog); if (!vprog || prog == &_mesa_DummyProgram) { - vprog = (struct gl_vertex_program *) - ctx->Driver.NewProgram(ctx, target, id); + vprog = gl_vertex_program(ctx->Driver.NewProgram(ctx, target, id)); if (!vprog) { _mesa_error(ctx, GL_OUT_OF_MEMORY, "glLoadProgramNV"); return; @@ -647,10 +646,9 @@ _mesa_LoadProgramNV(GLenum target, GLuint id, GLsizei len, } else if (target == GL_FRAGMENT_PROGRAM_NV && ctx->Extensions.NV_fragment_program) { - struct gl_fragment_program *fprog = (struct gl_fragment_program *) prog; + struct gl_fragment_program *fprog = gl_fragment_program(prog); if (!fprog || prog == &_mesa_DummyProgram) { - fprog = (struct gl_fragment_program *) - ctx->Driver.NewProgram(ctx, target, id); + fprog = gl_fragment_program(ctx->Driver.NewProgram(ctx, target, id)); if (!fprog) { _mesa_error(ctx, GL_OUT_OF_MEMORY, "glLoadProgramNV"); return; @@ -661,10 +659,9 @@ _mesa_LoadProgramNV(GLenum target, GLuint id, GLsizei len, } else if (target == GL_FRAGMENT_PROGRAM_ARB && ctx->Extensions.ARB_fragment_program) { - struct gl_fragment_program *fprog = (struct gl_fragment_program *) prog; + struct gl_fragment_program *fprog = gl_fragment_program(prog); if (!fprog || prog == &_mesa_DummyProgram) { - fprog = (struct gl_fragment_program *) - ctx->Driver.NewProgram(ctx, target, id); + fprog = gl_fragment_program(ctx->Driver.NewProgram(ctx, target, id)); if (!fprog) { _mesa_error(ctx, GL_OUT_OF_MEMORY, "glLoadProgramNV"); return; @@ -830,7 +827,7 @@ _mesa_ProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte *name, return; } - fragProg = (struct gl_fragment_program *) prog; + fragProg = gl_fragment_program(prog); v = _mesa_lookup_parameter_value(fragProg->Base.Parameters, len, (char *) name); if (v) { @@ -895,7 +892,7 @@ _mesa_GetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLubyte *name, return; } - fragProg = (struct gl_fragment_program *) prog; + fragProg = gl_fragment_program(prog); v = _mesa_lookup_parameter_value(fragProg->Base.Parameters, len, (char *) name); if (v) { diff --git a/mesalib/src/mesa/main/pack.c b/mesalib/src/mesa/main/pack.c index c25a02e85..83192c157 100644 --- a/mesalib/src/mesa/main/pack.c +++ b/mesalib/src/mesa/main/pack.c @@ -29,6 +29,19 @@ */ +/* + * XXX: MSVC takes forever to compile this module for x86_64 unless we disable + * this global optimization. + * + * See also: + * - http://msdn.microsoft.com/en-us/library/1yk3ydd7.aspx + * - http://msdn.microsoft.com/en-us/library/chh3fb0k.aspx + */ +#if defined(_MSC_VER) && defined(_M_X64) +# pragma optimize( "g", off ) +#endif + + #include "glheader.h" #include "colormac.h" #include "enums.h" @@ -39,6 +52,7 @@ #include "pack.h" #include "pixeltransfer.h" #include "imports.h" +#include "glformats.h" #include "../../gallium/auxiliary/util/u_format_rgb9e5.h" #include "../../gallium/auxiliary/util/u_format_r11g11b10f.h" @@ -500,26 +514,29 @@ _mesa_pack_rgba_span_int(struct gl_context *ctx, GLuint n, GLuint rgba[][4], { switch(dstType) { case GL_UNSIGNED_INT: - pack_uint_from_uint_rgba(dstAddr, dstFormat, rgba, n); + pack_uint_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, n); break; case GL_INT: /* No conversion necessary. */ - pack_uint_from_uint_rgba(dstAddr, dstFormat, rgba, n); + pack_uint_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, n); break; case GL_UNSIGNED_SHORT: - pack_ushort_from_uint_rgba(dstAddr, dstFormat, rgba, n); + pack_ushort_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, n); break; case GL_SHORT: - pack_short_from_uint_rgba(dstAddr, dstFormat, rgba, n); + pack_short_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, n); break; case GL_UNSIGNED_BYTE: - pack_ubyte_from_uint_rgba(dstAddr, dstFormat, rgba, n); + pack_ubyte_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, n); break; case GL_BYTE: - pack_byte_from_uint_rgba(dstAddr, dstFormat, rgba, n); + pack_byte_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, n); break; default: - assert(0); + _mesa_problem(ctx, + "Unsupported type (%s) for format (%s)", + _mesa_lookup_enum_by_nr(dstType), + _mesa_lookup_enum_by_nr(dstFormat)); return; } } @@ -545,7 +562,7 @@ _mesa_pack_rgba_span_float(struct gl_context *ctx, GLuint n, GLfloat rgba[][4], { GLfloat *luminance; const GLint comps = _mesa_components_in_format(dstFormat); - const GLboolean intDstFormat = _mesa_is_integer_format(dstFormat); + const GLboolean intDstFormat = _mesa_is_enum_format_integer(dstFormat); GLuint i; if (dstFormat == GL_LUMINANCE || @@ -2476,7 +2493,7 @@ extract_float_rgba(GLuint n, GLfloat rgba[][4], stride = _mesa_components_in_format(srcFormat); - intFormat = _mesa_is_integer_format(srcFormat); + intFormat = _mesa_is_enum_format_integer(srcFormat); #define PROCESS(SRC_INDEX, DST_INDEX, DEFAULT_FLT, DEFAULT_INT, TYPE, CONVERSION) \ if ((SRC_INDEX) < 0) { \ @@ -3531,7 +3548,7 @@ _mesa_unpack_color_span_ubyte(struct gl_context *ctx, const struct gl_pixelstore_attrib *srcPacking, GLbitfield transferOps ) { - GLboolean intFormat = _mesa_is_integer_format(srcFormat); + GLboolean intFormat = _mesa_is_enum_format_integer(srcFormat); ASSERT(dstFormat == GL_ALPHA || dstFormat == GL_LUMINANCE || dstFormat == GL_LUMINANCE_ALPHA || @@ -3838,7 +3855,7 @@ _mesa_unpack_color_span_float( struct gl_context *ctx, GLint dstComponents; GLint rDst, gDst, bDst, aDst, lDst, iDst; GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat)); - GLboolean intFormat = _mesa_is_integer_format(srcFormat); + GLboolean intFormat = _mesa_is_enum_format_integer(srcFormat); if (!rgba) { _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking"); diff --git a/mesalib/src/mesa/main/pack_tmp.h b/mesalib/src/mesa/main/pack_tmp.h index 83b655729..0d4eb387d 100644 --- a/mesalib/src/mesa/main/pack_tmp.h +++ b/mesalib/src/mesa/main/pack_tmp.h @@ -22,7 +22,8 @@ */ static void -FN_NAME(DST_TYPE *dst, +FN_NAME(struct gl_context *ctx, + DST_TYPE *dst, GLenum dstFormat, SRC_TYPE rgba[][4], int n) @@ -111,5 +112,11 @@ FN_NAME(DST_TYPE *dst, dst[i*2+1] = SRC_CONVERT(rgba[i][ACOMP]); } break; + + default: + _mesa_problem(ctx, + "Unsupported format (%s)", + _mesa_lookup_enum_by_nr(dstFormat)); + break; } } diff --git a/mesalib/src/mesa/main/pbo.c b/mesalib/src/mesa/main/pbo.c index d8fa9191d..c73d7492f 100644 --- a/mesalib/src/mesa/main/pbo.c +++ b/mesalib/src/mesa/main/pbo.c @@ -32,6 +32,7 @@ #include "glheader.h" #include "bufferobj.h" +#include "glformats.h" #include "image.h" #include "imports.h" #include "mtypes.h" @@ -172,11 +173,12 @@ _mesa_map_pbo_source(struct gl_context *ctx, */ const GLvoid * _mesa_map_validate_pbo_source(struct gl_context *ctx, - GLuint dimensions, - const struct gl_pixelstore_attrib *unpack, - GLsizei width, GLsizei height, GLsizei depth, - GLenum format, GLenum type, GLsizei clientMemSize, - const GLvoid *ptr, const char *where) + GLuint dimensions, + const struct gl_pixelstore_attrib *unpack, + GLsizei width, GLsizei height, GLsizei depth, + GLenum format, GLenum type, + GLsizei clientMemSize, + const GLvoid *ptr, const char *where) { ASSERT(dimensions == 1 || dimensions == 2 || dimensions == 3); @@ -268,11 +270,11 @@ _mesa_map_pbo_dest(struct gl_context *ctx, */ GLvoid * _mesa_map_validate_pbo_dest(struct gl_context *ctx, - GLuint dimensions, - const struct gl_pixelstore_attrib *unpack, - GLsizei width, GLsizei height, GLsizei depth, - GLenum format, GLenum type, GLsizei clientMemSize, - GLvoid *ptr, const char *where) + GLuint dimensions, + const struct gl_pixelstore_attrib *unpack, + GLsizei width, GLsizei height, GLsizei depth, + GLenum format, GLenum type, GLsizei clientMemSize, + GLvoid *ptr, const char *where) { ASSERT(dimensions == 1 || dimensions == 2 || dimensions == 3); @@ -339,12 +341,13 @@ _mesa_validate_pbo_teximage(struct gl_context *ctx, GLuint dimensions, return pixels; } if (!_mesa_validate_pbo_access(dimensions, unpack, width, height, depth, - format, type, INT_MAX, pixels)) { + format, type, INT_MAX, pixels)) { _mesa_error(ctx, GL_INVALID_OPERATION, funcName, "(invalid PBO access)"); return NULL; } - buf = (GLubyte *) ctx->Driver.MapBufferRange(ctx, 0, unpack->BufferObj->Size, + buf = (GLubyte *) ctx->Driver.MapBufferRange(ctx, 0, + unpack->BufferObj->Size, GL_MAP_READ_BIT, unpack->BufferObj); if (!buf) { @@ -407,5 +410,3 @@ _mesa_unmap_teximage_pbo(struct gl_context *ctx, ctx->Driver.UnmapBuffer(ctx, unpack->BufferObj); } } - - diff --git a/mesalib/src/mesa/main/readpix.c b/mesalib/src/mesa/main/readpix.c index 138111049..7ac877497 100644 --- a/mesalib/src/mesa/main/readpix.c +++ b/mesalib/src/mesa/main/readpix.c @@ -36,6 +36,8 @@ #include "pack.h" #include "pbo.h" #include "state.h" +#include "glformats.h" +#include "fbobject.h" /** @@ -337,7 +339,7 @@ slow_read_rgba_pixels( struct gl_context *ctx, goto done; for (j = 0; j < height; j++) { - if (_mesa_is_integer_format(format)) { + if (_mesa_is_enum_format_integer(format)) { _mesa_unpack_uint_rgba_row(rbFormat, width, map, (GLuint (*)[4]) rgba); _mesa_rebase_rgba_uint(width, (GLuint (*)[4]) rgba, rb->_BaseFormat); @@ -378,7 +380,7 @@ read_rgba_pixels( struct gl_context *ctx, return; if ((ctx->Color._ClampReadColor == GL_TRUE || type != GL_FLOAT) && - !_mesa_is_integer_format(format)) { + !_mesa_is_enum_format_integer(format)) { transferOps |= IMAGE_CLAMP_BIT; } @@ -713,7 +715,7 @@ _mesa_ReadnPixelsARB( GLint x, GLint y, GLsizei width, GLsizei height, if (ctx->Extensions.EXT_texture_integer && _mesa_is_color_format(format)) { const struct gl_renderbuffer *rb = ctx->ReadBuffer->_ColorReadBuffer; const GLboolean srcInteger = _mesa_is_format_integer_color(rb->Format); - const GLboolean dstInteger = _mesa_is_integer_format(format); + const GLboolean dstInteger = _mesa_is_enum_format_integer(format); if (dstInteger != srcInteger) { _mesa_error(ctx, GL_INVALID_OPERATION, "glReadPixels(integer / non-integer format mismatch"); @@ -721,7 +723,8 @@ _mesa_ReadnPixelsARB( GLint x, GLint y, GLsizei width, GLsizei height, } } - if (ctx->ReadBuffer->Name != 0 && ctx->ReadBuffer->Visual.samples > 0) { + if (_mesa_is_user_fbo(ctx->ReadBuffer) && + ctx->ReadBuffer->Visual.samples > 0) { _mesa_error(ctx, GL_INVALID_OPERATION, "glReadPixels(multisample FBO)"); return; } diff --git a/mesalib/src/mesa/main/shaderapi.c b/mesalib/src/mesa/main/shaderapi.c index 6927368de..7c97a6359 100644 --- a/mesalib/src/mesa/main/shaderapi.c +++ b/mesalib/src/mesa/main/shaderapi.c @@ -346,10 +346,12 @@ delete_shader(struct gl_context *ctx, GLuint shader) if (!sh) return; - sh->DeletePending = GL_TRUE; + if (!sh->DeletePending) { + sh->DeletePending = GL_TRUE; - /* effectively, decr sh's refcount */ - _mesa_reference_shader(ctx, &sh, NULL); + /* effectively, decr sh's refcount */ + _mesa_reference_shader(ctx, &sh, NULL); + } } diff --git a/mesalib/src/mesa/main/shared.c b/mesalib/src/mesa/main/shared.c index 226947638..58cbc5250 100644 --- a/mesalib/src/mesa/main/shared.c +++ b/mesalib/src/mesa/main/shared.c @@ -71,13 +71,15 @@ _mesa_alloc_shared_state(struct gl_context *ctx) shared->Programs = _mesa_NewHashTable(); #if FEATURE_ARB_vertex_program - shared->DefaultVertexProgram = (struct gl_vertex_program *) - ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0); + shared->DefaultVertexProgram = + gl_vertex_program(ctx->Driver.NewProgram(ctx, + GL_VERTEX_PROGRAM_ARB, 0)); #endif #if FEATURE_ARB_fragment_program - shared->DefaultFragmentProgram = (struct gl_fragment_program *) - ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0); + shared->DefaultFragmentProgram = + gl_fragment_program(ctx->Driver.NewProgram(ctx, + GL_FRAGMENT_PROGRAM_ARB, 0)); #endif #if FEATURE_ATI_fragment_shader diff --git a/mesalib/src/mesa/main/state.c b/mesalib/src/mesa/main/state.c index db0cc30ec..76946bd93 100644 --- a/mesalib/src/mesa/main/state.c +++ b/mesalib/src/mesa/main/state.c @@ -134,8 +134,7 @@ update_program(struct gl_context *ctx) &ctx->Shader._CurrentFragmentProgram, fsProg); _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, - (struct gl_fragment_program *) - fsProg->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program); + gl_fragment_program(fsProg->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program)); _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._TexEnvProgram, NULL); } @@ -157,11 +156,9 @@ update_program(struct gl_context *ctx) &ctx->Shader._CurrentFragmentProgram, f); _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, - (struct gl_fragment_program *) - f->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program); + gl_fragment_program(f->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program)); _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._TexEnvProgram, - (struct gl_fragment_program *) - f->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program); + gl_fragment_program(f->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program)); } else { /* No fragment program */ @@ -174,8 +171,7 @@ update_program(struct gl_context *ctx) && gsProg->_LinkedShaders[MESA_SHADER_GEOMETRY]) { /* Use GLSL geometry shader */ _mesa_reference_geomprog(ctx, &ctx->GeometryProgram._Current, - (struct gl_geometry_program *) - gsProg->_LinkedShaders[MESA_SHADER_GEOMETRY]->Program); + gl_geometry_program(gsProg->_LinkedShaders[MESA_SHADER_GEOMETRY]->Program)); } else { /* No geometry program */ _mesa_reference_geomprog(ctx, &ctx->GeometryProgram._Current, NULL); @@ -189,8 +185,7 @@ update_program(struct gl_context *ctx) && vsProg->_LinkedShaders[MESA_SHADER_VERTEX]) { /* Use GLSL vertex shader */ _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, - (struct gl_vertex_program *) - vsProg->_LinkedShaders[MESA_SHADER_VERTEX]->Program); + gl_vertex_program(vsProg->_LinkedShaders[MESA_SHADER_VERTEX]->Program)); } else if (ctx->VertexProgram._Enabled) { /* Use user-defined vertex program */ diff --git a/mesalib/src/mesa/main/texformat.c b/mesalib/src/mesa/main/texformat.c index 26bcbc10a..d360f0e22 100644 --- a/mesalib/src/mesa/main/texformat.c +++ b/mesalib/src/mesa/main/texformat.c @@ -887,6 +887,7 @@ _mesa_choose_tex_format( struct gl_context *ctx, GLint internalFormat, switch (internalFormat) { case GL_RGB10_A2UI: RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB2101010_UINT); + RETURN_IF_SUPPORTED(MESA_FORMAT_ABGR2101010_UINT); break; default: break; @@ -894,7 +895,7 @@ _mesa_choose_tex_format( struct gl_context *ctx, GLint internalFormat, } /* GL_BGRA can be an internal format *only* in OpenGL ES (1.x or 2.0). */ - if (ctx->API != API_OPENGL) { + if (_mesa_is_gles(ctx)) { switch (internalFormat) { case GL_BGRA: RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB8888); diff --git a/mesalib/src/mesa/main/texgetimage.c b/mesalib/src/mesa/main/texgetimage.c index 05b052a01..0ba3ff5b3 100644 --- a/mesalib/src/mesa/main/texgetimage.c +++ b/mesalib/src/mesa/main/texgetimage.c @@ -35,6 +35,7 @@ #include "context.h" #include "formats.h" #include "format_unpack.h" +#include "glformats.h" #include "image.h" #include "mfeatures.h" #include "mtypes.h" diff --git a/mesalib/src/mesa/main/teximage.c b/mesalib/src/mesa/main/teximage.c index 64b25a82d..d2746c6f3 100644 --- a/mesalib/src/mesa/main/teximage.c +++ b/mesalib/src/mesa/main/teximage.c @@ -47,6 +47,7 @@ #include "texstate.h" #include "texpal.h" #include "mtypes.h" +#include "glformats.h" /** @@ -129,7 +130,7 @@ _mesa_base_tex_format( struct gl_context *ctx, GLint internalFormat ) /* GL_BGRA can be an internal format *only* in OpenGL ES (1.x or 2.0). */ - if (ctx->API != API_OPENGL) { + if (_mesa_is_gles(ctx)) { switch (internalFormat) { case GL_BGRA: return GL_RGBA; @@ -1764,8 +1765,8 @@ texture_error_check( struct gl_context *ctx, /* additional checks for integer textures */ if ((ctx->VersionMajor >= 3 || ctx->Extensions.EXT_texture_integer) && - (_mesa_is_integer_format(format) != - _mesa_is_integer_format(internalFormat))) { + (_mesa_is_enum_format_integer(format) != + _mesa_is_enum_format_integer(internalFormat))) { if (!isProxy) { _mesa_error(ctx, GL_INVALID_OPERATION, "glTexImage%dD(integer/non-integer format mismatch)", @@ -1939,7 +1940,7 @@ subtexture_error_check2( struct gl_context *ctx, GLuint dimensions, if (ctx->VersionMajor >= 3 || ctx->Extensions.EXT_texture_integer) { /* both source and dest must be integer-valued, or neither */ if (_mesa_is_format_integer_color(destTex->TexFormat) != - _mesa_is_integer_format(format)) { + _mesa_is_enum_format_integer(format)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glTexSubImage%dD(integer/non-integer format mismatch)", dimensions); @@ -2042,8 +2043,8 @@ copytexture_error_check( struct gl_context *ctx, GLuint dimensions, if (_mesa_is_color_format(internalFormat)) { struct gl_renderbuffer *rb = ctx->ReadBuffer->_ColorReadBuffer; - if (_mesa_is_integer_format(rb->InternalFormat) != - _mesa_is_integer_format(internalFormat)) { + if (_mesa_is_enum_format_integer(rb->InternalFormat) != + _mesa_is_enum_format_integer(internalFormat)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glCopyTexImage%dD(integer vs non-integer)", dimensions); return GL_TRUE; diff --git a/mesalib/src/mesa/main/texparam.c b/mesalib/src/mesa/main/texparam.c index 9abc503e3..1376219d7 100644 --- a/mesalib/src/mesa/main/texparam.c +++ b/mesalib/src/mesa/main/texparam.c @@ -35,7 +35,7 @@ #include "main/context.h" #include "main/enums.h" #include "main/formats.h" -#include "main/image.h" +#include "main/glformats.h" #include "main/macros.h" #include "main/mfeatures.h" #include "main/mtypes.h" diff --git a/mesalib/src/mesa/main/texstore.c b/mesalib/src/mesa/main/texstore.c index 1ced8aac9..ab9fdf26d 100644 --- a/mesalib/src/mesa/main/texstore.c +++ b/mesalib/src/mesa/main/texstore.c @@ -37,9 +37,8 @@ * However, most device drivers will be able to use the fallback functions * in this file. That is, most drivers will have the following bit of * code: - * ctx->Driver.TexImage1D = _mesa_store_teximage1d; - * ctx->Driver.TexImage2D = _mesa_store_teximage2d; - * ctx->Driver.TexImage3D = _mesa_store_teximage3d; + * ctx->Driver.TexImage = _mesa_store_teximage; + * ctx->Driver.TexSubImage = _mesa_store_texsubimage; * etc... * * Texture image processing is actually kind of complicated. We have to do: @@ -72,6 +71,7 @@ #include "teximage.h" #include "texstore.h" #include "enums.h" +#include "glformats.h" #include "../../gallium/auxiliary/util/u_format_rgb9e5.h" #include "../../gallium/auxiliary/util/u_format_r11g11b10f.h" @@ -3892,6 +3892,72 @@ _mesa_texstore_argb2101010_uint(TEXSTORE_PARAMS) } static GLboolean +_mesa_texstore_abgr2101010_uint(TEXSTORE_PARAMS) +{ + const GLenum baseFormat = _mesa_get_format_base_format(dstFormat); + + ASSERT(dstFormat == MESA_FORMAT_ABGR2101010_UINT); + ASSERT(_mesa_get_format_bytes(dstFormat) == 4); + + if (baseInternalFormat == GL_RGBA && + _mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType, + srcPacking->SwapBytes)) { + /* simple memcpy path */ + memcpy_texture(ctx, dims, + dstFormat, + dstRowStride, dstSlices, + srcWidth, srcHeight, srcDepth, srcFormat, srcType, + srcAddr, srcPacking); + } + else { + /* general path */ + const GLuint *tempImage = make_temp_uint_image(ctx, dims, + baseInternalFormat, + baseFormat, + srcWidth, srcHeight, + srcDepth, srcFormat, + srcType, srcAddr, + srcPacking); + const GLuint *src = tempImage; + GLint img, row, col; + GLboolean is_unsigned = _mesa_is_type_unsigned(srcType); + if (!tempImage) + return GL_FALSE; + for (img = 0; img < srcDepth; img++) { + GLubyte *dstRow = dstSlices[img]; + + for (row = 0; row < srcHeight; row++) { + GLuint *dstUI = (GLuint *) dstRow; + if (is_unsigned) { + for (col = 0; col < srcWidth; col++) { + GLushort a,r,g,b; + r = MIN2(src[RCOMP], 0x3ff); + g = MIN2(src[GCOMP], 0x3ff); + b = MIN2(src[BCOMP], 0x3ff); + a = MIN2(src[ACOMP], 0x003); + dstUI[col] = (a << 30) | (b << 20) | (g << 10) | (r); + src += 4; + } + } else { + for (col = 0; col < srcWidth; col++) { + GLushort a,r,g,b; + r = CLAMP((GLint) src[RCOMP], 0, 0x3ff); + g = CLAMP((GLint) src[GCOMP], 0, 0x3ff); + b = CLAMP((GLint) src[BCOMP], 0, 0x3ff); + a = CLAMP((GLint) src[ACOMP], 0, 0x003); + dstUI[col] = (a << 30) | (b << 20) | (g << 10) | (r); + src += 4; + } + } + dstRow += dstRowStride; + } + } + free((void *) tempImage); + } + return GL_TRUE; +} + +static GLboolean _mesa_texstore_null(TEXSTORE_PARAMS) { (void) ctx; (void) dims; @@ -4085,6 +4151,7 @@ _mesa_get_texstore_func(gl_format format) table[MESA_FORMAT_RGBA_UINT32] = _mesa_texstore_rgba_uint32; table[MESA_FORMAT_ARGB2101010_UINT] = _mesa_texstore_argb2101010_uint; + table[MESA_FORMAT_ABGR2101010_UINT] = _mesa_texstore_abgr2101010_uint; initialized = GL_TRUE; } diff --git a/mesalib/src/mesa/main/uniform_query.cpp b/mesalib/src/mesa/main/uniform_query.cpp index f5d998ffb..816c2779c 100644 --- a/mesalib/src/mesa/main/uniform_query.cpp +++ b/mesalib/src/mesa/main/uniform_query.cpp @@ -74,6 +74,79 @@ _mesa_GetActiveUniformARB(GLhandleARB program, GLuint index, } } +extern "C" void GLAPIENTRY +_mesa_GetActiveUniformsiv(GLuint program, + GLsizei uniformCount, + const GLuint *uniformIndices, + GLenum pname, + GLint *params) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_shader_program *shProg; + GLsizei i; + + shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveUniform"); + if (!shProg) + return; + + if (uniformCount < 0) { + _mesa_error(ctx, GL_INVALID_VALUE, + "glGetUniformIndices(uniformCount < 0)"); + return; + } + + for (i = 0; i < uniformCount; i++) { + GLuint index = uniformIndices[i]; + const struct gl_uniform_storage *uni = &shProg->UniformStorage[index]; + + if (index >= shProg->NumUserUniformStorage) { + _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveUniformsiv(index)"); + return; + } + + switch (pname) { + case GL_UNIFORM_TYPE: + params[i] = uni->type->gl_type; + break; + + case GL_UNIFORM_SIZE: + /* array_elements is zero for non-arrays, but the API requires that 1 be + * returned. + */ + params[i] = MAX2(1, uni->array_elements); + break; + + case GL_UNIFORM_NAME_LENGTH: + params[i] = strlen(uni->name) + 1; + break; + + case GL_UNIFORM_BLOCK_INDEX: + params[i] = uni->block_index; + break; + + case GL_UNIFORM_OFFSET: + params[i] = uni->offset; + break; + + case GL_UNIFORM_ARRAY_STRIDE: + params[i] = uni->array_stride; + break; + + case GL_UNIFORM_MATRIX_STRIDE: + params[i] = uni->matrix_stride; + break; + + case GL_UNIFORM_IS_ROW_MAJOR: + params[i] = uni->row_major; + break; + + default: + _mesa_error(ctx, GL_INVALID_ENUM, "glGetActiveUniformsiv(pname)"); + return; + } + } +} + static bool validate_uniform_parameters(struct gl_context *ctx, struct gl_shader_program *shProg, @@ -852,13 +925,17 @@ _mesa_uniform_matrix(struct gl_context *ctx, struct gl_shader_program *shProg, /** * Called via glGetUniformLocation(). * - * The return value will encode two values, the uniform location and an - * offset (used for arrays, structs). + * Returns the uniform index into UniformStorage (also the + * glGetActiveUniformsiv uniform index), and stores the referenced + * array offset in *offset, or GL_INVALID_INDEX (-1). Those two + * return values can be encoded into a uniform location for + * glUniform* using _mesa_uniform_merge_location_offset(index, offset). */ -extern "C" GLint +extern "C" unsigned _mesa_get_uniform_location(struct gl_context *ctx, struct gl_shader_program *shProg, - const GLchar *name) + const GLchar *name, + unsigned *out_offset) { const size_t len = strlen(name); long offset; @@ -901,13 +978,13 @@ _mesa_get_uniform_location(struct gl_context *ctx, * (or other non-digit characters) before the opening '['. */ if ((i == 0) || name[i-1] != '[') - return -1; + return GL_INVALID_INDEX; /* Return an error if there are no digits between the opening '[' to * match the closing ']'. */ if (i == (len - 1)) - return -1; + return GL_INVALID_INDEX; /* Make a new string that is a copy of the old string up to (but not * including) the '[' character. @@ -919,7 +996,7 @@ _mesa_get_uniform_location(struct gl_context *ctx, offset = strtol(&name[i], NULL, 10); if (offset < 0) { free(name_copy); - return -1; + return GL_INVALID_INDEX; } array_lookup = true; @@ -941,16 +1018,17 @@ _mesa_get_uniform_location(struct gl_context *ctx, free(name_copy); if (!found) - return -1; + return GL_INVALID_INDEX; /* Since array_elements is 0 for non-arrays, this causes look-ups of 'a[0]' * to (correctly) fail if 'a' is not an array. */ if (array_lookup && shProg->UniformStorage[location].array_elements == 0) { - return -1; + return GL_INVALID_INDEX; } - return _mesa_uniform_merge_location_offset(location, offset); + *out_offset = offset; + return location; } extern "C" bool diff --git a/mesalib/src/mesa/main/uniforms.c b/mesalib/src/mesa/main/uniforms.c index e6604b1a4..ccbd753db 100644 --- a/mesalib/src/mesa/main/uniforms.c +++ b/mesalib/src/mesa/main/uniforms.c @@ -497,6 +497,7 @@ GLint GLAPIENTRY _mesa_GetUniformLocationARB(GLhandleARB programObj, const GLcharARB *name) { struct gl_shader_program *shProg; + GLuint index, offset; GET_CURRENT_CONTEXT(ctx); @@ -516,9 +517,71 @@ _mesa_GetUniformLocationARB(GLhandleARB programObj, const GLcharARB *name) return -1; } - return _mesa_get_uniform_location(ctx, shProg, name); + index = _mesa_get_uniform_location(ctx, shProg, name, &offset); + if (index == GL_INVALID_INDEX) + return -1; + + return _mesa_uniform_merge_location_offset(index, offset); } +static GLuint GLAPIENTRY +_mesa_GetUniformBlockIndex(GLuint program, + const GLchar *uniformBlockName) +{ + GET_CURRENT_CONTEXT(ctx); + GLuint i; + struct gl_shader_program *shProg; + + if (!ctx->Extensions.ARB_uniform_buffer_object) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformBlockIndex"); + return GL_INVALID_INDEX; + } + + shProg = _mesa_lookup_shader_program_err(ctx, program, + "glGetUniformBlockIndex"); + if (!shProg) + return GL_INVALID_INDEX; + + for (i = 0; i < shProg->NumUniformBlocks; i++) { + if (!strcmp(shProg->UniformBlocks[i].Name, uniformBlockName)) + return i; + } + + return GL_INVALID_INDEX; +} + +static void GLAPIENTRY +_mesa_GetUniformIndices(GLuint program, + GLsizei uniformCount, + const GLchar * const *uniformNames, + GLuint *uniformIndices) +{ + GET_CURRENT_CONTEXT(ctx); + GLsizei i; + struct gl_shader_program *shProg; + + if (!ctx->Extensions.ARB_uniform_buffer_object) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformIndices"); + return; + } + + shProg = _mesa_lookup_shader_program_err(ctx, program, + "glGetUniformIndices"); + if (!shProg) + return; + + if (uniformCount < 0) { + _mesa_error(ctx, GL_INVALID_VALUE, + "glGetUniformIndices(uniformCount < 0)"); + return; + } + + for (i = 0; i < uniformCount; i++) { + unsigned offset; + uniformIndices[i] = _mesa_get_uniform_location(ctx, shProg, + uniformNames[i], &offset); + } +} /** * Plug in shader uniform-related functions into API dispatch table. @@ -577,5 +640,10 @@ _mesa_init_shader_uniform_dispatch(struct _glapi_table *exec) SET_GetnUniformuivARB(exec, _mesa_GetnUniformuivARB); SET_GetnUniformdvARB(exec, _mesa_GetnUniformdvARB); /* GL 4.0 */ + /* GL_ARB_uniform_buffer_object / GL 3.1 */ + SET_GetUniformBlockIndex(exec, _mesa_GetUniformBlockIndex); + SET_GetUniformIndices(exec, _mesa_GetUniformIndices); + SET_GetActiveUniformsiv(exec, _mesa_GetActiveUniformsiv); + #endif /* FEATURE_GL */ } diff --git a/mesalib/src/mesa/main/uniforms.h b/mesalib/src/mesa/main/uniforms.h index 7b512a527..bb0552476 100644 --- a/mesalib/src/mesa/main/uniforms.h +++ b/mesalib/src/mesa/main/uniforms.h @@ -150,6 +150,13 @@ _mesa_GetActiveUniformARB(GLhandleARB, GLuint, GLsizei, GLsizei *, GLint *, GLenum *, GLcharARB *); extern void GLAPIENTRY +_mesa_GetActiveUniformsiv(GLuint program, + GLsizei uniformCount, + const GLuint *uniformIndices, + GLenum pname, + GLint *params); + +extern void GLAPIENTRY _mesa_GetUniformfvARB(GLhandleARB, GLint, GLfloat *); extern void GLAPIENTRY @@ -176,9 +183,9 @@ _mesa_GetnUniformdvARB(GLhandleARB, GLint, GLsizei, GLdouble *); extern GLint GLAPIENTRY _mesa_GetUniformLocationARB(GLhandleARB, const GLcharARB *); -GLint +unsigned _mesa_get_uniform_location(struct gl_context *ctx, struct gl_shader_program *shProg, - const GLchar *name); + const GLchar *name, unsigned *offset); void _mesa_uniform(struct gl_context *ctx, struct gl_shader_program *shader_program, diff --git a/mesalib/src/mesa/main/varray.c b/mesalib/src/mesa/main/varray.c index efa63b07c..7ec7cfee6 100644 --- a/mesalib/src/mesa/main/varray.c +++ b/mesalib/src/mesa/main/varray.c @@ -92,7 +92,7 @@ type_to_bit(const struct gl_context *ctx, GLenum type) case GL_DOUBLE: return DOUBLE_BIT; case GL_FIXED: - return ctx->API == API_OPENGL ? FIXED_GL_BIT : FIXED_ES_BIT; + return _mesa_is_desktop_gl(ctx) ? FIXED_GL_BIT : FIXED_ES_BIT; case GL_UNSIGNED_INT_2_10_10_10_REV: return UNSIGNED_INT_2_10_10_10_REV_BIT; case GL_INT_2_10_10_10_REV: diff --git a/mesalib/src/mesa/main/version.c b/mesalib/src/mesa/main/version.c index efaaf58de..91ef2dff4 100644 --- a/mesalib/src/mesa/main/version.c +++ b/mesalib/src/mesa/main/version.c @@ -315,6 +315,7 @@ _mesa_compute_version(struct gl_context *ctx) switch (ctx->API) { case API_OPENGL: + case API_OPENGL_CORE: compute_version(ctx); break; case API_OPENGLES: diff --git a/mesalib/src/mesa/main/vtxfmt.c b/mesalib/src/mesa/main/vtxfmt.c index bf7a54c0a..ce490ed9e 100644 --- a/mesalib/src/mesa/main/vtxfmt.c +++ b/mesalib/src/mesa/main/vtxfmt.c @@ -45,57 +45,64 @@ * API dispatch table. */ static void -install_vtxfmt( struct _glapi_table *tab, const GLvertexformat *vfmt ) +install_vtxfmt(struct gl_context *ctx, struct _glapi_table *tab, + const GLvertexformat *vfmt) { _mesa_install_arrayelt_vtxfmt(tab, vfmt); - SET_Color3f(tab, vfmt->Color3f); - SET_Color3fv(tab, vfmt->Color3fv); - SET_Color4f(tab, vfmt->Color4f); - SET_Color4fv(tab, vfmt->Color4fv); - SET_EdgeFlag(tab, vfmt->EdgeFlag); + if (ctx->API != API_OPENGL_CORE) { + SET_Color3f(tab, vfmt->Color3f); + SET_Color3fv(tab, vfmt->Color3fv); + SET_Color4f(tab, vfmt->Color4f); + SET_Color4fv(tab, vfmt->Color4fv); + SET_EdgeFlag(tab, vfmt->EdgeFlag); + } _mesa_install_eval_vtxfmt(tab, vfmt); - SET_FogCoordfEXT(tab, vfmt->FogCoordfEXT); - SET_FogCoordfvEXT(tab, vfmt->FogCoordfvEXT); - SET_Indexf(tab, vfmt->Indexf); - SET_Indexfv(tab, vfmt->Indexfv); - SET_Materialfv(tab, vfmt->Materialfv); - SET_MultiTexCoord1fARB(tab, vfmt->MultiTexCoord1fARB); - SET_MultiTexCoord1fvARB(tab, vfmt->MultiTexCoord1fvARB); - SET_MultiTexCoord2fARB(tab, vfmt->MultiTexCoord2fARB); - SET_MultiTexCoord2fvARB(tab, vfmt->MultiTexCoord2fvARB); - SET_MultiTexCoord3fARB(tab, vfmt->MultiTexCoord3fARB); - SET_MultiTexCoord3fvARB(tab, vfmt->MultiTexCoord3fvARB); - SET_MultiTexCoord4fARB(tab, vfmt->MultiTexCoord4fARB); - SET_MultiTexCoord4fvARB(tab, vfmt->MultiTexCoord4fvARB); - SET_Normal3f(tab, vfmt->Normal3f); - SET_Normal3fv(tab, vfmt->Normal3fv); - SET_SecondaryColor3fEXT(tab, vfmt->SecondaryColor3fEXT); - SET_SecondaryColor3fvEXT(tab, vfmt->SecondaryColor3fvEXT); - SET_TexCoord1f(tab, vfmt->TexCoord1f); - SET_TexCoord1fv(tab, vfmt->TexCoord1fv); - SET_TexCoord2f(tab, vfmt->TexCoord2f); - SET_TexCoord2fv(tab, vfmt->TexCoord2fv); - SET_TexCoord3f(tab, vfmt->TexCoord3f); - SET_TexCoord3fv(tab, vfmt->TexCoord3fv); - SET_TexCoord4f(tab, vfmt->TexCoord4f); - SET_TexCoord4fv(tab, vfmt->TexCoord4fv); - SET_Vertex2f(tab, vfmt->Vertex2f); - SET_Vertex2fv(tab, vfmt->Vertex2fv); - SET_Vertex3f(tab, vfmt->Vertex3f); - SET_Vertex3fv(tab, vfmt->Vertex3fv); - SET_Vertex4f(tab, vfmt->Vertex4f); - SET_Vertex4fv(tab, vfmt->Vertex4fv); + if (ctx->API != API_OPENGL_CORE) { + SET_FogCoordfEXT(tab, vfmt->FogCoordfEXT); + SET_FogCoordfvEXT(tab, vfmt->FogCoordfvEXT); + SET_Indexf(tab, vfmt->Indexf); + SET_Indexfv(tab, vfmt->Indexfv); + SET_Materialfv(tab, vfmt->Materialfv); + SET_MultiTexCoord1fARB(tab, vfmt->MultiTexCoord1fARB); + SET_MultiTexCoord1fvARB(tab, vfmt->MultiTexCoord1fvARB); + SET_MultiTexCoord2fARB(tab, vfmt->MultiTexCoord2fARB); + SET_MultiTexCoord2fvARB(tab, vfmt->MultiTexCoord2fvARB); + SET_MultiTexCoord3fARB(tab, vfmt->MultiTexCoord3fARB); + SET_MultiTexCoord3fvARB(tab, vfmt->MultiTexCoord3fvARB); + SET_MultiTexCoord4fARB(tab, vfmt->MultiTexCoord4fARB); + SET_MultiTexCoord4fvARB(tab, vfmt->MultiTexCoord4fvARB); + SET_Normal3f(tab, vfmt->Normal3f); + SET_Normal3fv(tab, vfmt->Normal3fv); + SET_SecondaryColor3fEXT(tab, vfmt->SecondaryColor3fEXT); + SET_SecondaryColor3fvEXT(tab, vfmt->SecondaryColor3fvEXT); + SET_TexCoord1f(tab, vfmt->TexCoord1f); + SET_TexCoord1fv(tab, vfmt->TexCoord1fv); + SET_TexCoord2f(tab, vfmt->TexCoord2f); + SET_TexCoord2fv(tab, vfmt->TexCoord2fv); + SET_TexCoord3f(tab, vfmt->TexCoord3f); + SET_TexCoord3fv(tab, vfmt->TexCoord3fv); + SET_TexCoord4f(tab, vfmt->TexCoord4f); + SET_TexCoord4fv(tab, vfmt->TexCoord4fv); + SET_Vertex2f(tab, vfmt->Vertex2f); + SET_Vertex2fv(tab, vfmt->Vertex2fv); + SET_Vertex3f(tab, vfmt->Vertex3f); + SET_Vertex3fv(tab, vfmt->Vertex3fv); + SET_Vertex4f(tab, vfmt->Vertex4f); + SET_Vertex4fv(tab, vfmt->Vertex4fv); + } _mesa_install_dlist_vtxfmt(tab, vfmt); /* glCallList / glCallLists */ - SET_Begin(tab, vfmt->Begin); - SET_End(tab, vfmt->End); - SET_PrimitiveRestartNV(tab, vfmt->PrimitiveRestartNV); + if (ctx->API != API_OPENGL_CORE) { + SET_Begin(tab, vfmt->Begin); + SET_End(tab, vfmt->End); + SET_PrimitiveRestartNV(tab, vfmt->PrimitiveRestartNV); - SET_Rectf(tab, vfmt->Rectf); + SET_Rectf(tab, vfmt->Rectf); + } SET_DrawArrays(tab, vfmt->DrawArrays); SET_DrawElements(tab, vfmt->DrawElements); @@ -154,42 +161,44 @@ install_vtxfmt( struct _glapi_table *tab, const GLvertexformat *vfmt ) SET_VertexAttribI3uivEXT(tab, vfmt->VertexAttribI3uiv); SET_VertexAttribI4uivEXT(tab, vfmt->VertexAttribI4uiv); - /* GL_ARB_vertex_type_10_10_10_2_rev / GL 3.3 */ - SET_VertexP2ui(tab, vfmt->VertexP2ui); - SET_VertexP2uiv(tab, vfmt->VertexP2uiv); - SET_VertexP3ui(tab, vfmt->VertexP3ui); - SET_VertexP3uiv(tab, vfmt->VertexP3uiv); - SET_VertexP4ui(tab, vfmt->VertexP4ui); - SET_VertexP4uiv(tab, vfmt->VertexP4uiv); - - SET_TexCoordP1ui(tab, vfmt->TexCoordP1ui); - SET_TexCoordP1uiv(tab, vfmt->TexCoordP1uiv); - SET_TexCoordP2ui(tab, vfmt->TexCoordP2ui); - SET_TexCoordP2uiv(tab, vfmt->TexCoordP2uiv); - SET_TexCoordP3ui(tab, vfmt->TexCoordP3ui); - SET_TexCoordP3uiv(tab, vfmt->TexCoordP3uiv); - SET_TexCoordP4ui(tab, vfmt->TexCoordP4ui); - SET_TexCoordP4uiv(tab, vfmt->TexCoordP4uiv); - - SET_MultiTexCoordP1ui(tab, vfmt->MultiTexCoordP1ui); - SET_MultiTexCoordP2ui(tab, vfmt->MultiTexCoordP2ui); - SET_MultiTexCoordP3ui(tab, vfmt->MultiTexCoordP3ui); - SET_MultiTexCoordP4ui(tab, vfmt->MultiTexCoordP4ui); - SET_MultiTexCoordP1uiv(tab, vfmt->MultiTexCoordP1uiv); - SET_MultiTexCoordP2uiv(tab, vfmt->MultiTexCoordP2uiv); - SET_MultiTexCoordP3uiv(tab, vfmt->MultiTexCoordP3uiv); - SET_MultiTexCoordP4uiv(tab, vfmt->MultiTexCoordP4uiv); - - SET_NormalP3ui(tab, vfmt->NormalP3ui); - SET_NormalP3uiv(tab, vfmt->NormalP3uiv); - - SET_ColorP3ui(tab, vfmt->ColorP3ui); - SET_ColorP4ui(tab, vfmt->ColorP4ui); - SET_ColorP3uiv(tab, vfmt->ColorP3uiv); - SET_ColorP4uiv(tab, vfmt->ColorP4uiv); - - SET_SecondaryColorP3ui(tab, vfmt->SecondaryColorP3ui); - SET_SecondaryColorP3uiv(tab, vfmt->SecondaryColorP3uiv); + if (ctx->API != API_OPENGL_CORE) { + /* GL_ARB_vertex_type_10_10_10_2_rev / GL 3.3 */ + SET_VertexP2ui(tab, vfmt->VertexP2ui); + SET_VertexP2uiv(tab, vfmt->VertexP2uiv); + SET_VertexP3ui(tab, vfmt->VertexP3ui); + SET_VertexP3uiv(tab, vfmt->VertexP3uiv); + SET_VertexP4ui(tab, vfmt->VertexP4ui); + SET_VertexP4uiv(tab, vfmt->VertexP4uiv); + + SET_TexCoordP1ui(tab, vfmt->TexCoordP1ui); + SET_TexCoordP1uiv(tab, vfmt->TexCoordP1uiv); + SET_TexCoordP2ui(tab, vfmt->TexCoordP2ui); + SET_TexCoordP2uiv(tab, vfmt->TexCoordP2uiv); + SET_TexCoordP3ui(tab, vfmt->TexCoordP3ui); + SET_TexCoordP3uiv(tab, vfmt->TexCoordP3uiv); + SET_TexCoordP4ui(tab, vfmt->TexCoordP4ui); + SET_TexCoordP4uiv(tab, vfmt->TexCoordP4uiv); + + SET_MultiTexCoordP1ui(tab, vfmt->MultiTexCoordP1ui); + SET_MultiTexCoordP2ui(tab, vfmt->MultiTexCoordP2ui); + SET_MultiTexCoordP3ui(tab, vfmt->MultiTexCoordP3ui); + SET_MultiTexCoordP4ui(tab, vfmt->MultiTexCoordP4ui); + SET_MultiTexCoordP1uiv(tab, vfmt->MultiTexCoordP1uiv); + SET_MultiTexCoordP2uiv(tab, vfmt->MultiTexCoordP2uiv); + SET_MultiTexCoordP3uiv(tab, vfmt->MultiTexCoordP3uiv); + SET_MultiTexCoordP4uiv(tab, vfmt->MultiTexCoordP4uiv); + + SET_NormalP3ui(tab, vfmt->NormalP3ui); + SET_NormalP3uiv(tab, vfmt->NormalP3uiv); + + SET_ColorP3ui(tab, vfmt->ColorP3ui); + SET_ColorP4ui(tab, vfmt->ColorP4ui); + SET_ColorP3uiv(tab, vfmt->ColorP3uiv); + SET_ColorP4uiv(tab, vfmt->ColorP4uiv); + + SET_SecondaryColorP3ui(tab, vfmt->SecondaryColorP3ui); + SET_SecondaryColorP3uiv(tab, vfmt->SecondaryColorP3uiv); + } SET_VertexAttribP1ui(tab, vfmt->VertexAttribP1ui); SET_VertexAttribP2ui(tab, vfmt->VertexAttribP2ui); @@ -209,8 +218,8 @@ install_vtxfmt( struct _glapi_table *tab, const GLvertexformat *vfmt ) void _mesa_install_exec_vtxfmt(struct gl_context *ctx, const GLvertexformat *vfmt) { - if (ctx->API == API_OPENGL) - install_vtxfmt( ctx->Exec, vfmt ); + if (_mesa_is_desktop_gl(ctx)) + install_vtxfmt( ctx, ctx->Exec, vfmt ); } @@ -221,8 +230,8 @@ _mesa_install_exec_vtxfmt(struct gl_context *ctx, const GLvertexformat *vfmt) void _mesa_install_save_vtxfmt(struct gl_context *ctx, const GLvertexformat *vfmt) { - if (ctx->API == API_OPENGL) - install_vtxfmt( ctx->Save, vfmt ); + if (_mesa_is_desktop_gl(ctx)) + install_vtxfmt( ctx, ctx->Save, vfmt ); } diff --git a/mesalib/src/mesa/math/m_debug_norm.c b/mesalib/src/mesa/math/m_debug_norm.c index 02eb1f989..dc768f306 100644 --- a/mesalib/src/mesa/math/m_debug_norm.c +++ b/mesalib/src/mesa/math/m_debug_norm.c @@ -165,7 +165,7 @@ static void ref_norm_transform_normalize( const GLmatrix *mat, /* Hmmm, don't know how we could test the precalculated * length case... */ - scale = 1.0 / SQRTF( len ); + scale = INV_SQRTF( len ); SCALE_SCALAR_3V( out[i], scale, t ); } else { out[i][0] = out[i][1] = out[i][2] = 0; @@ -241,7 +241,7 @@ static int test_norm_function( normal_func func, int mtype, long *cycles ) ASSIGN_3V( d2[i], 0.0, 0.0, 0.0 ); for ( j = 0 ; j < 3 ; j++ ) s[i][j] = rnd(); - length[i] = 1 / SQRTF( LEN_SQUARED_3FV( s[i] ) ); + length[i] = INV_SQRTF( LEN_SQUARED_3FV( s[i] ) ); } source->data = (GLfloat(*)[4]) s; diff --git a/mesalib/src/mesa/math/m_matrix.c b/mesalib/src/mesa/math/m_matrix.c index 02aedbad8..00a6c814f 100644 --- a/mesalib/src/mesa/math/m_matrix.c +++ b/mesalib/src/mesa/math/m_matrix.c @@ -45,7 +45,6 @@ * \defgroup MatFlags MAT_FLAG_XXX-flags * * Bitmasks to indicate different kinds of 4x4 matrices in GLmatrix::flags - * It would be nice to make all these flags private to m_matrix.c */ /*@{*/ #define MAT_FLAG_IDENTITY 0 /**< is an identity matrix flag. @@ -296,19 +295,15 @@ static void print_matrix_floats( const GLfloat m[16] ) void _math_matrix_print( const GLmatrix *m ) { + GLfloat prod[16]; + _mesa_debug(NULL, "Matrix type: %s, flags: %x\n", types[m->type], m->flags); print_matrix_floats(m->m); _mesa_debug(NULL, "Inverse: \n"); - if (m->inv) { - GLfloat prod[16]; - print_matrix_floats(m->inv); - matmul4(prod, m->m, m->inv); - _mesa_debug(NULL, "Mat * Inverse:\n"); - print_matrix_floats(prod); - } - else { - _mesa_debug(NULL, " - not available\n"); - } + print_matrix_floats(m->inv); + matmul4(prod, m->m, m->inv); + _mesa_debug(NULL, "Mat * Inverse:\n"); + print_matrix_floats(prod); } /*@}*/ @@ -333,7 +328,7 @@ _math_matrix_print( const GLmatrix *m ) /*@{*/ /** - * Swaps the values of two floating pointer variables. + * Swaps the values of two floating point variables. * * Used by invert_matrix_general() to swap the row pointers. */ @@ -513,7 +508,7 @@ static GLboolean invert_matrix_3d_general( GLmatrix *mat ) det = pos + neg; - if (det*det < 1e-25) + if (FABSF(det) < 1e-25) return GL_FALSE; det = 1.0F / det; @@ -1141,9 +1136,7 @@ void _math_matrix_set_identity( GLmatrix *mat ) { memcpy( mat->m, Identity, 16*sizeof(GLfloat) ); - - if (mat->inv) - memcpy( mat->inv, Identity, 16*sizeof(GLfloat) ); + memcpy( mat->inv, Identity, 16*sizeof(GLfloat) ); mat->type = MATRIX_IDENTITY; mat->flags &= ~(MAT_DIRTY_FLAGS| @@ -1444,17 +1437,9 @@ void _math_matrix_copy( GLmatrix *to, const GLmatrix *from ) { memcpy( to->m, from->m, sizeof(Identity) ); + memcpy(to->inv, from->inv, 16 * sizeof(GLfloat)); to->flags = from->flags; to->type = from->type; - - if (to->inv != 0) { - if (from->inv == 0) { - matrix_invert( to ); - } - else { - memcpy(to->inv, from->inv, sizeof(GLfloat)*16); - } - } } /** @@ -1486,7 +1471,9 @@ _math_matrix_ctr( GLmatrix *m ) m->m = (GLfloat *) _mesa_align_malloc( 16 * sizeof(GLfloat), 16 ); if (m->m) memcpy( m->m, Identity, sizeof(Identity) ); - m->inv = NULL; + m->inv = (GLfloat *) _mesa_align_malloc( 16 * sizeof(GLfloat), 16 ); + if (m->inv) + memcpy( m->inv, Identity, sizeof(Identity) ); m->type = MATRIX_IDENTITY; m->flags = 0; } @@ -1511,23 +1498,6 @@ _math_matrix_dtr( GLmatrix *m ) } } -/** - * Allocate a matrix inverse. - * - * \param m matrix. - * - * Allocates the matrix inverse, GLmatrix::inv, and sets it to Identity. - */ -void -_math_matrix_alloc_inv( GLmatrix *m ) -{ - if (!m->inv) { - m->inv = (GLfloat *) _mesa_align_malloc( 16 * sizeof(GLfloat), 16 ); - if (m->inv) - memcpy( m->inv, Identity, 16 * sizeof(GLfloat) ); - } -} - /*@}*/ diff --git a/mesalib/src/mesa/math/m_matrix.h b/mesalib/src/mesa/math/m_matrix.h index e8e48aab7..9f4ea2586 100644 --- a/mesalib/src/mesa/math/m_matrix.h +++ b/mesalib/src/mesa/math/m_matrix.h @@ -74,7 +74,7 @@ enum GLmatrixtype { */ typedef struct { GLfloat *m; /**< 16 matrix elements (16-byte aligned) */ - GLfloat *inv; /**< optional 16-element inverse (16-byte aligned) */ + GLfloat *inv; /**< 16-element inverse (16-byte aligned) */ GLuint flags; /**< possible values determined by (of \link * MatFlags MAT_FLAG_* flags\endlink) */ @@ -91,9 +91,6 @@ extern void _math_matrix_dtr( GLmatrix *m ); extern void -_math_matrix_alloc_inv( GLmatrix *m ); - -extern void _math_matrix_mul_matrix( GLmatrix *dest, const GLmatrix *a, const GLmatrix *b ); extern void diff --git a/mesalib/src/mesa/program/arbprogparse.c b/mesalib/src/mesa/program/arbprogparse.c index dffc8abf7..72e51dd0f 100644 --- a/mesalib/src/mesa/program/arbprogparse.c +++ b/mesalib/src/mesa/program/arbprogparse.c @@ -120,6 +120,7 @@ _mesa_parse_arb_fragment_program(struct gl_context* ctx, GLenum target, program->PixelCenterInteger = state.option.PixelCenterInteger; program->UsesKill = state.fragment.UsesKill; + program->UsesDFdy = state.fragment.UsesDFdy; if (program->Base.Instructions) free(program->Base.Instructions); diff --git a/mesalib/src/mesa/program/ir_to_mesa.cpp b/mesalib/src/mesa/program/ir_to_mesa.cpp index 217a26455..baa317204 100644 --- a/mesalib/src/mesa/program/ir_to_mesa.cpp +++ b/mesalib/src/mesa/program/ir_to_mesa.cpp @@ -2157,8 +2157,6 @@ ir_to_mesa_visitor::visit(ir_return *ir) void ir_to_mesa_visitor::visit(ir_discard *ir) { - struct gl_fragment_program *fp = (struct gl_fragment_program *)this->prog; - if (ir->condition) { ir->condition->accept(this); this->result.negate = ~this->result.negate; @@ -2166,8 +2164,6 @@ ir_to_mesa_visitor::visit(ir_discard *ir) } else { emit(ir, OPCODE_KIL_NV); } - - fp->UsesKill = GL_TRUE; } void @@ -3119,6 +3115,12 @@ _mesa_glsl_compile_shader(struct gl_context *ctx, struct gl_shader *shader) } } + if (shader->UniformBlocks) + ralloc_free(shader->UniformBlocks); + shader->NumUniformBlocks = state->num_uniform_blocks; + shader->UniformBlocks = state->uniform_blocks; + ralloc_steal(shader, shader->UniformBlocks); + /* Retain any live IR, but trash the rest. */ reparent_ir(shader->ir, shader->ir); diff --git a/mesalib/src/mesa/program/prog_statevars.c b/mesalib/src/mesa/program/prog_statevars.c index 98ab9d003..3d1338674 100644 --- a/mesalib/src/mesa/program/prog_statevars.c +++ b/mesalib/src/mesa/program/prog_statevars.c @@ -34,6 +34,7 @@ #include "main/imports.h" #include "main/macros.h" #include "main/mtypes.h" +#include "main/fbobject.h" #include "prog_statevars.h" #include "prog_parameter.h" @@ -322,7 +323,6 @@ _mesa_fetch_state(struct gl_context *ctx, const gl_state_index state[], modifier == STATE_MATRIX_INVTRANS) { /* Be sure inverse is up to date: */ - _math_matrix_alloc_inv( (GLmatrix *) matrix ); _math_matrix_analyse( (GLmatrix*) matrix ); m = matrix->inv; } @@ -574,7 +574,7 @@ _mesa_fetch_state(struct gl_context *ctx, const gl_state_index state[], case STATE_FB_WPOS_Y_TRANSFORM: /* A driver may negate this conditional by using ZW swizzle * instead of XY (based on e.g. some other state). */ - if (ctx->DrawBuffer->Name != 0) { + if (_mesa_is_user_fbo(ctx->DrawBuffer)) { /* Identity (XY) followed by flipping Y upside down (ZW). */ value[0] = 1.0F; value[1] = 0.0F; diff --git a/mesalib/src/mesa/program/program.c b/mesalib/src/mesa/program/program.c index 582cbccf8..15337f4d8 100644 --- a/mesalib/src/mesa/program/program.c +++ b/mesalib/src/mesa/program/program.c @@ -169,22 +169,19 @@ _mesa_update_default_objects_program(struct gl_context *ctx) { #if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current, - (struct gl_vertex_program *) ctx->Shared->DefaultVertexProgram); assert(ctx->VertexProgram.Current); #endif #if FEATURE_NV_fragment_program || FEATURE_ARB_fragment_program _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current, - (struct gl_fragment_program *) ctx->Shared->DefaultFragmentProgram); assert(ctx->FragmentProgram.Current); #endif #if FEATURE_ARB_geometry_shader4 _mesa_reference_geomprog(ctx, &ctx->GeometryProgram.Current, - (struct gl_geometry_program *) - ctx->Shared->DefaultGeometryProgram); + ctx->Shared->DefaultGeometryProgram); #endif /* XXX probably move this stuff */ @@ -538,28 +535,26 @@ _mesa_clone_program(struct gl_context *ctx, const struct gl_program *prog) switch (prog->Target) { case GL_VERTEX_PROGRAM_ARB: { - const struct gl_vertex_program *vp - = (const struct gl_vertex_program *) prog; - struct gl_vertex_program *vpc = (struct gl_vertex_program *) clone; + const struct gl_vertex_program *vp = gl_vertex_program_const(prog); + struct gl_vertex_program *vpc = gl_vertex_program(clone); vpc->IsPositionInvariant = vp->IsPositionInvariant; vpc->IsNVProgram = vp->IsNVProgram; } break; case GL_FRAGMENT_PROGRAM_ARB: { - const struct gl_fragment_program *fp - = (const struct gl_fragment_program *) prog; - struct gl_fragment_program *fpc = (struct gl_fragment_program *) clone; + const struct gl_fragment_program *fp = gl_fragment_program_const(prog); + struct gl_fragment_program *fpc = gl_fragment_program(clone); fpc->UsesKill = fp->UsesKill; + fpc->UsesDFdy = fp->UsesDFdy; fpc->OriginUpperLeft = fp->OriginUpperLeft; fpc->PixelCenterInteger = fp->PixelCenterInteger; } break; case MESA_GEOMETRY_PROGRAM: { - const struct gl_geometry_program *gp - = (const struct gl_geometry_program *) prog; - struct gl_geometry_program *gpc = (struct gl_geometry_program *) clone; + const struct gl_geometry_program *gp = gl_geometry_program_const(prog); + struct gl_geometry_program *gpc = gl_geometry_program(clone); gpc->VerticesOut = gp->VerticesOut; gpc->InputType = gp->InputType; gpc->OutputType = gp->OutputType; @@ -763,15 +758,17 @@ _mesa_combine_programs(struct gl_context *ctx, usedTemps, MAX_PROGRAM_TEMPS); if (newProg->Target == GL_FRAGMENT_PROGRAM_ARB) { - struct gl_fragment_program *fprogA, *fprogB, *newFprog; + const struct gl_fragment_program *fprogA, *fprogB; + struct gl_fragment_program *newFprog; GLbitfield progB_inputsRead = progB->InputsRead; GLint progB_colorFile, progB_colorIndex; - fprogA = (struct gl_fragment_program *) progA; - fprogB = (struct gl_fragment_program *) progB; - newFprog = (struct gl_fragment_program *) newProg; + fprogA = gl_fragment_program_const(progA); + fprogB = gl_fragment_program_const(progB); + newFprog = gl_fragment_program(newProg); newFprog->UsesKill = fprogA->UsesKill || fprogB->UsesKill; + newFprog->UsesDFdy = fprogA->UsesDFdy || fprogB->UsesDFdy; /* We'll do a search and replace for instances * of progB_colorFile/progB_colorIndex below... diff --git a/mesalib/src/mesa/program/program.h b/mesalib/src/mesa/program/program.h index 9cd1780b8..c5650c519 100644 --- a/mesalib/src/mesa/program/program.h +++ b/mesalib/src/mesa/program/program.h @@ -183,13 +183,11 @@ _mesa_valid_register_index(const struct gl_context *ctx, extern void _mesa_postprocess_program(struct gl_context *ctx, struct gl_program *prog); -/* keep these in the same order as TGSI_PROCESSOR_* */ static inline GLuint _mesa_program_target_to_index(GLenum v) { - switch(v) - { + switch (v) { case GL_VERTEX_PROGRAM_ARB: return MESA_SHADER_VERTEX; case GL_FRAGMENT_PROGRAM_ARB: @@ -205,10 +203,10 @@ _mesa_program_target_to_index(GLenum v) static inline GLenum _mesa_program_index_to_target(GLuint i) { - GLenum enums[MESA_SHADER_TYPES] = { - GL_VERTEX_PROGRAM_ARB, - GL_FRAGMENT_PROGRAM_ARB, - GL_GEOMETRY_PROGRAM_NV, + static const GLenum enums[MESA_SHADER_TYPES] = { + GL_VERTEX_PROGRAM_ARB, + GL_FRAGMENT_PROGRAM_ARB, + GL_GEOMETRY_PROGRAM_NV, }; if(i >= MESA_SHADER_TYPES) return 0; @@ -216,4 +214,46 @@ _mesa_program_index_to_target(GLuint i) return enums[i]; } + +/* Cast wrappers from gl_program to gl_vertex/geometry/fragment_program */ + +static inline struct gl_fragment_program * +gl_fragment_program(struct gl_program *prog) +{ + return (struct gl_fragment_program *) prog; +} + +static inline const struct gl_fragment_program * +gl_fragment_program_const(const struct gl_program *prog) +{ + return (const struct gl_fragment_program *) prog; +} + + +static inline struct gl_vertex_program * +gl_vertex_program(struct gl_program *prog) +{ + return (struct gl_vertex_program *) prog; +} + +static inline const struct gl_vertex_program * +gl_vertex_program_const(const struct gl_program *prog) +{ + return (const struct gl_vertex_program *) prog; +} + + +static inline struct gl_geometry_program * +gl_geometry_program(struct gl_program *prog) +{ + return (struct gl_geometry_program *) prog; +} + +static inline const struct gl_geometry_program * +gl_geometry_program_const(const struct gl_program *prog) +{ + return (const struct gl_geometry_program *) prog; +} + + #endif /* PROGRAM_H */ diff --git a/mesalib/src/mesa/program/program_parse.y b/mesalib/src/mesa/program/program_parse.y index 4f958a993..54b17314a 100644 --- a/mesalib/src/mesa/program/program_parse.y +++ b/mesalib/src/mesa/program/program_parse.y @@ -382,6 +382,8 @@ ARL_instruction: ARL maskedAddrReg ',' scalarSrcReg VECTORop_instruction: VECTOR_OP maskedDstReg ',' swizzleSrcReg { + if ($1.Opcode == OPCODE_DDY) + state->fragment.UsesDFdy = 1; $$ = asm_instruction_copy_ctor(& $1, & $2, & $4, NULL, NULL); } ; diff --git a/mesalib/src/mesa/program/program_parser.h b/mesalib/src/mesa/program/program_parser.h index bc756148a..ca36bb6dc 100644 --- a/mesalib/src/mesa/program/program_parser.h +++ b/mesalib/src/mesa/program/program_parser.h @@ -214,6 +214,7 @@ struct asm_parser_state { struct { unsigned UsesKill:1; + unsigned UsesDFdy:1; } fragment; }; diff --git a/mesalib/src/mesa/sources.mak b/mesalib/src/mesa/sources.mak index d22f0595c..ce248dea1 100644 --- a/mesalib/src/mesa/sources.mak +++ b/mesalib/src/mesa/sources.mak @@ -1,319 +1,321 @@ ### Lists of source files, included by Makefiles -SRCDIR ?= . +# This file is among different build systems. SRCDIR must be defined with +# a trailing slash because the Android build system leaves it undefined. # this is part of MAIN_FILES MAIN_ES_FILES = \ - $(SRCDIR)/main/api_exec_es1.c \ - $(SRCDIR)/main/api_exec_es2.c + $(SRCDIR)main/api_exec_es1.c \ + $(SRCDIR)main/api_exec_es2.c MAIN_FILES = \ - $(SRCDIR)/main/api_arrayelt.c \ - $(SRCDIR)/main/api_exec.c \ - $(SRCDIR)/main/api_loopback.c \ - $(SRCDIR)/main/api_validate.c \ - $(SRCDIR)/main/accum.c \ - $(SRCDIR)/main/arbprogram.c \ - $(SRCDIR)/main/atifragshader.c \ - $(SRCDIR)/main/attrib.c \ - $(SRCDIR)/main/arrayobj.c \ - $(SRCDIR)/main/blend.c \ - $(SRCDIR)/main/bufferobj.c \ - $(SRCDIR)/main/buffers.c \ - $(SRCDIR)/main/clear.c \ - $(SRCDIR)/main/clip.c \ - $(SRCDIR)/main/colortab.c \ - $(SRCDIR)/main/condrender.c \ - $(SRCDIR)/main/context.c \ - $(SRCDIR)/main/convolve.c \ - $(SRCDIR)/main/cpuinfo.c \ - $(SRCDIR)/main/debug.c \ - $(SRCDIR)/main/depth.c \ - $(SRCDIR)/main/dlist.c \ - $(SRCDIR)/main/dlopen.c \ - $(SRCDIR)/main/drawpix.c \ - $(SRCDIR)/main/drawtex.c \ - $(SRCDIR)/main/enable.c \ - $(SRCDIR)/main/enums.c \ - $(SRCDIR)/main/errors.c \ - $(SRCDIR)/main/eval.c \ - $(SRCDIR)/main/execmem.c \ - $(SRCDIR)/main/extensions.c \ - $(SRCDIR)/main/fbobject.c \ - $(SRCDIR)/main/feedback.c \ - $(SRCDIR)/main/ffvertex_prog.c \ - $(SRCDIR)/main/fog.c \ - $(SRCDIR)/main/formats.c \ - $(SRCDIR)/main/format_pack.c \ - $(SRCDIR)/main/format_unpack.c \ - $(SRCDIR)/main/framebuffer.c \ - $(SRCDIR)/main/get.c \ - $(SRCDIR)/main/getstring.c \ - $(SRCDIR)/main/hash.c \ - $(SRCDIR)/main/hint.c \ - $(SRCDIR)/main/histogram.c \ - $(SRCDIR)/main/image.c \ - $(SRCDIR)/main/imports.c \ - $(SRCDIR)/main/light.c \ - $(SRCDIR)/main/lines.c \ - $(SRCDIR)/main/matrix.c \ - $(SRCDIR)/main/mipmap.c \ - $(SRCDIR)/main/mm.c \ - $(SRCDIR)/main/multisample.c \ - $(SRCDIR)/main/nvprogram.c \ - $(SRCDIR)/main/pack.c \ - $(SRCDIR)/main/pbo.c \ - $(SRCDIR)/main/pixel.c \ - $(SRCDIR)/main/pixelstore.c \ - $(SRCDIR)/main/pixeltransfer.c \ - $(SRCDIR)/main/points.c \ - $(SRCDIR)/main/polygon.c \ - $(SRCDIR)/main/queryobj.c \ - $(SRCDIR)/main/querymatrix.c \ - $(SRCDIR)/main/rastpos.c \ - $(SRCDIR)/main/readpix.c \ - $(SRCDIR)/main/remap.c \ - $(SRCDIR)/main/renderbuffer.c \ - $(SRCDIR)/main/samplerobj.c \ - $(SRCDIR)/main/scissor.c \ - $(SRCDIR)/main/shaderapi.c \ - $(SRCDIR)/main/shaderobj.c \ - $(SRCDIR)/main/shared.c \ - $(SRCDIR)/main/state.c \ - $(SRCDIR)/main/stencil.c \ - $(SRCDIR)/main/syncobj.c \ - $(SRCDIR)/main/texcompress.c \ - $(SRCDIR)/main/texcompress_rgtc.c \ - $(SRCDIR)/main/texcompress_s3tc.c \ - $(SRCDIR)/main/texcompress_fxt1.c \ - $(SRCDIR)/main/texcompress_etc.c \ - $(SRCDIR)/main/texenv.c \ - $(SRCDIR)/main/texformat.c \ - $(SRCDIR)/main/texgen.c \ - $(SRCDIR)/main/texgetimage.c \ - $(SRCDIR)/main/teximage.c \ - $(SRCDIR)/main/texobj.c \ - $(SRCDIR)/main/texpal.c \ - $(SRCDIR)/main/texparam.c \ - $(SRCDIR)/main/texstate.c \ - $(SRCDIR)/main/texstorage.c \ - $(SRCDIR)/main/texstore.c \ - $(SRCDIR)/main/texturebarrier.c \ - $(SRCDIR)/main/transformfeedback.c \ - $(SRCDIR)/main/uniforms.c \ - $(SRCDIR)/main/varray.c \ - $(SRCDIR)/main/version.c \ - $(SRCDIR)/main/viewport.c \ - $(SRCDIR)/main/vtxfmt.c \ + $(SRCDIR)main/api_arrayelt.c \ + $(SRCDIR)main/api_exec.c \ + $(SRCDIR)main/api_loopback.c \ + $(SRCDIR)main/api_validate.c \ + $(SRCDIR)main/accum.c \ + $(SRCDIR)main/arbprogram.c \ + $(SRCDIR)main/atifragshader.c \ + $(SRCDIR)main/attrib.c \ + $(SRCDIR)main/arrayobj.c \ + $(SRCDIR)main/blend.c \ + $(SRCDIR)main/bufferobj.c \ + $(SRCDIR)main/buffers.c \ + $(SRCDIR)main/clear.c \ + $(SRCDIR)main/clip.c \ + $(SRCDIR)main/colortab.c \ + $(SRCDIR)main/condrender.c \ + $(SRCDIR)main/context.c \ + $(SRCDIR)main/convolve.c \ + $(SRCDIR)main/cpuinfo.c \ + $(SRCDIR)main/debug.c \ + $(SRCDIR)main/depth.c \ + $(SRCDIR)main/dlist.c \ + $(SRCDIR)main/dlopen.c \ + $(SRCDIR)main/drawpix.c \ + $(SRCDIR)main/drawtex.c \ + $(SRCDIR)main/enable.c \ + $(SRCDIR)main/enums.c \ + $(SRCDIR)main/errors.c \ + $(SRCDIR)main/eval.c \ + $(SRCDIR)main/execmem.c \ + $(SRCDIR)main/extensions.c \ + $(SRCDIR)main/fbobject.c \ + $(SRCDIR)main/feedback.c \ + $(SRCDIR)main/ffvertex_prog.c \ + $(SRCDIR)main/fog.c \ + $(SRCDIR)main/formats.c \ + $(SRCDIR)main/format_pack.c \ + $(SRCDIR)main/format_unpack.c \ + $(SRCDIR)main/framebuffer.c \ + $(SRCDIR)main/get.c \ + $(SRCDIR)main/getstring.c \ + $(SRCDIR)main/glformats.c \ + $(SRCDIR)main/hash.c \ + $(SRCDIR)main/hint.c \ + $(SRCDIR)main/histogram.c \ + $(SRCDIR)main/image.c \ + $(SRCDIR)main/imports.c \ + $(SRCDIR)main/light.c \ + $(SRCDIR)main/lines.c \ + $(SRCDIR)main/matrix.c \ + $(SRCDIR)main/mipmap.c \ + $(SRCDIR)main/mm.c \ + $(SRCDIR)main/multisample.c \ + $(SRCDIR)main/nvprogram.c \ + $(SRCDIR)main/pack.c \ + $(SRCDIR)main/pbo.c \ + $(SRCDIR)main/pixel.c \ + $(SRCDIR)main/pixelstore.c \ + $(SRCDIR)main/pixeltransfer.c \ + $(SRCDIR)main/points.c \ + $(SRCDIR)main/polygon.c \ + $(SRCDIR)main/queryobj.c \ + $(SRCDIR)main/querymatrix.c \ + $(SRCDIR)main/rastpos.c \ + $(SRCDIR)main/readpix.c \ + $(SRCDIR)main/remap.c \ + $(SRCDIR)main/renderbuffer.c \ + $(SRCDIR)main/samplerobj.c \ + $(SRCDIR)main/scissor.c \ + $(SRCDIR)main/shaderapi.c \ + $(SRCDIR)main/shaderobj.c \ + $(SRCDIR)main/shared.c \ + $(SRCDIR)main/state.c \ + $(SRCDIR)main/stencil.c \ + $(SRCDIR)main/syncobj.c \ + $(SRCDIR)main/texcompress.c \ + $(SRCDIR)main/texcompress_rgtc.c \ + $(SRCDIR)main/texcompress_s3tc.c \ + $(SRCDIR)main/texcompress_fxt1.c \ + $(SRCDIR)main/texcompress_etc.c \ + $(SRCDIR)main/texenv.c \ + $(SRCDIR)main/texformat.c \ + $(SRCDIR)main/texgen.c \ + $(SRCDIR)main/texgetimage.c \ + $(SRCDIR)main/teximage.c \ + $(SRCDIR)main/texobj.c \ + $(SRCDIR)main/texpal.c \ + $(SRCDIR)main/texparam.c \ + $(SRCDIR)main/texstate.c \ + $(SRCDIR)main/texstorage.c \ + $(SRCDIR)main/texstore.c \ + $(SRCDIR)main/texturebarrier.c \ + $(SRCDIR)main/transformfeedback.c \ + $(SRCDIR)main/uniforms.c \ + $(SRCDIR)main/varray.c \ + $(SRCDIR)main/version.c \ + $(SRCDIR)main/viewport.c \ + $(SRCDIR)main/vtxfmt.c \ $(MAIN_ES_FILES) MAIN_CXX_FILES = \ - $(SRCDIR)/main/ff_fragment_shader.cpp \ - $(SRCDIR)/main/shader_query.cpp \ - $(SRCDIR)/main/uniform_query.cpp + $(SRCDIR)main/ff_fragment_shader.cpp \ + $(SRCDIR)main/shader_query.cpp \ + $(SRCDIR)main/uniform_query.cpp MATH_FILES = \ - $(SRCDIR)/math/m_debug_clip.c \ - $(SRCDIR)/math/m_debug_norm.c \ - $(SRCDIR)/math/m_debug_xform.c \ - $(SRCDIR)/math/m_eval.c \ - $(SRCDIR)/math/m_matrix.c \ - $(SRCDIR)/math/m_translate.c \ - $(SRCDIR)/math/m_vector.c + $(SRCDIR)math/m_debug_clip.c \ + $(SRCDIR)math/m_debug_norm.c \ + $(SRCDIR)math/m_debug_xform.c \ + $(SRCDIR)math/m_eval.c \ + $(SRCDIR)math/m_matrix.c \ + $(SRCDIR)math/m_translate.c \ + $(SRCDIR)math/m_vector.c MATH_XFORM_FILES = \ - $(SRCDIR)/math/m_xform.c + $(SRCDIR)math/m_xform.c SWRAST_FILES = \ - $(SRCDIR)/swrast/s_aaline.c \ - $(SRCDIR)/swrast/s_aatriangle.c \ - $(SRCDIR)/swrast/s_alpha.c \ - $(SRCDIR)/swrast/s_atifragshader.c \ - $(SRCDIR)/swrast/s_bitmap.c \ - $(SRCDIR)/swrast/s_blend.c \ - $(SRCDIR)/swrast/s_blit.c \ - $(SRCDIR)/swrast/s_clear.c \ - $(SRCDIR)/swrast/s_copypix.c \ - $(SRCDIR)/swrast/s_context.c \ - $(SRCDIR)/swrast/s_depth.c \ - $(SRCDIR)/swrast/s_drawpix.c \ - $(SRCDIR)/swrast/s_feedback.c \ - $(SRCDIR)/swrast/s_fog.c \ - $(SRCDIR)/swrast/s_fragprog.c \ - $(SRCDIR)/swrast/s_lines.c \ - $(SRCDIR)/swrast/s_logic.c \ - $(SRCDIR)/swrast/s_masking.c \ - $(SRCDIR)/swrast/s_points.c \ - $(SRCDIR)/swrast/s_renderbuffer.c \ - $(SRCDIR)/swrast/s_span.c \ - $(SRCDIR)/swrast/s_stencil.c \ - $(SRCDIR)/swrast/s_texcombine.c \ - $(SRCDIR)/swrast/s_texfetch.c \ - $(SRCDIR)/swrast/s_texfilter.c \ - $(SRCDIR)/swrast/s_texrender.c \ - $(SRCDIR)/swrast/s_texture.c \ - $(SRCDIR)/swrast/s_triangle.c \ - $(SRCDIR)/swrast/s_zoom.c + $(SRCDIR)swrast/s_aaline.c \ + $(SRCDIR)swrast/s_aatriangle.c \ + $(SRCDIR)swrast/s_alpha.c \ + $(SRCDIR)swrast/s_atifragshader.c \ + $(SRCDIR)swrast/s_bitmap.c \ + $(SRCDIR)swrast/s_blend.c \ + $(SRCDIR)swrast/s_blit.c \ + $(SRCDIR)swrast/s_clear.c \ + $(SRCDIR)swrast/s_copypix.c \ + $(SRCDIR)swrast/s_context.c \ + $(SRCDIR)swrast/s_depth.c \ + $(SRCDIR)swrast/s_drawpix.c \ + $(SRCDIR)swrast/s_feedback.c \ + $(SRCDIR)swrast/s_fog.c \ + $(SRCDIR)swrast/s_fragprog.c \ + $(SRCDIR)swrast/s_lines.c \ + $(SRCDIR)swrast/s_logic.c \ + $(SRCDIR)swrast/s_masking.c \ + $(SRCDIR)swrast/s_points.c \ + $(SRCDIR)swrast/s_renderbuffer.c \ + $(SRCDIR)swrast/s_span.c \ + $(SRCDIR)swrast/s_stencil.c \ + $(SRCDIR)swrast/s_texcombine.c \ + $(SRCDIR)swrast/s_texfetch.c \ + $(SRCDIR)swrast/s_texfilter.c \ + $(SRCDIR)swrast/s_texrender.c \ + $(SRCDIR)swrast/s_texture.c \ + $(SRCDIR)swrast/s_triangle.c \ + $(SRCDIR)swrast/s_zoom.c SWRAST_SETUP_FILES = \ - $(SRCDIR)/swrast_setup/ss_context.c \ - $(SRCDIR)/swrast_setup/ss_triangle.c + $(SRCDIR)swrast_setup/ss_context.c \ + $(SRCDIR)swrast_setup/ss_triangle.c TNL_FILES = \ - $(SRCDIR)/tnl/t_context.c \ - $(SRCDIR)/tnl/t_pipeline.c \ - $(SRCDIR)/tnl/t_draw.c \ - $(SRCDIR)/tnl/t_rasterpos.c \ - $(SRCDIR)/tnl/t_vb_program.c \ - $(SRCDIR)/tnl/t_vb_render.c \ - $(SRCDIR)/tnl/t_vb_texgen.c \ - $(SRCDIR)/tnl/t_vb_texmat.c \ - $(SRCDIR)/tnl/t_vb_vertex.c \ - $(SRCDIR)/tnl/t_vb_fog.c \ - $(SRCDIR)/tnl/t_vb_light.c \ - $(SRCDIR)/tnl/t_vb_normals.c \ - $(SRCDIR)/tnl/t_vb_points.c \ - $(SRCDIR)/tnl/t_vp_build.c \ - $(SRCDIR)/tnl/t_vertex.c \ - $(SRCDIR)/tnl/t_vertex_sse.c \ - $(SRCDIR)/tnl/t_vertex_generic.c + $(SRCDIR)tnl/t_context.c \ + $(SRCDIR)tnl/t_pipeline.c \ + $(SRCDIR)tnl/t_draw.c \ + $(SRCDIR)tnl/t_rasterpos.c \ + $(SRCDIR)tnl/t_vb_program.c \ + $(SRCDIR)tnl/t_vb_render.c \ + $(SRCDIR)tnl/t_vb_texgen.c \ + $(SRCDIR)tnl/t_vb_texmat.c \ + $(SRCDIR)tnl/t_vb_vertex.c \ + $(SRCDIR)tnl/t_vb_fog.c \ + $(SRCDIR)tnl/t_vb_light.c \ + $(SRCDIR)tnl/t_vb_normals.c \ + $(SRCDIR)tnl/t_vb_points.c \ + $(SRCDIR)tnl/t_vp_build.c \ + $(SRCDIR)tnl/t_vertex.c \ + $(SRCDIR)tnl/t_vertex_sse.c \ + $(SRCDIR)tnl/t_vertex_generic.c VBO_FILES = \ - $(SRCDIR)/vbo/vbo_context.c \ - $(SRCDIR)/vbo/vbo_exec.c \ - $(SRCDIR)/vbo/vbo_exec_api.c \ - $(SRCDIR)/vbo/vbo_exec_array.c \ - $(SRCDIR)/vbo/vbo_exec_draw.c \ - $(SRCDIR)/vbo/vbo_exec_eval.c \ - $(SRCDIR)/vbo/vbo_noop.c \ - $(SRCDIR)/vbo/vbo_primitive_restart.c \ - $(SRCDIR)/vbo/vbo_rebase.c \ - $(SRCDIR)/vbo/vbo_split.c \ - $(SRCDIR)/vbo/vbo_split_copy.c \ - $(SRCDIR)/vbo/vbo_split_inplace.c \ - $(SRCDIR)/vbo/vbo_save.c \ - $(SRCDIR)/vbo/vbo_save_api.c \ - $(SRCDIR)/vbo/vbo_save_draw.c \ - $(SRCDIR)/vbo/vbo_save_loopback.c + $(SRCDIR)vbo/vbo_context.c \ + $(SRCDIR)vbo/vbo_exec.c \ + $(SRCDIR)vbo/vbo_exec_api.c \ + $(SRCDIR)vbo/vbo_exec_array.c \ + $(SRCDIR)vbo/vbo_exec_draw.c \ + $(SRCDIR)vbo/vbo_exec_eval.c \ + $(SRCDIR)vbo/vbo_noop.c \ + $(SRCDIR)vbo/vbo_primitive_restart.c \ + $(SRCDIR)vbo/vbo_rebase.c \ + $(SRCDIR)vbo/vbo_split.c \ + $(SRCDIR)vbo/vbo_split_copy.c \ + $(SRCDIR)vbo/vbo_split_inplace.c \ + $(SRCDIR)vbo/vbo_save.c \ + $(SRCDIR)vbo/vbo_save_api.c \ + $(SRCDIR)vbo/vbo_save_draw.c \ + $(SRCDIR)vbo/vbo_save_loopback.c STATETRACKER_FILES = \ - $(SRCDIR)/state_tracker/st_atom.c \ - $(SRCDIR)/state_tracker/st_atom_array.c \ - $(SRCDIR)/state_tracker/st_atom_blend.c \ - $(SRCDIR)/state_tracker/st_atom_clip.c \ - $(SRCDIR)/state_tracker/st_atom_constbuf.c \ - $(SRCDIR)/state_tracker/st_atom_depth.c \ - $(SRCDIR)/state_tracker/st_atom_framebuffer.c \ - $(SRCDIR)/state_tracker/st_atom_msaa.c \ - $(SRCDIR)/state_tracker/st_atom_pixeltransfer.c \ - $(SRCDIR)/state_tracker/st_atom_sampler.c \ - $(SRCDIR)/state_tracker/st_atom_scissor.c \ - $(SRCDIR)/state_tracker/st_atom_shader.c \ - $(SRCDIR)/state_tracker/st_atom_rasterizer.c \ - $(SRCDIR)/state_tracker/st_atom_stipple.c \ - $(SRCDIR)/state_tracker/st_atom_texture.c \ - $(SRCDIR)/state_tracker/st_atom_viewport.c \ - $(SRCDIR)/state_tracker/st_cb_bitmap.c \ - $(SRCDIR)/state_tracker/st_cb_blit.c \ - $(SRCDIR)/state_tracker/st_cb_bufferobjects.c \ - $(SRCDIR)/state_tracker/st_cb_clear.c \ - $(SRCDIR)/state_tracker/st_cb_condrender.c \ - $(SRCDIR)/state_tracker/st_cb_flush.c \ - $(SRCDIR)/state_tracker/st_cb_drawpixels.c \ - $(SRCDIR)/state_tracker/st_cb_drawtex.c \ - $(SRCDIR)/state_tracker/st_cb_eglimage.c \ - $(SRCDIR)/state_tracker/st_cb_fbo.c \ - $(SRCDIR)/state_tracker/st_cb_feedback.c \ - $(SRCDIR)/state_tracker/st_cb_program.c \ - $(SRCDIR)/state_tracker/st_cb_queryobj.c \ - $(SRCDIR)/state_tracker/st_cb_rasterpos.c \ - $(SRCDIR)/state_tracker/st_cb_readpixels.c \ - $(SRCDIR)/state_tracker/st_cb_syncobj.c \ - $(SRCDIR)/state_tracker/st_cb_strings.c \ - $(SRCDIR)/state_tracker/st_cb_texture.c \ - $(SRCDIR)/state_tracker/st_cb_texturebarrier.c \ - $(SRCDIR)/state_tracker/st_cb_viewport.c \ - $(SRCDIR)/state_tracker/st_cb_xformfb.c \ - $(SRCDIR)/state_tracker/st_context.c \ - $(SRCDIR)/state_tracker/st_debug.c \ - $(SRCDIR)/state_tracker/st_draw.c \ - $(SRCDIR)/state_tracker/st_draw_feedback.c \ - $(SRCDIR)/state_tracker/st_extensions.c \ - $(SRCDIR)/state_tracker/st_format.c \ - $(SRCDIR)/state_tracker/st_gen_mipmap.c \ - $(SRCDIR)/state_tracker/st_manager.c \ - $(SRCDIR)/state_tracker/st_mesa_to_tgsi.c \ - $(SRCDIR)/state_tracker/st_program.c \ - $(SRCDIR)/state_tracker/st_texture.c + $(SRCDIR)state_tracker/st_atom.c \ + $(SRCDIR)state_tracker/st_atom_array.c \ + $(SRCDIR)state_tracker/st_atom_blend.c \ + $(SRCDIR)state_tracker/st_atom_clip.c \ + $(SRCDIR)state_tracker/st_atom_constbuf.c \ + $(SRCDIR)state_tracker/st_atom_depth.c \ + $(SRCDIR)state_tracker/st_atom_framebuffer.c \ + $(SRCDIR)state_tracker/st_atom_msaa.c \ + $(SRCDIR)state_tracker/st_atom_pixeltransfer.c \ + $(SRCDIR)state_tracker/st_atom_sampler.c \ + $(SRCDIR)state_tracker/st_atom_scissor.c \ + $(SRCDIR)state_tracker/st_atom_shader.c \ + $(SRCDIR)state_tracker/st_atom_rasterizer.c \ + $(SRCDIR)state_tracker/st_atom_stipple.c \ + $(SRCDIR)state_tracker/st_atom_texture.c \ + $(SRCDIR)state_tracker/st_atom_viewport.c \ + $(SRCDIR)state_tracker/st_cb_bitmap.c \ + $(SRCDIR)state_tracker/st_cb_blit.c \ + $(SRCDIR)state_tracker/st_cb_bufferobjects.c \ + $(SRCDIR)state_tracker/st_cb_clear.c \ + $(SRCDIR)state_tracker/st_cb_condrender.c \ + $(SRCDIR)state_tracker/st_cb_flush.c \ + $(SRCDIR)state_tracker/st_cb_drawpixels.c \ + $(SRCDIR)state_tracker/st_cb_drawtex.c \ + $(SRCDIR)state_tracker/st_cb_eglimage.c \ + $(SRCDIR)state_tracker/st_cb_fbo.c \ + $(SRCDIR)state_tracker/st_cb_feedback.c \ + $(SRCDIR)state_tracker/st_cb_program.c \ + $(SRCDIR)state_tracker/st_cb_queryobj.c \ + $(SRCDIR)state_tracker/st_cb_rasterpos.c \ + $(SRCDIR)state_tracker/st_cb_readpixels.c \ + $(SRCDIR)state_tracker/st_cb_syncobj.c \ + $(SRCDIR)state_tracker/st_cb_strings.c \ + $(SRCDIR)state_tracker/st_cb_texture.c \ + $(SRCDIR)state_tracker/st_cb_texturebarrier.c \ + $(SRCDIR)state_tracker/st_cb_viewport.c \ + $(SRCDIR)state_tracker/st_cb_xformfb.c \ + $(SRCDIR)state_tracker/st_context.c \ + $(SRCDIR)state_tracker/st_debug.c \ + $(SRCDIR)state_tracker/st_draw.c \ + $(SRCDIR)state_tracker/st_draw_feedback.c \ + $(SRCDIR)state_tracker/st_extensions.c \ + $(SRCDIR)state_tracker/st_format.c \ + $(SRCDIR)state_tracker/st_gen_mipmap.c \ + $(SRCDIR)state_tracker/st_manager.c \ + $(SRCDIR)state_tracker/st_mesa_to_tgsi.c \ + $(SRCDIR)state_tracker/st_program.c \ + $(SRCDIR)state_tracker/st_texture.c PROGRAM_FILES = \ - $(SRCDIR)/program/arbprogparse.c \ - $(SRCDIR)/program/hash_table.c \ - $(SRCDIR)/program/lex.yy.c \ - $(SRCDIR)/program/nvfragparse.c \ - $(SRCDIR)/program/nvvertparse.c \ - $(SRCDIR)/program/program.c \ - $(SRCDIR)/program/program_parse.tab.c \ - $(SRCDIR)/program/program_parse_extra.c \ - $(SRCDIR)/program/prog_cache.c \ - $(SRCDIR)/program/prog_execute.c \ - $(SRCDIR)/program/prog_instruction.c \ - $(SRCDIR)/program/prog_noise.c \ - $(SRCDIR)/program/prog_optimize.c \ - $(SRCDIR)/program/prog_opt_constant_fold.c \ - $(SRCDIR)/program/prog_parameter.c \ - $(SRCDIR)/program/prog_parameter_layout.c \ - $(SRCDIR)/program/prog_print.c \ - $(SRCDIR)/program/prog_statevars.c \ - $(SRCDIR)/program/programopt.c \ - $(SRCDIR)/program/register_allocate.c \ - $(SRCDIR)/program/symbol_table.c + $(SRCDIR)program/arbprogparse.c \ + $(SRCDIR)program/hash_table.c \ + $(SRCDIR)program/lex.yy.c \ + $(SRCDIR)program/nvfragparse.c \ + $(SRCDIR)program/nvvertparse.c \ + $(SRCDIR)program/program.c \ + $(SRCDIR)program/program_parse.tab.c \ + $(SRCDIR)program/program_parse_extra.c \ + $(SRCDIR)program/prog_cache.c \ + $(SRCDIR)program/prog_execute.c \ + $(SRCDIR)program/prog_instruction.c \ + $(SRCDIR)program/prog_noise.c \ + $(SRCDIR)program/prog_optimize.c \ + $(SRCDIR)program/prog_opt_constant_fold.c \ + $(SRCDIR)program/prog_parameter.c \ + $(SRCDIR)program/prog_parameter_layout.c \ + $(SRCDIR)program/prog_print.c \ + $(SRCDIR)program/prog_statevars.c \ + $(SRCDIR)program/programopt.c \ + $(SRCDIR)program/register_allocate.c \ + $(SRCDIR)program/symbol_table.c SHADER_CXX_FILES = \ - $(SRCDIR)/program/ir_to_mesa.cpp \ - $(SRCDIR)/program/sampler.cpp \ - $(SRCDIR)/program/string_to_uint_map.cpp + $(SRCDIR)program/ir_to_mesa.cpp \ + $(SRCDIR)program/sampler.cpp \ + $(SRCDIR)program/string_to_uint_map.cpp ASM_C_FILES = \ - $(SRCDIR)/x86/common_x86.c \ - $(SRCDIR)/x86/x86_xform.c \ - $(SRCDIR)/x86/3dnow.c \ - $(SRCDIR)/x86/sse.c \ - $(SRCDIR)/x86/rtasm/x86sse.c \ - $(SRCDIR)/sparc/sparc.c \ - $(SRCDIR)/x86-64/x86-64.c + $(SRCDIR)x86/common_x86.c \ + $(SRCDIR)x86/x86_xform.c \ + $(SRCDIR)x86/3dnow.c \ + $(SRCDIR)x86/sse.c \ + $(SRCDIR)x86/rtasm/x86sse.c \ + $(SRCDIR)sparc/sparc.c \ + $(SRCDIR)x86-64/x86-64.c X86_FILES = \ - $(SRCDIR)/x86/common_x86_asm.S \ - $(SRCDIR)/x86/x86_xform2.S \ - $(SRCDIR)/x86/x86_xform3.S \ - $(SRCDIR)/x86/x86_xform4.S \ - $(SRCDIR)/x86/x86_cliptest.S \ - $(SRCDIR)/x86/mmx_blend.S \ - $(SRCDIR)/x86/3dnow_xform1.S \ - $(SRCDIR)/x86/3dnow_xform2.S \ - $(SRCDIR)/x86/3dnow_xform3.S \ - $(SRCDIR)/x86/3dnow_xform4.S \ - $(SRCDIR)/x86/3dnow_normal.S \ - $(SRCDIR)/x86/sse_xform1.S \ - $(SRCDIR)/x86/sse_xform2.S \ - $(SRCDIR)/x86/sse_xform3.S \ - $(SRCDIR)/x86/sse_xform4.S \ - $(SRCDIR)/x86/sse_normal.S \ - $(SRCDIR)/x86/read_rgba_span_x86.S + $(SRCDIR)x86/common_x86_asm.S \ + $(SRCDIR)x86/x86_xform2.S \ + $(SRCDIR)x86/x86_xform3.S \ + $(SRCDIR)x86/x86_xform4.S \ + $(SRCDIR)x86/x86_cliptest.S \ + $(SRCDIR)x86/mmx_blend.S \ + $(SRCDIR)x86/3dnow_xform1.S \ + $(SRCDIR)x86/3dnow_xform2.S \ + $(SRCDIR)x86/3dnow_xform3.S \ + $(SRCDIR)x86/3dnow_xform4.S \ + $(SRCDIR)x86/3dnow_normal.S \ + $(SRCDIR)x86/sse_xform1.S \ + $(SRCDIR)x86/sse_xform2.S \ + $(SRCDIR)x86/sse_xform3.S \ + $(SRCDIR)x86/sse_xform4.S \ + $(SRCDIR)x86/sse_normal.S \ + $(SRCDIR)x86/read_rgba_span_x86.S X86_64_FILES = \ - $(SRCDIR)/x86-64/xform4.S + $(SRCDIR)x86-64/xform4.S SPARC_FILES = \ - $(SRCDIR)/sparc/sparc_clip.S \ - $(SRCDIR)/sparc/norm.S \ - $(SRCDIR)/sparc/xform.S + $(SRCDIR)sparc/sparc_clip.S \ + $(SRCDIR)sparc/norm.S \ + $(SRCDIR)sparc/xform.S COMMON_DRIVER_FILES = \ - $(SRCDIR)/drivers/common/driverfuncs.c \ - $(SRCDIR)/drivers/common/meta.c + $(SRCDIR)drivers/common/driverfuncs.c \ + $(SRCDIR)drivers/common/meta.c # Sources for building non-Gallium drivers @@ -340,11 +342,11 @@ MESA_GALLIUM_FILES = \ $(VBO_FILES) \ $(STATETRACKER_FILES) \ $(PROGRAM_FILES) \ - $(SRCDIR)/x86/common_x86.c + $(SRCDIR)x86/common_x86.c MESA_GALLIUM_CXX_FILES = \ $(MESA_CXX_FILES) \ - $(SRCDIR)/state_tracker/st_glsl_to_tgsi.cpp + $(SRCDIR)state_tracker/st_glsl_to_tgsi.cpp # All the core C sources, for dependency checking ALL_FILES = \ diff --git a/mesalib/src/mesa/state_tracker/st_atom_array.c b/mesalib/src/mesa/state_tracker/st_atom_array.c index d60b0d7a9..ab46f1188 100644 --- a/mesalib/src/mesa/state_tracker/st_atom_array.c +++ b/mesalib/src/mesa/state_tracker/st_atom_array.c @@ -1,3 +1,4 @@ + /************************************************************************** * * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas. @@ -45,7 +46,7 @@ #include "util/u_math.h" #include "main/bufferobj.h" -#include "main/image.h" +#include "main/glformats.h" static GLuint double_types[4] = { diff --git a/mesalib/src/mesa/state_tracker/st_atom_clip.c b/mesalib/src/mesa/state_tracker/st_atom_clip.c index 2a5110098..a1a7e003a 100644 --- a/mesalib/src/mesa/state_tracker/st_atom_clip.c +++ b/mesalib/src/mesa/state_tracker/st_atom_clip.c @@ -47,7 +47,7 @@ static void update_clip( struct st_context *st ) const struct gl_context *ctx = st->ctx; bool use_eye = FALSE; - assert(sizeof(clip.ucp) <= sizeof(ctx->Transform._ClipUserPlane)); + STATIC_ASSERT(sizeof(clip.ucp) <= sizeof(ctx->Transform._ClipUserPlane)); /* if we have a vertex shader that writes clip vertex we need to pass the pre-projection transformed coordinates into the driver. */ diff --git a/mesalib/src/mesa/state_tracker/st_atom_depth.c b/mesalib/src/mesa/state_tracker/st_atom_depth.c index 6c51b1ac1..c76a6d8c6 100644 --- a/mesalib/src/mesa/state_tracker/st_atom_depth.c +++ b/mesalib/src/mesa/state_tracker/st_atom_depth.c @@ -49,14 +49,14 @@ GLuint st_compare_func_to_pipe(GLenum func) { /* Same values, just biased */ - assert(PIPE_FUNC_NEVER == GL_NEVER - GL_NEVER); - assert(PIPE_FUNC_LESS == GL_LESS - GL_NEVER); - assert(PIPE_FUNC_EQUAL == GL_EQUAL - GL_NEVER); - assert(PIPE_FUNC_LEQUAL == GL_LEQUAL - GL_NEVER); - assert(PIPE_FUNC_GREATER == GL_GREATER - GL_NEVER); - assert(PIPE_FUNC_NOTEQUAL == GL_NOTEQUAL - GL_NEVER); - assert(PIPE_FUNC_GEQUAL == GL_GEQUAL - GL_NEVER); - assert(PIPE_FUNC_ALWAYS == GL_ALWAYS - GL_NEVER); + STATIC_ASSERT(PIPE_FUNC_NEVER == GL_NEVER - GL_NEVER); + STATIC_ASSERT(PIPE_FUNC_LESS == GL_LESS - GL_NEVER); + STATIC_ASSERT(PIPE_FUNC_EQUAL == GL_EQUAL - GL_NEVER); + STATIC_ASSERT(PIPE_FUNC_LEQUAL == GL_LEQUAL - GL_NEVER); + STATIC_ASSERT(PIPE_FUNC_GREATER == GL_GREATER - GL_NEVER); + STATIC_ASSERT(PIPE_FUNC_NOTEQUAL == GL_NOTEQUAL - GL_NEVER); + STATIC_ASSERT(PIPE_FUNC_GEQUAL == GL_GEQUAL - GL_NEVER); + STATIC_ASSERT(PIPE_FUNC_ALWAYS == GL_ALWAYS - GL_NEVER); assert(func >= GL_NEVER); assert(func <= GL_ALWAYS); return func - GL_NEVER; diff --git a/mesalib/src/mesa/state_tracker/st_atom_framebuffer.c b/mesalib/src/mesa/state_tracker/st_atom_framebuffer.c index a8907c157..a10dbfbd0 100644 --- a/mesalib/src/mesa/state_tracker/st_atom_framebuffer.c +++ b/mesalib/src/mesa/state_tracker/st_atom_framebuffer.c @@ -33,6 +33,7 @@ #include "st_context.h" #include "st_atom.h" +#include "st_cb_bitmap.h" #include "st_cb_fbo.h" #include "st_texture.h" #include "pipe/p_context.h" @@ -52,7 +53,7 @@ update_renderbuffer_surface(struct st_context *st, struct st_renderbuffer *strb) { struct pipe_context *pipe = st->pipe; - struct pipe_resource *resource = strb->rtt->pt; + struct pipe_resource *resource = strb->rtt ? strb->rtt->pt : strb->texture; int rtt_width = strb->Base.Width; int rtt_height = strb->Base.Height; enum pipe_format format = st->ctx->Color.sRGBEnabled ? resource->format : util_format_linear(resource->format); @@ -103,6 +104,9 @@ update_framebuffer_state( struct st_context *st ) struct st_renderbuffer *strb; GLuint i; + st_flush_bitmap_cache(st); + + st->state.fb_orientation = st_fb_orientation(fb); framebuffer->width = fb->Width; framebuffer->height = fb->Height; @@ -117,7 +121,8 @@ update_framebuffer_state( struct st_context *st ) if (strb) { /*printf("--------- framebuffer surface rtt %p\n", strb->rtt);*/ - if (strb->rtt) { + if (strb->rtt || + (strb->texture && util_format_is_srgb(strb->texture->format))) { /* rendering to a GL texture, may have to update surface */ update_renderbuffer_surface(st, strb); } diff --git a/mesalib/src/mesa/state_tracker/st_cb_bitmap.c b/mesalib/src/mesa/state_tracker/st_cb_bitmap.c index 09152c79a..c26058874 100644 --- a/mesalib/src/mesa/state_tracker/st_cb_bitmap.c +++ b/mesalib/src/mesa/state_tracker/st_cb_bitmap.c @@ -335,9 +335,8 @@ setup_bitmap_vertex_data(struct st_context *st, bool normalized, struct pipe_resource **vbuf, unsigned *vbuf_offset) { - const struct gl_framebuffer *fb = st->ctx->DrawBuffer; - const GLfloat fb_width = (GLfloat)fb->Width; - const GLfloat fb_height = (GLfloat)fb->Height; + const GLfloat fb_width = (GLfloat)st->state.framebuffer.width; + const GLfloat fb_height = (GLfloat)st->state.framebuffer.height; const GLfloat x0 = (GLfloat)x; const GLfloat x1 = (GLfloat)(x + width); const GLfloat y0 = (GLfloat)y; @@ -502,10 +501,9 @@ draw_bitmap_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z, /* viewport state: viewport matching window dims */ { - const struct gl_framebuffer *fb = st->ctx->DrawBuffer; - const GLboolean invert = (st_fb_orientation(fb) == Y_0_TOP); - const GLfloat width = (GLfloat)fb->Width; - const GLfloat height = (GLfloat)fb->Height; + const GLboolean invert = st->state.fb_orientation == Y_0_TOP; + const GLfloat width = (GLfloat)st->state.framebuffer.width; + const GLfloat height = (GLfloat)st->state.framebuffer.height; struct pipe_viewport_state vp; vp.scale[0] = 0.5f * width; vp.scale[1] = height * (invert ? -0.5f : 0.5f); @@ -636,43 +634,41 @@ st_flush_bitmap_cache(struct st_context *st) if (!st->bitmap.cache->empty) { struct bitmap_cache *cache = st->bitmap.cache; - if (st->ctx->DrawBuffer) { - struct pipe_context *pipe = st->pipe; - struct pipe_sampler_view *sv; + struct pipe_context *pipe = st->pipe; + struct pipe_sampler_view *sv; - assert(cache->xmin <= cache->xmax); - -/* printf("flush size %d x %d at %d, %d\n", - cache->xmax - cache->xmin, - cache->ymax - cache->ymin, - cache->xpos, cache->ypos); + assert(cache->xmin <= cache->xmax); + +/* printf("flush size %d x %d at %d, %d\n", + cache->xmax - cache->xmin, + cache->ymax - cache->ymin, + cache->xpos, cache->ypos); */ - /* The texture transfer has been mapped until now. + /* The texture transfer has been mapped until now. * So unmap and release the texture transfer before drawing. */ - if (cache->trans) { - if (0) - print_cache(cache); - pipe_transfer_unmap(pipe, cache->trans); - cache->buffer = NULL; - - pipe->transfer_destroy(pipe, cache->trans); - cache->trans = NULL; - } - - sv = st_create_texture_sampler_view(st->pipe, cache->texture); - if (sv) { - draw_bitmap_quad(st->ctx, - cache->xpos, - cache->ypos, - cache->zpos, - BITMAP_CACHE_WIDTH, BITMAP_CACHE_HEIGHT, - sv, - cache->color); - - pipe_sampler_view_reference(&sv, NULL); - } + if (cache->trans) { + if (0) + print_cache(cache); + pipe_transfer_unmap(pipe, cache->trans); + cache->buffer = NULL; + + pipe->transfer_destroy(pipe, cache->trans); + cache->trans = NULL; + } + + sv = st_create_texture_sampler_view(st->pipe, cache->texture); + if (sv) { + draw_bitmap_quad(st->ctx, + cache->xpos, + cache->ypos, + cache->zpos, + BITMAP_CACHE_WIDTH, BITMAP_CACHE_HEIGHT, + sv, + cache->color); + + pipe_sampler_view_reference(&sv, NULL); } /* release/free the texture */ @@ -684,16 +680,6 @@ st_flush_bitmap_cache(struct st_context *st) /** - * Flush bitmap cache. - */ -void -st_flush_bitmap( struct st_context *st ) -{ - st_flush_bitmap_cache(st); -} - - -/** * Try to accumulate this glBitmap call in the bitmap cache. * \return GL_TRUE for success, GL_FALSE if bitmap is too large, etc. */ diff --git a/mesalib/src/mesa/state_tracker/st_cb_bitmap.h b/mesalib/src/mesa/state_tracker/st_cb_bitmap.h index ed1415803..25410e503 100644 --- a/mesalib/src/mesa/state_tracker/st_cb_bitmap.h +++ b/mesalib/src/mesa/state_tracker/st_cb_bitmap.h @@ -58,12 +58,6 @@ st_make_bitmap_fragment_program(struct st_context *st, extern void st_flush_bitmap_cache(struct st_context *st); -/* Flush bitmap cache and release vertex buffer. Needed at end of - * frame to avoid synchronous rendering. - */ -extern void -st_flush_bitmap(struct st_context *st); - #else static INLINE void diff --git a/mesalib/src/mesa/state_tracker/st_cb_blit.c b/mesalib/src/mesa/state_tracker/st_cb_blit.c index 1486779fd..b189cb406 100644 --- a/mesalib/src/mesa/state_tracker/st_cb_blit.c +++ b/mesalib/src/mesa/state_tracker/st_cb_blit.c @@ -80,9 +80,8 @@ st_BlitFramebuffer_resolve(struct gl_context *ctx, info->src.res = srcRb->texture; info->src.layer = srcRb->surface->u.tex.first_layer; - info->dst.res = dstRb->texture; - info->dst.level = dstRb->surface->u.tex.level; - info->dst.layer = dstRb->surface->u.tex.first_layer; + + info->dst.surface = dstRb->surface; st->pipe->resource_resolve(st->pipe, info); } @@ -114,9 +113,8 @@ st_BlitFramebuffer_resolve(struct gl_context *ctx, info->src.res = srcRb->texture; info->src.layer = srcRb->surface->u.tex.first_layer; - info->dst.res = dstRb->texture; - info->dst.level = dstRb->surface->u.tex.level; - info->dst.layer = dstRb->surface->u.tex.first_layer; + + info->dst.surface = dstRb->surface; st->pipe->resource_resolve(st->pipe, info); } @@ -130,9 +128,8 @@ st_BlitFramebuffer_resolve(struct gl_context *ctx, info->src.res = srcRb->texture; info->src.layer = srcRb->surface->u.tex.first_layer; - info->dst.res = dstRb->texture; - info->dst.level = dstRb->surface->u.tex.level; - info->dst.layer = dstRb->surface->u.tex.first_layer; + + info->dst.surface = dstRb->surface; st->pipe->resource_resolve(st->pipe, info); } diff --git a/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c b/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c index c5f36316b..f288a9632 100644 --- a/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c +++ b/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c @@ -43,6 +43,7 @@ #include "main/texformat.h" #include "main/teximage.h" #include "main/texstore.h" +#include "main/glformats.h" #include "program/program.h" #include "program/prog_print.h" #include "program/prog_instruction.h" @@ -368,7 +369,7 @@ internal_format(struct gl_context *ctx, GLenum format, GLenum type) return GL_STENCIL_INDEX; default: - if (_mesa_is_integer_format(format)) { + if (_mesa_is_enum_format_integer(format)) { switch (type) { case GL_BYTE: return GL_RGBA8I; diff --git a/mesalib/src/mesa/state_tracker/st_cb_fbo.c b/mesalib/src/mesa/state_tracker/st_cb_fbo.c index e1818abb9..7eef5c659 100644 --- a/mesalib/src/mesa/state_tracker/st_cb_fbo.c +++ b/mesalib/src/mesa/state_tracker/st_cb_fbo.c @@ -291,13 +291,21 @@ st_new_renderbuffer_fb(enum pipe_format format, int samples, boolean sw) case PIPE_FORMAT_R8G8B8A8_UNORM: case PIPE_FORMAT_B8G8R8A8_UNORM: case PIPE_FORMAT_A8R8G8B8_UNORM: + strb->Base.InternalFormat = GL_RGBA8; + break; case PIPE_FORMAT_R8G8B8X8_UNORM: case PIPE_FORMAT_B8G8R8X8_UNORM: case PIPE_FORMAT_X8R8G8B8_UNORM: + strb->Base.InternalFormat = GL_RGB8; + break; case PIPE_FORMAT_B5G5R5A1_UNORM: + strb->Base.InternalFormat = GL_RGB5_A1; + break; case PIPE_FORMAT_B4G4R4A4_UNORM: + strb->Base.InternalFormat = GL_RGBA4; + break; case PIPE_FORMAT_B5G6R5_UNORM: - strb->Base.InternalFormat = GL_RGBA; + strb->Base.InternalFormat = GL_RGB565; break; case PIPE_FORMAT_Z16_UNORM: strb->Base.InternalFormat = GL_DEPTH_COMPONENT16; diff --git a/mesalib/src/mesa/state_tracker/st_cb_flush.c b/mesalib/src/mesa/state_tracker/st_cb_flush.c index 4e40a93f5..b4372ae7c 100644 --- a/mesalib/src/mesa/state_tracker/st_cb_flush.c +++ b/mesalib/src/mesa/state_tracker/st_cb_flush.c @@ -81,7 +81,7 @@ void st_flush( struct st_context *st, { FLUSH_CURRENT(st->ctx, 0); - st_flush_bitmap(st); + st_flush_bitmap_cache(st); st->pipe->flush( st->pipe, fence ); } diff --git a/mesalib/src/mesa/state_tracker/st_cb_viewport.c b/mesalib/src/mesa/state_tracker/st_cb_viewport.c index d4742eb89..d654ed6e7 100644 --- a/mesalib/src/mesa/state_tracker/st_cb_viewport.c +++ b/mesalib/src/mesa/state_tracker/st_cb_viewport.c @@ -43,7 +43,9 @@ static INLINE struct st_framebuffer * st_ws_framebuffer(struct gl_framebuffer *fb) { /* FBO cannot be casted. See st_new_framebuffer */ - return (struct st_framebuffer *) ((fb && !fb->Name) ? fb : NULL); + if (fb && _mesa_is_winsys_fbo(fb)) + return (struct st_framebuffer *) fb; + return NULL; } static void st_viewport(struct gl_context * ctx, GLint x, GLint y, diff --git a/mesalib/src/mesa/state_tracker/st_context.c b/mesalib/src/mesa/state_tracker/st_context.c index 117ea90f8..6b7c047ed 100644 --- a/mesalib/src/mesa/state_tracker/st_context.c +++ b/mesalib/src/mesa/state_tracker/st_context.c @@ -211,9 +211,9 @@ struct st_context *st_create_context(gl_api api, struct pipe_context *pipe, struct dd_function_table funcs; /* Sanity checks */ - assert(MESA_SHADER_VERTEX == PIPE_SHADER_VERTEX); - assert(MESA_SHADER_FRAGMENT == PIPE_SHADER_FRAGMENT); - assert(MESA_SHADER_GEOMETRY == PIPE_SHADER_GEOMETRY); + STATIC_ASSERT(MESA_SHADER_VERTEX == PIPE_SHADER_VERTEX); + STATIC_ASSERT(MESA_SHADER_FRAGMENT == PIPE_SHADER_FRAGMENT); + STATIC_ASSERT(MESA_SHADER_GEOMETRY == PIPE_SHADER_GEOMETRY); memset(&funcs, 0, sizeof(funcs)); st_init_driver_functions(&funcs); diff --git a/mesalib/src/mesa/state_tracker/st_context.h b/mesalib/src/mesa/state_tracker/st_context.h index a3f44b3ab..cdac5a1c7 100644 --- a/mesalib/src/mesa/state_tracker/st_context.h +++ b/mesalib/src/mesa/state_tracker/st_context.h @@ -31,6 +31,7 @@ #include "main/mtypes.h" #include "pipe/p_state.h" #include "state_tracker/st_api.h" +#include "main/fbobject.h" struct bitmap_cache; struct blit_state; @@ -117,6 +118,8 @@ struct st_context GLuint num_vertex_textures; GLuint poly_stipple[32]; /**< In OpenGL's bottom-to-top order */ + + GLuint fb_orientation; } state; char vendor[100]; @@ -236,7 +239,7 @@ void st_invalidate_state(struct gl_context * ctx, GLuint new_state); static INLINE GLuint st_fb_orientation(const struct gl_framebuffer *fb) { - if (fb && fb->Name == 0) { + if (fb && _mesa_is_winsys_fbo(fb)) { /* Drawing into a window (on-screen buffer). * * Negate Y scale to flip image vertically. diff --git a/mesalib/src/mesa/state_tracker/st_draw.c b/mesalib/src/mesa/state_tracker/st_draw.c index 4dc09e7fb..9dc4822cc 100644 --- a/mesalib/src/mesa/state_tracker/st_draw.c +++ b/mesalib/src/mesa/state_tracker/st_draw.c @@ -153,9 +153,9 @@ static unsigned translate_prim(const struct gl_context *ctx, unsigned prim) { /* GL prims should match Gallium prims, spot-check a few */ - assert(GL_POINTS == PIPE_PRIM_POINTS); - assert(GL_QUADS == PIPE_PRIM_QUADS); - assert(GL_TRIANGLE_STRIP_ADJACENCY == PIPE_PRIM_TRIANGLE_STRIP_ADJACENCY); + STATIC_ASSERT(GL_POINTS == PIPE_PRIM_POINTS); + STATIC_ASSERT(GL_QUADS == PIPE_PRIM_QUADS); + STATIC_ASSERT(GL_TRIANGLE_STRIP_ADJACENCY == PIPE_PRIM_TRIANGLE_STRIP_ADJACENCY); /* Avoid quadstrips if it's easy to do so: * Note: it's important to do the correct trimming if we change the diff --git a/mesalib/src/mesa/state_tracker/st_format.c b/mesalib/src/mesa/state_tracker/st_format.c index 57d34411f..962b09250 100644 --- a/mesalib/src/mesa/state_tracker/st_format.c +++ b/mesalib/src/mesa/state_tracker/st_format.c @@ -34,6 +34,7 @@ #include "main/imports.h" #include "main/context.h" +#include "main/glformats.h" #include "main/texstore.h" #include "main/image.h" #include "main/macros.h" diff --git a/mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.cpp b/mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.cpp index 1d91e3661..fcd69b18d 100644 --- a/mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.cpp +++ b/mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.cpp @@ -1448,9 +1448,29 @@ glsl_to_tgsi_visitor::visit(ir_expression *ir) emit(ir, TGSI_OPCODE_DDX, result_dst, op[0]); break; case ir_unop_dFdy: - op[0].negate = ~op[0].negate; - emit(ir, TGSI_OPCODE_DDY, result_dst, op[0]); + { + /* The X component contains 1 or -1 depending on whether the framebuffer + * is a FBO or the window system buffer, respectively. + * It is then multiplied with the source operand of DDY. + */ + static const gl_state_index transform_y_state[STATE_LENGTH] + = { STATE_INTERNAL, STATE_FB_WPOS_Y_TRANSFORM }; + + unsigned transform_y_index = + _mesa_add_state_reference(this->prog->Parameters, + transform_y_state); + + st_src_reg transform_y = st_src_reg(PROGRAM_STATE_VAR, + transform_y_index, + glsl_type::vec4_type); + transform_y.swizzle = SWIZZLE_XXXX; + + st_src_reg temp = get_temp(glsl_type::vec4_type); + + emit(ir, TGSI_OPCODE_MUL, st_dst_reg(temp), transform_y, op[0]); + emit(ir, TGSI_OPCODE_DDY, result_dst, temp); break; + } case ir_unop_noise: { /* At some point, a motivated person could add a better @@ -2758,8 +2778,6 @@ glsl_to_tgsi_visitor::visit(ir_return *ir) void glsl_to_tgsi_visitor::visit(ir_discard *ir) { - struct gl_fragment_program *fp = (struct gl_fragment_program *)this->prog; - if (ir->condition) { ir->condition->accept(this); this->result.negate = ~this->result.negate; @@ -2767,8 +2785,6 @@ glsl_to_tgsi_visitor::visit(ir_discard *ir) } else { emit(ir, TGSI_OPCODE_KILP); } - - fp->UsesKill = GL_TRUE; } void @@ -2893,13 +2909,15 @@ set_uniform_initializer(struct gl_context *ctx, void *mem_ctx, return; } - int loc = _mesa_get_uniform_location(ctx, shader_program, name); - - if (loc == -1) { + unsigned offset; + unsigned index = _mesa_get_uniform_location(ctx, shader_program, name, + &offset); + if (offset == GL_INVALID_INDEX) { fail_link(shader_program, "Couldn't find uniform for initializer %s\n", name); return; } + int loc = _mesa_uniform_merge_location_offset(index, offset); for (unsigned int i = 0; i < (type->is_array() ? type->length : 1); i++) { ir_constant *element; @@ -4483,6 +4501,7 @@ st_translate_program( const ubyte inputSemanticName[], const ubyte inputSemanticIndex[], const GLuint interpMode[], + const GLboolean is_centroid[], GLuint numOutputs, const GLuint outputMapping[], const ubyte outputSemanticName[], @@ -4524,10 +4543,11 @@ st_translate_program( */ if (procType == TGSI_PROCESSOR_FRAGMENT) { for (i = 0; i < numInputs; i++) { - t->inputs[i] = ureg_DECL_fs_input(ureg, - inputSemanticName[i], - inputSemanticIndex[i], - interpMode[i]); + t->inputs[i] = ureg_DECL_fs_input_cyl_centroid(ureg, + inputSemanticName[i], + inputSemanticIndex[i], + interpMode[i], 0, + is_centroid[i]); } if (proginfo->InputsRead & FRAG_BIT_WPOS) { diff --git a/mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.h b/mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.h index 55d59d571..a3fe91f7e 100644 --- a/mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.h +++ b/mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.h @@ -45,6 +45,7 @@ enum pipe_error st_translate_program( const ubyte inputSemanticName[], const ubyte inputSemanticIndex[], const GLuint interpMode[], + const GLboolean is_centroid[], GLuint numOutputs, const GLuint outputMapping[], const ubyte outputSemanticName[], diff --git a/mesalib/src/mesa/state_tracker/st_manager.c b/mesalib/src/mesa/state_tracker/st_manager.c index 748624f3d..875e0c44a 100644 --- a/mesalib/src/mesa/state_tracker/st_manager.c +++ b/mesalib/src/mesa/state_tracker/st_manager.c @@ -64,7 +64,9 @@ static INLINE struct st_framebuffer * st_ws_framebuffer(struct gl_framebuffer *fb) { /* FBO cannot be casted. See st_new_framebuffer */ - return (struct st_framebuffer *) ((fb && !fb->Name) ? fb : NULL); + if (fb && _mesa_is_winsys_fbo(fb)) + return (struct st_framebuffer *) fb; + return NULL; } /** diff --git a/mesalib/src/mesa/state_tracker/st_program.c b/mesalib/src/mesa/state_tracker/st_program.c index 9f98298b4..36015f69a 100644 --- a/mesalib/src/mesa/state_tracker/st_program.c +++ b/mesalib/src/mesa/state_tracker/st_program.c @@ -347,6 +347,7 @@ st_translate_vertex_program(struct st_context *st, NULL, /* input semantic name */ NULL, /* input semantic index */ NULL, /* interp mode */ + NULL, /* is centroid */ /* outputs */ stvp->num_outputs, stvp->result_to_output, @@ -484,6 +485,7 @@ st_translate_fragment_program(struct st_context *st, ubyte input_semantic_name[PIPE_MAX_SHADER_INPUTS]; ubyte input_semantic_index[PIPE_MAX_SHADER_INPUTS]; + GLboolean is_centroid[PIPE_MAX_SHADER_INPUTS]; uint fs_num_inputs = 0; ubyte fs_output_semantic_name[PIPE_MAX_SHADER_OUTPUTS]; @@ -537,6 +539,7 @@ st_translate_fragment_program(struct st_context *st, const GLuint slot = fs_num_inputs++; inputMapping[attr] = slot; + is_centroid[slot] = (stfp->Base.IsCentroid & BITFIELD64_BIT(attr)) != 0; switch (attr) { case FRAG_ATTRIB_WPOS: @@ -716,6 +719,7 @@ st_translate_fragment_program(struct st_context *st, input_semantic_name, input_semantic_index, interpMode, + is_centroid, /* outputs */ fs_num_outputs, outputMapping, diff --git a/mesalib/src/mesa/swrast/s_texfetch.c b/mesalib/src/mesa/swrast/s_texfetch.c index 8529ff08d..12ee47963 100644 --- a/mesalib/src/mesa/swrast/s_texfetch.c +++ b/mesalib/src/mesa/swrast/s_texfetch.c @@ -1104,7 +1104,13 @@ texfetch_funcs[MESA_FORMAT_COUNT] = NULL, NULL, NULL - } + }, + { + MESA_FORMAT_ABGR2101010_UINT, + NULL, + NULL, + NULL + }, }; diff --git a/mesalib/src/mesa/tnl/t_rasterpos.c b/mesalib/src/mesa/tnl/t_rasterpos.c index 50b5fcb4c..a28ad0daf 100644 --- a/mesalib/src/mesa/tnl/t_rasterpos.c +++ b/mesalib/src/mesa/tnl/t_rasterpos.c @@ -271,7 +271,7 @@ compute_texgen(struct gl_context *ctx, const GLfloat vObj[4], const GLfloat vEye rz = u[2] - normal[2] * two_nu; m = rx * rx + ry * ry + (rz + 1.0F) * (rz + 1.0F); if (m > 0.0F) - mInv = 0.5F * _mesa_inv_sqrtf(m); + mInv = 0.5F * INV_SQRTF(m); else mInv = 0.0F; diff --git a/mesalib/src/mesa/tnl/t_vb_points.c b/mesalib/src/mesa/tnl/t_vb_points.c index 9edbbc708..0e33b691e 100644 --- a/mesalib/src/mesa/tnl/t_vb_points.c +++ b/mesalib/src/mesa/tnl/t_vb_points.c @@ -64,7 +64,7 @@ run_point_stage(struct gl_context *ctx, struct tnl_pipeline_stage *stage) for (i = 0; i < VB->Count; i++) { const GLfloat dist = FABSF(*eyeCoord); const GLfloat q = p0 + dist * (p1 + dist * p2); - const GLfloat atten = (q != 0.0F) ? SQRTF(1.0F / q) : 1.0F; + const GLfloat atten = (q != 0.0F) ? INV_SQRTF(q) : 1.0F; size[i][0] = pointSize * atten; /* clamping done in rasterization */ eyeCoord += eyeCoordStride; } diff --git a/mesalib/src/mesa/tnl/t_vb_texgen.c b/mesalib/src/mesa/tnl/t_vb_texgen.c index 61430c396..d4c788523 100644 --- a/mesalib/src/mesa/tnl/t_vb_texgen.c +++ b/mesalib/src/mesa/tnl/t_vb_texgen.c @@ -117,7 +117,7 @@ static void build_m3( GLfloat f[][3], GLfloat m[], fz = f[i][2] = u[2] - norm[2] * two_nu; m[i] = fx * fx + fy * fy + (fz + 1.0F) * (fz + 1.0F); if (m[i] != 0.0F) { - m[i] = 0.5F * _mesa_inv_sqrtf(m[i]); + m[i] = 0.5F * INV_SQRTF(m[i]); } } } @@ -146,7 +146,7 @@ static void build_m2( GLfloat f[][3], GLfloat m[], fz = f[i][2] = u[2] - norm[2] * two_nu; m[i] = fx * fx + fy * fy + (fz + 1.0F) * (fz + 1.0F); if (m[i] != 0.0F) { - m[i] = 0.5F * _mesa_inv_sqrtf(m[i]); + m[i] = 0.5F * INV_SQRTF(m[i]); } } } diff --git a/mesalib/src/mesa/vbo/vbo_split_copy.c b/mesalib/src/mesa/vbo/vbo_split_copy.c index 528fcfd7f..a917f39ca 100644 --- a/mesalib/src/mesa/vbo/vbo_split_copy.c +++ b/mesalib/src/mesa/vbo/vbo_split_copy.c @@ -32,7 +32,7 @@ #include "main/glheader.h" #include "main/bufferobj.h" #include "main/imports.h" -#include "main/image.h" +#include "main/glformats.h" #include "main/macros.h" #include "main/mtypes.h" diff --git a/mesalib/src/mesa/vbo/vbo_split_inplace.c b/mesalib/src/mesa/vbo/vbo_split_inplace.c index 686b30a76..8a3830805 100644 --- a/mesalib/src/mesa/vbo/vbo_split_inplace.c +++ b/mesalib/src/mesa/vbo/vbo_split_inplace.c @@ -30,7 +30,7 @@ #include "main/mtypes.h" #include "main/macros.h" #include "main/enums.h" -#include "main/image.h" +#include "main/glformats.h" #include "vbo_split.h" |