X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fdrivers%2Fdri%2Fi965%2Fintel_state.c;h=5001a49faffb9aa4a3a701ad31ffc4cbfc56a9e0;hb=27e273578f05521baac08d7de915c95312e3a595;hp=67ef5f78c1aa32df0324ca8579ed867f8a8312e6;hpb=d7f1cb5b5a134b63227d5746a2dd1f05597c5c2f;p=mesa.git diff --git a/src/mesa/drivers/dri/i965/intel_state.c b/src/mesa/drivers/dri/i965/intel_state.c index 67ef5f78c1a..5001a49faff 100644 --- a/src/mesa/drivers/dri/i965/intel_state.c +++ b/src/mesa/drivers/dri/i965/intel_state.c @@ -1,225 +1,160 @@ -/************************************************************************** - * - * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas. +/* + * Copyright 2003 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 + * 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 NON-INFRINGEMENT. - * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * 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 "main/glheader.h" #include "main/context.h" #include "main/macros.h" #include "main/enums.h" -#include "main/colormac.h" #include "main/dd.h" #include "intel_screen.h" -#include "intel_context.h" -#include "intel_regions.h" -#include "swrast/swrast.h" +#include "brw_context.h" +#include "brw_defines.h" -int intel_translate_shadow_compare_func( GLenum func ) +int +intel_translate_shadow_compare_func(GLenum func) { - switch(func) { - case GL_NEVER: - return COMPAREFUNC_ALWAYS; - case GL_LESS: - return COMPAREFUNC_LEQUAL; - case GL_LEQUAL: - return COMPAREFUNC_LESS; - case GL_GREATER: - return COMPAREFUNC_GEQUAL; - case GL_GEQUAL: - return COMPAREFUNC_GREATER; - case GL_NOTEQUAL: - return COMPAREFUNC_EQUAL; - case GL_EQUAL: - return COMPAREFUNC_NOTEQUAL; - case GL_ALWAYS: - return COMPAREFUNC_NEVER; + /* GL specifies the result of shadow comparisons as: + * 1 if ref texel, + * 0 otherwise. + * + * The hardware does: + * 0 if texel ref, + * 1 otherwise. + * + * So, these look a bit strange because there's both a negation + * and swapping of the arguments involved. + */ + switch (func) { + case GL_NEVER: + return BRW_COMPAREFUNCTION_ALWAYS; + case GL_LESS: + return BRW_COMPAREFUNCTION_LEQUAL; + case GL_LEQUAL: + return BRW_COMPAREFUNCTION_LESS; + case GL_GREATER: + return BRW_COMPAREFUNCTION_GEQUAL; + case GL_GEQUAL: + return BRW_COMPAREFUNCTION_GREATER; + case GL_NOTEQUAL: + return BRW_COMPAREFUNCTION_EQUAL; + case GL_EQUAL: + return BRW_COMPAREFUNCTION_NOTEQUAL; + case GL_ALWAYS: + return BRW_COMPAREFUNCTION_NEVER; } - fprintf(stderr, "Unknown value in %s: %x\n", __FUNCTION__, func); - return COMPAREFUNC_NEVER; + unreachable("Invalid shadow comparison function."); } -int intel_translate_compare_func( GLenum func ) +int +intel_translate_compare_func(GLenum func) { - switch(func) { - case GL_NEVER: - return COMPAREFUNC_NEVER; - case GL_LESS: - return COMPAREFUNC_LESS; - case GL_LEQUAL: - return COMPAREFUNC_LEQUAL; - case GL_GREATER: - return COMPAREFUNC_GREATER; - case GL_GEQUAL: - return COMPAREFUNC_GEQUAL; - case GL_NOTEQUAL: - return COMPAREFUNC_NOTEQUAL; - case GL_EQUAL: - return COMPAREFUNC_EQUAL; - case GL_ALWAYS: - return COMPAREFUNC_ALWAYS; + switch (func) { + case GL_NEVER: + return BRW_COMPAREFUNCTION_NEVER; + case GL_LESS: + return BRW_COMPAREFUNCTION_LESS; + case GL_LEQUAL: + return BRW_COMPAREFUNCTION_LEQUAL; + case GL_GREATER: + return BRW_COMPAREFUNCTION_GREATER; + case GL_GEQUAL: + return BRW_COMPAREFUNCTION_GEQUAL; + case GL_NOTEQUAL: + return BRW_COMPAREFUNCTION_NOTEQUAL; + case GL_EQUAL: + return BRW_COMPAREFUNCTION_EQUAL; + case GL_ALWAYS: + return BRW_COMPAREFUNCTION_ALWAYS; } - fprintf(stderr, "Unknown value in %s: %x\n", __FUNCTION__, func); - return COMPAREFUNC_ALWAYS; + unreachable("Invalid comparison function."); } -int intel_translate_stencil_op( GLenum op ) +int +intel_translate_stencil_op(GLenum op) { - switch(op) { - case GL_KEEP: - return STENCILOP_KEEP; - case GL_ZERO: - return STENCILOP_ZERO; - case GL_REPLACE: - return STENCILOP_REPLACE; - case GL_INCR: - return STENCILOP_INCRSAT; - case GL_DECR: - return STENCILOP_DECRSAT; + switch (op) { + case GL_KEEP: + return BRW_STENCILOP_KEEP; + case GL_ZERO: + return BRW_STENCILOP_ZERO; + case GL_REPLACE: + return BRW_STENCILOP_REPLACE; + case GL_INCR: + return BRW_STENCILOP_INCRSAT; + case GL_DECR: + return BRW_STENCILOP_DECRSAT; case GL_INCR_WRAP: - return STENCILOP_INCR; + return BRW_STENCILOP_INCR; case GL_DECR_WRAP: - return STENCILOP_DECR; - case GL_INVERT: - return STENCILOP_INVERT; - default: - return STENCILOP_ZERO; - } -} - -int intel_translate_blend_factor( GLenum factor ) -{ - switch(factor) { - case GL_ZERO: - return BLENDFACT_ZERO; - case GL_SRC_ALPHA: - return BLENDFACT_SRC_ALPHA; - case GL_ONE: - return BLENDFACT_ONE; - case GL_SRC_COLOR: - return BLENDFACT_SRC_COLR; - case GL_ONE_MINUS_SRC_COLOR: - return BLENDFACT_INV_SRC_COLR; - case GL_DST_COLOR: - return BLENDFACT_DST_COLR; - case GL_ONE_MINUS_DST_COLOR: - return BLENDFACT_INV_DST_COLR; - case GL_ONE_MINUS_SRC_ALPHA: - return BLENDFACT_INV_SRC_ALPHA; - case GL_DST_ALPHA: - return BLENDFACT_DST_ALPHA; - case GL_ONE_MINUS_DST_ALPHA: - return BLENDFACT_INV_DST_ALPHA; - case GL_SRC_ALPHA_SATURATE: - return BLENDFACT_SRC_ALPHA_SATURATE; - case GL_CONSTANT_COLOR: - return BLENDFACT_CONST_COLOR; - case GL_ONE_MINUS_CONSTANT_COLOR: - return BLENDFACT_INV_CONST_COLOR; - case GL_CONSTANT_ALPHA: - return BLENDFACT_CONST_ALPHA; - case GL_ONE_MINUS_CONSTANT_ALPHA: - return BLENDFACT_INV_CONST_ALPHA; + return BRW_STENCILOP_DECR; + case GL_INVERT: + return BRW_STENCILOP_INVERT; + default: + return BRW_STENCILOP_ZERO; } - - fprintf(stderr, "Unknown value in %s: %x\n", __FUNCTION__, factor); - return BLENDFACT_ZERO; } -int intel_translate_logic_op( GLenum opcode ) +int +intel_translate_logic_op(GLenum opcode) { - switch(opcode) { - case GL_CLEAR: - return LOGICOP_CLEAR; - case GL_AND: - return LOGICOP_AND; - case GL_AND_REVERSE: - return LOGICOP_AND_RVRSE; - case GL_COPY: - return LOGICOP_COPY; - case GL_COPY_INVERTED: - return LOGICOP_COPY_INV; - case GL_AND_INVERTED: - return LOGICOP_AND_INV; - case GL_NOOP: - return LOGICOP_NOOP; - case GL_XOR: - return LOGICOP_XOR; - case GL_OR: - return LOGICOP_OR; - case GL_OR_INVERTED: - return LOGICOP_OR_INV; - case GL_NOR: - return LOGICOP_NOR; - case GL_EQUIV: - return LOGICOP_EQUIV; - case GL_INVERT: - return LOGICOP_INV; - case GL_OR_REVERSE: - return LOGICOP_OR_RVRSE; - case GL_NAND: - return LOGICOP_NAND; - case GL_SET: - return LOGICOP_SET; + switch (opcode) { + case GL_CLEAR: + return BRW_LOGICOPFUNCTION_CLEAR; + case GL_AND: + return BRW_LOGICOPFUNCTION_AND; + case GL_AND_REVERSE: + return BRW_LOGICOPFUNCTION_AND_REVERSE; + case GL_COPY: + return BRW_LOGICOPFUNCTION_COPY; + case GL_COPY_INVERTED: + return BRW_LOGICOPFUNCTION_COPY_INVERTED; + case GL_AND_INVERTED: + return BRW_LOGICOPFUNCTION_AND_INVERTED; + case GL_NOOP: + return BRW_LOGICOPFUNCTION_NOOP; + case GL_XOR: + return BRW_LOGICOPFUNCTION_XOR; + case GL_OR: + return BRW_LOGICOPFUNCTION_OR; + case GL_OR_INVERTED: + return BRW_LOGICOPFUNCTION_OR_INVERTED; + case GL_NOR: + return BRW_LOGICOPFUNCTION_NOR; + case GL_EQUIV: + return BRW_LOGICOPFUNCTION_EQUIV; + case GL_INVERT: + return BRW_LOGICOPFUNCTION_INVERT; + case GL_OR_REVERSE: + return BRW_LOGICOPFUNCTION_OR_REVERSE; + case GL_NAND: + return BRW_LOGICOPFUNCTION_NAND; + case GL_SET: + return BRW_LOGICOPFUNCTION_SET; default: - return LOGICOP_SET; + return BRW_LOGICOPFUNCTION_SET; } } - - -static void intelClearColor(GLcontext *ctx, const GLfloat color[4]) -{ - struct intel_context *intel = intel_context(ctx); - - UNCLAMPED_FLOAT_TO_RGBA_CHAN(intel->clear_chan, color); - - intel->ClearColor8888 = INTEL_PACKCOLOR8888(intel->clear_chan[0], - intel->clear_chan[1], - intel->clear_chan[2], - intel->clear_chan[3]); - intel->ClearColor565 = INTEL_PACKCOLOR565(intel->clear_chan[0], - intel->clear_chan[1], - intel->clear_chan[2]); -} - - - -/* Fallback to swrast for select and feedback. - */ -static void intelRenderMode( GLcontext *ctx, GLenum mode ) -{ - struct intel_context *intel = intel_context(ctx); - FALLBACK( intel, INTEL_FALLBACK_RENDERMODE, (mode != GL_RENDER) ); -} - - -void intelInitStateFuncs( struct dd_function_table *functions ) -{ - functions->RenderMode = intelRenderMode; - functions->ClearColor = intelClearColor; -}