From d41bc08d1ae8c4784c09d8977816c0fadab1ba52 Mon Sep 17 00:00:00 2001 From: marha Date: Thu, 17 Nov 2011 16:37:26 +0100 Subject: xserver mesa git update 17 nov 2011 --- mesalib/src/gallium/auxiliary/util/u_draw.c | 214 +- mesalib/src/gallium/auxiliary/util/u_prim.h | 2 +- mesalib/src/glsl/ast_function.cpp | 414 +-- mesalib/src/glsl/glsl_parser.yy | 2 +- mesalib/src/glsl/ir.h | 7 + mesalib/src/glsl/ir_function.cpp | 11 + mesalib/src/glsl/link_uniforms.cpp | 46 +- mesalib/src/glsl/linker.cpp | 44 + mesalib/src/mesa/SConscript | 1 - mesalib/src/mesa/drivers/common/driverfuncs.c | 3 +- mesalib/src/mesa/drivers/common/meta.c | 43 +- mesalib/src/mesa/main/ffvertex_prog.c | 113 +- mesalib/src/mesa/main/format_unpack.c | 1530 ++++++----- mesalib/src/mesa/main/image.c | 71 +- mesalib/src/mesa/main/light.c | 2863 ++++++++++---------- mesalib/src/mesa/main/macros.h | 37 +- mesalib/src/mesa/main/mtypes.h | 22 +- mesalib/src/mesa/main/pack.c | 64 +- mesalib/src/mesa/main/pack.h | 4 +- mesalib/src/mesa/main/pixeltransfer.c | 4 +- mesalib/src/mesa/main/pixeltransfer.h | 2 +- mesalib/src/mesa/main/readpix.c | 496 ++++ mesalib/src/mesa/main/readpix.h | 9 + mesalib/src/mesa/main/renderbuffer.c | 367 --- mesalib/src/mesa/main/renderbuffer.h | 9 - mesalib/src/mesa/main/uniform_query.cpp | 22 +- mesalib/src/mesa/program/ir_to_mesa.cpp | 59 +- mesalib/src/mesa/sources.mak | 1 - mesalib/src/mesa/state_tracker/st_cb_drawpixels.c | 21 +- mesalib/src/mesa/state_tracker/st_cb_fbo.c | 32 +- mesalib/src/mesa/state_tracker/st_cb_readpixels.c | 633 +---- mesalib/src/mesa/state_tracker/st_cb_readpixels.h | 92 +- mesalib/src/mesa/state_tracker/st_draw.c | 6 +- mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.cpp | 53 +- mesalib/src/mesa/state_tracker/st_mesa_to_tgsi.c | 1 + mesalib/src/mesa/swrast/s_copypix.c | 1440 +++++----- mesalib/src/mesa/swrast/s_depth.c | 3 +- mesalib/src/mesa/swrast/s_drawpix.c | 10 +- mesalib/src/mesa/swrast/s_readpix.c | 522 ---- mesalib/src/mesa/swrast/s_stencil.c | 184 +- mesalib/src/mesa/swrast/s_stencil.h | 106 +- mesalib/src/mesa/swrast/s_texrender.c | 13 + mesalib/src/mesa/swrast/s_zoom.c | 4 +- mesalib/src/mesa/swrast/s_zoom.h | 112 +- mesalib/src/mesa/swrast/swrast.h | 7 - xorg-server/Xext/xselinux_ext.c | 7 +- xorg-server/Xi/exevents.c | 8 +- xorg-server/Xi/xiquerypointer.c | 2 +- xorg-server/dix/enterleave.c | 2778 +++++++++---------- xorg-server/dix/events.c | 23 +- xorg-server/dix/getevents.c | 2 +- xorg-server/hw/xfree86/common/xf86DGA.c | 2 +- xorg-server/hw/xfree86/common/xf86Init.c | 2 + xorg-server/hw/xfree86/common/xf86Xinput.c | 2 +- xorg-server/hw/xfree86/modes/xf86Crtc.c | 3 + xorg-server/include/input.h | 4 +- xorg-server/xkb/xkbActions.c | 2 +- 57 files changed, 5898 insertions(+), 6636 deletions(-) delete mode 100644 mesalib/src/mesa/swrast/s_readpix.c diff --git a/mesalib/src/gallium/auxiliary/util/u_draw.c b/mesalib/src/gallium/auxiliary/util/u_draw.c index 4f2565edb..d16575b73 100644 --- a/mesalib/src/gallium/auxiliary/util/u_draw.c +++ b/mesalib/src/gallium/auxiliary/util/u_draw.c @@ -1,99 +1,115 @@ -/************************************************************************** - * - * Copyright 2011 VMware, Inc. - * All Rights Reserved. - * - * 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, sub license, 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 (including the - * next paragraph) 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 NON-INFRINGEMENT. - * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS 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 "util/u_debug.h" -#include "util/u_math.h" -#include "util/u_format.h" -#include "util/u_draw.h" - - -/** - * Returns the largest legal index value for the current set of bound vertex - * buffers. Regardless of any other consideration, all vertex lookups need to - * be clamped to 0..max_index to prevent an out-of-bound access. - */ -unsigned -util_draw_max_index( - const struct pipe_vertex_buffer *vertex_buffers, - unsigned nr_vertex_buffers, - const struct pipe_vertex_element *vertex_elements, - unsigned nr_vertex_elements, - const struct pipe_draw_info *info) -{ - unsigned max_index; - unsigned i; - - max_index = ~0; - for (i = 0; i < nr_vertex_elements; i++) { - const struct pipe_vertex_element *element = - &vertex_elements[i]; - const struct pipe_vertex_buffer *buffer = - &vertex_buffers[element->vertex_buffer_index]; - unsigned buffer_size; - const struct util_format_description *format_desc; - unsigned format_size; - - assert(buffer->buffer->height0 == 1); - assert(buffer->buffer->depth0 == 1); - buffer_size = buffer->buffer->width0; - - format_desc = util_format_description(element->src_format); - assert(format_desc->block.width == 1); - assert(format_desc->block.height == 1); - assert(format_desc->block.bits % 8 == 0); - format_size = format_desc->block.bits/8; - - assert(buffer_size - buffer->buffer_offset <= buffer_size); - buffer_size -= buffer->buffer_offset; - - assert(buffer_size - element->src_offset <= buffer_size); - buffer_size -= element->src_offset; - - assert(buffer_size - format_size <= buffer_size); - buffer_size -= format_size; - - if (buffer->stride != 0) { - unsigned buffer_max_index; - - buffer_max_index = buffer_size / buffer->stride; - - if (element->instance_divisor == 0) { - /* Per-vertex data */ - max_index = MIN2(max_index, buffer_max_index); - } - else { - /* Per-instance data. Simply make sure the state tracker didn't - * request more instances than those that fit in the buffer */ - assert((info->start_instance + info->instance_count)/element->instance_divisor - <= (buffer_max_index + 1)); - } - } - } - - return max_index; -} +/************************************************************************** + * + * Copyright 2011 VMware, Inc. + * All Rights Reserved. + * + * 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, sub license, 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 (including the + * next paragraph) 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 NON-INFRINGEMENT. + * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS 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 "util/u_debug.h" +#include "util/u_math.h" +#include "util/u_format.h" +#include "util/u_draw.h" + + +/** + * Returns the largest legal index value plus one for the current set + * of bound vertex buffers. Regardless of any other consideration, + * all vertex lookups need to be clamped to 0..max_index-1 to prevent + * an out-of-bound access. + * + * Note that if zero is returned it means that one or more buffers is + * too small to contain any valid vertex data. + */ +unsigned +util_draw_max_index( + const struct pipe_vertex_buffer *vertex_buffers, + unsigned nr_vertex_buffers, + const struct pipe_vertex_element *vertex_elements, + unsigned nr_vertex_elements, + const struct pipe_draw_info *info) +{ + unsigned max_index; + unsigned i; + + max_index = ~0U - 1; + for (i = 0; i < nr_vertex_elements; i++) { + const struct pipe_vertex_element *element = + &vertex_elements[i]; + const struct pipe_vertex_buffer *buffer = + &vertex_buffers[element->vertex_buffer_index]; + unsigned buffer_size; + const struct util_format_description *format_desc; + unsigned format_size; + + assert(buffer->buffer->height0 == 1); + assert(buffer->buffer->depth0 == 1); + buffer_size = buffer->buffer->width0; + + format_desc = util_format_description(element->src_format); + assert(format_desc->block.width == 1); + assert(format_desc->block.height == 1); + assert(format_desc->block.bits % 8 == 0); + format_size = format_desc->block.bits/8; + + if (buffer->buffer_offset >= buffer_size) { + /* buffer is too small */ + return 0; + } + + buffer_size -= buffer->buffer_offset; + + if (element->src_offset >= buffer_size) { + /* buffer is too small */ + return 0; + } + + buffer_size -= element->src_offset; + + if (format_size > buffer_size) { + /* buffer is too small */ + return 0; + } + + buffer_size -= format_size; + + if (buffer->stride != 0) { + unsigned buffer_max_index; + + buffer_max_index = buffer_size / buffer->stride; + + if (element->instance_divisor == 0) { + /* Per-vertex data */ + max_index = MIN2(max_index, buffer_max_index); + } + else { + /* Per-instance data. Simply make sure the state tracker didn't + * request more instances than those that fit in the buffer */ + assert((info->start_instance + info->instance_count)/element->instance_divisor + <= (buffer_max_index + 1)); + } + } + } + + return max_index + 1; +} diff --git a/mesalib/src/gallium/auxiliary/util/u_prim.h b/mesalib/src/gallium/auxiliary/util/u_prim.h index ca7c67d7c..070df643d 100644 --- a/mesalib/src/gallium/auxiliary/util/u_prim.h +++ b/mesalib/src/gallium/auxiliary/util/u_prim.h @@ -78,7 +78,7 @@ static INLINE boolean u_validate_pipe_prim( unsigned pipe_prim, unsigned nr ) static INLINE boolean u_trim_pipe_prim( unsigned pipe_prim, unsigned *nr ) { boolean ok = TRUE; - const static int values[][2] = { + const static unsigned values[][2] = { { 1, 0 }, /* PIPE_PRIM_POINTS */ { 2, 2 }, /* PIPE_PRIM_LINES */ { 2, 0 }, /* PIPE_PRIM_LINE_LOOP */ diff --git a/mesalib/src/glsl/ast_function.cpp b/mesalib/src/glsl/ast_function.cpp index fc0d7497d..126b610d1 100644 --- a/mesalib/src/glsl/ast_function.cpp +++ b/mesalib/src/glsl/ast_function.cpp @@ -93,214 +93,256 @@ prototype_string(const glsl_type *return_type, const char *name, return str; } - static ir_rvalue * -match_function_by_name(exec_list *instructions, const char *name, - YYLTYPE *loc, exec_list *actual_parameters, - struct _mesa_glsl_parse_state *state) +generate_call(exec_list *instructions, ir_function_signature *sig, + YYLTYPE *loc, exec_list *actual_parameters, + struct _mesa_glsl_parse_state *state) { void *ctx = state; - ir_function *f = state->symbols->get_function(name); - ir_function_signature *sig; - - sig = f ? f->matching_signature(actual_parameters) : NULL; + exec_list post_call_conversions; - /* FINISHME: This doesn't handle the case where shader X contains a - * FINISHME: matching signature but shader X + N contains an _exact_ - * FINISHME: matching signature. + /* Verify that 'out' and 'inout' actual parameters are lvalues. This + * isn't done in ir_function::matching_signature because that function + * cannot generate the necessary diagnostics. + * + * Also, validate that 'const_in' formal parameters (an extension of our + * IR) correspond to ir_constant actual parameters. + * + * Also, perform implicit conversion of arguments. Note: to implicitly + * convert out parameters, we need to place them in a temporary + * variable, and do the conversion after the call takes place. Since we + * haven't emitted the call yet, we'll place the post-call conversions + * in a temporary exec_list, and emit them later. */ - if (sig == NULL - && (f == NULL || state->es_shader || !f->has_user_signature()) - && state->symbols->get_type(name) == NULL - && (state->language_version == 110 - || state->symbols->get_variable(name) == NULL)) { - /* The current shader doesn't contain a matching function or signature. - * Before giving up, look for the prototype in the built-in functions. - */ - _mesa_glsl_initialize_functions(state); - for (unsigned i = 0; i < state->num_builtins_to_link; i++) { - ir_function *builtin; - builtin = state->builtins_to_link[i]->symbols->get_function(name); - sig = builtin ? builtin->matching_signature(actual_parameters) : NULL; - if (sig != NULL) { - if (f == NULL) { - f = new(ctx) ir_function(name); - state->symbols->add_global_function(f); - emit_function(state, f); - } + exec_list_iterator actual_iter = actual_parameters->iterator(); + exec_list_iterator formal_iter = sig->parameters.iterator(); + + while (actual_iter.has_next()) { + ir_rvalue *actual = (ir_rvalue *) actual_iter.get(); + ir_variable *formal = (ir_variable *) formal_iter.get(); - f->add_signature(sig->clone_prototype(f, NULL)); + assert(actual != NULL); + assert(formal != NULL); + + if (formal->mode == ir_var_const_in && !actual->as_constant()) { + _mesa_glsl_error(loc, state, + "parameter `%s' must be a constant expression", + formal->name); + return ir_call::get_error_instruction(ctx); + } + + if ((formal->mode == ir_var_out) + || (formal->mode == ir_var_inout)) { + const char *mode = NULL; + switch (formal->mode) { + case ir_var_out: mode = "out"; break; + case ir_var_inout: mode = "inout"; break; + default: assert(false); break; + } + /* FIXME: 'loc' is incorrect (as of 2011-01-21). It is always + * FIXME: 0:0(0). + */ + if (actual->variable_referenced() + && actual->variable_referenced()->read_only) { + _mesa_glsl_error(loc, state, + "function parameter '%s %s' references the " + "read-only variable '%s'", + mode, formal->name, + actual->variable_referenced()->name); + + } else if (!actual->is_lvalue()) { + _mesa_glsl_error(loc, state, + "function parameter '%s %s' is not an lvalue", + mode, formal->name); + } + } + + if (formal->type->is_numeric() || formal->type->is_boolean()) { + switch (formal->mode) { + case ir_var_const_in: + case ir_var_in: { + ir_rvalue *converted + = convert_component(actual, formal->type); + actual->replace_with(converted); + break; + } + case ir_var_out: + if (actual->type != formal->type) { + /* To convert an out parameter, we need to create a + * temporary variable to hold the value before conversion, + * and then perform the conversion after the function call + * returns. + * + * This has the effect of transforming code like this: + * + * void f(out int x); + * float value; + * f(value); + * + * Into IR that's equivalent to this: + * + * void f(out int x); + * float value; + * int out_parameter_conversion; + * f(out_parameter_conversion); + * value = float(out_parameter_conversion); + */ + ir_variable *tmp = + new(ctx) ir_variable(formal->type, + "out_parameter_conversion", + ir_var_temporary); + instructions->push_tail(tmp); + ir_dereference_variable *deref_tmp_1 + = new(ctx) ir_dereference_variable(tmp); + ir_dereference_variable *deref_tmp_2 + = new(ctx) ir_dereference_variable(tmp); + ir_rvalue *converted_tmp + = convert_component(deref_tmp_1, actual->type); + ir_assignment *assignment + = new(ctx) ir_assignment(actual, converted_tmp); + post_call_conversions.push_tail(assignment); + actual->replace_with(deref_tmp_2); + } + break; + case ir_var_inout: + /* Inout parameters should never require conversion, since that + * would require an implicit conversion to exist both to and + * from the formal parameter type, and there are no + * bidirectional implicit conversions. + */ + assert (actual->type == formal->type); + break; + default: + assert (!"Illegal formal parameter mode"); break; } } - } - exec_list post_call_conversions; + actual_iter.next(); + formal_iter.next(); + } - if (sig != NULL) { - /* Verify that 'out' and 'inout' actual parameters are lvalues. This - * isn't done in ir_function::matching_signature because that function - * cannot generate the necessary diagnostics. - * - * Also, validate that 'const_in' formal parameters (an extension of our - * IR) correspond to ir_constant actual parameters. + /* Always insert the call in the instruction stream, and return a deref + * of its return val if it returns a value, since we don't know if + * the rvalue is going to be assigned to anything or not. + * + * Also insert any out parameter conversions after the call. + */ + ir_call *call = new(ctx) ir_call(sig, actual_parameters); + ir_dereference_variable *deref; + if (!sig->return_type->is_void()) { + /* If the function call is a constant expression, don't + * generate the instructions to call it; just generate an + * ir_constant representing the constant value. * - * Also, perform implicit conversion of arguments. Note: to implicitly - * convert out parameters, we need to place them in a temporary - * variable, and do the conversion after the call takes place. Since we - * haven't emitted the call yet, we'll place the post-call conversions - * in a temporary exec_list, and emit them later. + * Function calls can only be constant expressions starting + * in GLSL 1.20. */ - exec_list_iterator actual_iter = actual_parameters->iterator(); - exec_list_iterator formal_iter = sig->parameters.iterator(); + if (state->language_version >= 120) { + ir_constant *const_val = call->constant_expression_value(); + if (const_val) { + return const_val; + } + } - while (actual_iter.has_next()) { - ir_rvalue *actual = (ir_rvalue *) actual_iter.get(); - ir_variable *formal = (ir_variable *) formal_iter.get(); + ir_variable *var; - assert(actual != NULL); - assert(formal != NULL); + var = new(ctx) ir_variable(sig->return_type, + ralloc_asprintf(ctx, "%s_retval", + sig->function_name()), + ir_var_temporary); + instructions->push_tail(var); - if (formal->mode == ir_var_const_in && !actual->as_constant()) { - _mesa_glsl_error(loc, state, - "parameter `%s' must be a constant expression", - formal->name); - return ir_call::get_error_instruction(ctx); - } + deref = new(ctx) ir_dereference_variable(var); + ir_assignment *assign = new(ctx) ir_assignment(deref, call, NULL); + instructions->push_tail(assign); - if ((formal->mode == ir_var_out) - || (formal->mode == ir_var_inout)) { - const char *mode = NULL; - switch (formal->mode) { - case ir_var_out: mode = "out"; break; - case ir_var_inout: mode = "inout"; break; - default: assert(false); break; - } - /* FIXME: 'loc' is incorrect (as of 2011-01-21). It is always - * FIXME: 0:0(0). - */ - if (actual->variable_referenced() - && actual->variable_referenced()->read_only) { - _mesa_glsl_error(loc, state, - "function parameter '%s %s' references the " - "read-only variable '%s'", - mode, formal->name, - actual->variable_referenced()->name); - - } else if (!actual->is_lvalue()) { - _mesa_glsl_error(loc, state, - "function parameter '%s %s' is not an lvalue", - mode, formal->name); - } - } + deref = new(ctx) ir_dereference_variable(var); + } else { + instructions->push_tail(call); + deref = NULL; + } + instructions->append_list(&post_call_conversions); + return deref; +} - if (formal->type->is_numeric() || formal->type->is_boolean()) { - switch (formal->mode) { - case ir_var_const_in: - case ir_var_in: { - ir_rvalue *converted - = convert_component(actual, formal->type); - actual->replace_with(converted); - break; - } - case ir_var_out: - if (actual->type != formal->type) { - /* To convert an out parameter, we need to create a - * temporary variable to hold the value before conversion, - * and then perform the conversion after the function call - * returns. - * - * This has the effect of transforming code like this: - * - * void f(out int x); - * float value; - * f(value); - * - * Into IR that's equivalent to this: - * - * void f(out int x); - * float value; - * int out_parameter_conversion; - * f(out_parameter_conversion); - * value = float(out_parameter_conversion); - */ - ir_variable *tmp = - new(ctx) ir_variable(formal->type, - "out_parameter_conversion", - ir_var_temporary); - instructions->push_tail(tmp); - ir_dereference_variable *deref_tmp_1 - = new(ctx) ir_dereference_variable(tmp); - ir_dereference_variable *deref_tmp_2 - = new(ctx) ir_dereference_variable(tmp); - ir_rvalue *converted_tmp - = convert_component(deref_tmp_1, actual->type); - ir_assignment *assignment - = new(ctx) ir_assignment(actual, converted_tmp); - post_call_conversions.push_tail(assignment); - actual->replace_with(deref_tmp_2); - } - break; - case ir_var_inout: - /* Inout parameters should never require conversion, since that - * would require an implicit conversion to exist both to and - * from the formal parameter type, and there are no - * bidirectional implicit conversions. - */ - assert (actual->type == formal->type); - break; - default: - assert (!"Illegal formal parameter mode"); - break; - } - } +static ir_rvalue * +match_function_by_name(exec_list *instructions, const char *name, + YYLTYPE *loc, exec_list *actual_parameters, + struct _mesa_glsl_parse_state *state) +{ + void *ctx = state; + ir_function *f = state->symbols->get_function(name); + ir_function_signature *local_sig = NULL; + ir_function_signature *sig = NULL; + + /* Is the function hidden by a record type constructor? */ + if (state->symbols->get_type(name)) + goto done; /* no match */ + + /* Is the function hidden by a variable (impossible in 1.10)? */ + if (state->language_version != 110 && state->symbols->get_variable(name)) + goto done; /* no match */ + + if (f != NULL) { + /* Look for a match in the local shader. If exact, we're done. */ + bool is_exact = false; + sig = local_sig = f->matching_signature(actual_parameters, &is_exact); + if (is_exact) + goto done; + + if (!state->es_shader && f->has_user_signature()) { + /* In desktop GL, the presence of a user-defined signature hides any + * built-in signatures, so we must ignore them. In contrast, in ES2 + * user-defined signatures add new overloads, so we must proceed. + */ + goto done; + } + } - actual_iter.next(); - formal_iter.next(); + /* Local shader has no exact candidates; check the built-ins. */ + _mesa_glsl_initialize_functions(state); + for (unsigned i = 0; i < state->num_builtins_to_link; i++) { + ir_function *builtin = + state->builtins_to_link[i]->symbols->get_function(name); + if (builtin == NULL) + continue; + + bool is_exact = false; + ir_function_signature *builtin_sig = + builtin->matching_signature(actual_parameters, &is_exact); + + if (builtin_sig == NULL) + continue; + + /* If the built-in signature is exact, we can stop. */ + if (is_exact) { + sig = builtin_sig; + goto done; } - /* Always insert the call in the instruction stream, and return a deref - * of its return val if it returns a value, since we don't know if - * the rvalue is going to be assigned to anything or not. - * - * Also insert any out parameter conversions after the call. - */ - ir_call *call = new(ctx) ir_call(sig, actual_parameters); - ir_dereference_variable *deref; - if (!sig->return_type->is_void()) { - /* If the function call is a constant expression, don't - * generate the instructions to call it; just generate an - * ir_constant representing the constant value. - * - * Function calls can only be constant expressions starting - * in GLSL 1.20. - */ - if (state->language_version >= 120) { - ir_constant *const_val = call->constant_expression_value(); - if (const_val) { - return const_val; - } - } - - ir_variable *var; - - var = new(ctx) ir_variable(sig->return_type, - ralloc_asprintf(ctx, "%s_retval", - sig->function_name()), - ir_var_temporary); - instructions->push_tail(var); - - deref = new(ctx) ir_dereference_variable(var); - ir_assignment *assign = new(ctx) ir_assignment(deref, call, NULL); - instructions->push_tail(assign); - - deref = new(ctx) ir_dereference_variable(var); - } else { - instructions->push_tail(call); - deref = NULL; + if (sig == NULL) { + /* We found an inexact match, which is better than nothing. However, + * we should keep searching for an exact match. + */ + sig = builtin_sig; + } + } + +done: + if (sig != NULL) { + /* If the match is from a linked built-in shader, import the prototype. */ + if (sig != local_sig) { + if (f == NULL) { + f = new(ctx) ir_function(name); + state->symbols->add_global_function(f); + emit_function(state, f); + } + f->add_signature(sig->clone_prototype(f, NULL)); } - instructions->append_list(&post_call_conversions); - return deref; + + /* Finally, generate a call instruction. */ + return generate_call(instructions, sig, loc, actual_parameters, state); } else { char *str = prototype_string(NULL, name, actual_parameters); diff --git a/mesalib/src/glsl/glsl_parser.yy b/mesalib/src/glsl/glsl_parser.yy index f3e873800..836390453 100644 --- a/mesalib/src/glsl/glsl_parser.yy +++ b/mesalib/src/glsl/glsl_parser.yy @@ -1706,7 +1706,7 @@ case_statement: ast_case_statement *stmts = new(state) ast_case_statement($1); stmts->stmts.push_tail(& $2->link); - $$ = stmts + $$ = stmts; } | case_statement statement { diff --git a/mesalib/src/glsl/ir.h b/mesalib/src/glsl/ir.h index 5878c051b..1faae3c72 100644 --- a/mesalib/src/glsl/ir.h +++ b/mesalib/src/glsl/ir.h @@ -564,6 +564,13 @@ public: return signatures.iterator(); } + /** + * Find a signature that matches a set of actual parameters, taking implicit + * conversions into account. Also flags whether the match was exact. + */ + ir_function_signature *matching_signature(const exec_list *actual_param, + bool *match_is_exact); + /** * Find a signature that matches a set of actual parameters, taking implicit * conversions into account. diff --git a/mesalib/src/glsl/ir_function.cpp b/mesalib/src/glsl/ir_function.cpp index 51d32b46f..b34a50081 100644 --- a/mesalib/src/glsl/ir_function.cpp +++ b/mesalib/src/glsl/ir_function.cpp @@ -117,6 +117,14 @@ parameter_lists_match(const exec_list *list_a, const exec_list *list_b) ir_function_signature * ir_function::matching_signature(const exec_list *actual_parameters) +{ + bool is_exact; + return matching_signature(actual_parameters, &is_exact); +} + +ir_function_signature * +ir_function::matching_signature(const exec_list *actual_parameters, + bool *is_exact) { ir_function_signature *match = NULL; bool multiple_inexact_matches = false; @@ -137,6 +145,7 @@ ir_function::matching_signature(const exec_list *actual_parameters) switch (parameter_lists_match(& sig->parameters, actual_parameters)) { case PARAMETER_LIST_EXACT_MATCH: + *is_exact = true; return sig; case PARAMETER_LIST_INEXACT_MATCH: if (match == NULL) @@ -159,6 +168,8 @@ ir_function::matching_signature(const exec_list *actual_parameters) * FINISHME: a "no matching signature" error; it should report that the * FINISHME: call is ambiguous. But reporting errors from here is hard. */ + *is_exact = false; + if (multiple_inexact_matches) return NULL; diff --git a/mesalib/src/glsl/link_uniforms.cpp b/mesalib/src/glsl/link_uniforms.cpp index b9d5361b0..ca5da3040 100644 --- a/mesalib/src/glsl/link_uniforms.cpp +++ b/mesalib/src/glsl/link_uniforms.cpp @@ -113,11 +113,18 @@ uniform_field_visitor::recursion(const glsl_type *t, char **name, class count_uniform_size : public uniform_field_visitor { public: count_uniform_size(struct string_to_uint_map *map) - : num_active_uniforms(0), num_values(0), map(map) + : num_active_uniforms(0), num_values(0), num_shader_samplers(0), + num_shader_uniforms(0), map(map) { /* empty */ } + void start_shader() + { + this->num_shader_samplers = 0; + this->num_shader_uniforms = 0; + } + /** * Total number of active uniforms counted */ @@ -128,12 +135,39 @@ public: */ unsigned num_values; + /** + * Number of samplers used + */ + unsigned num_shader_samplers; + + /** + * Number of uniforms used in the current shader + */ + unsigned num_shader_uniforms; + private: virtual void visit_field(const glsl_type *type, const char *name) { assert(!type->is_record()); assert(!(type->is_array() && type->fields.array->is_record())); + /* Count the number of samplers regardless of whether the uniform is + * already in the hash table. The hash table prevents adding the same + * uniform for multiple shader targets, but in this case we want to + * count it for each shader target. + */ + const unsigned values = values_for_type(type); + if (type->contains_sampler()) { + this->num_shader_samplers += + type->is_array() ? type->array_size() : 1; + } else { + /* Accumulate the total number of uniform slots used by this shader. + * Note that samplers do not count against this limit because they + * don't use any storage on current hardware. + */ + this->num_shader_uniforms += values; + } + /* If the uniform is already in the map, there's nothing more to do. */ unsigned id; @@ -147,7 +181,7 @@ private: * uniforms. */ this->num_active_uniforms++; - this->num_values += values_for_type(type); + this->num_values += values; } struct string_to_uint_map *map; @@ -267,6 +301,10 @@ link_assign_uniform_locations(struct gl_shader_program *prog) if (prog->_LinkedShaders[i] == NULL) continue; + /* Reset various per-shader target counts. + */ + uniform_size.start_shader(); + foreach_list(node, prog->_LinkedShaders[i]->ir) { ir_variable *const var = ((ir_instruction *) node)->as_variable(); @@ -280,6 +318,10 @@ link_assign_uniform_locations(struct gl_shader_program *prog) uniform_size.process(var); } + + prog->_LinkedShaders[i]->num_samplers = uniform_size.num_shader_samplers; + prog->_LinkedShaders[i]->num_uniform_components = + uniform_size.num_shader_uniforms * 4; } const unsigned num_user_uniforms = uniform_size.num_active_uniforms; diff --git a/mesalib/src/glsl/linker.cpp b/mesalib/src/glsl/linker.cpp index 351680d43..0ec773d6c 100644 --- a/mesalib/src/glsl/linker.cpp +++ b/mesalib/src/glsl/linker.cpp @@ -1875,6 +1875,47 @@ store_tfeedback_info(struct gl_context *ctx, struct gl_shader_program *prog, return true; } +/** + * Validate the resources used by a program versus the implementation limits + */ +static bool +check_resources(struct gl_context *ctx, struct gl_shader_program *prog) +{ + static const char *const shader_names[MESA_SHADER_TYPES] = { + "vertex", "fragment", "geometry" + }; + + const unsigned max_samplers[MESA_SHADER_TYPES] = { + ctx->Const.MaxVertexTextureImageUnits, + ctx->Const.MaxTextureImageUnits, + ctx->Const.MaxGeometryTextureImageUnits + }; + + const unsigned max_uniform_components[MESA_SHADER_TYPES] = { + ctx->Const.VertexProgram.MaxUniformComponents, + ctx->Const.FragmentProgram.MaxUniformComponents, + 0 /* FINISHME: Geometry shaders. */ + }; + + for (unsigned i = 0; i < MESA_SHADER_TYPES; i++) { + struct gl_shader *sh = prog->_LinkedShaders[i]; + + if (sh == NULL) + continue; + + if (sh->num_samplers > max_samplers[i]) { + linker_error(prog, "Too many %s shader texture samplers", + shader_names[i]); + } + + if (sh->num_uniform_components > max_uniform_components[i]) { + linker_error(prog, "Too many %s shader uniform components", + shader_names[i]); + } + } + + return prog->LinkStatus; +} void link_shaders(struct gl_context *ctx, struct gl_shader_program *prog) @@ -2137,6 +2178,9 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog) update_array_sizes(prog); link_assign_uniform_locations(prog); + if (!check_resources(ctx, prog)) + goto done; + /* OpenGL ES requires that a vertex shader and a fragment shader both be * present in a linked program. By checking for use of shading language * version 1.00, we also catch the GL_ARB_ES2_compatibility case. diff --git a/mesalib/src/mesa/SConscript b/mesalib/src/mesa/SConscript index 3e42bfd8b..807608636 100644 --- a/mesalib/src/mesa/SConscript +++ b/mesalib/src/mesa/SConscript @@ -169,7 +169,6 @@ swrast_sources = [ 'swrast/s_logic.c', 'swrast/s_masking.c', 'swrast/s_points.c', - 'swrast/s_readpix.c', 'swrast/s_span.c', 'swrast/s_stencil.c', 'swrast/s_texcombine.c', diff --git a/mesalib/src/mesa/drivers/common/driverfuncs.c b/mesalib/src/mesa/drivers/common/driverfuncs.c index 27ea559b3..5e25d7fda 100644 --- a/mesalib/src/mesa/drivers/common/driverfuncs.c +++ b/mesalib/src/mesa/drivers/common/driverfuncs.c @@ -30,6 +30,7 @@ #include "main/framebuffer.h" #include "main/mipmap.h" #include "main/queryobj.h" +#include "main/readpix.h" #include "main/renderbuffer.h" #include "main/shaderobj.h" #include "main/texcompress.h" @@ -82,7 +83,7 @@ _mesa_init_driver_functions(struct dd_function_table *driver) driver->Accum = _swrast_Accum; driver->RasterPos = _tnl_RasterPos; driver->DrawPixels = _swrast_DrawPixels; - driver->ReadPixels = _swrast_ReadPixels; + driver->ReadPixels = _mesa_readpixels; driver->CopyPixels = _swrast_CopyPixels; driver->Bitmap = _swrast_Bitmap; diff --git a/mesalib/src/mesa/drivers/common/meta.c b/mesalib/src/mesa/drivers/common/meta.c index 8d589e4c3..259041f67 100644 --- a/mesalib/src/mesa/drivers/common/meta.c +++ b/mesalib/src/mesa/drivers/common/meta.c @@ -879,40 +879,25 @@ _mesa_meta_end(struct gl_context *ctx) /* restore texture objects for unit[0] only */ for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) { - _mesa_reference_texobj(&ctx->Texture.Unit[0].CurrentTex[tgt], - save->CurrentTexture[tgt]); + if (ctx->Texture.Unit[0].CurrentTex[tgt] != save->CurrentTexture[tgt]) { + FLUSH_VERTICES(ctx, _NEW_TEXTURE); + _mesa_reference_texobj(&ctx->Texture.Unit[0].CurrentTex[tgt], + save->CurrentTexture[tgt]); + } _mesa_reference_texobj(&save->CurrentTexture[tgt], NULL); } - /* Re-enable textures, texgen */ + /* Restore fixed function texture enables, texgen */ for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { - if (save->TexEnabled[u]) { - _mesa_ActiveTextureARB(GL_TEXTURE0 + u); - - if (save->TexEnabled[u] & TEXTURE_1D_BIT) - _mesa_set_enable(ctx, GL_TEXTURE_1D, GL_TRUE); - if (save->TexEnabled[u] & TEXTURE_2D_BIT) - _mesa_set_enable(ctx, GL_TEXTURE_2D, GL_TRUE); - if (save->TexEnabled[u] & TEXTURE_3D_BIT) - _mesa_set_enable(ctx, GL_TEXTURE_3D, GL_TRUE); - if (save->TexEnabled[u] & TEXTURE_CUBE_BIT) - _mesa_set_enable(ctx, GL_TEXTURE_CUBE_MAP, GL_TRUE); - if (save->TexEnabled[u] & TEXTURE_RECT_BIT) - _mesa_set_enable(ctx, GL_TEXTURE_RECTANGLE, GL_TRUE); - } - - if (save->TexGenEnabled[u]) { - _mesa_ActiveTextureARB(GL_TEXTURE0 + u); + if (ctx->Texture.Unit[u].Enabled != save->TexEnabled[u]) { + FLUSH_VERTICES(ctx, _NEW_TEXTURE); + ctx->Texture.Unit[u].Enabled = save->TexEnabled[u]; + } - if (save->TexGenEnabled[u] & S_BIT) - _mesa_set_enable(ctx, GL_TEXTURE_GEN_S, GL_TRUE); - if (save->TexGenEnabled[u] & T_BIT) - _mesa_set_enable(ctx, GL_TEXTURE_GEN_T, GL_TRUE); - if (save->TexGenEnabled[u] & R_BIT) - _mesa_set_enable(ctx, GL_TEXTURE_GEN_R, GL_TRUE); - if (save->TexGenEnabled[u] & Q_BIT) - _mesa_set_enable(ctx, GL_TEXTURE_GEN_Q, GL_TRUE); - } + if (ctx->Texture.Unit[u].TexGenEnabled != save->TexGenEnabled[u]) { + FLUSH_VERTICES(ctx, _NEW_TEXTURE); + ctx->Texture.Unit[u].TexGenEnabled = save->TexGenEnabled[u]; + } } /* restore current unit state */ diff --git a/mesalib/src/mesa/main/ffvertex_prog.c b/mesalib/src/mesa/main/ffvertex_prog.c index 846907842..2c937386a 100644 --- a/mesalib/src/mesa/main/ffvertex_prog.c +++ b/mesalib/src/mesa/main/ffvertex_prog.c @@ -949,7 +949,7 @@ static struct ureg calculate_light_attenuation( struct tnl_program *p, { struct ureg attenuation = register_param3(p, STATE_LIGHT, i, STATE_ATTENUATION); - struct ureg att = get_temp(p); + struct ureg att = undef; /* Calculate spot attenuation: */ @@ -959,6 +959,8 @@ static struct ureg calculate_light_attenuation( struct tnl_program *p, struct ureg spot = get_temp(p); struct ureg slt = get_temp(p); + att = get_temp(p); + emit_op2(p, OPCODE_DP3, spot, 0, negate(VPpli), spot_dir_norm); emit_op2(p, OPCODE_SLT, slt, 0, swizzle1(spot_dir_norm,W), spot); emit_op2(p, OPCODE_POW, spot, 0, spot, swizzle1(attenuation, W)); @@ -968,9 +970,13 @@ static struct ureg calculate_light_attenuation( struct tnl_program *p, release_temp(p, slt); } - /* Calculate distance attenuation: + /* Calculate distance attenuation(See formula (2.4) at glspec 2.1 page 62): + * + * Skip the calucation when _dist_ is undefined(light_eyepos3_is_zero) */ - if (p->state->unit[i].light_attenuated) { + if (p->state->unit[i].light_attenuated && !is_undef(dist)) { + if (is_undef(att)) + att = get_temp(p); /* 1/d,d,d,1/d */ emit_op1(p, OPCODE_RCP, dist, WRITEMASK_YZ, dist); /* 1,d,d*d,1/d */ @@ -1113,73 +1119,54 @@ static void build_lighting( struct tnl_program *p ) if (p->state->unit[i].light_enabled) { struct ureg half = undef; struct ureg att = undef, VPpli = undef; + struct ureg dist = undef; count++; + if (p->state->unit[i].light_eyepos3_is_zero) { + VPpli = register_param3(p, STATE_INTERNAL, + STATE_LIGHT_POSITION_NORMALIZED, i); + } else { + struct ureg Ppli = register_param3(p, STATE_INTERNAL, + STATE_LIGHT_POSITION, i); + struct ureg V = get_eye_position(p); + + VPpli = get_temp(p); + dist = get_temp(p); + + /* Calculate VPpli vector + */ + emit_op2(p, OPCODE_SUB, VPpli, 0, Ppli, V); - if (p->state->unit[i].light_eyepos3_is_zero) { - /* Can used precomputed constants in this case. - * Attenuation never applies to infinite lights. - */ - VPpli = register_param3(p, STATE_INTERNAL, - STATE_LIGHT_POSITION_NORMALIZED, i); - - if (!p->state->material_shininess_is_zero) { - if (p->state->light_local_viewer) { - struct ureg eye_hat = get_eye_position_normalized(p); - half = get_temp(p); - emit_op2(p, OPCODE_SUB, half, 0, VPpli, eye_hat); - emit_normalize_vec3(p, half, half); - } - else { - half = register_param3(p, STATE_INTERNAL, - STATE_LIGHT_HALF_VECTOR, i); - } - } - } - else { - struct ureg Ppli = register_param3(p, STATE_INTERNAL, - STATE_LIGHT_POSITION, i); - struct ureg V = get_eye_position(p); - struct ureg dist = get_temp(p); - - VPpli = get_temp(p); - - /* Calculate VPpli vector - */ - emit_op2(p, OPCODE_SUB, VPpli, 0, Ppli, V); - - /* Normalize VPpli. The dist value also used in - * attenuation below. - */ - emit_op2(p, OPCODE_DP3, dist, 0, VPpli, VPpli); - emit_op1(p, OPCODE_RSQ, dist, 0, dist); - emit_op2(p, OPCODE_MUL, VPpli, 0, VPpli, dist); - - /* Calculate attenuation: - */ - if (!p->state->unit[i].light_spotcutoff_is_180 || - p->state->unit[i].light_attenuated) { - att = calculate_light_attenuation(p, i, VPpli, dist); - } - - /* Calculate viewer direction, or use infinite viewer: - */ - if (!p->state->material_shininess_is_zero) { - half = get_temp(p); + /* Normalize VPpli. The dist value also used in + * attenuation below. + */ + emit_op2(p, OPCODE_DP3, dist, 0, VPpli, VPpli); + emit_op1(p, OPCODE_RSQ, dist, 0, dist); + emit_op2(p, OPCODE_MUL, VPpli, 0, VPpli, dist); + } - if (p->state->light_local_viewer) { - struct ureg eye_hat = get_eye_position_normalized(p); - emit_op2(p, OPCODE_SUB, half, 0, VPpli, eye_hat); - } - else { - struct ureg z_dir = swizzle(get_identity_param(p),X,Y,W,Z); - emit_op2(p, OPCODE_ADD, half, 0, VPpli, z_dir); - } + /* Calculate attenuation: + */ + att = calculate_light_attenuation(p, i, VPpli, dist); + release_temp(p, dist); + /* Calculate viewer direction, or use infinite viewer: + */ + if (!p->state->material_shininess_is_zero) { + if (p->state->light_local_viewer) { + struct ureg eye_hat = get_eye_position_normalized(p); + half = get_temp(p); + emit_op2(p, OPCODE_SUB, half, 0, VPpli, eye_hat); + emit_normalize_vec3(p, half, half); + } else if (p->state->unit[i].light_eyepos3_is_zero) { + half = register_param3(p, STATE_INTERNAL, + STATE_LIGHT_HALF_VECTOR, i); + } else { + struct ureg z_dir = swizzle(get_identity_param(p),X,Y,W,Z); + half = get_temp(p); + emit_op2(p, OPCODE_ADD, half, 0, VPpli, z_dir); emit_normalize_vec3(p, half, half); } - - release_temp(p, dist); } /* Calculate dot products: diff --git a/mesalib/src/mesa/main/format_unpack.c b/mesalib/src/mesa/main/format_unpack.c index 525bbcb1c..6e2ce7a05 100644 --- a/mesalib/src/mesa/main/format_unpack.c +++ b/mesalib/src/mesa/main/format_unpack.c @@ -57,1049 +57,1335 @@ nonlinear_to_linear(GLubyte cs8) } -typedef void (*unpack_rgba_func)(const void *src, GLfloat dst[4]); +typedef void (*unpack_rgba_func)(const void *src, GLfloat dst[][4], GLuint n); static void -unpack_RGBA8888(const void *src, GLfloat dst[4]) +unpack_RGBA8888(const void *src, GLfloat dst[][4], GLuint n) { - const GLuint s = *((const GLuint *) src); - dst[RCOMP] = UBYTE_TO_FLOAT( (s >> 24) ); - dst[GCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff ); - dst[BCOMP] = UBYTE_TO_FLOAT( (s >> 8) & 0xff ); - dst[ACOMP] = UBYTE_TO_FLOAT( (s ) & 0xff ); + const GLuint *s = ((const GLuint *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = UBYTE_TO_FLOAT( (s[i] >> 24) ); + dst[i][GCOMP] = UBYTE_TO_FLOAT( (s[i] >> 16) & 0xff ); + dst[i][BCOMP] = UBYTE_TO_FLOAT( (s[i] >> 8) & 0xff ); + dst[i][ACOMP] = UBYTE_TO_FLOAT( (s[i] ) & 0xff ); + } } static void -unpack_RGBA8888_REV(const void *src, GLfloat dst[4]) +unpack_RGBA8888_REV(const void *src, GLfloat dst[][4], GLuint n) { - const GLuint s = *((const GLuint *) src); - dst[RCOMP] = UBYTE_TO_FLOAT( (s ) & 0xff ); - dst[GCOMP] = UBYTE_TO_FLOAT( (s >> 8) & 0xff ); - dst[BCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff ); - dst[ACOMP] = UBYTE_TO_FLOAT( (s >> 24) ); + const GLuint *s = ((const GLuint *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = UBYTE_TO_FLOAT( (s[i] ) & 0xff ); + dst[i][GCOMP] = UBYTE_TO_FLOAT( (s[i] >> 8) & 0xff ); + dst[i][BCOMP] = UBYTE_TO_FLOAT( (s[i] >> 16) & 0xff ); + dst[i][ACOMP] = UBYTE_TO_FLOAT( (s[i] >> 24) ); + } } static void -unpack_ARGB8888(const void *src, GLfloat dst[4]) +unpack_ARGB8888(const void *src, GLfloat dst[][4], GLuint n) { - const GLuint s = *((const GLuint *) src); - dst[RCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff ); - dst[GCOMP] = UBYTE_TO_FLOAT( (s >> 8) & 0xff ); - dst[BCOMP] = UBYTE_TO_FLOAT( (s ) & 0xff ); - dst[ACOMP] = UBYTE_TO_FLOAT( (s >> 24) ); + const GLuint *s = ((const GLuint *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = UBYTE_TO_FLOAT( (s[i] >> 16) & 0xff ); + dst[i][GCOMP] = UBYTE_TO_FLOAT( (s[i] >> 8) & 0xff ); + dst[i][BCOMP] = UBYTE_TO_FLOAT( (s[i] ) & 0xff ); + dst[i][ACOMP] = UBYTE_TO_FLOAT( (s[i] >> 24) ); + } } static void -unpack_ARGB8888_REV(const void *src, GLfloat dst[4]) +unpack_ARGB8888_REV(const void *src, GLfloat dst[][4], GLuint n) { - const GLuint s = *((const GLuint *) src); - dst[RCOMP] = UBYTE_TO_FLOAT( (s >> 8) & 0xff ); - dst[GCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff ); - dst[BCOMP] = UBYTE_TO_FLOAT( (s >> 24) ); - dst[ACOMP] = UBYTE_TO_FLOAT( (s ) & 0xff ); + const GLuint *s = ((const GLuint *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = UBYTE_TO_FLOAT( (s[i] >> 8) & 0xff ); + dst[i][GCOMP] = UBYTE_TO_FLOAT( (s[i] >> 16) & 0xff ); + dst[i][BCOMP] = UBYTE_TO_FLOAT( (s[i] >> 24) ); + dst[i][ACOMP] = UBYTE_TO_FLOAT( (s[i] ) & 0xff ); + } } static void -unpack_XRGB8888(const void *src, GLfloat dst[4]) +unpack_XRGB8888(const void *src, GLfloat dst[][4], GLuint n) { - const GLuint s = *((const GLuint *) src); - dst[RCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff ); - dst[GCOMP] = UBYTE_TO_FLOAT( (s >> 8) & 0xff ); - dst[BCOMP] = UBYTE_TO_FLOAT( (s ) & 0xff ); - dst[ACOMP] = 1.0f; + const GLuint *s = ((const GLuint *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = UBYTE_TO_FLOAT( (s[i] >> 16) & 0xff ); + dst[i][GCOMP] = UBYTE_TO_FLOAT( (s[i] >> 8) & 0xff ); + dst[i][BCOMP] = UBYTE_TO_FLOAT( (s[i] ) & 0xff ); + dst[i][ACOMP] = 1.0f; + } } static void -unpack_XRGB8888_REV(const void *src, GLfloat dst[4]) +unpack_XRGB8888_REV(const void *src, GLfloat dst[][4], GLuint n) { - const GLuint s = *((const GLuint *) src); - dst[RCOMP] = UBYTE_TO_FLOAT( (s >> 8) & 0xff ); - dst[GCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff ); - dst[BCOMP] = UBYTE_TO_FLOAT( (s >> 24) ); - dst[ACOMP] = 1.0f; + const GLuint *s = ((const GLuint *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = UBYTE_TO_FLOAT( (s[i] >> 8) & 0xff ); + dst[i][GCOMP] = UBYTE_TO_FLOAT( (s[i] >> 16) & 0xff ); + dst[i][BCOMP] = UBYTE_TO_FLOAT( (s[i] >> 24) ); + dst[i][ACOMP] = 1.0f; + } } static void -unpack_RGB888(const void *src, GLfloat dst[4]) +unpack_RGB888(const void *src, GLfloat dst[][4], GLuint n) { const GLubyte *s = (const GLubyte *) src; - dst[RCOMP] = UBYTE_TO_FLOAT( s[2] ); - dst[GCOMP] = UBYTE_TO_FLOAT( s[1] ); - dst[BCOMP] = UBYTE_TO_FLOAT( s[0] ); - dst[ACOMP] = 1.0F; + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = UBYTE_TO_FLOAT( s[i*3+2] ); + dst[i][GCOMP] = UBYTE_TO_FLOAT( s[i*3+1] ); + dst[i][BCOMP] = UBYTE_TO_FLOAT( s[i*3+0] ); + dst[i][ACOMP] = 1.0F; + } } static void -unpack_BGR888(const void *src, GLfloat dst[4]) +unpack_BGR888(const void *src, GLfloat dst[][4], GLuint n) { const GLubyte *s = (const GLubyte *) src; - dst[RCOMP] = UBYTE_TO_FLOAT( s[0] ); - dst[GCOMP] = UBYTE_TO_FLOAT( s[1] ); - dst[BCOMP] = UBYTE_TO_FLOAT( s[2] ); - dst[ACOMP] = 1.0F; + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = UBYTE_TO_FLOAT( s[i*3+0] ); + dst[i][GCOMP] = UBYTE_TO_FLOAT( s[i*3+1] ); + dst[i][BCOMP] = UBYTE_TO_FLOAT( s[i*3+2] ); + dst[i][ACOMP] = 1.0F; + } } static void -unpack_RGB565(const void *src, GLfloat dst[4]) +unpack_RGB565(const void *src, GLfloat dst[][4], GLuint n) { - const GLushort s = *((const GLushort *) src); - dst[RCOMP] = ((s >> 11) & 0x1f) * (1.0F / 31.0F); - dst[GCOMP] = ((s >> 5 ) & 0x3f) * (1.0F / 63.0F); - dst[BCOMP] = ((s ) & 0x1f) * (1.0F / 31.0F); - dst[ACOMP] = 1.0F; + const GLushort *s = ((const GLushort *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = ((s[i] >> 11) & 0x1f) * (1.0F / 31.0F); + dst[i][GCOMP] = ((s[i] >> 5 ) & 0x3f) * (1.0F / 63.0F); + dst[i][BCOMP] = ((s[i] ) & 0x1f) * (1.0F / 31.0F); + dst[i][ACOMP] = 1.0F; + } } static void -unpack_RGB565_REV(const void *src, GLfloat dst[4]) +unpack_RGB565_REV(const void *src, GLfloat dst[][4], GLuint n) { - GLushort s = *((const GLushort *) src); - s = (s >> 8) | (s << 8); /* byte swap */ - dst[RCOMP] = UBYTE_TO_FLOAT( ((s >> 8) & 0xf8) | ((s >> 13) & 0x7) ); - dst[GCOMP] = UBYTE_TO_FLOAT( ((s >> 3) & 0xfc) | ((s >> 9) & 0x3) ); - dst[BCOMP] = UBYTE_TO_FLOAT( ((s << 3) & 0xf8) | ((s >> 2) & 0x7) ); - dst[ACOMP] = 1.0F; + const GLushort *s = ((const GLushort *) src); + GLuint i; + for (i = 0; i < n; i++) { + GLuint t = (s[i] >> 8) | (s[i] << 8); /* byte swap */ + dst[i][RCOMP] = UBYTE_TO_FLOAT( ((t >> 8) & 0xf8) | ((t >> 13) & 0x7) ); + dst[i][GCOMP] = UBYTE_TO_FLOAT( ((t >> 3) & 0xfc) | ((t >> 9) & 0x3) ); + dst[i][BCOMP] = UBYTE_TO_FLOAT( ((t << 3) & 0xf8) | ((t >> 2) & 0x7) ); + dst[i][ACOMP] = 1.0F; + } } static void -unpack_ARGB4444(const void *src, GLfloat dst[4]) +unpack_ARGB4444(const void *src, GLfloat dst[][4], GLuint n) { - const GLushort s = *((const GLushort *) src); - dst[RCOMP] = ((s >> 8) & 0xf) * (1.0F / 15.0F); - dst[GCOMP] = ((s >> 4) & 0xf) * (1.0F / 15.0F); - dst[BCOMP] = ((s ) & 0xf) * (1.0F / 15.0F); - dst[ACOMP] = ((s >> 12) & 0xf) * (1.0F / 15.0F); + const GLushort *s = ((const GLushort *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = ((s[i] >> 8) & 0xf) * (1.0F / 15.0F); + dst[i][GCOMP] = ((s[i] >> 4) & 0xf) * (1.0F / 15.0F); + dst[i][BCOMP] = ((s[i] ) & 0xf) * (1.0F / 15.0F); + dst[i][ACOMP] = ((s[i] >> 12) & 0xf) * (1.0F / 15.0F); + } } static void -unpack_ARGB4444_REV(const void *src, GLfloat dst[4]) +unpack_ARGB4444_REV(const void *src, GLfloat dst[][4], GLuint n) { - const GLushort s = *((const GLushort *) src); - dst[RCOMP] = ((s ) & 0xf) * (1.0F / 15.0F); - dst[GCOMP] = ((s >> 12) & 0xf) * (1.0F / 15.0F); - dst[BCOMP] = ((s >> 8) & 0xf) * (1.0F / 15.0F); - dst[ACOMP] = ((s >> 4) & 0xf) * (1.0F / 15.0F); + const GLushort *s = ((const GLushort *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = ((s[i] ) & 0xf) * (1.0F / 15.0F); + dst[i][GCOMP] = ((s[i] >> 12) & 0xf) * (1.0F / 15.0F); + dst[i][BCOMP] = ((s[i] >> 8) & 0xf) * (1.0F / 15.0F); + dst[i][ACOMP] = ((s[i] >> 4) & 0xf) * (1.0F / 15.0F); + } } static void -unpack_RGBA5551(const void *src, GLfloat dst[4]) +unpack_RGBA5551(const void *src, GLfloat dst[][4], GLuint n) { - const GLushort s = *((const GLushort *) src); - dst[RCOMP] = ((s >> 11) & 0x1f) * (1.0F / 31.0F); - dst[GCOMP] = ((s >> 6) & 0x1f) * (1.0F / 31.0F); - dst[BCOMP] = ((s >> 1) & 0x1f) * (1.0F / 31.0F); - dst[ACOMP] = ((s ) & 0x01) * 1.0F; + const GLushort *s = ((const GLushort *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = ((s[i] >> 11) & 0x1f) * (1.0F / 31.0F); + dst[i][GCOMP] = ((s[i] >> 6) & 0x1f) * (1.0F / 31.0F); + dst[i][BCOMP] = ((s[i] >> 1) & 0x1f) * (1.0F / 31.0F); + dst[i][ACOMP] = ((s[i] ) & 0x01) * 1.0F; + } } static void -unpack_ARGB1555(const void *src, GLfloat dst[4]) +unpack_ARGB1555(const void *src, GLfloat dst[][4], GLuint n) { - const GLushort s = *((const GLushort *) src); - dst[RCOMP] = ((s >> 10) & 0x1f) * (1.0F / 31.0F); - dst[GCOMP] = ((s >> 5) & 0x1f) * (1.0F / 31.0F); - dst[BCOMP] = ((s >> 0) & 0x1f) * (1.0F / 31.0F); - dst[ACOMP] = ((s >> 15) & 0x01) * 1.0F; + const GLushort *s = ((const GLushort *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = ((s[i] >> 10) & 0x1f) * (1.0F / 31.0F); + dst[i][GCOMP] = ((s[i] >> 5) & 0x1f) * (1.0F / 31.0F); + dst[i][BCOMP] = ((s[i] >> 0) & 0x1f) * (1.0F / 31.0F); + dst[i][ACOMP] = ((s[i] >> 15) & 0x01) * 1.0F; + } } static void -unpack_ARGB1555_REV(const void *src, GLfloat dst[4]) +unpack_ARGB1555_REV(const void *src, GLfloat dst[][4], GLuint n) { - const GLushort s = *((const GLushort *) src); - dst[RCOMP] = UBYTE_TO_FLOAT( ((s >> 7) & 0xf8) | ((s >> 12) & 0x7) ); - dst[GCOMP] = UBYTE_TO_FLOAT( ((s >> 2) & 0xf8) | ((s >> 7) & 0x7) ); - dst[BCOMP] = UBYTE_TO_FLOAT( ((s << 3) & 0xf8) | ((s >> 2) & 0x7) ); - dst[ACOMP] = UBYTE_TO_FLOAT( ((s >> 15) & 0x01) * 255 ); + const GLushort *s = ((const GLushort *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = UBYTE_TO_FLOAT( ((s[i] >> 7) & 0xf8) | ((s[i] >> 12) & 0x7) ); + dst[i][GCOMP] = UBYTE_TO_FLOAT( ((s[i] >> 2) & 0xf8) | ((s[i] >> 7) & 0x7) ); + dst[i][BCOMP] = UBYTE_TO_FLOAT( ((s[i] << 3) & 0xf8) | ((s[i] >> 2) & 0x7) ); + dst[i][ACOMP] = UBYTE_TO_FLOAT( ((s[i] >> 15) & 0x01) * 255 ); + } } static void -unpack_AL44(const void *src, GLfloat dst[4]) +unpack_AL44(const void *src, GLfloat dst[][4], GLuint n) { - const GLubyte s = *((const GLubyte *) src); - dst[RCOMP] = - dst[GCOMP] = - dst[BCOMP] = (s & 0xf) * (1.0F / 15.0F); - dst[ACOMP] = ((s >> 4) & 0xf) * (1.0F / 15.0F); + const GLubyte *s = ((const GLubyte *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = + dst[i][GCOMP] = + dst[i][BCOMP] = (s[i] & 0xf) * (1.0F / 15.0F); + dst[i][ACOMP] = ((s[i] >> 4) & 0xf) * (1.0F / 15.0F); + } } static void -unpack_AL88(const void *src, GLfloat dst[4]) +unpack_AL88(const void *src, GLfloat dst[][4], GLuint n) { - const GLushort s = *((const GLushort *) src); - dst[RCOMP] = - dst[GCOMP] = - dst[BCOMP] = UBYTE_TO_FLOAT( s & 0xff ); - dst[ACOMP] = UBYTE_TO_FLOAT( s >> 8 ); + const GLushort *s = ((const GLushort *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = + dst[i][GCOMP] = + dst[i][BCOMP] = UBYTE_TO_FLOAT( s[i] & 0xff ); + dst[i][ACOMP] = UBYTE_TO_FLOAT( s[i] >> 8 ); + } } static void -unpack_AL88_REV(const void *src, GLfloat dst[4]) +unpack_AL88_REV(const void *src, GLfloat dst[][4], GLuint n) { - const GLushort s = *((const GLushort *) src); - dst[RCOMP] = - dst[GCOMP] = - dst[BCOMP] = UBYTE_TO_FLOAT( s >> 8 ); - dst[ACOMP] = UBYTE_TO_FLOAT( s & 0xff ); + const GLushort *s = ((const GLushort *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = + dst[i][GCOMP] = + dst[i][BCOMP] = UBYTE_TO_FLOAT( s[i] >> 8 ); + dst[i][ACOMP] = UBYTE_TO_FLOAT( s[i] & 0xff ); + } } static void -unpack_AL1616(const void *src, GLfloat dst[4]) +unpack_AL1616(const void *src, GLfloat dst[][4], GLuint n) { - const GLuint s = *((const GLuint *) src); - dst[RCOMP] = - dst[GCOMP] = - dst[BCOMP] = USHORT_TO_FLOAT( s & 0xffff ); - dst[ACOMP] = USHORT_TO_FLOAT( s >> 16 ); + const GLuint *s = ((const GLuint *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = + dst[i][GCOMP] = + dst[i][BCOMP] = USHORT_TO_FLOAT( s[i] & 0xffff ); + dst[i][ACOMP] = USHORT_TO_FLOAT( s[i] >> 16 ); + } } static void -unpack_AL1616_REV(const void *src, GLfloat dst[4]) +unpack_AL1616_REV(const void *src, GLfloat dst[][4], GLuint n) { - const GLuint s = *((const GLuint *) src); - dst[RCOMP] = - dst[GCOMP] = - dst[BCOMP] = USHORT_TO_FLOAT( s >> 16 ); - dst[ACOMP] = USHORT_TO_FLOAT( s & 0xffff ); + const GLuint *s = ((const GLuint *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = + dst[i][GCOMP] = + dst[i][BCOMP] = USHORT_TO_FLOAT( s[i] >> 16 ); + dst[i][ACOMP] = USHORT_TO_FLOAT( s[i] & 0xffff ); + } } static void -unpack_RGB332(const void *src, GLfloat dst[4]) +unpack_RGB332(const void *src, GLfloat dst[][4], GLuint n) { - const GLubyte s = *((const GLubyte *) src); - dst[RCOMP] = ((s >> 5) & 0x7) * (1.0F / 7.0F); - dst[GCOMP] = ((s >> 2) & 0x7) * (1.0F / 7.0F); - dst[BCOMP] = ((s ) & 0x3) * (1.0F / 3.0F); - dst[ACOMP] = 1.0F; + const GLubyte *s = ((const GLubyte *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = ((s[i] >> 5) & 0x7) * (1.0F / 7.0F); + dst[i][GCOMP] = ((s[i] >> 2) & 0x7) * (1.0F / 7.0F); + dst[i][BCOMP] = ((s[i] ) & 0x3) * (1.0F / 3.0F); + dst[i][ACOMP] = 1.0F; + } } static void -unpack_A8(const void *src, GLfloat dst[4]) +unpack_A8(const void *src, GLfloat dst[][4], GLuint n) { - const GLubyte s = *((const GLubyte *) src); - dst[RCOMP] = - dst[GCOMP] = - dst[BCOMP] = 0.0F; - dst[ACOMP] = UBYTE_TO_FLOAT(s); + const GLubyte *s = ((const GLubyte *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = + dst[i][GCOMP] = + dst[i][BCOMP] = 0.0F; + dst[i][ACOMP] = UBYTE_TO_FLOAT(s[i]); + } } static void -unpack_A16(const void *src, GLfloat dst[4]) +unpack_A16(const void *src, GLfloat dst[][4], GLuint n) { - const GLushort s = *((const GLushort *) src); - dst[RCOMP] = - dst[GCOMP] = - dst[BCOMP] = 0.0F; - dst[ACOMP] = USHORT_TO_FLOAT(s); + const GLushort *s = ((const GLushort *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = + dst[i][GCOMP] = + dst[i][BCOMP] = 0.0F; + dst[i][ACOMP] = USHORT_TO_FLOAT(s[i]); + } } static void -unpack_L8(const void *src, GLfloat dst[4]) +unpack_L8(const void *src, GLfloat dst[][4], GLuint n) { - const GLubyte s = *((const GLubyte *) src); - dst[RCOMP] = - dst[GCOMP] = - dst[BCOMP] = UBYTE_TO_FLOAT(s); - dst[ACOMP] = 1.0F; + const GLubyte *s = ((const GLubyte *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = + dst[i][GCOMP] = + dst[i][BCOMP] = UBYTE_TO_FLOAT(s[i]); + dst[i][ACOMP] = 1.0F; + } } static void -unpack_L16(const void *src, GLfloat dst[4]) +unpack_L16(const void *src, GLfloat dst[][4], GLuint n) { - const GLushort s = *((const GLushort *) src); - dst[RCOMP] = - dst[GCOMP] = - dst[BCOMP] = USHORT_TO_FLOAT(s); - dst[ACOMP] = 1.0F; + const GLushort *s = ((const GLushort *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = + dst[i][GCOMP] = + dst[i][BCOMP] = USHORT_TO_FLOAT(s[i]); + dst[i][ACOMP] = 1.0F; + } } static void -unpack_I8(const void *src, GLfloat dst[4]) +unpack_I8(const void *src, GLfloat dst[][4], GLuint n) { - const GLubyte s = *((const GLubyte *) src); - dst[RCOMP] = - dst[GCOMP] = - dst[BCOMP] = - dst[ACOMP] = UBYTE_TO_FLOAT(s); + const GLubyte *s = ((const GLubyte *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = + dst[i][GCOMP] = + dst[i][BCOMP] = + dst[i][ACOMP] = UBYTE_TO_FLOAT(s[i]); + } } static void -unpack_I16(const void *src, GLfloat dst[4]) +unpack_I16(const void *src, GLfloat dst[][4], GLuint n) { - const GLushort s = *((const GLushort *) src); - dst[RCOMP] = - dst[GCOMP] = - dst[BCOMP] = - dst[ACOMP] = USHORT_TO_FLOAT(s); + const GLushort *s = ((const GLushort *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = + dst[i][GCOMP] = + dst[i][BCOMP] = + dst[i][ACOMP] = USHORT_TO_FLOAT(s[i]); + } } static void -unpack_YCBCR(const void *src, GLfloat dst[4]) +unpack_YCBCR(const void *src, GLfloat dst[][4], GLuint n) { - const GLuint i = 0; - const GLushort *src0 = (const GLushort *) src; - const GLushort *src1 = src0 + 1; /* odd */ - const GLubyte y0 = (*src0 >> 8) & 0xff; /* luminance */ - const GLubyte cb = *src0 & 0xff; /* chroma U */ - const GLubyte y1 = (*src1 >> 8) & 0xff; /* luminance */ - const GLubyte cr = *src1 & 0xff; /* chroma V */ - const GLubyte y = (i & 1) ? y1 : y0; /* choose even/odd luminance */ - GLfloat r = 1.164F * (y - 16) + 1.596F * (cr - 128); - GLfloat g = 1.164F * (y - 16) - 0.813F * (cr - 128) - 0.391F * (cb - 128); - GLfloat b = 1.164F * (y - 16) + 2.018F * (cb - 128); - r *= (1.0F / 255.0F); - g *= (1.0F / 255.0F); - b *= (1.0F / 255.0F); - dst[RCOMP] = CLAMP(r, 0.0F, 1.0F); - dst[GCOMP] = CLAMP(g, 0.0F, 1.0F); - dst[BCOMP] = CLAMP(b, 0.0F, 1.0F); - dst[ACOMP] = 1.0F; + GLuint i; + for (i = 0; i < n; i++) { + const GLushort *src0 = ((const GLushort *) src) + i * 2; /* even */ + const GLushort *src1 = src0 + 1; /* odd */ + const GLubyte y0 = (*src0 >> 8) & 0xff; /* luminance */ + const GLubyte cb = *src0 & 0xff; /* chroma U */ + const GLubyte y1 = (*src1 >> 8) & 0xff; /* luminance */ + const GLubyte cr = *src1 & 0xff; /* chroma V */ + const GLubyte y = (i & 1) ? y1 : y0; /* choose even/odd luminance */ + GLfloat r = 1.164F * (y - 16) + 1.596F * (cr - 128); + GLfloat g = 1.164F * (y - 16) - 0.813F * (cr - 128) - 0.391F * (cb - 128); + GLfloat b = 1.164F * (y - 16) + 2.018F * (cb - 128); + r *= (1.0F / 255.0F); + g *= (1.0F / 255.0F); + b *= (1.0F / 255.0F); + dst[i][RCOMP] = CLAMP(r, 0.0F, 1.0F); + dst[i][GCOMP] = CLAMP(g, 0.0F, 1.0F); + dst[i][BCOMP] = CLAMP(b, 0.0F, 1.0F); + dst[i][ACOMP] = 1.0F; + } } static void -unpack_YCBCR_REV(const void *src, GLfloat dst[4]) +unpack_YCBCR_REV(const void *src, GLfloat dst[][4], GLuint n) { - const GLuint i = 0; - const GLushort *src0 = (const GLushort *) src; - const GLushort *src1 = src0 + 1; /* odd */ - const GLubyte y0 = *src0 & 0xff; /* luminance */ - const GLubyte cr = (*src0 >> 8) & 0xff; /* chroma V */ - const GLubyte y1 = *src1 & 0xff; /* luminance */ - const GLubyte cb = (*src1 >> 8) & 0xff; /* chroma U */ - const GLubyte y = (i & 1) ? y1 : y0; /* choose even/odd luminance */ - GLfloat r = 1.164F * (y - 16) + 1.596F * (cr - 128); - GLfloat g = 1.164F * (y - 16) - 0.813F * (cr - 128) - 0.391F * (cb - 128); - GLfloat b = 1.164F * (y - 16) + 2.018F * (cb - 128); - r *= (1.0F / 255.0F); - g *= (1.0F / 255.0F); - b *= (1.0F / 255.0F); - dst[RCOMP] = CLAMP(r, 0.0F, 1.0F); - dst[GCOMP] = CLAMP(g, 0.0F, 1.0F); - dst[BCOMP] = CLAMP(b, 0.0F, 1.0F); - dst[ACOMP] = 1.0F; + GLuint i; + for (i = 0; i < n; i++) { + const GLushort *src0 = ((const GLushort *) src) + i * 2; /* even */ + const GLushort *src1 = src0 + 1; /* odd */ + const GLubyte y0 = *src0 & 0xff; /* luminance */ + const GLubyte cr = (*src0 >> 8) & 0xff; /* chroma V */ + const GLubyte y1 = *src1 & 0xff; /* luminance */ + const GLubyte cb = (*src1 >> 8) & 0xff; /* chroma U */ + const GLubyte y = (i & 1) ? y1 : y0; /* choose even/odd luminance */ + GLfloat r = 1.164F * (y - 16) + 1.596F * (cr - 128); + GLfloat g = 1.164F * (y - 16) - 0.813F * (cr - 128) - 0.391F * (cb - 128); + GLfloat b = 1.164F * (y - 16) + 2.018F * (cb - 128); + r *= (1.0F / 255.0F); + g *= (1.0F / 255.0F); + b *= (1.0F / 255.0F); + dst[i][RCOMP] = CLAMP(r, 0.0F, 1.0F); + dst[i][GCOMP] = CLAMP(g, 0.0F, 1.0F); + dst[i][BCOMP] = CLAMP(b, 0.0F, 1.0F); + dst[i][ACOMP] = 1.0F; + } } static void -unpack_R8(const void *src, GLfloat dst[4]) +unpack_R8(const void *src, GLfloat dst[][4], GLuint n) { - const GLubyte s = *((const GLubyte *) src); - dst[0] = UBYTE_TO_FLOAT(s); - dst[1] = dst[2] = 0.0F; - dst[3] = 1.0F; + const GLubyte *s = ((const GLubyte *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][0] = UBYTE_TO_FLOAT(s[i]); + dst[i][1] = + dst[i][2] = 0.0F; + dst[i][3] = 1.0F; + } } static void -unpack_RG88(const void *src, GLfloat dst[4]) +unpack_RG88(const void *src, GLfloat dst[][4], GLuint n) { - const GLushort s = *((const GLushort *) src); - dst[RCOMP] = UBYTE_TO_FLOAT( s & 0xff ); - dst[GCOMP] = UBYTE_TO_FLOAT( s >> 8 ); - dst[BCOMP] = 0.0; - dst[ACOMP] = 1.0; + const GLushort *s = ((const GLushort *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = UBYTE_TO_FLOAT( s[i] & 0xff ); + dst[i][GCOMP] = UBYTE_TO_FLOAT( s[i] >> 8 ); + dst[i][BCOMP] = 0.0; + dst[i][ACOMP] = 1.0; + } } static void -unpack_RG88_REV(const void *src, GLfloat dst[4]) +unpack_RG88_REV(const void *src, GLfloat dst[][4], GLuint n) { - const GLushort s = *((const GLushort *) src); - dst[RCOMP] = UBYTE_TO_FLOAT( s & 0xff ); - dst[GCOMP] = UBYTE_TO_FLOAT( s >> 8 ); - dst[BCOMP] = 0.0; - dst[ACOMP] = 1.0; + const GLushort *s = ((const GLushort *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = UBYTE_TO_FLOAT( s[i] & 0xff ); + dst[i][GCOMP] = UBYTE_TO_FLOAT( s[i] >> 8 ); + dst[i][BCOMP] = 0.0; + dst[i][ACOMP] = 1.0; + } } static void -unpack_R16(const void *src, GLfloat dst[4]) +unpack_R16(const void *src, GLfloat dst[][4], GLuint n) { - const GLushort s = *((const GLushort *) src); - dst[RCOMP] = USHORT_TO_FLOAT(s); - dst[GCOMP] = 0.0; - dst[BCOMP] = 0.0; - dst[ACOMP] = 1.0; + const GLushort *s = ((const GLushort *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = USHORT_TO_FLOAT(s[i]); + dst[i][GCOMP] = 0.0; + dst[i][BCOMP] = 0.0; + dst[i][ACOMP] = 1.0; + } } static void -unpack_RG1616(const void *src, GLfloat dst[4]) +unpack_RG1616(const void *src, GLfloat dst[][4], GLuint n) { - const GLuint s = *((const GLuint *) src); - dst[RCOMP] = USHORT_TO_FLOAT( s & 0xffff ); - dst[GCOMP] = USHORT_TO_FLOAT( s >> 16 ); - dst[BCOMP] = 0.0; - dst[ACOMP] = 1.0; + const GLuint *s = ((const GLuint *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = USHORT_TO_FLOAT( s[i] & 0xffff ); + dst[i][GCOMP] = USHORT_TO_FLOAT( s[i] >> 16 ); + dst[i][BCOMP] = 0.0; + dst[i][ACOMP] = 1.0; + } } static void -unpack_RG1616_REV(const void *src, GLfloat dst[4]) +unpack_RG1616_REV(const void *src, GLfloat dst[][4], GLuint n) { - const GLuint s = *((const GLuint *) src); - dst[RCOMP] = USHORT_TO_FLOAT( s >> 16 ); - dst[GCOMP] = USHORT_TO_FLOAT( s & 0xffff ); - dst[BCOMP] = 0.0; - dst[ACOMP] = 1.0; + const GLuint *s = ((const GLuint *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = USHORT_TO_FLOAT( s[i] >> 16 ); + dst[i][GCOMP] = USHORT_TO_FLOAT( s[i] & 0xffff ); + dst[i][BCOMP] = 0.0; + dst[i][ACOMP] = 1.0; + } } static void -unpack_ARGB2101010(const void *src, GLfloat dst[4]) +unpack_ARGB2101010(const void *src, GLfloat dst[][4], GLuint n) { - const GLuint s = *((const GLuint *) src); - dst[RCOMP] = ((s >> 20) & 0x3ff) * (1.0F / 1023.0F); - dst[GCOMP] = ((s >> 10) & 0x3ff) * (1.0F / 1023.0F); - dst[BCOMP] = ((s >> 0) & 0x3ff) * (1.0F / 1023.0F); - dst[ACOMP] = ((s >> 30) & 0x03) * (1.0F / 3.0F); + const GLuint *s = ((const GLuint *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = ((s[i] >> 20) & 0x3ff) * (1.0F / 1023.0F); + dst[i][GCOMP] = ((s[i] >> 10) & 0x3ff) * (1.0F / 1023.0F); + dst[i][BCOMP] = ((s[i] >> 0) & 0x3ff) * (1.0F / 1023.0F); + dst[i][ACOMP] = ((s[i] >> 30) & 0x03) * (1.0F / 3.0F); + } } static void -unpack_Z24_S8(const void *src, GLfloat dst[4]) +unpack_Z24_S8(const void *src, GLfloat dst[][4], GLuint n) { /* only return Z, not stencil data */ - const GLuint s = *((const GLuint *) src); + const GLuint *s = ((const GLuint *) src); const GLfloat scale = 1.0F / (GLfloat) 0xffffff; - dst[0] = dst[1] = dst[2] = (s >> 8) * scale; - dst[3] = 1.0F; - ASSERT(dst[0] >= 0.0F); - ASSERT(dst[0] <= 1.0F); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][0] = + dst[i][1] = + dst[i][2] = (s[i] >> 8) * scale; + dst[i][3] = 1.0F; + ASSERT(dst[i][0] >= 0.0F); + ASSERT(dst[i][0] <= 1.0F); + } } static void -unpack_S8_Z24(const void *src, GLfloat dst[4]) +unpack_S8_Z24(const void *src, GLfloat dst[][4], GLuint n) { /* only return Z, not stencil data */ - const GLuint s = *((const GLuint *) src); + const GLuint *s = ((const GLuint *) src); const GLfloat scale = 1.0F / (GLfloat) 0xffffff; - dst[0] = dst[1] = dst[2] = (s & 0x00ffffff) * scale; - dst[3] = 1.0F; - ASSERT(dst[0] >= 0.0F); - ASSERT(dst[0] <= 1.0F); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][0] = + dst[i][1] = + dst[i][2] = (s[i] & 0x00ffffff) * scale; + dst[i][3] = 1.0F; + ASSERT(dst[i][0] >= 0.0F); + ASSERT(dst[i][0] <= 1.0F); + } } static void -unpack_Z16(const void *src, GLfloat dst[4]) +unpack_Z16(const void *src, GLfloat dst[][4], GLuint n) { - const GLushort s = *((const GLushort *) src); - dst[0] = dst[1] = dst[2] = s * (1.0F / 65535.0F); - dst[3] = 1.0F; + const GLushort *s = ((const GLushort *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][0] = + dst[i][1] = + dst[i][2] = s[i] * (1.0F / 65535.0F); + dst[i][3] = 1.0F; + } } static void -unpack_X8_Z24(const void *src, GLfloat dst[4]) +unpack_X8_Z24(const void *src, GLfloat dst[][4], GLuint n) { - unpack_S8_Z24(src, dst); + unpack_S8_Z24(src, dst, n); } static void -unpack_Z24_X8(const void *src, GLfloat dst[4]) +unpack_Z24_X8(const void *src, GLfloat dst[][4], GLuint n) { - unpack_Z24_S8(src, dst); + unpack_Z24_S8(src, dst, n); } static void -unpack_Z32(const void *src, GLfloat dst[4]) +unpack_Z32(const void *src, GLfloat dst[][4], GLuint n) { - const GLuint s = *((const GLuint *) src); - dst[0] = dst[1] = dst[2] = s * (1.0F / 0xffffffff); - dst[3] = 1.0F; + const GLuint *s = ((const GLuint *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][0] = + dst[i][1] = + dst[i][2] = s[i] * (1.0F / 0xffffffff); + dst[i][3] = 1.0F; + } } static void -unpack_Z32_FLOAT(const void *src, GLfloat dst[4]) +unpack_Z32_FLOAT(const void *src, GLfloat dst[][4], GLuint n) { - const GLfloat s = *((const GLfloat *) src); - dst[0] = dst[1] = dst[2] = s; - dst[3] = 1.0F; + const GLfloat *s = ((const GLfloat *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][0] = + dst[i][1] = + dst[i][2] = s[i]; + dst[i][3] = 1.0F; + } } static void -unpack_Z32_FLOAT_X24S8(const void *src, GLfloat dst[4]) +unpack_Z32_FLOAT_X24S8(const void *src, GLfloat dst[][4], GLuint n) { - const GLfloat s = *((const GLfloat *) src); - dst[0] = dst[1] = dst[2] = s; - dst[3] = 1.0F; + const GLfloat *s = ((const GLfloat *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][0] = + dst[i][1] = + dst[i][2] = s[i]; + dst[i][3] = 1.0F; + } } static void -unpack_S8(const void *src, GLfloat dst[4]) +unpack_S8(const void *src, GLfloat dst[][4], GLuint n) { /* should never be used */ - dst[0] = dst[1] = dst[2] = 0.0F; - dst[3] = 1.0F; + GLuint i; + for (i = 0; i < n; i++) { + dst[i][0] = + dst[i][1] = + dst[i][2] = 0.0F; + dst[i][3] = 1.0F; + } } static void -unpack_SRGB8(const void *src, GLfloat dst[4]) +unpack_SRGB8(const void *src, GLfloat dst[][4], GLuint n) { const GLubyte *s = (const GLubyte *) src; - dst[RCOMP] = nonlinear_to_linear(s[2]); - dst[GCOMP] = nonlinear_to_linear(s[1]); - dst[BCOMP] = nonlinear_to_linear(s[0]); - dst[ACOMP] = 1.0F; + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = nonlinear_to_linear(s[i*3+2]); + dst[i][GCOMP] = nonlinear_to_linear(s[i*3+1]); + dst[i][BCOMP] = nonlinear_to_linear(s[i*3+0]); + dst[i][ACOMP] = 1.0F; + } } static void -unpack_SRGBA8(const void *src, GLfloat dst[4]) +unpack_SRGBA8(const void *src, GLfloat dst[][4], GLuint n) { - const GLuint s = *((const GLuint *) src); - dst[RCOMP] = nonlinear_to_linear( (s >> 24) ); - dst[GCOMP] = nonlinear_to_linear( (s >> 16) & 0xff ); - dst[BCOMP] = nonlinear_to_linear( (s >> 8) & 0xff ); - dst[ACOMP] = UBYTE_TO_FLOAT( (s ) & 0xff ); /* linear! */ + const GLuint *s = ((const GLuint *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = nonlinear_to_linear( (s[i] >> 24) ); + dst[i][GCOMP] = nonlinear_to_linear( (s[i] >> 16) & 0xff ); + dst[i][BCOMP] = nonlinear_to_linear( (s[i] >> 8) & 0xff ); + dst[i][ACOMP] = UBYTE_TO_FLOAT( s[i] & 0xff ); /* linear! */ + } } static void -unpack_SARGB8(const void *src, GLfloat dst[4]) +unpack_SARGB8(const void *src, GLfloat dst[][4], GLuint n) { - const GLuint s = *((const GLuint *) src); - dst[RCOMP] = nonlinear_to_linear( (s >> 16) & 0xff ); - dst[GCOMP] = nonlinear_to_linear( (s >> 8) & 0xff ); - dst[BCOMP] = nonlinear_to_linear( (s ) & 0xff ); - dst[ACOMP] = UBYTE_TO_FLOAT( (s >> 24) ); /* linear! */ + const GLuint *s = ((const GLuint *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = nonlinear_to_linear( (s[i] >> 16) & 0xff ); + dst[i][GCOMP] = nonlinear_to_linear( (s[i] >> 8) & 0xff ); + dst[i][BCOMP] = nonlinear_to_linear( (s[i] ) & 0xff ); + dst[i][ACOMP] = UBYTE_TO_FLOAT( s[i] >> 24 ); /* linear! */ + } } static void -unpack_SL8(const void *src, GLfloat dst[4]) +unpack_SL8(const void *src, GLfloat dst[][4], GLuint n) { - const GLubyte s = *((const GLubyte *) src); - dst[RCOMP] = - dst[GCOMP] = - dst[BCOMP] = nonlinear_to_linear(s); - dst[ACOMP] = 1.0F; + const GLubyte *s = ((const GLubyte *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = + dst[i][GCOMP] = + dst[i][BCOMP] = nonlinear_to_linear(s[i]); + dst[i][ACOMP] = 1.0F; + } } static void -unpack_SLA8(const void *src, GLfloat dst[4]) +unpack_SLA8(const void *src, GLfloat dst[][4], GLuint n) { const GLubyte *s = (const GLubyte *) src; - dst[RCOMP] = - dst[GCOMP] = - dst[BCOMP] = nonlinear_to_linear(s[0]); - dst[ACOMP] = UBYTE_TO_FLOAT(s[1]); /* linear */ + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = + dst[i][GCOMP] = + dst[i][BCOMP] = nonlinear_to_linear(s[i*2+0]); + dst[i][ACOMP] = UBYTE_TO_FLOAT(s[i*2+1]); /* linear! */ + } } static void -unpack_SRGB_DXT1(const void *src, GLfloat dst[4]) +unpack_SRGB_DXT1(const void *src, GLfloat dst[][4], GLuint n) { } static void -unpack_SRGBA_DXT1(const void *src, GLfloat dst[4]) +unpack_SRGBA_DXT1(const void *src, GLfloat dst[][4], GLuint n) { } static void -unpack_SRGBA_DXT3(const void *src, GLfloat dst[4]) +unpack_SRGBA_DXT3(const void *src, GLfloat dst[][4], GLuint n) { } static void -unpack_SRGBA_DXT5(const void *src, GLfloat dst[4]) +unpack_SRGBA_DXT5(const void *src, GLfloat dst[][4], GLuint n) { } static void -unpack_RGB_FXT1(const void *src, GLfloat dst[4]) +unpack_RGB_FXT1(const void *src, GLfloat dst[][4], GLuint n) { } static void -unpack_RGBA_FXT1(const void *src, GLfloat dst[4]) +unpack_RGBA_FXT1(const void *src, GLfloat dst[][4], GLuint n) { } static void -unpack_RGB_DXT1(const void *src, GLfloat dst[4]) +unpack_RGB_DXT1(const void *src, GLfloat dst[][4], GLuint n) { } static void -unpack_RGBA_DXT1(const void *src, GLfloat dst[4]) +unpack_RGBA_DXT1(const void *src, GLfloat dst[][4], GLuint n) { } static void -unpack_RGBA_DXT3(const void *src, GLfloat dst[4]) +unpack_RGBA_DXT3(const void *src, GLfloat dst[][4], GLuint n) { } static void -unpack_RGBA_DXT5(const void *src, GLfloat dst[4]) +unpack_RGBA_DXT5(const void *src, GLfloat dst[][4], GLuint n) { } static void -unpack_RGBA_FLOAT32(const void *src, GLfloat dst[4]) +unpack_RGBA_FLOAT32(const void *src, GLfloat dst[][4], GLuint n) { const GLfloat *s = (const GLfloat *) src; - dst[RCOMP] = s[0]; - dst[GCOMP] = s[1]; - dst[BCOMP] = s[2]; - dst[ACOMP] = s[3]; + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = s[i*4+0]; + dst[i][GCOMP] = s[i*4+1]; + dst[i][BCOMP] = s[i*4+2]; + dst[i][ACOMP] = s[i*4+3]; + } } static void -unpack_RGBA_FLOAT16(const void *src, GLfloat dst[4]) +unpack_RGBA_FLOAT16(const void *src, GLfloat dst[][4], GLuint n) { const GLhalfARB *s = (const GLhalfARB *) src; - dst[RCOMP] = _mesa_half_to_float(s[0]); - dst[GCOMP] = _mesa_half_to_float(s[1]); - dst[BCOMP] = _mesa_half_to_float(s[2]); - dst[ACOMP] = _mesa_half_to_float(s[3]); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = _mesa_half_to_float(s[i*4+0]); + dst[i][GCOMP] = _mesa_half_to_float(s[i*4+1]); + dst[i][BCOMP] = _mesa_half_to_float(s[i*4+2]); + dst[i][ACOMP] = _mesa_half_to_float(s[i*4+3]); + } } static void -unpack_RGB_FLOAT32(const void *src, GLfloat dst[4]) +unpack_RGB_FLOAT32(const void *src, GLfloat dst[][4], GLuint n) { const GLfloat *s = (const GLfloat *) src; - dst[RCOMP] = s[0]; - dst[GCOMP] = s[1]; - dst[BCOMP] = s[2]; - dst[ACOMP] = 1.0F; + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = s[i*3+0]; + dst[i][GCOMP] = s[i*3+1]; + dst[i][BCOMP] = s[i*3+2]; + dst[i][ACOMP] = 1.0F; + } } static void -unpack_RGB_FLOAT16(const void *src, GLfloat dst[4]) +unpack_RGB_FLOAT16(const void *src, GLfloat dst[][4], GLuint n) { const GLhalfARB *s = (const GLhalfARB *) src; - dst[RCOMP] = _mesa_half_to_float(s[0]); - dst[GCOMP] = _mesa_half_to_float(s[1]); - dst[BCOMP] = _mesa_half_to_float(s[2]); - dst[ACOMP] = 1.0F; + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = _mesa_half_to_float(s[i*3+0]); + dst[i][GCOMP] = _mesa_half_to_float(s[i*3+1]); + dst[i][BCOMP] = _mesa_half_to_float(s[i*3+2]); + dst[i][ACOMP] = 1.0F; + } } static void -unpack_ALPHA_FLOAT32(const void *src, GLfloat dst[4]) +unpack_ALPHA_FLOAT32(const void *src, GLfloat dst[][4], GLuint n) { const GLfloat *s = (const GLfloat *) src; - dst[RCOMP] = - dst[GCOMP] = - dst[BCOMP] = 0.0F; - dst[ACOMP] = s[0]; + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = + dst[i][GCOMP] = + dst[i][BCOMP] = 0.0F; + dst[i][ACOMP] = s[i]; + } } static void -unpack_ALPHA_FLOAT16(const void *src, GLfloat dst[4]) +unpack_ALPHA_FLOAT16(const void *src, GLfloat dst[][4], GLuint n) { const GLhalfARB *s = (const GLhalfARB *) src; - dst[RCOMP] = - dst[GCOMP] = - dst[BCOMP] = 0.0F; - dst[ACOMP] = _mesa_half_to_float(s[0]); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = + dst[i][GCOMP] = + dst[i][BCOMP] = 0.0F; + dst[i][ACOMP] = _mesa_half_to_float(s[i]); + } } static void -unpack_LUMINANCE_FLOAT32(const void *src, GLfloat dst[4]) +unpack_LUMINANCE_FLOAT32(const void *src, GLfloat dst[][4], GLuint n) { const GLfloat *s = (const GLfloat *) src; - dst[RCOMP] = - dst[GCOMP] = - dst[BCOMP] = s[0]; - dst[ACOMP] = 1.0F; + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = + dst[i][GCOMP] = + dst[i][BCOMP] = s[i]; + dst[i][ACOMP] = 1.0F; + } } static void -unpack_LUMINANCE_FLOAT16(const void *src, GLfloat dst[4]) +unpack_LUMINANCE_FLOAT16(const void *src, GLfloat dst[][4], GLuint n) { const GLhalfARB *s = (const GLhalfARB *) src; - dst[RCOMP] = - dst[GCOMP] = - dst[BCOMP] = _mesa_half_to_float(s[0]); - dst[ACOMP] = 1.0F; + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = + dst[i][GCOMP] = + dst[i][BCOMP] = _mesa_half_to_float(s[i]); + dst[i][ACOMP] = 1.0F; + } } static void -unpack_LUMINANCE_ALPHA_FLOAT32(const void *src, GLfloat dst[4]) +unpack_LUMINANCE_ALPHA_FLOAT32(const void *src, GLfloat dst[][4], GLuint n) { const GLfloat *s = (const GLfloat *) src; - dst[RCOMP] = - dst[GCOMP] = - dst[BCOMP] = s[0]; - dst[ACOMP] = s[1]; + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = + dst[i][GCOMP] = + dst[i][BCOMP] = s[i*2+0]; + dst[i][ACOMP] = s[i*2+1]; + } } static void -unpack_LUMINANCE_ALPHA_FLOAT16(const void *src, GLfloat dst[4]) +unpack_LUMINANCE_ALPHA_FLOAT16(const void *src, GLfloat dst[][4], GLuint n) { const GLhalfARB *s = (const GLhalfARB *) src; - dst[RCOMP] = - dst[GCOMP] = - dst[BCOMP] = _mesa_half_to_float(s[0]); - dst[ACOMP] = _mesa_half_to_float(s[1]); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = + dst[i][GCOMP] = + dst[i][BCOMP] = _mesa_half_to_float(s[i*2+0]); + dst[i][ACOMP] = _mesa_half_to_float(s[i*2+1]); + } } static void -unpack_INTENSITY_FLOAT32(const void *src, GLfloat dst[4]) +unpack_INTENSITY_FLOAT32(const void *src, GLfloat dst[][4], GLuint n) { const GLfloat *s = (const GLfloat *) src; - dst[RCOMP] = - dst[GCOMP] = - dst[BCOMP] = - dst[ACOMP] = s[0]; + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = + dst[i][GCOMP] = + dst[i][BCOMP] = + dst[i][ACOMP] = s[i]; + } } static void -unpack_INTENSITY_FLOAT16(const void *src, GLfloat dst[4]) +unpack_INTENSITY_FLOAT16(const void *src, GLfloat dst[][4], GLuint n) { const GLhalfARB *s = (const GLhalfARB *) src; - dst[RCOMP] = - dst[GCOMP] = - dst[BCOMP] = - dst[ACOMP] = s[0]; + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = + dst[i][GCOMP] = + dst[i][BCOMP] = + dst[i][ACOMP] = s[i]; + } } static void -unpack_R_FLOAT32(const void *src, GLfloat dst[4]) +unpack_R_FLOAT32(const void *src, GLfloat dst[][4], GLuint n) { const GLfloat *s = (const GLfloat *) src; - dst[RCOMP] = s[0]; - dst[GCOMP] = 0.0F; - dst[BCOMP] = 0.0F; - dst[ACOMP] = 1.0F; + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = s[i]; + dst[i][GCOMP] = 0.0F; + dst[i][BCOMP] = 0.0F; + dst[i][ACOMP] = 1.0F; + } } static void -unpack_R_FLOAT16(const void *src, GLfloat dst[4]) +unpack_R_FLOAT16(const void *src, GLfloat dst[][4], GLuint n) { const GLhalfARB *s = (const GLhalfARB *) src; - dst[RCOMP] = _mesa_half_to_float(s[0]); - dst[GCOMP] = 0.0F; - dst[BCOMP] = 0.0F; - dst[ACOMP] = 1.0F; + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = _mesa_half_to_float(s[i]); + dst[i][GCOMP] = 0.0F; + dst[i][BCOMP] = 0.0F; + dst[i][ACOMP] = 1.0F; + } } static void -unpack_RG_FLOAT32(const void *src, GLfloat dst[4]) +unpack_RG_FLOAT32(const void *src, GLfloat dst[][4], GLuint n) { const GLfloat *s = (const GLfloat *) src; - dst[RCOMP] = s[0]; - dst[GCOMP] = s[1]; - dst[BCOMP] = 0.0F; - dst[ACOMP] = 1.0F; + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = s[i*2+0]; + dst[i][GCOMP] = s[i*2+1]; + dst[i][BCOMP] = 0.0F; + dst[i][ACOMP] = 1.0F; + } } static void -unpack_RG_FLOAT16(const void *src, GLfloat dst[4]) +unpack_RG_FLOAT16(const void *src, GLfloat dst[][4], GLuint n) { const GLhalfARB *s = (const GLhalfARB *) src; - dst[RCOMP] = _mesa_half_to_float(s[0]); - dst[GCOMP] = _mesa_half_to_float(s[1]); - dst[BCOMP] = 0.0F; - dst[ACOMP] = 1.0F; + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = _mesa_half_to_float(s[i*2+0]); + dst[i][GCOMP] = _mesa_half_to_float(s[i*2+1]); + dst[i][BCOMP] = 0.0F; + dst[i][ACOMP] = 1.0F; + } } static void -unpack_RGBA_INT8(const void *src, GLfloat dst[4]) +unpack_RGBA_INT8(const void *src, GLfloat dst[][4], GLuint n) { const GLbyte *s = (const GLbyte *) src; - dst[RCOMP] = (GLfloat) s[0]; - dst[GCOMP] = (GLfloat) s[1]; - dst[BCOMP] = (GLfloat) s[2]; - dst[ACOMP] = (GLfloat) s[3]; + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = (GLfloat) s[i*4+0]; + dst[i][GCOMP] = (GLfloat) s[i*4+1]; + dst[i][BCOMP] = (GLfloat) s[i*4+2]; + dst[i][ACOMP] = (GLfloat) s[i*4+3]; + } } static void -unpack_RGBA_INT16(const void *src, GLfloat dst[4]) +unpack_RGBA_INT16(const void *src, GLfloat dst[][4], GLuint n) { const GLshort *s = (const GLshort *) src; - dst[RCOMP] = (GLfloat) s[0]; - dst[GCOMP] = (GLfloat) s[1]; - dst[BCOMP] = (GLfloat) s[2]; - dst[ACOMP] = (GLfloat) s[3]; + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = (GLfloat) s[i*4+0]; + dst[i][GCOMP] = (GLfloat) s[i*4+1]; + dst[i][BCOMP] = (GLfloat) s[i*4+2]; + dst[i][ACOMP] = (GLfloat) s[i*4+3]; + } } static void -unpack_RGBA_INT32(const void *src, GLfloat dst[4]) +unpack_RGBA_INT32(const void *src, GLfloat dst[][4], GLuint n) { const GLint *s = (const GLint *) src; - dst[RCOMP] = (GLfloat) s[0]; - dst[GCOMP] = (GLfloat) s[1]; - dst[BCOMP] = (GLfloat) s[2]; - dst[ACOMP] = (GLfloat) s[3]; + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = (GLfloat) s[i*4+0]; + dst[i][GCOMP] = (GLfloat) s[i*4+1]; + dst[i][BCOMP] = (GLfloat) s[i*4+2]; + dst[i][ACOMP] = (GLfloat) s[i*4+3]; + } } static void -unpack_RGBA_UINT8(const void *src, GLfloat dst[4]) +unpack_RGBA_UINT8(const void *src, GLfloat dst[][4], GLuint n) { const GLubyte *s = (const GLubyte *) src; - dst[RCOMP] = (GLfloat) s[0]; - dst[GCOMP] = (GLfloat) s[1]; - dst[BCOMP] = (GLfloat) s[2]; - dst[ACOMP] = (GLfloat) s[3]; + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = (GLfloat) s[i*4+0]; + dst[i][GCOMP] = (GLfloat) s[i*4+1]; + dst[i][BCOMP] = (GLfloat) s[i*4+2]; + dst[i][ACOMP] = (GLfloat) s[i*4+3]; + } } static void -unpack_RGBA_UINT16(const void *src, GLfloat dst[4]) +unpack_RGBA_UINT16(const void *src, GLfloat dst[][4], GLuint n) { const GLushort *s = (const GLushort *) src; - dst[RCOMP] = (GLfloat) s[0]; - dst[GCOMP] = (GLfloat) s[1]; - dst[BCOMP] = (GLfloat) s[2]; - dst[ACOMP] = (GLfloat) s[3]; + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = (GLfloat) s[i*4+0]; + dst[i][GCOMP] = (GLfloat) s[i*4+1]; + dst[i][BCOMP] = (GLfloat) s[i*4+2]; + dst[i][ACOMP] = (GLfloat) s[i*4+3]; + } } static void -unpack_RGBA_UINT32(const void *src, GLfloat dst[4]) +unpack_RGBA_UINT32(const void *src, GLfloat dst[][4], GLuint n) { const GLuint *s = (const GLuint *) src; - dst[RCOMP] = (GLfloat) s[0]; - dst[GCOMP] = (GLfloat) s[1]; - dst[BCOMP] = (GLfloat) s[2]; - dst[ACOMP] = (GLfloat) s[3]; + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = (GLfloat) s[i*4+0]; + dst[i][GCOMP] = (GLfloat) s[i*4+1]; + dst[i][BCOMP] = (GLfloat) s[i*4+2]; + dst[i][ACOMP] = (GLfloat) s[i*4+3]; + } } static void -unpack_DUDV8(const void *src, GLfloat dst[4]) +unpack_DUDV8(const void *src, GLfloat dst[][4], GLuint n) { const GLbyte *s = (const GLbyte *) src; - dst[RCOMP] = BYTE_TO_FLOAT(s[0]); - dst[GCOMP] = BYTE_TO_FLOAT(s[1]); - dst[BCOMP] = 0; - dst[ACOMP] = 0; + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = BYTE_TO_FLOAT(s[i*2+0]); + dst[i][GCOMP] = BYTE_TO_FLOAT(s[i*2+1]); + dst[i][BCOMP] = 0; + dst[i][ACOMP] = 0; + } } static void -unpack_SIGNED_R8(const void *src, GLfloat dst[4]) +unpack_SIGNED_R8(const void *src, GLfloat dst[][4], GLuint n) { - const GLbyte s = *((const GLbyte *) src); - dst[RCOMP] = BYTE_TO_FLOAT_TEX( s ); - dst[GCOMP] = 0.0F; - dst[BCOMP] = 0.0F; - dst[ACOMP] = 1.0F; + const GLbyte *s = ((const GLbyte *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = BYTE_TO_FLOAT_TEX( s[i] ); + dst[i][GCOMP] = 0.0F; + dst[i][BCOMP] = 0.0F; + dst[i][ACOMP] = 1.0F; + } } static void -unpack_SIGNED_RG88_REV(const void *src, GLfloat dst[4]) +unpack_SIGNED_RG88_REV(const void *src, GLfloat dst[][4], GLuint n) { - const GLushort s = *((const GLushort *) src); - dst[RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s & 0xff) ); - dst[GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 8) ); - dst[BCOMP] = 0.0F; - dst[ACOMP] = 1.0F; + const GLushort *s = ((const GLushort *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s[i] & 0xff) ); + dst[i][GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s[i] >> 8) ); + dst[i][BCOMP] = 0.0F; + dst[i][ACOMP] = 1.0F; + } } static void -unpack_SIGNED_RGBX8888(const void *src, GLfloat dst[4]) +unpack_SIGNED_RGBX8888(const void *src, GLfloat dst[][4], GLuint n) { - const GLuint s = *((const GLuint *) src); - dst[RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 24) ); - dst[GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 16) ); - dst[BCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 8) ); - dst[ACOMP] = 1.0f; + const GLuint *s = ((const GLuint *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s[i] >> 24) ); + dst[i][GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s[i] >> 16) ); + dst[i][BCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s[i] >> 8) ); + dst[i][ACOMP] = 1.0f; + } } static void -unpack_SIGNED_RGBA8888(const void *src, GLfloat dst[4]) +unpack_SIGNED_RGBA8888(const void *src, GLfloat dst[][4], GLuint n) { - const GLuint s = *((const GLuint *) src); - dst[RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 24) ); - dst[GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 16) ); - dst[BCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 8) ); - dst[ACOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s ) ); + const GLuint *s = ((const GLuint *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s[i] >> 24) ); + dst[i][GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s[i] >> 16) ); + dst[i][BCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s[i] >> 8) ); + dst[i][ACOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s[i] ) ); + } } static void -unpack_SIGNED_RGBA8888_REV(const void *src, GLfloat dst[4]) +unpack_SIGNED_RGBA8888_REV(const void *src, GLfloat dst[][4], GLuint n) { - const GLuint s = *((const GLuint *) src); - dst[RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s ) ); - dst[GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 8) ); - dst[BCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 16) ); - dst[ACOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 24) ); + const GLuint *s = ((const GLuint *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s[i] ) ); + dst[i][GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s[i] >> 8) ); + dst[i][BCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s[i] >> 16) ); + dst[i][ACOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s[i] >> 24) ); + } } static void -unpack_SIGNED_R16(const void *src, GLfloat dst[4]) +unpack_SIGNED_R16(const void *src, GLfloat dst[][4], GLuint n) { - const GLshort s = *((const GLshort *) src); - dst[RCOMP] = SHORT_TO_FLOAT_TEX( s ); - dst[GCOMP] = 0.0F; - dst[BCOMP] = 0.0F; - dst[ACOMP] = 1.0F; + const GLshort *s = ((const GLshort *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = SHORT_TO_FLOAT_TEX( s[i] ); + dst[i][GCOMP] = 0.0F; + dst[i][BCOMP] = 0.0F; + dst[i][ACOMP] = 1.0F; + } } static void -unpack_SIGNED_GR1616(const void *src, GLfloat dst[4]) +unpack_SIGNED_GR1616(const void *src, GLfloat dst[][4], GLuint n) { - const GLuint s = *((const GLuint *) src); - dst[RCOMP] = SHORT_TO_FLOAT_TEX( s & 0xffff ); - dst[GCOMP] = SHORT_TO_FLOAT_TEX( s >> 16 ); - dst[BCOMP] = 0.0F; - dst[ACOMP] = 1.0F; + const GLuint *s = ((const GLuint *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = SHORT_TO_FLOAT_TEX( s[i] & 0xffff ); + dst[i][GCOMP] = SHORT_TO_FLOAT_TEX( s[i] >> 16 ); + dst[i][BCOMP] = 0.0F; + dst[i][ACOMP] = 1.0F; + } } static void -unpack_SIGNED_RGB_16(const void *src, GLfloat dst[4]) +unpack_SIGNED_RGB_16(const void *src, GLfloat dst[][4], GLuint n) { const GLshort *s = (const GLshort *) src; - dst[RCOMP] = SHORT_TO_FLOAT_TEX( s[0] ); - dst[GCOMP] = SHORT_TO_FLOAT_TEX( s[1] ); - dst[BCOMP] = SHORT_TO_FLOAT_TEX( s[2] ); - dst[ACOMP] = 1.0F; + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = SHORT_TO_FLOAT_TEX( s[i*3+0] ); + dst[i][GCOMP] = SHORT_TO_FLOAT_TEX( s[i*3+1] ); + dst[i][BCOMP] = SHORT_TO_FLOAT_TEX( s[i*3+2] ); + dst[i][ACOMP] = 1.0F; + } } static void -unpack_SIGNED_RGBA_16(const void *src, GLfloat dst[4]) +unpack_SIGNED_RGBA_16(const void *src, GLfloat dst[][4], GLuint n) { const GLshort *s = (const GLshort *) src; - dst[RCOMP] = SHORT_TO_FLOAT_TEX( s[0] ); - dst[GCOMP] = SHORT_TO_FLOAT_TEX( s[1] ); - dst[BCOMP] = SHORT_TO_FLOAT_TEX( s[2] ); - dst[ACOMP] = SHORT_TO_FLOAT_TEX( s[3] ); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = SHORT_TO_FLOAT_TEX( s[i*4+0] ); + dst[i][GCOMP] = SHORT_TO_FLOAT_TEX( s[i*4+1] ); + dst[i][BCOMP] = SHORT_TO_FLOAT_TEX( s[i*4+2] ); + dst[i][ACOMP] = SHORT_TO_FLOAT_TEX( s[i*4+3] ); + } } static void -unpack_RGBA_16(const void *src, GLfloat dst[4]) +unpack_RGBA_16(const void *src, GLfloat dst[][4], GLuint n) { const GLushort *s = (const GLushort *) src; - dst[RCOMP] = USHORT_TO_FLOAT( s[0] ); - dst[GCOMP] = USHORT_TO_FLOAT( s[1] ); - dst[BCOMP] = USHORT_TO_FLOAT( s[2] ); - dst[ACOMP] = USHORT_TO_FLOAT( s[3] ); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = USHORT_TO_FLOAT( s[i*4+0] ); + dst[i][GCOMP] = USHORT_TO_FLOAT( s[i*4+1] ); + dst[i][BCOMP] = USHORT_TO_FLOAT( s[i*4+2] ); + dst[i][ACOMP] = USHORT_TO_FLOAT( s[i*4+3] ); + } } static void -unpack_RED_RGTC1(const void *src, GLfloat dst[4]) +unpack_RED_RGTC1(const void *src, GLfloat dst[][4], GLuint n) { /* XXX to do */ } static void -unpack_SIGNED_RED_RGTC1(const void *src, GLfloat dst[4]) +unpack_SIGNED_RED_RGTC1(const void *src, GLfloat dst[][4], GLuint n) { /* XXX to do */ } static void -unpack_RG_RGTC2(const void *src, GLfloat dst[4]) +unpack_RG_RGTC2(const void *src, GLfloat dst[][4], GLuint n) { /* XXX to do */ } static void -unpack_SIGNED_RG_RGTC2(const void *src, GLfloat dst[4]) +unpack_SIGNED_RG_RGTC2(const void *src, GLfloat dst[][4], GLuint n) { /* XXX to do */ } static void -unpack_L_LATC1(const void *src, GLfloat dst[4]) +unpack_L_LATC1(const void *src, GLfloat dst[][4], GLuint n) { /* XXX to do */ } static void -unpack_SIGNED_L_LATC1(const void *src, GLfloat dst[4]) +unpack_SIGNED_L_LATC1(const void *src, GLfloat dst[][4], GLuint n) { /* XXX to do */ } static void -unpack_LA_LATC2(const void *src, GLfloat dst[4]) +unpack_LA_LATC2(const void *src, GLfloat dst[][4], GLuint n) { /* XXX to do */ } static void -unpack_SIGNED_LA_LATC2(const void *src, GLfloat dst[4]) +unpack_SIGNED_LA_LATC2(const void *src, GLfloat dst[][4], GLuint n) { /* XXX to do */ } static void -unpack_SIGNED_A8(const void *src, GLfloat dst[4]) +unpack_SIGNED_A8(const void *src, GLfloat dst[][4], GLuint n) { - const GLbyte s = *((const GLbyte *) src); - dst[RCOMP] = 0.0F; - dst[GCOMP] = 0.0F; - dst[BCOMP] = 0.0F; - dst[ACOMP] = BYTE_TO_FLOAT_TEX( s ); + const GLbyte *s = ((const GLbyte *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = 0.0F; + dst[i][GCOMP] = 0.0F; + dst[i][BCOMP] = 0.0F; + dst[i][ACOMP] = BYTE_TO_FLOAT_TEX( s[i] ); + } } static void -unpack_SIGNED_L8(const void *src, GLfloat dst[4]) +unpack_SIGNED_L8(const void *src, GLfloat dst[][4], GLuint n) { - const GLbyte s = *((const GLbyte *) src); - dst[RCOMP] = - dst[GCOMP] = - dst[BCOMP] = BYTE_TO_FLOAT_TEX( s ); - dst[ACOMP] = 1.0F; + const GLbyte *s = ((const GLbyte *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = + dst[i][GCOMP] = + dst[i][BCOMP] = BYTE_TO_FLOAT_TEX( s[i] ); + dst[i][ACOMP] = 1.0F; + } } static void -unpack_SIGNED_AL88(const void *src, GLfloat dst[4]) +unpack_SIGNED_AL88(const void *src, GLfloat dst[][4], GLuint n) { - const GLushort s = *((const GLshort *) src); - dst[RCOMP] = - dst[GCOMP] = - dst[BCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s & 0xff) ); - dst[ACOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 8) ); + const GLshort *s = ((const GLshort *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = + dst[i][GCOMP] = + dst[i][BCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s[i] & 0xff) ); + dst[i][ACOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s[i] >> 8) ); + } } static void -unpack_SIGNED_I8(const void *src, GLfloat dst[4]) +unpack_SIGNED_I8(const void *src, GLfloat dst[][4], GLuint n) { - const GLbyte s = *((const GLbyte *) src); - dst[RCOMP] = - dst[GCOMP] = - dst[BCOMP] = - dst[ACOMP] = BYTE_TO_FLOAT_TEX( s ); + const GLbyte *s = ((const GLbyte *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = + dst[i][GCOMP] = + dst[i][BCOMP] = + dst[i][ACOMP] = BYTE_TO_FLOAT_TEX( s[i] ); + } } static void -unpack_SIGNED_A16(const void *src, GLfloat dst[4]) +unpack_SIGNED_A16(const void *src, GLfloat dst[][4], GLuint n) { - const GLshort s = *((const GLshort *) src); - dst[RCOMP] = 0.0F; - dst[GCOMP] = 0.0F; - dst[BCOMP] = 0.0F; - dst[ACOMP] = SHORT_TO_FLOAT_TEX( s ); + const GLshort *s = ((const GLshort *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = 0.0F; + dst[i][GCOMP] = 0.0F; + dst[i][BCOMP] = 0.0F; + dst[i][ACOMP] = SHORT_TO_FLOAT_TEX( s[i] ); + } } static void -unpack_SIGNED_L16(const void *src, GLfloat dst[4]) +unpack_SIGNED_L16(const void *src, GLfloat dst[][4], GLuint n) { - const GLshort s = *((const GLshort *) src); - dst[RCOMP] = - dst[GCOMP] = - dst[BCOMP] = SHORT_TO_FLOAT_TEX( s ); - dst[ACOMP] = 1.0F; + const GLshort *s = ((const GLshort *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = + dst[i][GCOMP] = + dst[i][BCOMP] = SHORT_TO_FLOAT_TEX( s[i] ); + dst[i][ACOMP] = 1.0F; + } } static void -unpack_SIGNED_AL1616(const void *src, GLfloat dst[4]) +unpack_SIGNED_AL1616(const void *src, GLfloat dst[][4], GLuint n) { const GLshort *s = (const GLshort *) src; - dst[RCOMP] = - dst[GCOMP] = - dst[BCOMP] = SHORT_TO_FLOAT_TEX( s[0] ); - dst[ACOMP] = SHORT_TO_FLOAT_TEX( s[1] ); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = + dst[i][GCOMP] = + dst[i][BCOMP] = SHORT_TO_FLOAT_TEX( s[i*2+0] ); + dst[i][ACOMP] = SHORT_TO_FLOAT_TEX( s[i*2+1] ); + } } static void -unpack_SIGNED_I16(const void *src, GLfloat dst[4]) +unpack_SIGNED_I16(const void *src, GLfloat dst[][4], GLuint n) { - const GLshort s = *((const GLshort *) src); - dst[RCOMP] = - dst[GCOMP] = - dst[BCOMP] = - dst[ACOMP] = SHORT_TO_FLOAT_TEX( s ); + const GLshort *s = ((const GLshort *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i][RCOMP] = + dst[i][GCOMP] = + dst[i][BCOMP] = + dst[i][ACOMP] = SHORT_TO_FLOAT_TEX( s[i] ); + } } static void -unpack_RGB9_E5_FLOAT(const void *src, GLfloat dst[4]) +unpack_RGB9_E5_FLOAT(const void *src, GLfloat dst[][4], GLuint n) { const GLuint *s = (const GLuint *) src; - rgb9e5_to_float3(*s, dst); - dst[ACOMP] = 1.0F; + GLuint i; + for (i = 0; i < n; i++) { + rgb9e5_to_float3(s[i], dst[i]); + dst[i][ACOMP] = 1.0F; + } } static void -unpack_R11_G11_B10_FLOAT(const void *src, GLfloat dst[4]) +unpack_R11_G11_B10_FLOAT(const void *src, GLfloat dst[][4], GLuint n) { const GLuint *s = (const GLuint *) src; - r11g11b10f_to_float3(*s, dst); - dst[ACOMP] = 1.0F; + GLuint i; + for (i = 0; i < n; i++) { + r11g11b10f_to_float3(s[i], dst[i]); + dst[i][ACOMP] = 1.0F; + } } @@ -1248,14 +1534,7 @@ _mesa_unpack_rgba_row(gl_format format, GLuint n, const void *src, GLfloat dst[][4]) { unpack_rgba_func unpack = get_unpack_rgba_function(format); - GLuint srcStride = _mesa_get_format_bytes(format); - const GLubyte *srcPtr = (GLubyte *) src; - GLuint i; - - for (i = 0; i < n; i++) { - unpack(srcPtr, dst[i]); - srcPtr += srcStride; - } + unpack(src, dst, n); } static void @@ -1401,10 +1680,9 @@ _mesa_unpack_rgba_block(gl_format format, unpack_rgba_func unpack = get_unpack_rgba_function(format); const GLuint srcPixStride = _mesa_get_format_bytes(format); const GLuint dstPixStride = 4 * sizeof(GLfloat); - const GLubyte *srcRow, *srcPix; + const GLubyte *srcRow; GLubyte *dstRow; - GLfloat *dstPix; - GLuint i, j; + GLuint i; /* XXX needs to be fixed for compressed formats */ @@ -1412,14 +1690,7 @@ _mesa_unpack_rgba_block(gl_format format, dstRow = ((GLubyte *) dst) + dstRowStride * y + dstPixStride * x; for (i = 0; i < height; i++) { - srcPix = srcRow; - dstPix = (GLfloat *) dstRow; - - for (j = 0; j < width; j++) { - unpack(srcPix, dstPix); - srcPix += srcPixStride; - dstPix += dstPixStride; - } + unpack(srcRow, (GLfloat (*)[4]) dstRow, width); dstRow += dstRowStride; srcRow += srcRowStride; @@ -1429,60 +1700,64 @@ _mesa_unpack_rgba_block(gl_format format, -typedef void (*unpack_float_z_func)(const void *src, GLfloat *dst); +typedef void (*unpack_float_z_func)(GLuint n, const void *src, GLfloat *dst); static void -unpack_float_z_Z24_S8(const void *src, GLfloat *dst) +unpack_float_z_Z24_X8(GLuint n, const void *src, GLfloat *dst) { /* only return Z, not stencil data */ - const GLuint s = *((const GLuint *) src); + const GLuint *s = ((const GLuint *) src); const GLfloat scale = 1.0F / (GLfloat) 0xffffff; - *dst = (s >> 8) * scale; - ASSERT(*dst >= 0.0F); - ASSERT(*dst <= 1.0F); + GLuint i; + for (i = 0; i < n; i++) { + dst[i] = (s[i] >> 8) * scale; + ASSERT(dst[i] >= 0.0F); + ASSERT(dst[i] <= 1.0F); + } } static void -unpack_float_z_S8_Z24(const void *src, GLfloat *dst) +unpack_float_z_X8_Z24(GLuint n, const void *src, GLfloat *dst) { /* only return Z, not stencil data */ - const GLuint s = *((const GLuint *) src); + const GLuint *s = ((const GLuint *) src); const GLfloat scale = 1.0F / (GLfloat) 0xffffff; - *dst = (s & 0x00ffffff) * scale; - ASSERT(*dst >= 0.0F); - ASSERT(*dst <= 1.0F); -} - -static void -unpack_float_z_Z16(const void *src, GLfloat *dst) -{ - const GLushort s = *((const GLushort *) src); - *dst = s * (1.0F / 65535.0F); -} - -static void -unpack_float_z_X8_Z24(const void *src, GLfloat *dst) -{ - unpack_float_z_S8_Z24(src, dst); + GLuint i; + for (i = 0; i < n; i++) { + dst[i] = (s[i] & 0x00ffffff) * scale; + ASSERT(dst[i] >= 0.0F); + ASSERT(dst[i] <= 1.0F); + } } static void -unpack_float_z_Z24_X8(const void *src, GLfloat *dst) +unpack_float_z_Z16(GLuint n, const void *src, GLfloat *dst) { - unpack_float_z_Z24_S8(src, dst); + const GLushort *s = ((const GLushort *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i] = s[i] * (1.0F / 65535.0F); + } } static void -unpack_float_z_Z32(const void *src, GLfloat *dst) +unpack_float_z_Z32(GLuint n, const void *src, GLfloat *dst) { - const GLuint s = *((const GLuint *) src); - *dst = s * (1.0F / 0xffffffff); + const GLuint *s = ((const GLuint *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i] = s[i] * (1.0F / 0xffffffff); + } } static void -unpack_float_z_Z32X24S8(const void *src, GLfloat *dst) +unpack_float_z_Z32X24S8(GLuint n, const void *src, GLfloat *dst) { - *dst = *((const GLfloat *) src); + const GLfloat *s = ((const GLfloat *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i] = s[i * 2]; + } } @@ -1492,25 +1767,18 @@ _mesa_unpack_float_z_row(gl_format format, GLuint n, const void *src, GLfloat *dst) { unpack_float_z_func unpack; - GLuint srcStride = _mesa_get_format_bytes(format); - const GLubyte *srcPtr = (GLubyte *) src; - GLuint i; switch (format) { case MESA_FORMAT_Z24_S8: - unpack = unpack_float_z_Z24_S8; + case MESA_FORMAT_Z24_X8: + unpack = unpack_float_z_Z24_X8; break; case MESA_FORMAT_S8_Z24: - unpack = unpack_float_z_S8_Z24; - break; - case MESA_FORMAT_Z16: - unpack = unpack_float_z_Z16; - break; case MESA_FORMAT_X8_Z24: unpack = unpack_float_z_X8_Z24; break; - case MESA_FORMAT_Z24_X8: - unpack = unpack_float_z_Z24_X8; + case MESA_FORMAT_Z16: + unpack = unpack_float_z_Z16; break; case MESA_FORMAT_Z32: unpack = unpack_float_z_Z32; @@ -1524,43 +1792,49 @@ _mesa_unpack_float_z_row(gl_format format, GLuint n, return; } - for (i = 0; i < n; i++) { - unpack(srcPtr, &dst[i]); - srcPtr += srcStride; - } + unpack(n, src, dst); } -typedef void (*unpack_uint_z_func)(const void *src, GLuint *dst); +typedef void (*unpack_uint_z_func)(const void *src, GLuint *dst, GLuint n); static void -unpack_uint_z_Z24_X8(const void *src, GLuint *dst) +unpack_uint_z_Z24_X8(const void *src, GLuint *dst, GLuint n) { /* only return Z, not stencil data */ - const GLuint s = *((const GLuint *) src); - *dst = (s & 0xffffff00) | (s >> 24); + const GLuint *s = ((const GLuint *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i] = (s[i] & 0xffffff00) | (s[i] >> 24); + } } static void -unpack_uint_z_X8_Z24(const void *src, GLuint *dst) +unpack_uint_z_X8_Z24(const void *src, GLuint *dst, GLuint n) { /* only return Z, not stencil data */ - const GLuint s = *((const GLuint *) src); - *dst = (s << 8) | ((s >> 16) & 0xff); + const GLuint *s = ((const GLuint *) src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i] = (s[i] << 8) | ((s[i] >> 16) & 0xff); + } } static void -unpack_uint_z_Z16(const void *src, GLuint *dst) +unpack_uint_z_Z16(const void *src, GLuint *dst, GLuint n) { - const GLushort s = *((const GLushort *)src); - *dst = (s << 16) | s; + const GLushort *s = ((const GLushort *)src); + GLuint i; + for (i = 0; i < n; i++) { + dst[i] = (s[i] << 16) | s[i]; + } } static void -unpack_uint_z_Z32(const void *src, GLuint *dst) +unpack_uint_z_Z32(const void *src, GLuint *dst, GLuint n) { - *dst = *((const GLuint *) src); + memcpy(dst, src, n * sizeof(GLuint)); } @@ -1569,9 +1843,7 @@ _mesa_unpack_uint_z_row(gl_format format, GLuint n, const void *src, GLuint *dst) { unpack_uint_z_func unpack; - GLuint srcStride = _mesa_get_format_bytes(format); const GLubyte *srcPtr = (GLubyte *) src; - GLuint i; switch (format) { case MESA_FORMAT_Z24_S8: @@ -1594,12 +1866,10 @@ _mesa_unpack_uint_z_row(gl_format format, GLuint n, return; } - for (i = 0; i < n; i++) { - unpack(srcPtr, &dst[i]); - srcPtr += srcStride; - } + unpack(srcPtr, dst, n); } + static void unpack_ubyte_s_S8(const void *src, GLubyte *dst, GLuint n) { diff --git a/mesalib/src/mesa/main/image.c b/mesalib/src/mesa/main/image.c index 7d95dd6be..914a99923 100644 --- a/mesalib/src/mesa/main/image.c +++ b/mesalib/src/mesa/main/image.c @@ -39,25 +39,6 @@ #include "mtypes.h" -/** - * NOTE: - * Normally, BYTE_TO_FLOAT(0) returns 0.00392 That causes problems when - * we later convert the float to a packed integer value (such as for - * GL_RGB5_A1) because we'll wind up with a non-zero value. - * - * We redefine the macros here so zero is handled correctly. - */ -#undef BYTE_TO_FLOAT -#define BYTE_TO_FLOAT(B) ((B) == 0 ? 0.0F : ((2.0F * (B) + 1.0F) * (1.0F/255.0F))) - -#undef SHORT_TO_FLOAT -#define SHORT_TO_FLOAT(S) ((S) == 0 ? 0.0F : ((2.0F * (S) + 1.0F) * (1.0F/65535.0F))) - - - -/** Compute ceiling of integer quotient of A divided by B. */ -#define CEILING( A, B ) ( (A) % (B) == 0 ? (A)/(B) : (A)/(B)+1 ) - /** * \return GL_TRUE if type is packed pixel type, GL_FALSE otherwise. @@ -195,38 +176,24 @@ _mesa_sizeof_packed_type( GLenum type ) case GL_FLOAT: return sizeof(GLfloat); case GL_UNSIGNED_BYTE_3_3_2: - return sizeof(GLubyte); case GL_UNSIGNED_BYTE_2_3_3_REV: - return sizeof(GLubyte); case MESA_UNSIGNED_BYTE_4_4: return sizeof(GLubyte); case GL_UNSIGNED_SHORT_5_6_5: - return sizeof(GLushort); case GL_UNSIGNED_SHORT_5_6_5_REV: - return sizeof(GLushort); case GL_UNSIGNED_SHORT_4_4_4_4: - return sizeof(GLushort); case GL_UNSIGNED_SHORT_4_4_4_4_REV: - return sizeof(GLushort); case GL_UNSIGNED_SHORT_5_5_5_1: - return sizeof(GLushort); 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: - return sizeof(GLuint); case GL_UNSIGNED_INT_8_8_8_8_REV: - return sizeof(GLuint); case GL_UNSIGNED_INT_10_10_10_2: - return sizeof(GLuint); case GL_UNSIGNED_INT_2_10_10_10_REV: - return sizeof(GLuint); - case GL_UNSIGNED_SHORT_8_8_MESA: - case GL_UNSIGNED_SHORT_8_8_REV_MESA: - return sizeof(GLushort); case GL_UNSIGNED_INT_24_8_EXT: - return sizeof(GLuint); case GL_UNSIGNED_INT_5_9_9_9_REV: - return sizeof(GLuint); case GL_UNSIGNED_INT_10F_11F_11F_REV: return sizeof(GLuint); case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: @@ -263,29 +230,27 @@ _mesa_components_in_format( GLenum format ) 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: return 2; + case GL_RGB: + case GL_BGR: case GL_RGB_INTEGER_EXT: return 3; + case GL_RGBA: - case GL_RGBA_INTEGER_EXT: - return 4; - case GL_BGR: - return 3; case GL_BGRA: - return 4; case GL_ABGR_EXT: + case GL_RGBA_INTEGER_EXT: return 4; - case GL_YCBCR_MESA: - return 2; - case GL_DEPTH_STENCIL_EXT: - return 2; - case GL_DUDV_ATI: - case GL_DU8DV8_ATI: - return 2; + default: return -1; } @@ -987,36 +952,48 @@ _mesa_is_integer_format(GLenum format) /* 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: diff --git a/mesalib/src/mesa/main/light.c b/mesalib/src/mesa/main/light.c index 888e5622e..60daa89a3 100644 --- a/mesalib/src/mesa/main/light.c +++ b/mesalib/src/mesa/main/light.c @@ -1,1430 +1,1433 @@ -/* - * Mesa 3-D graphics library - * Version: 7.5 - * - * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. - * Copyright (C) 2009 VMware, Inc. All Rights Reserved. - * - * 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 - * BRIAN PAUL 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 "glheader.h" -#include "imports.h" -#include "context.h" -#include "enums.h" -#include "light.h" -#include "macros.h" -#include "simple_list.h" -#include "mtypes.h" -#include "math/m_matrix.h" - - -void GLAPIENTRY -_mesa_ShadeModel( GLenum mode ) -{ - GET_CURRENT_CONTEXT(ctx); - ASSERT_OUTSIDE_BEGIN_END(ctx); - - if (MESA_VERBOSE & VERBOSE_API) - _mesa_debug(ctx, "glShadeModel %s\n", _mesa_lookup_enum_by_nr(mode)); - - if (mode != GL_FLAT && mode != GL_SMOOTH) { - _mesa_error(ctx, GL_INVALID_ENUM, "glShadeModel"); - return; - } - - if (ctx->Light.ShadeModel == mode) - return; - - FLUSH_VERTICES(ctx, _NEW_LIGHT); - ctx->Light.ShadeModel = mode; - if (mode == GL_FLAT) - ctx->_TriangleCaps |= DD_FLATSHADE; - else - ctx->_TriangleCaps &= ~DD_FLATSHADE; - - if (ctx->Driver.ShadeModel) - ctx->Driver.ShadeModel( ctx, mode ); -} - - -/** - * Set the provoking vertex (the vertex which specifies the prim's - * color when flat shading) to either the first or last vertex of the - * triangle or line. - */ -void GLAPIENTRY -_mesa_ProvokingVertexEXT(GLenum mode) -{ - GET_CURRENT_CONTEXT(ctx); - ASSERT_OUTSIDE_BEGIN_END(ctx); - - if (MESA_VERBOSE&VERBOSE_API) - _mesa_debug(ctx, "glProvokingVertexEXT 0x%x\n", mode); - - switch (mode) { - case GL_FIRST_VERTEX_CONVENTION_EXT: - case GL_LAST_VERTEX_CONVENTION_EXT: - break; - default: - _mesa_error(ctx, GL_INVALID_ENUM, "glProvokingVertexEXT(0x%x)", mode); - return; - } - - if (ctx->Light.ProvokingVertex == mode) - return; - - FLUSH_VERTICES(ctx, _NEW_LIGHT); - ctx->Light.ProvokingVertex = mode; -} - - -/** - * Helper function called by _mesa_Lightfv and _mesa_PopAttrib to set - * per-light state. - * For GL_POSITION and GL_SPOT_DIRECTION the params position/direction - * will have already been transformed by the modelview matrix! - * Also, all error checking should have already been done. - */ -void -_mesa_light(struct gl_context *ctx, GLuint lnum, GLenum pname, const GLfloat *params) -{ - struct gl_light *light; - - ASSERT(lnum < MAX_LIGHTS); - light = &ctx->Light.Light[lnum]; - - switch (pname) { - case GL_AMBIENT: - if (TEST_EQ_4V(light->Ambient, params)) - return; - FLUSH_VERTICES(ctx, _NEW_LIGHT); - COPY_4V( light->Ambient, params ); - break; - case GL_DIFFUSE: - if (TEST_EQ_4V(light->Diffuse, params)) - return; - FLUSH_VERTICES(ctx, _NEW_LIGHT); - COPY_4V( light->Diffuse, params ); - break; - case GL_SPECULAR: - if (TEST_EQ_4V(light->Specular, params)) - return; - FLUSH_VERTICES(ctx, _NEW_LIGHT); - COPY_4V( light->Specular, params ); - break; - case GL_POSITION: - /* NOTE: position has already been transformed by ModelView! */ - if (TEST_EQ_4V(light->EyePosition, params)) - return; - FLUSH_VERTICES(ctx, _NEW_LIGHT); - COPY_4V(light->EyePosition, params); - if (light->EyePosition[3] != 0.0F) - light->_Flags |= LIGHT_POSITIONAL; - else - light->_Flags &= ~LIGHT_POSITIONAL; - break; - case GL_SPOT_DIRECTION: - /* NOTE: Direction already transformed by inverse ModelView! */ - if (TEST_EQ_3V(light->SpotDirection, params)) - return; - FLUSH_VERTICES(ctx, _NEW_LIGHT); - COPY_3V(light->SpotDirection, params); - break; - case GL_SPOT_EXPONENT: - ASSERT(params[0] >= 0.0); - ASSERT(params[0] <= ctx->Const.MaxSpotExponent); - if (light->SpotExponent == params[0]) - return; - FLUSH_VERTICES(ctx, _NEW_LIGHT); - light->SpotExponent = params[0]; - _mesa_invalidate_spot_exp_table(light); - break; - case GL_SPOT_CUTOFF: - ASSERT(params[0] == 180.0 || (params[0] >= 0.0 && params[0] <= 90.0)); - if (light->SpotCutoff == params[0]) - return; - FLUSH_VERTICES(ctx, _NEW_LIGHT); - light->SpotCutoff = params[0]; - light->_CosCutoffNeg = (GLfloat) (cos(light->SpotCutoff * DEG2RAD)); - if (light->_CosCutoffNeg < 0) - light->_CosCutoff = 0; - else - light->_CosCutoff = light->_CosCutoffNeg; - if (light->SpotCutoff != 180.0F) - light->_Flags |= LIGHT_SPOT; - else - light->_Flags &= ~LIGHT_SPOT; - break; - case GL_CONSTANT_ATTENUATION: - ASSERT(params[0] >= 0.0); - if (light->ConstantAttenuation == params[0]) - return; - FLUSH_VERTICES(ctx, _NEW_LIGHT); - light->ConstantAttenuation = params[0]; - break; - case GL_LINEAR_ATTENUATION: - ASSERT(params[0] >= 0.0); - if (light->LinearAttenuation == params[0]) - return; - FLUSH_VERTICES(ctx, _NEW_LIGHT); - light->LinearAttenuation = params[0]; - break; - case GL_QUADRATIC_ATTENUATION: - ASSERT(params[0] >= 0.0); - if (light->QuadraticAttenuation == params[0]) - return; - FLUSH_VERTICES(ctx, _NEW_LIGHT); - light->QuadraticAttenuation = params[0]; - break; - default: - _mesa_problem(ctx, "Unexpected pname in _mesa_light()"); - return; - } - - if (ctx->Driver.Lightfv) - ctx->Driver.Lightfv( ctx, GL_LIGHT0 + lnum, pname, params ); -} - - -void GLAPIENTRY -_mesa_Lightf( GLenum light, GLenum pname, GLfloat param ) -{ - GLfloat fparam[4]; - fparam[0] = param; - fparam[1] = fparam[2] = fparam[3] = 0.0F; - _mesa_Lightfv( light, pname, fparam ); -} - - -void GLAPIENTRY -_mesa_Lightfv( GLenum light, GLenum pname, const GLfloat *params ) -{ - GET_CURRENT_CONTEXT(ctx); - GLint i = (GLint) (light - GL_LIGHT0); - GLfloat temp[4]; - ASSERT_OUTSIDE_BEGIN_END(ctx); - - if (i < 0 || i >= (GLint) ctx->Const.MaxLights) { - _mesa_error( ctx, GL_INVALID_ENUM, "glLight(light=0x%x)", light ); - return; - } - - /* do particular error checks, transformations */ - switch (pname) { - case GL_AMBIENT: - case GL_DIFFUSE: - case GL_SPECULAR: - /* nothing */ - break; - case GL_POSITION: - /* transform position by ModelView matrix */ - TRANSFORM_POINT(temp, ctx->ModelviewMatrixStack.Top->m, params); - params = temp; - break; - case GL_SPOT_DIRECTION: - /* transform direction by inverse modelview */ - if (_math_matrix_is_dirty(ctx->ModelviewMatrixStack.Top)) { - _math_matrix_analyse(ctx->ModelviewMatrixStack.Top); - } - TRANSFORM_DIRECTION(temp, params, ctx->ModelviewMatrixStack.Top->m); - params = temp; - break; - case GL_SPOT_EXPONENT: - if (params[0] < 0.0 || params[0] > ctx->Const.MaxSpotExponent) { - _mesa_error(ctx, GL_INVALID_VALUE, "glLight"); - return; - } - break; - case GL_SPOT_CUTOFF: - if ((params[0] < 0.0 || params[0] > 90.0) && params[0] != 180.0) { - _mesa_error(ctx, GL_INVALID_VALUE, "glLight"); - return; - } - break; - case GL_CONSTANT_ATTENUATION: - if (params[0] < 0.0) { - _mesa_error(ctx, GL_INVALID_VALUE, "glLight"); - return; - } - break; - case GL_LINEAR_ATTENUATION: - if (params[0] < 0.0) { - _mesa_error(ctx, GL_INVALID_VALUE, "glLight"); - return; - } - break; - case GL_QUADRATIC_ATTENUATION: - if (params[0] < 0.0) { - _mesa_error(ctx, GL_INVALID_VALUE, "glLight"); - return; - } - break; - default: - _mesa_error(ctx, GL_INVALID_ENUM, "glLight(pname=0x%x)", pname); - return; - } - - _mesa_light(ctx, i, pname, params); -} - - -void GLAPIENTRY -_mesa_Lighti( GLenum light, GLenum pname, GLint param ) -{ - GLint iparam[4]; - iparam[0] = param; - iparam[1] = iparam[2] = iparam[3] = 0; - _mesa_Lightiv( light, pname, iparam ); -} - - -void GLAPIENTRY -_mesa_Lightiv( GLenum light, GLenum pname, const GLint *params ) -{ - GLfloat fparam[4]; - - switch (pname) { - case GL_AMBIENT: - case GL_DIFFUSE: - case GL_SPECULAR: - fparam[0] = INT_TO_FLOAT( params[0] ); - fparam[1] = INT_TO_FLOAT( params[1] ); - fparam[2] = INT_TO_FLOAT( params[2] ); - fparam[3] = INT_TO_FLOAT( params[3] ); - break; - case GL_POSITION: - fparam[0] = (GLfloat) params[0]; - fparam[1] = (GLfloat) params[1]; - fparam[2] = (GLfloat) params[2]; - fparam[3] = (GLfloat) params[3]; - break; - case GL_SPOT_DIRECTION: - fparam[0] = (GLfloat) params[0]; - fparam[1] = (GLfloat) params[1]; - fparam[2] = (GLfloat) params[2]; - break; - case GL_SPOT_EXPONENT: - case GL_SPOT_CUTOFF: - case GL_CONSTANT_ATTENUATION: - case GL_LINEAR_ATTENUATION: - case GL_QUADRATIC_ATTENUATION: - fparam[0] = (GLfloat) params[0]; - break; - default: - /* error will be caught later in gl_Lightfv */ - ; - } - - _mesa_Lightfv( light, pname, fparam ); -} - - - -void GLAPIENTRY -_mesa_GetLightfv( GLenum light, GLenum pname, GLfloat *params ) -{ - GET_CURRENT_CONTEXT(ctx); - GLint l = (GLint) (light - GL_LIGHT0); - ASSERT_OUTSIDE_BEGIN_END(ctx); - - if (l < 0 || l >= (GLint) ctx->Const.MaxLights) { - _mesa_error( ctx, GL_INVALID_ENUM, "glGetLightfv" ); - return; - } - - switch (pname) { - case GL_AMBIENT: - COPY_4V( params, ctx->Light.Light[l].Ambient ); - break; - case GL_DIFFUSE: - COPY_4V( params, ctx->Light.Light[l].Diffuse ); - break; - case GL_SPECULAR: - COPY_4V( params, ctx->Light.Light[l].Specular ); - break; - case GL_POSITION: - COPY_4V( params, ctx->Light.Light[l].EyePosition ); - break; - case GL_SPOT_DIRECTION: - COPY_3V( params, ctx->Light.Light[l].SpotDirection ); - break; - case GL_SPOT_EXPONENT: - params[0] = ctx->Light.Light[l].SpotExponent; - break; - case GL_SPOT_CUTOFF: - params[0] = ctx->Light.Light[l].SpotCutoff; - break; - case GL_CONSTANT_ATTENUATION: - params[0] = ctx->Light.Light[l].ConstantAttenuation; - break; - case GL_LINEAR_ATTENUATION: - params[0] = ctx->Light.Light[l].LinearAttenuation; - break; - case GL_QUADRATIC_ATTENUATION: - params[0] = ctx->Light.Light[l].QuadraticAttenuation; - break; - default: - _mesa_error( ctx, GL_INVALID_ENUM, "glGetLightfv" ); - break; - } -} - - -void GLAPIENTRY -_mesa_GetLightiv( GLenum light, GLenum pname, GLint *params ) -{ - GET_CURRENT_CONTEXT(ctx); - GLint l = (GLint) (light - GL_LIGHT0); - ASSERT_OUTSIDE_BEGIN_END(ctx); - - if (l < 0 || l >= (GLint) ctx->Const.MaxLights) { - _mesa_error( ctx, GL_INVALID_ENUM, "glGetLightiv" ); - return; - } - - switch (pname) { - case GL_AMBIENT: - params[0] = FLOAT_TO_INT(ctx->Light.Light[l].Ambient[0]); - params[1] = FLOAT_TO_INT(ctx->Light.Light[l].Ambient[1]); - params[2] = FLOAT_TO_INT(ctx->Light.Light[l].Ambient[2]); - params[3] = FLOAT_TO_INT(ctx->Light.Light[l].Ambient[3]); - break; - case GL_DIFFUSE: - params[0] = FLOAT_TO_INT(ctx->Light.Light[l].Diffuse[0]); - params[1] = FLOAT_TO_INT(ctx->Light.Light[l].Diffuse[1]); - params[2] = FLOAT_TO_INT(ctx->Light.Light[l].Diffuse[2]); - params[3] = FLOAT_TO_INT(ctx->Light.Light[l].Diffuse[3]); - break; - case GL_SPECULAR: - params[0] = FLOAT_TO_INT(ctx->Light.Light[l].Specular[0]); - params[1] = FLOAT_TO_INT(ctx->Light.Light[l].Specular[1]); - params[2] = FLOAT_TO_INT(ctx->Light.Light[l].Specular[2]); - params[3] = FLOAT_TO_INT(ctx->Light.Light[l].Specular[3]); - break; - case GL_POSITION: - params[0] = (GLint) ctx->Light.Light[l].EyePosition[0]; - params[1] = (GLint) ctx->Light.Light[l].EyePosition[1]; - params[2] = (GLint) ctx->Light.Light[l].EyePosition[2]; - params[3] = (GLint) ctx->Light.Light[l].EyePosition[3]; - break; - case GL_SPOT_DIRECTION: - params[0] = (GLint) ctx->Light.Light[l].SpotDirection[0]; - params[1] = (GLint) ctx->Light.Light[l].SpotDirection[1]; - params[2] = (GLint) ctx->Light.Light[l].SpotDirection[2]; - break; - case GL_SPOT_EXPONENT: - params[0] = (GLint) ctx->Light.Light[l].SpotExponent; - break; - case GL_SPOT_CUTOFF: - params[0] = (GLint) ctx->Light.Light[l].SpotCutoff; - break; - case GL_CONSTANT_ATTENUATION: - params[0] = (GLint) ctx->Light.Light[l].ConstantAttenuation; - break; - case GL_LINEAR_ATTENUATION: - params[0] = (GLint) ctx->Light.Light[l].LinearAttenuation; - break; - case GL_QUADRATIC_ATTENUATION: - params[0] = (GLint) ctx->Light.Light[l].QuadraticAttenuation; - break; - default: - _mesa_error( ctx, GL_INVALID_ENUM, "glGetLightiv" ); - break; - } -} - - - -/**********************************************************************/ -/*** Light Model ***/ -/**********************************************************************/ - - -void GLAPIENTRY -_mesa_LightModelfv( GLenum pname, const GLfloat *params ) -{ - GLenum newenum; - GLboolean newbool; - GET_CURRENT_CONTEXT(ctx); - ASSERT_OUTSIDE_BEGIN_END(ctx); - - switch (pname) { - case GL_LIGHT_MODEL_AMBIENT: - if (TEST_EQ_4V( ctx->Light.Model.Ambient, params )) - return; - FLUSH_VERTICES(ctx, _NEW_LIGHT); - COPY_4V( ctx->Light.Model.Ambient, params ); - break; - case GL_LIGHT_MODEL_LOCAL_VIEWER: - newbool = (params[0]!=0.0); - if (ctx->Light.Model.LocalViewer == newbool) - return; - FLUSH_VERTICES(ctx, _NEW_LIGHT); - ctx->Light.Model.LocalViewer = newbool; - break; - case GL_LIGHT_MODEL_TWO_SIDE: - newbool = (params[0]!=0.0); - if (ctx->Light.Model.TwoSide == newbool) - return; - FLUSH_VERTICES(ctx, _NEW_LIGHT); - ctx->Light.Model.TwoSide = newbool; - if (ctx->Light.Enabled && ctx->Light.Model.TwoSide) - ctx->_TriangleCaps |= DD_TRI_LIGHT_TWOSIDE; - else - ctx->_TriangleCaps &= ~DD_TRI_LIGHT_TWOSIDE; - break; - case GL_LIGHT_MODEL_COLOR_CONTROL: - if (params[0] == (GLfloat) GL_SINGLE_COLOR) - newenum = GL_SINGLE_COLOR; - else if (params[0] == (GLfloat) GL_SEPARATE_SPECULAR_COLOR) - newenum = GL_SEPARATE_SPECULAR_COLOR; - else { - _mesa_error( ctx, GL_INVALID_ENUM, "glLightModel(param=0x0%x)", - (GLint) params[0] ); - return; - } - if (ctx->Light.Model.ColorControl == newenum) - return; - FLUSH_VERTICES(ctx, _NEW_LIGHT); - ctx->Light.Model.ColorControl = newenum; - break; - default: - _mesa_error( ctx, GL_INVALID_ENUM, "glLightModel(pname=0x%x)", pname ); - break; - } - - if (ctx->Driver.LightModelfv) - ctx->Driver.LightModelfv( ctx, pname, params ); -} - - -void GLAPIENTRY -_mesa_LightModeliv( GLenum pname, const GLint *params ) -{ - GLfloat fparam[4]; - - switch (pname) { - case GL_LIGHT_MODEL_AMBIENT: - fparam[0] = INT_TO_FLOAT( params[0] ); - fparam[1] = INT_TO_FLOAT( params[1] ); - fparam[2] = INT_TO_FLOAT( params[2] ); - fparam[3] = INT_TO_FLOAT( params[3] ); - break; - case GL_LIGHT_MODEL_LOCAL_VIEWER: - case GL_LIGHT_MODEL_TWO_SIDE: - case GL_LIGHT_MODEL_COLOR_CONTROL: - fparam[0] = (GLfloat) params[0]; - break; - default: - /* Error will be caught later in gl_LightModelfv */ - ASSIGN_4V(fparam, 0.0F, 0.0F, 0.0F, 0.0F); - } - _mesa_LightModelfv( pname, fparam ); -} - - -void GLAPIENTRY -_mesa_LightModeli( GLenum pname, GLint param ) -{ - GLint iparam[4]; - iparam[0] = param; - iparam[1] = iparam[2] = iparam[3] = 0; - _mesa_LightModeliv( pname, iparam ); -} - - -void GLAPIENTRY -_mesa_LightModelf( GLenum pname, GLfloat param ) -{ - GLfloat fparam[4]; - fparam[0] = param; - fparam[1] = fparam[2] = fparam[3] = 0.0F; - _mesa_LightModelfv( pname, fparam ); -} - - - -/********** MATERIAL **********/ - - -/* - * Given a face and pname value (ala glColorMaterial), compute a bitmask - * of the targeted material values. - */ -GLuint -_mesa_material_bitmask( struct gl_context *ctx, GLenum face, GLenum pname, - GLuint legal, const char *where ) -{ - GLuint bitmask = 0; - - /* Make a bitmask indicating what material attribute(s) we're updating */ - switch (pname) { - case GL_EMISSION: - bitmask |= MAT_BIT_FRONT_EMISSION | MAT_BIT_BACK_EMISSION; - break; - case GL_AMBIENT: - bitmask |= MAT_BIT_FRONT_AMBIENT | MAT_BIT_BACK_AMBIENT; - break; - case GL_DIFFUSE: - bitmask |= MAT_BIT_FRONT_DIFFUSE | MAT_BIT_BACK_DIFFUSE; - break; - case GL_SPECULAR: - bitmask |= MAT_BIT_FRONT_SPECULAR | MAT_BIT_BACK_SPECULAR; - break; - case GL_SHININESS: - bitmask |= MAT_BIT_FRONT_SHININESS | MAT_BIT_BACK_SHININESS; - break; - case GL_AMBIENT_AND_DIFFUSE: - bitmask |= MAT_BIT_FRONT_AMBIENT | MAT_BIT_BACK_AMBIENT; - bitmask |= MAT_BIT_FRONT_DIFFUSE | MAT_BIT_BACK_DIFFUSE; - break; - case GL_COLOR_INDEXES: - bitmask |= MAT_BIT_FRONT_INDEXES | MAT_BIT_BACK_INDEXES; - break; - default: - _mesa_error( ctx, GL_INVALID_ENUM, "%s", where ); - return 0; - } - - if (face==GL_FRONT) { - bitmask &= FRONT_MATERIAL_BITS; - } - else if (face==GL_BACK) { - bitmask &= BACK_MATERIAL_BITS; - } - else if (face != GL_FRONT_AND_BACK) { - _mesa_error( ctx, GL_INVALID_ENUM, "%s", where ); - return 0; - } - - if (bitmask & ~legal) { - _mesa_error( ctx, GL_INVALID_ENUM, "%s", where ); - return 0; - } - - return bitmask; -} - - - -/* Perform a straight copy between materials. - */ -void -_mesa_copy_materials( struct gl_material *dst, - const struct gl_material *src, - GLuint bitmask ) -{ - int i; - - for (i = 0 ; i < MAT_ATTRIB_MAX ; i++) - if (bitmask & (1<Attrib[i], src->Attrib[i] ); -} - - - -/* Update derived values following a change in ctx->Light.Material - */ -void -_mesa_update_material( struct gl_context *ctx, GLuint bitmask ) -{ - struct gl_light *light, *list = &ctx->Light.EnabledList; - GLfloat (*mat)[4] = ctx->Light.Material.Attrib; - - if (MESA_VERBOSE & VERBOSE_MATERIAL) - _mesa_debug(ctx, "_mesa_update_material, mask 0x%x\n", bitmask); - - if (!bitmask) - return; - - /* update material ambience */ - if (bitmask & MAT_BIT_FRONT_AMBIENT) { - foreach (light, list) { - SCALE_3V( light->_MatAmbient[0], light->Ambient, - mat[MAT_ATTRIB_FRONT_AMBIENT]); - } - } - - if (bitmask & MAT_BIT_BACK_AMBIENT) { - foreach (light, list) { - SCALE_3V( light->_MatAmbient[1], light->Ambient, - mat[MAT_ATTRIB_BACK_AMBIENT]); - } - } - - /* update BaseColor = emission + scene's ambience * material's ambience */ - if (bitmask & (MAT_BIT_FRONT_EMISSION | MAT_BIT_FRONT_AMBIENT)) { - COPY_3V( ctx->Light._BaseColor[0], mat[MAT_ATTRIB_FRONT_EMISSION] ); - ACC_SCALE_3V( ctx->Light._BaseColor[0], mat[MAT_ATTRIB_FRONT_AMBIENT], - ctx->Light.Model.Ambient ); - } - - if (bitmask & (MAT_BIT_BACK_EMISSION | MAT_BIT_BACK_AMBIENT)) { - COPY_3V( ctx->Light._BaseColor[1], mat[MAT_ATTRIB_BACK_EMISSION] ); - ACC_SCALE_3V( ctx->Light._BaseColor[1], mat[MAT_ATTRIB_BACK_AMBIENT], - ctx->Light.Model.Ambient ); - } - - /* update material diffuse values */ - if (bitmask & MAT_BIT_FRONT_DIFFUSE) { - foreach (light, list) { - SCALE_3V( light->_MatDiffuse[0], light->Diffuse, - mat[MAT_ATTRIB_FRONT_DIFFUSE] ); - } - } - - if (bitmask & MAT_BIT_BACK_DIFFUSE) { - foreach (light, list) { - SCALE_3V( light->_MatDiffuse[1], light->Diffuse, - mat[MAT_ATTRIB_BACK_DIFFUSE] ); - } - } - - /* update material specular values */ - if (bitmask & MAT_BIT_FRONT_SPECULAR) { - foreach (light, list) { - SCALE_3V( light->_MatSpecular[0], light->Specular, - mat[MAT_ATTRIB_FRONT_SPECULAR]); - } - } - - if (bitmask & MAT_BIT_BACK_SPECULAR) { - foreach (light, list) { - SCALE_3V( light->_MatSpecular[1], light->Specular, - mat[MAT_ATTRIB_BACK_SPECULAR]); - } - } - - if (bitmask & MAT_BIT_FRONT_SHININESS) { - _mesa_invalidate_shine_table( ctx, 0 ); - } - - if (bitmask & MAT_BIT_BACK_SHININESS) { - _mesa_invalidate_shine_table( ctx, 1 ); - } -} - - -/* - * Update the current materials from the given rgba color - * according to the bitmask in ColorMaterialBitmask, which is - * set by glColorMaterial(). - */ -void -_mesa_update_color_material( struct gl_context *ctx, const GLfloat color[4] ) -{ - GLuint bitmask = ctx->Light.ColorMaterialBitmask; - struct gl_material *mat = &ctx->Light.Material; - int i; - - for (i = 0 ; i < MAT_ATTRIB_MAX ; i++) - if (bitmask & (1<Attrib[i], color ); - - _mesa_update_material( ctx, bitmask ); -} - - -void GLAPIENTRY -_mesa_ColorMaterial( GLenum face, GLenum mode ) -{ - GET_CURRENT_CONTEXT(ctx); - GLuint bitmask; - GLuint legal = (MAT_BIT_FRONT_EMISSION | MAT_BIT_BACK_EMISSION | - MAT_BIT_FRONT_SPECULAR | MAT_BIT_BACK_SPECULAR | - MAT_BIT_FRONT_DIFFUSE | MAT_BIT_BACK_DIFFUSE | - MAT_BIT_FRONT_AMBIENT | MAT_BIT_BACK_AMBIENT); - ASSERT_OUTSIDE_BEGIN_END(ctx); - - if (MESA_VERBOSE&VERBOSE_API) - _mesa_debug(ctx, "glColorMaterial %s %s\n", - _mesa_lookup_enum_by_nr(face), - _mesa_lookup_enum_by_nr(mode)); - - bitmask = _mesa_material_bitmask(ctx, face, mode, legal, "glColorMaterial"); - - if (ctx->Light.ColorMaterialBitmask == bitmask && - ctx->Light.ColorMaterialFace == face && - ctx->Light.ColorMaterialMode == mode) - return; - - FLUSH_VERTICES(ctx, _NEW_LIGHT); - ctx->Light.ColorMaterialBitmask = bitmask; - ctx->Light.ColorMaterialFace = face; - ctx->Light.ColorMaterialMode = mode; - - if (ctx->Light.ColorMaterialEnabled) { - FLUSH_CURRENT( ctx, 0 ); - _mesa_update_color_material(ctx,ctx->Current.Attrib[VERT_ATTRIB_COLOR0]); - } - - if (ctx->Driver.ColorMaterial) - ctx->Driver.ColorMaterial( ctx, face, mode ); -} - - -void GLAPIENTRY -_mesa_GetMaterialfv( GLenum face, GLenum pname, GLfloat *params ) -{ - GET_CURRENT_CONTEXT(ctx); - GLuint f; - GLfloat (*mat)[4] = ctx->Light.Material.Attrib; - ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); /* update materials */ - - FLUSH_CURRENT(ctx, 0); /* update ctx->Light.Material from vertex buffer */ - - if (face==GL_FRONT) { - f = 0; - } - else if (face==GL_BACK) { - f = 1; - } - else { - _mesa_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(face)" ); - return; - } - - switch (pname) { - case GL_AMBIENT: - COPY_4FV( params, mat[MAT_ATTRIB_AMBIENT(f)] ); - break; - case GL_DIFFUSE: - COPY_4FV( params, mat[MAT_ATTRIB_DIFFUSE(f)] ); - break; - case GL_SPECULAR: - COPY_4FV( params, mat[MAT_ATTRIB_SPECULAR(f)] ); - break; - case GL_EMISSION: - COPY_4FV( params, mat[MAT_ATTRIB_EMISSION(f)] ); - break; - case GL_SHININESS: - *params = mat[MAT_ATTRIB_SHININESS(f)][0]; - break; - case GL_COLOR_INDEXES: - params[0] = mat[MAT_ATTRIB_INDEXES(f)][0]; - params[1] = mat[MAT_ATTRIB_INDEXES(f)][1]; - params[2] = mat[MAT_ATTRIB_INDEXES(f)][2]; - break; - default: - _mesa_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(pname)" ); - } -} - - -void GLAPIENTRY -_mesa_GetMaterialiv( GLenum face, GLenum pname, GLint *params ) -{ - GET_CURRENT_CONTEXT(ctx); - GLuint f; - GLfloat (*mat)[4] = ctx->Light.Material.Attrib; - ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); /* update materials */ - - FLUSH_CURRENT(ctx, 0); /* update ctx->Light.Material from vertex buffer */ - - if (face==GL_FRONT) { - f = 0; - } - else if (face==GL_BACK) { - f = 1; - } - else { - _mesa_error( ctx, GL_INVALID_ENUM, "glGetMaterialiv(face)" ); - return; - } - switch (pname) { - case GL_AMBIENT: - params[0] = FLOAT_TO_INT( mat[MAT_ATTRIB_AMBIENT(f)][0] ); - params[1] = FLOAT_TO_INT( mat[MAT_ATTRIB_AMBIENT(f)][1] ); - params[2] = FLOAT_TO_INT( mat[MAT_ATTRIB_AMBIENT(f)][2] ); - params[3] = FLOAT_TO_INT( mat[MAT_ATTRIB_AMBIENT(f)][3] ); - break; - case GL_DIFFUSE: - params[0] = FLOAT_TO_INT( mat[MAT_ATTRIB_DIFFUSE(f)][0] ); - params[1] = FLOAT_TO_INT( mat[MAT_ATTRIB_DIFFUSE(f)][1] ); - params[2] = FLOAT_TO_INT( mat[MAT_ATTRIB_DIFFUSE(f)][2] ); - params[3] = FLOAT_TO_INT( mat[MAT_ATTRIB_DIFFUSE(f)][3] ); - break; - case GL_SPECULAR: - params[0] = FLOAT_TO_INT( mat[MAT_ATTRIB_SPECULAR(f)][0] ); - params[1] = FLOAT_TO_INT( mat[MAT_ATTRIB_SPECULAR(f)][1] ); - params[2] = FLOAT_TO_INT( mat[MAT_ATTRIB_SPECULAR(f)][2] ); - params[3] = FLOAT_TO_INT( mat[MAT_ATTRIB_SPECULAR(f)][3] ); - break; - case GL_EMISSION: - params[0] = FLOAT_TO_INT( mat[MAT_ATTRIB_EMISSION(f)][0] ); - params[1] = FLOAT_TO_INT( mat[MAT_ATTRIB_EMISSION(f)][1] ); - params[2] = FLOAT_TO_INT( mat[MAT_ATTRIB_EMISSION(f)][2] ); - params[3] = FLOAT_TO_INT( mat[MAT_ATTRIB_EMISSION(f)][3] ); - break; - case GL_SHININESS: - *params = IROUND( mat[MAT_ATTRIB_SHININESS(f)][0] ); - break; - case GL_COLOR_INDEXES: - params[0] = IROUND( mat[MAT_ATTRIB_INDEXES(f)][0] ); - params[1] = IROUND( mat[MAT_ATTRIB_INDEXES(f)][1] ); - params[2] = IROUND( mat[MAT_ATTRIB_INDEXES(f)][2] ); - break; - default: - _mesa_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(pname)" ); - } -} - - - -/**********************************************************************/ -/***** Lighting computation *****/ -/**********************************************************************/ - - -/* - * Notes: - * When two-sided lighting is enabled we compute the color (or index) - * for both the front and back side of the primitive. Then, when the - * orientation of the facet is later learned, we can determine which - * color (or index) to use for rendering. - * - * KW: We now know orientation in advance and only shade for - * the side or sides which are actually required. - * - * Variables: - * n = normal vector - * V = vertex position - * P = light source position - * Pe = (0,0,0,1) - * - * Precomputed: - * IF P[3]==0 THEN - * // light at infinity - * IF local_viewer THEN - * _VP_inf_norm = unit vector from V to P // Precompute - * ELSE - * // eye at infinity - * _h_inf_norm = Normalize( VP + <0,0,1> ) // Precompute - * ENDIF - * ENDIF - * - * Functions: - * Normalize( v ) = normalized vector v - * Magnitude( v ) = length of vector v - */ - - - -/* - * Whenever the spotlight exponent for a light changes we must call - * this function to recompute the exponent lookup table. - */ -void -_mesa_invalidate_spot_exp_table( struct gl_light *l ) -{ - l->_SpotExpTable[0][0] = -1; -} - - -static void -validate_spot_exp_table( struct gl_light *l ) -{ - GLint i; - GLdouble exponent = l->SpotExponent; - GLdouble tmp = 0; - GLint clamp = 0; - - l->_SpotExpTable[0][0] = 0.0; - - for (i = EXP_TABLE_SIZE - 1; i > 0 ;i--) { - if (clamp == 0) { - tmp = pow(i / (GLdouble) (EXP_TABLE_SIZE - 1), exponent); - if (tmp < FLT_MIN * 100.0) { - tmp = 0.0; - clamp = 1; - } - } - l->_SpotExpTable[i][0] = (GLfloat) tmp; - } - for (i = 0; i < EXP_TABLE_SIZE - 1; i++) { - l->_SpotExpTable[i][1] = (l->_SpotExpTable[i+1][0] - - l->_SpotExpTable[i][0]); - } - l->_SpotExpTable[EXP_TABLE_SIZE-1][1] = 0.0; -} - - - -/* Calculate a new shine table. Doing this here saves a branch in - * lighting, and the cost of doing it early may be partially offset - * by keeping a MRU cache of shine tables for various shine values. - */ -void -_mesa_invalidate_shine_table( struct gl_context *ctx, GLuint side ) -{ - ASSERT(side < 2); - if (ctx->_ShineTable[side]) - ctx->_ShineTable[side]->refcount--; - ctx->_ShineTable[side] = NULL; -} - - -static void -validate_shine_table( struct gl_context *ctx, GLuint side, GLfloat shininess ) -{ - struct gl_shine_tab *list = ctx->_ShineTabList; - struct gl_shine_tab *s; - - ASSERT(side < 2); - - foreach(s, list) - if ( s->shininess == shininess ) - break; - - if (s == list) { - GLint j; - GLfloat *m; - - foreach(s, list) - if (s->refcount == 0) - break; - - m = s->tab; - m[0] = 0.0; - if (shininess == 0.0) { - for (j = 1 ; j <= SHINE_TABLE_SIZE ; j++) - m[j] = 1.0; - } - else { - for (j = 1 ; j < SHINE_TABLE_SIZE ; j++) { - GLdouble t, x = j / (GLfloat) (SHINE_TABLE_SIZE - 1); - if (x < 0.005) /* underflow check */ - x = 0.005; - t = pow(x, shininess); - if (t > 1e-20) - m[j] = (GLfloat) t; - else - m[j] = 0.0; - } - m[SHINE_TABLE_SIZE] = 1.0; - } - - s->shininess = shininess; - } - - if (ctx->_ShineTable[side]) - ctx->_ShineTable[side]->refcount--; - - ctx->_ShineTable[side] = s; - move_to_tail( list, s ); - s->refcount++; -} - - -void -_mesa_validate_all_lighting_tables( struct gl_context *ctx ) -{ - GLuint i; - GLfloat shininess; - - shininess = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_SHININESS][0]; - if (!ctx->_ShineTable[0] || ctx->_ShineTable[0]->shininess != shininess) - validate_shine_table( ctx, 0, shininess ); - - shininess = ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_SHININESS][0]; - if (!ctx->_ShineTable[1] || ctx->_ShineTable[1]->shininess != shininess) - validate_shine_table( ctx, 1, shininess ); - - for (i = 0; i < ctx->Const.MaxLights; i++) - if (ctx->Light.Light[i]._SpotExpTable[0][0] == -1) - validate_spot_exp_table( &ctx->Light.Light[i] ); -} - - -/** - * Examine current lighting parameters to determine if the optimized lighting - * function can be used. - * Also, precompute some lighting values such as the products of light - * source and material ambient, diffuse and specular coefficients. - */ -void -_mesa_update_lighting( struct gl_context *ctx ) -{ - struct gl_light *light; - ctx->Light._NeedEyeCoords = GL_FALSE; - ctx->Light._Flags = 0; - - if (!ctx->Light.Enabled) - return; - - foreach(light, &ctx->Light.EnabledList) { - ctx->Light._Flags |= light->_Flags; - } - - ctx->Light._NeedVertices = - ((ctx->Light._Flags & (LIGHT_POSITIONAL|LIGHT_SPOT)) || - ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR || - ctx->Light.Model.LocalViewer); - - ctx->Light._NeedEyeCoords = ((ctx->Light._Flags & LIGHT_POSITIONAL) || - ctx->Light.Model.LocalViewer); - - /* XXX: This test is overkill & needs to be fixed both for software and - * hardware t&l drivers. The above should be sufficient & should - * be tested to verify this. - */ - if (ctx->Light._NeedVertices) - ctx->Light._NeedEyeCoords = GL_TRUE; - - /* Precompute some shading values. Although we reference - * Light.Material here, we can get away without flushing - * FLUSH_UPDATE_CURRENT, as when any outstanding material changes - * are flushed, they will update the derived state at that time. - */ - if (ctx->Light.Model.TwoSide) - _mesa_update_material(ctx, - MAT_BIT_FRONT_EMISSION | - MAT_BIT_FRONT_AMBIENT | - MAT_BIT_FRONT_DIFFUSE | - MAT_BIT_FRONT_SPECULAR | - MAT_BIT_BACK_EMISSION | - MAT_BIT_BACK_AMBIENT | - MAT_BIT_BACK_DIFFUSE | - MAT_BIT_BACK_SPECULAR); - else - _mesa_update_material(ctx, - MAT_BIT_FRONT_EMISSION | - MAT_BIT_FRONT_AMBIENT | - MAT_BIT_FRONT_DIFFUSE | - MAT_BIT_FRONT_SPECULAR); -} - - -/** - * Update state derived from light position, spot direction. - * Called upon: - * _NEW_MODELVIEW - * _NEW_LIGHT - * _TNL_NEW_NEED_EYE_COORDS - * - * Update on (_NEW_MODELVIEW | _NEW_LIGHT) when lighting is enabled. - * Also update on lighting space changes. - */ -static void -compute_light_positions( struct gl_context *ctx ) -{ - struct gl_light *light; - static const GLfloat eye_z[3] = { 0, 0, 1 }; - - if (!ctx->Light.Enabled) - return; - - if (ctx->_NeedEyeCoords) { - COPY_3V( ctx->_EyeZDir, eye_z ); - } - else { - TRANSFORM_NORMAL( ctx->_EyeZDir, eye_z, ctx->ModelviewMatrixStack.Top->m ); - } - - foreach (light, &ctx->Light.EnabledList) { - - if (ctx->_NeedEyeCoords) { - /* _Position is in eye coordinate space */ - COPY_4FV( light->_Position, light->EyePosition ); - } - else { - /* _Position is in object coordinate space */ - TRANSFORM_POINT( light->_Position, ctx->ModelviewMatrixStack.Top->inv, - light->EyePosition ); - } - - if (!(light->_Flags & LIGHT_POSITIONAL)) { - /* VP (VP) = Normalize( Position ) */ - COPY_3V( light->_VP_inf_norm, light->_Position ); - NORMALIZE_3FV( light->_VP_inf_norm ); - - if (!ctx->Light.Model.LocalViewer) { - /* _h_inf_norm = Normalize( V_to_P + <0,0,1> ) */ - ADD_3V( light->_h_inf_norm, light->_VP_inf_norm, ctx->_EyeZDir); - NORMALIZE_3FV( light->_h_inf_norm ); - } - light->_VP_inf_spot_attenuation = 1.0; - } - else { - /* positional light w/ homogeneous coordinate, divide by W */ - GLfloat wInv = (GLfloat)1.0 / light->_Position[3]; - light->_Position[0] *= wInv; - light->_Position[1] *= wInv; - light->_Position[2] *= wInv; - } - - if (light->_Flags & LIGHT_SPOT) { - /* Note: we normalize the spot direction now */ - - if (ctx->_NeedEyeCoords) { - COPY_3V( light->_NormSpotDirection, light->SpotDirection ); - NORMALIZE_3FV( light->_NormSpotDirection ); - } - else { - GLfloat spotDir[3]; - COPY_3V(spotDir, light->SpotDirection); - NORMALIZE_3FV(spotDir); - TRANSFORM_NORMAL( light->_NormSpotDirection, - spotDir, - ctx->ModelviewMatrixStack.Top->m); - } - - NORMALIZE_3FV( light->_NormSpotDirection ); - - if (!(light->_Flags & LIGHT_POSITIONAL)) { - GLfloat PV_dot_dir = - DOT3(light->_VP_inf_norm, - light->_NormSpotDirection); - - if (PV_dot_dir > light->_CosCutoff) { - double x = PV_dot_dir * (EXP_TABLE_SIZE-1); - int k = (int) x; - light->_VP_inf_spot_attenuation = - (GLfloat) (light->_SpotExpTable[k][0] + - (x-k)*light->_SpotExpTable[k][1]); - } - else { - light->_VP_inf_spot_attenuation = 0; - } - } - } - } -} - - - -static void -update_modelview_scale( struct gl_context *ctx ) -{ - ctx->_ModelViewInvScale = 1.0F; - if (!_math_matrix_is_length_preserving(ctx->ModelviewMatrixStack.Top)) { - const GLfloat *m = ctx->ModelviewMatrixStack.Top->inv; - GLfloat f = m[2] * m[2] + m[6] * m[6] + m[10] * m[10]; - if (f < 1e-12) f = 1.0; - if (ctx->_NeedEyeCoords) - ctx->_ModelViewInvScale = (GLfloat) INV_SQRTF(f); - else - ctx->_ModelViewInvScale = (GLfloat) SQRTF(f); - } -} - - -/** - * Bring up to date any state that relies on _NeedEyeCoords. - */ -void -_mesa_update_tnl_spaces( struct gl_context *ctx, GLuint new_state ) -{ - const GLuint oldneedeyecoords = ctx->_NeedEyeCoords; - - (void) new_state; - ctx->_NeedEyeCoords = GL_FALSE; - - if (ctx->_ForceEyeCoords || - (ctx->Texture._GenFlags & TEXGEN_NEED_EYE_COORD) || - ctx->Point._Attenuated || - ctx->Light._NeedEyeCoords) - ctx->_NeedEyeCoords = GL_TRUE; - - if (ctx->Light.Enabled && - !_math_matrix_is_length_preserving(ctx->ModelviewMatrixStack.Top)) - ctx->_NeedEyeCoords = GL_TRUE; - - /* Check if the truth-value interpretations of the bitfields have - * changed: - */ - if (oldneedeyecoords != ctx->_NeedEyeCoords) { - /* Recalculate all state that depends on _NeedEyeCoords. - */ - update_modelview_scale(ctx); - compute_light_positions( ctx ); - - if (ctx->Driver.LightingSpaceChange) - ctx->Driver.LightingSpaceChange( ctx ); - } - else { - GLuint new_state2 = ctx->NewState; - - /* Recalculate that same state only if it has been invalidated - * by other statechanges. - */ - if (new_state2 & _NEW_MODELVIEW) - update_modelview_scale(ctx); - - if (new_state2 & (_NEW_LIGHT|_NEW_MODELVIEW)) - compute_light_positions( ctx ); - } -} - - -/** - * Drivers may need this if the hardware tnl unit doesn't support the - * light-in-modelspace optimization. It's also useful for debugging. - */ -void -_mesa_allow_light_in_model( struct gl_context *ctx, GLboolean flag ) -{ - ctx->_ForceEyeCoords = !flag; - ctx->NewState |= _NEW_POINT; /* one of the bits from - * _MESA_NEW_NEED_EYE_COORDS. - */ -} - - - -/**********************************************************************/ -/***** Initialization *****/ -/**********************************************************************/ - -/** - * Initialize the n-th light data structure. - * - * \param l pointer to the gl_light structure to be initialized. - * \param n number of the light. - * \note The defaults for light 0 are different than the other lights. - */ -static void -init_light( struct gl_light *l, GLuint n ) -{ - make_empty_list( l ); - - ASSIGN_4V( l->Ambient, 0.0, 0.0, 0.0, 1.0 ); - if (n==0) { - ASSIGN_4V( l->Diffuse, 1.0, 1.0, 1.0, 1.0 ); - ASSIGN_4V( l->Specular, 1.0, 1.0, 1.0, 1.0 ); - } - else { - ASSIGN_4V( l->Diffuse, 0.0, 0.0, 0.0, 1.0 ); - ASSIGN_4V( l->Specular, 0.0, 0.0, 0.0, 1.0 ); - } - ASSIGN_4V( l->EyePosition, 0.0, 0.0, 1.0, 0.0 ); - ASSIGN_3V( l->SpotDirection, 0.0, 0.0, -1.0 ); - l->SpotExponent = 0.0; - _mesa_invalidate_spot_exp_table( l ); - l->SpotCutoff = 180.0; - l->_CosCutoffNeg = -1.0f; - l->_CosCutoff = 0.0; /* KW: -ve values not admitted */ - l->ConstantAttenuation = 1.0; - l->LinearAttenuation = 0.0; - l->QuadraticAttenuation = 0.0; - l->Enabled = GL_FALSE; -} - - -/** - * Initialize the light model data structure. - * - * \param lm pointer to the gl_lightmodel structure to be initialized. - */ -static void -init_lightmodel( struct gl_lightmodel *lm ) -{ - ASSIGN_4V( lm->Ambient, 0.2F, 0.2F, 0.2F, 1.0F ); - lm->LocalViewer = GL_FALSE; - lm->TwoSide = GL_FALSE; - lm->ColorControl = GL_SINGLE_COLOR; -} - - -/** - * Initialize the material data structure. - * - * \param m pointer to the gl_material structure to be initialized. - */ -static void -init_material( struct gl_material *m ) -{ - ASSIGN_4V( m->Attrib[MAT_ATTRIB_FRONT_AMBIENT], 0.2F, 0.2F, 0.2F, 1.0F ); - ASSIGN_4V( m->Attrib[MAT_ATTRIB_FRONT_DIFFUSE], 0.8F, 0.8F, 0.8F, 1.0F ); - ASSIGN_4V( m->Attrib[MAT_ATTRIB_FRONT_SPECULAR], 0.0F, 0.0F, 0.0F, 1.0F ); - ASSIGN_4V( m->Attrib[MAT_ATTRIB_FRONT_EMISSION], 0.0F, 0.0F, 0.0F, 1.0F ); - ASSIGN_4V( m->Attrib[MAT_ATTRIB_FRONT_SHININESS], 0.0F, 0.0F, 0.0F, 0.0F ); - ASSIGN_4V( m->Attrib[MAT_ATTRIB_FRONT_INDEXES], 0.0F, 1.0F, 1.0F, 0.0F ); - - ASSIGN_4V( m->Attrib[MAT_ATTRIB_BACK_AMBIENT], 0.2F, 0.2F, 0.2F, 1.0F ); - ASSIGN_4V( m->Attrib[MAT_ATTRIB_BACK_DIFFUSE], 0.8F, 0.8F, 0.8F, 1.0F ); - ASSIGN_4V( m->Attrib[MAT_ATTRIB_BACK_SPECULAR], 0.0F, 0.0F, 0.0F, 1.0F ); - ASSIGN_4V( m->Attrib[MAT_ATTRIB_BACK_EMISSION], 0.0F, 0.0F, 0.0F, 1.0F ); - ASSIGN_4V( m->Attrib[MAT_ATTRIB_BACK_SHININESS], 0.0F, 0.0F, 0.0F, 0.0F ); - ASSIGN_4V( m->Attrib[MAT_ATTRIB_BACK_INDEXES], 0.0F, 1.0F, 1.0F, 0.0F ); -} - - -/** - * Initialize all lighting state for the given context. - */ -void -_mesa_init_lighting( struct gl_context *ctx ) -{ - GLuint i; - - /* Lighting group */ - for (i = 0; i < MAX_LIGHTS; i++) { - init_light( &ctx->Light.Light[i], i ); - } - make_empty_list( &ctx->Light.EnabledList ); - - init_lightmodel( &ctx->Light.Model ); - init_material( &ctx->Light.Material ); - ctx->Light.ShadeModel = GL_SMOOTH; - ctx->Light.ProvokingVertex = GL_LAST_VERTEX_CONVENTION_EXT; - ctx->Light.Enabled = GL_FALSE; - ctx->Light.ColorMaterialFace = GL_FRONT_AND_BACK; - ctx->Light.ColorMaterialMode = GL_AMBIENT_AND_DIFFUSE; - ctx->Light.ColorMaterialBitmask = _mesa_material_bitmask( ctx, - GL_FRONT_AND_BACK, - GL_AMBIENT_AND_DIFFUSE, ~0, - NULL ); - - ctx->Light.ColorMaterialEnabled = GL_FALSE; - ctx->Light.ClampVertexColor = GL_TRUE; - - /* Lighting miscellaneous */ - ctx->_ShineTabList = MALLOC_STRUCT( gl_shine_tab ); - make_empty_list( ctx->_ShineTabList ); - /* Allocate 10 (arbitrary) shininess lookup tables */ - for (i = 0 ; i < 10 ; i++) { - struct gl_shine_tab *s = MALLOC_STRUCT( gl_shine_tab ); - s->shininess = -1; - s->refcount = 0; - insert_at_tail( ctx->_ShineTabList, s ); - } - - /* Miscellaneous */ - ctx->Light._NeedEyeCoords = GL_FALSE; - ctx->_NeedEyeCoords = GL_FALSE; - ctx->_ForceEyeCoords = GL_FALSE; - ctx->_ModelViewInvScale = 1.0; -} - - -/** - * Deallocate malloc'd lighting state attached to given context. - */ -void -_mesa_free_lighting_data( struct gl_context *ctx ) -{ - struct gl_shine_tab *s, *tmps; - - /* Free lighting shininess exponentiation table */ - foreach_s( s, tmps, ctx->_ShineTabList ) { - free( s ); - } - free( ctx->_ShineTabList ); -} +/* + * Mesa 3-D graphics library + * Version: 7.5 + * + * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. + * Copyright (C) 2009 VMware, Inc. All Rights Reserved. + * + * 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 + * BRIAN PAUL 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 "glheader.h" +#include "imports.h" +#include "context.h" +#include "enums.h" +#include "light.h" +#include "macros.h" +#include "simple_list.h" +#include "mtypes.h" +#include "math/m_matrix.h" + + +void GLAPIENTRY +_mesa_ShadeModel( GLenum mode ) +{ + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END(ctx); + + if (MESA_VERBOSE & VERBOSE_API) + _mesa_debug(ctx, "glShadeModel %s\n", _mesa_lookup_enum_by_nr(mode)); + + if (mode != GL_FLAT && mode != GL_SMOOTH) { + _mesa_error(ctx, GL_INVALID_ENUM, "glShadeModel"); + return; + } + + if (ctx->Light.ShadeModel == mode) + return; + + FLUSH_VERTICES(ctx, _NEW_LIGHT); + ctx->Light.ShadeModel = mode; + if (mode == GL_FLAT) + ctx->_TriangleCaps |= DD_FLATSHADE; + else + ctx->_TriangleCaps &= ~DD_FLATSHADE; + + if (ctx->Driver.ShadeModel) + ctx->Driver.ShadeModel( ctx, mode ); +} + + +/** + * Set the provoking vertex (the vertex which specifies the prim's + * color when flat shading) to either the first or last vertex of the + * triangle or line. + */ +void GLAPIENTRY +_mesa_ProvokingVertexEXT(GLenum mode) +{ + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END(ctx); + + if (MESA_VERBOSE&VERBOSE_API) + _mesa_debug(ctx, "glProvokingVertexEXT 0x%x\n", mode); + + switch (mode) { + case GL_FIRST_VERTEX_CONVENTION_EXT: + case GL_LAST_VERTEX_CONVENTION_EXT: + break; + default: + _mesa_error(ctx, GL_INVALID_ENUM, "glProvokingVertexEXT(0x%x)", mode); + return; + } + + if (ctx->Light.ProvokingVertex == mode) + return; + + FLUSH_VERTICES(ctx, _NEW_LIGHT); + ctx->Light.ProvokingVertex = mode; +} + + +/** + * Helper function called by _mesa_Lightfv and _mesa_PopAttrib to set + * per-light state. + * For GL_POSITION and GL_SPOT_DIRECTION the params position/direction + * will have already been transformed by the modelview matrix! + * Also, all error checking should have already been done. + */ +void +_mesa_light(struct gl_context *ctx, GLuint lnum, GLenum pname, const GLfloat *params) +{ + struct gl_light *light; + + ASSERT(lnum < MAX_LIGHTS); + light = &ctx->Light.Light[lnum]; + + switch (pname) { + case GL_AMBIENT: + if (TEST_EQ_4V(light->Ambient, params)) + return; + FLUSH_VERTICES(ctx, _NEW_LIGHT); + COPY_4V( light->Ambient, params ); + break; + case GL_DIFFUSE: + if (TEST_EQ_4V(light->Diffuse, params)) + return; + FLUSH_VERTICES(ctx, _NEW_LIGHT); + COPY_4V( light->Diffuse, params ); + break; + case GL_SPECULAR: + if (TEST_EQ_4V(light->Specular, params)) + return; + FLUSH_VERTICES(ctx, _NEW_LIGHT); + COPY_4V( light->Specular, params ); + break; + case GL_POSITION: + /* NOTE: position has already been transformed by ModelView! */ + if (TEST_EQ_4V(light->EyePosition, params)) + return; + FLUSH_VERTICES(ctx, _NEW_LIGHT); + COPY_4V(light->EyePosition, params); + if (light->EyePosition[3] != 0.0F) + light->_Flags |= LIGHT_POSITIONAL; + else + light->_Flags &= ~LIGHT_POSITIONAL; + break; + case GL_SPOT_DIRECTION: + /* NOTE: Direction already transformed by inverse ModelView! */ + if (TEST_EQ_3V(light->SpotDirection, params)) + return; + FLUSH_VERTICES(ctx, _NEW_LIGHT); + COPY_3V(light->SpotDirection, params); + break; + case GL_SPOT_EXPONENT: + ASSERT(params[0] >= 0.0); + ASSERT(params[0] <= ctx->Const.MaxSpotExponent); + if (light->SpotExponent == params[0]) + return; + FLUSH_VERTICES(ctx, _NEW_LIGHT); + light->SpotExponent = params[0]; + _mesa_invalidate_spot_exp_table(light); + break; + case GL_SPOT_CUTOFF: + ASSERT(params[0] == 180.0 || (params[0] >= 0.0 && params[0] <= 90.0)); + if (light->SpotCutoff == params[0]) + return; + FLUSH_VERTICES(ctx, _NEW_LIGHT); + light->SpotCutoff = params[0]; + light->_CosCutoffNeg = (GLfloat) (cos(light->SpotCutoff * DEG2RAD)); + if (light->_CosCutoffNeg < 0) + light->_CosCutoff = 0; + else + light->_CosCutoff = light->_CosCutoffNeg; + if (light->SpotCutoff != 180.0F) + light->_Flags |= LIGHT_SPOT; + else + light->_Flags &= ~LIGHT_SPOT; + break; + case GL_CONSTANT_ATTENUATION: + ASSERT(params[0] >= 0.0); + if (light->ConstantAttenuation == params[0]) + return; + FLUSH_VERTICES(ctx, _NEW_LIGHT); + light->ConstantAttenuation = params[0]; + break; + case GL_LINEAR_ATTENUATION: + ASSERT(params[0] >= 0.0); + if (light->LinearAttenuation == params[0]) + return; + FLUSH_VERTICES(ctx, _NEW_LIGHT); + light->LinearAttenuation = params[0]; + break; + case GL_QUADRATIC_ATTENUATION: + ASSERT(params[0] >= 0.0); + if (light->QuadraticAttenuation == params[0]) + return; + FLUSH_VERTICES(ctx, _NEW_LIGHT); + light->QuadraticAttenuation = params[0]; + break; + default: + _mesa_problem(ctx, "Unexpected pname in _mesa_light()"); + return; + } + + if (ctx->Driver.Lightfv) + ctx->Driver.Lightfv( ctx, GL_LIGHT0 + lnum, pname, params ); +} + + +void GLAPIENTRY +_mesa_Lightf( GLenum light, GLenum pname, GLfloat param ) +{ + GLfloat fparam[4]; + fparam[0] = param; + fparam[1] = fparam[2] = fparam[3] = 0.0F; + _mesa_Lightfv( light, pname, fparam ); +} + + +void GLAPIENTRY +_mesa_Lightfv( GLenum light, GLenum pname, const GLfloat *params ) +{ + GET_CURRENT_CONTEXT(ctx); + GLint i = (GLint) (light - GL_LIGHT0); + GLfloat temp[4]; + ASSERT_OUTSIDE_BEGIN_END(ctx); + + if (i < 0 || i >= (GLint) ctx->Const.MaxLights) { + _mesa_error( ctx, GL_INVALID_ENUM, "glLight(light=0x%x)", light ); + return; + } + + /* do particular error checks, transformations */ + switch (pname) { + case GL_AMBIENT: + case GL_DIFFUSE: + case GL_SPECULAR: + /* nothing */ + break; + case GL_POSITION: + /* transform position by ModelView matrix */ + TRANSFORM_POINT(temp, ctx->ModelviewMatrixStack.Top->m, params); + params = temp; + break; + case GL_SPOT_DIRECTION: + /* transform direction by inverse modelview */ + if (_math_matrix_is_dirty(ctx->ModelviewMatrixStack.Top)) { + _math_matrix_analyse(ctx->ModelviewMatrixStack.Top); + } + TRANSFORM_DIRECTION(temp, params, ctx->ModelviewMatrixStack.Top->m); + params = temp; + break; + case GL_SPOT_EXPONENT: + if (params[0] < 0.0 || params[0] > ctx->Const.MaxSpotExponent) { + _mesa_error(ctx, GL_INVALID_VALUE, "glLight"); + return; + } + break; + case GL_SPOT_CUTOFF: + if ((params[0] < 0.0 || params[0] > 90.0) && params[0] != 180.0) { + _mesa_error(ctx, GL_INVALID_VALUE, "glLight"); + return; + } + break; + case GL_CONSTANT_ATTENUATION: + if (params[0] < 0.0) { + _mesa_error(ctx, GL_INVALID_VALUE, "glLight"); + return; + } + break; + case GL_LINEAR_ATTENUATION: + if (params[0] < 0.0) { + _mesa_error(ctx, GL_INVALID_VALUE, "glLight"); + return; + } + break; + case GL_QUADRATIC_ATTENUATION: + if (params[0] < 0.0) { + _mesa_error(ctx, GL_INVALID_VALUE, "glLight"); + return; + } + break; + default: + _mesa_error(ctx, GL_INVALID_ENUM, "glLight(pname=0x%x)", pname); + return; + } + + _mesa_light(ctx, i, pname, params); +} + + +void GLAPIENTRY +_mesa_Lighti( GLenum light, GLenum pname, GLint param ) +{ + GLint iparam[4]; + iparam[0] = param; + iparam[1] = iparam[2] = iparam[3] = 0; + _mesa_Lightiv( light, pname, iparam ); +} + + +void GLAPIENTRY +_mesa_Lightiv( GLenum light, GLenum pname, const GLint *params ) +{ + GLfloat fparam[4]; + + switch (pname) { + case GL_AMBIENT: + case GL_DIFFUSE: + case GL_SPECULAR: + fparam[0] = INT_TO_FLOAT( params[0] ); + fparam[1] = INT_TO_FLOAT( params[1] ); + fparam[2] = INT_TO_FLOAT( params[2] ); + fparam[3] = INT_TO_FLOAT( params[3] ); + break; + case GL_POSITION: + fparam[0] = (GLfloat) params[0]; + fparam[1] = (GLfloat) params[1]; + fparam[2] = (GLfloat) params[2]; + fparam[3] = (GLfloat) params[3]; + break; + case GL_SPOT_DIRECTION: + fparam[0] = (GLfloat) params[0]; + fparam[1] = (GLfloat) params[1]; + fparam[2] = (GLfloat) params[2]; + break; + case GL_SPOT_EXPONENT: + case GL_SPOT_CUTOFF: + case GL_CONSTANT_ATTENUATION: + case GL_LINEAR_ATTENUATION: + case GL_QUADRATIC_ATTENUATION: + fparam[0] = (GLfloat) params[0]; + break; + default: + /* error will be caught later in gl_Lightfv */ + ; + } + + _mesa_Lightfv( light, pname, fparam ); +} + + + +void GLAPIENTRY +_mesa_GetLightfv( GLenum light, GLenum pname, GLfloat *params ) +{ + GET_CURRENT_CONTEXT(ctx); + GLint l = (GLint) (light - GL_LIGHT0); + ASSERT_OUTSIDE_BEGIN_END(ctx); + + if (l < 0 || l >= (GLint) ctx->Const.MaxLights) { + _mesa_error( ctx, GL_INVALID_ENUM, "glGetLightfv" ); + return; + } + + switch (pname) { + case GL_AMBIENT: + COPY_4V( params, ctx->Light.Light[l].Ambient ); + break; + case GL_DIFFUSE: + COPY_4V( params, ctx->Light.Light[l].Diffuse ); + break; + case GL_SPECULAR: + COPY_4V( params, ctx->Light.Light[l].Specular ); + break; + case GL_POSITION: + COPY_4V( params, ctx->Light.Light[l].EyePosition ); + break; + case GL_SPOT_DIRECTION: + COPY_3V( params, ctx->Light.Light[l].SpotDirection ); + break; + case GL_SPOT_EXPONENT: + params[0] = ctx->Light.Light[l].SpotExponent; + break; + case GL_SPOT_CUTOFF: + params[0] = ctx->Light.Light[l].SpotCutoff; + break; + case GL_CONSTANT_ATTENUATION: + params[0] = ctx->Light.Light[l].ConstantAttenuation; + break; + case GL_LINEAR_ATTENUATION: + params[0] = ctx->Light.Light[l].LinearAttenuation; + break; + case GL_QUADRATIC_ATTENUATION: + params[0] = ctx->Light.Light[l].QuadraticAttenuation; + break; + default: + _mesa_error( ctx, GL_INVALID_ENUM, "glGetLightfv" ); + break; + } +} + + +void GLAPIENTRY +_mesa_GetLightiv( GLenum light, GLenum pname, GLint *params ) +{ + GET_CURRENT_CONTEXT(ctx); + GLint l = (GLint) (light - GL_LIGHT0); + ASSERT_OUTSIDE_BEGIN_END(ctx); + + if (l < 0 || l >= (GLint) ctx->Const.MaxLights) { + _mesa_error( ctx, GL_INVALID_ENUM, "glGetLightiv" ); + return; + } + + switch (pname) { + case GL_AMBIENT: + params[0] = FLOAT_TO_INT(ctx->Light.Light[l].Ambient[0]); + params[1] = FLOAT_TO_INT(ctx->Light.Light[l].Ambient[1]); + params[2] = FLOAT_TO_INT(ctx->Light.Light[l].Ambient[2]); + params[3] = FLOAT_TO_INT(ctx->Light.Light[l].Ambient[3]); + break; + case GL_DIFFUSE: + params[0] = FLOAT_TO_INT(ctx->Light.Light[l].Diffuse[0]); + params[1] = FLOAT_TO_INT(ctx->Light.Light[l].Diffuse[1]); + params[2] = FLOAT_TO_INT(ctx->Light.Light[l].Diffuse[2]); + params[3] = FLOAT_TO_INT(ctx->Light.Light[l].Diffuse[3]); + break; + case GL_SPECULAR: + params[0] = FLOAT_TO_INT(ctx->Light.Light[l].Specular[0]); + params[1] = FLOAT_TO_INT(ctx->Light.Light[l].Specular[1]); + params[2] = FLOAT_TO_INT(ctx->Light.Light[l].Specular[2]); + params[3] = FLOAT_TO_INT(ctx->Light.Light[l].Specular[3]); + break; + case GL_POSITION: + params[0] = (GLint) ctx->Light.Light[l].EyePosition[0]; + params[1] = (GLint) ctx->Light.Light[l].EyePosition[1]; + params[2] = (GLint) ctx->Light.Light[l].EyePosition[2]; + params[3] = (GLint) ctx->Light.Light[l].EyePosition[3]; + break; + case GL_SPOT_DIRECTION: + params[0] = (GLint) ctx->Light.Light[l].SpotDirection[0]; + params[1] = (GLint) ctx->Light.Light[l].SpotDirection[1]; + params[2] = (GLint) ctx->Light.Light[l].SpotDirection[2]; + break; + case GL_SPOT_EXPONENT: + params[0] = (GLint) ctx->Light.Light[l].SpotExponent; + break; + case GL_SPOT_CUTOFF: + params[0] = (GLint) ctx->Light.Light[l].SpotCutoff; + break; + case GL_CONSTANT_ATTENUATION: + params[0] = (GLint) ctx->Light.Light[l].ConstantAttenuation; + break; + case GL_LINEAR_ATTENUATION: + params[0] = (GLint) ctx->Light.Light[l].LinearAttenuation; + break; + case GL_QUADRATIC_ATTENUATION: + params[0] = (GLint) ctx->Light.Light[l].QuadraticAttenuation; + break; + default: + _mesa_error( ctx, GL_INVALID_ENUM, "glGetLightiv" ); + break; + } +} + + + +/**********************************************************************/ +/*** Light Model ***/ +/**********************************************************************/ + + +void GLAPIENTRY +_mesa_LightModelfv( GLenum pname, const GLfloat *params ) +{ + GLenum newenum; + GLboolean newbool; + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END(ctx); + + switch (pname) { + case GL_LIGHT_MODEL_AMBIENT: + if (TEST_EQ_4V( ctx->Light.Model.Ambient, params )) + return; + FLUSH_VERTICES(ctx, _NEW_LIGHT); + COPY_4V( ctx->Light.Model.Ambient, params ); + break; + case GL_LIGHT_MODEL_LOCAL_VIEWER: + newbool = (params[0]!=0.0); + if (ctx->Light.Model.LocalViewer == newbool) + return; + FLUSH_VERTICES(ctx, _NEW_LIGHT); + ctx->Light.Model.LocalViewer = newbool; + break; + case GL_LIGHT_MODEL_TWO_SIDE: + newbool = (params[0]!=0.0); + if (ctx->Light.Model.TwoSide == newbool) + return; + FLUSH_VERTICES(ctx, _NEW_LIGHT); + ctx->Light.Model.TwoSide = newbool; + if (ctx->Light.Enabled && ctx->Light.Model.TwoSide) + ctx->_TriangleCaps |= DD_TRI_LIGHT_TWOSIDE; + else + ctx->_TriangleCaps &= ~DD_TRI_LIGHT_TWOSIDE; + break; + case GL_LIGHT_MODEL_COLOR_CONTROL: + if (params[0] == (GLfloat) GL_SINGLE_COLOR) + newenum = GL_SINGLE_COLOR; + else if (params[0] == (GLfloat) GL_SEPARATE_SPECULAR_COLOR) + newenum = GL_SEPARATE_SPECULAR_COLOR; + else { + _mesa_error( ctx, GL_INVALID_ENUM, "glLightModel(param=0x0%x)", + (GLint) params[0] ); + return; + } + if (ctx->Light.Model.ColorControl == newenum) + return; + FLUSH_VERTICES(ctx, _NEW_LIGHT); + ctx->Light.Model.ColorControl = newenum; + break; + default: + _mesa_error( ctx, GL_INVALID_ENUM, "glLightModel(pname=0x%x)", pname ); + break; + } + + if (ctx->Driver.LightModelfv) + ctx->Driver.LightModelfv( ctx, pname, params ); +} + + +void GLAPIENTRY +_mesa_LightModeliv( GLenum pname, const GLint *params ) +{ + GLfloat fparam[4]; + + switch (pname) { + case GL_LIGHT_MODEL_AMBIENT: + fparam[0] = INT_TO_FLOAT( params[0] ); + fparam[1] = INT_TO_FLOAT( params[1] ); + fparam[2] = INT_TO_FLOAT( params[2] ); + fparam[3] = INT_TO_FLOAT( params[3] ); + break; + case GL_LIGHT_MODEL_LOCAL_VIEWER: + case GL_LIGHT_MODEL_TWO_SIDE: + case GL_LIGHT_MODEL_COLOR_CONTROL: + fparam[0] = (GLfloat) params[0]; + break; + default: + /* Error will be caught later in gl_LightModelfv */ + ASSIGN_4V(fparam, 0.0F, 0.0F, 0.0F, 0.0F); + } + _mesa_LightModelfv( pname, fparam ); +} + + +void GLAPIENTRY +_mesa_LightModeli( GLenum pname, GLint param ) +{ + GLint iparam[4]; + iparam[0] = param; + iparam[1] = iparam[2] = iparam[3] = 0; + _mesa_LightModeliv( pname, iparam ); +} + + +void GLAPIENTRY +_mesa_LightModelf( GLenum pname, GLfloat param ) +{ + GLfloat fparam[4]; + fparam[0] = param; + fparam[1] = fparam[2] = fparam[3] = 0.0F; + _mesa_LightModelfv( pname, fparam ); +} + + + +/********** MATERIAL **********/ + + +/* + * Given a face and pname value (ala glColorMaterial), compute a bitmask + * of the targeted material values. + */ +GLuint +_mesa_material_bitmask( struct gl_context *ctx, GLenum face, GLenum pname, + GLuint legal, const char *where ) +{ + GLuint bitmask = 0; + + /* Make a bitmask indicating what material attribute(s) we're updating */ + switch (pname) { + case GL_EMISSION: + bitmask |= MAT_BIT_FRONT_EMISSION | MAT_BIT_BACK_EMISSION; + break; + case GL_AMBIENT: + bitmask |= MAT_BIT_FRONT_AMBIENT | MAT_BIT_BACK_AMBIENT; + break; + case GL_DIFFUSE: + bitmask |= MAT_BIT_FRONT_DIFFUSE | MAT_BIT_BACK_DIFFUSE; + break; + case GL_SPECULAR: + bitmask |= MAT_BIT_FRONT_SPECULAR | MAT_BIT_BACK_SPECULAR; + break; + case GL_SHININESS: + bitmask |= MAT_BIT_FRONT_SHININESS | MAT_BIT_BACK_SHININESS; + break; + case GL_AMBIENT_AND_DIFFUSE: + bitmask |= MAT_BIT_FRONT_AMBIENT | MAT_BIT_BACK_AMBIENT; + bitmask |= MAT_BIT_FRONT_DIFFUSE | MAT_BIT_BACK_DIFFUSE; + break; + case GL_COLOR_INDEXES: + bitmask |= MAT_BIT_FRONT_INDEXES | MAT_BIT_BACK_INDEXES; + break; + default: + _mesa_error( ctx, GL_INVALID_ENUM, "%s", where ); + return 0; + } + + if (face==GL_FRONT) { + bitmask &= FRONT_MATERIAL_BITS; + } + else if (face==GL_BACK) { + bitmask &= BACK_MATERIAL_BITS; + } + else if (face != GL_FRONT_AND_BACK) { + _mesa_error( ctx, GL_INVALID_ENUM, "%s", where ); + return 0; + } + + if (bitmask & ~legal) { + _mesa_error( ctx, GL_INVALID_ENUM, "%s", where ); + return 0; + } + + return bitmask; +} + + + +/* Perform a straight copy between materials. + */ +void +_mesa_copy_materials( struct gl_material *dst, + const struct gl_material *src, + GLuint bitmask ) +{ + int i; + + for (i = 0 ; i < MAT_ATTRIB_MAX ; i++) + if (bitmask & (1<Attrib[i], src->Attrib[i] ); +} + + + +/* Update derived values following a change in ctx->Light.Material + */ +void +_mesa_update_material( struct gl_context *ctx, GLuint bitmask ) +{ + struct gl_light *light, *list = &ctx->Light.EnabledList; + GLfloat (*mat)[4] = ctx->Light.Material.Attrib; + + if (MESA_VERBOSE & VERBOSE_MATERIAL) + _mesa_debug(ctx, "_mesa_update_material, mask 0x%x\n", bitmask); + + if (!bitmask) + return; + + /* update material ambience */ + if (bitmask & MAT_BIT_FRONT_AMBIENT) { + foreach (light, list) { + SCALE_3V( light->_MatAmbient[0], light->Ambient, + mat[MAT_ATTRIB_FRONT_AMBIENT]); + } + } + + if (bitmask & MAT_BIT_BACK_AMBIENT) { + foreach (light, list) { + SCALE_3V( light->_MatAmbient[1], light->Ambient, + mat[MAT_ATTRIB_BACK_AMBIENT]); + } + } + + /* update BaseColor = emission + scene's ambience * material's ambience */ + if (bitmask & (MAT_BIT_FRONT_EMISSION | MAT_BIT_FRONT_AMBIENT)) { + COPY_3V( ctx->Light._BaseColor[0], mat[MAT_ATTRIB_FRONT_EMISSION] ); + ACC_SCALE_3V( ctx->Light._BaseColor[0], mat[MAT_ATTRIB_FRONT_AMBIENT], + ctx->Light.Model.Ambient ); + } + + if (bitmask & (MAT_BIT_BACK_EMISSION | MAT_BIT_BACK_AMBIENT)) { + COPY_3V( ctx->Light._BaseColor[1], mat[MAT_ATTRIB_BACK_EMISSION] ); + ACC_SCALE_3V( ctx->Light._BaseColor[1], mat[MAT_ATTRIB_BACK_AMBIENT], + ctx->Light.Model.Ambient ); + } + + /* update material diffuse values */ + if (bitmask & MAT_BIT_FRONT_DIFFUSE) { + foreach (light, list) { + SCALE_3V( light->_MatDiffuse[0], light->Diffuse, + mat[MAT_ATTRIB_FRONT_DIFFUSE] ); + } + } + + if (bitmask & MAT_BIT_BACK_DIFFUSE) { + foreach (light, list) { + SCALE_3V( light->_MatDiffuse[1], light->Diffuse, + mat[MAT_ATTRIB_BACK_DIFFUSE] ); + } + } + + /* update material specular values */ + if (bitmask & MAT_BIT_FRONT_SPECULAR) { + foreach (light, list) { + SCALE_3V( light->_MatSpecular[0], light->Specular, + mat[MAT_ATTRIB_FRONT_SPECULAR]); + } + } + + if (bitmask & MAT_BIT_BACK_SPECULAR) { + foreach (light, list) { + SCALE_3V( light->_MatSpecular[1], light->Specular, + mat[MAT_ATTRIB_BACK_SPECULAR]); + } + } + + if (bitmask & MAT_BIT_FRONT_SHININESS) { + _mesa_invalidate_shine_table( ctx, 0 ); + } + + if (bitmask & MAT_BIT_BACK_SHININESS) { + _mesa_invalidate_shine_table( ctx, 1 ); + } +} + + +/* + * Update the current materials from the given rgba color + * according to the bitmask in ColorMaterialBitmask, which is + * set by glColorMaterial(). + */ +void +_mesa_update_color_material( struct gl_context *ctx, const GLfloat color[4] ) +{ + GLuint bitmask = ctx->Light.ColorMaterialBitmask; + struct gl_material *mat = &ctx->Light.Material; + int i; + + for (i = 0 ; i < MAT_ATTRIB_MAX ; i++) + if (bitmask & (1<Attrib[i], color ); + + _mesa_update_material( ctx, bitmask ); +} + + +void GLAPIENTRY +_mesa_ColorMaterial( GLenum face, GLenum mode ) +{ + GET_CURRENT_CONTEXT(ctx); + GLuint bitmask; + GLuint legal = (MAT_BIT_FRONT_EMISSION | MAT_BIT_BACK_EMISSION | + MAT_BIT_FRONT_SPECULAR | MAT_BIT_BACK_SPECULAR | + MAT_BIT_FRONT_DIFFUSE | MAT_BIT_BACK_DIFFUSE | + MAT_BIT_FRONT_AMBIENT | MAT_BIT_BACK_AMBIENT); + ASSERT_OUTSIDE_BEGIN_END(ctx); + + if (MESA_VERBOSE&VERBOSE_API) + _mesa_debug(ctx, "glColorMaterial %s %s\n", + _mesa_lookup_enum_by_nr(face), + _mesa_lookup_enum_by_nr(mode)); + + bitmask = _mesa_material_bitmask(ctx, face, mode, legal, "glColorMaterial"); + + if (ctx->Light.ColorMaterialBitmask == bitmask && + ctx->Light.ColorMaterialFace == face && + ctx->Light.ColorMaterialMode == mode) + return; + + FLUSH_VERTICES(ctx, _NEW_LIGHT); + ctx->Light.ColorMaterialBitmask = bitmask; + ctx->Light.ColorMaterialFace = face; + ctx->Light.ColorMaterialMode = mode; + + if (ctx->Light.ColorMaterialEnabled) { + FLUSH_CURRENT( ctx, 0 ); + _mesa_update_color_material(ctx,ctx->Current.Attrib[VERT_ATTRIB_COLOR0]); + } + + if (ctx->Driver.ColorMaterial) + ctx->Driver.ColorMaterial( ctx, face, mode ); +} + + +void GLAPIENTRY +_mesa_GetMaterialfv( GLenum face, GLenum pname, GLfloat *params ) +{ + GET_CURRENT_CONTEXT(ctx); + GLuint f; + GLfloat (*mat)[4] = ctx->Light.Material.Attrib; + ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); /* update materials */ + + FLUSH_CURRENT(ctx, 0); /* update ctx->Light.Material from vertex buffer */ + + if (face==GL_FRONT) { + f = 0; + } + else if (face==GL_BACK) { + f = 1; + } + else { + _mesa_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(face)" ); + return; + } + + switch (pname) { + case GL_AMBIENT: + COPY_4FV( params, mat[MAT_ATTRIB_AMBIENT(f)] ); + break; + case GL_DIFFUSE: + COPY_4FV( params, mat[MAT_ATTRIB_DIFFUSE(f)] ); + break; + case GL_SPECULAR: + COPY_4FV( params, mat[MAT_ATTRIB_SPECULAR(f)] ); + break; + case GL_EMISSION: + COPY_4FV( params, mat[MAT_ATTRIB_EMISSION(f)] ); + break; + case GL_SHININESS: + *params = mat[MAT_ATTRIB_SHININESS(f)][0]; + break; + case GL_COLOR_INDEXES: + params[0] = mat[MAT_ATTRIB_INDEXES(f)][0]; + params[1] = mat[MAT_ATTRIB_INDEXES(f)][1]; + params[2] = mat[MAT_ATTRIB_INDEXES(f)][2]; + break; + default: + _mesa_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(pname)" ); + } +} + + +void GLAPIENTRY +_mesa_GetMaterialiv( GLenum face, GLenum pname, GLint *params ) +{ + GET_CURRENT_CONTEXT(ctx); + GLuint f; + GLfloat (*mat)[4] = ctx->Light.Material.Attrib; + ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); /* update materials */ + + FLUSH_CURRENT(ctx, 0); /* update ctx->Light.Material from vertex buffer */ + + if (face==GL_FRONT) { + f = 0; + } + else if (face==GL_BACK) { + f = 1; + } + else { + _mesa_error( ctx, GL_INVALID_ENUM, "glGetMaterialiv(face)" ); + return; + } + switch (pname) { + case GL_AMBIENT: + params[0] = FLOAT_TO_INT( mat[MAT_ATTRIB_AMBIENT(f)][0] ); + params[1] = FLOAT_TO_INT( mat[MAT_ATTRIB_AMBIENT(f)][1] ); + params[2] = FLOAT_TO_INT( mat[MAT_ATTRIB_AMBIENT(f)][2] ); + params[3] = FLOAT_TO_INT( mat[MAT_ATTRIB_AMBIENT(f)][3] ); + break; + case GL_DIFFUSE: + params[0] = FLOAT_TO_INT( mat[MAT_ATTRIB_DIFFUSE(f)][0] ); + params[1] = FLOAT_TO_INT( mat[MAT_ATTRIB_DIFFUSE(f)][1] ); + params[2] = FLOAT_TO_INT( mat[MAT_ATTRIB_DIFFUSE(f)][2] ); + params[3] = FLOAT_TO_INT( mat[MAT_ATTRIB_DIFFUSE(f)][3] ); + break; + case GL_SPECULAR: + params[0] = FLOAT_TO_INT( mat[MAT_ATTRIB_SPECULAR(f)][0] ); + params[1] = FLOAT_TO_INT( mat[MAT_ATTRIB_SPECULAR(f)][1] ); + params[2] = FLOAT_TO_INT( mat[MAT_ATTRIB_SPECULAR(f)][2] ); + params[3] = FLOAT_TO_INT( mat[MAT_ATTRIB_SPECULAR(f)][3] ); + break; + case GL_EMISSION: + params[0] = FLOAT_TO_INT( mat[MAT_ATTRIB_EMISSION(f)][0] ); + params[1] = FLOAT_TO_INT( mat[MAT_ATTRIB_EMISSION(f)][1] ); + params[2] = FLOAT_TO_INT( mat[MAT_ATTRIB_EMISSION(f)][2] ); + params[3] = FLOAT_TO_INT( mat[MAT_ATTRIB_EMISSION(f)][3] ); + break; + case GL_SHININESS: + *params = IROUND( mat[MAT_ATTRIB_SHININESS(f)][0] ); + break; + case GL_COLOR_INDEXES: + params[0] = IROUND( mat[MAT_ATTRIB_INDEXES(f)][0] ); + params[1] = IROUND( mat[MAT_ATTRIB_INDEXES(f)][1] ); + params[2] = IROUND( mat[MAT_ATTRIB_INDEXES(f)][2] ); + break; + default: + _mesa_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(pname)" ); + } +} + + + +/**********************************************************************/ +/***** Lighting computation *****/ +/**********************************************************************/ + + +/* + * Notes: + * When two-sided lighting is enabled we compute the color (or index) + * for both the front and back side of the primitive. Then, when the + * orientation of the facet is later learned, we can determine which + * color (or index) to use for rendering. + * + * KW: We now know orientation in advance and only shade for + * the side or sides which are actually required. + * + * Variables: + * n = normal vector + * V = vertex position + * P = light source position + * Pe = (0,0,0,1) + * + * Precomputed: + * IF P[3]==0 THEN + * // light at infinity + * IF local_viewer THEN + * _VP_inf_norm = unit vector from V to P // Precompute + * ELSE + * // eye at infinity + * _h_inf_norm = Normalize( VP + <0,0,1> ) // Precompute + * ENDIF + * ENDIF + * + * Functions: + * Normalize( v ) = normalized vector v + * Magnitude( v ) = length of vector v + */ + + + +/* + * Whenever the spotlight exponent for a light changes we must call + * this function to recompute the exponent lookup table. + */ +void +_mesa_invalidate_spot_exp_table( struct gl_light *l ) +{ + l->_SpotExpTable[0][0] = -1; +} + + +static void +validate_spot_exp_table( struct gl_light *l ) +{ + GLint i; + GLdouble exponent = l->SpotExponent; + GLdouble tmp = 0; + GLint clamp = 0; + + l->_SpotExpTable[0][0] = 0.0; + + for (i = EXP_TABLE_SIZE - 1; i > 0 ;i--) { + if (clamp == 0) { + tmp = pow(i / (GLdouble) (EXP_TABLE_SIZE - 1), exponent); + if (tmp < FLT_MIN * 100.0) { + tmp = 0.0; + clamp = 1; + } + } + l->_SpotExpTable[i][0] = (GLfloat) tmp; + } + for (i = 0; i < EXP_TABLE_SIZE - 1; i++) { + l->_SpotExpTable[i][1] = (l->_SpotExpTable[i+1][0] - + l->_SpotExpTable[i][0]); + } + l->_SpotExpTable[EXP_TABLE_SIZE-1][1] = 0.0; +} + + + +/* Calculate a new shine table. Doing this here saves a branch in + * lighting, and the cost of doing it early may be partially offset + * by keeping a MRU cache of shine tables for various shine values. + */ +void +_mesa_invalidate_shine_table( struct gl_context *ctx, GLuint side ) +{ + ASSERT(side < 2); + if (ctx->_ShineTable[side]) + ctx->_ShineTable[side]->refcount--; + ctx->_ShineTable[side] = NULL; +} + + +static void +validate_shine_table( struct gl_context *ctx, GLuint side, GLfloat shininess ) +{ + struct gl_shine_tab *list = ctx->_ShineTabList; + struct gl_shine_tab *s; + + ASSERT(side < 2); + + foreach(s, list) + if ( s->shininess == shininess ) + break; + + if (s == list) { + GLint j; + GLfloat *m; + + foreach(s, list) + if (s->refcount == 0) + break; + + m = s->tab; + m[0] = 0.0; + if (shininess == 0.0) { + for (j = 1 ; j <= SHINE_TABLE_SIZE ; j++) + m[j] = 1.0; + } + else { + for (j = 1 ; j < SHINE_TABLE_SIZE ; j++) { + GLdouble t, x = j / (GLfloat) (SHINE_TABLE_SIZE - 1); + if (x < 0.005) /* underflow check */ + x = 0.005; + t = pow(x, shininess); + if (t > 1e-20) + m[j] = (GLfloat) t; + else + m[j] = 0.0; + } + m[SHINE_TABLE_SIZE] = 1.0; + } + + s->shininess = shininess; + } + + if (ctx->_ShineTable[side]) + ctx->_ShineTable[side]->refcount--; + + ctx->_ShineTable[side] = s; + move_to_tail( list, s ); + s->refcount++; +} + + +void +_mesa_validate_all_lighting_tables( struct gl_context *ctx ) +{ + GLuint i; + GLfloat shininess; + + shininess = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_SHININESS][0]; + if (!ctx->_ShineTable[0] || ctx->_ShineTable[0]->shininess != shininess) + validate_shine_table( ctx, 0, shininess ); + + shininess = ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_SHININESS][0]; + if (!ctx->_ShineTable[1] || ctx->_ShineTable[1]->shininess != shininess) + validate_shine_table( ctx, 1, shininess ); + + for (i = 0; i < ctx->Const.MaxLights; i++) + if (ctx->Light.Light[i]._SpotExpTable[0][0] == -1) + validate_spot_exp_table( &ctx->Light.Light[i] ); +} + + +/** + * Examine current lighting parameters to determine if the optimized lighting + * function can be used. + * Also, precompute some lighting values such as the products of light + * source and material ambient, diffuse and specular coefficients. + */ +void +_mesa_update_lighting( struct gl_context *ctx ) +{ + struct gl_light *light; + ctx->Light._NeedEyeCoords = GL_FALSE; + ctx->Light._Flags = 0; + + if (!ctx->Light.Enabled) + return; + + foreach(light, &ctx->Light.EnabledList) { + ctx->Light._Flags |= light->_Flags; + } + + ctx->Light._NeedVertices = + ((ctx->Light._Flags & (LIGHT_POSITIONAL|LIGHT_SPOT)) || + ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR || + ctx->Light.Model.LocalViewer); + + ctx->Light._NeedEyeCoords = ((ctx->Light._Flags & LIGHT_POSITIONAL) || + ctx->Light.Model.LocalViewer); + + /* XXX: This test is overkill & needs to be fixed both for software and + * hardware t&l drivers. The above should be sufficient & should + * be tested to verify this. + */ + if (ctx->Light._NeedVertices) + ctx->Light._NeedEyeCoords = GL_TRUE; + + /* Precompute some shading values. Although we reference + * Light.Material here, we can get away without flushing + * FLUSH_UPDATE_CURRENT, as when any outstanding material changes + * are flushed, they will update the derived state at that time. + */ + if (ctx->Light.Model.TwoSide) + _mesa_update_material(ctx, + MAT_BIT_FRONT_EMISSION | + MAT_BIT_FRONT_AMBIENT | + MAT_BIT_FRONT_DIFFUSE | + MAT_BIT_FRONT_SPECULAR | + MAT_BIT_BACK_EMISSION | + MAT_BIT_BACK_AMBIENT | + MAT_BIT_BACK_DIFFUSE | + MAT_BIT_BACK_SPECULAR); + else + _mesa_update_material(ctx, + MAT_BIT_FRONT_EMISSION | + MAT_BIT_FRONT_AMBIENT | + MAT_BIT_FRONT_DIFFUSE | + MAT_BIT_FRONT_SPECULAR); +} + + +/** + * Update state derived from light position, spot direction. + * Called upon: + * _NEW_MODELVIEW + * _NEW_LIGHT + * _TNL_NEW_NEED_EYE_COORDS + * + * Update on (_NEW_MODELVIEW | _NEW_LIGHT) when lighting is enabled. + * Also update on lighting space changes. + */ +static void +compute_light_positions( struct gl_context *ctx ) +{ + struct gl_light *light; + static const GLfloat eye_z[3] = { 0, 0, 1 }; + + if (!ctx->Light.Enabled) + return; + + if (ctx->_NeedEyeCoords) { + COPY_3V( ctx->_EyeZDir, eye_z ); + } + else { + TRANSFORM_NORMAL( ctx->_EyeZDir, eye_z, ctx->ModelviewMatrixStack.Top->m ); + } + + /* Make sure all the light tables are updated before the computation */ + _mesa_validate_all_lighting_tables(ctx); + + foreach (light, &ctx->Light.EnabledList) { + + if (ctx->_NeedEyeCoords) { + /* _Position is in eye coordinate space */ + COPY_4FV( light->_Position, light->EyePosition ); + } + else { + /* _Position is in object coordinate space */ + TRANSFORM_POINT( light->_Position, ctx->ModelviewMatrixStack.Top->inv, + light->EyePosition ); + } + + if (!(light->_Flags & LIGHT_POSITIONAL)) { + /* VP (VP) = Normalize( Position ) */ + COPY_3V( light->_VP_inf_norm, light->_Position ); + NORMALIZE_3FV( light->_VP_inf_norm ); + + if (!ctx->Light.Model.LocalViewer) { + /* _h_inf_norm = Normalize( V_to_P + <0,0,1> ) */ + ADD_3V( light->_h_inf_norm, light->_VP_inf_norm, ctx->_EyeZDir); + NORMALIZE_3FV( light->_h_inf_norm ); + } + light->_VP_inf_spot_attenuation = 1.0; + } + else { + /* positional light w/ homogeneous coordinate, divide by W */ + GLfloat wInv = (GLfloat)1.0 / light->_Position[3]; + light->_Position[0] *= wInv; + light->_Position[1] *= wInv; + light->_Position[2] *= wInv; + } + + if (light->_Flags & LIGHT_SPOT) { + /* Note: we normalize the spot direction now */ + + if (ctx->_NeedEyeCoords) { + COPY_3V( light->_NormSpotDirection, light->SpotDirection ); + NORMALIZE_3FV( light->_NormSpotDirection ); + } + else { + GLfloat spotDir[3]; + COPY_3V(spotDir, light->SpotDirection); + NORMALIZE_3FV(spotDir); + TRANSFORM_NORMAL( light->_NormSpotDirection, + spotDir, + ctx->ModelviewMatrixStack.Top->m); + } + + NORMALIZE_3FV( light->_NormSpotDirection ); + + if (!(light->_Flags & LIGHT_POSITIONAL)) { + GLfloat PV_dot_dir = - DOT3(light->_VP_inf_norm, + light->_NormSpotDirection); + + if (PV_dot_dir > light->_CosCutoff) { + double x = PV_dot_dir * (EXP_TABLE_SIZE-1); + int k = (int) x; + light->_VP_inf_spot_attenuation = + (GLfloat) (light->_SpotExpTable[k][0] + + (x-k)*light->_SpotExpTable[k][1]); + } + else { + light->_VP_inf_spot_attenuation = 0; + } + } + } + } +} + + + +static void +update_modelview_scale( struct gl_context *ctx ) +{ + ctx->_ModelViewInvScale = 1.0F; + if (!_math_matrix_is_length_preserving(ctx->ModelviewMatrixStack.Top)) { + const GLfloat *m = ctx->ModelviewMatrixStack.Top->inv; + GLfloat f = m[2] * m[2] + m[6] * m[6] + m[10] * m[10]; + if (f < 1e-12) f = 1.0; + if (ctx->_NeedEyeCoords) + ctx->_ModelViewInvScale = (GLfloat) INV_SQRTF(f); + else + ctx->_ModelViewInvScale = (GLfloat) SQRTF(f); + } +} + + +/** + * Bring up to date any state that relies on _NeedEyeCoords. + */ +void +_mesa_update_tnl_spaces( struct gl_context *ctx, GLuint new_state ) +{ + const GLuint oldneedeyecoords = ctx->_NeedEyeCoords; + + (void) new_state; + ctx->_NeedEyeCoords = GL_FALSE; + + if (ctx->_ForceEyeCoords || + (ctx->Texture._GenFlags & TEXGEN_NEED_EYE_COORD) || + ctx->Point._Attenuated || + ctx->Light._NeedEyeCoords) + ctx->_NeedEyeCoords = GL_TRUE; + + if (ctx->Light.Enabled && + !_math_matrix_is_length_preserving(ctx->ModelviewMatrixStack.Top)) + ctx->_NeedEyeCoords = GL_TRUE; + + /* Check if the truth-value interpretations of the bitfields have + * changed: + */ + if (oldneedeyecoords != ctx->_NeedEyeCoords) { + /* Recalculate all state that depends on _NeedEyeCoords. + */ + update_modelview_scale(ctx); + compute_light_positions( ctx ); + + if (ctx->Driver.LightingSpaceChange) + ctx->Driver.LightingSpaceChange( ctx ); + } + else { + GLuint new_state2 = ctx->NewState; + + /* Recalculate that same state only if it has been invalidated + * by other statechanges. + */ + if (new_state2 & _NEW_MODELVIEW) + update_modelview_scale(ctx); + + if (new_state2 & (_NEW_LIGHT|_NEW_MODELVIEW)) + compute_light_positions( ctx ); + } +} + + +/** + * Drivers may need this if the hardware tnl unit doesn't support the + * light-in-modelspace optimization. It's also useful for debugging. + */ +void +_mesa_allow_light_in_model( struct gl_context *ctx, GLboolean flag ) +{ + ctx->_ForceEyeCoords = !flag; + ctx->NewState |= _NEW_POINT; /* one of the bits from + * _MESA_NEW_NEED_EYE_COORDS. + */ +} + + + +/**********************************************************************/ +/***** Initialization *****/ +/**********************************************************************/ + +/** + * Initialize the n-th light data structure. + * + * \param l pointer to the gl_light structure to be initialized. + * \param n number of the light. + * \note The defaults for light 0 are different than the other lights. + */ +static void +init_light( struct gl_light *l, GLuint n ) +{ + make_empty_list( l ); + + ASSIGN_4V( l->Ambient, 0.0, 0.0, 0.0, 1.0 ); + if (n==0) { + ASSIGN_4V( l->Diffuse, 1.0, 1.0, 1.0, 1.0 ); + ASSIGN_4V( l->Specular, 1.0, 1.0, 1.0, 1.0 ); + } + else { + ASSIGN_4V( l->Diffuse, 0.0, 0.0, 0.0, 1.0 ); + ASSIGN_4V( l->Specular, 0.0, 0.0, 0.0, 1.0 ); + } + ASSIGN_4V( l->EyePosition, 0.0, 0.0, 1.0, 0.0 ); + ASSIGN_3V( l->SpotDirection, 0.0, 0.0, -1.0 ); + l->SpotExponent = 0.0; + _mesa_invalidate_spot_exp_table( l ); + l->SpotCutoff = 180.0; + l->_CosCutoffNeg = -1.0f; + l->_CosCutoff = 0.0; /* KW: -ve values not admitted */ + l->ConstantAttenuation = 1.0; + l->LinearAttenuation = 0.0; + l->QuadraticAttenuation = 0.0; + l->Enabled = GL_FALSE; +} + + +/** + * Initialize the light model data structure. + * + * \param lm pointer to the gl_lightmodel structure to be initialized. + */ +static void +init_lightmodel( struct gl_lightmodel *lm ) +{ + ASSIGN_4V( lm->Ambient, 0.2F, 0.2F, 0.2F, 1.0F ); + lm->LocalViewer = GL_FALSE; + lm->TwoSide = GL_FALSE; + lm->ColorControl = GL_SINGLE_COLOR; +} + + +/** + * Initialize the material data structure. + * + * \param m pointer to the gl_material structure to be initialized. + */ +static void +init_material( struct gl_material *m ) +{ + ASSIGN_4V( m->Attrib[MAT_ATTRIB_FRONT_AMBIENT], 0.2F, 0.2F, 0.2F, 1.0F ); + ASSIGN_4V( m->Attrib[MAT_ATTRIB_FRONT_DIFFUSE], 0.8F, 0.8F, 0.8F, 1.0F ); + ASSIGN_4V( m->Attrib[MAT_ATTRIB_FRONT_SPECULAR], 0.0F, 0.0F, 0.0F, 1.0F ); + ASSIGN_4V( m->Attrib[MAT_ATTRIB_FRONT_EMISSION], 0.0F, 0.0F, 0.0F, 1.0F ); + ASSIGN_4V( m->Attrib[MAT_ATTRIB_FRONT_SHININESS], 0.0F, 0.0F, 0.0F, 0.0F ); + ASSIGN_4V( m->Attrib[MAT_ATTRIB_FRONT_INDEXES], 0.0F, 1.0F, 1.0F, 0.0F ); + + ASSIGN_4V( m->Attrib[MAT_ATTRIB_BACK_AMBIENT], 0.2F, 0.2F, 0.2F, 1.0F ); + ASSIGN_4V( m->Attrib[MAT_ATTRIB_BACK_DIFFUSE], 0.8F, 0.8F, 0.8F, 1.0F ); + ASSIGN_4V( m->Attrib[MAT_ATTRIB_BACK_SPECULAR], 0.0F, 0.0F, 0.0F, 1.0F ); + ASSIGN_4V( m->Attrib[MAT_ATTRIB_BACK_EMISSION], 0.0F, 0.0F, 0.0F, 1.0F ); + ASSIGN_4V( m->Attrib[MAT_ATTRIB_BACK_SHININESS], 0.0F, 0.0F, 0.0F, 0.0F ); + ASSIGN_4V( m->Attrib[MAT_ATTRIB_BACK_INDEXES], 0.0F, 1.0F, 1.0F, 0.0F ); +} + + +/** + * Initialize all lighting state for the given context. + */ +void +_mesa_init_lighting( struct gl_context *ctx ) +{ + GLuint i; + + /* Lighting group */ + for (i = 0; i < MAX_LIGHTS; i++) { + init_light( &ctx->Light.Light[i], i ); + } + make_empty_list( &ctx->Light.EnabledList ); + + init_lightmodel( &ctx->Light.Model ); + init_material( &ctx->Light.Material ); + ctx->Light.ShadeModel = GL_SMOOTH; + ctx->Light.ProvokingVertex = GL_LAST_VERTEX_CONVENTION_EXT; + ctx->Light.Enabled = GL_FALSE; + ctx->Light.ColorMaterialFace = GL_FRONT_AND_BACK; + ctx->Light.ColorMaterialMode = GL_AMBIENT_AND_DIFFUSE; + ctx->Light.ColorMaterialBitmask = _mesa_material_bitmask( ctx, + GL_FRONT_AND_BACK, + GL_AMBIENT_AND_DIFFUSE, ~0, + NULL ); + + ctx->Light.ColorMaterialEnabled = GL_FALSE; + ctx->Light.ClampVertexColor = GL_TRUE; + + /* Lighting miscellaneous */ + ctx->_ShineTabList = MALLOC_STRUCT( gl_shine_tab ); + make_empty_list( ctx->_ShineTabList ); + /* Allocate 10 (arbitrary) shininess lookup tables */ + for (i = 0 ; i < 10 ; i++) { + struct gl_shine_tab *s = MALLOC_STRUCT( gl_shine_tab ); + s->shininess = -1; + s->refcount = 0; + insert_at_tail( ctx->_ShineTabList, s ); + } + + /* Miscellaneous */ + ctx->Light._NeedEyeCoords = GL_FALSE; + ctx->_NeedEyeCoords = GL_FALSE; + ctx->_ForceEyeCoords = GL_FALSE; + ctx->_ModelViewInvScale = 1.0; +} + + +/** + * Deallocate malloc'd lighting state attached to given context. + */ +void +_mesa_free_lighting_data( struct gl_context *ctx ) +{ + struct gl_shine_tab *s, *tmps; + + /* Free lighting shininess exponentiation table */ + foreach_s( s, tmps, ctx->_ShineTabList ) { + free( s ); + } + free( ctx->_ShineTabList ); +} diff --git a/mesalib/src/mesa/main/macros.h b/mesalib/src/mesa/main/macros.h index 2a849e36a..dbe5b867c 100644 --- a/mesalib/src/mesa/main/macros.h +++ b/mesalib/src/mesa/main/macros.h @@ -54,6 +54,10 @@ extern GLfloat _mesa_ubyte_to_float_color_tab[256]; #define FLOAT_TO_BYTE(X) ( (((GLint) (255.0F * (X))) - 1) / 2 ) +/** Convert GLbyte to GLfloat while preserving zero */ +#define BYTE_TO_FLOATZ(B) ((B) == 0 ? 0.0F : BYTE_TO_FLOAT(B)) + + /** Convert GLbyte in [-128,127] to GLfloat in [-1.0,1.0], texture/fb data */ #define BYTE_TO_FLOAT_TEX(B) ((B) == -128 ? -1.0F : (B) * (1.0F/127.0F)) @@ -73,6 +77,9 @@ extern GLfloat _mesa_ubyte_to_float_color_tab[256]; /** Convert GLfloat in [-1.0,1.0] to GLshort in [-32768,32767] */ #define FLOAT_TO_SHORT(X) ( (((GLint) (65535.0F * (X))) - 1) / 2 ) +/** Convert GLshort to GLfloat while preserving zero */ +#define SHORT_TO_FLOATZ(S) ((S) == 0 ? 0.0F : SHORT_TO_FLOAT(S)) + /** Convert GLshort in [-32768,32767] to GLfloat in [-1.0,1.0], texture/fb data */ #define SHORT_TO_FLOAT_TEX(S) ((S) == -32768 ? -1.0F : (S) * (1.0F/32767.0F)) @@ -588,19 +595,6 @@ do { \ */ #define LINTERP(T, OUT, IN) ((OUT) + (T) * ((IN) - (OUT))) -/* Can do better with integer math - */ -#define INTERP_UB( t, dstub, outub, inub ) \ -do { \ - GLfloat inf = UBYTE_TO_FLOAT( inub ); \ - GLfloat outf = UBYTE_TO_FLOAT( outub ); \ - GLfloat dstf = LINTERP( t, outf, inf ); \ - UNCLAMPED_FLOAT_TO_UBYTE( dstub, dstf ); \ -} while (0) - -#define INTERP_UI( t, dstui, outui, inui ) \ - dstui = (GLuint) (GLint) LINTERP( (t), (GLfloat) (outui), (GLfloat) (inui) ) - #define INTERP_F( t, dstf, outf, inf ) \ dstf = LINTERP( t, outf, inf ) @@ -619,16 +613,6 @@ do { \ dst[2] = LINTERP( (t), (out)[2], (in)[2] ); \ } while (0) -#define INTERP_SZ( t, vec, to, out, in, sz ) \ -do { \ - switch (sz) { \ - case 4: vec[to][3] = LINTERP( (t), (vec)[out][3], (vec)[in][3] ); \ - case 3: vec[to][2] = LINTERP( (t), (vec)[out][2], (vec)[in][2] ); \ - case 2: vec[to][1] = LINTERP( (t), (vec)[out][1], (vec)[in][1] ); \ - case 1: vec[to][0] = LINTERP( (t), (vec)[out][0], (vec)[in][0] ); \ - } \ -} while(0) - /*@}*/ @@ -656,9 +640,6 @@ do { \ #define DOT4( a, b ) ( (a)[0]*(b)[0] + (a)[1]*(b)[1] + \ (a)[2]*(b)[2] + (a)[3]*(b)[3] ) -/** Dot product of two 4-element vectors */ -#define DOT4V(v,a,b,c,d) (v[0]*(a) + v[1]*(b) + v[2]*(c) + v[3]*(d)) - /** Cross product of two 3-element vectors */ #define CROSS3(n, u, v) \ @@ -688,6 +669,10 @@ do { \ #define LEN_SQUARED_2FV( V ) ((V)[0]*(V)[0]+(V)[1]*(V)[1]) +/** Compute ceiling of integer quotient of A divided by B. */ +#define CEILING( A, B ) ( (A) % (B) == 0 ? (A)/(B) : (A)/(B)+1 ) + + /** casts to silence warnings with some compilers */ #define ENUM_TO_INT(E) ((GLint)(E)) #define ENUM_TO_FLOAT(E) ((GLfloat)(GLint)(E)) diff --git a/mesalib/src/mesa/main/mtypes.h b/mesalib/src/mesa/main/mtypes.h index deab97d3e..285ec0783 100644 --- a/mesalib/src/mesa/main/mtypes.h +++ b/mesalib/src/mesa/main/mtypes.h @@ -48,18 +48,6 @@ extern "C" { #endif -/** - * Stencil buffer data type. - */ -#if STENCIL_BITS==8 - typedef GLubyte GLstencil; -#elif STENCIL_BITS==16 - typedef GLushort GLstencil; -#else -# error "illegal number of stencil bits" -#endif - - /** * \name 64-bit extension of GLbitfield. */ @@ -2158,6 +2146,16 @@ struct gl_shader unsigned Version; /**< GLSL version used for linking */ + unsigned num_samplers; /**< Number of samplers used by this shader. + * This field is only set post-linking. + */ + /** + * Number of uniform components used by this shader. + * + * This field is only set post-linking. + */ + unsigned num_uniform_components; + struct exec_list *ir; struct glsl_symbol_table *symbols; diff --git a/mesalib/src/mesa/main/pack.c b/mesalib/src/mesa/main/pack.c index 539a06c9a..6f48a2e7c 100644 --- a/mesalib/src/mesa/main/pack.c +++ b/mesalib/src/mesa/main/pack.c @@ -34,6 +34,7 @@ #include "enums.h" #include "image.h" #include "imports.h" +#include "macros.h" #include "mtypes.h" #include "pack.h" #include "pixeltransfer.h" @@ -42,26 +43,6 @@ #include "../../gallium/auxiliary/util/u_format_r11g11b10f.h" -/** - * NOTE: - * Normally, BYTE_TO_FLOAT(0) returns 0.00392 That causes problems when - * we later convert the float to a packed integer value (such as for - * GL_RGB5_A1) because we'll wind up with a non-zero value. - * - * We redefine the macros here so zero is handled correctly. - */ -#undef BYTE_TO_FLOAT -#define BYTE_TO_FLOAT(B) ((B) == 0 ? 0.0F : ((2.0F * (B) + 1.0F) * (1.0F/255.0F))) - -#undef SHORT_TO_FLOAT -#define SHORT_TO_FLOAT(S) ((S) == 0 ? 0.0F : ((2.0F * (S) + 1.0F) * (1.0F/65535.0F))) - - - -/** Compute ceiling of integer quotient of A divided by B. */ -#define CEILING( A, B ) ( (A) % (B) == 0 ? (A)/(B) : (A)/(B)+1 ) - - /** * Flip the 8 bits in each byte of the given array. * @@ -2507,10 +2488,10 @@ extract_float_rgba(GLuint n, GLfloat rgba[][4], PROCESS(aSrc, ACOMP, 1.0F, 255, GLubyte, UBYTE_TO_FLOAT); break; case GL_BYTE: - PROCESS(rSrc, RCOMP, 0.0F, 0, GLbyte, BYTE_TO_FLOAT); - PROCESS(gSrc, GCOMP, 0.0F, 0, GLbyte, BYTE_TO_FLOAT); - PROCESS(bSrc, BCOMP, 0.0F, 0, GLbyte, BYTE_TO_FLOAT); - PROCESS(aSrc, ACOMP, 1.0F, 127, GLbyte, BYTE_TO_FLOAT); + PROCESS(rSrc, RCOMP, 0.0F, 0, GLbyte, BYTE_TO_FLOATZ); + PROCESS(gSrc, GCOMP, 0.0F, 0, GLbyte, BYTE_TO_FLOATZ); + PROCESS(bSrc, BCOMP, 0.0F, 0, GLbyte, BYTE_TO_FLOATZ); + PROCESS(aSrc, ACOMP, 1.0F, 127, GLbyte, BYTE_TO_FLOATZ); break; case GL_UNSIGNED_SHORT: PROCESS(rSrc, RCOMP, 0.0F, 0, GLushort, USHORT_TO_FLOAT); @@ -2519,10 +2500,10 @@ extract_float_rgba(GLuint n, GLfloat rgba[][4], PROCESS(aSrc, ACOMP, 1.0F, 0xffff, GLushort, USHORT_TO_FLOAT); break; case GL_SHORT: - PROCESS(rSrc, RCOMP, 0.0F, 0, GLshort, SHORT_TO_FLOAT); - PROCESS(gSrc, GCOMP, 0.0F, 0, GLshort, SHORT_TO_FLOAT); - PROCESS(bSrc, BCOMP, 0.0F, 0, GLshort, SHORT_TO_FLOAT); - PROCESS(aSrc, ACOMP, 1.0F, 32767, GLshort, SHORT_TO_FLOAT); + PROCESS(rSrc, RCOMP, 0.0F, 0, GLshort, SHORT_TO_FLOATZ); + PROCESS(gSrc, GCOMP, 0.0F, 0, GLshort, SHORT_TO_FLOATZ); + PROCESS(bSrc, BCOMP, 0.0F, 0, GLshort, SHORT_TO_FLOATZ); + PROCESS(aSrc, ACOMP, 1.0F, 32767, GLshort, SHORT_TO_FLOATZ); break; case GL_UNSIGNED_INT: PROCESS(rSrc, RCOMP, 0.0F, 0, GLuint, UINT_TO_FLOAT); @@ -4586,10 +4567,10 @@ _mesa_unpack_stencil_span( struct gl_context *ctx, GLuint n, void _mesa_pack_stencil_span( struct gl_context *ctx, GLuint n, - GLenum dstType, GLvoid *dest, const GLstencil *source, + GLenum dstType, GLvoid *dest, const GLubyte *source, const struct gl_pixelstore_attrib *dstPacking ) { - GLstencil *stencil = (GLstencil *) malloc(n * sizeof(GLstencil)); + GLubyte *stencil = (GLubyte *) malloc(n * sizeof(GLubyte)); if (!stencil) { _mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil packing"); @@ -4599,23 +4580,14 @@ _mesa_pack_stencil_span( struct gl_context *ctx, GLuint n, if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset || ctx->Pixel.MapStencilFlag) { /* make a copy of input */ - memcpy(stencil, source, n * sizeof(GLstencil)); + memcpy(stencil, source, n * sizeof(GLubyte)); _mesa_apply_stencil_transfer_ops(ctx, n, stencil); source = stencil; } switch (dstType) { case GL_UNSIGNED_BYTE: - if (sizeof(GLstencil) == 1) { - memcpy( dest, source, n ); - } - else { - GLubyte *dst = (GLubyte *) dest; - GLuint i; - for (i=0;iPixel.IndexShift || ctx->Pixel.IndexOffset || ctx->Pixel.MapStencilFlag) { - memcpy(stencilCopy, stencilVals, n * sizeof(GLstencil)); + memcpy(stencilCopy, stencilVals, n * sizeof(GLubyte)); _mesa_apply_stencil_transfer_ops(ctx, n, stencilCopy); stencilVals = stencilCopy; } diff --git a/mesalib/src/mesa/main/pack.h b/mesalib/src/mesa/main/pack.h index 7a0089c2f..b1853cd59 100644 --- a/mesalib/src/mesa/main/pack.h +++ b/mesalib/src/mesa/main/pack.h @@ -113,7 +113,7 @@ _mesa_unpack_stencil_span(struct gl_context *ctx, GLuint n, extern void _mesa_pack_stencil_span(struct gl_context *ctx, GLuint n, - GLenum dstType, GLvoid *dest, const GLstencil *source, + GLenum dstType, GLvoid *dest, const GLubyte *source, const struct gl_pixelstore_attrib *dstPacking); @@ -133,7 +133,7 @@ extern void _mesa_pack_depth_stencil_span(struct gl_context *ctx,GLuint n, GLenum dstType, GLuint *dest, const GLfloat *depthVals, - const GLstencil *stencilVals, + const GLubyte *stencilVals, const struct gl_pixelstore_attrib *dstPacking); diff --git a/mesalib/src/mesa/main/pixeltransfer.c b/mesalib/src/mesa/main/pixeltransfer.c index 5e881436a..5c167e0a9 100644 --- a/mesalib/src/mesa/main/pixeltransfer.c +++ b/mesalib/src/mesa/main/pixeltransfer.c @@ -273,7 +273,7 @@ _mesa_apply_ci_transfer_ops(const struct gl_context *ctx, */ void _mesa_apply_stencil_transfer_ops(const struct gl_context *ctx, GLuint n, - GLstencil stencil[]) + GLubyte stencil[]) { if (ctx->Pixel.IndexShift != 0 || ctx->Pixel.IndexOffset != 0) { const GLint offset = ctx->Pixel.IndexOffset; @@ -300,7 +300,7 @@ _mesa_apply_stencil_transfer_ops(const struct gl_context *ctx, GLuint n, GLuint mask = ctx->PixelMaps.StoS.Size - 1; GLuint i; for (i = 0; i < n; i++) { - stencil[i] = (GLstencil)ctx->PixelMaps.StoS.Map[ stencil[i] & mask ]; + stencil[i] = (GLubyte) ctx->PixelMaps.StoS.Map[ stencil[i] & mask ]; } } } diff --git a/mesalib/src/mesa/main/pixeltransfer.h b/mesalib/src/mesa/main/pixeltransfer.h index 8af2e9ee2..a8c14757f 100644 --- a/mesalib/src/mesa/main/pixeltransfer.h +++ b/mesalib/src/mesa/main/pixeltransfer.h @@ -75,7 +75,7 @@ _mesa_apply_ci_transfer_ops(const struct gl_context *ctx, extern void _mesa_apply_stencil_transfer_ops(const struct gl_context *ctx, GLuint n, - GLstencil stencil[]); + GLubyte stencil[]); #endif diff --git a/mesalib/src/mesa/main/readpix.c b/mesalib/src/mesa/main/readpix.c index 84c5b2228..86b87534d 100644 --- a/mesalib/src/mesa/main/readpix.c +++ b/mesalib/src/mesa/main/readpix.c @@ -30,12 +30,508 @@ #include "readpix.h" #include "framebuffer.h" #include "formats.h" +#include "format_unpack.h" #include "image.h" #include "mtypes.h" +#include "pack.h" #include "pbo.h" #include "state.h" +/** + * Tries to implement glReadPixels() of GL_DEPTH_COMPONENT using memcpy of the + * mapping. + */ +static GLboolean +fast_read_depth_pixels( struct gl_context *ctx, + GLint x, GLint y, + GLsizei width, GLsizei height, + GLenum type, GLvoid *pixels, + const struct gl_pixelstore_attrib *packing ) +{ + struct gl_framebuffer *fb = ctx->ReadBuffer; + struct gl_renderbuffer *rb = fb->Attachment[BUFFER_DEPTH].Renderbuffer; + GLubyte *map, *dst; + int stride, dstStride, j; + + if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) + return GL_FALSE; + + if (packing->SwapBytes) + return GL_FALSE; + + if (_mesa_get_format_datatype(rb->Format) != GL_UNSIGNED_INT) + return GL_FALSE; + + if (!((type == GL_UNSIGNED_SHORT && rb->Format == MESA_FORMAT_Z16) || + type == GL_UNSIGNED_INT)) + return GL_FALSE; + + ctx->Driver.MapRenderbuffer(ctx, rb, x, y, width, height, GL_MAP_READ_BIT, + &map, &stride); + + dstStride = _mesa_image_row_stride(packing, width, GL_DEPTH_COMPONENT, type); + dst = (GLubyte *) _mesa_image_address2d(packing, pixels, width, height, + GL_DEPTH_COMPONENT, type, 0, 0); + + for (j = 0; j < height; j++) { + if (type == GL_UNSIGNED_INT) { + _mesa_unpack_uint_z_row(rb->Format, width, map, (GLuint *)dst); + } else { + ASSERT(type == GL_UNSIGNED_SHORT && rb->Format == MESA_FORMAT_Z16); + memcpy(dst, map, width * 2); + } + + map += stride; + dst += dstStride; + } + ctx->Driver.UnmapRenderbuffer(ctx, rb); + + return GL_TRUE; +} + +/** + * Read pixels for format=GL_DEPTH_COMPONENT. + */ +static void +read_depth_pixels( struct gl_context *ctx, + GLint x, GLint y, + GLsizei width, GLsizei height, + GLenum type, GLvoid *pixels, + const struct gl_pixelstore_attrib *packing ) +{ + struct gl_framebuffer *fb = ctx->ReadBuffer; + struct gl_renderbuffer *rb = fb->Attachment[BUFFER_DEPTH].Renderbuffer; + GLint j; + GLubyte *dst, *map; + int dstStride, stride; + + if (!rb) + return; + + /* clipping should have been done already */ + ASSERT(x >= 0); + ASSERT(y >= 0); + ASSERT(x + width <= (GLint) rb->Width); + ASSERT(y + height <= (GLint) rb->Height); + /* width should never be > MAX_WIDTH since we did clipping earlier */ + ASSERT(width <= MAX_WIDTH); + + if (fast_read_depth_pixels(ctx, x, y, width, height, type, pixels, packing)) + return; + + dstStride = _mesa_image_row_stride(packing, width, GL_DEPTH_COMPONENT, type); + dst = (GLubyte *) _mesa_image_address2d(packing, pixels, width, height, + GL_DEPTH_COMPONENT, type, 0, 0); + + ctx->Driver.MapRenderbuffer(ctx, rb, x, y, width, height, GL_MAP_READ_BIT, + &map, &stride); + + /* General case (slower) */ + for (j = 0; j < height; j++, y++) { + GLfloat depthValues[MAX_WIDTH]; + _mesa_unpack_float_z_row(rb->Format, width, map, depthValues); + _mesa_pack_depth_span(ctx, width, dst, type, depthValues, packing); + + dst += dstStride; + map += stride; + } + + ctx->Driver.UnmapRenderbuffer(ctx, rb); +} + + +/** + * Read pixels for format=GL_STENCIL_INDEX. + */ +static void +read_stencil_pixels( struct gl_context *ctx, + GLint x, GLint y, + GLsizei width, GLsizei height, + GLenum type, GLvoid *pixels, + const struct gl_pixelstore_attrib *packing ) +{ + struct gl_framebuffer *fb = ctx->ReadBuffer; + struct gl_renderbuffer *rb = fb->Attachment[BUFFER_STENCIL].Renderbuffer; + GLint j; + GLubyte *map; + GLint stride; + + if (!rb) + return; + + /* width should never be > MAX_WIDTH since we did clipping earlier */ + ASSERT(width <= MAX_WIDTH); + + ctx->Driver.MapRenderbuffer(ctx, rb, x, y, width, height, GL_MAP_READ_BIT, + &map, &stride); + + /* process image row by row */ + for (j = 0; j < height; j++) { + GLvoid *dest; + GLubyte stencil[MAX_WIDTH]; + + _mesa_unpack_ubyte_stencil_row(rb->Format, width, map, stencil); + dest = _mesa_image_address2d(packing, pixels, width, height, + GL_STENCIL_INDEX, type, j, 0); + + _mesa_pack_stencil_span(ctx, width, type, dest, stencil, packing); + + map += stride; + } + + ctx->Driver.UnmapRenderbuffer(ctx, rb); +} + +static GLboolean +fast_read_rgba_pixels_memcpy( struct gl_context *ctx, + GLint x, GLint y, + GLsizei width, GLsizei height, + GLenum format, GLenum type, + GLvoid *pixels, + const struct gl_pixelstore_attrib *packing, + GLbitfield transferOps ) +{ + struct gl_renderbuffer *rb = ctx->ReadBuffer->_ColorReadBuffer; + GLubyte *dst, *map; + int dstStride, stride, j, texelBytes; + + if (!_mesa_format_matches_format_and_type(rb->Format, format, type)) + return GL_FALSE; + + /* check for things we can't handle here */ + if (packing->SwapBytes || + packing->LsbFirst) { + return GL_FALSE; + } + + dstStride = _mesa_image_row_stride(packing, width, format, type); + dst = (GLubyte *) _mesa_image_address2d(packing, pixels, width, height, + format, type, 0, 0); + + ctx->Driver.MapRenderbuffer(ctx, rb, x, y, width, height, GL_MAP_READ_BIT, + &map, &stride); + + texelBytes = _mesa_get_format_bytes(rb->Format); + for (j = 0; j < height; j++) { + memcpy(dst, map, width * texelBytes); + dst += dstStride; + map += stride; + } + + ctx->Driver.UnmapRenderbuffer(ctx, rb); + + return GL_TRUE; +} + +static GLboolean +slow_read_rgba_pixels( struct gl_context *ctx, + GLint x, GLint y, + GLsizei width, GLsizei height, + GLenum format, GLenum type, + GLvoid *pixels, + const struct gl_pixelstore_attrib *packing, + GLbitfield transferOps ) +{ + struct gl_renderbuffer *rb = ctx->ReadBuffer->_ColorReadBuffer; + const gl_format rbFormat = _mesa_get_srgb_format_linear(rb->Format); + union { + float f[MAX_WIDTH][4]; + unsigned int i[MAX_WIDTH][4]; + } rgba; + GLubyte *dst, *map; + int dstStride, stride, j; + + dstStride = _mesa_image_row_stride(packing, width, format, type); + dst = (GLubyte *) _mesa_image_address2d(packing, pixels, width, height, + format, type, 0, 0); + + ctx->Driver.MapRenderbuffer(ctx, rb, x, y, width, height, GL_MAP_READ_BIT, + &map, &stride); + + for (j = 0; j < height; j++) { + if (_mesa_is_integer_format(format)) { + _mesa_unpack_int_rgba_row(rbFormat, width, map, rgba.i); + _mesa_pack_rgba_span_int(ctx, width, rgba.i, format, type, dst); + } else { + _mesa_unpack_rgba_row(rbFormat, width, map, rgba.f); + _mesa_pack_rgba_span_float(ctx, width, rgba.f, format, type, dst, + packing, transferOps); + } + dst += dstStride; + map += stride; + } + + ctx->Driver.UnmapRenderbuffer(ctx, rb); + + return GL_TRUE; +} + +/* + * Read R, G, B, A, RGB, L, or LA pixels. + */ +static void +read_rgba_pixels( struct gl_context *ctx, + GLint x, GLint y, + GLsizei width, GLsizei height, + GLenum format, GLenum type, GLvoid *pixels, + const struct gl_pixelstore_attrib *packing ) +{ + GLbitfield transferOps = ctx->_ImageTransferState; + struct gl_framebuffer *fb = ctx->ReadBuffer; + struct gl_renderbuffer *rb = fb->_ColorReadBuffer; + + if (!rb) + return; + + if ((ctx->Color._ClampReadColor == GL_TRUE || type != GL_FLOAT) && + !_mesa_is_integer_format(format)) { + transferOps |= IMAGE_CLAMP_BIT; + } + + if (!transferOps) { + /* Try the optimized paths first. */ + if (fast_read_rgba_pixels_memcpy(ctx, x, y, width, height, + format, type, pixels, packing, + transferOps)) { + return; + } + } + + slow_read_rgba_pixels(ctx, x, y, width, height, + format, type, pixels, packing, transferOps); +} + +/** + * For a packed depth/stencil buffer being read as depth/stencil, just memcpy the + * data (possibly swapping 8/24 vs 24/8 as we go). + */ +static GLboolean +fast_read_depth_stencil_pixels(struct gl_context *ctx, + GLint x, GLint y, + GLsizei width, GLsizei height, + GLubyte *dst, int dstStride) +{ + struct gl_framebuffer *fb = ctx->ReadBuffer; + struct gl_renderbuffer *rb = fb->Attachment[BUFFER_DEPTH].Renderbuffer; + struct gl_renderbuffer *stencilRb = fb->Attachment[BUFFER_STENCIL].Renderbuffer; + GLubyte *map; + int stride, i; + + if (rb != stencilRb) + return GL_FALSE; + + if (rb->Format != MESA_FORMAT_Z24_S8 && + rb->Format != MESA_FORMAT_S8_Z24) + return GL_FALSE; + + ctx->Driver.MapRenderbuffer(ctx, rb, x, y, width, height, GL_MAP_READ_BIT, + &map, &stride); + + for (i = 0; i < height; i++) { + _mesa_unpack_uint_24_8_depth_stencil_row(rb->Format, width, + map, (GLuint *)dst); + map += stride; + dst += dstStride; + } + + ctx->Driver.UnmapRenderbuffer(ctx, rb); + + return GL_TRUE; +} + + +/** + * For non-float-depth and stencil buffers being read as 24/8 depth/stencil, + * copy the integer data directly instead of converting depth to float and + * re-packing. + */ +static GLboolean +fast_read_depth_stencil_pixels_separate(struct gl_context *ctx, + GLint x, GLint y, + GLsizei width, GLsizei height, + uint32_t *dst, int dstStride) +{ + struct gl_framebuffer *fb = ctx->ReadBuffer; + struct gl_renderbuffer *depthRb = fb->Attachment[BUFFER_DEPTH].Renderbuffer; + struct gl_renderbuffer *stencilRb = fb->Attachment[BUFFER_STENCIL].Renderbuffer; + GLubyte *depthMap, *stencilMap; + int depthStride, stencilStride, i, j; + + if (_mesa_get_format_datatype(depthRb->Format) != GL_UNSIGNED_INT) + return GL_FALSE; + + ctx->Driver.MapRenderbuffer(ctx, depthRb, x, y, width, height, + GL_MAP_READ_BIT, &depthMap, &depthStride); + ctx->Driver.MapRenderbuffer(ctx, stencilRb, x, y, width, height, + GL_MAP_READ_BIT, &stencilMap, &stencilStride); + + for (j = 0; j < height; j++) { + GLubyte stencilVals[MAX_WIDTH]; + + _mesa_unpack_uint_z_row(depthRb->Format, width, depthMap, dst); + _mesa_unpack_ubyte_stencil_row(stencilRb->Format, width, + stencilMap, stencilVals); + + for (i = 0; i < width; i++) { + dst[i] = (dst[i] & 0xffffff00) | stencilVals[i]; + } + + depthMap += depthStride; + stencilMap += stencilStride; + dst += dstStride / 4; + } + + ctx->Driver.UnmapRenderbuffer(ctx, depthRb); + ctx->Driver.UnmapRenderbuffer(ctx, stencilRb); + + return GL_TRUE; +} + +static void +slow_read_depth_stencil_pixels_separate(struct gl_context *ctx, + GLint x, GLint y, + GLsizei width, GLsizei height, + GLenum type, + const struct gl_pixelstore_attrib *packing, + GLubyte *dst, int dstStride) +{ + struct gl_framebuffer *fb = ctx->ReadBuffer; + struct gl_renderbuffer *depthRb = fb->Attachment[BUFFER_DEPTH].Renderbuffer; + struct gl_renderbuffer *stencilRb = fb->Attachment[BUFFER_STENCIL].Renderbuffer; + GLubyte *depthMap, *stencilMap; + int depthStride, stencilStride, j; + + /* The depth and stencil buffers might be separate, or a single buffer. + * If one buffer, only map it once. + */ + ctx->Driver.MapRenderbuffer(ctx, depthRb, x, y, width, height, + GL_MAP_READ_BIT, &depthMap, &depthStride); + if (stencilRb != depthRb) { + ctx->Driver.MapRenderbuffer(ctx, stencilRb, x, y, width, height, + GL_MAP_READ_BIT, &stencilMap, + &stencilStride); + } + else { + stencilMap = depthMap; + stencilStride = depthStride; + } + + for (j = 0; j < height; j++) { + GLubyte stencilVals[MAX_WIDTH]; + GLfloat depthVals[MAX_WIDTH]; + + _mesa_unpack_float_z_row(depthRb->Format, width, depthMap, depthVals); + _mesa_unpack_ubyte_stencil_row(stencilRb->Format, width, + stencilMap, stencilVals); + + _mesa_pack_depth_stencil_span(ctx, width, type, (GLuint *)dst, + depthVals, stencilVals, packing); + + depthMap += depthStride; + stencilMap += stencilStride; + dst += dstStride; + } + + ctx->Driver.UnmapRenderbuffer(ctx, depthRb); + if (stencilRb != depthRb) { + ctx->Driver.UnmapRenderbuffer(ctx, stencilRb); + } +} + + +/** + * Read combined depth/stencil values. + * We'll have already done error checking to be sure the expected + * depth and stencil buffers really exist. + */ +static void +read_depth_stencil_pixels(struct gl_context *ctx, + GLint x, GLint y, + GLsizei width, GLsizei height, + GLenum type, GLvoid *pixels, + const struct gl_pixelstore_attrib *packing ) +{ + const GLboolean scaleOrBias + = ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0; + const GLboolean stencilTransfer = ctx->Pixel.IndexShift + || ctx->Pixel.IndexOffset || ctx->Pixel.MapStencilFlag; + GLubyte *dst; + int dstStride; + + dst = (GLubyte *) _mesa_image_address2d(packing, pixels, + width, height, + GL_DEPTH_STENCIL_EXT, + type, 0, 0); + dstStride = _mesa_image_row_stride(packing, width, + GL_DEPTH_STENCIL_EXT, type); + + /* Fast 24/8 reads. */ + if (type == GL_UNSIGNED_INT_24_8 && + !scaleOrBias && !stencilTransfer && !packing->SwapBytes) { + if (fast_read_depth_stencil_pixels(ctx, x, y, width, height, + dst, dstStride)) + return; + + if (fast_read_depth_stencil_pixels_separate(ctx, x, y, width, height, + (uint32_t *)dst, dstStride)) + return; + } + + slow_read_depth_stencil_pixels_separate(ctx, x, y, width, height, + type, packing, + dst, dstStride); +} + + + +/** + * Software fallback routine for ctx->Driver.ReadPixels(). + * By time we get here, all error checking will have been done. + */ +void +_mesa_readpixels(struct gl_context *ctx, + GLint x, GLint y, GLsizei width, GLsizei height, + GLenum format, GLenum type, + const struct gl_pixelstore_attrib *packing, + GLvoid *pixels) +{ + struct gl_pixelstore_attrib clippedPacking = *packing; + + if (ctx->NewState) + _mesa_update_state(ctx); + + /* Do all needed clipping here, so that we can forget about it later */ + if (_mesa_clip_readpixels(ctx, &x, &y, &width, &height, &clippedPacking)) { + + pixels = _mesa_map_pbo_dest(ctx, &clippedPacking, pixels); + + if (pixels) { + switch (format) { + case GL_STENCIL_INDEX: + read_stencil_pixels(ctx, x, y, width, height, type, pixels, + &clippedPacking); + break; + case GL_DEPTH_COMPONENT: + read_depth_pixels(ctx, x, y, width, height, type, pixels, + &clippedPacking); + break; + case GL_DEPTH_STENCIL_EXT: + read_depth_stencil_pixels(ctx, x, y, width, height, type, pixels, + &clippedPacking); + break; + default: + /* all other formats should be color formats */ + read_rgba_pixels(ctx, x, y, width, height, format, type, pixels, + &clippedPacking); + } + + _mesa_unmap_pbo_dest(ctx, &clippedPacking); + } + } +} + + /** * Do error checking of the format/type parameters to glReadPixels and * glDrawPixels. diff --git a/mesalib/src/mesa/main/readpix.h b/mesalib/src/mesa/main/readpix.h index f6bb3d6e2..6caaf3adc 100644 --- a/mesalib/src/mesa/main/readpix.h +++ b/mesalib/src/mesa/main/readpix.h @@ -30,11 +30,20 @@ #include "glheader.h" struct gl_context; +struct gl_pixelstore_attrib; + extern GLboolean _mesa_error_check_format_type(struct gl_context *ctx, GLenum format, GLenum type, GLboolean drawing); +extern void +_mesa_readpixels(struct gl_context *ctx, + GLint x, GLint y, GLsizei width, GLsizei height, + GLenum format, GLenum type, + const struct gl_pixelstore_attrib *packing, + GLvoid *pixels); + extern void GLAPIENTRY _mesa_ReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels ); diff --git a/mesalib/src/mesa/main/renderbuffer.c b/mesalib/src/mesa/main/renderbuffer.c index 4415dbd4f..c9a16a989 100644 --- a/mesalib/src/mesa/main/renderbuffer.c +++ b/mesalib/src/mesa/main/renderbuffer.c @@ -28,11 +28,6 @@ * Also, routines for reading/writing software-based renderbuffer data as * ubytes, ushorts, uints, etc. * - * The 'alpha8' renderbuffer is interesting. It's used to add a software-based - * alpha channel to RGB renderbuffers. This is done by wrapping the RGB - * renderbuffer with the alpha renderbuffer. We can do this because of the - * OO-nature of renderbuffers. - * * Down the road we'll use this for run-time support of 8, 16 and 32-bit * color channels. For example, Mesa may use 32-bit/float color channels * internally (swrast) and use wrapper renderbuffers to convert 32-bit @@ -1470,18 +1465,6 @@ _mesa_set_renderbuffer_accessors(struct gl_renderbuffer *rb) rb->PutMonoValues = put_mono_values_ushort4; break; -#if 0 - case MESA_FORMAT_A8: - rb->DataType = GL_UNSIGNED_BYTE; - rb->GetValues = get_values_alpha8; - rb->PutRow = put_row_alpha8; - rb->PutRowRGB = NULL; - rb->PutMonoRow = put_mono_row_alpha8; - rb->PutValues = put_values_alpha8; - rb->PutMonoValues = put_mono_values_alpha8; - break; -#endif - case MESA_FORMAT_S8: rb->DataType = GL_UNSIGNED_BYTE; rb->GetValues = get_values_ubyte; @@ -1639,11 +1622,6 @@ _mesa_soft_renderbuffer_storage(struct gl_context *ctx, struct gl_renderbuffer * /* for accum buffer */ rb->Format = MESA_FORMAT_SIGNED_RGBA_16; break; -#if 0 - case GL_ALPHA8: - rb->Format = MESA_FORMAT_A8; - break; -#endif case GL_STENCIL_INDEX: case GL_STENCIL_INDEX1_EXT: case GL_STENCIL_INDEX4_EXT: @@ -1754,236 +1732,6 @@ _mesa_unmap_soft_renderbuffer(struct gl_context *ctx, } -/**********************************************************************/ -/**********************************************************************/ -/**********************************************************************/ - - -/** - * Here we utilize the gl_renderbuffer->Wrapper field to put an alpha - * buffer wrapper around an existing RGB renderbuffer (hw or sw). - * - * When PutRow is called (for example), we store the alpha values in - * this buffer, then pass on the PutRow call to the wrapped RGB - * buffer. - */ - - -static GLboolean -alloc_storage_alpha8(struct gl_context *ctx, struct gl_renderbuffer *arb, - GLenum internalFormat, GLuint width, GLuint height) -{ - ASSERT(arb != arb->Wrapped); - ASSERT(arb->Format == MESA_FORMAT_A8); - - /* first, pass the call to the wrapped RGB buffer */ - if (!arb->Wrapped->AllocStorage(ctx, arb->Wrapped, internalFormat, - width, height)) { - return GL_FALSE; - } - - /* next, resize my alpha buffer */ - if (arb->Data) { - free(arb->Data); - } - - arb->Data = malloc(width * height * sizeof(GLubyte)); - if (arb->Data == NULL) { - arb->Width = 0; - arb->Height = 0; - _mesa_error(ctx, GL_OUT_OF_MEMORY, "software alpha buffer allocation"); - return GL_FALSE; - } - - arb->Width = width; - arb->Height = height; - arb->RowStride = width; - - return GL_TRUE; -} - - -/** - * Delete an alpha_renderbuffer object, as well as the wrapped RGB buffer. - */ -static void -delete_renderbuffer_alpha8(struct gl_renderbuffer *arb) -{ - if (arb->Data) { - free(arb->Data); - } - ASSERT(arb->Wrapped); - ASSERT(arb != arb->Wrapped); - arb->Wrapped->Delete(arb->Wrapped); - arb->Wrapped = NULL; - free(arb); -} - - -static void * -get_pointer_alpha8(struct gl_context *ctx, struct gl_renderbuffer *arb, - GLint x, GLint y) -{ - return NULL; /* don't allow direct access! */ -} - - -static void -get_row_alpha8(struct gl_context *ctx, struct gl_renderbuffer *arb, GLuint count, - GLint x, GLint y, void *values) -{ - /* NOTE: 'values' is RGBA format! */ - const GLubyte *src = (const GLubyte *) arb->Data + y * arb->RowStride + x; - GLubyte *dst = (GLubyte *) values; - GLuint i; - ASSERT(arb != arb->Wrapped); - ASSERT(arb->DataType == GL_UNSIGNED_BYTE); - /* first, pass the call to the wrapped RGB buffer */ - arb->Wrapped->GetRow(ctx, arb->Wrapped, count, x, y, values); - /* second, fill in alpha values from this buffer! */ - for (i = 0; i < count; i++) { - dst[i * 4 + 3] = src[i]; - } -} - - -static void -get_values_alpha8(struct gl_context *ctx, struct gl_renderbuffer *arb, GLuint count, - const GLint x[], const GLint y[], void *values) -{ - GLubyte *dst = (GLubyte *) values; - GLuint i; - ASSERT(arb != arb->Wrapped); - ASSERT(arb->DataType == GL_UNSIGNED_BYTE); - /* first, pass the call to the wrapped RGB buffer */ - arb->Wrapped->GetValues(ctx, arb->Wrapped, count, x, y, values); - /* second, fill in alpha values from this buffer! */ - for (i = 0; i < count; i++) { - const GLubyte *src = (GLubyte *) arb->Data + y[i] * arb->RowStride + x[i]; - dst[i * 4 + 3] = *src; - } -} - - -static void -put_row_alpha8(struct gl_context *ctx, struct gl_renderbuffer *arb, GLuint count, - GLint x, GLint y, const void *values, const GLubyte *mask) -{ - const GLubyte *src = (const GLubyte *) values; - GLubyte *dst = (GLubyte *) arb->Data + y * arb->RowStride + x; - GLuint i; - ASSERT(arb != arb->Wrapped); - ASSERT(arb->DataType == GL_UNSIGNED_BYTE); - /* first, pass the call to the wrapped RGB buffer */ - arb->Wrapped->PutRow(ctx, arb->Wrapped, count, x, y, values, mask); - /* second, store alpha in our buffer */ - for (i = 0; i < count; i++) { - if (!mask || mask[i]) { - dst[i] = src[i * 4 + 3]; - } - } -} - - -static void -put_row_rgb_alpha8(struct gl_context *ctx, struct gl_renderbuffer *arb, GLuint count, - GLint x, GLint y, const void *values, const GLubyte *mask) -{ - const GLubyte *src = (const GLubyte *) values; - GLubyte *dst = (GLubyte *) arb->Data + y * arb->RowStride + x; - GLuint i; - ASSERT(arb != arb->Wrapped); - ASSERT(arb->DataType == GL_UNSIGNED_BYTE); - /* first, pass the call to the wrapped RGB buffer */ - arb->Wrapped->PutRowRGB(ctx, arb->Wrapped, count, x, y, values, mask); - /* second, store alpha in our buffer */ - for (i = 0; i < count; i++) { - if (!mask || mask[i]) { - dst[i] = src[i * 4 + 3]; - } - } -} - - -static void -put_mono_row_alpha8(struct gl_context *ctx, struct gl_renderbuffer *arb, GLuint count, - GLint x, GLint y, const void *value, const GLubyte *mask) -{ - const GLubyte val = ((const GLubyte *) value)[3]; - GLubyte *dst = (GLubyte *) arb->Data + y * arb->RowStride + x; - ASSERT(arb != arb->Wrapped); - ASSERT(arb->DataType == GL_UNSIGNED_BYTE); - /* first, pass the call to the wrapped RGB buffer */ - arb->Wrapped->PutMonoRow(ctx, arb->Wrapped, count, x, y, value, mask); - /* second, store alpha in our buffer */ - if (mask) { - GLuint i; - for (i = 0; i < count; i++) { - if (mask[i]) { - dst[i] = val; - } - } - } - else { - memset(dst, val, count); - } -} - - -static void -put_values_alpha8(struct gl_context *ctx, struct gl_renderbuffer *arb, GLuint count, - const GLint x[], const GLint y[], - const void *values, const GLubyte *mask) -{ - const GLubyte *src = (const GLubyte *) values; - GLuint i; - ASSERT(arb != arb->Wrapped); - ASSERT(arb->DataType == GL_UNSIGNED_BYTE); - /* first, pass the call to the wrapped RGB buffer */ - arb->Wrapped->PutValues(ctx, arb->Wrapped, count, x, y, values, mask); - /* second, store alpha in our buffer */ - for (i = 0; i < count; i++) { - if (!mask || mask[i]) { - GLubyte *dst = (GLubyte *) arb->Data + y[i] * arb->RowStride + x[i]; - *dst = src[i * 4 + 3]; - } - } -} - - -static void -put_mono_values_alpha8(struct gl_context *ctx, struct gl_renderbuffer *arb, - GLuint count, const GLint x[], const GLint y[], - const void *value, const GLubyte *mask) -{ - const GLubyte val = ((const GLubyte *) value)[3]; - GLuint i; - ASSERT(arb != arb->Wrapped); - ASSERT(arb->DataType == GL_UNSIGNED_BYTE); - /* first, pass the call to the wrapped RGB buffer */ - arb->Wrapped->PutValues(ctx, arb->Wrapped, count, x, y, value, mask); - /* second, store alpha in our buffer */ - for (i = 0; i < count; i++) { - if (!mask || mask[i]) { - GLubyte *dst = (GLubyte *) arb->Data + y[i] * arb->RowStride + x[i]; - *dst = val; - } - } -} - - -static void -copy_buffer_alpha8(struct gl_renderbuffer* dst, struct gl_renderbuffer* src) -{ - ASSERT(dst->Format == MESA_FORMAT_A8); - ASSERT(src->Format == MESA_FORMAT_A8); - ASSERT(dst->Width == src->Width); - ASSERT(dst->Height == src->Height); - ASSERT(dst->RowStride == src->RowStride); - - memcpy(dst->Data, src->Data, dst->RowStride * dst->Height * sizeof(GLubyte)); -} - /**********************************************************************/ /**********************************************************************/ @@ -2147,114 +1895,6 @@ _mesa_add_color_renderbuffers(struct gl_context *ctx, struct gl_framebuffer *fb, } -/** - * Add software-based alpha renderbuffers to the given framebuffer. - * This is a helper routine for device drivers when creating a - * window system framebuffer (not a user-created render/framebuffer). - * Once this function is called, you can basically forget about this - * renderbuffer; core Mesa will handle all the buffer management and - * rendering! - */ -GLboolean -_mesa_add_alpha_renderbuffers(struct gl_context *ctx, struct gl_framebuffer *fb, - GLuint alphaBits, - GLboolean frontLeft, GLboolean backLeft, - GLboolean frontRight, GLboolean backRight) -{ - gl_buffer_index b; - - /* for window system framebuffers only! */ - assert(fb->Name == 0); - - if (alphaBits > 8) { - _mesa_problem(ctx, - "Unsupported bit depth in _mesa_add_alpha_renderbuffers"); - return GL_FALSE; - } - - assert(MAX_COLOR_ATTACHMENTS >= 4); - - /* Wrap each of the RGB color buffers with an alpha renderbuffer. - */ - for (b = BUFFER_FRONT_LEFT; b <= BUFFER_BACK_RIGHT; b++) { - struct gl_renderbuffer *arb; - - if (b == BUFFER_FRONT_LEFT && !frontLeft) - continue; - else if (b == BUFFER_BACK_LEFT && !backLeft) - continue; - else if (b == BUFFER_FRONT_RIGHT && !frontRight) - continue; - else if (b == BUFFER_BACK_RIGHT && !backRight) - continue; - - /* the RGB buffer to wrap must already exist!! */ - assert(fb->Attachment[b].Renderbuffer); - - /* only GLubyte supported for now */ - assert(fb->Attachment[b].Renderbuffer->DataType == GL_UNSIGNED_BYTE); - - /* allocate alpha renderbuffer */ - arb = _mesa_new_renderbuffer(ctx, 0); - if (!arb) { - _mesa_error(ctx, GL_OUT_OF_MEMORY, "Allocating alpha buffer"); - return GL_FALSE; - } - - /* wrap the alpha renderbuffer around the RGB renderbuffer */ - arb->Wrapped = fb->Attachment[b].Renderbuffer; - - /* Set up my alphabuffer fields and plug in my functions. - * The functions will put/get the alpha values from/to RGBA arrays - * and then call the wrapped buffer's functions to handle the RGB - * values. - */ - arb->InternalFormat = arb->Wrapped->InternalFormat; - arb->Format = MESA_FORMAT_A8; - arb->DataType = arb->Wrapped->DataType; - arb->AllocStorage = alloc_storage_alpha8; - arb->Delete = delete_renderbuffer_alpha8; - arb->GetPointer = get_pointer_alpha8; - arb->GetRow = get_row_alpha8; - arb->GetValues = get_values_alpha8; - arb->PutRow = put_row_alpha8; - arb->PutRowRGB = put_row_rgb_alpha8; - arb->PutMonoRow = put_mono_row_alpha8; - arb->PutValues = put_values_alpha8; - arb->PutMonoValues = put_mono_values_alpha8; - - /* clear the pointer to avoid assertion/sanity check failure later */ - fb->Attachment[b].Renderbuffer = NULL; - - /* plug the alpha renderbuffer into the colorbuffer attachment */ - _mesa_add_renderbuffer(fb, b, arb); - } - - return GL_TRUE; -} - - -/** - * For framebuffers that use a software alpha channel wrapper - * created by _mesa_add_alpha_renderbuffer or _mesa_add_soft_renderbuffers, - * copy the back buffer alpha channel into the front buffer alpha channel. - */ -void -_mesa_copy_soft_alpha_renderbuffers(struct gl_context *ctx, struct gl_framebuffer *fb) -{ - if (fb->Attachment[BUFFER_FRONT_LEFT].Renderbuffer && - fb->Attachment[BUFFER_BACK_LEFT].Renderbuffer) - copy_buffer_alpha8(fb->Attachment[BUFFER_FRONT_LEFT].Renderbuffer, - fb->Attachment[BUFFER_BACK_LEFT].Renderbuffer); - - - if (fb->Attachment[BUFFER_FRONT_RIGHT].Renderbuffer && - fb->Attachment[BUFFER_BACK_RIGHT].Renderbuffer) - copy_buffer_alpha8(fb->Attachment[BUFFER_FRONT_RIGHT].Renderbuffer, - fb->Attachment[BUFFER_BACK_RIGHT].Renderbuffer); -} - - /** * Add a software-based depth renderbuffer to the given framebuffer. * This is a helper routine for device drivers when creating a @@ -2476,13 +2116,6 @@ _mesa_add_soft_renderbuffers(struct gl_framebuffer *fb, fb->Visual.numAuxBuffers); } - if (alpha) { - assert(fb->Visual.alphaBits > 0); - _mesa_add_alpha_renderbuffers(NULL, fb, fb->Visual.alphaBits, - frontLeft, backLeft, - frontRight, backRight); - } - #if 0 if (multisample) { /* maybe someday */ diff --git a/mesalib/src/mesa/main/renderbuffer.h b/mesalib/src/mesa/main/renderbuffer.h index cb0d712eb..3194fc3fe 100644 --- a/mesalib/src/mesa/main/renderbuffer.h +++ b/mesalib/src/mesa/main/renderbuffer.h @@ -72,15 +72,6 @@ _mesa_add_color_renderbuffers(struct gl_context *ctx, struct gl_framebuffer *fb, GLboolean frontLeft, GLboolean backLeft, GLboolean frontRight, GLboolean backRight); -extern GLboolean -_mesa_add_alpha_renderbuffers(struct gl_context *ctx, struct gl_framebuffer *fb, - GLuint alphaBits, - GLboolean frontLeft, GLboolean backLeft, - GLboolean frontRight, GLboolean backRight); - -extern void -_mesa_copy_soft_alpha_renderbuffers(struct gl_context *ctx, struct gl_framebuffer *fb); - extern GLboolean _mesa_add_depth_renderbuffer(struct gl_context *ctx, struct gl_framebuffer *fb, GLuint depthBits); diff --git a/mesalib/src/mesa/main/uniform_query.cpp b/mesalib/src/mesa/main/uniform_query.cpp index 5371d6a17..33ba53c2e 100644 --- a/mesalib/src/mesa/main/uniform_query.cpp +++ b/mesalib/src/mesa/main/uniform_query.cpp @@ -698,11 +698,27 @@ _mesa_uniform(struct gl_context *ctx, struct gl_shader_program *shProg, prog = shProg->_LinkedShaders[i]->Program; + /* If the shader stage doesn't use any samplers, don't bother + * checking if any samplers have changed. + */ + if (prog->SamplersUsed == 0) + continue; + assert(sizeof(prog->SamplerUnits) == sizeof(shProg->SamplerUnits)); - if (memcmp(prog->SamplerUnits, - shProg->SamplerUnits, - sizeof(shProg->SamplerUnits)) != 0) { + /* Determine if any of the samplers used by this shader stage have + * been modified. + */ + bool changed = false; + for (unsigned j = 0; j < Elements(prog->SamplerUnits); j++) { + if ((prog->SamplersUsed & (1U << j)) != 0 + && (prog->SamplerUnits[j] != shProg->SamplerUnits[j])) { + changed = true; + break; + } + } + + if (changed) { if (!flushed) { FLUSH_VERTICES(ctx, _NEW_TEXTURE | _NEW_PROGRAM); flushed = true; diff --git a/mesalib/src/mesa/program/ir_to_mesa.cpp b/mesalib/src/mesa/program/ir_to_mesa.cpp index 1b8b48e53..5cee83778 100644 --- a/mesalib/src/mesa/program/ir_to_mesa.cpp +++ b/mesalib/src/mesa/program/ir_to_mesa.cpp @@ -2541,58 +2541,6 @@ count_resources(struct gl_program *prog) _mesa_update_shader_textures_used(prog); } - -/** - * Check if the given vertex/fragment/shader program is within the - * resource limits of the context (number of texture units, etc). - * If any of those checks fail, record a linker error. - * - * XXX more checks are needed... - */ -static bool -check_resources(const struct gl_context *ctx, - struct gl_shader_program *shader_program, - struct gl_program *prog) -{ - switch (prog->Target) { - case GL_VERTEX_PROGRAM_ARB: - if (_mesa_bitcount(prog->SamplersUsed) > - ctx->Const.MaxVertexTextureImageUnits) { - linker_error(shader_program, - "Too many vertex shader texture samplers"); - } - if (prog->Parameters->NumParameters > MAX_UNIFORMS) { - linker_error(shader_program, "Too many vertex shader constants"); - } - break; - case MESA_GEOMETRY_PROGRAM: - if (_mesa_bitcount(prog->SamplersUsed) > - ctx->Const.MaxGeometryTextureImageUnits) { - linker_error(shader_program, - "Too many geometry shader texture samplers"); - } - if (prog->Parameters->NumParameters > - MAX_GEOMETRY_UNIFORM_COMPONENTS / 4) { - linker_error(shader_program, "Too many geometry shader constants"); - } - break; - case GL_FRAGMENT_PROGRAM_ARB: - if (_mesa_bitcount(prog->SamplersUsed) > - ctx->Const.MaxTextureImageUnits) { - linker_error(shader_program, - "Too many fragment shader texture samplers"); - } - if (prog->Parameters->NumParameters > MAX_UNIFORMS) { - linker_error(shader_program, "Too many fragment shader constants"); - } - break; - default: - _mesa_problem(ctx, "unexpected program type in check_resources()"); - } - - return shader_program->LinkStatus; -} - class add_uniform_to_shader : public uniform_field_visitor { public: add_uniform_to_shader(struct gl_shader_program *shader_program, @@ -3274,9 +3222,6 @@ get_mesa_program(struct gl_context *ctx, do_set_program_inouts(shader->ir, prog, shader->Type == GL_FRAGMENT_SHADER); count_resources(prog); - if (!check_resources(ctx, shader_program, prog)) - goto fail_exit; - _mesa_reference_program(ctx, &shader->Program, prog); if ((ctx->Shader.Flags & GLSL_NO_OPT) == 0) { @@ -3513,7 +3458,9 @@ _mesa_glsl_link_shader(struct gl_context *ctx, struct gl_shader_program *prog) } } - set_uniform_initializers(ctx, prog); + if (prog->LinkStatus) { + set_uniform_initializers(ctx, prog); + } if (ctx->Shader.Flags & GLSL_DUMP) { if (!prog->LinkStatus) { diff --git a/mesalib/src/mesa/sources.mak b/mesalib/src/mesa/sources.mak index 102562ace..e72a1ce1e 100644 --- a/mesalib/src/mesa/sources.mak +++ b/mesalib/src/mesa/sources.mak @@ -141,7 +141,6 @@ SWRAST_SOURCES = \ swrast/s_logic.c \ swrast/s_masking.c \ swrast/s_points.c \ - swrast/s_readpix.c \ swrast/s_span.c \ swrast/s_stencil.c \ swrast/s_texcombine.c \ diff --git a/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c b/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c index 5714d343d..95805fd3c 100644 --- a/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c +++ b/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c @@ -38,6 +38,7 @@ #include "main/mtypes.h" #include "main/pack.h" #include "main/pbo.h" +#include "main/readpix.h" #include "main/texformat.h" #include "main/teximage.h" #include "main/texstore.h" @@ -1189,9 +1190,9 @@ copy_stencil_pixels(struct gl_context *ctx, GLint srcx, GLint srcy, rbDraw = st_renderbuffer(rbDraw->Base.Wrapped); /* this will do stencil pixel transfer ops */ - st_read_stencil_pixels(ctx, srcx, srcy, width, height, - GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, - &ctx->DefaultPacking, buffer); + _mesa_readpixels(ctx, srcx, srcy, width, height, + GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, + &ctx->DefaultPacking, buffer); if (0) { /* debug code: dump stencil values */ @@ -1296,6 +1297,20 @@ copy_stencil_pixels(struct gl_context *ctx, GLint srcx, GLint srcy, } +/** + * Return renderbuffer to use for reading color pixels for glCopyPixels + */ +static struct st_renderbuffer * +st_get_color_read_renderbuffer(struct gl_context *ctx) +{ + struct gl_framebuffer *fb = ctx->ReadBuffer; + struct st_renderbuffer *strb = + st_renderbuffer(fb->_ColorReadBuffer); + + return strb; +} + + /** Do the src/dest regions overlap? */ static GLboolean regions_overlap(GLint srcX, GLint srcY, GLint dstX, GLint dstY, diff --git a/mesalib/src/mesa/state_tracker/st_cb_fbo.c b/mesalib/src/mesa/state_tracker/st_cb_fbo.c index e04cb4406..a351d1197 100644 --- a/mesalib/src/mesa/state_tracker/st_cb_fbo.c +++ b/mesalib/src/mesa/state_tracker/st_cb_fbo.c @@ -355,8 +355,12 @@ st_render_texture(struct gl_context *ctx, /* get pointer to texture image we're rendeing to */ texImage = _mesa_get_attachment_teximage(att); - /* create new renderbuffer which wraps the texture image */ - rb = st_new_renderbuffer(ctx, 0); + /* create new renderbuffer which wraps the texture image. + * Use the texture's name as the renderbuffer's name so that we have + * something that's non-zero (to determine vertical orientation) and + * possibly helpful for debugging. + */ + rb = st_new_renderbuffer(ctx, att->Texture->Name); if (!rb) { _mesa_error(ctx, GL_OUT_OF_MEMORY, "glFramebufferTexture()"); return; @@ -644,7 +648,9 @@ st_MapRenderbuffer(struct gl_context *ctx, struct st_context *st = st_context(ctx); struct st_renderbuffer *strb = st_renderbuffer(rb); struct pipe_context *pipe = st->pipe; + const GLboolean invert = rb->Name == 0; unsigned usage; + GLuint y2; usage = 0x0; if (mode & GL_MAP_READ_BIT) @@ -652,14 +658,30 @@ st_MapRenderbuffer(struct gl_context *ctx, if (mode & GL_MAP_WRITE_BIT) usage |= PIPE_TRANSFER_WRITE; + /* Note: y=0=bottom of buffer while y2=0=top of buffer. + * 'invert' will be true for window-system buffers and false for + * user-allocated renderbuffers and textures. + */ + if (invert) + y2 = strb->Base.Height - y - h; + else + y2 = y; + strb->transfer = pipe_get_transfer(pipe, strb->texture, strb->rtt_level, strb->rtt_face + strb->rtt_slice, - usage, x, y, w, h); + usage, x, y2, w, h); if (strb->transfer) { - *mapOut = pipe_transfer_map(pipe, strb->transfer); - *rowStrideOut = strb->transfer->stride; + GLubyte *map = pipe_transfer_map(pipe, strb->transfer); + if (invert) { + *rowStrideOut = -strb->transfer->stride; + map += (h - 1) * strb->transfer->stride; + } + else { + *rowStrideOut = strb->transfer->stride; + } + *mapOut = map; } else { *mapOut = NULL; diff --git a/mesalib/src/mesa/state_tracker/st_cb_readpixels.c b/mesalib/src/mesa/state_tracker/st_cb_readpixels.c index bd73f3bf0..6b824b161 100644 --- a/mesalib/src/mesa/state_tracker/st_cb_readpixels.c +++ b/mesalib/src/mesa/state_tracker/st_cb_readpixels.c @@ -26,649 +26,32 @@ **************************************************************************/ -/** - * glReadPixels interface to pipe - * - * \author Brian Paul - */ - - #include "main/imports.h" -#include "main/bufferobj.h" -#include "main/context.h" -#include "main/image.h" -#include "main/pack.h" -#include "main/pbo.h" - -#include "pipe/p_context.h" -#include "pipe/p_defines.h" -#include "util/u_format.h" -#include "util/u_inlines.h" -#include "util/u_tile.h" +#include "main/readpix.h" -#include "st_debug.h" -#include "st_context.h" #include "st_atom.h" +#include "st_context.h" #include "st_cb_bitmap.h" #include "st_cb_readpixels.h" -#include "st_cb_fbo.h" - -/** - * Special case for reading stencil buffer. - * For color/depth we use get_tile(). For stencil, map the stencil buffer. - */ -void -st_read_stencil_pixels(struct gl_context *ctx, GLint x, GLint y, - GLsizei width, GLsizei height, - GLenum format, GLenum type, - const struct gl_pixelstore_attrib *packing, - GLvoid *pixels) -{ - struct gl_framebuffer *fb = ctx->ReadBuffer; - struct pipe_context *pipe = st_context(ctx)->pipe; - struct st_renderbuffer *strb = st_renderbuffer(fb->_StencilBuffer); - struct pipe_transfer *pt; - ubyte *stmap; - GLint j; - - if (strb->Base.Wrapped) { - strb = st_renderbuffer(strb->Base.Wrapped); - } - - if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) { - y = ctx->DrawBuffer->Height - y - height; - } - - /* Create a read transfer from the renderbuffer's texture */ - - pt = pipe_get_transfer(pipe, strb->texture, - strb->rtt_level, - strb->rtt_face + strb->rtt_slice, - PIPE_TRANSFER_READ, - x, y, width, height); - - /* map the stencil buffer */ - stmap = pipe_transfer_map(pipe, pt); - - /* width should never be > MAX_WIDTH since we did clipping earlier */ - ASSERT(width <= MAX_WIDTH); - - /* process image row by row */ - for (j = 0; j < height; j++) { - GLvoid *dest; - GLstencil sValues[MAX_WIDTH]; - GLfloat zValues[MAX_WIDTH]; - GLint srcY; - - if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) { - srcY = height - j - 1; - } - else { - srcY = j; - } - - /* get stencil (and Z) values */ - switch (pt->resource->format) { - case PIPE_FORMAT_S8_UINT: - { - const ubyte *src = stmap + srcY * pt->stride; - memcpy(sValues, src, width); - } - break; - case PIPE_FORMAT_Z24_UNORM_S8_UINT: - if (format == GL_DEPTH_STENCIL) { - const uint *src = (uint *) (stmap + srcY * pt->stride); - const GLfloat scale = 1.0f / (0xffffff); - GLint k; - for (k = 0; k < width; k++) { - sValues[k] = src[k] >> 24; - zValues[k] = (src[k] & 0xffffff) * scale; - } - } - else { - const uint *src = (uint *) (stmap + srcY * pt->stride); - GLint k; - for (k = 0; k < width; k++) { - sValues[k] = src[k] >> 24; - } - } - break; - case PIPE_FORMAT_S8_UINT_Z24_UNORM: - if (format == GL_DEPTH_STENCIL) { - const uint *src = (uint *) (stmap + srcY * pt->stride); - const GLfloat scale = 1.0f / (0xffffff); - GLint k; - for (k = 0; k < width; k++) { - sValues[k] = src[k] & 0xff; - zValues[k] = (src[k] >> 8) * scale; - } - } - else { - const uint *src = (uint *) (stmap + srcY * pt->stride); - GLint k; - for (k = 0; k < width; k++) { - sValues[k] = src[k] & 0xff; - } - } - break; - case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT: - if (format == GL_DEPTH_STENCIL) { - const uint *src = (uint *) (stmap + srcY * pt->stride); - const GLfloat *srcf = (const GLfloat*)src; - GLint k; - for (k = 0; k < width; k++) { - zValues[k] = srcf[k*2]; - sValues[k] = src[k*2+1] & 0xff; - } - } - else { - const uint *src = (uint *) (stmap + srcY * pt->stride); - GLint k; - for (k = 0; k < width; k++) { - sValues[k] = src[k*2+1] & 0xff; - } - } - break; - default: - assert(0); - } - - /* store */ - dest = _mesa_image_address2d(packing, pixels, width, height, - format, type, j, 0); - if (format == GL_DEPTH_STENCIL) { - _mesa_pack_depth_stencil_span(ctx, width, type, dest, - zValues, sValues, packing); - } - else { - _mesa_pack_stencil_span(ctx, width, type, dest, sValues, packing); - } - } - - /* unmap the stencil buffer */ - pipe_transfer_unmap(pipe, pt); - pipe->transfer_destroy(pipe, pt); -} - - -/** - * Return renderbuffer to use for reading color pixels for glRead/CopyPixel - * commands. - */ -struct st_renderbuffer * -st_get_color_read_renderbuffer(struct gl_context *ctx) -{ - struct gl_framebuffer *fb = ctx->ReadBuffer; - struct st_renderbuffer *strb = - st_renderbuffer(fb->_ColorReadBuffer); - - return strb; -} - - -/** - * Try to do glReadPixels in a fast manner for common cases. - * \return GL_TRUE for success, GL_FALSE for failure - */ -static GLboolean -st_fast_readpixels(struct gl_context *ctx, struct st_renderbuffer *strb, - GLint x, GLint y, GLsizei width, GLsizei height, - GLenum format, GLenum type, - const struct gl_pixelstore_attrib *pack, - GLvoid *dest) -{ - GLubyte alphaORoperand; - enum combination { - A8R8G8B8_UNORM_TO_RGBA_UBYTE, - A8R8G8B8_UNORM_TO_RGB_UBYTE, - A8R8G8B8_UNORM_TO_BGRA_UINT, - A8R8G8B8_UNORM_TO_RGBA_UINT - } combo; - - if (ctx->_ImageTransferState) - return GL_FALSE; - - if (strb->format == PIPE_FORMAT_B8G8R8A8_UNORM) { - alphaORoperand = 0; - } - else if (strb->format == PIPE_FORMAT_B8G8R8X8_UNORM ) { - alphaORoperand = 0xff; - } - else { - return GL_FALSE; - } - - if (format == GL_RGBA && type == GL_UNSIGNED_BYTE) { - combo = A8R8G8B8_UNORM_TO_RGBA_UBYTE; - } - else if (format == GL_RGB && type == GL_UNSIGNED_BYTE) { - combo = A8R8G8B8_UNORM_TO_RGB_UBYTE; - } - else if (format == GL_BGRA && type == GL_UNSIGNED_INT_8_8_8_8_REV) { - combo = A8R8G8B8_UNORM_TO_BGRA_UINT; - } - else if (format == GL_RGBA && type == GL_UNSIGNED_INT_8_8_8_8) { - combo = A8R8G8B8_UNORM_TO_RGBA_UINT; - } - else { - return GL_FALSE; - } - - /*printf("st_fast_readpixels combo %d\n", (GLint) combo);*/ - - { - struct pipe_context *pipe = st_context(ctx)->pipe; - struct pipe_transfer *trans; - const GLubyte *map; - GLubyte *dst; - GLint row, col, dy, dstStride; - - if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) { - /* convert GL Y to Gallium Y */ - y = strb->texture->height0 - y - height; - } - - trans = pipe_get_transfer(pipe, strb->texture, - strb->rtt_level, - strb->rtt_face + strb->rtt_slice, - PIPE_TRANSFER_READ, - x, y, width, height); - if (!trans) { - return GL_FALSE; - } - - map = pipe_transfer_map(pipe, trans); - if (!map) { - pipe->transfer_destroy(pipe, trans); - return GL_FALSE; - } - - /* We always write to the user/dest buffer from low addr to high addr - * but the read order depends on renderbuffer orientation - */ - if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) { - /* read source rows from bottom to top */ - y = height - 1; - dy = -1; - } - else { - /* read source rows from top to bottom */ - y = 0; - dy = 1; - } - - dst = _mesa_image_address2d(pack, dest, width, height, - format, type, 0, 0); - dstStride = _mesa_image_row_stride(pack, width, format, type); - - switch (combo) { - case A8R8G8B8_UNORM_TO_RGBA_UBYTE: - for (row = 0; row < height; row++) { - const GLubyte *src = map + y * trans->stride; - for (col = 0; col < width; col++) { - GLuint pixel = ((GLuint *) src)[col]; - dst[col*4+0] = (pixel >> 16) & 0xff; - dst[col*4+1] = (pixel >> 8) & 0xff; - dst[col*4+2] = (pixel >> 0) & 0xff; - dst[col*4+3] = ((pixel >> 24) & 0xff) | alphaORoperand; - } - dst += dstStride; - y += dy; - } - break; - case A8R8G8B8_UNORM_TO_RGB_UBYTE: - for (row = 0; row < height; row++) { - const GLubyte *src = map + y * trans->stride; - for (col = 0; col < width; col++) { - GLuint pixel = ((GLuint *) src)[col]; - dst[col*3+0] = (pixel >> 16) & 0xff; - dst[col*3+1] = (pixel >> 8) & 0xff; - dst[col*3+2] = (pixel >> 0) & 0xff; - } - dst += dstStride; - y += dy; - } - break; - case A8R8G8B8_UNORM_TO_BGRA_UINT: - for (row = 0; row < height; row++) { - const GLubyte *src = map + y * trans->stride; - memcpy(dst, src, 4 * width); - if (alphaORoperand) { - assert(alphaORoperand == 0xff); - for (col = 0; col < width; col++) { - dst[col*4+3] = 0xff; - } - } - dst += dstStride; - y += dy; - } - break; - case A8R8G8B8_UNORM_TO_RGBA_UINT: - for (row = 0; row < height; row++) { - const GLubyte *src = map + y * trans->stride; - for (col = 0; col < width; col++) { - GLuint pixel = ((GLuint *) src)[col]; - dst[col*4+0] = ((pixel >> 24) & 0xff) | alphaORoperand; - dst[col*4+1] = (pixel >> 0) & 0xff; - dst[col*4+2] = (pixel >> 8) & 0xff; - dst[col*4+3] = (pixel >> 16) & 0xff; - } - dst += dstStride; - y += dy; - } - break; - default: - ; /* nothing */ - } - - pipe_transfer_unmap(pipe, trans); - pipe->transfer_destroy(pipe, trans); - } - - return GL_TRUE; -} /** - * Do glReadPixels by getting rows from the framebuffer transfer with - * get_tile(). Convert to requested format/type with Mesa image routines. - * Image transfer ops are done in software too. + * The only special thing we need to do for the state tracker's + * glReadPixels is to validate state (to be sure we have up-to-date + * framebuffer surfaces) and flush the bitmap cache prior to reading. */ static void -st_readpixels(struct gl_context *ctx, GLint x, GLint y, GLsizei width, GLsizei height, +st_readpixels(struct gl_context *ctx, GLint x, GLint y, + GLsizei width, GLsizei height, GLenum format, GLenum type, const struct gl_pixelstore_attrib *pack, GLvoid *dest) { struct st_context *st = st_context(ctx); - struct pipe_context *pipe = st->pipe; - GLfloat (*temp)[4]; - GLbitfield transferOps = ctx->_ImageTransferState; - GLsizei i, j; - GLint yStep, dfStride; - GLfloat *df; - GLuint *dui; - GLint *di; - struct st_renderbuffer *strb; - struct gl_pixelstore_attrib clippedPacking = *pack; - struct pipe_transfer *trans; - enum pipe_format pformat; - - assert(ctx->ReadBuffer->Width > 0); st_validate_state(st); - - /* Do all needed clipping here, so that we can forget about it later */ - if (!_mesa_clip_readpixels(ctx, &x, &y, &width, &height, &clippedPacking)) { - /* The ReadPixels transfer is totally outside the window bounds */ - return; - } - st_flush_bitmap_cache(st); - - dest = _mesa_map_pbo_dest(ctx, &clippedPacking, dest); - if (!dest) - return; - - if (format == GL_STENCIL_INDEX || - format == GL_DEPTH_STENCIL) { - st_read_stencil_pixels(ctx, x, y, width, height, - format, type, pack, dest); - return; - } - else if (format == GL_DEPTH_COMPONENT) { - strb = st_renderbuffer(ctx->ReadBuffer->_DepthBuffer); - if (strb->Base.Wrapped) { - strb = st_renderbuffer(strb->Base.Wrapped); - } - } - else { - /* Read color buffer */ - strb = st_get_color_read_renderbuffer(ctx); - } - - if (!strb) - return; - - /* try a fast-path readpixels before anything else */ - if (st_fast_readpixels(ctx, strb, x, y, width, height, - format, type, pack, dest)) { - /* success! */ - _mesa_unmap_pbo_dest(ctx, &clippedPacking); - return; - } - - /* allocate temp pixel row buffer */ - temp = (GLfloat (*)[4]) malloc(4 * width * sizeof(GLfloat)); - if (!temp) { - _mesa_error(ctx, GL_OUT_OF_MEMORY, "glReadPixels"); - return; - } - - if(ctx->Color._ClampReadColor) - transferOps |= IMAGE_CLAMP_BIT; - - if (format == GL_RGBA && type == GL_FLOAT && !transferOps) { - /* write tile(row) directly into user's buffer */ - df = (GLfloat *) _mesa_image_address2d(&clippedPacking, dest, width, - height, format, type, 0, 0); - dfStride = width * 4; - } - else { - /* write tile(row) into temp row buffer */ - df = (GLfloat *)temp; - dfStride = 0; - } - - dui = (GLuint *)df; - di = (GLint *)df; - - if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) { - /* convert GL Y to Gallium Y */ - y = strb->Base.Height - y - height; - } - - /* Create a read transfer from the renderbuffer's texture */ - trans = pipe_get_transfer(pipe, strb->texture, - strb->rtt_level, /* level */ - strb->rtt_face + strb->rtt_slice, /* layer */ - PIPE_TRANSFER_READ, - x, y, width, height); - - /* determine bottom-to-top vs. top-to-bottom order */ - if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) { - y = height - 1; - yStep = -1; - } - else { - y = 0; - yStep = 1; - } - - /* possibly convert sRGB format to linear RGB format */ - pformat = util_format_linear(trans->resource->format); - - if (ST_DEBUG & DEBUG_FALLBACK) - debug_printf("%s: fallback processing\n", __FUNCTION__); - - /* - * Copy pixels from pipe_transfer to user memory - */ - { - /* dest of first pixel in client memory */ - GLubyte *dst = _mesa_image_address2d(&clippedPacking, dest, width, - height, format, type, 0, 0); - /* dest row stride */ - const GLint dstStride = _mesa_image_row_stride(&clippedPacking, width, - format, type); - - if (pformat == PIPE_FORMAT_Z24_UNORM_S8_UINT || - pformat == PIPE_FORMAT_Z24X8_UNORM) { - if (format == GL_DEPTH_COMPONENT) { - for (i = 0; i < height; i++) { - GLuint ztemp[MAX_WIDTH]; - GLfloat zfloat[MAX_WIDTH]; - const double scale = 1.0 / ((1 << 24) - 1); - pipe_get_tile_raw(pipe, trans, 0, y, width, 1, ztemp, 0); - y += yStep; - for (j = 0; j < width; j++) { - zfloat[j] = (float) (scale * (ztemp[j] & 0xffffff)); - } - _mesa_pack_depth_span(ctx, width, dst, type, - zfloat, &clippedPacking); - dst += dstStride; - } - } - else { - /* XXX: unreachable code -- should be before st_read_stencil_pixels */ - assert(format == GL_DEPTH_STENCIL_EXT); - for (i = 0; i < height; i++) { - GLuint *zshort = (GLuint *)dst; - pipe_get_tile_raw(pipe, trans, 0, y, width, 1, dst, 0); - y += yStep; - /* Reverse into 24/8 */ - for (j = 0; j < width; j++) { - zshort[j] = (zshort[j] << 8) | (zshort[j] >> 24); - } - dst += dstStride; - } - } - } - else if (pformat == PIPE_FORMAT_S8_UINT_Z24_UNORM || - pformat == PIPE_FORMAT_X8Z24_UNORM) { - if (format == GL_DEPTH_COMPONENT) { - for (i = 0; i < height; i++) { - GLuint ztemp[MAX_WIDTH]; - GLfloat zfloat[MAX_WIDTH]; - const double scale = 1.0 / ((1 << 24) - 1); - pipe_get_tile_raw(pipe, trans, 0, y, width, 1, ztemp, 0); - y += yStep; - for (j = 0; j < width; j++) { - zfloat[j] = (float) (scale * ((ztemp[j] >> 8) & 0xffffff)); - } - _mesa_pack_depth_span(ctx, width, dst, type, - zfloat, &clippedPacking); - dst += dstStride; - } - } - else { - /* XXX: unreachable code -- should be before st_read_stencil_pixels */ - assert(format == GL_DEPTH_STENCIL_EXT); - for (i = 0; i < height; i++) { - pipe_get_tile_raw(pipe, trans, 0, y, width, 1, dst, 0); - y += yStep; - dst += dstStride; - } - } - } - else if (pformat == PIPE_FORMAT_Z16_UNORM) { - for (i = 0; i < height; i++) { - GLushort ztemp[MAX_WIDTH]; - GLfloat zfloat[MAX_WIDTH]; - const double scale = 1.0 / 0xffff; - pipe_get_tile_raw(pipe, trans, 0, y, width, 1, ztemp, 0); - y += yStep; - for (j = 0; j < width; j++) { - zfloat[j] = (float) (scale * ztemp[j]); - } - _mesa_pack_depth_span(ctx, width, dst, type, - zfloat, &clippedPacking); - dst += dstStride; - } - } - else if (pformat == PIPE_FORMAT_Z32_UNORM) { - for (i = 0; i < height; i++) { - GLuint ztemp[MAX_WIDTH]; - GLfloat zfloat[MAX_WIDTH]; - const double scale = 1.0 / 0xffffffff; - pipe_get_tile_raw(pipe, trans, 0, y, width, 1, ztemp, 0); - y += yStep; - for (j = 0; j < width; j++) { - zfloat[j] = (float) (scale * ztemp[j]); - } - _mesa_pack_depth_span(ctx, width, dst, type, - zfloat, &clippedPacking); - dst += dstStride; - } - } - else if (pformat == PIPE_FORMAT_Z32_FLOAT) { - for (i = 0; i < height; i++) { - GLfloat zfloat[MAX_WIDTH]; - pipe_get_tile_raw(pipe, trans, 0, y, width, 1, zfloat, 0); - y += yStep; - _mesa_pack_depth_span(ctx, width, dst, type, - zfloat, &clippedPacking); - dst += dstStride; - } - } - else if (pformat == PIPE_FORMAT_Z32_FLOAT_S8X24_UINT) { - assert(format == GL_DEPTH_COMPONENT); - for (i = 0; i < height; i++) { - GLfloat zfloat[MAX_WIDTH]; /* Z32 */ - GLfloat zfloat2[MAX_WIDTH*2]; /* Z32X32 */ - pipe_get_tile_raw(pipe, trans, 0, y, width, 1, zfloat2, 0); - y += yStep; - for (j = 0; j < width; j++) { - zfloat[j] = zfloat2[j*2]; - } - _mesa_pack_depth_span(ctx, width, dst, type, - zfloat, &clippedPacking); - dst += dstStride; - } - } - else if (util_format_is_pure_sint(pformat)) { - for (i = 0; i < height; i++) { - if (type == GL_UNSIGNED_INT) - pipe_get_tile_ui_format(pipe, trans, 0, y, width, 1, - pformat, dui); - else - pipe_get_tile_i_format(pipe, trans, 0, y, width, 1, - pformat, di); - y += yStep; - if (!dfStride) { - _mesa_pack_rgba_span_int(ctx, width, (GLuint (*)[4])temp, - format, type, dst); - dst += dstStride; - } - } - } else if (util_format_is_pure_uint(pformat)) { - for (i = 0; i < height; i++) { - if (type == GL_UNSIGNED_INT) - pipe_get_tile_ui_format(pipe, trans, 0, y, width, 1, - pformat, dui); - else - pipe_get_tile_i_format(pipe, trans, 0, y, width, 1, - pformat, di); - y += yStep; - df += dfStride; - if (!dfStride) { - _mesa_pack_rgba_span_int(ctx, width, (GLuint (*)[4])temp, - format, type, dst); - dst += dstStride; - } - } - } else { - /* RGBA format */ - /* Do a row at a time to flip image data vertically */ - for (i = 0; i < height; i++) { - pipe_get_tile_rgba_format(pipe, trans, 0, y, width, 1, - pformat, df); - y += yStep; - df += dfStride; - if (!dfStride) { - _mesa_pack_rgba_span_float(ctx, width, temp, format, type, dst, - &clippedPacking, transferOps); - dst += dstStride; - } - } - } - } - - free(temp); - - pipe->transfer_destroy(pipe, trans); - - _mesa_unmap_pbo_dest(ctx, &clippedPacking); + _mesa_readpixels(ctx, x, y, width, height, format, type, pack, dest); } diff --git a/mesalib/src/mesa/state_tracker/st_cb_readpixels.h b/mesalib/src/mesa/state_tracker/st_cb_readpixels.h index fba1a6540..fdc854782 100644 --- a/mesalib/src/mesa/state_tracker/st_cb_readpixels.h +++ b/mesalib/src/mesa/state_tracker/st_cb_readpixels.h @@ -1,52 +1,40 @@ -/************************************************************************** - * - * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas. - * All Rights Reserved. - * - * 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, sub license, 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 (including the - * next paragraph) 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 NON-INFRINGEMENT. - * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS 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 ST_CB_READPIXELS_H -#define ST_CB_READPIXELS_H - -#include "main/glheader.h" - -struct dd_function_table; -struct gl_context; -struct gl_pixelstore_attrib; - -extern struct st_renderbuffer * -st_get_color_read_renderbuffer(struct gl_context *ctx); - -extern void -st_read_stencil_pixels(struct gl_context *ctx, GLint x, GLint y, - GLsizei width, GLsizei height, - GLenum format, GLenum type, - const struct gl_pixelstore_attrib *packing, - GLvoid *pixels); - -extern void -st_init_readpixels_functions(struct dd_function_table *functions); - - -#endif /* ST_CB_READPIXELS_H */ +/************************************************************************** + * + * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas. + * All Rights Reserved. + * + * 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, sub license, 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 (including the + * next paragraph) 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 NON-INFRINGEMENT. + * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS 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 ST_CB_READPIXELS_H +#define ST_CB_READPIXELS_H + +#include "main/glheader.h" + +struct dd_function_table; + +extern void +st_init_readpixels_functions(struct dd_function_table *functions); + + +#endif /* ST_CB_READPIXELS_H */ diff --git a/mesalib/src/mesa/state_tracker/st_draw.c b/mesalib/src/mesa/state_tracker/st_draw.c index f2fbf4836..cb518e1af 100644 --- a/mesalib/src/mesa/state_tracker/st_draw.c +++ b/mesalib/src/mesa/state_tracker/st_draw.c @@ -436,8 +436,8 @@ setup_interleaved_attribs(struct gl_context *ctx, /* all interleaved arrays in a VBO */ struct st_buffer_object *stobj = st_buffer_object(bufobj); - if (!stobj) { - /* probably out of memory */ + if (!stobj || !stobj->buffer) { + /* probably out of memory (or zero-sized buffer) */ return GL_FALSE; } @@ -505,7 +505,7 @@ setup_non_interleaved_attribs(struct gl_context *ctx, struct st_buffer_object *stobj = st_buffer_object(bufobj); if (!stobj || !stobj->buffer) { - /* probably ran out of memory */ + /* probably out of memory (or zero-sized buffer) */ return GL_FALSE; } 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 b133164c3..0bf6766f7 100644 --- a/mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.cpp +++ b/mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.cpp @@ -2873,55 +2873,6 @@ count_resources(glsl_to_tgsi_visitor *v, gl_program *prog) _mesa_update_shader_textures_used(prog); } - -/** - * Check if the given vertex/fragment/shader program is within the - * resource limits of the context (number of texture units, etc). - * If any of those checks fail, record a linker error. - * - * XXX more checks are needed... - */ -static void -check_resources(const struct gl_context *ctx, - struct gl_shader_program *shader_program, - glsl_to_tgsi_visitor *prog, - struct gl_program *proginfo) -{ - switch (proginfo->Target) { - case GL_VERTEX_PROGRAM_ARB: - if (_mesa_bitcount(prog->samplers_used) > - ctx->Const.MaxVertexTextureImageUnits) { - fail_link(shader_program, "Too many vertex shader texture samplers"); - } - if (proginfo->Parameters->NumParameters > MAX_UNIFORMS) { - fail_link(shader_program, "Too many vertex shader constants"); - } - break; - case MESA_GEOMETRY_PROGRAM: - if (_mesa_bitcount(prog->samplers_used) > - ctx->Const.MaxGeometryTextureImageUnits) { - fail_link(shader_program, "Too many geometry shader texture samplers"); - } - if (proginfo->Parameters->NumParameters > - MAX_GEOMETRY_UNIFORM_COMPONENTS / 4) { - fail_link(shader_program, "Too many geometry shader constants"); - } - break; - case GL_FRAGMENT_PROGRAM_ARB: - if (_mesa_bitcount(prog->samplers_used) > - ctx->Const.MaxTextureImageUnits) { - fail_link(shader_program, "Too many fragment shader texture samplers"); - } - if (proginfo->Parameters->NumParameters > MAX_UNIFORMS) { - fail_link(shader_program, "Too many fragment shader constants"); - } - break; - default: - _mesa_problem(ctx, "unexpected program type in check_resources()"); - } -} - - static void set_uniform_initializer(struct gl_context *ctx, void *mem_ctx, struct gl_shader_program *shader_program, @@ -4015,6 +3966,7 @@ struct st_translate { /** Map Mesa's SYSTEM_VALUE_x to TGSI_SEMANTIC_x */ static unsigned mesa_sysval_to_semantic[SYSTEM_VALUE_MAX] = { TGSI_SEMANTIC_FACE, + TGSI_SEMANTIC_VERTEXID, TGSI_SEMANTIC_INSTANCEID }; @@ -4991,6 +4943,7 @@ get_mesa_program(struct gl_context *ctx, _mesa_print_ir(shader->ir, NULL); printf("\n"); printf("\n"); + fflush(stdout); } prog->Instructions = NULL; @@ -4999,8 +4952,6 @@ get_mesa_program(struct gl_context *ctx, do_set_program_inouts(shader->ir, prog, shader->Type == GL_FRAGMENT_SHADER); count_resources(v, prog); - check_resources(ctx, shader_program, v, prog); - _mesa_reference_program(ctx, &shader->Program, prog); /* This has to be done last. Any operation the can cause diff --git a/mesalib/src/mesa/state_tracker/st_mesa_to_tgsi.c b/mesalib/src/mesa/state_tracker/st_mesa_to_tgsi.c index 27ebb1ad7..ac615343a 100644 --- a/mesalib/src/mesa/state_tracker/st_mesa_to_tgsi.c +++ b/mesalib/src/mesa/state_tracker/st_mesa_to_tgsi.c @@ -108,6 +108,7 @@ struct st_translate { /** Map Mesa's SYSTEM_VALUE_x to TGSI_SEMANTIC_x */ static unsigned mesa_sysval_to_semantic[SYSTEM_VALUE_MAX] = { TGSI_SEMANTIC_FACE, + TGSI_SEMANTIC_VERTEXID, TGSI_SEMANTIC_INSTANCEID }; diff --git a/mesalib/src/mesa/swrast/s_copypix.c b/mesalib/src/mesa/swrast/s_copypix.c index e249e4ad5..3ba31f22c 100644 --- a/mesalib/src/mesa/swrast/s_copypix.c +++ b/mesalib/src/mesa/swrast/s_copypix.c @@ -1,720 +1,720 @@ -/* - * Mesa 3-D graphics library - * Version: 7.1 - * - * Copyright (C) 1999-2007 Brian Paul All Rights Reserved. - * - * 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 - * BRIAN PAUL 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 "main/glheader.h" -#include "main/context.h" -#include "main/colormac.h" -#include "main/condrender.h" -#include "main/macros.h" -#include "main/pixeltransfer.h" -#include "main/imports.h" - -#include "s_context.h" -#include "s_depth.h" -#include "s_span.h" -#include "s_stencil.h" -#include "s_zoom.h" - - - -/** - * Determine if there's overlap in an image copy. - * This test also compensates for the fact that copies are done from - * bottom to top and overlaps can sometimes be handled correctly - * without making a temporary image copy. - * \return GL_TRUE if the regions overlap, GL_FALSE otherwise. - */ -static GLboolean -regions_overlap(GLint srcx, GLint srcy, - GLint dstx, GLint dsty, - GLint width, GLint height, - GLfloat zoomX, GLfloat zoomY) -{ - if (zoomX == 1.0 && zoomY == 1.0) { - /* no zoom */ - if (srcx >= dstx + width || (srcx + width <= dstx)) { - return GL_FALSE; - } - else if (srcy < dsty) { /* this is OK */ - return GL_FALSE; - } - else if (srcy > dsty + height) { - return GL_FALSE; - } - else { - return GL_TRUE; - } - } - else { - /* add one pixel of slop when zooming, just to be safe */ - if (srcx > (dstx + ((zoomX > 0.0F) ? (width * zoomX + 1.0F) : 0.0F))) { - /* src is completely right of dest */ - return GL_FALSE; - } - else if (srcx + width + 1.0F < dstx + ((zoomX > 0.0F) ? 0.0F : (width * zoomX))) { - /* src is completely left of dest */ - return GL_FALSE; - } - else if ((srcy < dsty) && (srcy + height < dsty + (height * zoomY))) { - /* src is completely below dest */ - return GL_FALSE; - } - else if ((srcy > dsty) && (srcy + height > dsty + (height * zoomY))) { - /* src is completely above dest */ - return GL_FALSE; - } - else { - return GL_TRUE; - } - } -} - - -/** - * RGBA copypixels - */ -static void -copy_rgba_pixels(struct gl_context *ctx, GLint srcx, GLint srcy, - GLint width, GLint height, GLint destx, GLint desty) -{ - GLfloat *tmpImage, *p; - GLint sy, dy, stepy, row; - const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F; - GLint overlapping; - GLuint transferOps = ctx->_ImageTransferState; - SWspan span; - - if (!ctx->ReadBuffer->_ColorReadBuffer) { - /* no readbuffer - OK */ - return; - } - - if (ctx->DrawBuffer == ctx->ReadBuffer) { - overlapping = regions_overlap(srcx, srcy, destx, desty, width, height, - ctx->Pixel.ZoomX, ctx->Pixel.ZoomY); - } - else { - overlapping = GL_FALSE; - } - - /* Determine if copy should be done bottom-to-top or top-to-bottom */ - if (!overlapping && srcy < desty) { - /* top-down max-to-min */ - sy = srcy + height - 1; - dy = desty + height - 1; - stepy = -1; - } - else { - /* bottom-up min-to-max */ - sy = srcy; - dy = desty; - stepy = 1; - } - - INIT_SPAN(span, GL_BITMAP); - _swrast_span_default_attribs(ctx, &span); - span.arrayMask = SPAN_RGBA; - span.arrayAttribs = FRAG_BIT_COL0; /* we'll fill in COL0 attrib values */ - - if (overlapping) { - tmpImage = (GLfloat *) malloc(width * height * sizeof(GLfloat) * 4); - if (!tmpImage) { - _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" ); - return; - } - /* read the source image as RGBA/float */ - p = tmpImage; - for (row = 0; row < height; row++) { - _swrast_read_rgba_span( ctx, ctx->ReadBuffer->_ColorReadBuffer, - width, srcx, sy + row, GL_FLOAT, p ); - p += width * 4; - } - p = tmpImage; - } - else { - tmpImage = NULL; /* silence compiler warnings */ - p = NULL; - } - - ASSERT(width < MAX_WIDTH); - - for (row = 0; row < height; row++, sy += stepy, dy += stepy) { - GLvoid *rgba = span.array->attribs[FRAG_ATTRIB_COL0]; - - /* Get row/span of source pixels */ - if (overlapping) { - /* get from buffered image */ - memcpy(rgba, p, width * sizeof(GLfloat) * 4); - p += width * 4; - } - else { - /* get from framebuffer */ - _swrast_read_rgba_span( ctx, ctx->ReadBuffer->_ColorReadBuffer, - width, srcx, sy, GL_FLOAT, rgba ); - } - - if (transferOps) { - _mesa_apply_rgba_transfer_ops(ctx, transferOps, width, - (GLfloat (*)[4]) rgba); - } - - /* Write color span */ - span.x = destx; - span.y = dy; - span.end = width; - span.array->ChanType = GL_FLOAT; - if (zoom) { - _swrast_write_zoomed_rgba_span(ctx, destx, desty, &span, rgba); - } - else { - _swrast_write_rgba_span(ctx, &span); - } - } - - span.array->ChanType = CHAN_TYPE; /* restore */ - - if (overlapping) - free(tmpImage); -} - - -/** - * Convert floating point Z values to integer Z values with pixel transfer's - * Z scale and bias. - */ -static void -scale_and_bias_z(struct gl_context *ctx, GLuint width, - const GLfloat depth[], GLuint z[]) -{ - const GLuint depthMax = ctx->DrawBuffer->_DepthMax; - GLuint i; - - if (depthMax <= 0xffffff && - ctx->Pixel.DepthScale == 1.0 && - ctx->Pixel.DepthBias == 0.0) { - /* no scale or bias and no clamping and no worry of overflow */ - const GLfloat depthMaxF = ctx->DrawBuffer->_DepthMaxF; - for (i = 0; i < width; i++) { - z[i] = (GLuint) (depth[i] * depthMaxF); - } - } - else { - /* need to be careful with overflow */ - const GLdouble depthMaxF = ctx->DrawBuffer->_DepthMaxF; - for (i = 0; i < width; i++) { - GLdouble d = depth[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias; - d = CLAMP(d, 0.0, 1.0) * depthMaxF; - if (d >= depthMaxF) - z[i] = depthMax; - else - z[i] = (GLuint) d; - } - } -} - - - -/* - * TODO: Optimize!!!! - */ -static void -copy_depth_pixels( struct gl_context *ctx, GLint srcx, GLint srcy, - GLint width, GLint height, - GLint destx, GLint desty ) -{ - struct gl_framebuffer *fb = ctx->ReadBuffer; - struct gl_renderbuffer *readRb = fb->_DepthBuffer; - GLfloat *p, *tmpImage; - GLint sy, dy, stepy; - GLint j; - const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F; - GLint overlapping; - SWspan span; - - if (!readRb) { - /* no readbuffer - OK */ - return; - } - - INIT_SPAN(span, GL_BITMAP); - _swrast_span_default_attribs(ctx, &span); - span.arrayMask = SPAN_Z; - - if (ctx->DrawBuffer == ctx->ReadBuffer) { - overlapping = regions_overlap(srcx, srcy, destx, desty, width, height, - ctx->Pixel.ZoomX, ctx->Pixel.ZoomY); - } - else { - overlapping = GL_FALSE; - } - - /* Determine if copy should be bottom-to-top or top-to-bottom */ - if (!overlapping && srcy < desty) { - /* top-down max-to-min */ - sy = srcy + height - 1; - dy = desty + height - 1; - stepy = -1; - } - else { - /* bottom-up min-to-max */ - sy = srcy; - dy = desty; - stepy = 1; - } - - if (overlapping) { - GLint ssy = sy; - tmpImage = (GLfloat *) malloc(width * height * sizeof(GLfloat)); - if (!tmpImage) { - _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" ); - return; - } - p = tmpImage; - for (j = 0; j < height; j++, ssy += stepy) { - _swrast_read_depth_span_float(ctx, readRb, width, srcx, ssy, p); - p += width; - } - p = tmpImage; - } - else { - tmpImage = NULL; /* silence compiler warning */ - p = NULL; - } - - for (j = 0; j < height; j++, sy += stepy, dy += stepy) { - GLfloat depth[MAX_WIDTH]; - /* get depth values */ - if (overlapping) { - memcpy(depth, p, width * sizeof(GLfloat)); - p += width; - } - else { - _swrast_read_depth_span_float(ctx, readRb, width, srcx, sy, depth); - } - - /* apply scale and bias */ - scale_and_bias_z(ctx, width, depth, span.array->z); - - /* write depth values */ - span.x = destx; - span.y = dy; - span.end = width; - if (zoom) - _swrast_write_zoomed_depth_span(ctx, destx, desty, &span); - else - _swrast_write_rgba_span(ctx, &span); - } - - if (overlapping) - free(tmpImage); -} - - - -static void -copy_stencil_pixels( struct gl_context *ctx, GLint srcx, GLint srcy, - GLint width, GLint height, - GLint destx, GLint desty ) -{ - struct gl_framebuffer *fb = ctx->ReadBuffer; - struct gl_renderbuffer *rb = fb->_StencilBuffer; - GLint sy, dy, stepy; - GLint j; - GLstencil *p, *tmpImage; - const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F; - GLint overlapping; - - if (!rb) { - /* no readbuffer - OK */ - return; - } - - if (ctx->DrawBuffer == ctx->ReadBuffer) { - overlapping = regions_overlap(srcx, srcy, destx, desty, width, height, - ctx->Pixel.ZoomX, ctx->Pixel.ZoomY); - } - else { - overlapping = GL_FALSE; - } - - /* Determine if copy should be bottom-to-top or top-to-bottom */ - if (!overlapping && srcy < desty) { - /* top-down max-to-min */ - sy = srcy + height - 1; - dy = desty + height - 1; - stepy = -1; - } - else { - /* bottom-up min-to-max */ - sy = srcy; - dy = desty; - stepy = 1; - } - - if (overlapping) { - GLint ssy = sy; - tmpImage = (GLstencil *) malloc(width * height * sizeof(GLstencil)); - if (!tmpImage) { - _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" ); - return; - } - p = tmpImage; - for (j = 0; j < height; j++, ssy += stepy) { - _swrast_read_stencil_span( ctx, rb, width, srcx, ssy, p ); - p += width; - } - p = tmpImage; - } - else { - tmpImage = NULL; /* silence compiler warning */ - p = NULL; - } - - for (j = 0; j < height; j++, sy += stepy, dy += stepy) { - GLstencil stencil[MAX_WIDTH]; - - /* Get stencil values */ - if (overlapping) { - memcpy(stencil, p, width * sizeof(GLstencil)); - p += width; - } - else { - _swrast_read_stencil_span( ctx, rb, width, srcx, sy, stencil ); - } - - _mesa_apply_stencil_transfer_ops(ctx, width, stencil); - - /* Write stencil values */ - if (zoom) { - _swrast_write_zoomed_stencil_span(ctx, destx, desty, width, - destx, dy, stencil); - } - else { - _swrast_write_stencil_span( ctx, width, destx, dy, stencil ); - } - } - - if (overlapping) - free(tmpImage); -} - - -/** - * This isn't terribly efficient. If a driver really has combined - * depth/stencil buffers the driver should implement an optimized - * CopyPixels function. - */ -static void -copy_depth_stencil_pixels(struct gl_context *ctx, - const GLint srcX, const GLint srcY, - const GLint width, const GLint height, - const GLint destX, const GLint destY) -{ - struct gl_renderbuffer *stencilReadRb, *depthReadRb, *depthDrawRb; - GLint sy, dy, stepy; - GLint j; - GLstencil *tempStencilImage = NULL, *stencilPtr = NULL; - GLfloat *tempDepthImage = NULL, *depthPtr = NULL; - const GLfloat depthScale = ctx->DrawBuffer->_DepthMaxF; - const GLuint stencilMask = ctx->Stencil.WriteMask[0]; - const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F; - const GLboolean scaleOrBias - = ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0; - GLint overlapping; - - depthDrawRb = ctx->DrawBuffer->_DepthBuffer; - depthReadRb = ctx->ReadBuffer->_DepthBuffer; - stencilReadRb = ctx->ReadBuffer->_StencilBuffer; - - ASSERT(depthDrawRb); - ASSERT(depthReadRb); - ASSERT(stencilReadRb); - - if (ctx->DrawBuffer == ctx->ReadBuffer) { - overlapping = regions_overlap(srcX, srcY, destX, destY, width, height, - ctx->Pixel.ZoomX, ctx->Pixel.ZoomY); - } - else { - overlapping = GL_FALSE; - } - - /* Determine if copy should be bottom-to-top or top-to-bottom */ - if (!overlapping && srcY < destY) { - /* top-down max-to-min */ - sy = srcY + height - 1; - dy = destY + height - 1; - stepy = -1; - } - else { - /* bottom-up min-to-max */ - sy = srcY; - dy = destY; - stepy = 1; - } - - if (overlapping) { - GLint ssy = sy; - - if (stencilMask != 0x0) { - tempStencilImage - = (GLstencil *) malloc(width * height * sizeof(GLstencil)); - if (!tempStencilImage) { - _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels"); - return; - } - - /* get copy of stencil pixels */ - stencilPtr = tempStencilImage; - for (j = 0; j < height; j++, ssy += stepy) { - _swrast_read_stencil_span(ctx, stencilReadRb, - width, srcX, ssy, stencilPtr); - stencilPtr += width; - } - stencilPtr = tempStencilImage; - } - - if (ctx->Depth.Mask) { - tempDepthImage - = (GLfloat *) malloc(width * height * sizeof(GLfloat)); - if (!tempDepthImage) { - _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels"); - free(tempStencilImage); - return; - } - - /* get copy of depth pixels */ - depthPtr = tempDepthImage; - for (j = 0; j < height; j++, ssy += stepy) { - _swrast_read_depth_span_float(ctx, depthReadRb, - width, srcX, ssy, depthPtr); - depthPtr += width; - } - depthPtr = tempDepthImage; - } - } - - for (j = 0; j < height; j++, sy += stepy, dy += stepy) { - if (stencilMask != 0x0) { - GLstencil stencil[MAX_WIDTH]; - - /* Get stencil values */ - if (overlapping) { - memcpy(stencil, stencilPtr, width * sizeof(GLstencil)); - stencilPtr += width; - } - else { - _swrast_read_stencil_span(ctx, stencilReadRb, - width, srcX, sy, stencil); - } - - _mesa_apply_stencil_transfer_ops(ctx, width, stencil); - - /* Write values */ - if (zoom) { - _swrast_write_zoomed_stencil_span(ctx, destX, destY, width, - destX, dy, stencil); - } - else { - _swrast_write_stencil_span( ctx, width, destX, dy, stencil ); - } - } - - if (ctx->Depth.Mask) { - GLfloat depth[MAX_WIDTH]; - GLuint zVals32[MAX_WIDTH]; - GLushort zVals16[MAX_WIDTH]; - GLvoid *zVals; - GLuint zBytes; - - /* get depth values */ - if (overlapping) { - memcpy(depth, depthPtr, width * sizeof(GLfloat)); - depthPtr += width; - } - else { - _swrast_read_depth_span_float(ctx, depthReadRb, - width, srcX, sy, depth); - } - - /* scale & bias */ - if (scaleOrBias) { - _mesa_scale_and_bias_depth(ctx, width, depth); - } - /* convert to integer Z values */ - if (depthDrawRb->DataType == GL_UNSIGNED_SHORT) { - GLint k; - for (k = 0; k < width; k++) - zVals16[k] = (GLushort) (depth[k] * depthScale); - zVals = zVals16; - zBytes = 2; - } - else { - GLint k; - for (k = 0; k < width; k++) - zVals32[k] = (GLuint) (depth[k] * depthScale); - zVals = zVals32; - zBytes = 4; - } - - /* Write values */ - if (zoom) { - _swrast_write_zoomed_z_span(ctx, destX, destY, width, - destX, dy, zVals); - } - else { - _swrast_put_row(ctx, depthDrawRb, width, destX, dy, zVals, zBytes); - } - } - } - - if (tempStencilImage) - free(tempStencilImage); - - if (tempDepthImage) - free(tempDepthImage); -} - - - -/** - * Try to do a fast copy pixels. - */ -static GLboolean -fast_copy_pixels(struct gl_context *ctx, - GLint srcX, GLint srcY, GLsizei width, GLsizei height, - GLint dstX, GLint dstY, GLenum type) -{ - struct gl_framebuffer *srcFb = ctx->ReadBuffer; - struct gl_framebuffer *dstFb = ctx->DrawBuffer; - struct gl_renderbuffer *srcRb, *dstRb; - GLint row, yStep; - - if (SWRAST_CONTEXT(ctx)->_RasterMask != 0x0 || - ctx->Pixel.ZoomX != 1.0F || - ctx->Pixel.ZoomY != 1.0F || - ctx->_ImageTransferState) { - /* can't handle these */ - return GL_FALSE; - } - - if (type == GL_COLOR) { - if (dstFb->_NumColorDrawBuffers != 1) - return GL_FALSE; - srcRb = srcFb->_ColorReadBuffer; - dstRb = dstFb->_ColorDrawBuffers[0]; - } - else if (type == GL_STENCIL) { - srcRb = srcFb->_StencilBuffer; - dstRb = dstFb->_StencilBuffer; - } - else if (type == GL_DEPTH) { - srcRb = srcFb->_DepthBuffer; - dstRb = dstFb->_DepthBuffer; - } - else { - ASSERT(type == GL_DEPTH_STENCIL_EXT); - /* XXX correct? */ - srcRb = srcFb->Attachment[BUFFER_DEPTH].Renderbuffer; - dstRb = dstFb->Attachment[BUFFER_DEPTH].Renderbuffer; - } - - /* src and dst renderbuffers must be same format and type */ - if (!srcRb || !dstRb || - srcRb->DataType != dstRb->DataType || - srcRb->_BaseFormat != dstRb->_BaseFormat) { - return GL_FALSE; - } - - /* clipping not supported */ - if (srcX < 0 || srcX + width > (GLint) srcFb->Width || - srcY < 0 || srcY + height > (GLint) srcFb->Height || - dstX < dstFb->_Xmin || dstX + width > dstFb->_Xmax || - dstY < dstFb->_Ymin || dstY + height > dstFb->_Ymax) { - return GL_FALSE; - } - - /* overlapping src/dst doesn't matter, just determine Y direction */ - if (srcY < dstY) { - /* top-down max-to-min */ - srcY = srcY + height - 1; - dstY = dstY + height - 1; - yStep = -1; - } - else { - /* bottom-up min-to-max */ - yStep = 1; - } - - for (row = 0; row < height; row++) { - GLuint temp[MAX_WIDTH][4]; - srcRb->GetRow(ctx, srcRb, width, srcX, srcY, temp); - dstRb->PutRow(ctx, dstRb, width, dstX, dstY, temp, NULL); - srcY += yStep; - dstY += yStep; - } - - return GL_TRUE; -} - - -/** - * Do software-based glCopyPixels. - * By time we get here, all parameters will have been error-checked. - */ -void -_swrast_CopyPixels( struct gl_context *ctx, - GLint srcx, GLint srcy, GLsizei width, GLsizei height, - GLint destx, GLint desty, GLenum type ) -{ - SWcontext *swrast = SWRAST_CONTEXT(ctx); - swrast_render_start(ctx); - - if (!_mesa_check_conditional_render(ctx)) - return; /* don't copy */ - - if (swrast->NewState) - _swrast_validate_derived( ctx ); - - if (!fast_copy_pixels(ctx, srcx, srcy, width, height, destx, desty, type)) { - switch (type) { - case GL_COLOR: - copy_rgba_pixels( ctx, srcx, srcy, width, height, destx, desty ); - break; - case GL_DEPTH: - copy_depth_pixels( ctx, srcx, srcy, width, height, destx, desty ); - break; - case GL_STENCIL: - copy_stencil_pixels( ctx, srcx, srcy, width, height, destx, desty ); - break; - case GL_DEPTH_STENCIL_EXT: - copy_depth_stencil_pixels(ctx, srcx, srcy, width, height, destx, desty); - break; - default: - _mesa_problem(ctx, "unexpected type in _swrast_CopyPixels"); - } - } - - swrast_render_finish(ctx); -} +/* + * Mesa 3-D graphics library + * Version: 7.1 + * + * Copyright (C) 1999-2007 Brian Paul All Rights Reserved. + * + * 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 + * BRIAN PAUL 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 "main/glheader.h" +#include "main/context.h" +#include "main/colormac.h" +#include "main/condrender.h" +#include "main/macros.h" +#include "main/pixeltransfer.h" +#include "main/imports.h" + +#include "s_context.h" +#include "s_depth.h" +#include "s_span.h" +#include "s_stencil.h" +#include "s_zoom.h" + + + +/** + * Determine if there's overlap in an image copy. + * This test also compensates for the fact that copies are done from + * bottom to top and overlaps can sometimes be handled correctly + * without making a temporary image copy. + * \return GL_TRUE if the regions overlap, GL_FALSE otherwise. + */ +static GLboolean +regions_overlap(GLint srcx, GLint srcy, + GLint dstx, GLint dsty, + GLint width, GLint height, + GLfloat zoomX, GLfloat zoomY) +{ + if (zoomX == 1.0 && zoomY == 1.0) { + /* no zoom */ + if (srcx >= dstx + width || (srcx + width <= dstx)) { + return GL_FALSE; + } + else if (srcy < dsty) { /* this is OK */ + return GL_FALSE; + } + else if (srcy > dsty + height) { + return GL_FALSE; + } + else { + return GL_TRUE; + } + } + else { + /* add one pixel of slop when zooming, just to be safe */ + if (srcx > (dstx + ((zoomX > 0.0F) ? (width * zoomX + 1.0F) : 0.0F))) { + /* src is completely right of dest */ + return GL_FALSE; + } + else if (srcx + width + 1.0F < dstx + ((zoomX > 0.0F) ? 0.0F : (width * zoomX))) { + /* src is completely left of dest */ + return GL_FALSE; + } + else if ((srcy < dsty) && (srcy + height < dsty + (height * zoomY))) { + /* src is completely below dest */ + return GL_FALSE; + } + else if ((srcy > dsty) && (srcy + height > dsty + (height * zoomY))) { + /* src is completely above dest */ + return GL_FALSE; + } + else { + return GL_TRUE; + } + } +} + + +/** + * RGBA copypixels + */ +static void +copy_rgba_pixels(struct gl_context *ctx, GLint srcx, GLint srcy, + GLint width, GLint height, GLint destx, GLint desty) +{ + GLfloat *tmpImage, *p; + GLint sy, dy, stepy, row; + const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F; + GLint overlapping; + GLuint transferOps = ctx->_ImageTransferState; + SWspan span; + + if (!ctx->ReadBuffer->_ColorReadBuffer) { + /* no readbuffer - OK */ + return; + } + + if (ctx->DrawBuffer == ctx->ReadBuffer) { + overlapping = regions_overlap(srcx, srcy, destx, desty, width, height, + ctx->Pixel.ZoomX, ctx->Pixel.ZoomY); + } + else { + overlapping = GL_FALSE; + } + + /* Determine if copy should be done bottom-to-top or top-to-bottom */ + if (!overlapping && srcy < desty) { + /* top-down max-to-min */ + sy = srcy + height - 1; + dy = desty + height - 1; + stepy = -1; + } + else { + /* bottom-up min-to-max */ + sy = srcy; + dy = desty; + stepy = 1; + } + + INIT_SPAN(span, GL_BITMAP); + _swrast_span_default_attribs(ctx, &span); + span.arrayMask = SPAN_RGBA; + span.arrayAttribs = FRAG_BIT_COL0; /* we'll fill in COL0 attrib values */ + + if (overlapping) { + tmpImage = (GLfloat *) malloc(width * height * sizeof(GLfloat) * 4); + if (!tmpImage) { + _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" ); + return; + } + /* read the source image as RGBA/float */ + p = tmpImage; + for (row = 0; row < height; row++) { + _swrast_read_rgba_span( ctx, ctx->ReadBuffer->_ColorReadBuffer, + width, srcx, sy + row, GL_FLOAT, p ); + p += width * 4; + } + p = tmpImage; + } + else { + tmpImage = NULL; /* silence compiler warnings */ + p = NULL; + } + + ASSERT(width < MAX_WIDTH); + + for (row = 0; row < height; row++, sy += stepy, dy += stepy) { + GLvoid *rgba = span.array->attribs[FRAG_ATTRIB_COL0]; + + /* Get row/span of source pixels */ + if (overlapping) { + /* get from buffered image */ + memcpy(rgba, p, width * sizeof(GLfloat) * 4); + p += width * 4; + } + else { + /* get from framebuffer */ + _swrast_read_rgba_span( ctx, ctx->ReadBuffer->_ColorReadBuffer, + width, srcx, sy, GL_FLOAT, rgba ); + } + + if (transferOps) { + _mesa_apply_rgba_transfer_ops(ctx, transferOps, width, + (GLfloat (*)[4]) rgba); + } + + /* Write color span */ + span.x = destx; + span.y = dy; + span.end = width; + span.array->ChanType = GL_FLOAT; + if (zoom) { + _swrast_write_zoomed_rgba_span(ctx, destx, desty, &span, rgba); + } + else { + _swrast_write_rgba_span(ctx, &span); + } + } + + span.array->ChanType = CHAN_TYPE; /* restore */ + + if (overlapping) + free(tmpImage); +} + + +/** + * Convert floating point Z values to integer Z values with pixel transfer's + * Z scale and bias. + */ +static void +scale_and_bias_z(struct gl_context *ctx, GLuint width, + const GLfloat depth[], GLuint z[]) +{ + const GLuint depthMax = ctx->DrawBuffer->_DepthMax; + GLuint i; + + if (depthMax <= 0xffffff && + ctx->Pixel.DepthScale == 1.0 && + ctx->Pixel.DepthBias == 0.0) { + /* no scale or bias and no clamping and no worry of overflow */ + const GLfloat depthMaxF = ctx->DrawBuffer->_DepthMaxF; + for (i = 0; i < width; i++) { + z[i] = (GLuint) (depth[i] * depthMaxF); + } + } + else { + /* need to be careful with overflow */ + const GLdouble depthMaxF = ctx->DrawBuffer->_DepthMaxF; + for (i = 0; i < width; i++) { + GLdouble d = depth[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias; + d = CLAMP(d, 0.0, 1.0) * depthMaxF; + if (d >= depthMaxF) + z[i] = depthMax; + else + z[i] = (GLuint) d; + } + } +} + + + +/* + * TODO: Optimize!!!! + */ +static void +copy_depth_pixels( struct gl_context *ctx, GLint srcx, GLint srcy, + GLint width, GLint height, + GLint destx, GLint desty ) +{ + struct gl_framebuffer *fb = ctx->ReadBuffer; + struct gl_renderbuffer *readRb = fb->_DepthBuffer; + GLfloat *p, *tmpImage; + GLint sy, dy, stepy; + GLint j; + const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F; + GLint overlapping; + SWspan span; + + if (!readRb) { + /* no readbuffer - OK */ + return; + } + + INIT_SPAN(span, GL_BITMAP); + _swrast_span_default_attribs(ctx, &span); + span.arrayMask = SPAN_Z; + + if (ctx->DrawBuffer == ctx->ReadBuffer) { + overlapping = regions_overlap(srcx, srcy, destx, desty, width, height, + ctx->Pixel.ZoomX, ctx->Pixel.ZoomY); + } + else { + overlapping = GL_FALSE; + } + + /* Determine if copy should be bottom-to-top or top-to-bottom */ + if (!overlapping && srcy < desty) { + /* top-down max-to-min */ + sy = srcy + height - 1; + dy = desty + height - 1; + stepy = -1; + } + else { + /* bottom-up min-to-max */ + sy = srcy; + dy = desty; + stepy = 1; + } + + if (overlapping) { + GLint ssy = sy; + tmpImage = (GLfloat *) malloc(width * height * sizeof(GLfloat)); + if (!tmpImage) { + _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" ); + return; + } + p = tmpImage; + for (j = 0; j < height; j++, ssy += stepy) { + _swrast_read_depth_span_float(ctx, readRb, width, srcx, ssy, p); + p += width; + } + p = tmpImage; + } + else { + tmpImage = NULL; /* silence compiler warning */ + p = NULL; + } + + for (j = 0; j < height; j++, sy += stepy, dy += stepy) { + GLfloat depth[MAX_WIDTH]; + /* get depth values */ + if (overlapping) { + memcpy(depth, p, width * sizeof(GLfloat)); + p += width; + } + else { + _swrast_read_depth_span_float(ctx, readRb, width, srcx, sy, depth); + } + + /* apply scale and bias */ + scale_and_bias_z(ctx, width, depth, span.array->z); + + /* write depth values */ + span.x = destx; + span.y = dy; + span.end = width; + if (zoom) + _swrast_write_zoomed_depth_span(ctx, destx, desty, &span); + else + _swrast_write_rgba_span(ctx, &span); + } + + if (overlapping) + free(tmpImage); +} + + + +static void +copy_stencil_pixels( struct gl_context *ctx, GLint srcx, GLint srcy, + GLint width, GLint height, + GLint destx, GLint desty ) +{ + struct gl_framebuffer *fb = ctx->ReadBuffer; + struct gl_renderbuffer *rb = fb->_StencilBuffer; + GLint sy, dy, stepy; + GLint j; + GLubyte *p, *tmpImage; + const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F; + GLint overlapping; + + if (!rb) { + /* no readbuffer - OK */ + return; + } + + if (ctx->DrawBuffer == ctx->ReadBuffer) { + overlapping = regions_overlap(srcx, srcy, destx, desty, width, height, + ctx->Pixel.ZoomX, ctx->Pixel.ZoomY); + } + else { + overlapping = GL_FALSE; + } + + /* Determine if copy should be bottom-to-top or top-to-bottom */ + if (!overlapping && srcy < desty) { + /* top-down max-to-min */ + sy = srcy + height - 1; + dy = desty + height - 1; + stepy = -1; + } + else { + /* bottom-up min-to-max */ + sy = srcy; + dy = desty; + stepy = 1; + } + + if (overlapping) { + GLint ssy = sy; + tmpImage = (GLubyte *) malloc(width * height * sizeof(GLubyte)); + if (!tmpImage) { + _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" ); + return; + } + p = tmpImage; + for (j = 0; j < height; j++, ssy += stepy) { + _swrast_read_stencil_span( ctx, rb, width, srcx, ssy, p ); + p += width; + } + p = tmpImage; + } + else { + tmpImage = NULL; /* silence compiler warning */ + p = NULL; + } + + for (j = 0; j < height; j++, sy += stepy, dy += stepy) { + GLubyte stencil[MAX_WIDTH]; + + /* Get stencil values */ + if (overlapping) { + memcpy(stencil, p, width * sizeof(GLubyte)); + p += width; + } + else { + _swrast_read_stencil_span( ctx, rb, width, srcx, sy, stencil ); + } + + _mesa_apply_stencil_transfer_ops(ctx, width, stencil); + + /* Write stencil values */ + if (zoom) { + _swrast_write_zoomed_stencil_span(ctx, destx, desty, width, + destx, dy, stencil); + } + else { + _swrast_write_stencil_span( ctx, width, destx, dy, stencil ); + } + } + + if (overlapping) + free(tmpImage); +} + + +/** + * This isn't terribly efficient. If a driver really has combined + * depth/stencil buffers the driver should implement an optimized + * CopyPixels function. + */ +static void +copy_depth_stencil_pixels(struct gl_context *ctx, + const GLint srcX, const GLint srcY, + const GLint width, const GLint height, + const GLint destX, const GLint destY) +{ + struct gl_renderbuffer *stencilReadRb, *depthReadRb, *depthDrawRb; + GLint sy, dy, stepy; + GLint j; + GLubyte *tempStencilImage = NULL, *stencilPtr = NULL; + GLfloat *tempDepthImage = NULL, *depthPtr = NULL; + const GLfloat depthScale = ctx->DrawBuffer->_DepthMaxF; + const GLuint stencilMask = ctx->Stencil.WriteMask[0]; + const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F; + const GLboolean scaleOrBias + = ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0; + GLint overlapping; + + depthDrawRb = ctx->DrawBuffer->_DepthBuffer; + depthReadRb = ctx->ReadBuffer->_DepthBuffer; + stencilReadRb = ctx->ReadBuffer->_StencilBuffer; + + ASSERT(depthDrawRb); + ASSERT(depthReadRb); + ASSERT(stencilReadRb); + + if (ctx->DrawBuffer == ctx->ReadBuffer) { + overlapping = regions_overlap(srcX, srcY, destX, destY, width, height, + ctx->Pixel.ZoomX, ctx->Pixel.ZoomY); + } + else { + overlapping = GL_FALSE; + } + + /* Determine if copy should be bottom-to-top or top-to-bottom */ + if (!overlapping && srcY < destY) { + /* top-down max-to-min */ + sy = srcY + height - 1; + dy = destY + height - 1; + stepy = -1; + } + else { + /* bottom-up min-to-max */ + sy = srcY; + dy = destY; + stepy = 1; + } + + if (overlapping) { + GLint ssy = sy; + + if (stencilMask != 0x0) { + tempStencilImage + = (GLubyte *) malloc(width * height * sizeof(GLubyte)); + if (!tempStencilImage) { + _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels"); + return; + } + + /* get copy of stencil pixels */ + stencilPtr = tempStencilImage; + for (j = 0; j < height; j++, ssy += stepy) { + _swrast_read_stencil_span(ctx, stencilReadRb, + width, srcX, ssy, stencilPtr); + stencilPtr += width; + } + stencilPtr = tempStencilImage; + } + + if (ctx->Depth.Mask) { + tempDepthImage + = (GLfloat *) malloc(width * height * sizeof(GLfloat)); + if (!tempDepthImage) { + _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels"); + free(tempStencilImage); + return; + } + + /* get copy of depth pixels */ + depthPtr = tempDepthImage; + for (j = 0; j < height; j++, ssy += stepy) { + _swrast_read_depth_span_float(ctx, depthReadRb, + width, srcX, ssy, depthPtr); + depthPtr += width; + } + depthPtr = tempDepthImage; + } + } + + for (j = 0; j < height; j++, sy += stepy, dy += stepy) { + if (stencilMask != 0x0) { + GLubyte stencil[MAX_WIDTH]; + + /* Get stencil values */ + if (overlapping) { + memcpy(stencil, stencilPtr, width * sizeof(GLubyte)); + stencilPtr += width; + } + else { + _swrast_read_stencil_span(ctx, stencilReadRb, + width, srcX, sy, stencil); + } + + _mesa_apply_stencil_transfer_ops(ctx, width, stencil); + + /* Write values */ + if (zoom) { + _swrast_write_zoomed_stencil_span(ctx, destX, destY, width, + destX, dy, stencil); + } + else { + _swrast_write_stencil_span( ctx, width, destX, dy, stencil ); + } + } + + if (ctx->Depth.Mask) { + GLfloat depth[MAX_WIDTH]; + GLuint zVals32[MAX_WIDTH]; + GLushort zVals16[MAX_WIDTH]; + GLvoid *zVals; + GLuint zBytes; + + /* get depth values */ + if (overlapping) { + memcpy(depth, depthPtr, width * sizeof(GLfloat)); + depthPtr += width; + } + else { + _swrast_read_depth_span_float(ctx, depthReadRb, + width, srcX, sy, depth); + } + + /* scale & bias */ + if (scaleOrBias) { + _mesa_scale_and_bias_depth(ctx, width, depth); + } + /* convert to integer Z values */ + if (depthDrawRb->DataType == GL_UNSIGNED_SHORT) { + GLint k; + for (k = 0; k < width; k++) + zVals16[k] = (GLushort) (depth[k] * depthScale); + zVals = zVals16; + zBytes = 2; + } + else { + GLint k; + for (k = 0; k < width; k++) + zVals32[k] = (GLuint) (depth[k] * depthScale); + zVals = zVals32; + zBytes = 4; + } + + /* Write values */ + if (zoom) { + _swrast_write_zoomed_z_span(ctx, destX, destY, width, + destX, dy, zVals); + } + else { + _swrast_put_row(ctx, depthDrawRb, width, destX, dy, zVals, zBytes); + } + } + } + + if (tempStencilImage) + free(tempStencilImage); + + if (tempDepthImage) + free(tempDepthImage); +} + + + +/** + * Try to do a fast copy pixels. + */ +static GLboolean +fast_copy_pixels(struct gl_context *ctx, + GLint srcX, GLint srcY, GLsizei width, GLsizei height, + GLint dstX, GLint dstY, GLenum type) +{ + struct gl_framebuffer *srcFb = ctx->ReadBuffer; + struct gl_framebuffer *dstFb = ctx->DrawBuffer; + struct gl_renderbuffer *srcRb, *dstRb; + GLint row, yStep; + + if (SWRAST_CONTEXT(ctx)->_RasterMask != 0x0 || + ctx->Pixel.ZoomX != 1.0F || + ctx->Pixel.ZoomY != 1.0F || + ctx->_ImageTransferState) { + /* can't handle these */ + return GL_FALSE; + } + + if (type == GL_COLOR) { + if (dstFb->_NumColorDrawBuffers != 1) + return GL_FALSE; + srcRb = srcFb->_ColorReadBuffer; + dstRb = dstFb->_ColorDrawBuffers[0]; + } + else if (type == GL_STENCIL) { + srcRb = srcFb->_StencilBuffer; + dstRb = dstFb->_StencilBuffer; + } + else if (type == GL_DEPTH) { + srcRb = srcFb->_DepthBuffer; + dstRb = dstFb->_DepthBuffer; + } + else { + ASSERT(type == GL_DEPTH_STENCIL_EXT); + /* XXX correct? */ + srcRb = srcFb->Attachment[BUFFER_DEPTH].Renderbuffer; + dstRb = dstFb->Attachment[BUFFER_DEPTH].Renderbuffer; + } + + /* src and dst renderbuffers must be same format and type */ + if (!srcRb || !dstRb || + srcRb->DataType != dstRb->DataType || + srcRb->_BaseFormat != dstRb->_BaseFormat) { + return GL_FALSE; + } + + /* clipping not supported */ + if (srcX < 0 || srcX + width > (GLint) srcFb->Width || + srcY < 0 || srcY + height > (GLint) srcFb->Height || + dstX < dstFb->_Xmin || dstX + width > dstFb->_Xmax || + dstY < dstFb->_Ymin || dstY + height > dstFb->_Ymax) { + return GL_FALSE; + } + + /* overlapping src/dst doesn't matter, just determine Y direction */ + if (srcY < dstY) { + /* top-down max-to-min */ + srcY = srcY + height - 1; + dstY = dstY + height - 1; + yStep = -1; + } + else { + /* bottom-up min-to-max */ + yStep = 1; + } + + for (row = 0; row < height; row++) { + GLuint temp[MAX_WIDTH][4]; + srcRb->GetRow(ctx, srcRb, width, srcX, srcY, temp); + dstRb->PutRow(ctx, dstRb, width, dstX, dstY, temp, NULL); + srcY += yStep; + dstY += yStep; + } + + return GL_TRUE; +} + + +/** + * Do software-based glCopyPixels. + * By time we get here, all parameters will have been error-checked. + */ +void +_swrast_CopyPixels( struct gl_context *ctx, + GLint srcx, GLint srcy, GLsizei width, GLsizei height, + GLint destx, GLint desty, GLenum type ) +{ + SWcontext *swrast = SWRAST_CONTEXT(ctx); + swrast_render_start(ctx); + + if (!_mesa_check_conditional_render(ctx)) + return; /* don't copy */ + + if (swrast->NewState) + _swrast_validate_derived( ctx ); + + if (!fast_copy_pixels(ctx, srcx, srcy, width, height, destx, desty, type)) { + switch (type) { + case GL_COLOR: + copy_rgba_pixels( ctx, srcx, srcy, width, height, destx, desty ); + break; + case GL_DEPTH: + copy_depth_pixels( ctx, srcx, srcy, width, height, destx, desty ); + break; + case GL_STENCIL: + copy_stencil_pixels( ctx, srcx, srcy, width, height, destx, desty ); + break; + case GL_DEPTH_STENCIL_EXT: + copy_depth_stencil_pixels(ctx, srcx, srcy, width, height, destx, desty); + break; + default: + _mesa_problem(ctx, "unexpected type in _swrast_CopyPixels"); + } + } + + swrast_render_finish(ctx); +} diff --git a/mesalib/src/mesa/swrast/s_depth.c b/mesalib/src/mesa/swrast/s_depth.c index 6ffa0a310..8d3ad105b 100644 --- a/mesalib/src/mesa/swrast/s_depth.c +++ b/mesalib/src/mesa/swrast/s_depth.c @@ -1248,8 +1248,7 @@ _swrast_depth_bounds_test( struct gl_context *ctx, SWspan *span ) * Read a span of depth values from the given depth renderbuffer, returning * the values as GLfloats. * This function does clipping to prevent reading outside the depth buffer's - * bounds. Though the clipping is redundant when we're called from - * _swrast_ReadPixels. + * bounds. */ void _swrast_read_depth_span_float( struct gl_context *ctx, struct gl_renderbuffer *rb, diff --git a/mesalib/src/mesa/swrast/s_drawpix.c b/mesalib/src/mesa/swrast/s_drawpix.c index 20bf4d626..b6c433753 100644 --- a/mesalib/src/mesa/swrast/s_drawpix.c +++ b/mesalib/src/mesa/swrast/s_drawpix.c @@ -320,6 +320,7 @@ draw_stencil_pixels( struct gl_context *ctx, GLint x, GLint y, const GLvoid *pixels ) { const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0; + const GLenum destType = GL_UNSIGNED_BYTE; GLint skipPixels; /* if width > MAX_WIDTH, have to process image in chunks */ @@ -330,9 +331,7 @@ draw_stencil_pixels( struct gl_context *ctx, GLint x, GLint y, GLint row; for (row = 0; row < height; row++) { const GLint spanY = y + row; - GLstencil values[MAX_WIDTH]; - GLenum destType = (sizeof(GLstencil) == sizeof(GLubyte)) - ? GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT; + GLubyte values[MAX_WIDTH]; const GLvoid *source = _mesa_image_address2d(unpack, pixels, width, height, GL_STENCIL_INDEX, type, @@ -570,8 +569,7 @@ draw_depth_stencil_pixels(struct gl_context *ctx, GLint x, GLint y, = ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0; const GLuint depthMax = ctx->DrawBuffer->_DepthMax; const GLuint stencilMask = ctx->Stencil.WriteMask[0]; - const GLuint stencilType = (STENCIL_BITS == 8) ? - GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT; + const GLenum stencilType = GL_UNSIGNED_BYTE; const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0; struct gl_renderbuffer *depthRb, *stencilRb; struct gl_pixelstore_attrib clippedUnpack = *unpack; @@ -672,7 +670,7 @@ draw_depth_stencil_pixels(struct gl_context *ctx, GLint x, GLint y, } if (stencilMask != 0x0) { - GLstencil stencilValues[MAX_WIDTH]; + GLubyte stencilValues[MAX_WIDTH]; /* get stencil values, with shift/offset/mapping */ _mesa_unpack_stencil_span(ctx, width, stencilType, stencilValues, type, depthStencilSrc, &clippedUnpack, diff --git a/mesalib/src/mesa/swrast/s_readpix.c b/mesalib/src/mesa/swrast/s_readpix.c deleted file mode 100644 index 3cef7304a..000000000 --- a/mesalib/src/mesa/swrast/s_readpix.c +++ /dev/null @@ -1,522 +0,0 @@ -/* - * Mesa 3-D graphics library - * Version: 7.0.3 - * - * Copyright (C) 1999-2007 Brian Paul All Rights Reserved. - * - * 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 - * BRIAN PAUL 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 "main/glheader.h" -#include "main/colormac.h" -#include "main/feedback.h" -#include "main/formats.h" -#include "main/format_unpack.h" -#include "main/image.h" -#include "main/imports.h" -#include "main/macros.h" -#include "main/pack.h" -#include "main/pbo.h" -#include "main/state.h" - -#include "s_context.h" -#include "s_depth.h" -#include "s_span.h" -#include "s_stencil.h" - -/** - * Tries to implement glReadPixels() of GL_DEPTH_COMPONENT using memcpy of the - * mapping. - */ -static GLboolean -fast_read_depth_pixels( struct gl_context *ctx, - GLint x, GLint y, - GLsizei width, GLsizei height, - GLenum type, GLvoid *pixels, - const struct gl_pixelstore_attrib *packing ) -{ - struct gl_framebuffer *fb = ctx->ReadBuffer; - struct gl_renderbuffer *rb = fb->Attachment[BUFFER_DEPTH].Renderbuffer; - GLubyte *map, *dst; - int stride, dstStride, j; - - if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) - return GL_FALSE; - - if (packing->SwapBytes) - return GL_FALSE; - - if (_mesa_get_format_datatype(rb->Format) != GL_UNSIGNED_INT) - return GL_FALSE; - - if (!((type == GL_UNSIGNED_SHORT && rb->Format == MESA_FORMAT_Z16) || - type == GL_UNSIGNED_INT)) - return GL_FALSE; - - ctx->Driver.MapRenderbuffer(ctx, rb, x, y, width, height, GL_MAP_READ_BIT, - &map, &stride); - - dstStride = _mesa_image_row_stride(packing, width, GL_DEPTH_COMPONENT, type); - dst = (GLubyte *) _mesa_image_address2d(packing, pixels, width, height, - GL_DEPTH_COMPONENT, type, 0, 0); - - for (j = 0; j < height; j++) { - if (type == GL_UNSIGNED_INT) { - _mesa_unpack_uint_z_row(rb->Format, width, map, (GLuint *)dst); - } else { - ASSERT(type == GL_UNSIGNED_SHORT && rb->Format == MESA_FORMAT_Z16); - memcpy(dst, map, width * 2); - } - - map += stride; - dst += dstStride; - } - ctx->Driver.UnmapRenderbuffer(ctx, rb); - - return GL_TRUE; -} - -/** - * Read pixels for format=GL_DEPTH_COMPONENT. - */ -static void -read_depth_pixels( struct gl_context *ctx, - GLint x, GLint y, - GLsizei width, GLsizei height, - GLenum type, GLvoid *pixels, - const struct gl_pixelstore_attrib *packing ) -{ - struct gl_framebuffer *fb = ctx->ReadBuffer; - struct gl_renderbuffer *rb = fb->Attachment[BUFFER_DEPTH].Renderbuffer; - GLint j; - GLubyte *dst, *map; - int dstStride, stride; - - if (!rb) - return; - - /* clipping should have been done already */ - ASSERT(x >= 0); - ASSERT(y >= 0); - ASSERT(x + width <= (GLint) rb->Width); - ASSERT(y + height <= (GLint) rb->Height); - /* width should never be > MAX_WIDTH since we did clipping earlier */ - ASSERT(width <= MAX_WIDTH); - - if (fast_read_depth_pixels(ctx, x, y, width, height, type, pixels, packing)) - return; - - dstStride = _mesa_image_row_stride(packing, width, GL_DEPTH_COMPONENT, type); - dst = (GLubyte *) _mesa_image_address2d(packing, pixels, width, height, - GL_DEPTH_COMPONENT, type, 0, 0); - - ctx->Driver.MapRenderbuffer(ctx, rb, x, y, width, height, GL_MAP_READ_BIT, - &map, &stride); - - /* General case (slower) */ - for (j = 0; j < height; j++, y++) { - GLfloat depthValues[MAX_WIDTH]; - _mesa_unpack_float_z_row(rb->Format, width, map, depthValues); - _mesa_pack_depth_span(ctx, width, dst, type, depthValues, packing); - - dst += dstStride; - map += stride; - } - - ctx->Driver.UnmapRenderbuffer(ctx, rb); -} - - -/** - * Read pixels for format=GL_STENCIL_INDEX. - */ -static void -read_stencil_pixels( struct gl_context *ctx, - GLint x, GLint y, - GLsizei width, GLsizei height, - GLenum type, GLvoid *pixels, - const struct gl_pixelstore_attrib *packing ) -{ - struct gl_framebuffer *fb = ctx->ReadBuffer; - struct gl_renderbuffer *rb = fb->Attachment[BUFFER_STENCIL].Renderbuffer; - GLint j; - GLubyte *map; - GLint stride; - - if (!rb) - return; - - /* width should never be > MAX_WIDTH since we did clipping earlier */ - ASSERT(width <= MAX_WIDTH); - - ctx->Driver.MapRenderbuffer(ctx, rb, x, y, width, height, GL_MAP_READ_BIT, - &map, &stride); - - /* process image row by row */ - for (j = 0; j < height; j++) { - GLvoid *dest; - GLstencil stencil[MAX_WIDTH]; - - _mesa_unpack_ubyte_stencil_row(rb->Format, width, map, stencil); - dest = _mesa_image_address2d(packing, pixels, width, height, - GL_STENCIL_INDEX, type, j, 0); - - _mesa_pack_stencil_span(ctx, width, type, dest, stencil, packing); - - map += stride; - } - - ctx->Driver.UnmapRenderbuffer(ctx, rb); -} - -static GLboolean -fast_read_rgba_pixels_memcpy( struct gl_context *ctx, - GLint x, GLint y, - GLsizei width, GLsizei height, - GLenum format, GLenum type, - GLvoid *pixels, - const struct gl_pixelstore_attrib *packing, - GLbitfield transferOps ) -{ - struct gl_renderbuffer *rb = ctx->ReadBuffer->_ColorReadBuffer; - GLubyte *dst, *map; - int dstStride, stride, j, texelBytes; - - if (!_mesa_format_matches_format_and_type(rb->Format, format, type)) - return GL_FALSE; - - /* check for things we can't handle here */ - if (packing->SwapBytes || - packing->LsbFirst) { - return GL_FALSE; - } - - dstStride = _mesa_image_row_stride(packing, width, format, type); - dst = (GLubyte *) _mesa_image_address2d(packing, pixels, width, height, - format, type, 0, 0); - - ctx->Driver.MapRenderbuffer(ctx, rb, x, y, width, height, GL_MAP_READ_BIT, - &map, &stride); - - texelBytes = _mesa_get_format_bytes(rb->Format); - for (j = 0; j < height; j++) { - memcpy(dst, map, width * texelBytes); - dst += dstStride; - map += stride; - } - - ctx->Driver.UnmapRenderbuffer(ctx, rb); - - return GL_TRUE; -} - -static GLboolean -slow_read_rgba_pixels( struct gl_context *ctx, - GLint x, GLint y, - GLsizei width, GLsizei height, - GLenum format, GLenum type, - GLvoid *pixels, - const struct gl_pixelstore_attrib *packing, - GLbitfield transferOps ) -{ - struct gl_renderbuffer *rb = ctx->ReadBuffer->_ColorReadBuffer; - const gl_format rbFormat = _mesa_get_srgb_format_linear(rb->Format); - union { - float f[MAX_WIDTH][4]; - unsigned int i[MAX_WIDTH][4]; - } rgba; - GLubyte *dst, *map; - int dstStride, stride, j; - - dstStride = _mesa_image_row_stride(packing, width, format, type); - dst = (GLubyte *) _mesa_image_address2d(packing, pixels, width, height, - format, type, 0, 0); - - ctx->Driver.MapRenderbuffer(ctx, rb, x, y, width, height, GL_MAP_READ_BIT, - &map, &stride); - - for (j = 0; j < height; j++) { - if (_mesa_is_integer_format(format)) { - _mesa_unpack_int_rgba_row(rbFormat, width, map, rgba.i); - _mesa_pack_rgba_span_int(ctx, width, rgba.i, format, type, dst); - } else { - _mesa_unpack_rgba_row(rbFormat, width, map, rgba.f); - _mesa_pack_rgba_span_float(ctx, width, rgba.f, format, type, dst, - packing, transferOps); - } - dst += dstStride; - map += stride; - } - - ctx->Driver.UnmapRenderbuffer(ctx, rb); - - return GL_TRUE; -} - -/* - * Read R, G, B, A, RGB, L, or LA pixels. - */ -static void -read_rgba_pixels( struct gl_context *ctx, - GLint x, GLint y, - GLsizei width, GLsizei height, - GLenum format, GLenum type, GLvoid *pixels, - const struct gl_pixelstore_attrib *packing ) -{ - GLbitfield transferOps = ctx->_ImageTransferState; - struct gl_framebuffer *fb = ctx->ReadBuffer; - struct gl_renderbuffer *rb = fb->_ColorReadBuffer; - - if (!rb) - return; - - if ((ctx->Color._ClampReadColor == GL_TRUE || type != GL_FLOAT) && - !_mesa_is_integer_format(format)) { - transferOps |= IMAGE_CLAMP_BIT; - } - - if (!transferOps) { - /* Try the optimized paths first. */ - if (fast_read_rgba_pixels_memcpy(ctx, x, y, width, height, - format, type, pixels, packing, - transferOps)) { - return; - } - } - - slow_read_rgba_pixels(ctx, x, y, width, height, - format, type, pixels, packing, transferOps); -} - -/** - * For a packed depth/stencil buffer being read as depth/stencil, just memcpy the - * data (possibly swapping 8/24 vs 24/8 as we go). - */ -static GLboolean -fast_read_depth_stencil_pixels(struct gl_context *ctx, - GLint x, GLint y, - GLsizei width, GLsizei height, - GLubyte *dst, int dstStride) -{ - struct gl_framebuffer *fb = ctx->ReadBuffer; - struct gl_renderbuffer *rb = fb->Attachment[BUFFER_DEPTH].Renderbuffer; - struct gl_renderbuffer *stencilRb = fb->Attachment[BUFFER_STENCIL].Renderbuffer; - GLubyte *map; - int stride, i; - - if (rb != stencilRb) - return GL_FALSE; - - if (rb->Format != MESA_FORMAT_Z24_S8 && - rb->Format != MESA_FORMAT_S8_Z24) - return GL_FALSE; - - ctx->Driver.MapRenderbuffer(ctx, rb, x, y, width, height, GL_MAP_READ_BIT, - &map, &stride); - - for (i = 0; i < height; i++) { - _mesa_unpack_uint_24_8_depth_stencil_row(rb->Format, width, - map, (GLuint *)dst); - map += stride; - dst += dstStride; - } - - ctx->Driver.UnmapRenderbuffer(ctx, rb); - - return GL_TRUE; -} - - -/** - * For non-float-depth and stencil buffers being read as 24/8 depth/stencil, - * copy the integer data directly instead of converting depth to float and - * re-packing. - */ -static GLboolean -fast_read_depth_stencil_pixels_separate(struct gl_context *ctx, - GLint x, GLint y, - GLsizei width, GLsizei height, - uint32_t *dst, int dstStride) -{ - struct gl_framebuffer *fb = ctx->ReadBuffer; - struct gl_renderbuffer *depthRb = fb->Attachment[BUFFER_DEPTH].Renderbuffer; - struct gl_renderbuffer *stencilRb = fb->Attachment[BUFFER_STENCIL].Renderbuffer; - GLubyte *depthMap, *stencilMap; - int depthStride, stencilStride, i, j; - - if (_mesa_get_format_datatype(depthRb->Format) != GL_UNSIGNED_INT) - return GL_FALSE; - - ctx->Driver.MapRenderbuffer(ctx, depthRb, x, y, width, height, - GL_MAP_READ_BIT, &depthMap, &depthStride); - ctx->Driver.MapRenderbuffer(ctx, stencilRb, x, y, width, height, - GL_MAP_READ_BIT, &stencilMap, &stencilStride); - - for (j = 0; j < height; j++) { - GLstencil stencilVals[MAX_WIDTH]; - - _mesa_unpack_uint_z_row(depthRb->Format, width, depthMap, dst); - _mesa_unpack_ubyte_stencil_row(stencilRb->Format, width, - stencilMap, stencilVals); - - for (i = 0; i < width; i++) { - dst[i] = (dst[i] & 0xffffff00) | stencilVals[i]; - } - - depthMap += depthStride; - stencilMap += stencilStride; - dst += dstStride / 4; - } - - ctx->Driver.UnmapRenderbuffer(ctx, depthRb); - ctx->Driver.UnmapRenderbuffer(ctx, stencilRb); - - return GL_TRUE; -} - -static void -slow_read_depth_stencil_pixels_separate(struct gl_context *ctx, - GLint x, GLint y, - GLsizei width, GLsizei height, - GLenum type, - const struct gl_pixelstore_attrib *packing, - GLubyte *dst, int dstStride) -{ - struct gl_framebuffer *fb = ctx->ReadBuffer; - struct gl_renderbuffer *depthRb = fb->Attachment[BUFFER_DEPTH].Renderbuffer; - struct gl_renderbuffer *stencilRb = fb->Attachment[BUFFER_STENCIL].Renderbuffer; - GLubyte *depthMap, *stencilMap; - int depthStride, stencilStride, j; - - ctx->Driver.MapRenderbuffer(ctx, depthRb, x, y, width, height, - GL_MAP_READ_BIT, &depthMap, &depthStride); - ctx->Driver.MapRenderbuffer(ctx, stencilRb, x, y, width, height, - GL_MAP_READ_BIT, &stencilMap, &stencilStride); - - for (j = 0; j < height; j++) { - GLstencil stencilVals[MAX_WIDTH]; - GLfloat depthVals[MAX_WIDTH]; - - _mesa_unpack_float_z_row(depthRb->Format, width, depthMap, depthVals); - _mesa_unpack_ubyte_stencil_row(stencilRb->Format, width, - stencilMap, stencilVals); - - _mesa_pack_depth_stencil_span(ctx, width, type, (GLuint *)dst, - depthVals, stencilVals, packing); - - depthMap += depthStride; - stencilMap += stencilStride; - dst += dstStride; - } - - ctx->Driver.UnmapRenderbuffer(ctx, depthRb); - ctx->Driver.UnmapRenderbuffer(ctx, stencilRb); -} - - -/** - * Read combined depth/stencil values. - * We'll have already done error checking to be sure the expected - * depth and stencil buffers really exist. - */ -static void -read_depth_stencil_pixels(struct gl_context *ctx, - GLint x, GLint y, - GLsizei width, GLsizei height, - GLenum type, GLvoid *pixels, - const struct gl_pixelstore_attrib *packing ) -{ - const GLboolean scaleOrBias - = ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0; - const GLboolean stencilTransfer = ctx->Pixel.IndexShift - || ctx->Pixel.IndexOffset || ctx->Pixel.MapStencilFlag; - GLubyte *dst; - int dstStride; - - dst = (GLubyte *) _mesa_image_address2d(packing, pixels, - width, height, - GL_DEPTH_STENCIL_EXT, - type, 0, 0); - dstStride = _mesa_image_row_stride(packing, width, - GL_DEPTH_STENCIL_EXT, type); - - /* Fast 24/8 reads. */ - if (type == GL_UNSIGNED_INT_24_8 && - !scaleOrBias && !stencilTransfer && !packing->SwapBytes) { - if (fast_read_depth_stencil_pixels(ctx, x, y, width, height, - dst, dstStride)) - return; - - if (fast_read_depth_stencil_pixels_separate(ctx, x, y, width, height, - (uint32_t *)dst, dstStride)) - return; - } - - slow_read_depth_stencil_pixels_separate(ctx, x, y, width, height, - type, packing, - dst, dstStride); -} - - - -/** - * Software fallback routine for ctx->Driver.ReadPixels(). - * By time we get here, all error checking will have been done. - */ -void -_swrast_ReadPixels( struct gl_context *ctx, - GLint x, GLint y, GLsizei width, GLsizei height, - GLenum format, GLenum type, - const struct gl_pixelstore_attrib *packing, - GLvoid *pixels ) -{ - struct gl_pixelstore_attrib clippedPacking = *packing; - - if (ctx->NewState) - _mesa_update_state(ctx); - - /* Do all needed clipping here, so that we can forget about it later */ - if (_mesa_clip_readpixels(ctx, &x, &y, &width, &height, &clippedPacking)) { - - pixels = _mesa_map_pbo_dest(ctx, &clippedPacking, pixels); - - if (pixels) { - switch (format) { - case GL_STENCIL_INDEX: - read_stencil_pixels(ctx, x, y, width, height, type, pixels, - &clippedPacking); - break; - case GL_DEPTH_COMPONENT: - read_depth_pixels(ctx, x, y, width, height, type, pixels, - &clippedPacking); - break; - case GL_DEPTH_STENCIL_EXT: - read_depth_stencil_pixels(ctx, x, y, width, height, type, pixels, - &clippedPacking); - break; - default: - /* all other formats should be color formats */ - read_rgba_pixels(ctx, x, y, width, height, format, type, pixels, - &clippedPacking); - } - - _mesa_unmap_pbo_dest(ctx, &clippedPacking); - } - } -} diff --git a/mesalib/src/mesa/swrast/s_stencil.c b/mesalib/src/mesa/swrast/s_stencil.c index e713e2393..101ee5056 100644 --- a/mesalib/src/mesa/swrast/s_stencil.c +++ b/mesalib/src/mesa/swrast/s_stencil.c @@ -62,12 +62,12 @@ ENDIF */ static void apply_stencil_op( const struct gl_context *ctx, GLenum oper, GLuint face, - GLuint n, GLstencil stencil[], const GLubyte mask[] ) + GLuint n, GLubyte stencil[], const GLubyte mask[] ) { - const GLstencil ref = ctx->Stencil.Ref[face]; - const GLstencil wrtmask = ctx->Stencil.WriteMask[face]; - const GLstencil invmask = (GLstencil) (~wrtmask); - const GLstencil stencilMax = (1 << ctx->DrawBuffer->Visual.stencilBits) - 1; + const GLubyte ref = ctx->Stencil.Ref[face]; + const GLubyte wrtmask = ctx->Stencil.WriteMask[face]; + const GLubyte invmask = (GLubyte) (~wrtmask); + const GLubyte stencilMax = (1 << ctx->DrawBuffer->Visual.stencilBits) - 1; GLuint i; switch (oper) { @@ -85,7 +85,7 @@ apply_stencil_op( const struct gl_context *ctx, GLenum oper, GLuint face, else { for (i=0;i0) { - stencil[i] = (GLstencil) (s-1); + stencil[i] = (GLubyte) (s-1); } } } @@ -145,9 +145,9 @@ apply_stencil_op( const struct gl_context *ctx, GLenum oper, GLuint face, for (i=0;i0) { - stencil[i] = (GLstencil) ((invmask & s) | (wrtmask & (s-1))); + stencil[i] = (GLubyte) ((invmask & s) | (wrtmask & (s-1))); } } } @@ -164,8 +164,8 @@ apply_stencil_op( const struct gl_context *ctx, GLenum oper, GLuint face, else { for (i=0;iStencil.ValueMask[face]; - const GLstencil r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask); - GLstencil s; + const GLubyte r = (GLubyte) (ctx->Stencil.Ref[face] & valueMask); + GLubyte s; ASSERT(n <= MAX_WIDTH); @@ -263,7 +263,7 @@ do_stencil_test( struct gl_context *ctx, GLuint face, GLuint n, GLstencil stenci case GL_LESS: for (i=0;i s) { /* passed */ fail[i] = 0; @@ -317,7 +317,7 @@ do_stencil_test( struct gl_context *ctx, GLuint face, GLuint n, GLstencil stenci case GL_GEQUAL: for (i=0;i= s) { /* passed */ fail[i] = 0; @@ -335,7 +335,7 @@ do_stencil_test( struct gl_context *ctx, GLuint face, GLuint n, GLstencil stenci case GL_EQUAL: for (i=0;iDrawBuffer; struct gl_renderbuffer *rb = fb->_StencilBuffer; - GLstencil stencilRow[MAX_WIDTH]; - GLstencil *stencil; + GLubyte stencilRow[MAX_WIDTH]; + GLubyte *stencil; const GLuint n = span->end; const GLint x = span->x; const GLint y = span->y; @@ -438,7 +438,7 @@ stencil_and_ztest_span(struct gl_context *ctx, SWspan *span, GLuint face) } #endif - stencil = (GLstencil *) rb->GetPointer(ctx, rb, x, y); + stencil = (GLubyte *) rb->GetPointer(ctx, rb, x, y); if (!stencil) { rb->GetRow(ctx, rb, n, x, y, stencilRow); stencil = stencilRow; @@ -531,16 +531,15 @@ apply_stencil_op_to_pixels( struct gl_context *ctx, { struct gl_framebuffer *fb = ctx->DrawBuffer; struct gl_renderbuffer *rb = fb->_StencilBuffer; - const GLstencil stencilMax = (1 << fb->Visual.stencilBits) - 1; - const GLstencil ref = ctx->Stencil.Ref[face]; - const GLstencil wrtmask = ctx->Stencil.WriteMask[face]; - const GLstencil invmask = (GLstencil) (~wrtmask); + const GLubyte stencilMax = (1 << fb->Visual.stencilBits) - 1; + const GLubyte ref = ctx->Stencil.Ref[face]; + const GLubyte wrtmask = ctx->Stencil.WriteMask[face]; + const GLubyte invmask = (GLubyte) (~wrtmask); GLuint i; - GLstencil *stencilStart = (GLubyte *) rb->Data; + GLubyte *stencilStart = (GLubyte *) rb->Data; const GLuint stride = rb->Width; ASSERT(rb->GetPointer(ctx, rb, 0, 0)); - ASSERT(sizeof(GLstencil) == 1); switch (oper) { case GL_KEEP: @@ -550,7 +549,7 @@ apply_stencil_op_to_pixels( struct gl_context *ctx, if (invmask==0) { for (i=0;i0) { - *sptr = (GLstencil) (*sptr - 1); + *sptr = (GLubyte) (*sptr - 1); } } } @@ -618,9 +617,9 @@ apply_stencil_op_to_pixels( struct gl_context *ctx, else { for (i=0;i0) { - *sptr = (GLstencil) ((invmask & *sptr) | (wrtmask & (*sptr-1))); + *sptr = (GLubyte) ((invmask & *sptr) | (wrtmask & (*sptr-1))); } } } @@ -630,16 +629,16 @@ apply_stencil_op_to_pixels( struct gl_context *ctx, if (invmask==0) { for (i=0;iDrawBuffer; struct gl_renderbuffer *rb = fb->_StencilBuffer; GLubyte fail[MAX_WIDTH]; - GLstencil r, s; + GLubyte r, s; GLuint i; GLboolean allfail = GL_FALSE; const GLuint valueMask = ctx->Stencil.ValueMask[face]; - const GLstencil *stencilStart = (GLstencil *) rb->Data; + const GLubyte *stencilStart = (GLubyte *) rb->Data; const GLuint stride = rb->Width; ASSERT(rb->GetPointer(ctx, rb, 0, 0)); - ASSERT(sizeof(GLstencil) == 1); /* * Perform stencil test. The results of this operation are stored @@ -740,11 +738,11 @@ stencil_test_pixels( struct gl_context *ctx, GLuint face, GLuint n, allfail = GL_TRUE; break; case GL_LESS: - r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask); + r = (GLubyte) (ctx->Stencil.Ref[face] & valueMask); for (i=0;iStencil.Ref[face] & valueMask); + r = (GLubyte) (ctx->Stencil.Ref[face] & valueMask); for (i=0;iStencil.Ref[face] & valueMask); + r = (GLubyte) (ctx->Stencil.Ref[face] & valueMask); for (i=0;i s) { /* passed */ fail[i] = 0; @@ -800,11 +798,11 @@ stencil_test_pixels( struct gl_context *ctx, GLuint face, GLuint n, } break; case GL_GEQUAL: - r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask); + r = (GLubyte) (ctx->Stencil.Ref[face] & valueMask); for (i=0;i= s) { /* passed */ fail[i] = 0; @@ -820,11 +818,11 @@ stencil_test_pixels( struct gl_context *ctx, GLuint face, GLuint n, } break; case GL_EQUAL: - r = (GLstencil) (ctx->Stencil.Ref[face] & valueMask); + r = (GLubyte) (ctx->Stencil.Ref[face] & valueMask); for (i=0;iStencil.Ref[face] & valueMask); + r = (GLubyte) (ctx->Stencil.Ref[face] & valueMask); for (i=0;iGetPointer(ctx, rb, 0, 0)) { /* No direct access */ - GLstencil stencil[MAX_WIDTH]; + GLubyte stencil[MAX_WIDTH]; ASSERT(rb->DataType == GL_UNSIGNED_BYTE); _swrast_get_values(ctx, rb, n, x, y, stencil, sizeof(GLubyte)); @@ -1044,7 +1042,7 @@ clip_span(GLuint bufferWidth, GLuint bufferHeight, */ void _swrast_read_stencil_span(struct gl_context *ctx, struct gl_renderbuffer *rb, - GLint n, GLint x, GLint y, GLstencil stencil[]) + GLint n, GLint x, GLint y, GLubyte stencil[]) { if (y < 0 || y >= (GLint) rb->Height || x + n <= 0 || x >= (GLint) rb->Width) { @@ -1081,7 +1079,7 @@ _swrast_read_stencil_span(struct gl_context *ctx, struct gl_renderbuffer *rb, */ void _swrast_write_stencil_span(struct gl_context *ctx, GLint n, GLint x, GLint y, - const GLstencil stencil[] ) + const GLubyte stencil[] ) { struct gl_framebuffer *fb = ctx->DrawBuffer; struct gl_renderbuffer *rb = fb->_StencilBuffer; @@ -1109,7 +1107,7 @@ _swrast_write_stencil_span(struct gl_context *ctx, GLint n, GLint x, GLint y, if ((stencilMask & stencilMax) != stencilMax) { /* need to apply writemask */ - GLstencil destVals[MAX_WIDTH], newVals[MAX_WIDTH]; + GLubyte destVals[MAX_WIDTH], newVals[MAX_WIDTH]; GLint i; rb->GetRow(ctx, rb, n, x, y, destVals); for (i = 0; i < n; i++) { diff --git a/mesalib/src/mesa/swrast/s_stencil.h b/mesalib/src/mesa/swrast/s_stencil.h index 0bcfb799f..37f3c8da1 100644 --- a/mesalib/src/mesa/swrast/s_stencil.h +++ b/mesalib/src/mesa/swrast/s_stencil.h @@ -1,53 +1,53 @@ -/* - * Mesa 3-D graphics library - * Version: 6.3 - * - * Copyright (C) 1999-2005 Brian Paul All Rights Reserved. - * - * 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 - * BRIAN PAUL 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 S_STENCIL_H -#define S_STENCIL_H - - -#include "main/mtypes.h" -#include "s_span.h" - - - -extern GLboolean -_swrast_stencil_and_ztest_span(struct gl_context *ctx, SWspan *span); - - -extern void -_swrast_read_stencil_span(struct gl_context *ctx, struct gl_renderbuffer *rb, - GLint n, GLint x, GLint y, GLstencil stencil[]); - - -extern void -_swrast_write_stencil_span( struct gl_context *ctx, GLint n, GLint x, GLint y, - const GLstencil stencil[] ); - - -extern void -_swrast_clear_stencil_buffer( struct gl_context *ctx, struct gl_renderbuffer *rb ); - - -#endif +/* + * Mesa 3-D graphics library + * Version: 6.3 + * + * Copyright (C) 1999-2005 Brian Paul All Rights Reserved. + * + * 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 + * BRIAN PAUL 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 S_STENCIL_H +#define S_STENCIL_H + + +#include "main/mtypes.h" +#include "s_span.h" + + + +extern GLboolean +_swrast_stencil_and_ztest_span(struct gl_context *ctx, SWspan *span); + + +extern void +_swrast_read_stencil_span(struct gl_context *ctx, struct gl_renderbuffer *rb, + GLint n, GLint x, GLint y, GLubyte stencil[]); + + +extern void +_swrast_write_stencil_span( struct gl_context *ctx, GLint n, GLint x, GLint y, + const GLubyte stencil[] ); + + +extern void +_swrast_clear_stencil_buffer( struct gl_context *ctx, struct gl_renderbuffer *rb ); + + +#endif diff --git a/mesalib/src/mesa/swrast/s_texrender.c b/mesalib/src/mesa/swrast/s_texrender.c index 83e7a6a03..3734ce6d5 100644 --- a/mesalib/src/mesa/swrast/s_texrender.c +++ b/mesalib/src/mesa/swrast/s_texrender.c @@ -567,6 +567,19 @@ update_wrapper(struct gl_context *ctx, struct gl_renderbuffer_attachment *att) trb->Base.InternalFormat = trb->TexImage->Base.InternalFormat; trb->Base.Format = trb->TexImage->Base.TexFormat; + /* Set the gl_renderbuffer::Data field so that mapping the buffer + * in renderbuffer.c succeeds. + */ + if (att->Texture->Target == GL_TEXTURE_3D || + att->Texture->Target == GL_TEXTURE_2D_ARRAY_EXT) { + trb->Base.Data = trb->TexImage->Buffer + + trb->TexImage->ImageOffsets[trb->Zoffset] * + _mesa_get_format_bytes(trb->TexImage->Base.TexFormat); + } + else { + trb->Base.Data = trb->TexImage->Buffer; + } + /* XXX may need more special cases here */ switch (trb->TexImage->Base.TexFormat) { case MESA_FORMAT_Z24_S8: diff --git a/mesalib/src/mesa/swrast/s_zoom.c b/mesalib/src/mesa/swrast/s_zoom.c index 3fb784847..16bb997f3 100644 --- a/mesalib/src/mesa/swrast/s_zoom.c +++ b/mesalib/src/mesa/swrast/s_zoom.c @@ -351,9 +351,9 @@ _swrast_write_zoomed_depth_span(struct gl_context *ctx, GLint imgX, GLint imgY, void _swrast_write_zoomed_stencil_span(struct gl_context *ctx, GLint imgX, GLint imgY, GLint width, GLint spanX, GLint spanY, - const GLstencil stencil[]) + const GLubyte stencil[]) { - GLstencil zoomedVals[MAX_WIDTH]; + GLubyte zoomedVals[MAX_WIDTH]; GLint x0, x1, y0, y1, y; GLint i, zoomedWidth; diff --git a/mesalib/src/mesa/swrast/s_zoom.h b/mesalib/src/mesa/swrast/s_zoom.h index b8d17b5a4..0b82bb824 100644 --- a/mesalib/src/mesa/swrast/s_zoom.h +++ b/mesalib/src/mesa/swrast/s_zoom.h @@ -1,56 +1,56 @@ -/* - * Mesa 3-D graphics library - * Version: 6.5 - * - * Copyright (C) 1999-2005 Brian Paul All Rights Reserved. - * - * 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 - * BRIAN PAUL 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 S_ZOOM_H -#define S_ZOOM_H - -#include "main/mtypes.h" -#include "s_span.h" - - -extern void -_swrast_write_zoomed_rgba_span(struct gl_context *ctx, GLint imgX, GLint imgY, - const SWspan *span, const GLvoid *rgba); - -extern void -_swrast_write_zoomed_rgb_span(struct gl_context *ctx, GLint imgX, GLint imgY, - const SWspan *span, const GLvoid *rgb); - -extern void -_swrast_write_zoomed_depth_span(struct gl_context *ctx, GLint imgX, GLint imgY, - const SWspan *span); - - -extern void -_swrast_write_zoomed_stencil_span(struct gl_context *ctx, GLint imgX, GLint imgY, - GLint width, GLint spanX, GLint spanY, - const GLstencil stencil[]); - -extern void -_swrast_write_zoomed_z_span(struct gl_context *ctx, GLint imgX, GLint imgY, - GLint width, GLint spanX, GLint spanY, - const GLvoid *z); - - -#endif +/* + * Mesa 3-D graphics library + * Version: 6.5 + * + * Copyright (C) 1999-2005 Brian Paul All Rights Reserved. + * + * 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 + * BRIAN PAUL 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 S_ZOOM_H +#define S_ZOOM_H + +#include "main/mtypes.h" +#include "s_span.h" + + +extern void +_swrast_write_zoomed_rgba_span(struct gl_context *ctx, GLint imgX, GLint imgY, + const SWspan *span, const GLvoid *rgba); + +extern void +_swrast_write_zoomed_rgb_span(struct gl_context *ctx, GLint imgX, GLint imgY, + const SWspan *span, const GLvoid *rgb); + +extern void +_swrast_write_zoomed_depth_span(struct gl_context *ctx, GLint imgX, GLint imgY, + const SWspan *span); + + +extern void +_swrast_write_zoomed_stencil_span(struct gl_context *ctx, GLint imgX, GLint imgY, + GLint width, GLint spanX, GLint spanY, + const GLubyte stencil[]); + +extern void +_swrast_write_zoomed_z_span(struct gl_context *ctx, GLint imgX, GLint imgY, + GLint width, GLint spanX, GLint spanY, + const GLvoid *z); + + +#endif diff --git a/mesalib/src/mesa/swrast/swrast.h b/mesalib/src/mesa/swrast/swrast.h index 08d565ba0..17b66c664 100644 --- a/mesalib/src/mesa/swrast/swrast.h +++ b/mesalib/src/mesa/swrast/swrast.h @@ -118,13 +118,6 @@ _swrast_DrawPixels( struct gl_context *ctx, const struct gl_pixelstore_attrib *unpack, const GLvoid *pixels ); -extern void -_swrast_ReadPixels( struct gl_context *ctx, - GLint x, GLint y, GLsizei width, GLsizei height, - GLenum format, GLenum type, - const struct gl_pixelstore_attrib *unpack, - GLvoid *pixels ); - extern void _swrast_BlitFramebuffer(struct gl_context *ctx, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, diff --git a/xorg-server/Xext/xselinux_ext.c b/xorg-server/Xext/xselinux_ext.c index 56f2d1ff2..a18a36706 100644 --- a/xorg-server/Xext/xselinux_ext.c +++ b/xorg-server/Xext/xselinux_ext.c @@ -337,7 +337,7 @@ static int SELinuxSendItemsToClient(ClientPtr client, SELinuxListItemRec *items, int size, int count) { - int rc, k, n, pos = 0; + int rc, k, pos = 0; SELinuxListItemsReply rep; CARD32 *buf; @@ -526,11 +526,6 @@ ProcSELinuxDispatch(ClientPtr client) static int SProcSELinuxQueryVersion(ClientPtr client) { - REQUEST(SELinuxQueryVersionReq); - - REQUEST_SIZE_MATCH(SELinuxQueryVersionReq); - swaps(&stuff->client_major); - swaps(&stuff->client_minor); return ProcSELinuxQueryVersion(client); } diff --git a/xorg-server/Xi/exevents.c b/xorg-server/Xi/exevents.c index 053c76f22..53db03629 100644 --- a/xorg-server/Xi/exevents.c +++ b/xorg-server/Xi/exevents.c @@ -104,7 +104,7 @@ int XIShouldNotify(ClientPtr client, DeviceIntPtr dev) { DeviceIntPtr current_ptr = PickPointer(client); - DeviceIntPtr current_kbd = GetPairedDevice(current_ptr); + DeviceIntPtr current_kbd = GetMaster(current_ptr, KEYBOARD_OR_FLOAT); if (dev == current_kbd || dev == current_ptr) return 1; @@ -903,13 +903,13 @@ ProcessOtherEvent(InternalEvent *ev, DeviceIntPtr device) if (IsPointerDevice(device)) { - kbd = GetPairedDevice(device); + kbd = GetMaster(device, KEYBOARD_OR_FLOAT); mouse = device; if (!kbd->key) /* can happen with floating SDs */ kbd = NULL; } else { - mouse = GetPairedDevice(device); + mouse = GetMaster(device, POINTER_OR_FLOAT); kbd = device; if (!mouse->valuator || !mouse->button) /* may be float. SDs */ mouse = NULL; @@ -1495,7 +1495,7 @@ GrabKey(ClientPtr client, DeviceIntPtr dev, DeviceIntPtr modifier_device, rc = CheckGrabValues(client, param); if (rc != Success) return rc; - if (k == NULL) + if ((dev->id != XIAllDevices && dev->id != XIAllMasterDevices) && k == NULL) return BadMatch; if (grabtype == GRABTYPE_XI) { diff --git a/xorg-server/Xi/xiquerypointer.c b/xorg-server/Xi/xiquerypointer.c index 9e05eff30..d01a81394 100644 --- a/xorg-server/Xi/xiquerypointer.c +++ b/xorg-server/Xi/xiquerypointer.c @@ -109,7 +109,7 @@ ProcXIQueryPointer(ClientPtr client) MaybeStopHint(pDev, client); if (IsMaster(pDev)) - kbd = GetPairedDevice(pDev); + kbd = GetMaster(pDev, MASTER_KEYBOARD); else kbd = (pDev->key) ? pDev : NULL; diff --git a/xorg-server/dix/enterleave.c b/xorg-server/dix/enterleave.c index 6be14190f..a39e64001 100644 --- a/xorg-server/dix/enterleave.c +++ b/xorg-server/dix/enterleave.c @@ -1,1389 +1,1389 @@ -/* - * Copyright © 2008 Red Hat, Inc. - * - * 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 (including the next - * paragraph) 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 OR COPYRIGHT HOLDERS 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. - * - * Authors: Peter Hutterer - * - */ - -#ifdef HAVE_DIX_CONFIG_H -#include -#endif - -#include -#include -#include "inputstr.h" -#include "windowstr.h" -#include "scrnintstr.h" -#include "exglobals.h" -#include "enterleave.h" - -/** - * @file - * This file describes the model for sending core enter/leave events and - * focus in/out in the case of multiple pointers/keyboard foci. - * - * Since we can't send more than one Enter or Leave/Focus in or out event per - * window to a core client without confusing it, this is a rather complicated - * approach. - * - * For a full description of the enter/leave model from a window's - * perspective, see - * http://lists.freedesktop.org/archives/xorg/2008-August/037606.html - * - * For a full description of the focus in/out model from a window's - * perspective, see - * http://lists.freedesktop.org/archives/xorg/2008-December/041740.html - * - * Additional notes: - * - The core protocol spec says that "In a LeaveNotify event, if a child of the - * event window contains the initial position of the pointer, then the child - * component is set to that child. Otherwise, it is None. For an EnterNotify - * event, if a child of the event window contains the final pointer position, - * then the child component is set to that child. Otherwise, it is None." - * - * By inference, this means that only NotifyVirtual or NotifyNonlinearVirtual - * events may have a subwindow set to other than None. - * - * - NotifyPointer events may be sent if the focus changes from window A to - * B. The assumption used in this model is that NotifyPointer events are only - * sent for the pointer paired with the keyboard that is involved in the focus - * events. For example, if F(W) changes because of keyboard 2, then - * NotifyPointer events are only sent for pointer 2. - */ - -static WindowPtr PointerWindows[MAXDEVICES]; -static WindowPtr FocusWindows[MAXDEVICES]; - -/** - * Return TRUE if 'win' has a pointer within its boundaries, excluding child - * window. - */ -static BOOL -HasPointer(DeviceIntPtr dev, WindowPtr win) -{ - int i; - - /* FIXME: The enter/leave model does not cater for grabbed devices. For - * now, a quickfix: if the device about to send an enter/leave event to - * a window is grabbed, assume there is no pointer in that window. - * Fixes fdo 27804. - * There isn't enough beer in my fridge to fix this properly. - */ - if (dev->deviceGrab.grab) - return FALSE; - - for (i = 0; i < MAXDEVICES; i++) - if (PointerWindows[i] == win) - return TRUE; - - return FALSE; -} - -/** - * Return TRUE if at least one keyboard focus is set to 'win' (excluding - * descendants of win). - */ -static BOOL -HasFocus(WindowPtr win) -{ - int i; - for (i = 0; i < MAXDEVICES; i++) - if (FocusWindows[i] == win) - return TRUE; - - return FALSE; -} - -/** - * Return the window the device dev is currently on. - */ -static WindowPtr -PointerWin(DeviceIntPtr dev) -{ - return PointerWindows[dev->id]; -} - -/** - * Search for the first window below 'win' that has a pointer directly within - * it's boundaries (excluding boundaries of its own descendants). - * - * @return The child window that has the pointer within its boundaries or - * NULL. - */ -static WindowPtr -FirstPointerChild(WindowPtr win) -{ - int i; - for (i = 0; i < MAXDEVICES; i++) - { - if (PointerWindows[i] && IsParent(win, PointerWindows[i])) - return PointerWindows[i]; - } - - return NULL; -} - -/** - * Search for the first window below 'win' that has a focus directly within - * it's boundaries (excluding boundaries of its own descendants). - * - * @return The child window that has the pointer within its boundaries or - * NULL. - */ -static WindowPtr -FirstFocusChild(WindowPtr win) -{ - int i; - for (i = 0; i < MAXDEVICES; i++) - { - if (FocusWindows[i] && FocusWindows[i] != PointerRootWin && - IsParent(win, FocusWindows[i])) - return FocusWindows[i]; - } - - return NULL; -} - -/** - * Set the presence flag for dev to mark that it is now in 'win'. - */ -void -EnterWindow(DeviceIntPtr dev, WindowPtr win, int mode) -{ - PointerWindows[dev->id] = win; -} - -/** - * Unset the presence flag for dev to mark that it is not in 'win' anymore. - */ -void -LeaveWindow(DeviceIntPtr dev) -{ - PointerWindows[dev->id] = NULL; -} - -/** - * Set the presence flag for dev to mark that it is now in 'win'. - */ -void -SetFocusIn(DeviceIntPtr dev, WindowPtr win) -{ - FocusWindows[dev->id] = win; -} - -/** - * Unset the presence flag for dev to mark that it is not in 'win' anymore. - */ -void -SetFocusOut(DeviceIntPtr dev) -{ - FocusWindows[dev->id] = NULL; -} - - - - -/** - * Return the common ancestor of 'a' and 'b' (if one exists). - * @param a A window with the same ancestor as b. - * @param b A window with the same ancestor as a. - * @return The window that is the first ancestor of both 'a' and 'b', or the - * NullWindow if they do not have a common ancestor. - */ -WindowPtr -CommonAncestor( - WindowPtr a, - WindowPtr b) -{ - for (b = b->parent; b; b = b->parent) - if (IsParent(b, a)) return b; - return NullWindow; -} - - -/** - * Send enter notifies to all windows between 'ancestor' and 'child' (excluding - * both). Events are sent running up the window hierarchy. This function - * recurses. - */ -static void -DeviceEnterNotifies(DeviceIntPtr dev, - int sourceid, - WindowPtr ancestor, - WindowPtr child, - int mode, - int detail) -{ - WindowPtr parent = child->parent; - - if (ancestor == parent) - return; - DeviceEnterNotifies(dev, sourceid, ancestor, parent, mode, detail); - DeviceEnterLeaveEvent(dev, sourceid, XI_Enter, mode, detail, parent, - child->drawable.id); -} - -/** - * Send enter notifies to all windows between 'ancestor' and 'child' (excluding - * both). Events are sent running down the window hierarchy. This function - * recurses. - */ -static void -CoreEnterNotifies(DeviceIntPtr dev, - WindowPtr ancestor, - WindowPtr child, - int mode, - int detail) -{ - WindowPtr parent = child->parent; - if (ancestor == parent) - return; - CoreEnterNotifies(dev, ancestor, parent, mode, detail); - - - /* Case 3: - A is above W, B is a descendant - - Classically: The move generates an EnterNotify on W with a detail of - Virtual or NonlinearVirtual - - MPX: - Case 3A: There is at least one other pointer on W itself - P(W) doesn't change, so the event should be suppressed - Case 3B: Otherwise, if there is at least one other pointer in a - descendant - P(W) stays on the same descendant, or changes to a different - descendant. The event should be suppressed. - Case 3C: Otherwise: - P(W) moves from a window above W to a descendant. The subwindow - field is set to the child containing the descendant. The detail - may need to be changed from Virtual to NonlinearVirtual depending - on the previous P(W). */ - - if (!HasPointer(dev, parent) && !FirstPointerChild(parent)) - CoreEnterLeaveEvent(dev, EnterNotify, mode, detail, parent, - child->drawable.id); -} - -static void -CoreLeaveNotifies(DeviceIntPtr dev, - WindowPtr child, - WindowPtr ancestor, - int mode, - int detail) -{ - WindowPtr win; - - if (ancestor == child) - return; - - for (win = child->parent; win != ancestor; win = win->parent) - { - /*Case 7: - A is a descendant of W, B is above W - - Classically: A LeaveNotify is generated on W with a detail of Virtual - or NonlinearVirtual. - - MPX: - Case 3A: There is at least one other pointer on W itself - P(W) doesn't change, the event should be suppressed. - Case 3B: Otherwise, if there is at least one other pointer in a - descendant - P(W) stays on the same descendant, or changes to a different - descendant. The event should be suppressed. - Case 3C: Otherwise: - P(W) changes from the descendant of W to a window above W. - The detail may need to be changed from Virtual to NonlinearVirtual - or vice-versa depending on the new P(W).*/ - - /* If one window has a pointer or a child with a pointer, skip some - * work and exit. */ - if (HasPointer(dev, win) || FirstPointerChild(win)) - return; - - CoreEnterLeaveEvent(dev, LeaveNotify, mode, detail, win, child->drawable.id); - - child = win; - } -} - -/** - * Send leave notifies to all windows between 'child' and 'ancestor'. - * Events are sent running up the hierarchy. - */ -static void -DeviceLeaveNotifies(DeviceIntPtr dev, - int sourceid, - WindowPtr child, - WindowPtr ancestor, - int mode, - int detail) -{ - WindowPtr win; - - if (ancestor == child) - return; - for (win = child->parent; win != ancestor; win = win->parent) - { - DeviceEnterLeaveEvent(dev, sourceid, XI_Leave, mode, detail, win, - child->drawable.id); - child = win; - } -} - -/** - * Pointer dev moves from A to B and A neither a descendant of B nor is - * B a descendant of A. - */ -static void -CoreEnterLeaveNonLinear(DeviceIntPtr dev, - WindowPtr A, - WindowPtr B, - int mode) -{ - WindowPtr X = CommonAncestor(A, B); - /* Case 4: - A is W, B is above W - - Classically: The move generates a LeaveNotify on W with a detail of - Ancestor or Nonlinear - - MPX: - Case 3A: There is at least one other pointer on W itself - P(W) doesn't change, the event should be suppressed - Case 3B: Otherwise, if there is at least one other pointer in a - descendant of W - P(W) changes from W to a descendant of W. The subwindow field - is set to the child containing the new P(W), the detail field - is set to Inferior - Case 3C: Otherwise: - The pointer window moves from W to a window above W. - The detail may need to be changed from Ancestor to Nonlinear or - vice versa depending on the the new P(W) - */ - - if (!HasPointer(dev, A)) - { - WindowPtr child = FirstPointerChild(A); - if (child) - CoreEnterLeaveEvent(dev, LeaveNotify, mode, NotifyInferior, A, None); - else - CoreEnterLeaveEvent(dev, LeaveNotify, mode, NotifyNonlinear, A, None); - } - - - CoreLeaveNotifies(dev, A, X, mode, NotifyNonlinearVirtual); - - /* - Case 9: - A is a descendant of W, B is a descendant of W - - Classically: No events are generated on W - MPX: The pointer window stays the same or moves to a different - descendant of W. No events should be generated on W. - - - Therefore, no event to X. - */ - - CoreEnterNotifies(dev, X, B, mode, NotifyNonlinearVirtual); - - /* Case 2: - A is above W, B=W - - Classically: The move generates an EnterNotify on W with a detail of - Ancestor or Nonlinear - - MPX: - Case 2A: There is at least one other pointer on W itself - P(W) doesn't change, so the event should be suppressed - Case 2B: Otherwise, if there is at least one other pointer in a - descendant - P(W) moves from a descendant to W. detail is changed to Inferior, - subwindow is set to the child containing the previous P(W) - Case 2C: Otherwise: - P(W) changes from a window above W to W itself. - The detail may need to be changed from Ancestor to Nonlinear - or vice-versa depending on the previous P(W). */ - - if (!HasPointer(dev, B)) - { - WindowPtr child = FirstPointerChild(B); - if (child) - CoreEnterLeaveEvent(dev, EnterNotify, mode, NotifyInferior, B, None); - else - CoreEnterLeaveEvent(dev, EnterNotify, mode, NotifyNonlinear, B, None); - } -} - -/** - * Pointer dev moves from A to B and A is a descendant of B. - */ -static void -CoreEnterLeaveToAncestor(DeviceIntPtr dev, - WindowPtr A, - WindowPtr B, - int mode) -{ - /* Case 4: - A is W, B is above W - - Classically: The move generates a LeaveNotify on W with a detail of - Ancestor or Nonlinear - - MPX: - Case 3A: There is at least one other pointer on W itself - P(W) doesn't change, the event should be suppressed - Case 3B: Otherwise, if there is at least one other pointer in a - descendant of W - P(W) changes from W to a descendant of W. The subwindow field - is set to the child containing the new P(W), the detail field - is set to Inferior - Case 3C: Otherwise: - The pointer window moves from W to a window above W. - The detail may need to be changed from Ancestor to Nonlinear or - vice versa depending on the the new P(W) - */ - if (!HasPointer(dev, A)) - { - WindowPtr child = FirstPointerChild(A); - if (child) - CoreEnterLeaveEvent(dev, LeaveNotify, mode, NotifyInferior, A, None); - else - CoreEnterLeaveEvent(dev, LeaveNotify, mode, NotifyAncestor, A, None); - } - - CoreLeaveNotifies(dev, A, B, mode, NotifyVirtual); - - /* Case 8: - A is a descendant of W, B is W - - Classically: A EnterNotify is generated on W with a detail of - NotifyInferior - - MPX: - Case 3A: There is at least one other pointer on W itself - P(W) doesn't change, the event should be suppressed - Case 3B: Otherwise: - P(W) changes from a descendant to W itself. The subwindow - field should be set to the child containing the old P(W) <<< WRONG */ - - if (!HasPointer(dev, B)) - CoreEnterLeaveEvent(dev, EnterNotify, mode, NotifyInferior, B, None); - -} - - -/** - * Pointer dev moves from A to B and B is a descendant of A. - */ -static void -CoreEnterLeaveToDescendant(DeviceIntPtr dev, - WindowPtr A, - WindowPtr B, - int mode) -{ - /* Case 6: - A is W, B is a descendant of W - - Classically: A LeaveNotify is generated on W with a detail of - NotifyInferior - - MPX: - Case 3A: There is at least one other pointer on W itself - P(W) doesn't change, the event should be suppressed - Case 3B: Otherwise: - P(W) changes from W to a descendant of W. The subwindow field - is set to the child containing the new P(W) <<< THIS IS WRONG */ - - if (!HasPointer(dev, A)) - CoreEnterLeaveEvent(dev, LeaveNotify, mode, NotifyInferior, A, None); - - - CoreEnterNotifies(dev, A, B, mode, NotifyVirtual); - - /* Case 2: - A is above W, B=W - - Classically: The move generates an EnterNotify on W with a detail of - Ancestor or Nonlinear - - MPX: - Case 2A: There is at least one other pointer on W itself - P(W) doesn't change, so the event should be suppressed - Case 2B: Otherwise, if there is at least one other pointer in a - descendant - P(W) moves from a descendant to W. detail is changed to Inferior, - subwindow is set to the child containing the previous P(W) - Case 2C: Otherwise: - P(W) changes from a window above W to W itself. - The detail may need to be changed from Ancestor to Nonlinear - or vice-versa depending on the previous P(W). */ - - if (!HasPointer(dev, B)) - { - WindowPtr child = FirstPointerChild(B); - if (child) - CoreEnterLeaveEvent(dev, EnterNotify, mode, NotifyInferior, B, None); - else - CoreEnterLeaveEvent(dev, EnterNotify, mode, NotifyAncestor, B, None); - } -} - -static void -CoreEnterLeaveEvents(DeviceIntPtr dev, - WindowPtr from, - WindowPtr to, - int mode) -{ - if (!IsMaster(dev)) - return; - - LeaveWindow(dev); - - if (IsParent(from, to)) - CoreEnterLeaveToDescendant(dev, from, to, mode); - else if (IsParent(to, from)) - CoreEnterLeaveToAncestor(dev, from, to, mode); - else - CoreEnterLeaveNonLinear(dev, from, to, mode); - - EnterWindow(dev, to, mode); -} - -static void -DeviceEnterLeaveEvents(DeviceIntPtr dev, - int sourceid, - WindowPtr from, - WindowPtr to, - int mode) -{ - if (IsParent(from, to)) - { - DeviceEnterLeaveEvent(dev, sourceid, XI_Leave, mode, NotifyInferior, from, None); - DeviceEnterNotifies(dev, sourceid, from, to, mode, NotifyVirtual); - DeviceEnterLeaveEvent(dev, sourceid, XI_Enter, mode, NotifyAncestor, to, None); - } - else if (IsParent(to, from)) - { - DeviceEnterLeaveEvent(dev, sourceid, XI_Leave, mode, NotifyAncestor, from, None); - DeviceLeaveNotifies(dev, sourceid, from, to, mode, NotifyVirtual); - DeviceEnterLeaveEvent(dev, sourceid, XI_Enter, mode, NotifyInferior, to, None); - } - else - { /* neither from nor to is descendent of the other */ - WindowPtr common = CommonAncestor(to, from); - /* common == NullWindow ==> different screens */ - DeviceEnterLeaveEvent(dev, sourceid, XI_Leave, mode, NotifyNonlinear, from, None); - DeviceLeaveNotifies(dev, sourceid, from, common, mode, NotifyNonlinearVirtual); - DeviceEnterNotifies(dev, sourceid, common, to, mode, NotifyNonlinearVirtual); - DeviceEnterLeaveEvent(dev, sourceid, XI_Enter, mode, NotifyNonlinear, to, None); - } -} - -/** - * Figure out if enter/leave events are necessary and send them to the - * appropriate windows. - * - * @param fromWin Window the sprite moved out of. - * @param toWin Window the sprite moved into. - */ -void -DoEnterLeaveEvents(DeviceIntPtr pDev, - int sourceid, - WindowPtr fromWin, - WindowPtr toWin, - int mode) -{ - if (!IsPointerDevice(pDev)) - return; - - if (fromWin == toWin) - return; - - if (mode != XINotifyPassiveGrab && mode != XINotifyPassiveUngrab) - CoreEnterLeaveEvents(pDev, fromWin, toWin, mode); - DeviceEnterLeaveEvents(pDev, sourceid, fromWin, toWin, mode); -} - -/** - * Send focus out events to all windows between 'child' and 'ancestor'. - * Events are sent running up the hierarchy. - */ -static void -DeviceFocusOutEvents(DeviceIntPtr dev, - WindowPtr child, - WindowPtr ancestor, - int mode, - int detail) -{ - WindowPtr win; - - if (ancestor == child) - return; - for (win = child->parent; win != ancestor; win = win->parent) - DeviceFocusEvent(dev, XI_FocusOut, mode, detail, win); -} - - -/** - * Send enter notifies to all windows between 'ancestor' and 'child' (excluding - * both). Events are sent running up the window hierarchy. This function - * recurses. - */ -static void -DeviceFocusInEvents(DeviceIntPtr dev, - WindowPtr ancestor, - WindowPtr child, - int mode, - int detail) -{ - WindowPtr parent = child->parent; - - if (ancestor == parent || !parent) - return; - DeviceFocusInEvents(dev, ancestor, parent, mode, detail); - DeviceFocusEvent(dev, XI_FocusIn, mode, detail, parent); -} - -/** - * Send FocusIn events to all windows between 'ancestor' and 'child' (excluding - * both). Events are sent running down the window hierarchy. This function - * recurses. - */ -static void -CoreFocusInEvents(DeviceIntPtr dev, - WindowPtr ancestor, - WindowPtr child, - int mode, - int detail) -{ - WindowPtr parent = child->parent; - if (ancestor == parent) - return; - CoreFocusInEvents(dev, ancestor, parent, mode, detail); - - - /* Case 3: - A is above W, B is a descendant - - Classically: The move generates an FocusIn on W with a detail of - Virtual or NonlinearVirtual - - MPX: - Case 3A: There is at least one other focus on W itself - F(W) doesn't change, so the event should be suppressed - Case 3B: Otherwise, if there is at least one other focus in a - descendant - F(W) stays on the same descendant, or changes to a different - descendant. The event should be suppressed. - Case 3C: Otherwise: - F(W) moves from a window above W to a descendant. The detail may - need to be changed from Virtual to NonlinearVirtual depending - on the previous F(W). */ - - if (!HasFocus(parent) && !FirstFocusChild(parent)) - CoreFocusEvent(dev, FocusIn, mode, detail, parent); -} - -static void -CoreFocusOutEvents(DeviceIntPtr dev, - WindowPtr child, - WindowPtr ancestor, - int mode, - int detail) -{ - WindowPtr win; - - if (ancestor == child) - return; - - for (win = child->parent; win != ancestor; win = win->parent) - { - /*Case 7: - A is a descendant of W, B is above W - - Classically: A FocusOut is generated on W with a detail of Virtual - or NonlinearVirtual. - - MPX: - Case 3A: There is at least one other focus on W itself - F(W) doesn't change, the event should be suppressed. - Case 3B: Otherwise, if there is at least one other focus in a - descendant - F(W) stays on the same descendant, or changes to a different - descendant. The event should be suppressed. - Case 3C: Otherwise: - F(W) changes from the descendant of W to a window above W. - The detail may need to be changed from Virtual to NonlinearVirtual - or vice-versa depending on the new P(W).*/ - - /* If one window has a focus or a child with a focuspointer, skip some - * work and exit. */ - if (HasFocus(win) || FirstFocusChild(win)) - return; - - CoreFocusEvent(dev, FocusOut, mode, detail, win); - } -} - -/** - * Send FocusOut(NotifyPointer) events from the current pointer window (which - * is a descendant of pwin_parent) up to (excluding) pwin_parent. - * - * NotifyPointer events are only sent for the device paired with dev. - * - * If the current pointer window is a descendant of 'exclude' or an ancestor of - * 'exclude', no events are sent. If the current pointer IS 'exclude', events - * are sent! - */ -static void -CoreFocusOutNotifyPointerEvents(DeviceIntPtr dev, - WindowPtr pwin_parent, - WindowPtr exclude, - int mode, - int inclusive) -{ - WindowPtr P, stopAt; - - P = PointerWin(GetPairedDevice(dev)); - - if (!P) - return; - if (!IsParent(pwin_parent, P)) - if (!(pwin_parent == P && inclusive)) - return; - - if (exclude != None && exclude != PointerRootWin && - (IsParent(exclude, P) || IsParent(P, exclude))) - return; - - stopAt = (inclusive) ? pwin_parent->parent : pwin_parent; - - for (; P && P != stopAt; P = P->parent) - CoreFocusEvent(dev, FocusOut, mode, NotifyPointer, P); -} - -/** - * DO NOT CALL DIRECTLY. - * Recursion helper for CoreFocusInNotifyPointerEvents. - */ -static void -CoreFocusInRecurse(DeviceIntPtr dev, - WindowPtr win, - WindowPtr stopAt, - int mode, - int inclusive) -{ - if ((!inclusive && win == stopAt) || !win) - return; - - CoreFocusInRecurse(dev, win->parent, stopAt, mode, inclusive); - CoreFocusEvent(dev, FocusIn, mode, NotifyPointer, win); -} - - -/** - * Send FocusIn(NotifyPointer) events from pwin_parent down to - * including the current pointer window (which is a descendant of pwin_parent). - * - * @param pwin The pointer window. - * @param exclude If the pointer window is a child of 'exclude', no events are - * sent. - * @param inclusive If TRUE, pwin_parent will receive the event too. - */ -static void -CoreFocusInNotifyPointerEvents(DeviceIntPtr dev, - WindowPtr pwin_parent, - WindowPtr exclude, - int mode, - int inclusive) -{ - WindowPtr P; - - P = PointerWin(GetPairedDevice(dev)); - - if (!P || P == exclude || (pwin_parent != P && !IsParent(pwin_parent, P))) - return; - - if (exclude != None && (IsParent(exclude, P) || IsParent(P, exclude))) - return; - - CoreFocusInRecurse(dev, P, pwin_parent, mode, inclusive); -} - - -/** - * Focus of dev moves from A to B and A neither a descendant of B nor is - * B a descendant of A. - */ -static void -CoreFocusNonLinear(DeviceIntPtr dev, - WindowPtr A, - WindowPtr B, - int mode) -{ - WindowPtr X = CommonAncestor(A, B); - - /* Case 4: - A is W, B is above W - - Classically: The change generates a FocusOut on W with a detail of - Ancestor or Nonlinear - - MPX: - Case 3A: There is at least one other focus on W itself - F(W) doesn't change, the event should be suppressed - Case 3B: Otherwise, if there is at least one other focus in a - descendant of W - F(W) changes from W to a descendant of W. The detail field - is set to Inferior - Case 3C: Otherwise: - The focus window moves from W to a window above W. - The detail may need to be changed from Ancestor to Nonlinear or - vice versa depending on the the new F(W) - */ - - if (!HasFocus(A)) - { - WindowPtr child = FirstFocusChild(A); - if (child) - { - /* NotifyPointer P-A unless P is child or below*/ - CoreFocusOutNotifyPointerEvents(dev, A, child, mode, FALSE); - CoreFocusEvent(dev, FocusOut, mode, NotifyInferior, A); - } else - { - /* NotifyPointer P-A */ - CoreFocusOutNotifyPointerEvents(dev, A, None, mode, FALSE); - CoreFocusEvent(dev, FocusOut, mode, NotifyNonlinear, A); - } - } - - - CoreFocusOutEvents(dev, A, X, mode, NotifyNonlinearVirtual); - - /* - Case 9: - A is a descendant of W, B is a descendant of W - - Classically: No events are generated on W - MPX: The focus window stays the same or moves to a different - descendant of W. No events should be generated on W. - - - Therefore, no event to X. - */ - - CoreFocusInEvents(dev, X, B, mode, NotifyNonlinearVirtual); - - /* Case 2: - A is above W, B=W - - Classically: The move generates an EnterNotify on W with a detail of - Ancestor or Nonlinear - - MPX: - Case 2A: There is at least one other focus on W itself - F(W) doesn't change, so the event should be suppressed - Case 2B: Otherwise, if there is at least one other focus in a - descendant - F(W) moves from a descendant to W. detail is changed to Inferior. - Case 2C: Otherwise: - F(W) changes from a window above W to W itself. - The detail may need to be changed from Ancestor to Nonlinear - or vice-versa depending on the previous F(W). */ - - if (!HasFocus(B)) - { - WindowPtr child = FirstFocusChild(B); - if (child) - { - CoreFocusEvent(dev, FocusIn, mode, NotifyInferior, B); - /* NotifyPointer B-P unless P is child or below. */ - CoreFocusInNotifyPointerEvents(dev, B, child, mode, FALSE); - } else { - CoreFocusEvent(dev, FocusIn, mode, NotifyNonlinear, B); - /* NotifyPointer B-P unless P is child or below. */ - CoreFocusInNotifyPointerEvents(dev, B, None, mode, FALSE); - } - } -} - - -/** - * Focus of dev moves from A to B and A is a descendant of B. - */ -static void -CoreFocusToAncestor(DeviceIntPtr dev, - WindowPtr A, - WindowPtr B, - int mode) -{ - /* Case 4: - A is W, B is above W - - Classically: The change generates a FocusOut on W with a detail of - Ancestor or Nonlinear - - MPX: - Case 3A: There is at least one other focus on W itself - F(W) doesn't change, the event should be suppressed - Case 3B: Otherwise, if there is at least one other focus in a - descendant of W - F(W) changes from W to a descendant of W. The detail field - is set to Inferior - Case 3C: Otherwise: - The focus window moves from W to a window above W. - The detail may need to be changed from Ancestor to Nonlinear or - vice versa depending on the the new F(W) - */ - if (!HasFocus(A)) - { - WindowPtr child = FirstFocusChild(A); - if (child) - { - /* NotifyPointer P-A unless P is child or below*/ - CoreFocusOutNotifyPointerEvents(dev, A, child, mode, FALSE); - CoreFocusEvent(dev, FocusOut, mode, NotifyInferior, A); - } else - CoreFocusEvent(dev, FocusOut, mode, NotifyAncestor, A); - } - - CoreFocusOutEvents(dev, A, B, mode, NotifyVirtual); - - /* Case 8: - A is a descendant of W, B is W - - Classically: A FocusOut is generated on W with a detail of - NotifyInferior - - MPX: - Case 3A: There is at least one other focus on W itself - F(W) doesn't change, the event should be suppressed - Case 3B: Otherwise: - F(W) changes from a descendant to W itself. */ - - if (!HasFocus(B)) - { - CoreFocusEvent(dev, FocusIn, mode, NotifyInferior, B); - /* NotifyPointer B-P unless P is A or below. */ - CoreFocusInNotifyPointerEvents(dev, B, A, mode, FALSE); - } -} - -/** - * Focus of dev moves from A to B and B is a descendant of A. - */ -static void -CoreFocusToDescendant(DeviceIntPtr dev, - WindowPtr A, - WindowPtr B, - int mode) -{ - /* Case 6: - A is W, B is a descendant of W - - Classically: A FocusOut is generated on W with a detail of - NotifyInferior - - MPX: - Case 3A: There is at least one other focus on W itself - F(W) doesn't change, the event should be suppressed - Case 3B: Otherwise: - F(W) changes from W to a descendant of W. */ - - if (!HasFocus(A)) - { - /* NotifyPointer P-A unless P is B or below*/ - CoreFocusOutNotifyPointerEvents(dev, A, B, mode, FALSE); - CoreFocusEvent(dev, FocusOut, mode, NotifyInferior, A); - } - - - CoreFocusInEvents(dev, A, B, mode, NotifyVirtual); - - /* Case 2: - A is above W, B=W - - Classically: The move generates an FocusIn on W with a detail of - Ancestor or Nonlinear - - MPX: - Case 2A: There is at least one other focus on W itself - F(W) doesn't change, so the event should be suppressed - Case 2B: Otherwise, if there is at least one other focus in a - descendant - F(W) moves from a descendant to W. detail is changed to Inferior. - Case 2C: Otherwise: - F(W) changes from a window above W to W itself. - The detail may need to be changed from Ancestor to Nonlinear - or vice-versa depending on the previous F(W). */ - - if (!HasFocus(B)) - { - WindowPtr child = FirstFocusChild(B); - if (child) - { - CoreFocusEvent(dev, FocusIn, mode, NotifyInferior, B); - /* NotifyPointer B-P unless P is child or below. */ - CoreFocusInNotifyPointerEvents(dev, B, child, mode, FALSE); - } else - CoreFocusEvent(dev, FocusIn, mode, NotifyAncestor, B); - } -} - -static BOOL -HasOtherPointer(WindowPtr win, DeviceIntPtr exclude) -{ - int i; - - for (i = 0; i < MAXDEVICES; i++) - if (i != exclude->id && PointerWindows[i] == win) - return TRUE; - - return FALSE; -} - -/** - * Focus moves from PointerRoot to None or from None to PointerRoot. - * Assumption: Neither A nor B are valid windows. - */ -static void -CoreFocusPointerRootNoneSwitch(DeviceIntPtr dev, - WindowPtr A, /* PointerRootWin or NoneWin */ - WindowPtr B, /* NoneWin or PointerRootWin */ - int mode) -{ - WindowPtr root; - int i; - int nscreens = screenInfo.numScreens; - -#ifdef PANORAMIX - if (!noPanoramiXExtension) - nscreens = 1; -#endif - - for (i = 0; i < nscreens; i++) - { - root = screenInfo.screens[i]->root; - if (!HasOtherPointer(root, GetPairedDevice(dev)) && !FirstFocusChild(root)) - { - /* If pointer was on PointerRootWin and changes to NoneWin, and - * the pointer paired with dev is below the current root window, - * do a NotifyPointer run. */ - if (dev->focus && dev->focus->win == PointerRootWin && - B != PointerRootWin) - { - WindowPtr ptrwin = PointerWin(GetPairedDevice(dev)); - if (ptrwin && IsParent(root, ptrwin)) - CoreFocusOutNotifyPointerEvents(dev, root, None, mode, TRUE); - } - CoreFocusEvent(dev, FocusOut, mode, A ? NotifyPointerRoot : NotifyDetailNone, root); - CoreFocusEvent(dev, FocusIn, mode, B ? NotifyPointerRoot : NotifyDetailNone, root); - if (B == PointerRootWin) - CoreFocusInNotifyPointerEvents(dev, root, None, mode, TRUE); - } - - } -} - -/** - * Focus moves from window A to PointerRoot or to None. - * Assumption: A is a valid window and not PointerRoot or None. - */ -static void -CoreFocusToPointerRootOrNone(DeviceIntPtr dev, - WindowPtr A, - WindowPtr B, /* PointerRootWin or NoneWin */ - int mode) -{ - WindowPtr root; - int i; - int nscreens = screenInfo.numScreens; - -#ifdef PANORAMIX - if (!noPanoramiXExtension) - nscreens = 1; -#endif - - if (!HasFocus(A)) - { - WindowPtr child = FirstFocusChild(A); - if (child) - { - /* NotifyPointer P-A unless P is B or below*/ - CoreFocusOutNotifyPointerEvents(dev, A, B, mode, FALSE); - CoreFocusEvent(dev, FocusOut, mode, NotifyInferior, A); - } else { - /* NotifyPointer P-A */ - CoreFocusOutNotifyPointerEvents(dev, A, None, mode, FALSE); - CoreFocusEvent(dev, FocusOut, mode, NotifyNonlinear, A); - } - } - - /* NullWindow means we include the root window */ - CoreFocusOutEvents(dev, A, NullWindow, mode, NotifyNonlinearVirtual); - - for (i = 0; i < nscreens; i++) - { - root = screenInfo.screens[i]->root; - if (!HasFocus(root) && !FirstFocusChild(root)) - { - CoreFocusEvent(dev, FocusIn, mode, B ? NotifyPointerRoot : NotifyDetailNone, root); - if (B == PointerRootWin) - CoreFocusInNotifyPointerEvents(dev, root, None, mode, TRUE); - } - } -} - -/** - * Focus moves from PointerRoot or None to a window B. - * Assumption: B is a valid window and not PointerRoot or None. - */ -static void -CoreFocusFromPointerRootOrNone(DeviceIntPtr dev, - WindowPtr A, /* PointerRootWin or NoneWin */ - WindowPtr B, - int mode) -{ - WindowPtr root; - int i; - int nscreens = screenInfo.numScreens; - -#ifdef PANORAMIX - if (!noPanoramiXExtension) - nscreens = 1; -#endif - - for (i = 0; i < nscreens; i++) - { - root = screenInfo.screens[i]->root; - if (!HasFocus(root) && !FirstFocusChild(root)) - { - /* If pointer was on PointerRootWin and changes to NoneWin, and - * the pointer paired with dev is below the current root window, - * do a NotifyPointer run. */ - if (dev->focus && dev->focus->win == PointerRootWin && - B != PointerRootWin) - { - WindowPtr ptrwin = PointerWin(GetPairedDevice(dev)); - if (ptrwin) - CoreFocusOutNotifyPointerEvents(dev, root, None, mode, TRUE); - } - CoreFocusEvent(dev, FocusOut, mode, A ? NotifyPointerRoot : NotifyDetailNone, root); - } - } - - root = B; /* get B's root window */ - while(root->parent) - root = root->parent; - - if (B != root) - { - CoreFocusEvent(dev, FocusIn, mode, NotifyNonlinearVirtual, root); - CoreFocusInEvents(dev, root, B, mode, NotifyNonlinearVirtual); - } - - - if (!HasFocus(B)) - { - WindowPtr child = FirstFocusChild(B); - if (child) - { - CoreFocusEvent(dev, FocusIn, mode, NotifyInferior, B); - /* NotifyPointer B-P unless P is child or below. */ - CoreFocusInNotifyPointerEvents(dev, B, child, mode, FALSE); - } else { - CoreFocusEvent(dev, FocusIn, mode, NotifyNonlinear, B); - /* NotifyPointer B-P unless P is child or below. */ - CoreFocusInNotifyPointerEvents(dev, B, None, mode, FALSE); - } - } - -} - -static void -CoreFocusEvents(DeviceIntPtr dev, - WindowPtr from, - WindowPtr to, - int mode) -{ - if (!IsMaster(dev)) - return; - - SetFocusOut(dev); - - if (((to == NullWindow) || (to == PointerRootWin)) && - ((from == NullWindow) || (from == PointerRootWin))) - CoreFocusPointerRootNoneSwitch(dev, from, to, mode); - else if ((to == NullWindow) || (to == PointerRootWin)) - CoreFocusToPointerRootOrNone(dev, from, to, mode); - else if ((from == NullWindow) || (from == PointerRootWin)) - CoreFocusFromPointerRootOrNone(dev, from, to, mode); - else if (IsParent(from, to)) - CoreFocusToDescendant(dev, from, to, mode); - else if (IsParent(to, from)) - CoreFocusToAncestor(dev, from, to, mode); - else - CoreFocusNonLinear(dev, from, to, mode); - - SetFocusIn(dev, to); -} - -static void -DeviceFocusEvents(DeviceIntPtr dev, - WindowPtr from, - WindowPtr to, - int mode) -{ - int out, in; /* for holding details for to/from - PointerRoot/None */ - int i; - int nscreens = screenInfo.numScreens; - SpritePtr sprite = dev->spriteInfo->sprite; - - if (from == to) - return; - out = (from == NoneWin) ? NotifyDetailNone : NotifyPointerRoot; - in = (to == NoneWin) ? NotifyDetailNone : NotifyPointerRoot; - /* wrong values if neither, but then not referenced */ - -#ifdef PANORAMIX - if (!noPanoramiXExtension) - nscreens = 1; -#endif - - if ((to == NullWindow) || (to == PointerRootWin)) - { - if ((from == NullWindow) || (from == PointerRootWin)) - { - if (from == PointerRootWin) - DeviceFocusOutEvents(dev, sprite->win, GetCurrentRootWindow(dev), mode, - NotifyPointer); - /* Notify all the roots */ - for (i = 0; i < nscreens; i++) - DeviceFocusEvent(dev, XI_FocusOut, mode, out, screenInfo.screens[i]->root); - } - else - { - if (IsParent(from, sprite->win)) - DeviceFocusOutEvents(dev, sprite->win, from, mode, - NotifyPointer); - DeviceFocusEvent(dev, XI_FocusOut, mode, NotifyNonlinear, from); - /* next call catches the root too, if the screen changed */ - DeviceFocusOutEvents(dev, from->parent, NullWindow, mode, - NotifyNonlinearVirtual); - } - /* Notify all the roots */ - for (i = 0; i < nscreens; i++) - DeviceFocusEvent(dev, XI_FocusIn, mode, in, screenInfo.screens[i]->root); - if (to == PointerRootWin) - DeviceFocusInEvents(dev, GetCurrentRootWindow(dev), sprite->win, mode, NotifyPointer); - } - else - { - if ((from == NullWindow) || (from == PointerRootWin)) - { - if (from == PointerRootWin) - DeviceFocusOutEvents(dev, sprite->win, GetCurrentRootWindow(dev), mode, - NotifyPointer); - for (i = 0; i < nscreens; i++) - DeviceFocusEvent(dev, XI_FocusOut, mode, out, screenInfo.screens[i]->root); - if (to->parent != NullWindow) - DeviceFocusInEvents(dev, GetCurrentRootWindow(dev), to, mode, NotifyNonlinearVirtual); - DeviceFocusEvent(dev, XI_FocusIn, mode, NotifyNonlinear, to); - if (IsParent(to, sprite->win)) - DeviceFocusInEvents(dev, to, sprite->win, mode, NotifyPointer); - } - else - { - if (IsParent(to, from)) - { - DeviceFocusEvent(dev, XI_FocusOut, mode, NotifyAncestor, from); - DeviceFocusOutEvents(dev, from->parent, to, mode, - NotifyVirtual); - DeviceFocusEvent(dev, XI_FocusIn, mode, NotifyInferior, to); - if ((IsParent(to, sprite->win)) && - (sprite->win != from) && - (!IsParent(from, sprite->win)) && - (!IsParent(sprite->win, from))) - DeviceFocusInEvents(dev, to, sprite->win, mode, NotifyPointer); - } - else - if (IsParent(from, to)) - { - if ((IsParent(from, sprite->win)) && - (sprite->win != from) && - (!IsParent(to, sprite->win)) && - (!IsParent(sprite->win, to))) - DeviceFocusOutEvents(dev, sprite->win, from, mode, - NotifyPointer); - DeviceFocusEvent(dev, XI_FocusOut, mode, NotifyInferior, from); - DeviceFocusInEvents(dev, from, to, mode, NotifyVirtual); - DeviceFocusEvent(dev, XI_FocusIn, mode, NotifyAncestor, to); - } - else - { - /* neither from or to is child of other */ - WindowPtr common = CommonAncestor(to, from); - /* common == NullWindow ==> different screens */ - if (IsParent(from, sprite->win)) - DeviceFocusOutEvents(dev, sprite->win, from, mode, - NotifyPointer); - DeviceFocusEvent(dev, XI_FocusOut, mode, NotifyNonlinear, from); - if (from->parent != NullWindow) - DeviceFocusOutEvents(dev, from->parent, common, mode, - NotifyNonlinearVirtual); - if (to->parent != NullWindow) - DeviceFocusInEvents(dev, common, to, mode, NotifyNonlinearVirtual); - DeviceFocusEvent(dev, XI_FocusIn, mode, NotifyNonlinear, to); - if (IsParent(to, sprite->win)) - DeviceFocusInEvents(dev, to, sprite->win, mode, NotifyPointer); - } - } - } -} - -/** - * Figure out if focus events are necessary and send them to the - * appropriate windows. - * - * @param from Window the focus moved out of. - * @param to Window the focus moved into. - */ -void -DoFocusEvents(DeviceIntPtr pDev, - WindowPtr from, - WindowPtr to, - int mode) -{ - if (!IsKeyboardDevice(pDev)) - return; - - if (from == to) - return; - - CoreFocusEvents(pDev, from, to, mode); - DeviceFocusEvents(pDev, from, to, mode); -} +/* + * Copyright © 2008 Red Hat, Inc. + * + * 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 (including the next + * paragraph) 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 OR COPYRIGHT HOLDERS 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. + * + * Authors: Peter Hutterer + * + */ + +#ifdef HAVE_DIX_CONFIG_H +#include +#endif + +#include +#include +#include "inputstr.h" +#include "windowstr.h" +#include "scrnintstr.h" +#include "exglobals.h" +#include "enterleave.h" + +/** + * @file + * This file describes the model for sending core enter/leave events and + * focus in/out in the case of multiple pointers/keyboard foci. + * + * Since we can't send more than one Enter or Leave/Focus in or out event per + * window to a core client without confusing it, this is a rather complicated + * approach. + * + * For a full description of the enter/leave model from a window's + * perspective, see + * http://lists.freedesktop.org/archives/xorg/2008-August/037606.html + * + * For a full description of the focus in/out model from a window's + * perspective, see + * http://lists.freedesktop.org/archives/xorg/2008-December/041740.html + * + * Additional notes: + * - The core protocol spec says that "In a LeaveNotify event, if a child of the + * event window contains the initial position of the pointer, then the child + * component is set to that child. Otherwise, it is None. For an EnterNotify + * event, if a child of the event window contains the final pointer position, + * then the child component is set to that child. Otherwise, it is None." + * + * By inference, this means that only NotifyVirtual or NotifyNonlinearVirtual + * events may have a subwindow set to other than None. + * + * - NotifyPointer events may be sent if the focus changes from window A to + * B. The assumption used in this model is that NotifyPointer events are only + * sent for the pointer paired with the keyboard that is involved in the focus + * events. For example, if F(W) changes because of keyboard 2, then + * NotifyPointer events are only sent for pointer 2. + */ + +static WindowPtr PointerWindows[MAXDEVICES]; +static WindowPtr FocusWindows[MAXDEVICES]; + +/** + * Return TRUE if 'win' has a pointer within its boundaries, excluding child + * window. + */ +static BOOL +HasPointer(DeviceIntPtr dev, WindowPtr win) +{ + int i; + + /* FIXME: The enter/leave model does not cater for grabbed devices. For + * now, a quickfix: if the device about to send an enter/leave event to + * a window is grabbed, assume there is no pointer in that window. + * Fixes fdo 27804. + * There isn't enough beer in my fridge to fix this properly. + */ + if (dev->deviceGrab.grab) + return FALSE; + + for (i = 0; i < MAXDEVICES; i++) + if (PointerWindows[i] == win) + return TRUE; + + return FALSE; +} + +/** + * Return TRUE if at least one keyboard focus is set to 'win' (excluding + * descendants of win). + */ +static BOOL +HasFocus(WindowPtr win) +{ + int i; + for (i = 0; i < MAXDEVICES; i++) + if (FocusWindows[i] == win) + return TRUE; + + return FALSE; +} + +/** + * Return the window the device dev is currently on. + */ +static WindowPtr +PointerWin(DeviceIntPtr dev) +{ + return PointerWindows[dev->id]; +} + +/** + * Search for the first window below 'win' that has a pointer directly within + * it's boundaries (excluding boundaries of its own descendants). + * + * @return The child window that has the pointer within its boundaries or + * NULL. + */ +static WindowPtr +FirstPointerChild(WindowPtr win) +{ + int i; + for (i = 0; i < MAXDEVICES; i++) + { + if (PointerWindows[i] && IsParent(win, PointerWindows[i])) + return PointerWindows[i]; + } + + return NULL; +} + +/** + * Search for the first window below 'win' that has a focus directly within + * it's boundaries (excluding boundaries of its own descendants). + * + * @return The child window that has the pointer within its boundaries or + * NULL. + */ +static WindowPtr +FirstFocusChild(WindowPtr win) +{ + int i; + for (i = 0; i < MAXDEVICES; i++) + { + if (FocusWindows[i] && FocusWindows[i] != PointerRootWin && + IsParent(win, FocusWindows[i])) + return FocusWindows[i]; + } + + return NULL; +} + +/** + * Set the presence flag for dev to mark that it is now in 'win'. + */ +void +EnterWindow(DeviceIntPtr dev, WindowPtr win, int mode) +{ + PointerWindows[dev->id] = win; +} + +/** + * Unset the presence flag for dev to mark that it is not in 'win' anymore. + */ +void +LeaveWindow(DeviceIntPtr dev) +{ + PointerWindows[dev->id] = NULL; +} + +/** + * Set the presence flag for dev to mark that it is now in 'win'. + */ +void +SetFocusIn(DeviceIntPtr dev, WindowPtr win) +{ + FocusWindows[dev->id] = win; +} + +/** + * Unset the presence flag for dev to mark that it is not in 'win' anymore. + */ +void +SetFocusOut(DeviceIntPtr dev) +{ + FocusWindows[dev->id] = NULL; +} + + + + +/** + * Return the common ancestor of 'a' and 'b' (if one exists). + * @param a A window with the same ancestor as b. + * @param b A window with the same ancestor as a. + * @return The window that is the first ancestor of both 'a' and 'b', or the + * NullWindow if they do not have a common ancestor. + */ +WindowPtr +CommonAncestor( + WindowPtr a, + WindowPtr b) +{ + for (b = b->parent; b; b = b->parent) + if (IsParent(b, a)) return b; + return NullWindow; +} + + +/** + * Send enter notifies to all windows between 'ancestor' and 'child' (excluding + * both). Events are sent running up the window hierarchy. This function + * recurses. + */ +static void +DeviceEnterNotifies(DeviceIntPtr dev, + int sourceid, + WindowPtr ancestor, + WindowPtr child, + int mode, + int detail) +{ + WindowPtr parent = child->parent; + + if (ancestor == parent) + return; + DeviceEnterNotifies(dev, sourceid, ancestor, parent, mode, detail); + DeviceEnterLeaveEvent(dev, sourceid, XI_Enter, mode, detail, parent, + child->drawable.id); +} + +/** + * Send enter notifies to all windows between 'ancestor' and 'child' (excluding + * both). Events are sent running down the window hierarchy. This function + * recurses. + */ +static void +CoreEnterNotifies(DeviceIntPtr dev, + WindowPtr ancestor, + WindowPtr child, + int mode, + int detail) +{ + WindowPtr parent = child->parent; + if (ancestor == parent) + return; + CoreEnterNotifies(dev, ancestor, parent, mode, detail); + + + /* Case 3: + A is above W, B is a descendant + + Classically: The move generates an EnterNotify on W with a detail of + Virtual or NonlinearVirtual + + MPX: + Case 3A: There is at least one other pointer on W itself + P(W) doesn't change, so the event should be suppressed + Case 3B: Otherwise, if there is at least one other pointer in a + descendant + P(W) stays on the same descendant, or changes to a different + descendant. The event should be suppressed. + Case 3C: Otherwise: + P(W) moves from a window above W to a descendant. The subwindow + field is set to the child containing the descendant. The detail + may need to be changed from Virtual to NonlinearVirtual depending + on the previous P(W). */ + + if (!HasPointer(dev, parent) && !FirstPointerChild(parent)) + CoreEnterLeaveEvent(dev, EnterNotify, mode, detail, parent, + child->drawable.id); +} + +static void +CoreLeaveNotifies(DeviceIntPtr dev, + WindowPtr child, + WindowPtr ancestor, + int mode, + int detail) +{ + WindowPtr win; + + if (ancestor == child) + return; + + for (win = child->parent; win != ancestor; win = win->parent) + { + /*Case 7: + A is a descendant of W, B is above W + + Classically: A LeaveNotify is generated on W with a detail of Virtual + or NonlinearVirtual. + + MPX: + Case 3A: There is at least one other pointer on W itself + P(W) doesn't change, the event should be suppressed. + Case 3B: Otherwise, if there is at least one other pointer in a + descendant + P(W) stays on the same descendant, or changes to a different + descendant. The event should be suppressed. + Case 3C: Otherwise: + P(W) changes from the descendant of W to a window above W. + The detail may need to be changed from Virtual to NonlinearVirtual + or vice-versa depending on the new P(W).*/ + + /* If one window has a pointer or a child with a pointer, skip some + * work and exit. */ + if (HasPointer(dev, win) || FirstPointerChild(win)) + return; + + CoreEnterLeaveEvent(dev, LeaveNotify, mode, detail, win, child->drawable.id); + + child = win; + } +} + +/** + * Send leave notifies to all windows between 'child' and 'ancestor'. + * Events are sent running up the hierarchy. + */ +static void +DeviceLeaveNotifies(DeviceIntPtr dev, + int sourceid, + WindowPtr child, + WindowPtr ancestor, + int mode, + int detail) +{ + WindowPtr win; + + if (ancestor == child) + return; + for (win = child->parent; win != ancestor; win = win->parent) + { + DeviceEnterLeaveEvent(dev, sourceid, XI_Leave, mode, detail, win, + child->drawable.id); + child = win; + } +} + +/** + * Pointer dev moves from A to B and A neither a descendant of B nor is + * B a descendant of A. + */ +static void +CoreEnterLeaveNonLinear(DeviceIntPtr dev, + WindowPtr A, + WindowPtr B, + int mode) +{ + WindowPtr X = CommonAncestor(A, B); + /* Case 4: + A is W, B is above W + + Classically: The move generates a LeaveNotify on W with a detail of + Ancestor or Nonlinear + + MPX: + Case 3A: There is at least one other pointer on W itself + P(W) doesn't change, the event should be suppressed + Case 3B: Otherwise, if there is at least one other pointer in a + descendant of W + P(W) changes from W to a descendant of W. The subwindow field + is set to the child containing the new P(W), the detail field + is set to Inferior + Case 3C: Otherwise: + The pointer window moves from W to a window above W. + The detail may need to be changed from Ancestor to Nonlinear or + vice versa depending on the the new P(W) + */ + + if (!HasPointer(dev, A)) + { + WindowPtr child = FirstPointerChild(A); + if (child) + CoreEnterLeaveEvent(dev, LeaveNotify, mode, NotifyInferior, A, None); + else + CoreEnterLeaveEvent(dev, LeaveNotify, mode, NotifyNonlinear, A, None); + } + + + CoreLeaveNotifies(dev, A, X, mode, NotifyNonlinearVirtual); + + /* + Case 9: + A is a descendant of W, B is a descendant of W + + Classically: No events are generated on W + MPX: The pointer window stays the same or moves to a different + descendant of W. No events should be generated on W. + + + Therefore, no event to X. + */ + + CoreEnterNotifies(dev, X, B, mode, NotifyNonlinearVirtual); + + /* Case 2: + A is above W, B=W + + Classically: The move generates an EnterNotify on W with a detail of + Ancestor or Nonlinear + + MPX: + Case 2A: There is at least one other pointer on W itself + P(W) doesn't change, so the event should be suppressed + Case 2B: Otherwise, if there is at least one other pointer in a + descendant + P(W) moves from a descendant to W. detail is changed to Inferior, + subwindow is set to the child containing the previous P(W) + Case 2C: Otherwise: + P(W) changes from a window above W to W itself. + The detail may need to be changed from Ancestor to Nonlinear + or vice-versa depending on the previous P(W). */ + + if (!HasPointer(dev, B)) + { + WindowPtr child = FirstPointerChild(B); + if (child) + CoreEnterLeaveEvent(dev, EnterNotify, mode, NotifyInferior, B, None); + else + CoreEnterLeaveEvent(dev, EnterNotify, mode, NotifyNonlinear, B, None); + } +} + +/** + * Pointer dev moves from A to B and A is a descendant of B. + */ +static void +CoreEnterLeaveToAncestor(DeviceIntPtr dev, + WindowPtr A, + WindowPtr B, + int mode) +{ + /* Case 4: + A is W, B is above W + + Classically: The move generates a LeaveNotify on W with a detail of + Ancestor or Nonlinear + + MPX: + Case 3A: There is at least one other pointer on W itself + P(W) doesn't change, the event should be suppressed + Case 3B: Otherwise, if there is at least one other pointer in a + descendant of W + P(W) changes from W to a descendant of W. The subwindow field + is set to the child containing the new P(W), the detail field + is set to Inferior + Case 3C: Otherwise: + The pointer window moves from W to a window above W. + The detail may need to be changed from Ancestor to Nonlinear or + vice versa depending on the the new P(W) + */ + if (!HasPointer(dev, A)) + { + WindowPtr child = FirstPointerChild(A); + if (child) + CoreEnterLeaveEvent(dev, LeaveNotify, mode, NotifyInferior, A, None); + else + CoreEnterLeaveEvent(dev, LeaveNotify, mode, NotifyAncestor, A, None); + } + + CoreLeaveNotifies(dev, A, B, mode, NotifyVirtual); + + /* Case 8: + A is a descendant of W, B is W + + Classically: A EnterNotify is generated on W with a detail of + NotifyInferior + + MPX: + Case 3A: There is at least one other pointer on W itself + P(W) doesn't change, the event should be suppressed + Case 3B: Otherwise: + P(W) changes from a descendant to W itself. The subwindow + field should be set to the child containing the old P(W) <<< WRONG */ + + if (!HasPointer(dev, B)) + CoreEnterLeaveEvent(dev, EnterNotify, mode, NotifyInferior, B, None); + +} + + +/** + * Pointer dev moves from A to B and B is a descendant of A. + */ +static void +CoreEnterLeaveToDescendant(DeviceIntPtr dev, + WindowPtr A, + WindowPtr B, + int mode) +{ + /* Case 6: + A is W, B is a descendant of W + + Classically: A LeaveNotify is generated on W with a detail of + NotifyInferior + + MPX: + Case 3A: There is at least one other pointer on W itself + P(W) doesn't change, the event should be suppressed + Case 3B: Otherwise: + P(W) changes from W to a descendant of W. The subwindow field + is set to the child containing the new P(W) <<< THIS IS WRONG */ + + if (!HasPointer(dev, A)) + CoreEnterLeaveEvent(dev, LeaveNotify, mode, NotifyInferior, A, None); + + + CoreEnterNotifies(dev, A, B, mode, NotifyVirtual); + + /* Case 2: + A is above W, B=W + + Classically: The move generates an EnterNotify on W with a detail of + Ancestor or Nonlinear + + MPX: + Case 2A: There is at least one other pointer on W itself + P(W) doesn't change, so the event should be suppressed + Case 2B: Otherwise, if there is at least one other pointer in a + descendant + P(W) moves from a descendant to W. detail is changed to Inferior, + subwindow is set to the child containing the previous P(W) + Case 2C: Otherwise: + P(W) changes from a window above W to W itself. + The detail may need to be changed from Ancestor to Nonlinear + or vice-versa depending on the previous P(W). */ + + if (!HasPointer(dev, B)) + { + WindowPtr child = FirstPointerChild(B); + if (child) + CoreEnterLeaveEvent(dev, EnterNotify, mode, NotifyInferior, B, None); + else + CoreEnterLeaveEvent(dev, EnterNotify, mode, NotifyAncestor, B, None); + } +} + +static void +CoreEnterLeaveEvents(DeviceIntPtr dev, + WindowPtr from, + WindowPtr to, + int mode) +{ + if (!IsMaster(dev)) + return; + + LeaveWindow(dev); + + if (IsParent(from, to)) + CoreEnterLeaveToDescendant(dev, from, to, mode); + else if (IsParent(to, from)) + CoreEnterLeaveToAncestor(dev, from, to, mode); + else + CoreEnterLeaveNonLinear(dev, from, to, mode); + + EnterWindow(dev, to, mode); +} + +static void +DeviceEnterLeaveEvents(DeviceIntPtr dev, + int sourceid, + WindowPtr from, + WindowPtr to, + int mode) +{ + if (IsParent(from, to)) + { + DeviceEnterLeaveEvent(dev, sourceid, XI_Leave, mode, NotifyInferior, from, None); + DeviceEnterNotifies(dev, sourceid, from, to, mode, NotifyVirtual); + DeviceEnterLeaveEvent(dev, sourceid, XI_Enter, mode, NotifyAncestor, to, None); + } + else if (IsParent(to, from)) + { + DeviceEnterLeaveEvent(dev, sourceid, XI_Leave, mode, NotifyAncestor, from, None); + DeviceLeaveNotifies(dev, sourceid, from, to, mode, NotifyVirtual); + DeviceEnterLeaveEvent(dev, sourceid, XI_Enter, mode, NotifyInferior, to, None); + } + else + { /* neither from nor to is descendent of the other */ + WindowPtr common = CommonAncestor(to, from); + /* common == NullWindow ==> different screens */ + DeviceEnterLeaveEvent(dev, sourceid, XI_Leave, mode, NotifyNonlinear, from, None); + DeviceLeaveNotifies(dev, sourceid, from, common, mode, NotifyNonlinearVirtual); + DeviceEnterNotifies(dev, sourceid, common, to, mode, NotifyNonlinearVirtual); + DeviceEnterLeaveEvent(dev, sourceid, XI_Enter, mode, NotifyNonlinear, to, None); + } +} + +/** + * Figure out if enter/leave events are necessary and send them to the + * appropriate windows. + * + * @param fromWin Window the sprite moved out of. + * @param toWin Window the sprite moved into. + */ +void +DoEnterLeaveEvents(DeviceIntPtr pDev, + int sourceid, + WindowPtr fromWin, + WindowPtr toWin, + int mode) +{ + if (!IsPointerDevice(pDev)) + return; + + if (fromWin == toWin) + return; + + if (mode != XINotifyPassiveGrab && mode != XINotifyPassiveUngrab) + CoreEnterLeaveEvents(pDev, fromWin, toWin, mode); + DeviceEnterLeaveEvents(pDev, sourceid, fromWin, toWin, mode); +} + +/** + * Send focus out events to all windows between 'child' and 'ancestor'. + * Events are sent running up the hierarchy. + */ +static void +DeviceFocusOutEvents(DeviceIntPtr dev, + WindowPtr child, + WindowPtr ancestor, + int mode, + int detail) +{ + WindowPtr win; + + if (ancestor == child) + return; + for (win = child->parent; win != ancestor; win = win->parent) + DeviceFocusEvent(dev, XI_FocusOut, mode, detail, win); +} + + +/** + * Send enter notifies to all windows between 'ancestor' and 'child' (excluding + * both). Events are sent running up the window hierarchy. This function + * recurses. + */ +static void +DeviceFocusInEvents(DeviceIntPtr dev, + WindowPtr ancestor, + WindowPtr child, + int mode, + int detail) +{ + WindowPtr parent = child->parent; + + if (ancestor == parent || !parent) + return; + DeviceFocusInEvents(dev, ancestor, parent, mode, detail); + DeviceFocusEvent(dev, XI_FocusIn, mode, detail, parent); +} + +/** + * Send FocusIn events to all windows between 'ancestor' and 'child' (excluding + * both). Events are sent running down the window hierarchy. This function + * recurses. + */ +static void +CoreFocusInEvents(DeviceIntPtr dev, + WindowPtr ancestor, + WindowPtr child, + int mode, + int detail) +{ + WindowPtr parent = child->parent; + if (ancestor == parent) + return; + CoreFocusInEvents(dev, ancestor, parent, mode, detail); + + + /* Case 3: + A is above W, B is a descendant + + Classically: The move generates an FocusIn on W with a detail of + Virtual or NonlinearVirtual + + MPX: + Case 3A: There is at least one other focus on W itself + F(W) doesn't change, so the event should be suppressed + Case 3B: Otherwise, if there is at least one other focus in a + descendant + F(W) stays on the same descendant, or changes to a different + descendant. The event should be suppressed. + Case 3C: Otherwise: + F(W) moves from a window above W to a descendant. The detail may + need to be changed from Virtual to NonlinearVirtual depending + on the previous F(W). */ + + if (!HasFocus(parent) && !FirstFocusChild(parent)) + CoreFocusEvent(dev, FocusIn, mode, detail, parent); +} + +static void +CoreFocusOutEvents(DeviceIntPtr dev, + WindowPtr child, + WindowPtr ancestor, + int mode, + int detail) +{ + WindowPtr win; + + if (ancestor == child) + return; + + for (win = child->parent; win != ancestor; win = win->parent) + { + /*Case 7: + A is a descendant of W, B is above W + + Classically: A FocusOut is generated on W with a detail of Virtual + or NonlinearVirtual. + + MPX: + Case 3A: There is at least one other focus on W itself + F(W) doesn't change, the event should be suppressed. + Case 3B: Otherwise, if there is at least one other focus in a + descendant + F(W) stays on the same descendant, or changes to a different + descendant. The event should be suppressed. + Case 3C: Otherwise: + F(W) changes from the descendant of W to a window above W. + The detail may need to be changed from Virtual to NonlinearVirtual + or vice-versa depending on the new P(W).*/ + + /* If one window has a focus or a child with a focuspointer, skip some + * work and exit. */ + if (HasFocus(win) || FirstFocusChild(win)) + return; + + CoreFocusEvent(dev, FocusOut, mode, detail, win); + } +} + +/** + * Send FocusOut(NotifyPointer) events from the current pointer window (which + * is a descendant of pwin_parent) up to (excluding) pwin_parent. + * + * NotifyPointer events are only sent for the device paired with dev. + * + * If the current pointer window is a descendant of 'exclude' or an ancestor of + * 'exclude', no events are sent. If the current pointer IS 'exclude', events + * are sent! + */ +static void +CoreFocusOutNotifyPointerEvents(DeviceIntPtr dev, + WindowPtr pwin_parent, + WindowPtr exclude, + int mode, + int inclusive) +{ + WindowPtr P, stopAt; + + P = PointerWin(GetMaster(dev, POINTER_OR_FLOAT)); + + if (!P) + return; + if (!IsParent(pwin_parent, P)) + if (!(pwin_parent == P && inclusive)) + return; + + if (exclude != None && exclude != PointerRootWin && + (IsParent(exclude, P) || IsParent(P, exclude))) + return; + + stopAt = (inclusive) ? pwin_parent->parent : pwin_parent; + + for (; P && P != stopAt; P = P->parent) + CoreFocusEvent(dev, FocusOut, mode, NotifyPointer, P); +} + +/** + * DO NOT CALL DIRECTLY. + * Recursion helper for CoreFocusInNotifyPointerEvents. + */ +static void +CoreFocusInRecurse(DeviceIntPtr dev, + WindowPtr win, + WindowPtr stopAt, + int mode, + int inclusive) +{ + if ((!inclusive && win == stopAt) || !win) + return; + + CoreFocusInRecurse(dev, win->parent, stopAt, mode, inclusive); + CoreFocusEvent(dev, FocusIn, mode, NotifyPointer, win); +} + + +/** + * Send FocusIn(NotifyPointer) events from pwin_parent down to + * including the current pointer window (which is a descendant of pwin_parent). + * + * @param pwin The pointer window. + * @param exclude If the pointer window is a child of 'exclude', no events are + * sent. + * @param inclusive If TRUE, pwin_parent will receive the event too. + */ +static void +CoreFocusInNotifyPointerEvents(DeviceIntPtr dev, + WindowPtr pwin_parent, + WindowPtr exclude, + int mode, + int inclusive) +{ + WindowPtr P; + + P = PointerWin(GetMaster(dev, POINTER_OR_FLOAT)); + + if (!P || P == exclude || (pwin_parent != P && !IsParent(pwin_parent, P))) + return; + + if (exclude != None && (IsParent(exclude, P) || IsParent(P, exclude))) + return; + + CoreFocusInRecurse(dev, P, pwin_parent, mode, inclusive); +} + + +/** + * Focus of dev moves from A to B and A neither a descendant of B nor is + * B a descendant of A. + */ +static void +CoreFocusNonLinear(DeviceIntPtr dev, + WindowPtr A, + WindowPtr B, + int mode) +{ + WindowPtr X = CommonAncestor(A, B); + + /* Case 4: + A is W, B is above W + + Classically: The change generates a FocusOut on W with a detail of + Ancestor or Nonlinear + + MPX: + Case 3A: There is at least one other focus on W itself + F(W) doesn't change, the event should be suppressed + Case 3B: Otherwise, if there is at least one other focus in a + descendant of W + F(W) changes from W to a descendant of W. The detail field + is set to Inferior + Case 3C: Otherwise: + The focus window moves from W to a window above W. + The detail may need to be changed from Ancestor to Nonlinear or + vice versa depending on the the new F(W) + */ + + if (!HasFocus(A)) + { + WindowPtr child = FirstFocusChild(A); + if (child) + { + /* NotifyPointer P-A unless P is child or below*/ + CoreFocusOutNotifyPointerEvents(dev, A, child, mode, FALSE); + CoreFocusEvent(dev, FocusOut, mode, NotifyInferior, A); + } else + { + /* NotifyPointer P-A */ + CoreFocusOutNotifyPointerEvents(dev, A, None, mode, FALSE); + CoreFocusEvent(dev, FocusOut, mode, NotifyNonlinear, A); + } + } + + + CoreFocusOutEvents(dev, A, X, mode, NotifyNonlinearVirtual); + + /* + Case 9: + A is a descendant of W, B is a descendant of W + + Classically: No events are generated on W + MPX: The focus window stays the same or moves to a different + descendant of W. No events should be generated on W. + + + Therefore, no event to X. + */ + + CoreFocusInEvents(dev, X, B, mode, NotifyNonlinearVirtual); + + /* Case 2: + A is above W, B=W + + Classically: The move generates an EnterNotify on W with a detail of + Ancestor or Nonlinear + + MPX: + Case 2A: There is at least one other focus on W itself + F(W) doesn't change, so the event should be suppressed + Case 2B: Otherwise, if there is at least one other focus in a + descendant + F(W) moves from a descendant to W. detail is changed to Inferior. + Case 2C: Otherwise: + F(W) changes from a window above W to W itself. + The detail may need to be changed from Ancestor to Nonlinear + or vice-versa depending on the previous F(W). */ + + if (!HasFocus(B)) + { + WindowPtr child = FirstFocusChild(B); + if (child) + { + CoreFocusEvent(dev, FocusIn, mode, NotifyInferior, B); + /* NotifyPointer B-P unless P is child or below. */ + CoreFocusInNotifyPointerEvents(dev, B, child, mode, FALSE); + } else { + CoreFocusEvent(dev, FocusIn, mode, NotifyNonlinear, B); + /* NotifyPointer B-P unless P is child or below. */ + CoreFocusInNotifyPointerEvents(dev, B, None, mode, FALSE); + } + } +} + + +/** + * Focus of dev moves from A to B and A is a descendant of B. + */ +static void +CoreFocusToAncestor(DeviceIntPtr dev, + WindowPtr A, + WindowPtr B, + int mode) +{ + /* Case 4: + A is W, B is above W + + Classically: The change generates a FocusOut on W with a detail of + Ancestor or Nonlinear + + MPX: + Case 3A: There is at least one other focus on W itself + F(W) doesn't change, the event should be suppressed + Case 3B: Otherwise, if there is at least one other focus in a + descendant of W + F(W) changes from W to a descendant of W. The detail field + is set to Inferior + Case 3C: Otherwise: + The focus window moves from W to a window above W. + The detail may need to be changed from Ancestor to Nonlinear or + vice versa depending on the the new F(W) + */ + if (!HasFocus(A)) + { + WindowPtr child = FirstFocusChild(A); + if (child) + { + /* NotifyPointer P-A unless P is child or below*/ + CoreFocusOutNotifyPointerEvents(dev, A, child, mode, FALSE); + CoreFocusEvent(dev, FocusOut, mode, NotifyInferior, A); + } else + CoreFocusEvent(dev, FocusOut, mode, NotifyAncestor, A); + } + + CoreFocusOutEvents(dev, A, B, mode, NotifyVirtual); + + /* Case 8: + A is a descendant of W, B is W + + Classically: A FocusOut is generated on W with a detail of + NotifyInferior + + MPX: + Case 3A: There is at least one other focus on W itself + F(W) doesn't change, the event should be suppressed + Case 3B: Otherwise: + F(W) changes from a descendant to W itself. */ + + if (!HasFocus(B)) + { + CoreFocusEvent(dev, FocusIn, mode, NotifyInferior, B); + /* NotifyPointer B-P unless P is A or below. */ + CoreFocusInNotifyPointerEvents(dev, B, A, mode, FALSE); + } +} + +/** + * Focus of dev moves from A to B and B is a descendant of A. + */ +static void +CoreFocusToDescendant(DeviceIntPtr dev, + WindowPtr A, + WindowPtr B, + int mode) +{ + /* Case 6: + A is W, B is a descendant of W + + Classically: A FocusOut is generated on W with a detail of + NotifyInferior + + MPX: + Case 3A: There is at least one other focus on W itself + F(W) doesn't change, the event should be suppressed + Case 3B: Otherwise: + F(W) changes from W to a descendant of W. */ + + if (!HasFocus(A)) + { + /* NotifyPointer P-A unless P is B or below*/ + CoreFocusOutNotifyPointerEvents(dev, A, B, mode, FALSE); + CoreFocusEvent(dev, FocusOut, mode, NotifyInferior, A); + } + + + CoreFocusInEvents(dev, A, B, mode, NotifyVirtual); + + /* Case 2: + A is above W, B=W + + Classically: The move generates an FocusIn on W with a detail of + Ancestor or Nonlinear + + MPX: + Case 2A: There is at least one other focus on W itself + F(W) doesn't change, so the event should be suppressed + Case 2B: Otherwise, if there is at least one other focus in a + descendant + F(W) moves from a descendant to W. detail is changed to Inferior. + Case 2C: Otherwise: + F(W) changes from a window above W to W itself. + The detail may need to be changed from Ancestor to Nonlinear + or vice-versa depending on the previous F(W). */ + + if (!HasFocus(B)) + { + WindowPtr child = FirstFocusChild(B); + if (child) + { + CoreFocusEvent(dev, FocusIn, mode, NotifyInferior, B); + /* NotifyPointer B-P unless P is child or below. */ + CoreFocusInNotifyPointerEvents(dev, B, child, mode, FALSE); + } else + CoreFocusEvent(dev, FocusIn, mode, NotifyAncestor, B); + } +} + +static BOOL +HasOtherPointer(WindowPtr win, DeviceIntPtr exclude) +{ + int i; + + for (i = 0; i < MAXDEVICES; i++) + if (i != exclude->id && PointerWindows[i] == win) + return TRUE; + + return FALSE; +} + +/** + * Focus moves from PointerRoot to None or from None to PointerRoot. + * Assumption: Neither A nor B are valid windows. + */ +static void +CoreFocusPointerRootNoneSwitch(DeviceIntPtr dev, + WindowPtr A, /* PointerRootWin or NoneWin */ + WindowPtr B, /* NoneWin or PointerRootWin */ + int mode) +{ + WindowPtr root; + int i; + int nscreens = screenInfo.numScreens; + +#ifdef PANORAMIX + if (!noPanoramiXExtension) + nscreens = 1; +#endif + + for (i = 0; i < nscreens; i++) + { + root = screenInfo.screens[i]->root; + if (!HasOtherPointer(root, GetMaster(dev, POINTER_OR_FLOAT)) && !FirstFocusChild(root)) + { + /* If pointer was on PointerRootWin and changes to NoneWin, and + * the pointer paired with dev is below the current root window, + * do a NotifyPointer run. */ + if (dev->focus && dev->focus->win == PointerRootWin && + B != PointerRootWin) + { + WindowPtr ptrwin = PointerWin(GetMaster(dev, POINTER_OR_FLOAT)); + if (ptrwin && IsParent(root, ptrwin)) + CoreFocusOutNotifyPointerEvents(dev, root, None, mode, TRUE); + } + CoreFocusEvent(dev, FocusOut, mode, A ? NotifyPointerRoot : NotifyDetailNone, root); + CoreFocusEvent(dev, FocusIn, mode, B ? NotifyPointerRoot : NotifyDetailNone, root); + if (B == PointerRootWin) + CoreFocusInNotifyPointerEvents(dev, root, None, mode, TRUE); + } + + } +} + +/** + * Focus moves from window A to PointerRoot or to None. + * Assumption: A is a valid window and not PointerRoot or None. + */ +static void +CoreFocusToPointerRootOrNone(DeviceIntPtr dev, + WindowPtr A, + WindowPtr B, /* PointerRootWin or NoneWin */ + int mode) +{ + WindowPtr root; + int i; + int nscreens = screenInfo.numScreens; + +#ifdef PANORAMIX + if (!noPanoramiXExtension) + nscreens = 1; +#endif + + if (!HasFocus(A)) + { + WindowPtr child = FirstFocusChild(A); + if (child) + { + /* NotifyPointer P-A unless P is B or below*/ + CoreFocusOutNotifyPointerEvents(dev, A, B, mode, FALSE); + CoreFocusEvent(dev, FocusOut, mode, NotifyInferior, A); + } else { + /* NotifyPointer P-A */ + CoreFocusOutNotifyPointerEvents(dev, A, None, mode, FALSE); + CoreFocusEvent(dev, FocusOut, mode, NotifyNonlinear, A); + } + } + + /* NullWindow means we include the root window */ + CoreFocusOutEvents(dev, A, NullWindow, mode, NotifyNonlinearVirtual); + + for (i = 0; i < nscreens; i++) + { + root = screenInfo.screens[i]->root; + if (!HasFocus(root) && !FirstFocusChild(root)) + { + CoreFocusEvent(dev, FocusIn, mode, B ? NotifyPointerRoot : NotifyDetailNone, root); + if (B == PointerRootWin) + CoreFocusInNotifyPointerEvents(dev, root, None, mode, TRUE); + } + } +} + +/** + * Focus moves from PointerRoot or None to a window B. + * Assumption: B is a valid window and not PointerRoot or None. + */ +static void +CoreFocusFromPointerRootOrNone(DeviceIntPtr dev, + WindowPtr A, /* PointerRootWin or NoneWin */ + WindowPtr B, + int mode) +{ + WindowPtr root; + int i; + int nscreens = screenInfo.numScreens; + +#ifdef PANORAMIX + if (!noPanoramiXExtension) + nscreens = 1; +#endif + + for (i = 0; i < nscreens; i++) + { + root = screenInfo.screens[i]->root; + if (!HasFocus(root) && !FirstFocusChild(root)) + { + /* If pointer was on PointerRootWin and changes to NoneWin, and + * the pointer paired with dev is below the current root window, + * do a NotifyPointer run. */ + if (dev->focus && dev->focus->win == PointerRootWin && + B != PointerRootWin) + { + WindowPtr ptrwin = PointerWin(GetMaster(dev, POINTER_OR_FLOAT)); + if (ptrwin) + CoreFocusOutNotifyPointerEvents(dev, root, None, mode, TRUE); + } + CoreFocusEvent(dev, FocusOut, mode, A ? NotifyPointerRoot : NotifyDetailNone, root); + } + } + + root = B; /* get B's root window */ + while(root->parent) + root = root->parent; + + if (B != root) + { + CoreFocusEvent(dev, FocusIn, mode, NotifyNonlinearVirtual, root); + CoreFocusInEvents(dev, root, B, mode, NotifyNonlinearVirtual); + } + + + if (!HasFocus(B)) + { + WindowPtr child = FirstFocusChild(B); + if (child) + { + CoreFocusEvent(dev, FocusIn, mode, NotifyInferior, B); + /* NotifyPointer B-P unless P is child or below. */ + CoreFocusInNotifyPointerEvents(dev, B, child, mode, FALSE); + } else { + CoreFocusEvent(dev, FocusIn, mode, NotifyNonlinear, B); + /* NotifyPointer B-P unless P is child or below. */ + CoreFocusInNotifyPointerEvents(dev, B, None, mode, FALSE); + } + } + +} + +static void +CoreFocusEvents(DeviceIntPtr dev, + WindowPtr from, + WindowPtr to, + int mode) +{ + if (!IsMaster(dev)) + return; + + SetFocusOut(dev); + + if (((to == NullWindow) || (to == PointerRootWin)) && + ((from == NullWindow) || (from == PointerRootWin))) + CoreFocusPointerRootNoneSwitch(dev, from, to, mode); + else if ((to == NullWindow) || (to == PointerRootWin)) + CoreFocusToPointerRootOrNone(dev, from, to, mode); + else if ((from == NullWindow) || (from == PointerRootWin)) + CoreFocusFromPointerRootOrNone(dev, from, to, mode); + else if (IsParent(from, to)) + CoreFocusToDescendant(dev, from, to, mode); + else if (IsParent(to, from)) + CoreFocusToAncestor(dev, from, to, mode); + else + CoreFocusNonLinear(dev, from, to, mode); + + SetFocusIn(dev, to); +} + +static void +DeviceFocusEvents(DeviceIntPtr dev, + WindowPtr from, + WindowPtr to, + int mode) +{ + int out, in; /* for holding details for to/from + PointerRoot/None */ + int i; + int nscreens = screenInfo.numScreens; + SpritePtr sprite = dev->spriteInfo->sprite; + + if (from == to) + return; + out = (from == NoneWin) ? NotifyDetailNone : NotifyPointerRoot; + in = (to == NoneWin) ? NotifyDetailNone : NotifyPointerRoot; + /* wrong values if neither, but then not referenced */ + +#ifdef PANORAMIX + if (!noPanoramiXExtension) + nscreens = 1; +#endif + + if ((to == NullWindow) || (to == PointerRootWin)) + { + if ((from == NullWindow) || (from == PointerRootWin)) + { + if (from == PointerRootWin) + DeviceFocusOutEvents(dev, sprite->win, GetCurrentRootWindow(dev), mode, + NotifyPointer); + /* Notify all the roots */ + for (i = 0; i < nscreens; i++) + DeviceFocusEvent(dev, XI_FocusOut, mode, out, screenInfo.screens[i]->root); + } + else + { + if (IsParent(from, sprite->win)) + DeviceFocusOutEvents(dev, sprite->win, from, mode, + NotifyPointer); + DeviceFocusEvent(dev, XI_FocusOut, mode, NotifyNonlinear, from); + /* next call catches the root too, if the screen changed */ + DeviceFocusOutEvents(dev, from->parent, NullWindow, mode, + NotifyNonlinearVirtual); + } + /* Notify all the roots */ + for (i = 0; i < nscreens; i++) + DeviceFocusEvent(dev, XI_FocusIn, mode, in, screenInfo.screens[i]->root); + if (to == PointerRootWin) + DeviceFocusInEvents(dev, GetCurrentRootWindow(dev), sprite->win, mode, NotifyPointer); + } + else + { + if ((from == NullWindow) || (from == PointerRootWin)) + { + if (from == PointerRootWin) + DeviceFocusOutEvents(dev, sprite->win, GetCurrentRootWindow(dev), mode, + NotifyPointer); + for (i = 0; i < nscreens; i++) + DeviceFocusEvent(dev, XI_FocusOut, mode, out, screenInfo.screens[i]->root); + if (to->parent != NullWindow) + DeviceFocusInEvents(dev, GetCurrentRootWindow(dev), to, mode, NotifyNonlinearVirtual); + DeviceFocusEvent(dev, XI_FocusIn, mode, NotifyNonlinear, to); + if (IsParent(to, sprite->win)) + DeviceFocusInEvents(dev, to, sprite->win, mode, NotifyPointer); + } + else + { + if (IsParent(to, from)) + { + DeviceFocusEvent(dev, XI_FocusOut, mode, NotifyAncestor, from); + DeviceFocusOutEvents(dev, from->parent, to, mode, + NotifyVirtual); + DeviceFocusEvent(dev, XI_FocusIn, mode, NotifyInferior, to); + if ((IsParent(to, sprite->win)) && + (sprite->win != from) && + (!IsParent(from, sprite->win)) && + (!IsParent(sprite->win, from))) + DeviceFocusInEvents(dev, to, sprite->win, mode, NotifyPointer); + } + else + if (IsParent(from, to)) + { + if ((IsParent(from, sprite->win)) && + (sprite->win != from) && + (!IsParent(to, sprite->win)) && + (!IsParent(sprite->win, to))) + DeviceFocusOutEvents(dev, sprite->win, from, mode, + NotifyPointer); + DeviceFocusEvent(dev, XI_FocusOut, mode, NotifyInferior, from); + DeviceFocusInEvents(dev, from, to, mode, NotifyVirtual); + DeviceFocusEvent(dev, XI_FocusIn, mode, NotifyAncestor, to); + } + else + { + /* neither from or to is child of other */ + WindowPtr common = CommonAncestor(to, from); + /* common == NullWindow ==> different screens */ + if (IsParent(from, sprite->win)) + DeviceFocusOutEvents(dev, sprite->win, from, mode, + NotifyPointer); + DeviceFocusEvent(dev, XI_FocusOut, mode, NotifyNonlinear, from); + if (from->parent != NullWindow) + DeviceFocusOutEvents(dev, from->parent, common, mode, + NotifyNonlinearVirtual); + if (to->parent != NullWindow) + DeviceFocusInEvents(dev, common, to, mode, NotifyNonlinearVirtual); + DeviceFocusEvent(dev, XI_FocusIn, mode, NotifyNonlinear, to); + if (IsParent(to, sprite->win)) + DeviceFocusInEvents(dev, to, sprite->win, mode, NotifyPointer); + } + } + } +} + +/** + * Figure out if focus events are necessary and send them to the + * appropriate windows. + * + * @param from Window the focus moved out of. + * @param to Window the focus moved into. + */ +void +DoFocusEvents(DeviceIntPtr pDev, + WindowPtr from, + WindowPtr to, + int mode) +{ + if (!IsKeyboardDevice(pDev)) + return; + + if (from == to) + return; + + CoreFocusEvents(pDev, from, to, mode); + DeviceFocusEvents(pDev, from, to, mode); +} diff --git a/xorg-server/dix/events.c b/xorg-server/dix/events.c index f87d2bbf9..5e0dc5f17 100644 --- a/xorg-server/dix/events.c +++ b/xorg-server/dix/events.c @@ -3698,10 +3698,7 @@ CheckPassiveGrabsOnWindow( gdev= grab->modifierDevice; if (grab->grabtype == GRABTYPE_CORE) { - if (IsPointerDevice(device)) - gdev = GetPairedDevice(device); - else - gdev = device; + gdev = GetMaster(device, KEYBOARD_OR_FLOAT); } else if (grab->grabtype == GRABTYPE_XI2) { /* if the device is an attached slave device, gdev must be the @@ -4000,8 +3997,7 @@ DeliverFocusedEvent(DeviceIntPtr keybd, InternalEvent *event, WindowPtr window) } /* just deliver it to the focus window */ - ptr = GetPairedDevice(keybd); - + ptr = GetMaster(keybd, POINTER_OR_FLOAT); rc = EventToXI2(event, &xi2); if (rc == Success) @@ -4501,7 +4497,7 @@ CoreEnterLeaveEvent( GrabPtr grab = mouse->deviceGrab.grab; Mask mask; - keybd = GetPairedDevice(mouse); + keybd = GetMaster(mouse, KEYBOARD_OR_FLOAT); if ((pWin == mouse->valuator->motionHintWindow) && (detail != NotifyInferior)) @@ -4719,10 +4715,7 @@ SetInputFocus( } time = ClientTimeToServerTime(ctime); - if (IsKeyboardDevice(dev)) - keybd = dev; - else - keybd = GetPairedDevice(dev); + keybd = GetMaster(dev, KEYBOARD_OR_FLOAT); if ((focusID == None) || (focusID == PointerRoot)) focusWin = (WindowPtr)(long)focusID; @@ -5197,7 +5190,7 @@ ProcQueryPointer(ClientPtr client) if (rc != Success && rc != BadAccess) return rc; - keyboard = GetPairedDevice(mouse); + keyboard = GetMaster(mouse, MASTER_KEYBOARD); pSprite = mouse->spriteInfo->sprite; if (mouse->valuator->motionHintWindow) @@ -5321,7 +5314,7 @@ ProcSendEvent(ClientPtr client) WindowPtr pWin; WindowPtr effectiveFocus = NullWindow; /* only set if dest==InputFocus */ DeviceIntPtr dev = PickPointer(client); - DeviceIntPtr keybd = GetPairedDevice(dev); + DeviceIntPtr keybd = GetMaster(dev, MASTER_KEYBOARD); SpritePtr pSprite = dev->spriteInfo->sprite; REQUEST(xSendEventReq); @@ -5594,7 +5587,7 @@ ProcGrabButton(ClientPtr client) } ptr = PickPointer(client); - modifierDevice = GetPairedDevice(ptr); + modifierDevice = GetMaster(ptr, MASTER_KEYBOARD); if (stuff->pointerMode == GrabModeSync || stuff->keyboardMode == GrabModeSync) access_mode |= DixFreezeAccess; @@ -5651,7 +5644,7 @@ ProcUngrabButton(ClientPtr client) tempGrab.window = pWin; tempGrab.modifiersDetail.exact = stuff->modifiers; tempGrab.modifiersDetail.pMask = NULL; - tempGrab.modifierDevice = GetPairedDevice(ptr); + tempGrab.modifierDevice = GetMaster(ptr, MASTER_KEYBOARD); tempGrab.type = ButtonPress; tempGrab.detail.exact = stuff->button; tempGrab.grabtype = GRABTYPE_CORE; diff --git a/xorg-server/dix/getevents.c b/xorg-server/dix/getevents.c index df47b2b95..8798f6418 100644 --- a/xorg-server/dix/getevents.c +++ b/xorg-server/dix/getevents.c @@ -1546,7 +1546,7 @@ GetProximityEvents(InternalEvent *events, DeviceIntPtr pDev, int type, const Val /* Sanity checks. */ if ((type != ProximityIn && type != ProximityOut) || !mask_in) return 0; - if (!pDev->valuator) + if (!pDev->valuator || !pDev->proximity) return 0; valuator_mask_copy(&mask, mask_in); diff --git a/xorg-server/hw/xfree86/common/xf86DGA.c b/xorg-server/hw/xfree86/common/xf86DGA.c index 74eb739e4..46e3005fa 100644 --- a/xorg-server/hw/xfree86/common/xf86DGA.c +++ b/xorg-server/hw/xfree86/common/xf86DGA.c @@ -1016,7 +1016,7 @@ DGAProcessKeyboardEvent (ScreenPtr pScreen, DGAEvent *event, DeviceIntPtr keybd) { KeyClassPtr keyc = keybd->key; DGAScreenPtr pScreenPriv = DGA_GET_SCREEN_PRIV(pScreen); - DeviceIntPtr pointer = GetPairedDevice(keybd); + DeviceIntPtr pointer = GetMaster(keybd, POINTER_OR_FLOAT); DeviceEvent ev; memset(&ev, 0, sizeof(ev)); diff --git a/xorg-server/hw/xfree86/common/xf86Init.c b/xorg-server/hw/xfree86/common/xf86Init.c index a0fdf29ad..c1e48eed2 100644 --- a/xorg-server/hw/xfree86/common/xf86Init.c +++ b/xorg-server/hw/xfree86/common/xf86Init.c @@ -827,6 +827,8 @@ InitInput(int argc, char **argv) /* Initialize all configured input devices */ for (pInfo = xf86ConfigLayout.inputs; pInfo && *pInfo; pInfo++) { + (*pInfo)->options = xf86AddNewOption((*pInfo)->options, "driver", (*pInfo)->driver); + (*pInfo)->options = xf86AddNewOption((*pInfo)->options, "identifier", (*pInfo)->name); /* If one fails, the others will too */ if (NewInputDeviceRequest((*pInfo)->options, NULL, &dev) == BadAlloc) break; diff --git a/xorg-server/hw/xfree86/common/xf86Xinput.c b/xorg-server/hw/xfree86/common/xf86Xinput.c index c3ffc27d0..7feb48c1e 100644 --- a/xorg-server/hw/xfree86/common/xf86Xinput.c +++ b/xorg-server/hw/xfree86/common/xf86Xinput.c @@ -1275,7 +1275,7 @@ xf86PostKeyEventM(DeviceIntPtr device, DeviceIntPtr pointer; /* Some pointers send key events, paired device is wrong then. */ - pointer = IsPointerDevice(device) ? device : GetPairedDevice(device); + pointer = GetMaster(device, POINTER_OR_FLOAT); if (miPointerGetScreen(pointer)) { int index = miPointerGetScreen(pointer)->myNum; diff --git a/xorg-server/hw/xfree86/modes/xf86Crtc.c b/xorg-server/hw/xfree86/modes/xf86Crtc.c index aac33d32f..953215196 100644 --- a/xorg-server/hw/xfree86/modes/xf86Crtc.c +++ b/xorg-server/hw/xfree86/modes/xf86Crtc.c @@ -807,6 +807,9 @@ xf86CrtcScreenInit (ScreenPtr screen) config->CloseScreen = screen->CloseScreen; screen->CloseScreen = xf86CrtcCloseScreen; + + /* This might still be marked wrapped from a previous generation */ + config->BlockHandler = NULL; #ifdef XFreeXDGA _xf86_di_dga_init_internal(screen); diff --git a/xorg-server/include/input.h b/xorg-server/include/input.h index 5dd5c1bcf..9ef726f4e 100644 --- a/xorg-server/include/input.h +++ b/xorg-server/include/input.h @@ -463,13 +463,13 @@ extern _X_EXPORT void QueueKeyboardEvents( int key_code, const ValuatorMask *mask); -extern int GetProximityEvents( +extern _X_EXPORT int GetProximityEvents( InternalEvent *events, DeviceIntPtr pDev, int type, const ValuatorMask *mask); -extern void QueueProximityEvents( +extern _X_EXPORT void QueueProximityEvents( DeviceIntPtr pDev, int type, const ValuatorMask *mask); diff --git a/xorg-server/xkb/xkbActions.c b/xorg-server/xkb/xkbActions.c index 000002a45..1e94d261c 100644 --- a/xorg-server/xkb/xkbActions.c +++ b/xorg-server/xkb/xkbActions.c @@ -1203,7 +1203,7 @@ xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(dev); if (keyEvent) tmpdev = dev; else - tmpdev = GetPairedDevice(dev); + tmpdev = GetMaster(dev, POINTER_OR_FLOAT); UNWRAP_PROCESS_INPUT_PROC(tmpdev,xkbPrivPtr, backupproc); dev->public.processInputProc((InternalEvent*)event, tmpdev); -- cgit v1.2.3