diff options
Diffstat (limited to 'xc/lib/GL/mesa/src/drv/i830')
33 files changed, 6673 insertions, 6431 deletions
diff --git a/xc/lib/GL/mesa/src/drv/i830/Imakefile b/xc/lib/GL/mesa/src/drv/i830/Imakefile index 926900c67..fa4474bba 100644 --- a/xc/lib/GL/mesa/src/drv/i830/Imakefile +++ b/xc/lib/GL/mesa/src/drv/i830/Imakefile @@ -33,8 +33,7 @@ XCOMM $XFree86: xc/lib/GL/mesa/src/drv/i830/Imakefile,v 1.2 2002/02/23 00:45:50 DEFINES = $(ALLOC_DEFINES) $(DRI_DEFINES) $(MESA_ASM_DEFINES) INCLUDES = $(X_INCLUDES) $(MESA_INCLUDES) $(DRI_INCLUDES) - DRIOBJS = $(GLXLIBSRC)/mesa/dri/dri_mesa.o \ - $(GLXLIBSRC)/dri/dri_tmm.o + DRIOBJS = $(GLXLIBSRC)/dri/dri_util.o DRMOBJS = $(GLXLIBSRC)/dri/drm/xf86drm.o \ $(GLXLIBSRC)/dri/drm/xf86drmHash.o \ diff --git a/xc/lib/GL/mesa/src/drv/i830/Imakefile.inc b/xc/lib/GL/mesa/src/drv/i830/Imakefile.inc index 86c425b53..9da00b91a 100644 --- a/xc/lib/GL/mesa/src/drv/i830/Imakefile.inc +++ b/xc/lib/GL/mesa/src/drv/i830/Imakefile.inc @@ -1,4 +1,4 @@ -XCOMM $XFree86: xc/lib/GL/mesa/src/drv/i830/Imakefile.inc,v 1.1 2001/10/04 18:28:21 alanh Exp $ +XCOMM $XFree86: xc/lib/GL/mesa/src/drv/i830/Imakefile.inc,v 1.1 2001/03/23 19:18:40 dawes Exp $ #ifndef MesaDrvSrcDir #define MesaDrvSrcDir $(GLXLIBSRC)/mesa/src/drv @@ -17,84 +17,100 @@ ALLOC_DEFINES = -DMALLOC_0_RETURNS_NULL #if BuildXF86DRI DRI_DEFINES = GlxDefines - DRI_INCLUDES = -I$(GLXLIBSRC)/dri -I$(GLXLIBSRC)/glx \ - -I$(INCLUDESRC) -I$(INCLUDESRC)/GL \ - -I$(GLXLIBSRC)/mesa/dri \ + DRI_INCLUDES = -I$(GLXLIBSRC)/dri \ + -I$(GLXLIBSRC)/glx \ + -I$(INCLUDESRC) \ + -I$(INCLUDESRC)/GL \ + -I$(GLXLIBSRC)/dri \ -I$(SERVERSRC)/GL/dri \ -I$(XF86OSSRC) \ -I$(XF86DRIVERSRC)/i810 \ - -I$(GLXLIBSRC)/dri/drm + -I$(GLXLIBSRC)/dri/drm \ + -I$(GLXLIBSRC)/include #endif MESA_INCLUDES = -I$(MESASRCDIR)/src -I$(MESADRVSRCDIR)/common \ -I$(MESADRVSRCDIR)/i830 X_INCLUDES = -I$(XINCLUDESRC) -I$(EXTINCSRC) - I830SRCS = $(MESADRVI830BUILDDIR)i830_xmesa.c \ - $(MESADRVI830BUILDDIR)i830_dd.c \ - $(MESADRVI830BUILDDIR)i830_pipeline.c \ + I830SRCS = $(MESADRVI830BUILDDIR)i830_context.c \ + $(MESADRVI830BUILDDIR)i830_debug.c \ + $(MESADRVI830BUILDDIR)i830_ioctl.c \ + $(MESADRVI830BUILDDIR)i830_render.c \ + $(MESADRVI830BUILDDIR)i830_screen.c \ $(MESADRVI830BUILDDIR)i830_span.c \ $(MESADRVI830BUILDDIR)i830_state.c \ $(MESADRVI830BUILDDIR)i830_tex.c \ + $(MESADRVI830BUILDDIR)i830_texmem.c \ + $(MESADRVI830BUILDDIR)i830_texstate.c \ $(MESADRVI830BUILDDIR)i830_tris.c \ - $(MESADRVI830BUILDDIR)i830_vb.c \ - $(MESADRVI830BUILDDIR)i830_fastpath.c \ - $(MESADRVI830BUILDDIR)i830_ioctl.c + $(MESADRVI830BUILDDIR)i830_vb.c - I830OBJS = $(MESADRVI830BUILDDIR)i830_xmesa.o \ - $(MESADRVI830BUILDDIR)i830_dd.o \ - $(MESADRVI830BUILDDIR)i830_pipeline.o \ + I830OBJS = $(MESADRVI830BUILDDIR)i830_context.o \ + $(MESADRVI830BUILDDIR)i830_debug.o \ + $(MESADRVI830BUILDDIR)i830_ioctl.o \ + $(MESADRVI830BUILDDIR)i830_render.o \ + $(MESADRVI830BUILDDIR)i830_screen.o \ $(MESADRVI830BUILDDIR)i830_span.o \ $(MESADRVI830BUILDDIR)i830_state.o \ $(MESADRVI830BUILDDIR)i830_tex.o \ + $(MESADRVI830BUILDDIR)i830_texmem.o \ + $(MESADRVI830BUILDDIR)i830_texstate.o \ $(MESADRVI830BUILDDIR)i830_tris.o \ - $(MESADRVI830BUILDDIR)i830_vb.o \ - $(MESADRVI830BUILDDIR)i830_fastpath.o \ - $(MESADRVI830BUILDDIR)i830_ioctl.o + $(MESADRVI830BUILDDIR)i830_vb.o - I830UOBJS = $(MESADRVI830BUILDDIR)unshared/i830_xmesa.o \ - $(MESADRVI830BUILDDIR)unshared/i830_dd.o \ - $(MESADRVI830BUILDDIR)unshared/i830_pipeline.o \ + I830UOBJS = $(MESADRVI830BUILDDIR)unshared/i830_context.o \ + $(MESADRVI830BUILDDIR)unshared/i830_debug.o \ + $(MESADRVI830BUILDDIR)unshared/i830_ioctl.o \ + $(MESADRVI830BUILDDIR)unshared/i830_render.o \ + $(MESADRVI830BUILDDIR)unshared/i830_screen.o \ $(MESADRVI830BUILDDIR)unshared/i830_span.o \ $(MESADRVI830BUILDDIR)unshared/i830_state.o \ $(MESADRVI830BUILDDIR)unshared/i830_tex.o \ + $(MESADRVI830BUILDDIR)unshared/i830_texmem.o \ + $(MESADRVI830BUILDDIR)unshared/i830_texstate.o \ $(MESADRVI830BUILDDIR)unshared/i830_tris.o \ - $(MESADRVI830BUILDDIR)unshared/i830_vb.o \ - $(MESADRVI830BUILDDIR)unshared/i830_fastpath.o \ - $(MESADRVI830BUILDDIR)unshared/i830_ioctl.o + $(MESADRVI830BUILDDIR)unshared/i830_vb.o - I830DOBJS = $(MESADRVI830BUILDDIR)unshared/i830_xmesa.o \ - $(MESADRVI830BUILDDIR)unshared/i830_dd.o \ - $(MESADRVI830BUILDDIR)unshared/i830_pipeline.o \ - $(MESADRVI830BUILDDIR)unshared/i830_span.o \ - $(MESADRVI830BUILDDIR)unshared/i830_state.o \ - $(MESADRVI830BUILDDIR)unshared/i830_tex.o \ - $(MESADRVI830BUILDDIR)unshared/i830_tris.o \ - $(MESADRVI830BUILDDIR)unshared/i830_vb.o \ - $(MESADRVI830BUILDDIR)unshared/i830_fastpath.o \ - $(MESADRVI830BUILDDIR)unshared/i830_ioctl.o + I830DOBJS = $(MESADRVI830BUILDDIR)debugger/i830_context.o \ + $(MESADRVI830BUILDDIR)debugger/i830_debug.o \ + $(MESADRVI830BUILDDIR)debugger/i830_ioctl.o \ + $(MESADRVI830BUILDDIR)debugger/i830_render.o \ + $(MESADRVI830BUILDDIR)debugger/i830_screen.o \ + $(MESADRVI830BUILDDIR)debugger/i830_span.o \ + $(MESADRVI830BUILDDIR)debugger/i830_state.o \ + $(MESADRVI830BUILDDIR)debugger/i830_tex.o \ + $(MESADRVI830BUILDDIR)debugger/i830_texmem.o \ + $(MESADRVI830BUILDDIR)debugger/i830_texstate.o \ + $(MESADRVI830BUILDDIR)debugger/i830_tris.o \ + $(MESADRVI830BUILDDIR)debugger/i830_vb.o - I830POBJS = $(MESADRVI830BUILDDIR)unshared/i830_xmesa.o \ - $(MESADRVI830BUILDDIR)unshared/i830_dd.o \ - $(MESADRVI830BUILDDIR)unshared/i830_pipeline.o \ - $(MESADRVI830BUILDDIR)unshared/i830_span.o \ - $(MESADRVI830BUILDDIR)unshared/i830_state.o \ - $(MESADRVI830BUILDDIR)unshared/i830_tex.o \ - $(MESADRVI830BUILDDIR)unshared/i830_tris.o \ - $(MESADRVI830BUILDDIR)unshared/i830_vb.o \ - $(MESADRVI830BUILDDIR)unshared/i830_fastpath.o \ - $(MESADRVI830BUILDDIR)unshared/i830_ioctl.o + I830POBJS = $(MESADRVI830BUILDDIR)profiled/i830_context.o \ + $(MESADRVI830BUILDDIR)profiled/i830_debug.o \ + $(MESADRVI830BUILDDIR)profiled/i830_ioctl.o \ + $(MESADRVI830BUILDDIR)profiled/i830_render.o \ + $(MESADRVI830BUILDDIR)profiled/i830_screen.o \ + $(MESADRVI830BUILDDIR)profiled/i830_span.o \ + $(MESADRVI830BUILDDIR)profiled/i830_state.o \ + $(MESADRVI830BUILDDIR)profiled/i830_tex.o \ + $(MESADRVI830BUILDDIR)profiled/i830_texmem.o \ + $(MESADRVI830BUILDDIR)profiled/i830_texstate.o \ + $(MESADRVI830BUILDDIR)profiled/i830_tris.o \ + $(MESADRVI830BUILDDIR)profiled/i830_vb.o #ifdef NeedToLinkMesaSrc -LinkSourceFile(i830_xmesa.c, $(MESADRVSRCDIR)/i830) -LinkSourceFile(i830_dd.c, $(MESADRVSRCDIR)/i830) -LinkSourceFile(i830_pipeline.c, $(MESADRVSRCDIR)/i830) +LinkSourceFile(i830_context.c, $(MESADRVSRCDIR)/i830) +LinkSourceFile(i830_debug.c, $(MESADRVSRCDIR)/i830) +LinkSourceFile(i830_ioctl.c, $(MESADRVSRCDIR)/i830) +LinkSourceFile(i830_render.c, $(MESADRVSRCDIR)/i830) +LinkSourceFile(i830_screen.c, $(MESADRVSRCDIR)/i830) LinkSourceFile(i830_span.c, $(MESADRVSRCDIR)/i830) LinkSourceFile(i830_state.c, $(MESADRVSRCDIR)/i830) LinkSourceFile(i830_tex.c, $(MESADRVSRCDIR)/i830) +LinkSourceFile(i830_texmem.c, $(MESADRVSRCDIR)/i830) +LinkSourceFile(i830_texstate.c, $(MESADRVSRCDIR)/i830) LinkSourceFile(i830_tris.c, $(MESADRVSRCDIR)/i830) LinkSourceFile(i830_vb.c, $(MESADRVSRCDIR)/i830) -LinkSourceFile(i830_fastpath.c, $(MESADRVSRCDIR)/i830) -LinkSourceFile(i830_ioctl.c, $(MESADRVSRCDIR)/i830) #endif + diff --git a/xc/lib/GL/mesa/src/drv/i830/i830_3d_reg.h b/xc/lib/GL/mesa/src/drv/i830/i830_3d_reg.h index 80721d344..2166a136d 100644 --- a/xc/lib/GL/mesa/src/drv/i830/i830_3d_reg.h +++ b/xc/lib/GL/mesa/src/drv/i830/i830_3d_reg.h @@ -683,6 +683,11 @@ #define TEXCOORDFMT_4D 2 #define TEXCOORDFMT_1D 3 +/*New stuff picked up along the way */ + +#define MLC_LOD_BIAS_MASK ((1<<7)-1) + + /* STATE3D_VERTEX_TRANSFORM, p207 */ #define STATE3D_VERTEX_TRANS_CMD (CMD_3D|(0x1d<<24)|(0x8b<<16)|0) #define STATE3D_VERTEX_TRANS_MTX_CMD (CMD_3D|(0x1d<<24)|(0x8b<<16)|6) diff --git a/xc/lib/GL/mesa/src/drv/i830/i830_context.c b/xc/lib/GL/mesa/src/drv/i830/i830_context.c new file mode 100644 index 000000000..e425fd949 --- /dev/null +++ b/xc/lib/GL/mesa/src/drv/i830/i830_context.c @@ -0,0 +1,474 @@ +/************************************************************************** + * + * Copyright 1998-1999 Precision Insight, 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 PRECISION INSIGHT 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. + * + * **************************************************************************/ +/* $XFree86$ */ + +/* + * Authors: + * Jeff Hartmann <jhartmann@2d3d.com> + * Graeme Fisher <graeme@2d3d.co.za> + * Abraham vd Merwe <abraham@2d3d.co.za> + * + * Heavily Based on I810 driver written by: + * Keith Whitwell <keith@tungstengraphics.com> + */ + +#include "glheader.h" +#include "context.h" +#include "matrix.h" +#include "simple_list.h" +#include "extensions.h" +#include "mem.h" + +#include "swrast/swrast.h" +#include "swrast_setup/swrast_setup.h" +#include "tnl/tnl.h" +#include "array_cache/acache.h" + +#include "tnl/t_pipeline.h" + +#include "i830_screen.h" +#include "i830_dri.h" + +#include "i830_state.h" +#include "i830_tex.h" +#include "i830_span.h" +#include "i830_tris.h" +#include "i830_vb.h" +#include "i830_ioctl.h" + +#include <X11/Xlibint.h> +#include <stdio.h> + +/*************************************** + * Mesa's Driver Functions + ***************************************/ + +static const GLubyte *i830DDGetString( GLcontext *ctx, GLenum name ) +{ + switch (name) { + case GL_VENDOR: + return (GLubyte *)"2d3D, Inc"; + case GL_RENDERER: + return (GLubyte *)"Mesa DRI I830 20020528"; + default: + return 0; + } +} + +static void i830BufferSize(GLframebuffer *buffer, + GLuint *width, GLuint *height) +{ + GET_CURRENT_CONTEXT(ctx); + i830ContextPtr imesa = I830_CONTEXT(ctx); + /* Need to lock to make sure the driDrawable is uptodate. This + * information is used to resize Mesa's software buffers, so it has + * to be correct. + */ + LOCK_HARDWARE(imesa); + *width = imesa->driDrawable->w; + *height = imesa->driDrawable->h; + UNLOCK_HARDWARE(imesa); +} + +/* Enable all the extensions we need */ +static void i830InitExtensions( GLcontext *ctx ) +{ + _mesa_enable_imaging_extensions( ctx ); + _mesa_enable_extension( ctx, "GL_ARB_multitexture" ); + _mesa_enable_extension( ctx, "GL_ARB_texture_env_add" ); + _mesa_enable_extension( ctx, "GL_EXT_texture_env_add" ); + _mesa_enable_extension( ctx, "GL_ARB_texture_env_combine" ); + _mesa_enable_extension( ctx, "GL_EXT_texture_env_combine" ); + _mesa_enable_extension( ctx, "GL_EXT_blend_color" ); + _mesa_enable_extension( ctx, "GL_EXT_blend_minmax" ); + _mesa_enable_extension( ctx, "GL_EXT_blend_subtract" ); + _mesa_enable_extension( ctx, "GL_EXT_blend_func_separate" ); + _mesa_enable_extension( ctx, "GL_EXT_texture_lod_bias" ); + + /* Leave this for later */ +#if 0 + _mesa_enable_extension( ctx, "GL_EXT_stencil_wrap" ); +#endif +} + +extern const struct gl_pipeline_stage _i830_render_stage; + +static const struct gl_pipeline_stage *i830_pipeline[] = { + &_tnl_vertex_transform_stage, + &_tnl_normal_transform_stage, + &_tnl_lighting_stage, + &_tnl_fog_coordinate_stage, + &_tnl_texgen_stage, + &_tnl_texture_transform_stage, + /* REMOVE: point attenuation stage */ +#if 1 + &_i830_render_stage, /* ADD: unclipped rastersetup-to-dma */ +#endif + &_tnl_render_stage, + 0, +}; + +GLboolean i830CreateContext( Display *dpy, const __GLcontextModes *mesaVis, + __DRIcontextPrivate *driContextPriv, + void *sharedContextPrivate) +{ + GLcontext *ctx , *shareCtx; + i830ContextPtr imesa; + __DRIscreenPrivate *sPriv = driContextPriv->driScreenPriv; + i830ScreenPrivate *i830Screen = (i830ScreenPrivate *)sPriv->private; + I830SAREAPtr saPriv=(I830SAREAPtr) + (((GLubyte *)sPriv->pSAREA)+i830Screen->sarea_priv_offset); + + /* Allocate i830 context */ + imesa = (i830ContextPtr) CALLOC_STRUCT(i830_context_t); + if (!imesa) return GL_FALSE; + + /* Allocate the Mesa context */ + if (sharedContextPrivate) + shareCtx = ((i830ContextPtr) sharedContextPrivate)->glCtx; + else + shareCtx = NULL; + + imesa->glCtx = _mesa_create_context(mesaVis, shareCtx, imesa, GL_TRUE); + if (!imesa->glCtx) { + FREE(imesa); + return GL_FALSE; + } + driContextPriv->driverPrivate = imesa; + + /* Set the maximum texture size small enough that we can guarentee + * that both texture units can bind a maximal texture and have them + * in memory at once. + */ + ctx = imesa->glCtx; + if (i830Screen->textureSize < 2*1024*1024) { + ctx->Const.MaxTextureLevels = 9; + } else if (i830Screen->textureSize < 8*1024*1024) { + ctx->Const.MaxTextureLevels = 10; + } else { + ctx->Const.MaxTextureLevels = 11; + } + ctx->Const.MaxTextureUnits = 2; + + ctx->Const.MinLineWidth = 1.0; + ctx->Const.MinLineWidthAA = 1.0; + ctx->Const.MaxLineWidth = 3.0; + ctx->Const.MaxLineWidthAA = 3.0; + ctx->Const.LineWidthGranularity = 1.0; + + ctx->Const.MinPointSize = 1.0; + ctx->Const.MinPointSizeAA = 1.0; + ctx->Const.MaxPointSize = 255.0; + ctx->Const.MaxPointSizeAA = 3.0; + ctx->Const.PointSizeGranularity = 1.0; + + ctx->Driver.GetBufferSize = i830BufferSize; + ctx->Driver.ResizeBuffers = _swrast_alloc_buffers; + ctx->Driver.GetString = i830DDGetString; + + /* Who owns who? */ + ctx->DriverCtx = (void *) imesa; + imesa->glCtx = ctx; + + /* Initialize the software rasterizer and helper modules. */ + _swrast_CreateContext( ctx ); + _ac_CreateContext( ctx ); + _tnl_CreateContext( ctx ); + _swsetup_CreateContext( ctx ); + + /* Install the customized pipeline: */ + _tnl_destroy_pipeline( ctx ); + _tnl_install_pipeline( ctx, i830_pipeline ); + + /* Configure swrast to match hardware characteristics: */ + _swrast_allow_pixel_fog( ctx, GL_FALSE ); + _swrast_allow_vertex_fog( ctx, GL_TRUE ); + + /* Dri stuff */ + imesa->display = dpy; + imesa->hHWContext = driContextPriv->hHWContext; + imesa->driFd = sPriv->fd; + imesa->driHwLock = &sPriv->pSAREA->lock; + imesa->vertex_format = 0; + + imesa->hw_stencil = mesaVis->stencilBits && mesaVis->depthBits == 24; + + switch(mesaVis->depthBits) { + case 16: + imesa->depth_scale = 1.0/0xffff; + imesa->depth_clear_mask = ~0; + imesa->ClearDepth = 0xffff; + break; + case 24: + imesa->depth_scale = 1.0/0xffffff; + imesa->depth_clear_mask = 0x00ffffff; + imesa->stencil_clear_mask = 0xff000000; + imesa->ClearDepth = 0x00ffffff; + break; + case 32: /* Not supported */ + default: + break; + } + /* Completely disable stenciling for now, there are some serious issues + * with stencil. + */ +#if 1 + imesa->hw_stencil = 0; +#endif + + imesa->i830Screen = i830Screen; + imesa->driScreen = sPriv; + imesa->sarea = saPriv; + imesa->glBuffer = NULL; + + imesa->texHeap = mmInit( 0, i830Screen->textureSize ); + imesa->RenderIndex = ~0; + imesa->dirty = ~0; + imesa->upload_cliprects = GL_TRUE; + + make_empty_list(&imesa->TexObjList); + make_empty_list(&imesa->SwappedOut); + + imesa->CurrentTexObj[0] = 0; + imesa->CurrentTexObj[1] = 0; + + _math_matrix_ctr (&imesa->ViewportMatrix); + + + i830InitExtensions (ctx); + i830DDInitStateFuncs( ctx ); + i830DDInitTextureFuncs( ctx ); + i830InitTriFuncs (ctx); + i830DDInitSpanFuncs( ctx ); + i830DDInitIoctlFuncs( ctx ); + i830InitVB (ctx); + i830DDInitState (ctx); + + return GL_TRUE; +} + +void i830DestroyContext(__DRIcontextPrivate *driContextPriv) +{ + i830ContextPtr imesa = (i830ContextPtr) driContextPriv->driverPrivate; + + assert(imesa); /* should never be null */ + if (imesa) { + _swsetup_DestroyContext (imesa->glCtx); + _tnl_DestroyContext (imesa->glCtx); + _ac_DestroyContext (imesa->glCtx); + _swrast_DestroyContext (imesa->glCtx); + + i830FreeVB (imesa->glCtx); + + /* free the Mesa context */ + imesa->glCtx->DriverCtx = NULL; + _mesa_destroy_context(imesa->glCtx); + + Xfree (imesa); + } +} + +void i830XMesaSetFrontClipRects( i830ContextPtr imesa ) +{ + __DRIdrawablePrivate *dPriv = imesa->driDrawable; + + imesa->numClipRects = dPriv->numClipRects; + imesa->pClipRects = dPriv->pClipRects; + imesa->drawX = dPriv->x; + imesa->drawY = dPriv->y; + + i830EmitDrawingRectangle( imesa ); + imesa->upload_cliprects = GL_TRUE; +} + +void i830XMesaSetBackClipRects( i830ContextPtr imesa ) +{ + __DRIdrawablePrivate *dPriv = imesa->driDrawable; + + if (dPriv->numBackClipRects == 0) { + imesa->numClipRects = dPriv->numClipRects; + imesa->pClipRects = dPriv->pClipRects; + imesa->drawX = dPriv->x; + imesa->drawY = dPriv->y; + } else { + imesa->numClipRects = dPriv->numBackClipRects; + imesa->pClipRects = dPriv->pBackClipRects; + imesa->drawX = dPriv->backX; + imesa->drawY = dPriv->backY; + } + + i830EmitDrawingRectangle( imesa ); + imesa->upload_cliprects = GL_TRUE; +} + +static void i830XMesaWindowMoved( i830ContextPtr imesa ) +{ + switch (imesa->glCtx->Color.DriverDrawBuffer) { + case GL_FRONT_LEFT: + i830XMesaSetFrontClipRects( imesa ); + break; + case GL_BACK_LEFT: + i830XMesaSetBackClipRects( imesa ); + break; + default: + break; + } +} + +GLboolean i830UnbindContext(__DRIcontextPrivate *driContextPriv) +{ + i830ContextPtr imesa = (i830ContextPtr) driContextPriv->driverPrivate; + if (imesa) { + /* Might want to change this so texblend isn't always updated */ + imesa->dirty = (I830_UPLOAD_CTX | + I830_UPLOAD_BUFFERS | + I830_UPLOAD_TEXBLEND0 | + I830_UPLOAD_TEXBLEND1); + + if (imesa->CurrentTexObj[0]) imesa->dirty |= I830_UPLOAD_TEX0; + if (imesa->CurrentTexObj[1]) imesa->dirty |= I830_UPLOAD_TEX1; + } + return GL_TRUE; +} + +GLboolean i830MakeCurrent(__DRIcontextPrivate *driContextPriv, + __DRIdrawablePrivate *driDrawPriv, + __DRIdrawablePrivate *driReadPriv) +{ + + if (driContextPriv) { + i830ContextPtr imesa = (i830ContextPtr) driContextPriv->driverPrivate; + + _mesa_make_current2(imesa->glCtx, + (GLframebuffer *) driDrawPriv->driverPrivate, + (GLframebuffer *) driReadPriv->driverPrivate); + /* Shouldn't the readbuffer be stored also? */ + imesa->driDrawable = driDrawPriv; + + /* Are these necessary? */ + i830XMesaWindowMoved( imesa ); + if (!imesa->glCtx->Viewport.Width) + _mesa_set_viewport(imesa->glCtx, 0, 0, + driDrawPriv->w, driDrawPriv->h); + } else { + _mesa_make_current(0,0); + } + + return GL_TRUE; +} + +void i830GetLock( i830ContextPtr imesa, GLuint flags ) +{ + __DRIdrawablePrivate *dPriv = imesa->driDrawable; + __DRIscreenPrivate *sPriv = imesa->driScreen; + I830SAREAPtr sarea = imesa->sarea; + int me = imesa->hHWContext; + + drmGetLock(imesa->driFd, imesa->hHWContext, flags); + + /* If the window moved, may need to set a new cliprect now. + * + * NOTE: This releases and regains the hw lock, so all state + * checking must be done *after* this call: + */ + DRI_VALIDATE_DRAWABLE_INFO(imesa->display, sPriv, dPriv); + + /* If we lost context, need to dump all registers to hardware. + * Note that we don't care about 2d contexts, even if they perform + * accelerated commands, so the DRI locking in the X server is even + * more broken than usual. + */ + + if (sarea->ctxOwner != me) { + imesa->upload_cliprects = GL_TRUE; + imesa->dirty |= (I830_UPLOAD_CTX | + I830_UPLOAD_BUFFERS); + + if(imesa->CurrentTexObj[0]) imesa->dirty |= I830_UPLOAD_TEX0; + if(imesa->CurrentTexObj[1]) imesa->dirty |= I830_UPLOAD_TEX1; + if(imesa->TexBlendWordsUsed[0]) imesa->dirty |= I830_UPLOAD_TEXBLEND0; + if(imesa->TexBlendWordsUsed[1]) imesa->dirty |= I830_UPLOAD_TEXBLEND1; + + sarea->ctxOwner = me; + } + + /* Shared texture managment - if another client has played with + * texture space, figure out which if any of our textures have been + * ejected, and update our global LRU. + */ + if (sarea->texAge != imesa->texAge) { + int sz = 1 << (imesa->i830Screen->logTextureGranularity); + int idx, nr = 0; + + /* Have to go right round from the back to ensure stuff ends up + * LRU in our local list... + */ + for (idx = sarea->texList[I830_NR_TEX_REGIONS].prev ; + idx != I830_NR_TEX_REGIONS && nr < I830_NR_TEX_REGIONS ; + idx = sarea->texList[idx].prev, nr++) { + if (sarea->texList[idx].age > imesa->texAge) + i830TexturesGone(imesa, idx * sz, sz, sarea->texList[idx].in_use); + } + + if (nr == I830_NR_TEX_REGIONS) { + i830TexturesGone(imesa, 0, imesa->i830Screen->textureSize, 0); + i830ResetGlobalLRU( imesa ); + } + + imesa->texAge = sarea->texAge; + } + + if (imesa->lastStamp != dPriv->lastStamp) { + i830XMesaWindowMoved( imesa ); + imesa->lastStamp = dPriv->lastStamp; + } + + sarea->last_quiescent = -1; /* just kill it for now */ +} + +void i830SwapBuffers(Display *dpy, void *drawablePrivate) +{ + __DRIdrawablePrivate *dPriv = (__DRIdrawablePrivate *) drawablePrivate; + + if (dPriv->driContextPriv && dPriv->driContextPriv->driverPrivate) { + i830ContextPtr imesa; + GLcontext *ctx; + imesa = (i830ContextPtr) dPriv->driContextPriv->driverPrivate; + ctx = imesa->glCtx; + if (ctx->Visual.doubleBufferMode) { + _mesa_swapbuffers( ctx ); /* flush pending rendering comands */ + if ( imesa->doPageFlip ) { + i830PageFlip( dPriv ); + } else { + i830CopyBuffer( dPriv ); + } + } + } else { + /* XXX this shouldn't be an error but we can't handle it for now */ + _mesa_problem(NULL, "i830SwapBuffers: drawable has no context!\n"); + } +} diff --git a/xc/lib/GL/mesa/src/drv/i830/i830_context.h b/xc/lib/GL/mesa/src/drv/i830/i830_context.h new file mode 100644 index 000000000..516e0047b --- /dev/null +++ b/xc/lib/GL/mesa/src/drv/i830/i830_context.h @@ -0,0 +1,267 @@ +/* + * GLX Hardware Device Driver for Intel i830 + * Copyright (C) 1999 Keith Whitwell + * + * 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 + * KEITH WHITWELL, OR ANY OTHER CONTRIBUTORS 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. + * + */ + +/* Adapted for use in the I830M driver: + * Jeff Hartmann <jhartmann@2d3d.com> + */ +/* $XFree86$ */ + +#ifndef I830CONTEXT_INC +#define I830CONTEXT_INC + +typedef struct i830_context_t i830Context; +typedef struct i830_context_t *i830ContextPtr; +typedef struct i830_texture_object_t *i830TextureObjectPtr; + + +#include "mtypes.h" +#include "drm.h" +#include "mm.h" + +#include "i830_screen.h" +#include "i830_tex.h" +#include "i830_drv.h" + +#define TAG(x) i830##x +#include "tnl_dd/t_dd_vertex.h" +#undef TAG + + +typedef void (*i830_tri_func)(i830ContextPtr, i830Vertex *, i830Vertex *, + i830Vertex *); +typedef void (*i830_line_func)(i830ContextPtr, i830Vertex *, i830Vertex *); +typedef void (*i830_point_func)(i830ContextPtr, i830Vertex *); + +#define I830_FALLBACK_TEXTURE 0x1 +#define I830_FALLBACK_DRAW_BUFFER 0x2 +#define I830_FALLBACK_READ_BUFFER 0x4 +#define I830_FALLBACK_COLORMASK 0x8 +#define I830_FALLBACK_SPECULAR 0x20 +#define I830_FALLBACK_LOGICOP 0x40 +#define I830_FALLBACK_RENDERMODE 0x80 +#define I830_FALLBACK_STENCIL 0x100 +#define I830_FALLBACK_BLEND_EQ 0x200 +#define I830_FALLBACK_BLEND_FUNC 0x400 +#define I830_FALLBACK_STIPPLE 0x800 + +struct i830_context_t +{ + GLint refcount; + GLcontext *glCtx; + + /*From I830 stuff*/ + int TextureMode; + GLuint renderindex; + GLuint TexBlendWordsUsed[I830_TEXBLEND_COUNT]; + GLuint TexBlend[I830_TEXBLEND_COUNT][I830_TEXBLEND_SIZE]; + GLuint Init_TexBlend[I830_TEXBLEND_COUNT][I830_TEXBLEND_SIZE]; + GLuint Init_TexBlendWordsUsed[I830_TEXBLEND_COUNT]; + GLuint Init_TexBlendColorPipeNum[I830_TEXBLEND_COUNT]; + GLuint TexBlendColorPipeNum[I830_TEXBLEND_COUNT]; + GLuint Init_BufferSetup[I830_DEST_SETUP_SIZE]; + + GLenum palette_format; + GLuint palette[256]; + + + GLuint Init_Setup[I830_CTX_SETUP_SIZE]; + GLuint vertex_prim; + drmBufPtr vertex_dma_buffer; + + GLboolean mask_red; + GLboolean mask_green; + GLboolean mask_blue; + GLboolean mask_alpha; + + GLboolean clear_red; + GLboolean clear_green; + GLboolean clear_blue; + GLboolean clear_alpha; + + GLfloat depth_scale; + int depth_clear_mask; + int stencil_clear_mask; + int ClearDepth; + int hw_stencil; + + GLuint MonoColor; + + GLuint LastTexEnabled; + GLuint TexEnabledMask; + + /* Textures + */ + i830TextureObjectPtr CurrentTexObj[2]; + struct i830_texture_object_t TexObjList; + struct i830_texture_object_t SwappedOut; + memHeap_t *texHeap; + + /* Bit flag to keep track of fallbacks. + */ + GLuint Fallback; + + /* Temporaries for translating away float colors: + */ + struct gl_client_array UbyteColor; + struct gl_client_array UbyteSecondaryColor; + + /* State for i830vb.c and i830tris.c. + */ + GLuint new_state; /* _NEW_* flags */ + GLuint SetupNewInputs; + GLuint SetupIndex; + GLuint RenderIndex; + GLmatrix ViewportMatrix; + GLenum render_primitive; + GLenum reduced_primitive; + GLuint hw_primitive; + GLuint vertex_format; + char *verts; + + drmBufPtr vertex_buffer; + char *vertex_addr; + GLuint vertex_low; + GLuint vertex_high; + GLuint vertex_last_prim; + + GLboolean upload_cliprects; + + + /* Fallback rasterization functions + */ + i830_point_func draw_point; + i830_line_func draw_line; + i830_tri_func draw_tri; + + /* Hardware state + */ + GLuint dirty; /* I810_UPLOAD_* */ + GLuint Setup[I830_CTX_SETUP_SIZE]; + GLuint BufferSetup[I830_DEST_SETUP_SIZE]; + int vertex_size; + int vertex_stride_shift; + GLint lastStamp; + GLboolean stipple_in_hw; + + GLenum TexEnvImageFmt[2]; + + /* State which can't be computed completely on the fly: + */ + GLuint LcsCullMode; + GLuint LcsLineWidth; + GLuint LcsPointSize; + + /* Funny mesa mirrors + */ + GLuint ClearColor; + + /* DRI stuff + */ + GLuint needClip; + GLframebuffer *glBuffer; + GLboolean doPageFlip; + + /* These refer to the current draw (front vs. back) buffer: + */ + char *drawMap; /* draw buffer address in virtual mem */ + char *readMap; + int drawX; /* origin of drawable in draw buffer */ + int drawY; + GLuint numClipRects; /* cliprects for that buffer */ + XF86DRIClipRectPtr pClipRects; + + int lastSwap; + int texAge; + int ctxAge; + int dirtyAge; + + GLboolean scissor; + XF86DRIClipRectRec draw_rect; + XF86DRIClipRectRec scissor_rect; + + drmContext hHWContext; + drmLock *driHwLock; + int driFd; + Display *display; + + __DRIdrawablePrivate *driDrawable; + __DRIscreenPrivate *driScreen; + i830ScreenPrivate *i830Screen; + I830SAREAPtr sarea; +}; + + +#define I830_TEX_UNIT_ENABLED(unit) (1<<unit) +#define VALID_I830_TEXTURE_OBJECT(tobj) (tobj) + +#define I830_CONTEXT(ctx) ((i830ContextPtr)(ctx->DriverCtx)) +#define I830_DRIVER_DATA(vb) ((i830VertexBufferPtr)((vb)->driver_data)) +#define GET_DISPATCH_AGE(imesa) imesa->sarea->last_dispatch +#define GET_ENQUEUE_AGE(imesa) imesa->sarea->last_enqueue + + +/* Lock the hardware and validate our state. + */ +#define LOCK_HARDWARE( imesa ) \ +do { \ + char __ret=0; \ + DRM_CAS(imesa->driHwLock, imesa->hHWContext, \ + (DRM_LOCK_HELD|imesa->hHWContext), __ret); \ + if (__ret) \ + i830GetLock( imesa, 0 ); \ +}while (0) + + + /* Unlock the hardware using the global current context + */ +#define UNLOCK_HARDWARE(imesa) \ + DRM_UNLOCK(imesa->driFd, imesa->driHwLock, imesa->hHWContext); + + + /* This is the wrong way to do it, I'm sure. Otherwise the drm + * bitches that I've already got the heavyweight lock. At worst, + * this is 3 ioctls. The best solution probably only gets me down + * to 2 ioctls in the worst case. + */ +#define LOCK_HARDWARE_QUIESCENT( imesa ) do { \ + LOCK_HARDWARE( imesa ); \ + i830RegetLockQuiescent( imesa ); \ +} while(0) + + + +extern void i830GetLock(i830ContextPtr imesa, GLuint flags); +extern void i830EmitHwStateLocked(i830ContextPtr imesa); +extern void i830EmitDrawingRectangle(i830ContextPtr imesa); +extern void i830XMesaSetBackClipRects(i830ContextPtr imesa); +extern void i830XMesaSetFrontClipRects(i830ContextPtr imesa); +extern void i830DDExtensionsInit(GLcontext *ctx); +extern void i830DDInitDriverFuncs(GLcontext *ctx); +extern void i830DDUpdateHwState(GLcontext *ctx); + +#define SUBPIXEL_X 0.125 +#define SUBPIXEL_Y 0.125 + +#endif + diff --git a/xc/lib/GL/mesa/src/drv/i830/i830_dd.c b/xc/lib/GL/mesa/src/drv/i830/i830_dd.c deleted file mode 100644 index 7b33694bc..000000000 --- a/xc/lib/GL/mesa/src/drv/i830/i830_dd.c +++ /dev/null @@ -1,159 +0,0 @@ -/************************************************************************** - -Copyright 2001 VA Linux Systems Inc., Fremont, California. - -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 -on 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 -ATI, VA LINUX SYSTEMS AND/OR THEIR 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. - -**************************************************************************/ - -/* $XFree86: xc/lib/GL/mesa/src/drv/i830/i830_dd.c,v 1.1 2001/10/04 18:28:21 alanh Exp $ */ - -/* - * Author: - * Jeff Hartmann <jhartmann@valinux.com> - * - * Heavily based on the I810 driver, which was written by: - * Keith Whitwell <keithw@valinux.com> - */ - -#include "types.h" -#include "vbrender.h" - -#include <stdio.h> - -#include "mm.h" -#include "extensions.h" -#include "vb.h" -#include "dd.h" - -#include "i830_drv.h" -#include "i830_ioctl.h" - -extern int xf86VTSema; - - -/*************************************** - * Mesa's Driver Functions - ***************************************/ - - -static const GLubyte *i830DDGetString( GLcontext *ctx, GLenum name ) -{ - switch (name) { - case GL_VENDOR: - return (GLubyte *)"VA Linux Systems"; - case GL_RENDERER: - return (GLubyte *)"Mesa DRI I830 20020221"; - default: - return 0; - } -} - -static GLint i830GetParameteri(const GLcontext *ctx, GLint param) -{ - switch (param) { - case DD_HAVE_HARDWARE_FOG: - return 1; - default: - return 0; - } -} - - - -static void i830BufferSize(GLframebuffer *buffer, GLuint *width, GLuint *height) -{ - GET_CURRENT_CONTEXT(ctx); - i830ContextPtr imesa = I830_CONTEXT(ctx); - - /* Need to lock to make sure the driDrawable is uptodate. This - * information is used to resize Mesa's software buffers, so it has - * to be correct. - */ - LOCK_HARDWARE(imesa); - *width = imesa->driDrawable->w; - *height = imesa->driDrawable->h; - UNLOCK_HARDWARE(imesa); -} - - - - -void i830DDExtensionsInit( GLcontext *ctx ) -{ - gl_extensions_enable( ctx, "GL_EXT_blend_color" ); - gl_extensions_enable( ctx, "GL_EXT_blend_minmax" ); - gl_extensions_enable( ctx, "GL_EXT_blend_subtract" ); - gl_extensions_enable( ctx, "GL_EXT_blend_logic_op" ); - - gl_extensions_enable( ctx, "GL_EXT_blend_func_separate" ); - gl_extensions_enable( ctx, "GL_ARB_texture_env_add" ); - gl_extensions_enable( ctx, "GL_EXT_texture_env_add" ); - gl_extensions_enable( ctx, "GL_EXT_texture_env_combine" ); - -#if 0 - /* These need a little work, the code is there, but some applications - * don't render correctly. - */ - - gl_extensions_enable( ctx, "GL_EXT_shared_texture_palette" ); - gl_extensions_enable( ctx, "GL_EXT_paletted_texture" ); -#else - gl_extensions_disable( ctx, "GL_EXT_shared_texture_palette" ); - gl_extensions_disable( ctx, "GL_EXT_paletted_texture" ); -#endif - - /* This should be easy to add */ - gl_extensions_disable( ctx, "GL_EXT_texture_lod_bias" ); - - /* Planned extensions */ - gl_extensions_disable( ctx, "GL_ARB_texture_compression" ); - gl_extensions_disable( ctx, "GL_ARB_texture_cube_map" ); - - /* we don't support point parameters in hardware yet */ - gl_extensions_disable( ctx, "GL_EXT_point_parameters" ); - - /* The imaging subset of 1.2 isn't supported by any mesa driver. - */ - gl_extensions_disable( ctx, "ARB_imaging" ); - gl_extensions_disable( ctx, "GL_EXT_convolution" ); - gl_extensions_disable( ctx, "GL_MESA_resize_buffers" ); - gl_extensions_disable( ctx, "GL_SGIX_pixel_texture" ); - gl_extensions_disable( ctx, "GL_SGI_color_matrix" ); - gl_extensions_disable( ctx, "GL_SGI_color_table" ); -} - - - - -void i830DDInitDriverFuncs( GLcontext *ctx ) -{ - ctx->Driver.GetBufferSize = i830BufferSize; - ctx->Driver.GetString = i830DDGetString; - ctx->Driver.GetParameteri = i830GetParameteri; - ctx->Driver.RegisterVB = i830DDRegisterVB; - ctx->Driver.UnregisterVB = i830DDUnregisterVB; - ctx->Driver.Clear = i830Clear; - - - ctx->Driver.BuildPrecalcPipeline = i830DDBuildPrecalcPipeline; -} diff --git a/xc/lib/GL/mesa/src/drv/i830/i830_debug.c b/xc/lib/GL/mesa/src/drv/i830/i830_debug.c new file mode 100644 index 000000000..94fc38a90 --- /dev/null +++ b/xc/lib/GL/mesa/src/drv/i830/i830_debug.c @@ -0,0 +1,366 @@ +/************************************************************************** + +Copyright 2001 2d3d Inc., Delray Beach, FL + +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 +on 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 +ATI, VA LINUX SYSTEMS AND/OR THEIR 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. + +**************************************************************************/ + +/* $XFree86$ */ + +/* + * Author: + * Jeff Hartmann <jhartmann@2d3d.com> + */ +#include <stdio.h> +#include <unistd.h> + +#include "glheader.h" +#include "context.h" +#include "macros.h" +#include "enums.h" +#include "dd.h" + +#include "mm.h" + +#include "i830_screen.h" +#include "i830_dri.h" + +#include "i830_context.h" +#include "i830_state.h" +#include "i830_tex.h" +#include "i830_vb.h" +#include "i830_tris.h" +#include "i830_ioctl.h" +#include "i830_debug.h" + +#include "swrast/swrast.h" +#include "array_cache/acache.h" +#include "tnl/tnl.h" +#include "swrast_setup/swrast_setup.h" + +#include "tnl/t_pipeline.h" + + +#define TINY_VERTEX_FORMAT (STATE3D_VERTEX_FORMAT_CMD | \ + VRTX_TEX_COORD_COUNT(0) | \ + VRTX_HAS_DIFFUSE | \ + VRTX_HAS_XYZ) + +#define NOTEX_VERTEX_FORMAT (STATE3D_VERTEX_FORMAT_CMD | \ + VRTX_TEX_COORD_COUNT(0) | \ + VRTX_HAS_DIFFUSE | \ + VRTX_HAS_SPEC | \ + VRTX_HAS_XYZW) + +#define TEX0_VERTEX_FORMAT (STATE3D_VERTEX_FORMAT_CMD | \ + VRTX_TEX_COORD_COUNT(1) | \ + VRTX_HAS_DIFFUSE | \ + VRTX_HAS_SPEC | \ + VRTX_HAS_XYZW) + +#define TEX1_VERTEX_FORMAT (STATE3D_VERTEX_FORMAT_CMD | \ + VRTX_TEX_COORD_COUNT(2) | \ + VRTX_HAS_DIFFUSE | \ + VRTX_HAS_SPEC | \ + VRTX_HAS_XYZW) + +#define PROJ_VF2 (STATE3D_VERTEX_FORMAT_2_CMD | \ + VRTX_TEX_SET_0_FMT(TEXCOORDFMT_3D) | \ + VRTX_TEX_SET_1_FMT(TEXCOORDFMT_3D) | \ + VRTX_TEX_SET_2_FMT(TEXCOORDFMT_3D) | \ + VRTX_TEX_SET_3_FMT(TEXCOORDFMT_3D)) + +#define NON_PROJ_VF2 (STATE3D_VERTEX_FORMAT_2_CMD | \ + VRTX_TEX_SET_0_FMT(TEXCOORDFMT_2D) | \ + VRTX_TEX_SET_1_FMT(TEXCOORDFMT_2D) | \ + VRTX_TEX_SET_2_FMT(TEXCOORDFMT_2D) | \ + VRTX_TEX_SET_3_FMT(TEXCOORDFMT_2D)) + +void i830DumpContextState( i830ContextPtr imesa ) +{ + GLuint *Context = imesa->Setup; + + fprintf(stderr, "%s\n", __FUNCTION__); + fprintf(stderr, "STATE1 : 0x%08x\n", Context[I830_CTXREG_STATE1]); + fprintf(stderr, "STATE2 : 0x%08x\n", Context[I830_CTXREG_STATE2]); + fprintf(stderr, "STATE3 : 0x%08x\n", Context[I830_CTXREG_STATE3]); + fprintf(stderr, "STATE4 : 0x%08x\n", Context[I830_CTXREG_STATE4]); + fprintf(stderr, "STATE5 : 0x%08x\n", Context[I830_CTXREG_STATE5]); + fprintf(stderr, "IALPHAB : 0x%08x\n", Context[I830_CTXREG_IALPHAB]); + fprintf(stderr, "STENCILTST : 0x%08x\n", Context[I830_CTXREG_STENCILTST]); + fprintf(stderr, "ENABLES_1 : 0x%08x\n", Context[I830_CTXREG_ENABLES_1]); + fprintf(stderr, "ENABLES_2 : 0x%08x\n", Context[I830_CTXREG_ENABLES_2]); + fprintf(stderr, "AA : 0x%08x\n", Context[I830_CTXREG_AA]); + fprintf(stderr, "FOGCOLOR : 0x%08x\n", Context[I830_CTXREG_FOGCOLOR]); + fprintf(stderr, "BCOLOR0 : 0x%08x\n", Context[I830_CTXREG_BLENDCOLR0]); + fprintf(stderr, "BCOLOR : 0x%08x\n", Context[I830_CTXREG_BLENDCOLR]); + fprintf(stderr, "VF : 0x%08x\n", Context[I830_CTXREG_VF]); + fprintf(stderr, "VF2 : 0x%08x\n", Context[I830_CTXREG_VF2]); + fprintf(stderr, "MCSB0 : 0x%08x\n", Context[I830_CTXREG_MCSB0]); + fprintf(stderr, "MCSB1 : 0x%08x\n", Context[I830_CTXREG_MCSB1]); +} + +void i830DumpBufferState( i830ContextPtr imesa ) +{ + GLuint *Buffer = imesa->BufferSetup; + + fprintf(stderr, "%s\n", __FUNCTION__); + fprintf(stderr, "CBUFADDR : 0x%08x\n", Buffer[I830_DESTREG_CBUFADDR]); + fprintf(stderr, "DBUFADDR : 0x%08x\n", Buffer[I830_DESTREG_DBUFADDR]); + fprintf(stderr, "DV0 : 0x%08x\n", Buffer[I830_DESTREG_DV0]); + fprintf(stderr, "DV1 : 0x%08x\n", Buffer[I830_DESTREG_DV1]); + fprintf(stderr, "SENABLE : 0x%08x\n", Buffer[I830_DESTREG_SENABLE]); + fprintf(stderr, "SR0 : 0x%08x\n", Buffer[I830_DESTREG_SR0]); + fprintf(stderr, "SR1 : 0x%08x\n", Buffer[I830_DESTREG_SR1]); + fprintf(stderr, "SR2 : 0x%08x\n", Buffer[I830_DESTREG_SR2]); + fprintf(stderr, "DR0 : 0x%08x\n", Buffer[I830_DESTREG_DR0]); + fprintf(stderr, "DR1 : 0x%08x\n", Buffer[I830_DESTREG_DR1]); + fprintf(stderr, "DR2 : 0x%08x\n", Buffer[I830_DESTREG_DR2]); + fprintf(stderr, "DR3 : 0x%08x\n", Buffer[I830_DESTREG_DR3]); + fprintf(stderr, "DR4 : 0x%08x\n", Buffer[I830_DESTREG_DR4]); +} + +void i830DumpTextureState( i830ContextPtr imesa, int unit ) +{ + i830TextureObjectPtr t = imesa->CurrentTexObj[unit]; + + if(t) { + fprintf(stderr, "%s : unit %d\n", __FUNCTION__, unit); + fprintf(stderr, "MI0 : 0x%08x\n", t->Setup[I830_TEXREG_MI0]); + fprintf(stderr, "MI1 : 0x%08x\n", t->Setup[I830_TEXREG_MI1]); + fprintf(stderr, "MI2 : 0x%08x\n", t->Setup[I830_TEXREG_MI2]); + fprintf(stderr, "MI3 : 0x%08x\n", t->Setup[I830_TEXREG_MI3]); + fprintf(stderr, "MI4 : 0x%08x\n", t->Setup[I830_TEXREG_MI4]); + fprintf(stderr, "MI5 : 0x%08x\n", t->Setup[I830_TEXREG_MI5]); + fprintf(stderr, "MF : 0x%08x\n", t->Setup[I830_TEXREG_MF]); + fprintf(stderr, "MLC : 0x%08x\n", t->Setup[I830_TEXREG_MLC]); + fprintf(stderr, "MLL : 0x%08x\n", t->Setup[I830_TEXREG_MLL]); + fprintf(stderr, "MCS : 0x%08x\n", t->Setup[I830_TEXREG_MCS]); + } +} + +void i830DumpTextureBlendState( i830ContextPtr imesa, int unit ) +{ + GLuint *TexBlend = imesa->TexBlend[unit]; + GLuint length = imesa->TexBlendWordsUsed[unit]; + int i; + + fprintf(stderr, "%s : unit %d : length %d\n", __FUNCTION__, unit, length); + for(i = 0; i < length; i++) { + fprintf(stderr, "[%d] : 0x%08x\n", i, TexBlend[i]); + } +} + +void i830VertexSanity( i830ContextPtr imesa, drmI830Vertex vertex ) +{ + I830SAREAPtr sarea = imesa->sarea; + char *prim_name; + int size = 0; + int vfmt_size = 0; + int hw_nr_vertex = 0; + int hw_start_vertex = 0; + + /* Do a bunch of sanity checks on the vertices sent to the hardware */ + + size = vertex.used - 4; + if(imesa->vertex_size && (size % imesa->vertex_size) != 0) { + fprintf(stderr, "\n\nVertex size does not match imesa " + "internal state\n"); + fprintf(stderr, "Buffer size : %d\n", size); + fprintf(stderr, "Vertex size : %d\n", imesa->vertex_size); + } + + /* Check to see if the vertex format is good, and get its size */ + if (sarea->ContextState[I830_CTXREG_VF] == TINY_VERTEX_FORMAT) { + vfmt_size = 16; /* 4 dwords */ + } else if (sarea->ContextState[I830_CTXREG_VF] == + NOTEX_VERTEX_FORMAT) { + vfmt_size = 24; /* 6 dwords */ + } else if (sarea->ContextState[I830_CTXREG_VF] == + TEX0_VERTEX_FORMAT) { + vfmt_size = 32; /* 8 dwords */ + if (sarea->ContextState[I830_CTXREG_VF2] != NON_PROJ_VF2) { + fprintf(stderr, "\n\nTex 0 vertex format, but proj " + "texturing\n"); + } + } else if(sarea->ContextState[I830_CTXREG_VF] == + TEX1_VERTEX_FORMAT) { + if (sarea->ContextState[I830_CTXREG_VF2] == NON_PROJ_VF2) + vfmt_size = 40; /* 10 dwords */ + else + vfmt_size = 48; /* 12 dwords */ + } else { + fprintf(stderr, "\n\nUnknown vertex format : vf : %08x " + "vf2 : %08x\n", + sarea->ContextState[I830_CTXREG_VF], + sarea->ContextState[I830_CTXREG_VF2]); + } + + if(vfmt_size && (size % vfmt_size) != 0) { + fprintf(stderr, "\n\nVertex size does not match hardware " + "internal state\n"); + fprintf(stderr, "Buffer size : %d\n", size); + fprintf(stderr, "Vertex size : %d\n", vfmt_size); + sleep(10); + } + + switch(sarea->vertex_prim) { + case PRIM3D_POINTLIST: + hw_start_vertex = 0; + hw_nr_vertex = 1; + prim_name = "PointList"; + break; + + case PRIM3D_LINELIST: + hw_start_vertex = 0; + hw_nr_vertex = 2; + prim_name = "LineList"; + break; + + case PRIM3D_LINESTRIP: + hw_start_vertex = 2; + hw_nr_vertex = 1; + prim_name = "LineStrip"; + break; + + case PRIM3D_TRILIST: + hw_start_vertex = 0; + hw_nr_vertex = 3; + prim_name = "TriList"; + break; + + case PRIM3D_TRISTRIP: + hw_start_vertex = 3; + hw_nr_vertex = 1; + prim_name = "TriStrip"; + break; + + case PRIM3D_TRIFAN: + hw_start_vertex = 3; + hw_nr_vertex = 1; + prim_name = "TriFan"; + break; + + case PRIM3D_POLY: + hw_start_vertex = 3; + hw_nr_vertex = 1; + prim_name = "Polygons"; + break; + default: + prim_name = "Unknown"; + fprintf(stderr, "\n\nUnknown primitive type : %08x\n", + sarea->vertex_prim); + } + + if (hw_nr_vertex && vfmt_size) { + int temp_size = size - (hw_start_vertex * vfmt_size); + int remaining = (temp_size % (hw_nr_vertex * vfmt_size)); + + if (remaining != 0) { + fprintf(stderr, "\n\nThis buffer contains an improper" + " multiple of vertices for this primitive : %s\n", + prim_name); + fprintf(stderr, "Number of vertices in buffer : %d\n", + size / vfmt_size); + fprintf(stderr, "temp_size : %d\n", temp_size); + fprintf(stderr, "remaining vertices : %d", + remaining / vfmt_size); + sleep(10); + } + } + if (PRINT_VERTEX_INFO) { + fprintf(stderr, "\n\nPrim name (%s), vertices (%d)\n", + prim_name, + size / vfmt_size); + } +} + +void i830EmitHwStateLockedDebug( i830ContextPtr imesa ) +{ + int i; + + if ((imesa->dirty & I830_UPLOAD_TEX0_IMAGE) && imesa->CurrentTexObj[0]) { + i830UploadTexImages(imesa, imesa->CurrentTexObj[0]); + } + + if ((imesa->dirty & I830_UPLOAD_TEX1_IMAGE) && imesa->CurrentTexObj[1]) { + i830UploadTexImages(imesa, imesa->CurrentTexObj[1]); + } + + if (imesa->dirty & I830_UPLOAD_CTX) { + memcpy( imesa->sarea->ContextState, + imesa->Setup, sizeof(imesa->Setup) ); + i830DumpContextState(imesa); + } + + for(i = 0; i < I830_TEXTURE_COUNT; i++) { + if ((imesa->dirty & I830_UPLOAD_TEX_N(i)) && imesa->CurrentTexObj[i]) { + imesa->sarea->dirty |= I830_UPLOAD_TEX_N(i); + memcpy(imesa->sarea->TexState[i], + imesa->CurrentTexObj[i]->Setup, + sizeof(imesa->sarea->TexState[i])); + i830DumpTextureState(imesa, i); + } + } + /* Need to figure out if texturing state, or enable changed. */ + + for(i = 0; i < I830_TEXBLEND_COUNT; i++) { + if (imesa->dirty & I830_UPLOAD_TEXBLEND_N(i)) { + imesa->sarea->dirty |= I830_UPLOAD_TEXBLEND_N(i); + memcpy(imesa->sarea->TexBlendState[i],imesa->TexBlend[i], + imesa->TexBlendWordsUsed[i] * 4); + imesa->sarea->TexBlendStateWordsUsed[i] = + imesa->TexBlendWordsUsed[i]; + i830DumpTextureBlendState(imesa, i); + } + } + + if (imesa->dirty & I830_UPLOAD_BUFFERS) { + memcpy( imesa->sarea->BufferState,imesa->BufferSetup, + sizeof(imesa->BufferSetup) ); + i830DumpBufferState(imesa); + } + + if (imesa->dirty & I830_UPLOAD_TEX_PALETTE_SHARED) { + memcpy( imesa->sarea->Palette[0],imesa->palette, + sizeof(imesa->sarea->Palette[0])); + } else { + i830TextureObjectPtr p; + if (imesa->dirty & I830_UPLOAD_TEX_PALETTE_N(0)) { + p = imesa->CurrentTexObj[0]; + memcpy( imesa->sarea->Palette[0],p->palette, + sizeof(imesa->sarea->Palette[0])); + } + if (imesa->dirty & I830_UPLOAD_TEX_PALETTE_N(1)) { + p = imesa->CurrentTexObj[1]; + memcpy( imesa->sarea->Palette[1], + p->palette, + sizeof(imesa->sarea->Palette[1])); + } + } + imesa->sarea->dirty |= (imesa->dirty & ~(I830_UPLOAD_TEX_MASK | + I830_UPLOAD_TEXBLEND_MASK)); + + imesa->upload_cliprects = GL_TRUE; + imesa->dirty = 0; +} diff --git a/xc/lib/GL/mesa/src/drv/i830/i830_debug.h b/xc/lib/GL/mesa/src/drv/i830/i830_debug.h new file mode 100644 index 000000000..77e7ac213 --- /dev/null +++ b/xc/lib/GL/mesa/src/drv/i830/i830_debug.h @@ -0,0 +1,53 @@ +/************************************************************************** + +Copyright 2001 2d3d Inc., Delray Beach, FL + +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 +on 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 +ATI, VA LINUX SYSTEMS AND/OR THEIR 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. + +**************************************************************************/ + +/* $XFree86$ */ + +/* + * Author: + * Jeff Hartmann <jhartmann@2d3d.com> + */ + +/* Defines for sanity checking and debug output */ +#ifndef I830DEBUG_INC +#define I830DEBUG_INC + +/* Do sanity checking on vertex buffers */ +#define VERTEX_SANITY 0 +/* Print out information at each vertex buffer dispatch */ +#define PRINT_VERTEX_INFO 0 +/* Dump all emitted state */ +#define OUTPUT_EMITTED_STATE 0 + +void i830DumpContextState( i830ContextPtr imesa ); +void i830DumpBufferState( i830ContextPtr imesa ); +void i830DumpTextureState( i830ContextPtr imesa, int unit ); +void i830DumpTextureBlendState( i830ContextPtr imesa, int unit ); +void i830VertexSanity( i830ContextPtr imesa, drmI830Vertex vertex ); +void i830EmitHwStateLockedDebug( i830ContextPtr imesa ); + +#endif diff --git a/xc/lib/GL/mesa/src/drv/i830/i830_drv.h b/xc/lib/GL/mesa/src/drv/i830/i830_drv.h index 93d574570..fafd9f98c 100644 --- a/xc/lib/GL/mesa/src/drv/i830/i830_drv.h +++ b/xc/lib/GL/mesa/src/drv/i830/i830_drv.h @@ -25,43 +25,37 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. **************************************************************************/ -/* $XFree86: xc/lib/GL/mesa/src/drv/i830/i830_drv.h,v 1.1 2001/10/04 18:28:21 alanh Exp $ */ +/* $XFree86$ */ /* * Author: - * Jeff Hartmann <jhartmann@valinux.com> + * Jeff Hartmann <jhartmann@2d3d.com> * * Heavily based on the I810 driver, which was written by: - * Keith Whitwell <keithw@valinux.com> + * Keith Whitwell <keith@tungstengraphics.com> */ #ifndef __I830_MESA_DRV_H__ #define __I830_MESA_DRV_H__ -#include <X11/Xlibint.h> +#define DEBUGGING 0 -#include "dri_tmm.h" -#include "dri_mesaint.h" -#include "dri_mesa.h" +#define TRACE_IN {\ + if (DEBUGGING) \ + fprintf(stderr,"\nWe are IN function %s on line %d\n",__FUNCTION__,__LINE__);\ +} +#define TRACE_OUT {\ + if (DEBUGGING) \ + fprintf(stderr,"\nWe are OUT OF function %s on line %d\n",__FUNCTION__,__LINE__);\ +} -#include "types.h" -#include "mm.h" -#include "context.h" -#include "mmath.h" -#include "vb.h" - -#include <sys/time.h> - -#include "xf86drm.h" -#include "xf86drmI830.h" -#include "i830_dri.h" + -#include "i830_3d_reg.h" /* To remove all debugging, make sure I830_DEBUG is defined as a * preprocessor symbol, and equal to zero. */ -#define I830_DEBUG 0 +#define I830_DEBUG 0/*DEBUG_VERBOSE_2D|DEBUG_VERBOSE_STATE|DEBUG_VERBOSE_TRACE|DEBUG_VERBOSE_IOCTL|DEBUG_VERBOSE_DRI|DEBUG_VERBOSE_LRU|DEBUG_VALIDATE_RING|DEBUG_VERBOSE_API|DEBUG_VERBOSE_MSG*/ #ifndef I830_DEBUG #warning "Debugging enabled - expect reduced performance" extern int I830_DEBUG; @@ -89,6 +83,7 @@ extern int I830_DEBUG; /* Reasons to fallback on all primitives. (see also * imesa->IndirectTriangles). */ +/* #define I830_FALLBACK_TEXTURE 0x1 #define I830_FALLBACK_DRAW_BUFFER 0x2 #define I830_FALLBACK_READ_BUFFER 0x4 @@ -96,7 +91,7 @@ extern int I830_DEBUG; #define I830_FALLBACK_SPECULAR 0x10 #define I830_FALLBACK_STENCIL 0x20 #define I830_FALLBACK_COLORMASK 0x40 - +*/ /* for i830ctx.new_state - manage GL->driver state changes */ @@ -110,80 +105,14 @@ extern int I830_DEBUG; #define I830_UPDATE_PALETTE 0x2 #define I830_FALLBACK_PALETTE 0x4 -#define I830_SPEC_BIT 0x1 -#define I830_FOG_BIT 0x2 +/*#define I830_SPEC_BIT 0x1 +#define I830_FOG_BIT 0x2*/ #define I830_ALPHA_BIT 0x4 /* GL_BLEND, not used */ -#define I830_TEX0_BIT 0x8 -#define I830_TEX1_BIT 0x10 -#define I830_RGBA_BIT 0x20 +/*#define I830_TEX0_BIT 0x8 +#define I830_TEX1_BIT 0x10*/ +/*#define I830_RGBA_BIT 0x20*/ #define I830_WIN_BIT 0x40 -/* All structures go here */ -typedef struct { - GLubyte blue; - GLubyte green; - GLubyte red; - GLubyte alpha; -} i830_color; - -/* A basic fixed format vertex to kick things off. Move to dynamic - * layouts later on. (see also the i830_full_vertex struct in - * i830_3d_reg.h) - */ -typedef struct { - float x; - float y; - float z; - float oow; - /* float point_width; */ - i830_color color; - i830_color specular; - - float tu0; - float tv0; - /* q only if TEXCOORDTYPE_HOMOGENEOUS (projective) or _VECTOR (cube map)*/ - /* when q is desired, need to change VRTX_TEX_SET_0_FMT(TEXCOORDFMT_2D) - to VRTX_TEX_SET_0_FMT(TEXCOORDFMT_3D); same for other texcoords */ - /* float tq0; */ - - float tu1; - float tv1; - /* float tq1; */ - -#if defined(I830_ENABLE_4_TEXTURES) /* see i830_3d_reg.h */ - float tu2; - float tv2; - /* float tq2; */ - - float tu3; - float tv3; - /* float tq3; */ -#endif /* I830_ENABLE_4_TEXTURES */ -} i830_vertex; - -/* Unfortunately only have assembly for 16-stride vertices. - */ -union i830_vertex_t { - i830_vertex v; - float f[16]; - GLuint ui[16]; -}; - -typedef union i830_vertex_t i830Vertex; -typedef union i830_vertex_t *i830VertexPtr; - -struct i830_vertex_buffer_t { - GLvector1ui clipped_elements; - i830VertexPtr verts; - int last_vert; - GLuint *primitive; - GLuint *next_primitive; - void *vert_store; - GLuint size; -}; - -typedef struct i830_vertex_buffer_t *i830VertexBufferPtr; - /* For shared texture space managment, these texture objects may also * be used as proxies for regions of texture memory containing other @@ -200,85 +129,6 @@ typedef struct i830_vertex_buffer_t *i830VertexBufferPtr; #define TEX_0 1 #define TEX_1 2 -struct i830_texture_object_t { - struct i830_texture_object_t *next, *prev; - - GLuint age; - struct gl_texture_object *globj; - - int Pitch; - int Height; - int texelBytes; - int totalSize; - int bound; - - PMemBlock MemBlock; - char *BufAddr; - - GLuint min_level; - GLuint max_level; - GLuint dirty_images; - - GLenum palette_format; - GLuint palette[256]; - - struct { - const struct gl_texture_image *image; - int offset; /* into BufAddr */ - int height; - int internalFormat; - } image[I830_TEX_MAXLEVELS]; - - /* Support for multitexture. - */ - GLuint current_unit; - GLuint Setup[I830_TEX_SETUP_SIZE]; -}; - -typedef struct { - drmHandle handle; - drmSize size; - char *map; -} i830Region, *i830RegionPtr; - -typedef struct { - i830Region front; - i830Region back; - i830Region depth; - i830Region tex; - - int deviceID; - int width; - int height; - int mem; - - int cpp; /* for front and back buffers */ - int bitsPerPixel; - - int fbFormat; - int fbOffset; - int fbStride; - - int backOffset; - int depthOffset; - - int backPitch; - int backPitchBits; - - int textureOffset; - int textureSize; - int logTextureGranularity; - - __DRIscreenPrivate *driScrnPriv; - drmBufMapPtr bufs; - int use_copy_buf; - unsigned int sarea_priv_offset; -} i830ScreenPrivate; - -typedef struct i830_context_t i830Context; -typedef struct i830_context_t *i830ContextPtr; -typedef struct i830_texture_object_t *i830TextureObjectPtr; - typedef void (*i830_interp_func)( GLfloat t, GLfloat *result, const GLfloat *in, @@ -286,182 +136,8 @@ typedef void (*i830_interp_func)( GLfloat t, -struct i830_context_t { - GLint refcount; - - GLcontext *glCtx; - - i830TextureObjectPtr CurrentTexObj[2]; - - struct i830_texture_object_t TexObjList; - struct i830_texture_object_t SwappedOut; - - int TextureMode; - - /* Hardware state - */ - GLuint Setup[I830_CTX_SETUP_SIZE]; - GLuint BufferSetup[I830_DEST_SETUP_SIZE]; - GLuint TexBlend[I830_TEXBLEND_COUNT][I830_TEXBLEND_SIZE]; - GLuint TexBlendWordsUsed[I830_TEXBLEND_COUNT]; - GLuint TexBlendColorPipeNum[I830_TEXBLEND_COUNT]; - GLuint LastTexEnabled; - GLuint TexEnabledMask; - int vertsize; - - /* Initial GL state, stored here so we can easily access it to draw - * quads to do clears. - */ - GLuint Init_Setup[I830_CTX_SETUP_SIZE]; - GLuint Init_BufferSetup[I830_DEST_SETUP_SIZE]; - GLuint Init_TexBlend[I830_TEXBLEND_COUNT][I830_TEXBLEND_SIZE]; - GLuint Init_TexBlendWordsUsed[I830_TEXBLEND_COUNT]; - GLuint Init_TexBlendColorPipeNum[I830_TEXBLEND_COUNT]; - - /* Support for CVA and the fast paths. - */ - GLuint setupdone; - GLuint setupindex; - GLuint renderindex; - GLuint using_fast_path; - i830_interp_func interp; - - /* Shortcircuit some state changes. - */ - points_func PointsFunc; - line_func LineFunc; - triangle_func TriangleFunc; - quad_func QuadFunc; - - /* Manage our own state */ - GLuint new_state; - - /* Manage hardware state */ - GLuint dirty; - memHeap_t *texHeap; - - /* One of the few bits of hardware state that can't be calculated - * completely on the fly: - */ - GLuint LcsCullMode; - - /* Funny mesa mirrors - */ - GLuint MonoColor; - GLuint ClearColor; - - /* DRI stuff - */ - drmBufPtr vertex_dma_buffer; - GLuint vertex_prim; - - GLframebuffer *glBuffer; - - /* Two flags to keep track of fallbacks. - */ - GLuint IndirectTriangles; - GLuint Fallback; - - - GLuint needClip; - - /* These refer to the current draw (front vs. back) buffer: - */ - char *drawMap; /* draw buffer address in virtual mem */ - char *readMap; - int drawX; /* origin of drawable in draw buffer */ - int drawY; - GLuint numClipRects; /* cliprects for that buffer */ - XF86DRIClipRectPtr pClipRects; - - int lastSwap; - int secondLastSwap; - int texAge; - int ctxAge; - int dirtyAge; - int any_contend; /* throttle me harder */ - - XF86DRIClipRectRec draw_rect; - - drmContext hHWContext; - drmLock *driHwLock; - int driFd; - Display *display; - - int hw_stencil; - - GLfloat depth_scale; - int depth_clear_mask; - int stencil_clear_mask; - int ClearDepth; - - GLboolean mask_red; - GLboolean mask_green; - GLboolean mask_blue; - GLboolean mask_alpha; - - GLubyte clear_red; - GLubyte clear_green; - GLubyte clear_blue; - GLubyte clear_alpha; - - GLenum palette_format; - GLuint palette[256]; - - __DRIdrawablePrivate *driDrawable; - __DRIscreenPrivate *driScreen; - i830ScreenPrivate *i830Screen; - I830SAREAPtr sarea; -}; - -extern void i830GetLock(i830ContextPtr imesa, GLuint flags); -extern void i830EmitHwStateLocked(i830ContextPtr imesa); -extern void i830EmitScissorValues(i830ContextPtr imesa, int box_nr, - int emit); -extern void i830EmitDrawingRectangle(i830ContextPtr imesa); -extern void i830XMesaSetBackClipRects(i830ContextPtr imesa); -extern void i830XMesaSetFrontClipRects(i830ContextPtr imesa); -extern void i830DestroyTexObj(i830ContextPtr imesa, - i830TextureObjectPtr t); -extern int i830UploadTexImages(i830ContextPtr imesa, - i830TextureObjectPtr t); -extern void i830ResetGlobalLRU(i830ContextPtr imesa); -extern void i830TexturesGone(i830ContextPtr imesa, - GLuint start, GLuint end, GLuint in_use); -extern void i830PrintLocalLRU(i830ContextPtr imesa); -extern void i830PrintGlobalLRU(i830ContextPtr imesa); -extern void i830ChooseRasterSetupFunc(GLcontext *ctx); -extern void i830PrintSetupFlags(char *msg, GLuint flags); -extern void i830UpdateTextureState(GLcontext *ctx); - - - -extern void i830DDFastPath(struct vertex_buffer *VB); -extern void i830DDFastPathInit(void); -extern void i830DDExtensionsInit(GLcontext *ctx); -extern void i830DDInitDriverFuncs(GLcontext *ctx); -extern void i830DDInitSpanFuncs(GLcontext *ctx); -extern void i830DDUpdateHwState(GLcontext *ctx); -extern void i830DDUpdateState(GLcontext *ctx); -extern void i830DDInitState(i830ContextPtr imesa); -extern void i830DDInitStateFuncs(GLcontext *ctx); -extern void i830DDInitTextureFuncs(GLcontext *ctx); -extern void i830DDDoRasterSetup(struct vertex_buffer *VB); -extern void i830DDPartialRasterSetup(struct vertex_buffer *VB); -extern void i830DDCheckPartialRasterSetup(GLcontext *ctx, - struct gl_pipeline_stage *d); -extern void i830DDViewport(GLcontext *ctx, GLint x, GLint y, - GLsizei width, GLsizei height); -extern void i830DDDepthRange(GLcontext *ctx, GLclampd nearval, - GLclampd farval); -extern void i830DDUnregisterVB(struct vertex_buffer *VB); -extern void i830DDRegisterVB(struct vertex_buffer *VB); -extern void i830DDResizeVB(struct vertex_buffer *VB, GLuint size); -extern void i830DDSetupInit(void); -extern GLboolean i830DDBuildPrecalcPipeline(GLcontext *ctx); -extern GLuint i830DDRegisterPipelineStages(struct gl_pipeline_stage *out, - const struct gl_pipeline_stage *in, - GLuint nr); + + #define I830_TEX_UNIT_ENABLED(unit) (1<<unit) #define VALID_I830_TEXTURE_OBJECT(tobj) (tobj) @@ -471,33 +147,4 @@ extern GLuint i830DDRegisterPipelineStages(struct gl_pipeline_stage *out, #define GET_DISPATCH_AGE(imesa) imesa->sarea->last_dispatch #define GET_ENQUEUE_AGE(imesa) imesa->sarea->last_enqueue -/* Lock the hardware and validate our state. - */ -#define LOCK_HARDWARE( imesa ) \ - do { \ - char __ret=0; \ - DRM_CAS(imesa->driHwLock, imesa->hHWContext, \ - (DRM_LOCK_HELD|imesa->hHWContext), __ret); \ - if (__ret) \ - i830GetLock( imesa, 0 ); \ - } while (0) - - - -/* Unlock the hardware using the global current context - */ -#define UNLOCK_HARDWARE(imesa) \ - DRM_UNLOCK(imesa->driFd, imesa->driHwLock, imesa->hHWContext); - - -/* This is the wrong way to do it, I'm sure. Otherwise the drm - * bitches that I've already got the heavyweight lock. At worst, - * this is 3 ioctls. The best solution probably only gets me down - * to 2 ioctls in the worst case. - */ -#define LOCK_HARDWARE_QUIESCENT( imesa ) do { \ - LOCK_HARDWARE( imesa ); \ - i830RegetLockQuiescent( imesa ); \ -} while(0) - #endif /* __I830_MESA_DRV_H__ */ diff --git a/xc/lib/GL/mesa/src/drv/i830/i830_fastpath.c b/xc/lib/GL/mesa/src/drv/i830/i830_fastpath.c deleted file mode 100644 index 462ad006f..000000000 --- a/xc/lib/GL/mesa/src/drv/i830/i830_fastpath.c +++ /dev/null @@ -1,535 +0,0 @@ -/************************************************************************** - -Copyright 2001 VA Linux Systems Inc., Fremont, California. - -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 -on 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 -ATI, VA LINUX SYSTEMS AND/OR THEIR 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. - -**************************************************************************/ - -/* $XFree86: xc/lib/GL/mesa/src/drv/i830/i830_fastpath.c,v 1.1 2001/10/04 18:28:21 alanh Exp $ */ - -/* - * Author: - * Jeff Hartmann <jhartmann@valinux.com> - * - * Heavily based on the I810 driver, which was written by: - * Keith Whitwell <keithw@valinux.com> - */ - -#include <stdio.h> - -#include "types.h" -#include "enums.h" -#include "cva.h" -#include "vertices.h" - -/* #include "mmath.h" */ - -#include "i830_drv.h" -#include "i830_tris.h" - - -extern void gl_fast_copy_vb( struct vertex_buffer *VB ); - -struct i830_fast_tab { - void (*build_vertices)( struct vertex_buffer *VB, GLuint do_cliptest ); - void (*interp)( GLfloat t, GLfloat *O, const GLfloat *I, const GLfloat *J ); -}; - - - - -#define POINT(x) i830_draw_point(imesa, &ivert[x], psize) -#define LINE(x,y) i830_draw_line(imesa, &ivert[x], &ivert[y] ) -#define TRI(x,y,z) i830_draw_triangle(imesa, &ivert[x], &ivert[y], &ivert[z]) - - - - -/* Direct, and no clipping required. I haven't written the clip funcs - * yet, so this is only useful for the fast path. - */ -#define RENDER_POINTS( start, count ) \ -do { \ - GLuint e; \ - for(e=start;e<count;e++) \ - POINT(elt[e]); \ -} while (0) - -#define RENDER_LINE( i1, i ) \ -do { \ - GLuint e1 = elt[i1], e = elt[i]; \ - LINE( e1, e ); \ -} while (0) - - -#define RENDER_TRI( i2, i1, i, pv, parity) \ -do { \ -{ GLuint e2 = elt[i2], e1 = elt[i1], e = elt[i]; \ - if (parity) {GLuint tmp = e2; e2 = e1; e1 = tmp;} \ - TRI(e2, e1, e); \ -}} while (0) - - -#define RENDER_QUAD( i3, i2, i1, i, pv) \ -do { \ - GLuint e3 = elt[i3], e2 = elt[i2], e1 = elt[i1], e = elt[i]; \ - TRI(e3, e2, e); \ - TRI(e2, e1, e); \ -} while (0) - -#define LOCAL_VARS \ - i830VertexPtr ivert = I830_DRIVER_DATA(VB)->verts; \ - const GLuint *elt = VB->EltPtr->data; \ - GLcontext *ctx = VB->ctx; \ - i830ContextPtr imesa = I830_CONTEXT(ctx); \ - const GLfloat psize = ctx->Point.Size; \ - (void)psize; (void) ivert; - - -#define TAG(x) x##_i830_smooth_indirect -#include "render_tmp.h" - - - -static void i830_render_elements_direct( struct vertex_buffer *VB ) -{ - GLcontext *ctx = VB->ctx; - i830ContextPtr imesa = I830_CONTEXT( ctx ); - GLenum prim = ctx->CVA.elt_mode; - GLuint nr = VB->EltPtr->count; - render_func func = render_tab_i830_smooth_indirect[prim]; - GLuint p = 0; - - if (imesa->new_state) - i830DDUpdateHwState( ctx ); - - do { - func( VB, 0, nr, 0 ); - } while (ctx->Driver.MultipassFunc && - ctx->Driver.MultipassFunc( VB, ++p )); -} - - - -#define NEGATIVE(f) (f < 0) -#define DIFFERENT_SIGNS(a,b) ((a*b) < 0) -#define LINTERP( T, A, B ) ( (A) + (T) * ( (B) - (A) ) ) - - -#define INTERP_RGBA(t, out, a, b) { \ - int i; \ - for (i = 0; i < 4; i++) { \ - GLfloat fa = UBYTE_COLOR_TO_FLOAT_COLOR(a[i]); \ - GLfloat fb = UBYTE_COLOR_TO_FLOAT_COLOR(b[i]); \ - GLfloat fo = LINTERP(t, fa, fb); \ - FLOAT_COLOR_TO_UBYTE_COLOR(out[i], fo); \ - } \ -} - - -#define CLIP(SGN,V,PLANE) \ -if (mask & PLANE) { \ - GLuint *indata = inlist[in]; \ - GLuint *outdata = inlist[in ^= 1]; \ - GLuint nr = n; \ - GLfloat *J = verts[indata[nr-1]].f; \ - GLfloat dpJ = (SGN J[V]) + J[3]; \ - \ - inlist[0] = vlist1; \ - for (i = n = 0 ; i < nr ; i++) { \ - GLuint elt_i = indata[i]; \ - GLfloat *I = verts[elt_i].f; \ - GLfloat dpI = (SGN I[V]) + I[3]; \ - \ - if (DIFFERENT_SIGNS(dpI, dpJ)) { \ - \ - GLfloat *O = verts[next_vert].f; \ - GLfloat t, *in, *out; \ - \ - if (NEGATIVE(dpI)) { \ - t = dpI / (dpI - dpJ); \ - in = I; \ - out = J; \ - } \ - else \ - { \ - t = dpJ / (dpJ - dpI); \ - in = J; \ - out = I; \ - } \ - \ - interp(t, O, in, out); \ - \ - clipmask[next_vert] = 0; \ - outdata[n++] = next_vert++; \ - } \ - \ - clipmask[elt_i] |= PLANE; /* don't set up */ \ - \ - if (!NEGATIVE(dpI)) { \ - outdata[n++] = elt_i; \ - clipmask[elt_i] &= ~PLANE; /* set up after all */ \ - } \ - \ - J = I; \ - dpJ = dpI; \ - } \ - \ - if (n < 3) return; \ -} - -#define LINE_CLIP(x,y,z,w,PLANE) \ -if (mask & PLANE) { \ - GLfloat dpI = DOT4V(I,x,y,z,w); \ - GLfloat dpJ = DOT4V(J,x,y,z,w); \ - \ - if (DIFFERENT_SIGNS(dpI, dpJ)) { \ - GLfloat *O = verts[next_vert].f; \ - GLfloat t = dpI / (dpI - dpJ); \ - \ - interp(t, O, I, J); \ - \ - clipmask[next_vert] = 0; \ - \ - if (NEGATIVE(dpI)) { \ - clipmask[elts[0]] |= PLANE; \ - I = O; elts[0] = next_vert++; \ - } else { \ - clipmask[elts[1]] |= PLANE; \ - J = O; elts[1] = next_vert++; \ - } \ - } \ - else if (NEGATIVE(dpI)) \ - return; \ -} - - -static __inline void i830_tri_clip( GLuint **p_elts, - i830Vertex *verts, - GLubyte *clipmask, - GLuint *p_next_vert, - GLubyte mask, - i830_interp_func interp ) -{ - GLuint *elts = *p_elts; - GLuint next_vert = *p_next_vert; - GLuint vlist1[VB_MAX_CLIPPED_VERTS]; - GLuint vlist2[VB_MAX_CLIPPED_VERTS]; - GLuint *inlist[2]; - GLuint *out; - GLuint in = 0; - GLuint n = 3; - GLuint i; - - inlist[0] = elts; - inlist[1] = vlist2; - - CLIP(-,0,CLIP_RIGHT_BIT); - CLIP(+,0,CLIP_LEFT_BIT); - CLIP(-,1,CLIP_TOP_BIT); - CLIP(+,1,CLIP_BOTTOM_BIT); - CLIP(-,2,CLIP_FAR_BIT); - CLIP(+,2,CLIP_NEAR_BIT); - - /* Convert the planar polygon to a list of triangles. - */ - out = inlist[in]; - - for (i = 2 ; i < n ; i++) { - elts[0] = out[0]; - elts[1] = out[i-1]; - elts[2] = out[i]; - elts += 3; - } - - *p_next_vert = next_vert; - *p_elts = elts; -} - - -static __inline void i830_line_clip( GLuint **p_elts, - i830Vertex *verts, - GLubyte *clipmask, - GLuint *p_next_vert, - GLubyte mask, - i830_interp_func interp ) -{ - GLuint *elts = *p_elts; - GLfloat *I = verts[elts[0]].f; - GLfloat *J = verts[elts[1]].f; - GLuint next_vert = *p_next_vert; - - LINE_CLIP(1,0,0,-1,CLIP_LEFT_BIT); - LINE_CLIP(-1,0,0,1,CLIP_RIGHT_BIT); - LINE_CLIP(0,1,0,-1,CLIP_TOP_BIT); - LINE_CLIP(0,-1,0,1,CLIP_BOTTOM_BIT); - LINE_CLIP(0,0,1,-1,CLIP_FAR_BIT); - LINE_CLIP(0,0,-1,1,CLIP_NEAR_BIT); - - *p_next_vert = next_vert; - *p_elts += 2; -} - - - -#define CLIP_POINT( e ) \ - if (mask[e]) \ - *out++ = e - -#define CLIP_LINE( e1, e0 ) \ -do { \ - GLubyte ormask = mask[e0] | mask[e1]; \ - out[0] = e1; \ - out[1] = e0; \ - out+=2; \ - if (ormask) { \ - out-=2; \ - if (!(mask[e0] & mask[e1])) { \ - i830_line_clip( &out, verts, mask, &next_vert, ormask, interp); \ - } \ - } \ -} while (0) - -#define CLIP_TRIANGLE( e2, e1, e0 ) \ -do { \ - GLubyte ormask; \ - out[0] = e2; \ - out[1] = e1; \ - out[2] = e0; \ - out += 3; \ - ormask = mask[e2] | mask[e1] | mask[e0]; \ - if (ormask) { \ - out -= 3; \ - if ( !(mask[e2] & mask[e1] & mask[e0])) { \ - i830_tri_clip( &out, verts, mask, &next_vert, ormask, interp ); \ - } \ - } \ -} while (0) - - - - - - -/* Build a table of functions to clip each primitive type. These - * produce a list of elements in the appropriate 'reduced' primitive, - * ie (points, lines, triangles) containing all the clipped and - * unclipped primitives from the original list. - */ -#define LOCAL_VARS \ - i830ContextPtr imesa = I830_CONTEXT( VB->ctx ); \ - GLuint *elt = VB->EltPtr->data; \ - i830Vertex *verts = I830_DRIVER_DATA(VB)->verts; \ - GLuint next_vert = I830_DRIVER_DATA(VB)->last_vert; \ - GLuint *out = I830_DRIVER_DATA(VB)->clipped_elements.data; \ - GLubyte *mask = VB->ClipMask; \ - i830_interp_func interp = imesa->interp; \ - (void) interp; (void) verts; - -#define POSTFIX \ - I830_DRIVER_DATA(VB)->clipped_elements.count = \ - out - I830_DRIVER_DATA(VB)->clipped_elements.data; \ - I830_DRIVER_DATA(VB)->last_vert = next_vert; - - -#define INIT(x) - -#define RENDER_POINTS(start, count) \ -do { \ - GLuint i; \ - for (i = start ; i < count ; i++ ) \ - CLIP_POINT( elt[i] ); \ -} while (0) - -#define RENDER_LINE(i1, i0) \ - CLIP_LINE(elt[i1], elt[i0]) - -#define RENDER_TRI(i2, i1, i0, pv, parity) \ -do { \ - GLuint e2 = elt[i2], e1 = elt[i1], e0 = elt[i0]; \ - if (parity) e2 = elt[i1], e1 = elt[i2]; \ - CLIP_TRIANGLE( e2, e1, e0 ); \ -} while (0) - -#define RENDER_QUAD(i3, i2, i1, i0, pv ) \ - CLIP_TRIANGLE(elt[i3], elt[i2], elt[i0]); \ - CLIP_TRIANGLE(elt[i2], elt[i1], elt[i0]) - -#define TAG(x) i830_clip_##x##_elt -#include "render_tmp.h" - - - -static void i830_project_vertices( struct vertex_buffer *VB ) -{ - i830VertexBufferPtr i830VB = I830_DRIVER_DATA(VB); - GLcontext *ctx = VB->ctx; - i830ContextPtr imesa = I830_CONTEXT(ctx); - GLmatrix *mat = &ctx->Viewport.WindowMap; - GLfloat m[16]; - - m[MAT_SX] = mat->m[MAT_SX]; - m[MAT_TX] = mat->m[MAT_TX] - .5; - m[MAT_SY] = (- mat->m[MAT_SY]); - m[MAT_TY] = (- mat->m[MAT_TY]) + I830_CONTEXT(ctx)->driDrawable->h - .5; - m[MAT_SZ] = mat->m[MAT_SZ] * imesa->depth_scale; - m[MAT_TZ] = mat->m[MAT_TZ] * imesa->depth_scale; - - gl_project_v16( i830VB->verts[VB->CopyStart].f, - i830VB->verts[i830VB->last_vert].f, - m, - 16 * 4 ); -} - -static void i830_project_clipped_vertices( struct vertex_buffer *VB ) -{ - i830VertexBufferPtr i830VB = I830_DRIVER_DATA(VB); - GLcontext *ctx = VB->ctx; - i830ContextPtr imesa = I830_CONTEXT(ctx); - GLmatrix *mat = &ctx->Viewport.WindowMap; - GLfloat m[16]; - - m[MAT_SX] = mat->m[MAT_SX]; - m[MAT_TX] = mat->m[MAT_TX] - .5; - m[MAT_SY] = (- mat->m[MAT_SY]); - m[MAT_TY] = (- mat->m[MAT_TY]) + I830_CONTEXT(ctx)->driDrawable->h - .5; - m[MAT_SZ] = mat->m[MAT_SZ] * imesa->depth_scale; - m[MAT_TZ] = mat->m[MAT_TZ] * imesa->depth_scale; - - gl_project_clipped_v16( i830VB->verts[VB->CopyStart].f, - i830VB->verts[i830VB->last_vert].f, - m, - 16 * 4, - VB->ClipMask + VB->CopyStart ); -} - - -/* Pack rgba and/or texture into the remaining half of a 32 byte vertex. - */ -#define CLIP_UBYTE_COLOR 4 -#define CLIP_UBYTE_B 0 -#define CLIP_UBYTE_G 1 -#define CLIP_UBYTE_R 2 -#define CLIP_UBYTE_A 3 -#define CLIP_S0 6 -#define CLIP_T0 7 -#define CLIP_S1 8 -#define CLIP_T1 9 - -#define TYPE (0) -#define TAG(x) x -#include "i830_fasttmp.h" - -#define TYPE (I830_RGBA_BIT) -#define TAG(x) x##_RGBA -#include "i830_fasttmp.h" - -#define TYPE (I830_TEX0_BIT) -#define TAG(x) x##_TEX0 -#include "i830_fasttmp.h" - -#define TYPE (I830_RGBA_BIT|I830_TEX0_BIT) -#define TAG(x) x##_RGBA_TEX0 -#include "i830_fasttmp.h" - -#define TYPE (I830_RGBA_BIT|I830_TEX0_BIT|I830_TEX1_BIT) -#define TAG(x) x##_RGBA_TEX0_TEX1 -#include "i830_fasttmp.h" - -/* This one *could* get away with sneaking TEX1 into the color and - * specular slots, thus fitting inside a cache line. Would be even - * better to switch to a smaller vertex. - */ -#define TYPE (I830_TEX0_BIT|I830_TEX1_BIT) -#define TAG(x) x##_TEX0_TEX1 -#include "i830_fasttmp.h" - - -/* Very sparsely popluated array - fix the indices. - */ -static struct i830_fast_tab i830FastTab[0x80]; - -void i830DDFastPathInit( void ) -{ - i830_clip_render_init_elt(); - render_init_i830_smooth_indirect(); - - i830_init_fastpath( &i830FastTab[0] ); - i830_init_fastpath_RGBA( &i830FastTab[I830_RGBA_BIT] ); - i830_init_fastpath_TEX0( &i830FastTab[I830_TEX0_BIT] ); - i830_init_fastpath_RGBA_TEX0( &i830FastTab[I830_RGBA_BIT|I830_TEX0_BIT] ); - i830_init_fastpath_TEX0_TEX1( &i830FastTab[I830_TEX0_BIT|I830_TEX1_BIT] ); - i830_init_fastpath_RGBA_TEX0_TEX1( &i830FastTab[I830_RGBA_BIT|I830_TEX0_BIT| - I830_TEX1_BIT] ); -} - -#define VALID_SETUP (I830_RGBA_BIT|I830_TEX0_BIT|I830_TEX1_BIT) - - -void i830DDFastPath( struct vertex_buffer *VB ) -{ - GLcontext *ctx = VB->ctx; - GLenum prim = ctx->CVA.elt_mode; - i830ContextPtr imesa = I830_CONTEXT( ctx ); - struct i830_fast_tab *tab = &i830FastTab[imesa->setupindex & VALID_SETUP]; - GLuint do_cliptest = 1; - - gl_prepare_arrays_cva( VB ); /* still need this */ - - /* Reserve enough space for the pathological case. - */ - if (VB->EltPtr->count * 12 > I830_DRIVER_DATA(VB)->size) { - i830DDResizeVB( VB, VB->EltPtr->count * 12 ); - do_cliptest = 1; - } - - tab->build_vertices( VB, do_cliptest ); /* object->clip space */ - - if (imesa->new_state) - i830DDUpdateHwState( ctx ); - - if (VB->ClipOrMask) { - if (!VB->ClipAndMask) { - render_func *clip = i830_clip_render_tab_elt; - - imesa->interp = tab->interp; - - clip[prim]( VB, 0, VB->EltPtr->count, 0 ); /* build new elts */ - - ctx->CVA.elt_mode = gl_reduce_prim[prim]; - VB->EltPtr = &(I830_DRIVER_DATA(VB)->clipped_elements); - - i830_project_clipped_vertices( VB ); /* clip->device space */ - i830_render_elements_direct( VB ); /* render using new list */ - } - } else { - i830_project_vertices( VB ); /* clip->device space */ - i830_render_elements_direct( VB ); /* render using orig list */ - } - - /* This indicates that there is no cached data to reuse. - */ - VB->pipeline->data_valid = 0; - VB->pipeline->new_state = 0; -} - diff --git a/xc/lib/GL/mesa/src/drv/i830/i830_fasttmp.h b/xc/lib/GL/mesa/src/drv/i830/i830_fasttmp.h deleted file mode 100644 index 78ea7698f..000000000 --- a/xc/lib/GL/mesa/src/drv/i830/i830_fasttmp.h +++ /dev/null @@ -1,156 +0,0 @@ -/************************************************************************** - -Copyright 2001 VA Linux Systems Inc., Fremont, California. - -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 -on 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 -ATI, VA LINUX SYSTEMS AND/OR THEIR 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. - -**************************************************************************/ - -/* $XFree86: xc/lib/GL/mesa/src/drv/i830/i830_fasttmp.h,v 1.1 2001/10/04 18:28:21 alanh Exp $ */ - -/* - * Author: - * Jeff Hartmann <jhartmann@valinux.com> - * - * Heavily based on the I810 driver, which was written by: - * Keith Whitwell <keithw@valinux.com> - */ - - - -/* The first part of setup is applied to all vertices, clipped or - * unclipped. This data w!ill be used for clipping, and then all - * vertices with a zero clipmask will be projected to device space. - * - * This could be split into several loops, but - it seems that the - * large stride of the fxVertices makes cache issues the big - * performance factor, and that multiple loops mean multiple cache - * misses.... - */ -static void TAG(i830_setup_full)( struct vertex_buffer *VB, GLuint do_cliptest ) -{ - GLcontext *ctx = VB->ctx; - const GLfloat * const m = ctx->ModelProjectMatrix.m; - GLuint start = VB->CopyStart; - GLuint count = VB->Count; - GLuint i; - - gl_xform_points3_v16_general(I830_DRIVER_DATA(VB)->verts[start].f, - m, - VB->ObjPtr->start, - VB->ObjPtr->stride, - count - start); - - if (do_cliptest) - { - VB->ClipAndMask = ~0; - VB->ClipOrMask = 0; - gl_cliptest_points4_v16(I830_DRIVER_DATA(VB)->verts[start].f, - I830_DRIVER_DATA(VB)->verts[count].f, - &(VB->ClipOrMask), - &(VB->ClipAndMask), - VB->ClipMask + start); - } - - /* These branches are all resolved at compile time. Hopefully all - * the pointers are valid addresses even when not enabled. - */ - if (TYPE) { - GLubyte *color = VB->ColorPtr->start; - GLfloat *tex0_data = VB->TexCoordPtr[0]->start; - GLfloat *tex1_data = VB->TexCoordPtr[1]->start; - - GLuint color_stride = VB->ColorPtr->stride; - GLuint tex0_stride = VB->TexCoordPtr[0]->stride; - GLuint tex1_stride = VB->TexCoordPtr[1]->stride; - - GLfloat *f = I830_DRIVER_DATA(VB)->verts[start].f; - - for (i = start ; i < count ; i++, f += 16) { - if (TYPE & I830_RGBA_BIT) { - GLubyte *b = (GLubyte *)&f[CLIP_UBYTE_COLOR]; - GLubyte *col = color; color += color_stride; - b[CLIP_UBYTE_R] = col[0]; - b[CLIP_UBYTE_G] = col[1]; - b[CLIP_UBYTE_B] = col[2]; - b[CLIP_UBYTE_A] = col[3]; - } - if (TYPE & I830_TEX0_BIT) { - f[CLIP_S0] = tex0_data[0]; - f[CLIP_T0] = tex0_data[1]; - STRIDE_F(tex0_data, tex0_stride); - } - if (TYPE & I830_TEX1_BIT) { - f[CLIP_S1] = tex1_data[0]; - f[CLIP_T1] = tex1_data[1]; - STRIDE_F(tex1_data, tex1_stride); - } - } - } - - I830_DRIVER_DATA(VB)->clipped_elements.count = start; - I830_DRIVER_DATA(VB)->last_vert = count; -} - - -/* Changed to just put the interp func instead of the whole clip - * routine into the header. Less code and better chance of doing some - * of this stuff in assembly. - */ -static void TAG(i830_interp_vert)( GLfloat t, - GLfloat *O, - const GLfloat *I, - const GLfloat *J ) -{ - O[0] = LINTERP(t, I[0], J[0]); - O[1] = LINTERP(t, I[1], J[1]); - O[2] = LINTERP(t, I[2], J[2]); - O[3] = LINTERP(t, I[3], J[3]); - - if (TYPE & I830_RGBA_BIT) { - INTERP_RGBA(t, - ((GLubyte *)&(O[4])), - ((GLubyte *)&(I[4])), - ((GLubyte *)&(J[4]))); - } - - if (TYPE & I830_TEX0_BIT) { - O[6] = LINTERP(t, I[6], J[6]); - O[7] = LINTERP(t, I[7], J[7]); - } - - if (TYPE & I830_TEX1_BIT) { - O[8] = LINTERP(t, I[8], J[8]); - O[9] = LINTERP(t, I[9], J[9]); - } -} - - -static void TAG(i830_init_fastpath)( struct i830_fast_tab *tab ) -{ - tab->interp = TAG(i830_interp_vert); - tab->build_vertices = TAG(i830_setup_full); -} - -#undef TYPE -#undef TAG -#undef SIZE diff --git a/xc/lib/GL/mesa/src/drv/i830/i830_ioctl.c b/xc/lib/GL/mesa/src/drv/i830/i830_ioctl.c index 44b3f15c7..493e495c8 100644 --- a/xc/lib/GL/mesa/src/drv/i830/i830_ioctl.c +++ b/xc/lib/GL/mesa/src/drv/i830/i830_ioctl.c @@ -1,3 +1,4 @@ + /************************************************************************** Copyright 2001 VA Linux Systems Inc., Fremont, California. @@ -25,74 +26,78 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. **************************************************************************/ -/* $XFree86: xc/lib/GL/mesa/src/drv/i830/i830_ioctl.c,v 1.1 2001/10/04 18:28:21 alanh Exp $ */ +/* $XFree86$ */ /* * Author: - * Jeff Hartmann <jhartmann@valinux.com> + * Jeff Hartmann <jhartmann@2d3d.com> + * Graeme Fisher <graeme@2d3d.co.za> + * Abraham vd Merwe <abraham@2d3d.co.za> * * Heavily based on the I810 driver, which was written by: - * Keith Whitwell <keithw@valinux.com> + * Keith Whitwell <keith@tungstengraphics.com> */ #include <stdio.h> #include <unistd.h> -#include "types.h" -#include "pb.h" +#include "glheader.h" +#include "mtypes.h" +#include "macros.h" #include "dd.h" +#include "swrast/swrast.h" #include "mm.h" -#include "i830_drv.h" + +#include "i830_screen.h" +#include "i830_dri.h" + +#include "i830_context.h" #include "i830_ioctl.h" +#include "i830_state.h" +#include "i830_debug.h" #include "drm.h" -#include <sys/ioctl.h> -drmBufPtr i830_get_buffer_ioctl( i830ContextPtr imesa ) + +static drmBufPtr i830_get_buffer_ioctl( i830ContextPtr imesa ) { - drm_i830_dma_t dma; + drmI830DMA dma; drmBufPtr buf; - int retcode; - - if (I830_DEBUG&DEBUG_VERBOSE_IOCTL) - fprintf(stderr, "Getting dma buffer\n"); - + int retcode,i = 0; while (1) { - retcode = ioctl(imesa->driFd, DRM_IOCTL_I830_GETBUF, &dma); - - if (dma.granted == 1 && retcode == 0) - break; - - if (I830_DEBUG&DEBUG_VERBOSE_IOCTL) - fprintf(stderr, "Retcode : %d, granted : %d\n", retcode, dma.granted); - - ioctl(imesa->driFd, DRM_IOCTL_I830_FLUSH); + retcode = drmCommandWriteRead(imesa->driFd, + DRM_I830_GETBUF, + &dma, + sizeof(drmI830DMA)); + if (dma.granted == 1 && retcode == 0) + break; + + if (++i > 1000) { + retcode = drmCommandNone(imesa->driFd, DRM_I830_FLUSH); + i = 0; + } } - - if (I830_DEBUG&DEBUG_VERBOSE_IOCTL) - fprintf(stderr, - "imesa->i830Screen->bufs->list : %p, " - "dma.request_idx : %d\n", - imesa->i830Screen->bufs->list, dma.request_idx); + if (0) + fprintf(stderr,"\nimesa->i830Screen->bufs->list: %p\n + dma.request_idx: %d\n",imesa->i830Screen->bufs->list, + dma.request_idx); buf = &(imesa->i830Screen->bufs->list[dma.request_idx]); buf->idx = dma.request_idx; - buf->used = 4; /* leave room for instruction header */ + buf->used = 0; buf->total = dma.request_size; + buf->address = (drmAddress)dma.virtual; - if(imesa->i830Screen->use_copy_buf != 1) - buf->address = (drmAddress)dma.virtual; return buf; } - static void i830ClearDrawQuad(i830ContextPtr imesa, float left, float right, float bottom, float top, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) { - GLuint *vb = i830AllocDwordsInlineLocked( imesa, 32 ); + GLuint *vb = i830AllocDmaLowLocked( imesa, 128 ); i830Vertex tmp; int i; @@ -102,7 +107,7 @@ static void i830ClearDrawQuad(i830ContextPtr imesa, float left, tmp.v.x = left; tmp.v.y = bottom; tmp.v.z = 1.0; - tmp.v.oow = 1.0; + tmp.v.w = 1.0; tmp.v.color.red = red; tmp.v.color.green = green; tmp.v.color.blue = blue; @@ -111,8 +116,8 @@ static void i830ClearDrawQuad(i830ContextPtr imesa, float left, tmp.v.specular.green = 0; tmp.v.specular.blue = 0; tmp.v.specular.alpha = 0; - tmp.v.tu0 = 0.0f; - tmp.v.tv0 = 0.0f; + tmp.v.u0 = 0.0f; + tmp.v.v0 = 0.0f; for (i = 0 ; i < 8 ; i++) vb[i] = tmp.ui[i]; @@ -180,8 +185,8 @@ static void i830ClearWithTris(GLcontext *ctx, GLbitfield mask, imesa->BufferSetup, sizeof(imesa->BufferSetup) ); - old_vertex_prim = imesa->vertex_prim; - imesa->vertex_prim = PRIM3D_TRIFAN; + old_vertex_prim = imesa->hw_primitive; + imesa->hw_primitive = PRIM3D_TRIFAN; if(mask & DD_FRONT_LEFT_BIT) { GLuint tmp = sarea->ContextState[I830_CTXREG_ENABLES_2]; @@ -242,7 +247,7 @@ static void i830ClearWithTris(GLcontext *ctx, GLbitfield mask, i830ClearDrawQuad(imesa, (float)x0, (float)x1, (float)y0, (float)y1, imesa->clear_red, imesa->clear_green, imesa->clear_blue, imesa->clear_alpha); - i830FlushVerticesLocked(imesa); + i830FlushPrimsLocked( imesa ); } if(mask & DD_BACK_LEFT_BIT) { @@ -305,7 +310,7 @@ static void i830ClearWithTris(GLcontext *ctx, GLbitfield mask, i830ClearDrawQuad(imesa, (float)x0, (float)x1, (float)y0, (float)y1, imesa->clear_red, imesa->clear_green, imesa->clear_blue, imesa->clear_alpha); - i830FlushVerticesLocked(imesa); + i830FlushPrimsLocked( imesa ); } if(mask & DD_STENCIL_BIT) { @@ -387,7 +392,7 @@ static void i830ClearWithTris(GLcontext *ctx, GLbitfield mask, i830ClearDrawQuad(imesa, (float)x0, (float)x1, (float)y0, (float)y1, 255, 255, 255, 255); - i830FlushVerticesLocked(imesa); + i830FlushPrimsLocked( imesa ); } UNLOCK_HARDWARE(imesa); @@ -396,32 +401,35 @@ static void i830ClearWithTris(GLcontext *ctx, GLbitfield mask, I830_UPLOAD_BUFFERS | I830_UPLOAD_TEXBLEND0); - imesa->vertex_prim = old_vertex_prim; + imesa->hw_primitive = old_vertex_prim; } -GLbitfield i830Clear( GLcontext *ctx, GLbitfield mask, GLboolean all, - GLint cx, GLint cy, GLint cw, GLint ch ) +static void i830Clear(GLcontext *ctx, GLbitfield mask, GLboolean all, + GLint cx1, GLint cy1, GLint cw, GLint ch) { i830ContextPtr imesa = I830_CONTEXT( ctx ); __DRIdrawablePrivate *dPriv = imesa->driDrawable; const GLuint colorMask = *((GLuint *) &ctx->Color.ColorMask); - drm_i830_clear_t clear; + drmI830Clear clear; GLbitfield tri_mask = 0; int i; - - FLUSH_BATCH( imesa ); + GLint cx, cy; /* flip top to bottom */ - cy = dPriv->h-cy-ch; - cx += imesa->drawX; + cy = dPriv->h-cy1-ch; + cx = cx1 + imesa->drawX; cy += imesa->drawY; + if(0) fprintf(stderr, "\nClearColor : 0x%08x\n", imesa->ClearColor); + clear.flags = 0; clear.clear_color = imesa->ClearColor; clear.clear_depth = 0; clear.clear_colormask = 0; clear.clear_depthmask = 0; + I830_FIREVERTICES( imesa ); + if (mask & DD_FRONT_LEFT_BIT) { if(colorMask == ~0) { clear.flags |= I830_FRONT; @@ -453,86 +461,89 @@ GLbitfield i830Clear( GLcontext *ctx, GLbitfield mask, GLboolean all, } else { clear.flags |= I830_DEPTH; clear.clear_depthmask |= imesa->stencil_clear_mask; - clear.clear_depth |= ((ctx->Stencil.Clear<<24) & - imesa->stencil_clear_mask); + clear.clear_depth |= imesa->stencil_clear_mask; } mask &= ~DD_STENCIL_BIT; } /* First check for clears that need to happen with triangles */ - if(tri_mask) { i830ClearWithTris(ctx, tri_mask, all, cx, cy, cw, ch); + } else { + mask |= tri_mask; } - if (!clear.flags) - return mask; - - LOCK_HARDWARE( imesa ); + if (clear.flags) { + LOCK_HARDWARE( imesa ); - if (I830_DEBUG&DEBUG_VERBOSE_IOCTL) - fprintf(stderr, "Clear, bufs %x nbox %d\n", - (int)clear.flags, (int)imesa->numClipRects); - - for (i = 0 ; i < imesa->numClipRects ; ) - { - int nr = MIN2(i + I830_NR_SAREA_CLIPRECTS, imesa->numClipRects); - XF86DRIClipRectRec *box = imesa->pClipRects; - drm_clip_rect_t *b = (drm_clip_rect_t *)imesa->sarea->boxes; - int n = 0; - - if (!all) { - for ( ; i < nr ; i++) { - GLint x = box[i].x1; - GLint y = box[i].y1; - GLint w = box[i].x2 - x; - GLint h = box[i].y2 - y; - - if (x < cx) w -= cx - x, x = cx; - if (y < cy) h -= cy - y, y = cy; - if (x + w > cx + cw) w = cx + cw - x; - if (y + h > cy + ch) h = cy + ch - y; - if (w <= 0) continue; - if (h <= 0) continue; - - b->x1 = x; - b->y1 = y; - b->x2 = x + w; - b->y2 = y + h; - b++; - n++; - } - } else { - for ( ; i < nr ; i++) { - *b++ = *(drm_clip_rect_t *)&box[i]; - n++; + for (i = 0 ; i < imesa->numClipRects ; ) + { + int nr = MIN2(i + I830_NR_SAREA_CLIPRECTS, imesa->numClipRects); + XF86DRIClipRectRec *box = imesa->pClipRects; + drm_clip_rect_t *b = (drm_clip_rect_t *)imesa->sarea->boxes; + int n = 0; + + if (!all) { + for ( ; i < nr ; i++) { + GLint x = box[i].x1; + GLint y = box[i].y1; + GLint w = box[i].x2 - x; + GLint h = box[i].y2 - y; + + if (x < cx) w -= cx - x, x = cx; + if (y < cy) h -= cy - y, y = cy; + if (x + w > cx + cw) w = cx + cw - x; + if (y + h > cy + ch) h = cy + ch - y; + if (w <= 0) continue; + if (h <= 0) continue; + + b->x1 = x; + b->y1 = y; + b->x2 = x + w; + b->y2 = y + h; + b++; + n++; + } + } else { + for ( ; i < nr ; i++) { + *b++ = *(drm_clip_rect_t *)&box[i]; + n++; + } } + + imesa->sarea->nbox = n; + drmCommandWrite(imesa->driFd, DRM_I830_CLEAR, + &clear, sizeof(drmI830Clear)); } - imesa->sarea->nbox = n; - ioctl(imesa->driFd, DRM_IOCTL_I830_CLEAR, &clear); + UNLOCK_HARDWARE( imesa ); + imesa->upload_cliprects = GL_TRUE; } - UNLOCK_HARDWARE( imesa ); - imesa->dirty |= I830_UPLOAD_CLIPRECTS; - - return mask; + if (mask) + _swrast_Clear( ctx, mask, all, cx1, cy1, cw, ch ); } + + /* * Copy the back buffer to the front buffer. */ -void i830SwapBuffers( i830ContextPtr imesa ) +void i830CopyBuffer( const __DRIdrawablePrivate *dPriv ) { - __DRIdrawablePrivate *dPriv = imesa->driDrawable; + i830ContextPtr imesa; XF86DRIClipRectPtr pbox; - int nbox; - int i; - int tmp; + int nbox, i, tmp; + + assert(dPriv); + assert(dPriv->driContextPriv); + assert(dPriv->driContextPriv->driverPrivate); - FLUSH_BATCH( imesa ); + imesa = (i830ContextPtr) dPriv->driContextPriv->driverPrivate; + + I830_FIREVERTICES( imesa ); LOCK_HARDWARE( imesa ); - + pbox = dPriv->pClipRects; nbox = dPriv->numClipRects; @@ -545,117 +556,76 @@ void i830SwapBuffers( i830ContextPtr imesa ) for ( ; i < nr ; i++) *b++ = pbox[i]; - - ioctl(imesa->driFd, DRM_IOCTL_I830_SWAP); + drmCommandNone(imesa->driFd, DRM_I830_SWAP); } tmp = GET_ENQUEUE_AGE(imesa); UNLOCK_HARDWARE( imesa ); - if (GET_DISPATCH_AGE(imesa) < imesa->lastSwap) + /* multiarb will suck the life out of the server without this throttle: + */ + if (GET_DISPATCH_AGE(imesa) < imesa->lastSwap) { i830WaitAge(imesa, imesa->lastSwap); + } imesa->lastSwap = tmp; - imesa->dirty |= I830_UPLOAD_CLIPRECTS; + imesa->upload_cliprects = GL_TRUE; } - - - - +/* + * XXX implement when full-screen extension is done. + */ +void i830PageFlip( const __DRIdrawablePrivate *dPriv ) +{ + return; +} /* This waits for *everybody* to finish rendering -- overkill. */ -void i830DmaFinish( i830ContextPtr imesa ) +void i830DmaFinish( i830ContextPtr imesa ) { - FLUSH_BATCH( imesa ); - - - if (1 || imesa->sarea->last_quiescent != imesa->sarea->last_enqueue) { - - if (I830_DEBUG&DEBUG_VERBOSE_IOCTL) - fprintf(stderr, "i830DmaFinish\n"); - - LOCK_HARDWARE( imesa ); - i830RegetLockQuiescent( imesa ); - UNLOCK_HARDWARE( imesa ); - imesa->sarea->last_quiescent = imesa->sarea->last_enqueue; - } + I830_FIREVERTICES( imesa ); + LOCK_HARDWARE( imesa ); + i830RegetLockQuiescent( imesa ); + UNLOCK_HARDWARE( imesa ); } - -void i830RegetLockQuiescent( i830ContextPtr imesa ) +void i830RegetLockQuiescent( i830ContextPtr imesa ) { - if (1 || imesa->sarea->last_quiescent != imesa->sarea->last_enqueue) { - if (I830_DEBUG&DEBUG_VERBOSE_IOCTL) - fprintf(stderr, "i830RegetLockQuiescent\n"); - - drmUnlock(imesa->driFd, imesa->hHWContext); - i830GetLock( imesa, DRM_LOCK_QUIESCENT ); - imesa->sarea->last_quiescent = imesa->sarea->last_enqueue; - } + drmUnlock(imesa->driFd, imesa->hHWContext); + i830GetLock( imesa, DRM_LOCK_QUIESCENT ); } -void i830WaitAgeLocked( i830ContextPtr imesa, int age ) +void i830WaitAgeLocked( i830ContextPtr imesa, int age ) { - int i = 0; - - - while (++i < 500000 && GET_DISPATCH_AGE(imesa) < age) { - ioctl(imesa->driFd, DRM_IOCTL_I830_GETAGE); - } - - if (GET_DISPATCH_AGE(imesa) < age) { - if (0) - fprintf(stderr, "wait locked %d %d\n", age, GET_DISPATCH_AGE(imesa)); - ioctl(imesa->driFd, DRM_IOCTL_I830_FLUSH); + int i = 0, j; + while (++i < 5000) { + drmCommandNone(imesa->driFd, DRM_I830_GETAGE); + if (GET_DISPATCH_AGE(imesa) >= age) return; + for (j = 0 ; j < 1000 ; j++); } + drmCommandNone(imesa->driFd, DRM_I830_FLUSH); } - void i830WaitAge( i830ContextPtr imesa, int age ) { - int i = 0; - - while (++i < 500000 && GET_DISPATCH_AGE(imesa) < age) { - ioctl(imesa->driFd, DRM_IOCTL_I830_GETAGE); + int i = 0, j; + while (++i < 5000) { + drmCommandNone(imesa->driFd, DRM_I830_GETAGE); + if (GET_DISPATCH_AGE(imesa) >= age) return; + for (j = 0 ; j < 1000 ; j++); } - if (GET_DISPATCH_AGE(imesa) >= age) - return; - i = 0; - while (++i < 1000 && GET_DISPATCH_AGE(imesa) < age) { - ioctl(imesa->driFd, DRM_IOCTL_I830_GETAGE); + while (++i < 1000) { + drmCommandNone(imesa->driFd, DRM_I830_GETAGE); + if (GET_DISPATCH_AGE(imesa) >= age) return; usleep(1000); } - - /* To be effective at letting other clients at the hardware, - * particularly the X server which regularly needs quiescence to - * touch the framebuffer, we really need to sleep *beyond* the - * point where our last buffer clears the hardware. - */ - if (imesa->any_contend) { - usleep(3000); - } - - imesa->any_contend = 0; - - if (GET_DISPATCH_AGE(imesa) < age) { - LOCK_HARDWARE(imesa); - if (GET_DISPATCH_AGE(imesa) < age) - ioctl(imesa->driFd, DRM_IOCTL_I830_FLUSH); - UNLOCK_HARDWARE(imesa); - } -} - -void i830FlushVertices( i830ContextPtr imesa ) -{ - if (!imesa->vertex_dma_buffer) return; - LOCK_HARDWARE( imesa ); - i830FlushVerticesLocked( imesa ); - UNLOCK_HARDWARE( imesa ); + LOCK_HARDWARE(imesa); + drmCommandNone(imesa->driFd, DRM_I830_FLUSH); + UNLOCK_HARDWARE(imesa); } static void age_imesa( i830ContextPtr imesa, int age ) @@ -664,139 +634,140 @@ static void age_imesa( i830ContextPtr imesa, int age ) if (imesa->CurrentTexObj[1]) imesa->CurrentTexObj[1]->age = age; } -void i830FlushVerticesLocked( i830ContextPtr imesa ) +void i830FlushPrimsLocked( i830ContextPtr imesa ) { - drm_clip_rect_t *pbox = (drm_clip_rect_t *)imesa->pClipRects; + XF86DRIClipRectPtr pbox = (XF86DRIClipRectPtr)imesa->pClipRects; int nbox = imesa->numClipRects; - drmBufPtr buffer = imesa->vertex_dma_buffer; - drm_i830_vertex_t vertex; + drmBufPtr buffer = imesa->vertex_buffer; + I830SAREAPtr sarea = imesa->sarea; + drmI830Vertex vertex; int i; - if (I830_DEBUG&DEBUG_VERBOSE_IOCTL) - fprintf(stderr, "i830FlushVerticesLocked, buf->used %d\n", - buffer->used); - - if (!buffer) - return; - - if (imesa->dirty & ~I830_UPLOAD_CLIPRECTS) - i830EmitHwStateLocked( imesa ); - - if (I830_DEBUG&DEBUG_VERBOSE_IOCTL) - fprintf(stderr, "i830FlushVerticesLocked, used %d\n", - buffer->used); - - imesa->vertex_dma_buffer = 0; + if (0) fprintf(stderr, "%s dirty: %08x\n", __FUNCTION__, imesa->dirty); + if (imesa->dirty) +#if OUTPUT_EMITTED_STATE + i830EmitHwStateLockedDebug(imesa); +#else + i830EmitHwStateLocked(imesa); +#endif vertex.idx = buffer->idx; - vertex.used = buffer->used; + vertex.used = imesa->vertex_low; vertex.discard = 0; - + sarea->vertex_prim = imesa->hw_primitive; + + if (0) + fprintf(stderr,"\nVertex idx%d\n" + "\nused %d\n" + "\ndiscard %d\n", + vertex.idx, + vertex.used, + vertex.discard); if (!nbox) vertex.used = 0; + else if (nbox > I830_NR_SAREA_CLIPRECTS) + imesa->upload_cliprects = GL_TRUE; - if (nbox > I830_NR_SAREA_CLIPRECTS) - imesa->dirty |= I830_UPLOAD_CLIPRECTS; - - if(imesa->i830Screen->use_copy_buf == 1 && vertex.used) { - drm_i830_copy_t copy; - - copy.idx = buffer->idx; - copy.used = buffer->used; - copy.address = buffer->address; - ioctl(imesa->driFd, DRM_IOCTL_I830_COPY, ©); - } - - - imesa->sarea->vertex_prim = imesa->vertex_prim; - - if (!nbox || !(imesa->dirty & I830_UPLOAD_CLIPRECTS)) - { - if (nbox == 1) - imesa->sarea->nbox = 0; - else - imesa->sarea->nbox = nbox; - - if (I830_DEBUG&DEBUG_VERBOSE_IOCTL) - fprintf(stderr, "DRM_IOCTL_I830_VERTEX CASE1 nbox %d used %d\n", - nbox, vertex.used); - + if (!nbox || !imesa->upload_cliprects) { + sarea->nbox = nbox == 1 ? 0 : nbox; vertex.discard = 1; - ioctl(imesa->driFd, DRM_IOCTL_I830_VERTEX, &vertex); - age_imesa(imesa, imesa->sarea->last_enqueue); - } - else - { - for (i = 0 ; i < nbox ; ) - { - int nr = MIN2(i + I810_NR_SAREA_CLIPRECTS, nbox); - drm_clip_rect_t *b = (drm_clip_rect_t *)imesa->sarea->boxes; + drmCommandWrite (imesa->driFd, DRM_I830_VERTEX, + &vertex, sizeof(drmI830Vertex)); + age_imesa(imesa, sarea->last_enqueue); + } else { + for (i = 0 ; i < nbox ; ) { + int nr = MIN2(i + I830_NR_SAREA_CLIPRECTS, nbox); + XF86DRIClipRectPtr b = sarea->boxes; - imesa->sarea->nbox = nr - i; + sarea->nbox = nr - i; for ( ; i < nr ; i++, b++) { *b++ = pbox[i]; - if(0) fprintf(stderr, "x1: %d y1: %d x2: %d y2: %d\n", - pbox[i].x1, - pbox[i].y1, - pbox[i].x2, - pbox[i].y2); + if (0) + fprintf(stderr,"\nCo-ordiantes: x1 %d\n" + "y1: %d\n" + "x2: %d\n" + "x3: %d\n", + b->x1, + b->y1, + b->x2, + b->y2); } /* Finished with the buffer? */ - if (nr == nbox) - vertex.discard = 1; + if (nr == nbox) + vertex.discard = 1; + if (0) + fprintf(stderr,"\nWriting vertex info to hardware\n"); + if (0) { + fprintf(stderr,"\nimesa->BufferSetup[I830_DESTREG_DR1] = %x\n", + imesa->BufferSetup[I830_DESTREG_DR1]); + fprintf(stderr,"\nimesa->BufferSetup[I830_DESTREG_DR4] = %x\n", + imesa->BufferSetup[I830_DESTREG_DR4]); + } - if (I830_DEBUG&DEBUG_VERBOSE_IOCTL) - fprintf(stderr, "DRM_IOCTL_I830_VERTEX nbox %d used %d\n", - nbox, vertex.used); + /* Do a bunch of sanity checks on the vertices sent to the hardware */ + if (VERTEX_SANITY) i830VertexSanity(imesa, vertex); - ioctl(imesa->driFd, DRM_IOCTL_I830_VERTEX, &vertex); + drmCommandWrite (imesa->driFd, DRM_I830_VERTEX, + &vertex, sizeof(drmI830Vertex)); age_imesa(imesa, imesa->sarea->last_enqueue); } } + /* Reset imesa vars: + */ + imesa->vertex_buffer = 0; + imesa->vertex_addr = 0; + imesa->vertex_low = 0; + imesa->vertex_high = 0; + imesa->vertex_last_prim = 0; imesa->dirty = 0; - if (I830_DEBUG&DEBUG_VERBOSE_IOCTL) - fprintf(stderr, "finished i830FlushVerticesLocked\n"); + imesa->upload_cliprects = GL_FALSE; } +void i830FlushPrimsGetBuffer( i830ContextPtr imesa ) +{ + LOCK_HARDWARE(imesa); + if (imesa->vertex_buffer) + i830FlushPrimsLocked( imesa ); + imesa->vertex_buffer = i830_get_buffer_ioctl( imesa ); + imesa->vertex_high = imesa->vertex_buffer->total; + imesa->vertex_addr = (char *)imesa->vertex_buffer->address; + imesa->vertex_low = 4; /* leave room for instruction header */ + imesa->vertex_last_prim = imesa->vertex_low; + UNLOCK_HARDWARE(imesa); +} -GLuint *i830AllocDwords( i830ContextPtr imesa, int dwords ) +void i830FlushPrimsGetBufferLocked( i830ContextPtr imesa ) { - GLuint *start; + if (imesa->vertex_buffer) + i830FlushPrimsLocked( imesa ); + imesa->vertex_buffer = i830_get_buffer_ioctl( imesa ); + imesa->vertex_high = imesa->vertex_buffer->total; + imesa->vertex_addr = (char *)imesa->vertex_buffer->address; + imesa->vertex_low = 4; /* leave room for instruction header */ + imesa->vertex_last_prim = imesa->vertex_low; +} - if (!imesa->vertex_dma_buffer) - { - LOCK_HARDWARE(imesa); - imesa->vertex_dma_buffer = i830_get_buffer_ioctl( imesa ); - UNLOCK_HARDWARE(imesa); - } - else if (imesa->vertex_dma_buffer->used + dwords * 4 > - imesa->vertex_dma_buffer->total) - { - LOCK_HARDWARE(imesa); - i830FlushVerticesLocked( imesa ); - imesa->vertex_dma_buffer = i830_get_buffer_ioctl( imesa ); - UNLOCK_HARDWARE(imesa); +void i830FlushPrims( i830ContextPtr imesa ) +{ + if (imesa->vertex_buffer) { + LOCK_HARDWARE( imesa ); + i830FlushPrimsLocked( imesa ); + UNLOCK_HARDWARE( imesa ); } - - start = (GLuint *)((char *)imesa->vertex_dma_buffer->address + - imesa->vertex_dma_buffer->used); - - imesa->vertex_dma_buffer->used += dwords * 4; - return start; } int i830_check_copy(int fd) { - return(ioctl(fd, DRM_IOCTL_I830_DOCOPY)); + return drmCommandNone(fd, DRM_I830_DOCOPY); } static void i830DDFlush( GLcontext *ctx ) { i830ContextPtr imesa = I830_CONTEXT( ctx ); - FLUSH_BATCH( imesa ); + I830_FIREVERTICES( imesa ); } static void i830DDFinish( GLcontext *ctx ) @@ -808,5 +779,7 @@ static void i830DDFinish( GLcontext *ctx ) void i830DDInitIoctlFuncs( GLcontext *ctx ) { ctx->Driver.Flush = i830DDFlush; + ctx->Driver.Clear = i830Clear; ctx->Driver.Finish = i830DDFinish; } + diff --git a/xc/lib/GL/mesa/src/drv/i830/i830_ioctl.h b/xc/lib/GL/mesa/src/drv/i830/i830_ioctl.h index 983ea9840..389143b22 100644 --- a/xc/lib/GL/mesa/src/drv/i830/i830_ioctl.h +++ b/xc/lib/GL/mesa/src/drv/i830/i830_ioctl.h @@ -1,3 +1,4 @@ + /************************************************************************** Copyright 2001 VA Linux Systems Inc., Fremont, California. @@ -25,104 +26,82 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. **************************************************************************/ -/* $XFree86: xc/lib/GL/mesa/src/drv/i830/i830_ioctl.h,v 1.1 2001/10/04 18:28:21 alanh Exp $ */ +/* $XFree86$ */ /* * Author: - * Jeff Hartmann <jhartmann@valinux.com> + * Jeff Hartmann <jhartmann@2d3d.com> + * Graeme Fisher <graeme@2d3d.co.za> + * Abraham vd Merwe <abraham@2d3d.co.za> * * Heavily based on the I810 driver, which was written by: - * Keith Whitwell <keithw@valinux.com> + * Keith Whitwell <keith@tungstengraphics.com> */ +/* $XFree86$ */ + #ifndef I830_IOCTL_H #define I830_IOCTL_H -#include "i830_drv.h" - - -GLuint *i830AllocDwords( i830ContextPtr imesa, int dwords ); - -void i830GetGeneralDmaBufferLocked( i830ContextPtr mmesa ); - -void i830FlushVertices( i830ContextPtr mmesa ); -void i830FlushVerticesLocked( i830ContextPtr mmesa ); +#include "i830_context.h" -void i830FlushGeneralLocked( i830ContextPtr imesa ); +GLuint *i830AllocDwords (i830ContextPtr imesa, int dwords); +void i830EmitPrim( i830ContextPtr imesa ); +void i830FlushPrims( i830ContextPtr mmesa ); +void i830FlushPrimsLocked( i830ContextPtr mmesa ); +void i830FlushPrimsGetBuffer( i830ContextPtr imesa ); +void i830FlushPrimsGetBufferLocked( i830ContextPtr imesa ); void i830WaitAgeLocked( i830ContextPtr imesa, int age ); void i830WaitAge( i830ContextPtr imesa, int age ); - void i830DmaFinish( i830ContextPtr imesa ); - void i830RegetLockQuiescent( i830ContextPtr imesa ); - void i830DDInitIoctlFuncs( GLcontext *ctx ); - -void i830SwapBuffers( i830ContextPtr imesa ); - +void i830CopyBuffer( const __DRIdrawablePrivate *dpriv ); +void i830PageFlip( const __DRIdrawablePrivate *dpriv ); int i830_check_copy(int fd); -GLbitfield i830Clear( GLcontext *ctx, GLbitfield mask, GLboolean all, - GLint cx, GLint cy, GLint cw, GLint ch ); +#define I830_STATECHANGE(imesa, flag) \ +do { \ + if (imesa->vertex_low != imesa->vertex_last_prim) \ + i830FlushPrims(imesa); \ + imesa->dirty |= flag; \ +} while (0) + -#define FLUSH_BATCH(imesa) do { \ - if (I830_DEBUG&DEBUG_VERBOSE_IOCTL) \ - fprintf(stderr, "FLUSH_BATCH in %s\n", __FUNCTION__); \ - if (imesa->vertex_dma_buffer) i830FlushVertices(imesa); \ +#define I830_FIREVERTICES(imesa) \ +do { \ + if (imesa->vertex_buffer) { \ + i830FlushPrims(imesa); \ +} \ } while (0) -extern drmBufPtr i830_get_buffer_ioctl( i830ContextPtr imesa ); -static __inline -GLuint *i830AllocDwordsInline( i830ContextPtr imesa, int dwords ) +static __inline GLuint *i830AllocDmaLow( i830ContextPtr imesa, int bytes ) { - int bytes = dwords * 4; - GLuint *start; - - if (!imesa->vertex_dma_buffer) - { - LOCK_HARDWARE(imesa); - imesa->vertex_dma_buffer = i830_get_buffer_ioctl( imesa ); - UNLOCK_HARDWARE(imesa); - } - else if (imesa->vertex_dma_buffer->used + bytes > - imesa->vertex_dma_buffer->total) + if (imesa->vertex_low + bytes > imesa->vertex_high) { + i830FlushPrimsGetBuffer( imesa ); + } + { - LOCK_HARDWARE(imesa); - i830FlushVerticesLocked( imesa ); - imesa->vertex_dma_buffer = i830_get_buffer_ioctl( imesa ); - UNLOCK_HARDWARE(imesa); + GLuint *start = (GLuint *)(imesa->vertex_addr + imesa->vertex_low); + imesa->vertex_low += bytes; + return start; } - - start = (GLuint *)((char *)imesa->vertex_dma_buffer->address + - imesa->vertex_dma_buffer->used); - - imesa->vertex_dma_buffer->used += bytes; - return start; } -static __inline -GLuint *i830AllocDwordsInlineLocked( i830ContextPtr imesa, int dwords ) +static __inline GLuint *i830AllocDmaLowLocked( i830ContextPtr imesa, + int bytes ) { - int bytes = dwords * 4; - GLuint *start; - - if (!imesa->vertex_dma_buffer) - { - imesa->vertex_dma_buffer = i830_get_buffer_ioctl( imesa ); - } - else if (imesa->vertex_dma_buffer->used + bytes > - imesa->vertex_dma_buffer->total) + if (imesa->vertex_low + bytes > imesa->vertex_high) { + i830FlushPrimsGetBufferLocked( imesa ); + } + { - i830FlushVerticesLocked( imesa ); - imesa->vertex_dma_buffer = i830_get_buffer_ioctl( imesa ); + GLuint *start = (GLuint *)(imesa->vertex_addr + imesa->vertex_low); + imesa->vertex_low += bytes; + return start; } - - start = (GLuint *)((char *)imesa->vertex_dma_buffer->address + - imesa->vertex_dma_buffer->used); - - imesa->vertex_dma_buffer->used += bytes; - return start; } + #endif diff --git a/xc/lib/GL/mesa/src/drv/i830/i830_pipeline.c b/xc/lib/GL/mesa/src/drv/i830/i830_pipeline.c deleted file mode 100644 index 79741cc79..000000000 --- a/xc/lib/GL/mesa/src/drv/i830/i830_pipeline.c +++ /dev/null @@ -1,145 +0,0 @@ -/************************************************************************** - -Copyright 2001 VA Linux Systems Inc., Fremont, California. - -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 -on 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 -ATI, VA LINUX SYSTEMS AND/OR THEIR 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. - -**************************************************************************/ - -/* $XFree86: xc/lib/GL/mesa/src/drv/i830/i830_pipeline.c,v 1.1 2001/10/04 18:28:21 alanh Exp $ */ - -/* - * Author: - * Jeff Hartmann <jhartmann@valinux.com> - * - * Heavily based on the I810 driver, which was written by: - * Keith Whitwell <keithw@valinux.com> - */ - -#include <stdio.h> - -#include "types.h" -#include "fog.h" - -#include "i830_drv.h" - -static struct gl_pipeline_stage i830_fast_stage = { - "i830 fast path", - (PIPE_OP_VERT_XFORM|PIPE_OP_RAST_SETUP_0| - PIPE_OP_RAST_SETUP_1|PIPE_OP_RENDER), - PIPE_PRECALC, - 0, 0, 0, 0, 0, 0, 0, 0, 0, - i830DDFastPath -}; - - -#define ILLEGAL_ENABLES (TEXTURE0_3D| \ - TEXTURE1_3D| \ - ENABLE_TEXMAT0 | \ - ENABLE_TEXMAT1 | \ - ENABLE_TEXGEN0 | \ - ENABLE_TEXGEN1 | \ - ENABLE_USERCLIP | \ - ENABLE_LIGHT | \ - ENABLE_FOG) - - -/* The driver gets first shot at building the pipeline - make some - * quick tests to see if we can use the fast path. - */ -GLboolean i830DDBuildPrecalcPipeline( GLcontext *ctx ) -{ - i830ContextPtr imesa = I830_CONTEXT( ctx ); - struct gl_pipeline *pipe = &ctx->CVA.pre; - - if (imesa->renderindex == 0 && - (ctx->Enabled & ILLEGAL_ENABLES) == 0 && - (ctx->Array.Flags & (VERT_OBJ_234| - VERT_TEX0_4| - VERT_TEX1_4| - VERT_ELT)) == (VERT_OBJ_23|VERT_ELT)) - { - pipe->stages[0] = &i830_fast_stage; - pipe->stages[1] = 0; - pipe->new_inputs = ctx->RenderFlags & VERT_DATA; - pipe->ops = pipe->stages[0]->ops; - imesa->using_fast_path = 1; - return 1; - } - - if (imesa->using_fast_path) - { - imesa->using_fast_path = 0; - ctx->CVA.VB->ClipOrMask = 0; - ctx->CVA.VB->ClipAndMask = CLIP_ALL_BITS; - ctx->Array.NewArrayState |= ctx->Array.Summary; - return 0; - } - - return 0; -} - - - -GLuint i830DDRegisterPipelineStages( struct gl_pipeline_stage *out, - const struct gl_pipeline_stage *in, - GLuint nr ) -{ - GLuint i, o; - - for (i = o = 0 ; i < nr ; i++) { - switch (in[i].ops) { - - case PIPE_OP_RAST_SETUP_0: - out[o] = in[i]; - out[o].cva_state_change = NEW_LIGHTING|NEW_TEXTURING|NEW_RASTER_OPS; - out[o].state_change = ~0; - out[o].check = i830DDCheckPartialRasterSetup; - out[o].run = i830DDPartialRasterSetup; - o++; - break; - - case PIPE_OP_RAST_SETUP_0|PIPE_OP_RAST_SETUP_1: - out[o] = in[i]; - out[o].run = i830DDDoRasterSetup; - o++; - break; - - /* Completely replace Mesa's fog processing to generate fog - * coordinates instead of messing with colors. - */ - case PIPE_OP_FOG: - out[o] = gl_fog_coord_stage; - o++; - break; - - - default: - out[o++] = in[i]; - break; - } - } - - return o; -} - - diff --git a/xc/lib/GL/mesa/src/drv/i830/i830_render.c b/xc/lib/GL/mesa/src/drv/i830/i830_render.c new file mode 100644 index 000000000..15edda3bc --- /dev/null +++ b/xc/lib/GL/mesa/src/drv/i830/i830_render.c @@ -0,0 +1,215 @@ +/* $Id: i830_render.c,v 1.1 2002/05/29 21:21:48 jhartmann Exp $ */ + +/* + * Intel i810 DRI driver for Mesa 3.5 + * + * Copyright (C) 1999-2000 Keith Whitwell 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 KEITH WHITWELL 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. + * + * Author: + * Keith Whitwell <keith@tungstengraphics.com> + * Adapted for use on the I830: + * Jeff Hartmann <jhartmann@2d3d.com> + */ + + +/* + * Render unclipped vertex buffers by emitting vertices directly to + * dma buffers. Use strip/fan hardware acceleration where possible. + * + */ +#include "glheader.h" +#include "context.h" +#include "macros.h" +#include "mem.h" +#include "mtypes.h" +#include "mmath.h" + +#include "tnl/t_context.h" + +#include "i830_screen.h" +#include "i830_dri.h" + +#include "i830_context.h" +#include "i830_tris.h" +#include "i830_state.h" +#include "i830_vb.h" +#include "i830_ioctl.h" + +/* + * Render unclipped vertex buffers by emitting vertices directly to + * dma buffers. Use strip/fan hardware primitives where possible. + * Try to simulate missing primitives with indexed vertices. + */ +#define HAVE_POINTS 0 /* Has it, but can't use because subpixel has to + * be adjusted for points on the I830/I845G + */ +#define HAVE_LINES 1 +#define HAVE_LINE_STRIPS 1 +#define HAVE_TRIANGLES 1 +#define HAVE_TRI_STRIPS 1 +#define HAVE_TRI_STRIP_1 0 /* has it, template can't use it yet */ +#define HAVE_TRI_FANS 1 +#define HAVE_POLYGONS 1 +#define HAVE_QUADS 0 +#define HAVE_QUAD_STRIPS 0 + +#define HAVE_ELTS 0 + +static GLuint hw_prim[GL_POLYGON+1] = { + PRIM3D_POINTLIST, + PRIM3D_LINELIST, + 0, + PRIM3D_LINESTRIP, + PRIM3D_TRILIST, + PRIM3D_TRISTRIP, + PRIM3D_TRIFAN, + 0, + 0, + PRIM3D_POLY +}; + +static const GLenum reduced_prim[GL_POLYGON+1] = { + GL_POINTS, + GL_LINES, + GL_LINES, + GL_LINES, + GL_TRIANGLES, + GL_TRIANGLES, + GL_TRIANGLES, + GL_TRIANGLES, + GL_TRIANGLES, + GL_TRIANGLES +}; + +/* Fallback to normal rendering. + */ +static void VERT_FALLBACK( GLcontext *ctx, + GLuint start, + GLuint count, + GLuint flags ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + tnl->Driver.Render.PrimitiveNotify( ctx, flags & PRIM_MODE_MASK ); + tnl->Driver.Render.BuildVertices( ctx, start, count, ~0 ); + tnl->Driver.Render.PrimTabVerts[flags&PRIM_MODE_MASK]( ctx, start, + count, flags ); + I830_CONTEXT(ctx)->SetupNewInputs = VERT_CLIP; +} + + +#define LOCAL_VARS i830ContextPtr imesa = I830_CONTEXT(ctx) +#define INIT( prim ) do { \ + I830_STATECHANGE(imesa, 0); \ + i830RasterPrimitive( ctx, reduced_prim[prim], hw_prim[prim] ); \ +} while (0) + +#define NEW_PRIMITIVE() I830_STATECHANGE( imesa, 0 ) +#define NEW_BUFFER() I830_FIREVERTICES( imesa ) +#define GET_CURRENT_VB_MAX_VERTS() \ + (((int)imesa->vertex_high - (int)imesa->vertex_low) / (imesa->vertex_size*4)) +#define GET_SUBSEQUENT_VB_MAX_VERTS() \ + (I830_DMA_BUF_SZ-4) / (imesa->vertex_size * 4) + +#define EMIT_VERTS( ctx, j, nr ) \ + i830_emit_contiguous_verts(ctx, j, (j)+(nr)) + +#define TAG(x) i830_##x +#include "tnl_dd/t_dd_dmatmp.h" + + +/**********************************************************************/ +/* Render pipeline stage */ +/**********************************************************************/ + + +static GLboolean i830_run_render( GLcontext *ctx, + struct gl_pipeline_stage *stage ) +{ + i830ContextPtr imesa = I830_CONTEXT(ctx); + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct vertex_buffer *VB = &tnl->vb; + GLuint i, length, flags = 0; + /* Don't handle clipping or indexed vertices. + */ + if (VB->ClipOrMask || imesa->RenderIndex != 0 || VB->Elts) { + return GL_TRUE; + } + + imesa->SetupNewInputs = VERT_CLIP; + + tnl->Driver.Render.Start( ctx ); + + for (i = VB->FirstPrimitive ; !(flags & PRIM_LAST) ; i += length) { + flags = VB->Primitive[i]; + length= VB->PrimitiveLength[i]; + if (length) + i830_render_tab_verts[flags & PRIM_MODE_MASK]( ctx, i, i + length, + flags ); + } + + tnl->Driver.Render.Finish( ctx ); + + return GL_FALSE; /* finished the pipe */ +} + + +static void i830_check_render( GLcontext *ctx, + struct gl_pipeline_stage *stage ) +{ + GLuint inputs = VERT_CLIP|VERT_RGBA; + if (ctx->RenderMode == GL_RENDER) { + if (ctx->_TriangleCaps & DD_SEPARATE_SPECULAR) + inputs |= VERT_SPEC_RGB; + + if (ctx->Texture.Unit[0]._ReallyEnabled) + inputs |= VERT_TEX(0); + + if (ctx->Texture.Unit[1]._ReallyEnabled) + inputs |= VERT_TEX(1); + + if (ctx->Fog.Enabled) + inputs |= VERT_FOG_COORD; + } + + stage->inputs = inputs; +} + +static void dtr( struct gl_pipeline_stage *stage ) +{ + (void)stage; +} + + +const struct gl_pipeline_stage _i830_render_stage = +{ + "i830 render", + (_DD_NEW_SEPARATE_SPECULAR | + _NEW_TEXTURE| + _NEW_FOG| + _NEW_RENDERMODE), /* re-check (new inputs) */ + 0, /* re-run (always runs) */ + GL_TRUE, /* active */ + 0, 0, /* inputs (set in check_render), outputs */ + 0, 0, /* changed_inputs, private */ + dtr, /* destructor */ + i830_check_render, /* check - initially set to alloc data */ + i830_run_render /* run */ +}; diff --git a/xc/lib/GL/mesa/src/drv/i830/i830_screen.c b/xc/lib/GL/mesa/src/drv/i830/i830_screen.c new file mode 100644 index 000000000..78ea80b06 --- /dev/null +++ b/xc/lib/GL/mesa/src/drv/i830/i830_screen.c @@ -0,0 +1,378 @@ +/************************************************************************** + * + * Copyright 1998-1999 Precision Insight, 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 PRECISION INSIGHT 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. + * + * **************************************************************************/ +/* $XFree86$ */ + +/* + * Authors: + * Keith Whitwell <keith@tungstengraphics.com> + * Adapted for use on the I830M: + * Jeff Hartmann <jhartmann@2d3d.com> + */ + + +#include <X11/Xlibint.h> +#include <stdio.h> + + +#include <X11/Xlibint.h> +#include <stdio.h> + +#include "glheader.h" +#include "context.h" +#include "matrix.h" +#include "simple_list.h" + +#include "i830_screen.h" +#include "i830_dri.h" + +#include "i830_state.h" +#include "i830_tex.h" +#include "i830_span.h" +#include "i830_tris.h" +#include "i830_ioctl.h" + +#include "i830_dri.h" + + +static int i830_malloc_proxy_buf(drmBufMapPtr buffers) +{ + char *buffer; + drmBufPtr buf; + int i; + + buffer = Xmalloc(I830_DMA_BUF_SZ); + if(buffer == NULL) return -1; + for(i = 0; i < I830_DMA_BUF_NR; i++) { + buf = &(buffers->list[i]); + buf->address = (drmAddress)buffer; + } + + return 0; +} + +static drmBufMapPtr i830_create_empty_buffers(void) +{ + drmBufMapPtr retval; + + retval = (drmBufMapPtr)Xmalloc(sizeof(drmBufMap)); + if(retval == NULL) return NULL; + memset(retval, 0, sizeof(drmBufMap)); + retval->list = (drmBufPtr)Xmalloc(sizeof(drmBuf) * I830_DMA_BUF_NR); + if(retval->list == NULL) { + Xfree(retval); + return NULL; + } + + memset(retval->list, 0, sizeof(drmBuf) * I830_DMA_BUF_NR); + return retval; +} + +static void i830PrintDRIInfo(i830ScreenPrivate *i830Screen, + __DRIscreenPrivate *sPriv, + I830DRIPtr gDRIPriv) +{ + GLuint size = (gDRIPriv->ringSize + + i830Screen->textureSize + + i830Screen->depth.size + + i830Screen->back.size + + sPriv->fbSize + + I830_DMA_BUF_NR * I830_DMA_BUF_SZ + + 32768 /* Context Memory */ + + 16*4096 /* Ring buffer */ + + 64*1024 /* Scratch buffer */ + + 4096 /* Cursor */); + GLuint size_low = (gDRIPriv->ringSize + + i830Screen->textureSize + + sPriv->fbSize + + I830_DMA_BUF_NR * I830_DMA_BUF_SZ + + 32768 /* Context Memory */ + + 16*4096 /* Ring buffer */ + + 64*1024 /* Scratch buffer */); + + fprintf(stderr, "\nFront size : 0x%x\n", sPriv->fbSize); + fprintf(stderr, "Front offset : 0x%x\n", i830Screen->fbOffset); + fprintf(stderr, "Back size : 0x%x\n", i830Screen->back.size); + fprintf(stderr, "Back offset : 0x%x\n", i830Screen->backOffset); + fprintf(stderr, "Depth size : 0x%x\n", i830Screen->depth.size); + fprintf(stderr, "Depth offset : 0x%x\n", i830Screen->depthOffset); + fprintf(stderr, "Texture size : 0x%x\n", i830Screen->textureSize); + fprintf(stderr, "Texture offset : 0x%x\n", i830Screen->textureOffset); + fprintf(stderr, "Ring offset : 0x%x\n", gDRIPriv->ringOffset); + fprintf(stderr, "Ring size : 0x%x\n", gDRIPriv->ringSize); + fprintf(stderr, "Memory : 0x%x\n", gDRIPriv->mem); + fprintf(stderr, "Used Memory : low(0x%x) high(0x%x)\n", size_low, size); +} + +static GLboolean i830InitDriver(__DRIscreenPrivate *sPriv) +{ + i830ScreenPrivate *i830Screen; + I830DRIPtr gDRIPriv = (I830DRIPtr)sPriv->pDevPriv; + + /* Check the DRI version */ + { + int major, minor, patch; + if (XF86DRIQueryVersion(sPriv->display, &major, &minor, &patch)) { + if (major != 4 || minor < 0) { + __driUtilMessage("i830 DRI driver expected DRI version 4.0.x but got version %d.%d.%d", major, minor, patch); + return GL_FALSE; + } + } + } + + /* Check that the DDX driver version is compatible */ + if (sPriv->ddxMajor != 1 || sPriv->ddxMinor < 0) { + __driUtilMessage("i830 DRI driver expected DDX driver version 1.0.x but got version %d.%d.%d", sPriv->ddxMajor, sPriv->ddxMinor, sPriv->ddxPatch); + return GL_FALSE; + } + + /* Check that the DRM driver version is compatible */ + if (sPriv->drmMajor != 1 || sPriv->drmMinor < 2) { + __driUtilMessage("i830 DRI driver expected DRM driver version 1.2.x but got version %d.%d.%d", sPriv->drmMajor, sPriv->drmMinor, sPriv->drmPatch); + return GL_FALSE; + } + + /* Allocate the private area */ + i830Screen = (i830ScreenPrivate *)Xmalloc(sizeof(i830ScreenPrivate)); + if (!i830Screen) { + if(DEBUGGING) + fprintf(stderr,"\nERROR! Allocating private area failed\n"); + return GL_FALSE; + } + + i830Screen->driScrnPriv = sPriv; + sPriv->private = (void *)i830Screen; + + i830Screen->deviceID = gDRIPriv->deviceID; + i830Screen->width = gDRIPriv->width; + i830Screen->height = gDRIPriv->height; + i830Screen->mem = gDRIPriv->mem; + i830Screen->cpp = gDRIPriv->cpp; + i830Screen->fbStride = gDRIPriv->fbStride; + i830Screen->fbOffset = gDRIPriv->fbOffset; + + switch (gDRIPriv->bitsPerPixel) { + case 15: i830Screen->fbFormat = DV_PF_555; break; + case 16: i830Screen->fbFormat = DV_PF_565; break; + case 32: i830Screen->fbFormat = DV_PF_8888; break; + } + + i830Screen->backOffset = gDRIPriv->backOffset; + i830Screen->depthOffset = gDRIPriv->depthOffset; + i830Screen->backPitch = gDRIPriv->auxPitch; + i830Screen->backPitchBits = gDRIPriv->auxPitchBits; + i830Screen->textureOffset = gDRIPriv->textureOffset; + i830Screen->textureSize = gDRIPriv->textureSize; + i830Screen->logTextureGranularity = gDRIPriv->logTextureGranularity; + + if (DEBUGGING) + fprintf(stderr, "Tex heap size 0x%x, granularity 0x%x bytes\n", + i830Screen->textureSize, + 1 << i830Screen->logTextureGranularity); + + i830Screen->bufs = i830_create_empty_buffers(); + if(i830Screen->bufs == NULL) { + if (DEBUGGING) + fprintf(stderr,"\nERROR: Failed to create empty buffers in %s \n", + __FUNCTION__); + Xfree(i830Screen); + return GL_FALSE; + } + + /* Check if you need to create a fake buffer */ + if(i830_check_copy(sPriv->fd) == 1) { + i830_malloc_proxy_buf(i830Screen->bufs); + i830Screen->use_copy_buf = 1; + } else { + i830Screen->use_copy_buf = 0; + } + + i830Screen->back.handle = gDRIPriv->backbuffer; + i830Screen->back.size = gDRIPriv->backbufferSize; + + if (drmMap(sPriv->fd, + i830Screen->back.handle, + i830Screen->back.size, + (drmAddress *)&i830Screen->back.map) != 0) { + if (DEBUGGING) + fprintf(stderr, "\nERROR: line %d, Function %s, File %s\n", + __LINE__, __FUNCTION__, __FILE__); + Xfree(i830Screen); + sPriv->private = NULL; + return GL_FALSE; + } + + i830Screen->depth.handle = gDRIPriv->depthbuffer; + i830Screen->depth.size = gDRIPriv->depthbufferSize; + + if (drmMap(sPriv->fd, + i830Screen->depth.handle, + i830Screen->depth.size, + (drmAddress *)&i830Screen->depth.map) != 0) { + if (DEBUGGING) + fprintf(stderr, "\nERROR: line %d, Function %s, File %s\n", + __LINE__, __FUNCTION__, __FILE__); + Xfree(i830Screen); + drmUnmap(i830Screen->back.map, i830Screen->back.size); + sPriv->private = NULL; + return GL_FALSE; + } + + i830Screen->tex.handle = gDRIPriv->textures; + i830Screen->tex.size = gDRIPriv->textureSize; + + if (drmMap(sPriv->fd, + i830Screen->tex.handle, + i830Screen->tex.size, + (drmAddress *)&i830Screen->tex.map) != 0) { + if (DEBUGGING) + fprintf(stderr, "\nERROR: line %d, Function %s, File %s\n", + __LINE__, __FUNCTION__, __FILE__); + Xfree(i830Screen); + drmUnmap(i830Screen->back.map, i830Screen->back.size); + drmUnmap(i830Screen->depth.map, i830Screen->depth.size); + sPriv->private = NULL; + return GL_FALSE; + } + + i830Screen->sarea_priv_offset = gDRIPriv->sarea_priv_offset; + if(0) i830PrintDRIInfo(i830Screen, sPriv, gDRIPriv); + return GL_TRUE; +} + + +static void i830DestroyScreen(__DRIscreenPrivate *sPriv) +{ + i830ScreenPrivate *i830Screen = (i830ScreenPrivate *)sPriv->private; + + /* Need to unmap all the bufs and maps here: + */ + drmUnmap(i830Screen->back.map, i830Screen->back.size); + drmUnmap(i830Screen->depth.map, i830Screen->depth.size); + drmUnmap(i830Screen->tex.map, i830Screen->tex.size); + Xfree(i830Screen); + sPriv->private = NULL; +} + +static GLboolean i830CreateBuffer( Display *dpy, + __DRIscreenPrivate *driScrnPriv, + __DRIdrawablePrivate *driDrawPriv, + const __GLcontextModes *mesaVis, + GLboolean isPixmap ) +{ + if (isPixmap) { + return GL_FALSE; /* not implemented */ + } else { +#if 0 + GLboolean swStencil = (mesaVis->stencilBits > 0 && + mesaVis->depthBits != 24); +#else + GLboolean swStencil = mesaVis->stencilBits > 0; +#endif + driDrawPriv->driverPrivate = (void *) + _mesa_create_framebuffer(mesaVis, + GL_FALSE, /* software depth buffer? */ + swStencil, + mesaVis->accumRedBits > 0, + GL_FALSE /* s/w alpha planes */); + + return (driDrawPriv->driverPrivate != NULL); + } +} + +static void i830DestroyBuffer(__DRIdrawablePrivate *driDrawPriv) +{ + _mesa_destroy_framebuffer((GLframebuffer *) (driDrawPriv->driverPrivate)); +} + +#if 0 +GLboolean XMesaCloseFullScreen(__DRIcontextPrivate *driContextPriv) +{ + i830ContextPtr imesa = (i830ContextPtr)driContextPriv->driverPrivate; + + if (imesa->currentPage ==1) { + i830PageFlip(imesa); + imesa->currentPage = 0; + } + + imesa->doPageFlip = GL_FALSE; + imesa->Setup[I830_DESTREG_DI0] = imesa->driScreen->front_offset; + + return GL_TRUE; +} + + +GLboolean XMesaOpenFullScreen(__DRIcontextPrivate *driContextPriv) +{ + i830ContextPtr imesa = (i830ContextPtr)driContextPriv->driverPrivate; + + imesa->doPageFlip = 1; + imesa->currentPage = 0; + + return GL_TRUE; +} + +#else + +static GLboolean i830OpenFullScreen (__DRIcontextPrivate *driContextPriv) +{ + return GL_TRUE; +} + +static GLboolean i830CloseFullScreen (__DRIcontextPrivate *driContextPriv) +{ + return GL_TRUE; +} + +#endif + +static struct __DriverAPIRec i830API = { + i830InitDriver, + i830DestroyScreen, + i830CreateContext, + i830DestroyContext, + i830CreateBuffer, + i830DestroyBuffer, + i830SwapBuffers, + i830MakeCurrent, + i830UnbindContext, + i830OpenFullScreen, + i830CloseFullScreen +}; + +/* + * This is the bootstrap function for the driver. + * The __driCreateScreen name is the symbol that libGL.so fetches. + * Return: pointer to a __DRIscreenPrivate. + */ +void *__driCreateScreen(Display *dpy, int scrn, __DRIscreen *psc, + int numConfigs, __GLXvisualConfig *config) +{ + __DRIscreenPrivate *psp; + psp = __driUtilCreateScreen(dpy, scrn, psc, numConfigs, config, &i830API); + return (void *) psp; +} + diff --git a/xc/lib/GL/mesa/src/drv/i830/i830_screen.h b/xc/lib/GL/mesa/src/drv/i830/i830_screen.h new file mode 100644 index 000000000..ca991c78a --- /dev/null +++ b/xc/lib/GL/mesa/src/drv/i830/i830_screen.h @@ -0,0 +1,115 @@ +/************************************************************************** + +Copyright 1998-1999 Precision Insight, 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 PRECISION INSIGHT 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. + +**************************************************************************/ + +/* + * Authors: + * Keith Whitwell <keith@tungstengraphics.com> + * Adapted for use on the I830M: + * Jeff Hartmann <jhartmann@2d3d.com> + */ + +#ifndef _I830_INIT_H_ +#define _I830_INIT_H_ + +#include <sys/time.h> +#include "dri_util.h" + + +/* All structures go here */ +typedef struct +{ + GLubyte blue; + GLubyte green; + GLubyte red; + GLubyte alpha; +}i830_color; + + + +typedef struct { + drmHandle handle; + drmSize size; + char *map; +} i830Region, *i830RegionPtr; + +typedef struct +{ + + i830Region front; + i830Region back; + i830Region depth; + i830Region tex; + + int deviceID; + int width; + int height; + int mem; + + int cpp; /* for front and back buffers */ + int bitsPerPixel; + + int fbFormat; + int fbOffset; + int fbStride; + + int backOffset; + int depthOffset; + + int backPitch; + int backPitchBits; + + int textureOffset; + int textureSize; + int logTextureGranularity; + + __DRIscreenPrivate *driScrnPriv; + drmBufMapPtr bufs; + int use_copy_buf; + unsigned int sarea_priv_offset; +}i830ScreenPrivate; + + +extern GLboolean +i830CreateContext( Display *dpy, const __GLcontextModes *mesaVis, + __DRIcontextPrivate *driContextPriv, + void *sharedContextPrivate ); + +extern void +i830DestroyContext(__DRIcontextPrivate *driContextPriv); + +extern GLboolean +i830UnbindContext(__DRIcontextPrivate *driContextPriv); + +extern GLboolean +i830MakeCurrent(__DRIcontextPrivate *driContextPriv, + __DRIdrawablePrivate *driDrawPriv, + __DRIdrawablePrivate *driReadPriv); + +extern void +i830SwapBuffers(Display *dpy, void *drawablePrivate); + +#endif diff --git a/xc/lib/GL/mesa/src/drv/i830/i830_span.c b/xc/lib/GL/mesa/src/drv/i830/i830_span.c index b52fd7006..035eb3820 100644 --- a/xc/lib/GL/mesa/src/drv/i830/i830_span.c +++ b/xc/lib/GL/mesa/src/drv/i830/i830_span.c @@ -25,50 +25,57 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. **************************************************************************/ -/* $XFree86: xc/lib/GL/mesa/src/drv/i830/i830_span.c,v 1.1 2001/10/04 18:28:21 alanh Exp $ */ +/* $XFree86$ */ /* * Author: - * Jeff Hartmann <jhartmann@valinux.com> + * Jeff Hartmann <jhartmann@2d3d.com> * * Heavily based on the I810 driver, which was written by: - * Keith Whitwell <keithw@valinux.com> + * Keith Whitwell <keith@tungstengraphics.com> */ -#include "types.h" +#include "glheader.h" +#include "macros.h" +#include "mtypes.h" -#include "i830_drv.h" +#include "i830_screen.h" +#include "i830_dri.h" + +#include "i830_span.h" #include "i830_ioctl.h" +#include "swrast/swrast.h" #define DBG 0 -#define LOCAL_VARS \ - __DRIdrawablePrivate *dPriv = imesa->driDrawable; \ - i830ScreenPrivate *i830Screen = imesa->i830Screen; \ +#define LOCAL_VARS \ + __DRIdrawablePrivate *dPriv = imesa->driDrawable; \ + i830ScreenPrivate *i830Screen = imesa->i830Screen; \ GLuint pitch = i830Screen->backPitch * i830Screen->cpp; \ - GLuint height = dPriv->h; \ - char *buf = (char *)(imesa->drawMap + \ - dPriv->x * i830Screen->cpp + \ - dPriv->y * pitch); \ - char *read_buf = (char *)(imesa->readMap + \ - dPriv->x * i830Screen->cpp + \ - dPriv->y * pitch); \ - GLushort p = I830_CONTEXT( ctx )->MonoColor; \ + GLuint height = dPriv->h; \ + char *buf = (char *)(imesa->drawMap + \ + dPriv->x * i830Screen->cpp + \ + dPriv->y * pitch); \ + char *read_buf = (char *)(imesa->readMap + \ + dPriv->x * i830Screen->cpp + \ + dPriv->y * pitch); \ + GLushort p; \ (void) read_buf; (void) buf; (void) p -#define LOCAL_DEPTH_VARS \ - __DRIdrawablePrivate *dPriv = imesa->driDrawable; \ - i830ScreenPrivate *i830Screen = imesa->i830Screen; \ +#define LOCAL_DEPTH_VARS \ + __DRIdrawablePrivate *dPriv = imesa->driDrawable; \ + i830ScreenPrivate *i830Screen = imesa->i830Screen; \ GLuint pitch = i830Screen->backPitch * i830Screen->cpp; \ - GLuint height = dPriv->h; \ - char *buf = (char *)(i830Screen->depth.map + \ - dPriv->x * i830Screen->cpp + \ + GLuint height = dPriv->h; \ + char *buf = (char *)(i830Screen->depth.map + \ + dPriv->x * i830Screen->cpp + \ dPriv->y * pitch) #define LOCAL_STENCIL_VARS LOCAL_DEPTH_VARS -#define INIT_MONO_PIXEL(p) +#define INIT_MONO_PIXEL(p,color)\ + p = PACK_COLOR_565(color[0],color[1],color[2]) #define CLIPPIXEL(_x,_y) (_x >= minx && _x < maxx && \ _y >= miny && _y < maxy) @@ -86,10 +93,10 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. #define Y_FLIP(_y) (height - _y - 1) -#define HW_LOCK() \ +#define HW_LOCK() \ i830ContextPtr imesa = I830_CONTEXT(ctx); \ - FLUSH_BATCH(imesa); \ - i830DmaFinish(imesa); \ + I830_FIREVERTICES(imesa); \ + i830DmaFinish(imesa); \ LOCK_HARDWARE_QUIESCENT(imesa); #define HW_CLIPLOOP() \ @@ -111,8 +118,6 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. UNLOCK_HARDWARE(imesa); - - /* 16 bit, 565 rgb color spanline and pixel functions */ #define WRITE_RGBA( _x, _y, r, g, b, a ) \ @@ -167,7 +172,6 @@ do { \ #define READ_DEPTH( d, _x, _y ) \ d = *(GLushort *)(buf + _x*2 + _y*pitch); -/* d = 0xffff; */ #define TAG(x) i830##x##_16 #include "depthtmp.h" @@ -188,6 +192,9 @@ do { \ GLuint p = I830_CONTEXT( ctx )->MonoColor; \ (void) read_buf; (void) buf; (void) p +#undef INIT_MONO_PIXEL +#define INIT_MONO_PIXEL(p,color)\ + p = PACK_COLOR_888(color[0],color[1],color[2]) /* 32 bit, 8888 argb color spanline and pixel functions */ @@ -258,76 +265,90 @@ do { \ #define TAG(x) i830##x##_24_8 #include "stenciltmp.h" +static void i830SetReadBuffer(GLcontext *ctx, GLframebuffer *colorBuffer, + GLenum mode) +{ + i830ContextPtr imesa = I830_CONTEXT(ctx); + if (mode == GL_FRONT_LEFT) { + imesa->readMap = (char*)imesa->driScreen->pFB; + } else if (mode == GL_BACK_LEFT) { + imesa->readMap = imesa->i830Screen->back.map; + } else { + ASSERT(0); + } +} + + void i830DDInitSpanFuncs( GLcontext *ctx ) { i830ContextPtr imesa = I830_CONTEXT(ctx); i830ScreenPrivate *i830Screen = imesa->i830Screen; + struct swrast_device_driver *swdd = _swrast_GetDeviceDriverReference(ctx); + if (DEBUGGING) + fprintf(stderr,"\nInitialising SPAN funcs\n"); + + swdd->SetReadBuffer = i830SetReadBuffer; + switch (i830Screen->fbFormat) { case DV_PF_555: - ctx->Driver.WriteRGBASpan = i830WriteRGBASpan_555; - ctx->Driver.WriteRGBSpan = i830WriteRGBSpan_555; - ctx->Driver.WriteMonoRGBASpan = i830WriteMonoRGBASpan_555; - ctx->Driver.WriteRGBAPixels = i830WriteRGBAPixels_555; - ctx->Driver.WriteMonoRGBAPixels = i830WriteMonoRGBAPixels_555; - ctx->Driver.ReadRGBASpan = i830ReadRGBASpan_555; - ctx->Driver.ReadRGBAPixels = i830ReadRGBAPixels_555; - - ctx->Driver.ReadDepthSpan = i830ReadDepthSpan_16; - ctx->Driver.WriteDepthSpan = i830WriteDepthSpan_16; - ctx->Driver.ReadDepthPixels = i830ReadDepthPixels_16; - ctx->Driver.WriteDepthPixels = i830WriteDepthPixels_16; + swdd->WriteRGBASpan = i830WriteRGBASpan_555; + swdd->WriteRGBSpan = i830WriteRGBSpan_555; + swdd->WriteMonoRGBASpan = i830WriteMonoRGBASpan_555; + swdd->WriteRGBAPixels = i830WriteRGBAPixels_555; + swdd->WriteMonoRGBAPixels = i830WriteMonoRGBAPixels_555; + swdd->ReadRGBASpan = i830ReadRGBASpan_555; + swdd->ReadRGBAPixels = i830ReadRGBAPixels_555; + + swdd->ReadDepthSpan = i830ReadDepthSpan_16; + swdd->WriteDepthSpan = i830WriteDepthSpan_16; + swdd->ReadDepthPixels = i830ReadDepthPixels_16; + swdd->WriteDepthPixels = i830WriteDepthPixels_16; break; case DV_PF_565: - ctx->Driver.WriteRGBASpan = i830WriteRGBASpan_565; - ctx->Driver.WriteRGBSpan = i830WriteRGBSpan_565; - ctx->Driver.WriteMonoRGBASpan = i830WriteMonoRGBASpan_565; - ctx->Driver.WriteRGBAPixels = i830WriteRGBAPixels_565; - ctx->Driver.WriteMonoRGBAPixels = i830WriteMonoRGBAPixels_565; - ctx->Driver.ReadRGBASpan = i830ReadRGBASpan_565; - ctx->Driver.ReadRGBAPixels = i830ReadRGBAPixels_565; - - ctx->Driver.ReadDepthSpan = i830ReadDepthSpan_16; - ctx->Driver.WriteDepthSpan = i830WriteDepthSpan_16; - ctx->Driver.ReadDepthPixels = i830ReadDepthPixels_16; - ctx->Driver.WriteDepthPixels = i830WriteDepthPixels_16; + swdd->WriteRGBASpan = i830WriteRGBASpan_565; + swdd->WriteRGBSpan = i830WriteRGBSpan_565; + swdd->WriteMonoRGBASpan = i830WriteMonoRGBASpan_565; + swdd->WriteRGBAPixels = i830WriteRGBAPixels_565; + swdd->WriteMonoRGBAPixels = i830WriteMonoRGBAPixels_565; + swdd->ReadRGBASpan = i830ReadRGBASpan_565; + swdd->ReadRGBAPixels = i830ReadRGBAPixels_565; + + swdd->ReadDepthSpan = i830ReadDepthSpan_16; + swdd->WriteDepthSpan = i830WriteDepthSpan_16; + swdd->ReadDepthPixels = i830ReadDepthPixels_16; + swdd->WriteDepthPixels = i830WriteDepthPixels_16; break; case DV_PF_8888: - ctx->Driver.WriteRGBASpan = i830WriteRGBASpan_8888; - ctx->Driver.WriteRGBSpan = i830WriteRGBSpan_8888; - ctx->Driver.WriteMonoRGBASpan = i830WriteMonoRGBASpan_8888; - ctx->Driver.WriteRGBAPixels = i830WriteRGBAPixels_8888; - ctx->Driver.WriteMonoRGBAPixels = i830WriteMonoRGBAPixels_8888; - ctx->Driver.ReadRGBASpan = i830ReadRGBASpan_8888; - ctx->Driver.ReadRGBAPixels = i830ReadRGBAPixels_8888; + swdd->WriteRGBASpan = i830WriteRGBASpan_8888; + swdd->WriteRGBSpan = i830WriteRGBSpan_8888; + swdd->WriteMonoRGBASpan = i830WriteMonoRGBASpan_8888; + swdd->WriteRGBAPixels = i830WriteRGBAPixels_8888; + swdd->WriteMonoRGBAPixels = i830WriteMonoRGBAPixels_8888; + swdd->ReadRGBASpan = i830ReadRGBASpan_8888; + swdd->ReadRGBAPixels = i830ReadRGBAPixels_8888; if(imesa->hw_stencil) { - ctx->Driver.ReadDepthSpan = i830ReadDepthSpan_24_8; - ctx->Driver.WriteDepthSpan = i830WriteDepthSpan_24_8; - ctx->Driver.ReadDepthPixels = i830ReadDepthPixels_24_8; - ctx->Driver.WriteDepthPixels = i830WriteDepthPixels_24_8; - - ctx->Driver.WriteStencilSpan = i830WriteStencilSpan_24_8; - ctx->Driver.ReadStencilSpan = i830ReadStencilSpan_24_8; - ctx->Driver.WriteStencilPixels = i830WriteStencilPixels_24_8; - ctx->Driver.ReadStencilPixels = i830ReadStencilPixels_24_8; + swdd->ReadDepthSpan = i830ReadDepthSpan_24_8; + swdd->WriteDepthSpan = i830WriteDepthSpan_24_8; + swdd->ReadDepthPixels = i830ReadDepthPixels_24_8; + swdd->WriteDepthPixels = i830WriteDepthPixels_24_8; + + swdd->WriteStencilSpan = i830WriteStencilSpan_24_8; + swdd->ReadStencilSpan = i830ReadStencilSpan_24_8; + swdd->WriteStencilPixels = i830WriteStencilPixels_24_8; + swdd->ReadStencilPixels = i830ReadStencilPixels_24_8; } else { - ctx->Driver.ReadDepthSpan = i830ReadDepthSpan_24; - ctx->Driver.WriteDepthSpan = i830WriteDepthSpan_24; - ctx->Driver.ReadDepthPixels = i830ReadDepthPixels_24; - ctx->Driver.WriteDepthPixels = i830WriteDepthPixels_24; + swdd->ReadDepthSpan = i830ReadDepthSpan_24; + swdd->WriteDepthSpan = i830WriteDepthSpan_24; + swdd->ReadDepthPixels = i830ReadDepthPixels_24; + swdd->WriteDepthPixels = i830WriteDepthPixels_24; } break; } - - ctx->Driver.WriteCI8Span =NULL; - ctx->Driver.WriteCI32Span =NULL; - ctx->Driver.WriteMonoCISpan =NULL; - ctx->Driver.WriteCI32Pixels =NULL; - ctx->Driver.WriteMonoCIPixels =NULL; - ctx->Driver.ReadCI32Span =NULL; - ctx->Driver.ReadCI32Pixels =NULL; + if (DEBUGGING) + fprintf(stderr,"\nFinished initialising SPAN funcs\n"); } diff --git a/xc/lib/GL/mesa/src/drv/i830/i830_span.h b/xc/lib/GL/mesa/src/drv/i830/i830_span.h new file mode 100644 index 000000000..295bf2838 --- /dev/null +++ b/xc/lib/GL/mesa/src/drv/i830/i830_span.h @@ -0,0 +1,43 @@ +/************************************************************************** + +Copyright 2001 VA Linux Systems Inc., Fremont, California. + +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 +on 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 +ATI, VA LINUX SYSTEMS AND/OR THEIR 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. + +**************************************************************************/ + +/* $XFree86$ */ + +/* + * Author: + * Jeff Hartmann <jhartmann@2d3d.com> + * + * Heavily based on the I810 driver, which was written by: + * Keith Whitwell <keith@tungstengraphics.com> + */ + +#ifndef _I830_SPAN_H +#define _I830_SPAN_H + +extern void i830DDInitSpanFuncs( GLcontext *ctx ); + +#endif diff --git a/xc/lib/GL/mesa/src/drv/i830/i830_state.c b/xc/lib/GL/mesa/src/drv/i830/i830_state.c index 94aa702d4..68ad5de16 100644 --- a/xc/lib/GL/mesa/src/drv/i830/i830_state.c +++ b/xc/lib/GL/mesa/src/drv/i830/i830_state.c @@ -1,6 +1,6 @@ /************************************************************************** -Copyright 2001 VA Linux Systems Inc., Fremont, California. +Copyright 2001 2d3d Inc., Delray Beach, FL All Rights Reserved. @@ -25,30 +25,42 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. **************************************************************************/ -/* $XFree86: xc/lib/GL/mesa/src/drv/i830/i830_state.c,v 1.1 2001/10/04 18:28:21 alanh Exp $ */ +/* $XFree86$ */ /* * Author: - * Jeff Hartmann <jhartmann@valinux.com> + * Jeff Hartmann <jhartmann@2d3d.com> * * Heavily based on the I810 driver, which was written by: - * Keith Whitwell <keithw@valinux.com> + * Keith Whitwell <keith@tungstengraphics.com> */ - #include <stdio.h> -#include "types.h" +#include "glheader.h" +#include "context.h" +#include "macros.h" #include "enums.h" -#include "pb.h" #include "dd.h" #include "mm.h" -#include "i830_drv.h" +#include "i830_screen.h" +#include "i830_dri.h" + +#include "i830_context.h" +#include "i830_state.h" +#include "i830_tex.h" +#include "i830_vb.h" #include "i830_tris.h" #include "i830_ioctl.h" -/* Need to add other formats */ +#include "swrast/swrast.h" +#include "array_cache/acache.h" +#include "tnl/tnl.h" +#include "swrast_setup/swrast_setup.h" + +#include "tnl/t_pipeline.h" + static __inline__ GLuint i830PackColor(GLuint format, GLubyte r, GLubyte g, GLubyte b, GLubyte a) @@ -70,109 +82,72 @@ static __inline__ GLuint i830PackColor(GLuint format, } } -static void i830DDPointSize(GLcontext *ctx, GLfloat size) +static void i830StencilFunc(GLcontext *ctx, GLenum func, GLint ref, + GLuint mask) { i830ContextPtr imesa = I830_CONTEXT(ctx); - GLint point_size = FloatToInt(size); - - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s\n", __FUNCTION__); - - FLUSH_BATCH(imesa); - CLAMP_SELF(point_size, 1, 256); - imesa->dirty |= I830_UPLOAD_CTX; - imesa->Setup[I830_CTXREG_STATE5] &= ~FIXED_POINT_WIDTH_MASK; - imesa->Setup[I830_CTXREG_STATE5] |= (ENABLE_FIXED_POINT_WIDTH | - FIXED_POINT_WIDTH(point_size)); -} - -static void i830DDStencilFunc(GLcontext *ctx, GLenum func, GLint ref, - GLuint mask) -{ - i830ContextPtr imesa = I830_CONTEXT(ctx); - GLuint v_mask, w_mask; int test = 0; + mask = mask & 0xff; if(I830_DEBUG&DEBUG_VERBOSE_TRACE) fprintf(stderr, "%s : func: %s, ref : 0x%x, mask: 0x%x\n", __FUNCTION__, - gl_lookup_enum_by_nr(func), ref, mask); - - FLUSH_BATCH(imesa); - - v_mask = ctx->Stencil.ValueMask & 0xff; - w_mask = ctx->Stencil.WriteMask & 0xff; + _mesa_lookup_enum_by_nr(func), ref, mask); switch(func) { case GL_NEVER: test = COMPAREFUNC_NEVER; break; case GL_LESS: test = COMPAREFUNC_LESS; break; - case GL_EQUAL: test = COMPAREFUNC_EQUAL; break; case GL_LEQUAL: test = COMPAREFUNC_LEQUAL; break; case GL_GREATER: test = COMPAREFUNC_GREATER; break; - case GL_NOTEQUAL: test = COMPAREFUNC_NOTEQUAL; break; case GL_GEQUAL: test = COMPAREFUNC_GEQUAL; break; + case GL_NOTEQUAL: test = COMPAREFUNC_NOTEQUAL; break; + case GL_EQUAL: test = COMPAREFUNC_EQUAL; break; case GL_ALWAYS: test = COMPAREFUNC_ALWAYS; break; - default: break; + default: return; } - imesa->dirty |= I830_UPLOAD_CTX; + I830_STATECHANGE(imesa, I830_UPLOAD_CTX); imesa->Setup[I830_CTXREG_STATE4] &= ~MODE4_ENABLE_STENCIL_MASK; imesa->Setup[I830_CTXREG_STATE4] |= (ENABLE_STENCIL_TEST_MASK | - ENABLE_STENCIL_WRITE_MASK | - STENCIL_TEST_MASK(v_mask) | - STENCIL_WRITE_MASK(w_mask)); + ENABLE_STENCIL_WRITE_MASK | + STENCIL_TEST_MASK(mask) | + STENCIL_WRITE_MASK(mask)); imesa->Setup[I830_CTXREG_STENCILTST] &= ~(STENCIL_REF_VALUE_MASK | - ENABLE_STENCIL_TEST_FUNC_MASK); + ENABLE_STENCIL_TEST_FUNC_MASK); imesa->Setup[I830_CTXREG_STENCILTST] |= (ENABLE_STENCIL_REF_VALUE | - ENABLE_STENCIL_TEST_FUNC | - STENCIL_REF_VALUE(ref) | - STENCIL_TEST_FUNC(test)); - - if(I830_DEBUG&DEBUG_VERBOSE_STATE) - fprintf(stderr, "%s : state4 : 0x%x, stentst : 0x%x\n", __FUNCTION__, - imesa->Setup[I830_CTXREG_STATE4], - imesa->Setup[I830_CTXREG_STENCILTST]); + ENABLE_STENCIL_TEST_FUNC | + STENCIL_REF_VALUE(ref) | + STENCIL_TEST_FUNC(test)); } -static void i830DDStencilMask(GLcontext *ctx, GLuint mask) +static void i830StencilMask(GLcontext *ctx, GLuint mask) { i830ContextPtr imesa = I830_CONTEXT(ctx); - GLuint v_mask, w_mask; - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) fprintf(stderr, "%s : mask 0x%x\n", __FUNCTION__, mask); - FLUSH_BATCH(imesa); - - v_mask = ctx->Stencil.ValueMask & 0xff; - w_mask = ctx->Stencil.WriteMask & 0xff; - - imesa->dirty |= I830_UPLOAD_CTX; + mask = mask & 0xff; + I830_STATECHANGE(imesa, I830_UPLOAD_CTX); imesa->Setup[I830_CTXREG_STATE4] &= ~MODE4_ENABLE_STENCIL_MASK; imesa->Setup[I830_CTXREG_STATE4] |= (ENABLE_STENCIL_TEST_MASK | - ENABLE_STENCIL_WRITE_MASK | - STENCIL_TEST_MASK(v_mask) | - STENCIL_WRITE_MASK(w_mask)); - if(I830_DEBUG&DEBUG_VERBOSE_STATE) - fprintf(stderr, "%s : state4 : 0x%x\n", __FUNCTION__, - imesa->Setup[I830_CTXREG_STATE4]); + ENABLE_STENCIL_WRITE_MASK | + STENCIL_TEST_MASK(mask) | + STENCIL_WRITE_MASK(mask)); } -static void i830DDStencilOp(GLcontext *ctx, GLenum fail, GLenum zfail, - GLenum zpass) +static void i830StencilOp(GLcontext *ctx, GLenum fail, GLenum zfail, + GLenum zpass) { i830ContextPtr imesa = I830_CONTEXT(ctx); int fop, dfop, dpop; if(I830_DEBUG&DEBUG_VERBOSE_TRACE) fprintf(stderr, "%s: fail : %s, zfail: %s, zpass : %s\n", __FUNCTION__, - gl_lookup_enum_by_nr(fail), - gl_lookup_enum_by_nr(zfail), - gl_lookup_enum_by_nr(zpass)); - - FLUSH_BATCH(imesa); + _mesa_lookup_enum_by_nr(fail), + _mesa_lookup_enum_by_nr(zfail), + _mesa_lookup_enum_by_nr(zpass)); fop = 0; dfop = 0; dpop = 0; @@ -204,59 +179,39 @@ static void i830DDStencilOp(GLcontext *ctx, GLenum fail, GLenum zfail, default: break; } - imesa->dirty |= I830_UPLOAD_CTX; + + I830_STATECHANGE(imesa, I830_UPLOAD_CTX); imesa->Setup[I830_CTXREG_STENCILTST] &= ~(STENCIL_OPS_MASK); imesa->Setup[I830_CTXREG_STENCILTST] |= (ENABLE_STENCIL_PARMS | - STENCIL_FAIL_OP(fop) | - STENCIL_PASS_DEPTH_FAIL_OP(dfop) | - STENCIL_PASS_DEPTH_PASS_OP(dpop)); + STENCIL_FAIL_OP(fop) | + STENCIL_PASS_DEPTH_FAIL_OP(dfop) | + STENCIL_PASS_DEPTH_PASS_OP(dpop)); if(I830_DEBUG&DEBUG_VERBOSE_STATE) fprintf(stderr, "%s : stentst : 0x%x\n", __FUNCTION__, imesa->Setup[I830_CTXREG_STENCILTST]); - } -static void i830DDAlphaFunc(GLcontext *ctx, GLenum func, GLclampf ref) +static void i830AlphaFunc(GLcontext *ctx, GLenum func, GLchan ref) { i830ContextPtr imesa = I830_CONTEXT(ctx); int test = 0; GLubyte tmp_ref; - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s %s\n", __FUNCTION__, gl_lookup_enum_by_nr(func)); - FLOAT_COLOR_TO_UBYTE_COLOR(tmp_ref, ref); - FLUSH_BATCH(imesa); - switch(func) { - case GL_NEVER: - test = COMPAREFUNC_NEVER; - break; - case GL_LESS: - test = COMPAREFUNC_LESS; - break; - case GL_LEQUAL: - test = COMPAREFUNC_LEQUAL; - break; - case GL_GREATER: - test = COMPAREFUNC_GREATER; - break; - case GL_GEQUAL: - test = COMPAREFUNC_GEQUAL; - break; - case GL_NOTEQUAL: - test = COMPAREFUNC_NOTEQUAL; - break; - case GL_EQUAL: - test = COMPAREFUNC_EQUAL; - break; - case GL_ALWAYS: - test = COMPAREFUNC_ALWAYS; - break; + case GL_NEVER: test = COMPAREFUNC_NEVER; break; + case GL_LESS: test = COMPAREFUNC_LESS; break; + case GL_LEQUAL: test = COMPAREFUNC_LEQUAL; break; + case GL_GREATER: test = COMPAREFUNC_GREATER; break; + case GL_GEQUAL: test = COMPAREFUNC_GEQUAL; break; + case GL_NOTEQUAL: test = COMPAREFUNC_NOTEQUAL; break; + case GL_EQUAL: test = COMPAREFUNC_EQUAL; break; + case GL_ALWAYS: test = COMPAREFUNC_ALWAYS; break; default: return; } - imesa->dirty |= I830_UPLOAD_CTX; + + I830_STATECHANGE(imesa, I830_UPLOAD_CTX); imesa->Setup[I830_CTXREG_STATE2] &= ~ALPHA_TEST_REF_MASK; imesa->Setup[I830_CTXREG_STATE2] |= (ENABLE_ALPHA_TEST_FUNC | ENABLE_ALPHA_REF_VALUE | @@ -274,10 +229,9 @@ static void i830EvalLogicOpBlendState(GLcontext *ctx) { i830ContextPtr imesa = I830_CONTEXT(ctx); - FLUSH_BATCH(imesa); - imesa->dirty |= I830_UPLOAD_CTX; + I830_STATECHANGE(imesa, I830_UPLOAD_CTX); - if(ctx->Color.ColorLogicOpEnabled || ctx->Color.IndexLogicOpEnabled) { + if(ctx->Color.ColorLogicOpEnabled) { imesa->Setup[I830_CTXREG_ENABLES_1] &= ~(ENABLE_COLOR_BLEND | ENABLE_LOGIC_OP_MASK); imesa->Setup[I830_CTXREG_ENABLES_1] |= (DISABLE_COLOR_BLEND | @@ -305,19 +259,38 @@ static void i830EvalLogicOpBlendState(GLcontext *ctx) } } -static void i830DDBlendEquation(GLcontext *ctx, GLenum mode) +static void i830BlendColor(GLcontext *ctx, const GLfloat color[4]) +{ + i830ContextPtr imesa = I830_CONTEXT(ctx); + GLubyte r, g, b, a; + + if(I830_DEBUG&DEBUG_VERBOSE_TRACE) + fprintf(stderr, "%s\n", __FUNCTION__); + + FLOAT_COLOR_TO_UBYTE_COLOR(r, color[RCOMP]); + FLOAT_COLOR_TO_UBYTE_COLOR(g, color[GCOMP]); + FLOAT_COLOR_TO_UBYTE_COLOR(b, color[BCOMP]); + FLOAT_COLOR_TO_UBYTE_COLOR(a, color[ACOMP]); + + I830_STATECHANGE(imesa, I830_UPLOAD_CTX); + imesa->Setup[I830_CTXREG_BLENDCOLR] = ((a << 24) | + (r << 16) | + (g << 8) | + b); +} + +static void i830BlendEquation(GLcontext *ctx, GLenum mode) { i830ContextPtr imesa = I830_CONTEXT(ctx); int func = ENABLE_ALPHA_BLENDFUNC; if(I830_DEBUG&DEBUG_VERBOSE_TRACE) fprintf(stderr, "%s %s\n", __FUNCTION__, - gl_lookup_enum_by_nr(mode)); + _mesa_lookup_enum_by_nr(mode)); + /* This will catch a logicop blend equation */ i830EvalLogicOpBlendState(ctx); - FLUSH_BATCH(imesa); - switch(mode) { case GL_FUNC_ADD_EXT: func |= BLENDFUNC_ADD; break; case GL_MIN_EXT: func |= BLENDFUNC_MIN; break; @@ -326,37 +299,89 @@ static void i830DDBlendEquation(GLcontext *ctx, GLenum mode) case GL_FUNC_REVERSE_SUBTRACT_EXT: func |= BLENDFUNC_RVRSE_SUB; break; default: return; } - - imesa->dirty |= I830_UPLOAD_CTX; + + I830_STATECHANGE(imesa, I830_UPLOAD_CTX); imesa->Setup[I830_CTXREG_STATE1] &= ~BLENDFUNC_MASK; imesa->Setup[I830_CTXREG_STATE1] |= func; + if (0) fprintf(stderr, "%s : STATE1 : 0x%08x\n", + __FUNCTION__, + imesa->Setup[I830_CTXREG_STATE1]); } -static void i830DDBlendConstColor(GLcontext *ctx, GLfloat red, - GLfloat green, GLfloat blue, - GLfloat alpha) +static void i830BlendFunc(GLcontext *ctx, GLenum sfactor, GLenum dfactor) { i830ContextPtr imesa = I830_CONTEXT(ctx); - GLubyte r, g, b, a; + int func = (ENABLE_SRC_BLND_FACTOR|ENABLE_DST_BLND_FACTOR); if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s\n", __FUNCTION__); + fprintf(stderr, "%s %s %s\n", __FUNCTION__, + _mesa_lookup_enum_by_nr(sfactor), + _mesa_lookup_enum_by_nr(dfactor)); - FLOAT_COLOR_TO_UBYTE_COLOR(r, red); - FLOAT_COLOR_TO_UBYTE_COLOR(g, green); - FLOAT_COLOR_TO_UBYTE_COLOR(b, blue); - FLOAT_COLOR_TO_UBYTE_COLOR(a, alpha); + switch(sfactor) { + case GL_ZERO: func |= SRC_BLND_FACT(BLENDFACT_ZERO); break; + case GL_SRC_ALPHA: func |= SRC_BLND_FACT(BLENDFACT_SRC_ALPHA); break; + case GL_ONE: func |= SRC_BLND_FACT(BLENDFACT_ONE); break; + case GL_DST_COLOR: func |= SRC_BLND_FACT(BLENDFACT_DST_COLR); break; + case GL_ONE_MINUS_DST_COLOR: + func |= SRC_BLND_FACT(BLENDFACT_INV_DST_COLR); break; + case GL_ONE_MINUS_SRC_ALPHA: + func |= SRC_BLND_FACT(BLENDFACT_INV_SRC_ALPHA); break; + case GL_DST_ALPHA: func |= SRC_BLND_FACT(BLENDFACT_DST_ALPHA); break; + case GL_ONE_MINUS_DST_ALPHA: + func |= SRC_BLND_FACT(BLENDFACT_INV_DST_ALPHA); break; + case GL_SRC_ALPHA_SATURATE: + func |= SRC_BLND_FACT(BLENDFACT_SRC_ALPHA_SATURATE); + break; + case GL_CONSTANT_COLOR_EXT: + func |= SRC_BLND_FACT(BLENDFACT_CONST_COLOR); break; + case GL_ONE_MINUS_CONSTANT_COLOR_EXT: + func |= SRC_BLND_FACT(BLENDFACT_INV_CONST_COLOR); + break; + case GL_CONSTANT_ALPHA_EXT: + func |= SRC_BLND_FACT(BLENDFACT_CONST_ALPHA); break; + case GL_ONE_MINUS_CONSTANT_ALPHA_EXT: + func |= SRC_BLND_FACT(BLENDFACT_INV_CONST_ALPHA); + break; + default: return; + } - imesa->dirty |= I830_UPLOAD_CTX; - imesa->Setup[I830_CTXREG_BLENDCOLR] = ((a << 24) | - (r << 16) | - (g << 8) | - b); + switch(dfactor) { + case GL_SRC_ALPHA: func |= DST_BLND_FACT(BLENDFACT_SRC_ALPHA); break; + case GL_ONE_MINUS_SRC_ALPHA: + func |= DST_BLND_FACT(BLENDFACT_INV_SRC_ALPHA); break; + case GL_ZERO: func |= DST_BLND_FACT(BLENDFACT_ZERO); break; + case GL_ONE: func |= DST_BLND_FACT(BLENDFACT_ONE); break; + case GL_SRC_COLOR: func |= DST_BLND_FACT(BLENDFACT_SRC_COLR); break; + case GL_ONE_MINUS_SRC_COLOR: + func |= DST_BLND_FACT(BLENDFACT_INV_SRC_COLR); break; + case GL_DST_ALPHA: func |= DST_BLND_FACT(BLENDFACT_DST_ALPHA); break; + case GL_ONE_MINUS_DST_ALPHA: + func |= DST_BLND_FACT(BLENDFACT_INV_DST_ALPHA); break; + case GL_CONSTANT_COLOR_EXT: + func |= DST_BLND_FACT(BLENDFACT_CONST_COLOR); break; + case GL_ONE_MINUS_CONSTANT_COLOR_EXT: + func |= DST_BLND_FACT(BLENDFACT_INV_CONST_COLOR); + break; + case GL_CONSTANT_ALPHA_EXT: + func |= DST_BLND_FACT(BLENDFACT_CONST_ALPHA); break; + case GL_ONE_MINUS_CONSTANT_ALPHA_EXT: + func |= DST_BLND_FACT(BLENDFACT_INV_CONST_ALPHA); + break; + default: return; + } + + I830_STATECHANGE(imesa, I830_UPLOAD_CTX); + imesa->Setup[I830_CTXREG_IALPHAB] &= ~SRC_DST_ABLEND_MASK; + imesa->Setup[I830_CTXREG_STATE1] &= ~SRC_DST_BLND_MASK; + imesa->Setup[I830_CTXREG_STATE1] |= func; + /* Insure Independant Alpha Blend is really disabled. */ + i830EvalLogicOpBlendState(ctx); } -static void i830DDBlendFuncSeparate(GLcontext *ctx, GLenum sfactorRGB, - GLenum dfactorRGB, GLenum sfactorA, - GLenum dfactorA ) +static void i830BlendFuncSeparate(GLcontext *ctx, GLenum sfactorRGB, + GLenum dfactorRGB, GLenum sfactorA, + GLenum dfactorA ) { i830ContextPtr imesa = I830_CONTEXT(ctx); int funcA = (ENABLE_SRC_ABLEND_FACTOR|ENABLE_DST_ABLEND_FACTOR); @@ -365,8 +390,6 @@ static void i830DDBlendFuncSeparate(GLcontext *ctx, GLenum sfactorRGB, if(I830_DEBUG&DEBUG_VERBOSE_TRACE) fprintf(stderr, "%s\n", __FUNCTION__); - FLUSH_BATCH(imesa); - switch(sfactorA) { case GL_ZERO: funcA |= SRC_ABLEND_FACT(BLENDFACT_ZERO); break; case GL_SRC_ALPHA: funcA |= SRC_ABLEND_FACT(BLENDFACT_SRC_ALPHA); break; @@ -472,91 +495,19 @@ static void i830DDBlendFuncSeparate(GLcontext *ctx, GLenum sfactorRGB, default: return; } - imesa->dirty |= I830_UPLOAD_CTX; + I830_STATECHANGE(imesa, I830_UPLOAD_CTX); imesa->Setup[I830_CTXREG_IALPHAB] &= ~SRC_DST_ABLEND_MASK; imesa->Setup[I830_CTXREG_IALPHAB] |= funcA; imesa->Setup[I830_CTXREG_STATE1] &= ~SRC_DST_BLND_MASK; imesa->Setup[I830_CTXREG_STATE1] |= funcRGB; - /* Insure Independant Alpha Blend is really enabled if need be */ - i830EvalLogicOpBlendState(ctx); -} - -static void i830DDBlendFunc(GLcontext *ctx, GLenum sfactor, GLenum dfactor) -{ - i830ContextPtr imesa = I830_CONTEXT(ctx); - int func = (ENABLE_SRC_BLND_FACTOR|ENABLE_DST_BLND_FACTOR); - - FLUSH_BATCH(imesa); - - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s %s %s\n", __FUNCTION__, - gl_lookup_enum_by_nr(sfactor), - gl_lookup_enum_by_nr(dfactor)); - - switch(sfactor) { - case GL_ZERO: func |= SRC_BLND_FACT(BLENDFACT_ZERO); break; - case GL_SRC_ALPHA: func |= SRC_BLND_FACT(BLENDFACT_SRC_ALPHA); break; - case GL_ONE: func |= SRC_BLND_FACT(BLENDFACT_ONE); break; - case GL_DST_COLOR: func |= SRC_BLND_FACT(BLENDFACT_DST_COLR); break; - case GL_ONE_MINUS_DST_COLOR: - func |= SRC_BLND_FACT(BLENDFACT_INV_DST_COLR); break; - case GL_ONE_MINUS_SRC_ALPHA: - func |= SRC_BLND_FACT(BLENDFACT_INV_SRC_ALPHA); break; - case GL_DST_ALPHA: func |= SRC_BLND_FACT(BLENDFACT_DST_ALPHA); break; - case GL_ONE_MINUS_DST_ALPHA: - func |= SRC_BLND_FACT(BLENDFACT_INV_DST_ALPHA); break; - case GL_SRC_ALPHA_SATURATE: - func |= SRC_BLND_FACT(BLENDFACT_SRC_ALPHA_SATURATE); - break; - case GL_CONSTANT_COLOR_EXT: - func |= SRC_BLND_FACT(BLENDFACT_CONST_COLOR); break; - case GL_ONE_MINUS_CONSTANT_COLOR_EXT: - func |= SRC_BLND_FACT(BLENDFACT_INV_CONST_COLOR); - break; - case GL_CONSTANT_ALPHA_EXT: - func |= SRC_BLND_FACT(BLENDFACT_CONST_ALPHA); break; - case GL_ONE_MINUS_CONSTANT_ALPHA_EXT: - func |= SRC_BLND_FACT(BLENDFACT_INV_CONST_ALPHA); - break; - default: return; - } - switch(dfactor) { - case GL_SRC_ALPHA: func |= DST_BLND_FACT(BLENDFACT_SRC_ALPHA); break; - case GL_ONE_MINUS_SRC_ALPHA: - func |= DST_BLND_FACT(BLENDFACT_INV_SRC_ALPHA); break; - case GL_ZERO: func |= DST_BLND_FACT(BLENDFACT_ZERO); break; - case GL_ONE: func |= DST_BLND_FACT(BLENDFACT_ONE); break; - case GL_SRC_COLOR: func |= DST_BLND_FACT(BLENDFACT_SRC_COLR); break; - case GL_ONE_MINUS_SRC_COLOR: - func |= DST_BLND_FACT(BLENDFACT_INV_SRC_COLR); break; - case GL_DST_ALPHA: func |= DST_BLND_FACT(BLENDFACT_DST_ALPHA); break; - case GL_ONE_MINUS_DST_ALPHA: - func |= DST_BLND_FACT(BLENDFACT_INV_DST_ALPHA); break; - case GL_CONSTANT_COLOR_EXT: - func |= DST_BLND_FACT(BLENDFACT_CONST_COLOR); break; - case GL_ONE_MINUS_CONSTANT_COLOR_EXT: - func |= DST_BLND_FACT(BLENDFACT_INV_CONST_COLOR); - break; - case GL_CONSTANT_ALPHA_EXT: - func |= DST_BLND_FACT(BLENDFACT_CONST_ALPHA); break; - case GL_ONE_MINUS_CONSTANT_ALPHA_EXT: - func |= DST_BLND_FACT(BLENDFACT_INV_CONST_ALPHA); - break; - default: return; - } - - imesa->dirty |= I830_UPLOAD_CTX; - imesa->Setup[I830_CTXREG_IALPHAB] &= ~SRC_DST_ABLEND_MASK; - imesa->Setup[I830_CTXREG_STATE1] &= ~SRC_DST_BLND_MASK; - imesa->Setup[I830_CTXREG_STATE1] |= func; - /* Insure Independant Alpha Blend is really disabled if need be */ + /* Insure Independant Alpha Blend is really enabled if + * Blending is already enabled. + */ i830EvalLogicOpBlendState(ctx); - - if(0) fprintf(stderr, "STATE1 : 0x%x\n", imesa->Setup[I830_CTXREG_STATE1]); } -static void i830DDDepthFunc(GLcontext *ctx, GLenum func) +static void i830DepthFunc(GLcontext *ctx, GLenum func) { i830ContextPtr imesa = I830_CONTEXT(ctx); int test = 0; @@ -564,52 +515,33 @@ static void i830DDDepthFunc(GLcontext *ctx, GLenum func) if(I830_DEBUG&DEBUG_VERBOSE_TRACE) fprintf(stderr, "%s\n", __FUNCTION__); - FLUSH_BATCH(imesa); - switch(func) { - case GL_NEVER: - test = COMPAREFUNC_NEVER; - break; - case GL_LESS: - test = COMPAREFUNC_LESS; - break; - case GL_LEQUAL: - test = COMPAREFUNC_LEQUAL; - break; - case GL_GREATER: - test = COMPAREFUNC_GREATER; - break; - case GL_GEQUAL: - test = COMPAREFUNC_GEQUAL; - break; - case GL_NOTEQUAL: - test = COMPAREFUNC_NOTEQUAL; - break; - case GL_EQUAL: - test = COMPAREFUNC_EQUAL; - break; - case GL_ALWAYS: - test = COMPAREFUNC_ALWAYS; - break; + case GL_NEVER: test = COMPAREFUNC_NEVER; break; + case GL_LESS: test = COMPAREFUNC_LESS; break; + case GL_LEQUAL: test = COMPAREFUNC_LEQUAL; break; + case GL_GREATER: test = COMPAREFUNC_GREATER; break; + case GL_GEQUAL: test = COMPAREFUNC_GEQUAL; break; + case GL_NOTEQUAL: test = COMPAREFUNC_NOTEQUAL; break; + case GL_EQUAL: test = COMPAREFUNC_EQUAL; break; + case GL_ALWAYS: test = COMPAREFUNC_ALWAYS; break; default: return; } - imesa->dirty |= I830_UPLOAD_CTX; + I830_STATECHANGE(imesa, I830_UPLOAD_CTX); imesa->Setup[I830_CTXREG_STATE3] &= ~DEPTH_TEST_FUNC_MASK; imesa->Setup[I830_CTXREG_STATE3] |= (ENABLE_DEPTH_TEST_FUNC | DEPTH_TEST_FUNC(test)); } -static void i830DDDepthMask(GLcontext *ctx, GLboolean flag) +static void i830DepthMask(GLcontext *ctx, GLboolean flag) { i830ContextPtr imesa = I830_CONTEXT(ctx); if(I830_DEBUG&DEBUG_VERBOSE_TRACE) fprintf(stderr, "%s flag (%d)\n", __FUNCTION__, flag); - FLUSH_BATCH(imesa); + I830_STATECHANGE(imesa, I830_UPLOAD_CTX); - imesa->dirty |= I830_UPLOAD_CTX; imesa->Setup[I830_CTXREG_ENABLES_2] &= ~ENABLE_DIS_DEPTH_WRITE_MASK; if (flag) @@ -618,13 +550,20 @@ static void i830DDDepthMask(GLcontext *ctx, GLboolean flag) imesa->Setup[I830_CTXREG_ENABLES_2] |= DISABLE_DEPTH_WRITE; } +/* The i830 has no stipple hardware */ +static void i830PolygonStipple(GLcontext *ctx, const GLubyte *mask) +{ + i830ContextPtr imesa = I830_CONTEXT(ctx); + + FALLBACK(imesa, I830_FALLBACK_STIPPLE, ctx->Polygon.StippleFlag); +} + /* ============================================================= * Hardware clipping */ - -static void i830DDScissor( GLcontext *ctx, GLint x, GLint y, - GLsizei w, GLsizei h ) -{ +static void i830Scissor(GLcontext *ctx, GLint x, GLint y, + GLsizei w, GLsizei h) +{ i830ContextPtr imesa = I830_CONTEXT(ctx); int x1 = x; int y1 = imesa->driDrawable->h - (y + h); @@ -640,13 +579,12 @@ static void i830DDScissor( GLcontext *ctx, GLint x, GLint y, if(x2 < 0) x2 = 0; if(y2 < 0) y2 = 0; - FLUSH_BATCH(imesa); - imesa->dirty |= I830_UPLOAD_BUFFERS; + I830_STATECHANGE(imesa, I830_UPLOAD_BUFFERS); imesa->BufferSetup[I830_DESTREG_SR1] = (y1 << 16) | (x1 & 0xffff); imesa->BufferSetup[I830_DESTREG_SR2] = (y2 << 16) | (x2 & 0xffff); } -static void i830DDLogicOp( GLcontext *ctx, GLenum opcode ) +static void i830LogicOp(GLcontext *ctx, GLenum opcode) { i830ContextPtr imesa = I830_CONTEXT(ctx); int tmp = 0; @@ -654,9 +592,6 @@ static void i830DDLogicOp( GLcontext *ctx, GLenum opcode ) if(I830_DEBUG&DEBUG_VERBOSE_TRACE) fprintf(stderr, "%s\n", __FUNCTION__); - - FLUSH_BATCH( imesa ); - switch(opcode) { case GL_CLEAR: tmp = LOGICOP_CLEAR; break; case GL_AND: tmp = LOGICOP_AND; break; @@ -677,106 +612,72 @@ static void i830DDLogicOp( GLcontext *ctx, GLenum opcode ) default: return; } - imesa->dirty |= I830_UPLOAD_CTX; + I830_STATECHANGE(imesa, I830_UPLOAD_CTX); imesa->Setup[I830_CTXREG_STATE4] &= ~LOGICOP_MASK; imesa->Setup[I830_CTXREG_STATE4] |= LOGIC_OP_FUNC(tmp); - if(0) fprintf(stderr, "Logicop : 0x%x, state4 : 0x%x\n", tmp, imesa->Setup[I830_CTXREG_STATE4]); - /* Insure all the enables are correct */ + + /* Make sure all the enables are correct */ i830EvalLogicOpBlendState(ctx); } -static GLboolean i830DDSetDrawBuffer(GLcontext *ctx, GLenum mode ) +/* Fallback to swrast for select and feedback. + */ +static void i830RenderMode( GLcontext *ctx, GLenum mode ) { i830ContextPtr imesa = I830_CONTEXT(ctx); + FALLBACK( imesa, I830_FALLBACK_RENDERMODE, (mode != GL_RENDER) ); +} - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s\n", __FUNCTION__); - - FLUSH_BATCH(imesa); +static GLboolean i830SetDrawBuffer(GLcontext *ctx, GLenum mode ) +{ + i830ContextPtr imesa = I830_CONTEXT(ctx); - imesa->Fallback &= ~I830_FALLBACK_DRAW_BUFFER; - if(mode == GL_FRONT_LEFT) { - imesa->readMap = (char *)imesa->driScreen->pFB; + I830_FIREVERTICES(imesa); + I830_STATECHANGE(imesa, I830_UPLOAD_BUFFERS); + + imesa->BufferSetup[I830_DESTREG_CBUFADDR] = imesa->i830Screen->fbOffset; + imesa->drawMap = (char *)imesa->driScreen->pFB; - imesa->BufferSetup[I830_DESTREG_CBUFADDR] = - imesa->i830Screen->fbOffset; - imesa->dirty |= I830_UPLOAD_BUFFERS; + imesa->readMap = (char *)imesa->driScreen->pFB; i830XMesaSetFrontClipRects( imesa ); + FALLBACK( imesa, I830_FALLBACK_DRAW_BUFFER, GL_FALSE ); return GL_TRUE; } else if(mode == GL_BACK_LEFT) { - imesa->readMap = imesa->i830Screen->back.map; - imesa->drawMap = (char *)imesa->i830Screen->back.map; - imesa->BufferSetup[I830_DESTREG_CBUFADDR] = - imesa->i830Screen->backOffset; - imesa->dirty |= I830_UPLOAD_BUFFERS; - i830XMesaSetBackClipRects( imesa ); - return GL_TRUE; - } + I830_FIREVERTICES(imesa); + I830_STATECHANGE(imesa, I830_UPLOAD_BUFFERS); - imesa->Fallback |= I830_FALLBACK_DRAW_BUFFER; - return GL_FALSE; -} - -static void i830DDSetReadBuffer(GLcontext *ctx, GLframebuffer *colorBuffer, - GLenum mode ) -{ - i830ContextPtr imesa = I830_CONTEXT(ctx); - - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s\n", __FUNCTION__); + imesa->BufferSetup[I830_DESTREG_CBUFADDR] = + imesa->i830Screen->backOffset; - if(mode == GL_FRONT_LEFT) { - imesa->readMap = (char *)imesa->driScreen->pFB; - imesa->Fallback &= ~I830_FALLBACK_READ_BUFFER; - } else if(mode == GL_BACK_LEFT) { + imesa->drawMap = imesa->i830Screen->back.map; imesa->readMap = imesa->i830Screen->back.map; - imesa->Fallback &= ~I830_FALLBACK_READ_BUFFER; + i830XMesaSetBackClipRects( imesa ); + FALLBACK( imesa, I830_FALLBACK_DRAW_BUFFER, GL_FALSE ); + return GL_TRUE; } else { - imesa->Fallback |= I830_FALLBACK_READ_BUFFER; + FALLBACK( imesa, I830_FALLBACK_DRAW_BUFFER, GL_TRUE ); + return GL_FALSE; } } -static void i830DDSetColor(GLcontext *ctx, - GLubyte r, GLubyte g, - GLubyte b, GLubyte a ) +static void i830ClearColor(GLcontext *ctx, const GLchan color[4]) { i830ContextPtr imesa = I830_CONTEXT(ctx); - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s r(%d) g(%d) b(%d) a(%d)\n", __FUNCTION__, - r, g, b, a); + imesa->clear_red = color[RCOMP]; + imesa->clear_green = color[GCOMP]; + imesa->clear_blue = color[BCOMP]; + imesa->clear_alpha = color[ACOMP]; - imesa->MonoColor = i830PackColor( imesa->i830Screen->fbFormat, r, g, b, a ); - if(I830_DEBUG&DEBUG_VERBOSE_STATE) - fprintf(stderr, "[%s] MonoColor = 0x%08x\n", __FUNCTION__, - imesa->MonoColor); + imesa->ClearColor = i830PackColor(imesa->i830Screen->fbFormat, + color[RCOMP], + color[GCOMP], + color[BCOMP], + color[ACOMP] ); } - -static void i830DDClearColor(GLcontext *ctx, - GLubyte r, GLubyte g, - GLubyte b, GLubyte a ) -{ - i830ContextPtr imesa = I830_CONTEXT(ctx); - - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s r(%d) g(%d) b(%d) a(%d)\n", __FUNCTION__, - r, g, b, a); - - imesa->clear_red = r; - imesa->clear_green = g; - imesa->clear_blue = b; - imesa->clear_alpha = a; - - imesa->ClearColor = i830PackColor( imesa->i830Screen->fbFormat, r, g, b, a ); - if(I830_DEBUG&DEBUG_VERBOSE_STATE) - fprintf(stderr, "[%s] ClearColor = 0x%08x\n", __FUNCTION__, - imesa->ClearColor); - -} - -static void i830DDCullFaceFrontFace(GLcontext *ctx, GLenum unused) +static void i830CullFaceFrontFace(GLcontext *ctx, GLenum unused) { i830ContextPtr imesa = I830_CONTEXT(ctx); GLuint mode = CULLMODE_BOTH; @@ -784,9 +685,7 @@ static void i830DDCullFaceFrontFace(GLcontext *ctx, GLenum unused) if(I830_DEBUG&DEBUG_VERBOSE_TRACE) fprintf(stderr, "%s\n", __FUNCTION__); - FLUSH_BATCH(imesa); - - if(ctx->Polygon.CullFaceMode != GL_FRONT_AND_BACK) { + if (ctx->Polygon.CullFaceMode != GL_FRONT_AND_BACK) { mode = CULLMODE_CW; if (ctx->Polygon.CullFaceMode == GL_FRONT) @@ -797,64 +696,14 @@ static void i830DDCullFaceFrontFace(GLcontext *ctx, GLenum unused) imesa->LcsCullMode = mode; - if(ctx->Polygon.CullFlag && ctx->PB->primitive == GL_POLYGON) { - imesa->dirty |= I830_UPLOAD_CTX; - imesa->Setup[I830_CTXREG_STATE3] &= ~CULLMODE_MASK; - imesa->Setup[I830_CTXREG_STATE3] |= ENABLE_CULL_MODE | mode; + if (ctx->Polygon.CullFlag) { + I830_STATECHANGE(imesa, I830_UPLOAD_CTX); + imesa->Setup[I830_CTXREG_STATE3] &= ~CULLMODE_MASK; + imesa->Setup[I830_CTXREG_STATE3] |= ENABLE_CULL_MODE | mode; } } -static void i830DDReducedPrimitiveChange( GLcontext *ctx, GLenum prim ) -{ - i830ContextPtr imesa = I830_CONTEXT(ctx); - - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s %s\n", __FUNCTION__, gl_lookup_enum_by_nr(prim)); - - FLUSH_BATCH(imesa); - imesa->dirty |= I830_UPLOAD_CTX; - imesa->Setup[I830_CTXREG_STATE3] &= ~CULLMODE_MASK; - imesa->Setup[I830_CTXREG_AA] &= ~AA_LINE_ENABLE; - imesa->vertex_prim = PRIM3D_TRILIST; - - switch(ctx->PB->primitive) { - case GL_POLYGON: - if (ctx->Polygon.CullFlag) - imesa->Setup[I830_CTXREG_STATE3] |= (ENABLE_CULL_MODE | - imesa->LcsCullMode); - else - imesa->Setup[I830_CTXREG_STATE3] |= (ENABLE_CULL_MODE | - CULLMODE_NONE); - break; - - case GL_LINE: - case GL_LINES: - imesa->vertex_prim = PRIM3D_LINELIST; - - if(ctx->Line.SmoothFlag) - imesa->Setup[I830_CTXREG_AA] |= AA_LINE_ENABLE; - imesa->Setup[I830_CTXREG_STATE3] |= CULLMODE_NONE; - break; - - case GL_POINT: - case GL_POINTS: - imesa->vertex_prim = PRIM3D_POINTLIST; - imesa->Setup[I830_CTXREG_STATE3] |= CULLMODE_NONE; - default: - imesa->Setup[I830_CTXREG_STATE3] |= CULLMODE_NONE; - break; - } - - if(I830_DEBUG&DEBUG_VERBOSE_STATE) - fprintf(stderr, "[%s] AA(0x%08x) STATE3(0x%08x) vertex_prim 0x%x\n", - __FUNCTION__, - imesa->Setup[I830_CTXREG_AA], - imesa->Setup[I830_CTXREG_STATE3], - imesa->vertex_prim); - -} - -static void i830DDLineWidth( GLcontext *ctx, GLfloat widthf ) +static void i830LineWidth( GLcontext *ctx, GLfloat widthf ) { i830ContextPtr imesa = I830_CONTEXT( ctx ); int width; @@ -864,24 +713,36 @@ static void i830DDLineWidth( GLcontext *ctx, GLfloat widthf ) width = FloatToInt(widthf * 2); CLAMP_SELF(width, 1, 15); + + I830_STATECHANGE(imesa, I830_UPLOAD_CTX); imesa->Setup[I830_CTXREG_STATE5] &= ~FIXED_LINE_WIDTH_MASK; imesa->Setup[I830_CTXREG_STATE5] |= (ENABLE_FIXED_LINE_WIDTH | FIXED_LINE_WIDTH(width)); +} - imesa->dirty |= I830_UPLOAD_CTX; +static void i830PointSize(GLcontext *ctx, GLfloat size) +{ + i830ContextPtr imesa = I830_CONTEXT(ctx); + GLint point_size = FloatToInt(size); + + if(I830_DEBUG&DEBUG_VERBOSE_TRACE) + fprintf(stderr, "%s\n", __FUNCTION__); + + CLAMP_SELF(point_size, 1, 256); + I830_STATECHANGE(imesa, I830_UPLOAD_CTX); + imesa->Setup[I830_CTXREG_STATE5] &= ~FIXED_POINT_WIDTH_MASK; + imesa->Setup[I830_CTXREG_STATE5] |= (ENABLE_FIXED_POINT_WIDTH | + FIXED_POINT_WIDTH(point_size)); } + /* ============================================================= * Color masks */ -/* This only deals with ColorMask for rendering, clears need to update - * a planemask for the clearing blit. This is to be done. - */ - -static GLboolean i830DDColorMask(GLcontext *ctx, - GLboolean r, GLboolean g, - GLboolean b, GLboolean a ) +static void i830ColorMask(GLcontext *ctx, + GLboolean r, GLboolean g, + GLboolean b, GLboolean a) { i830ContextPtr imesa = I830_CONTEXT( ctx ); GLuint tmp = 0; @@ -903,31 +764,29 @@ static GLboolean i830DDColorMask(GLcontext *ctx, ((!a) << WRITEMASK_ALPHA_SHIFT); if(tmp != imesa->Setup[I830_CTXREG_ENABLES_2]) { - FLUSH_BATCH(imesa); + I830_FIREVERTICES(imesa); imesa->dirty |= I830_UPLOAD_CTX; imesa->Setup[I830_CTXREG_ENABLES_2] = tmp; if(I830_DEBUG&DEBUG_VERBOSE_STATE) fprintf(stderr, "[%s] enables 2 = 0x%08x\n", __FUNCTION__, tmp); } - - /* Always return false so s/w fallbacks are correct */ - return GL_FALSE; } -static void i830DDLightModelfv(GLcontext *ctx, GLenum pname, - const GLfloat *param) + +static void i830LightModelfv(GLcontext *ctx, GLenum pname, + const GLfloat *param) { if(I830_DEBUG&DEBUG_VERBOSE_TRACE) fprintf(stderr, "%s\n", __FUNCTION__); if(pname == GL_LIGHT_MODEL_COLOR_CONTROL) { i830ContextPtr imesa = I830_CONTEXT( ctx ); - FLUSH_BATCH(imesa); - imesa->dirty |= I830_UPLOAD_CTX; + + I830_STATECHANGE(imesa, I830_UPLOAD_CTX); imesa->Setup[I830_CTXREG_ENABLES_1] &= ~ENABLE_SPEC_ADD_MASK; - if(ctx->Texture.ReallyEnabled && + if(ctx->Texture._ReallyEnabled && ctx->Light.Enabled && ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR) imesa->Setup[I830_CTXREG_ENABLES_1] |= ENABLE_SPEC_ADD; @@ -937,192 +796,167 @@ static void i830DDLightModelfv(GLcontext *ctx, GLenum pname, if(I830_DEBUG&DEBUG_VERBOSE_STATE) fprintf(stderr, "[%s] Enables_1 = 0x%08x\n", __FUNCTION__, imesa->Setup[I830_CTXREG_ENABLES_1]); + } +} + +/* In Mesa 3.5 we can reliably do native flatshading. + */ +static void i830ShadeModel(GLcontext *ctx, GLenum mode) +{ + i830ContextPtr imesa = I830_CONTEXT(ctx); + I830_STATECHANGE(imesa, I830_UPLOAD_CTX); + +#define SHADE_MODE_MASK ((1<<10)|(1<<8)|(1<<6)|(1<<4)) + + imesa->Setup[I830_CTXREG_STATE3] &= ~SHADE_MODE_MASK; + + if (mode == GL_FLAT) { + imesa->Setup[I830_CTXREG_STATE3] |= (ALPHA_SHADE_MODE(SHADE_MODE_FLAT) | + FOG_SHADE_MODE(SHADE_MODE_FLAT) | + SPEC_SHADE_MODE(SHADE_MODE_FLAT) | + COLOR_SHADE_MODE(SHADE_MODE_FLAT)); + } else { + imesa->Setup[I830_CTXREG_STATE3] |= (ALPHA_SHADE_MODE(SHADE_MODE_LINEAR) | + FOG_SHADE_MODE(SHADE_MODE_LINEAR) | + SPEC_SHADE_MODE(SHADE_MODE_LINEAR) | + COLOR_SHADE_MODE(SHADE_MODE_LINEAR)); } } /* ============================================================= * Fog */ -static void i830DDFogfv(GLcontext *ctx, GLenum pname, const GLfloat *param) +static void i830Fogfv(GLcontext *ctx, GLenum pname, const GLfloat *param) { i830ContextPtr imesa = I830_CONTEXT(ctx); if(I830_DEBUG&DEBUG_VERBOSE_TRACE) fprintf(stderr, "%s\n", __FUNCTION__); - if(pname == GL_FOG_COLOR) { + if (pname == GL_FOG_COLOR) { GLuint color = (((GLubyte)(ctx->Fog.Color[0]*255.0F) << 16) | ((GLubyte)(ctx->Fog.Color[1]*255.0F) << 8) | ((GLubyte)(ctx->Fog.Color[2]*255.0F) << 0)); - imesa->dirty |= I830_UPLOAD_CTX; + I830_STATECHANGE(imesa, I830_UPLOAD_CTX); imesa->Setup[I830_CTXREG_FOGCOLOR] = (STATE3D_FOG_COLOR_CMD | color); - - if(I830_DEBUG&DEBUG_VERBOSE_STATE) - fprintf(stderr, "[%s] FogColor = 0x%08x\n", __FUNCTION__, - imesa->Setup[I830_CTXREG_FOGCOLOR]); - } } - /* ============================================================= */ -static void i830DDEnable(GLcontext *ctx, GLenum cap, GLboolean state) +static void i830Enable(GLcontext *ctx, GLenum cap, GLboolean state) { i830ContextPtr imesa = I830_CONTEXT(ctx); - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s cap(%s) state(%d)\n", __FUNCTION__, - gl_lookup_enum_by_nr(cap), state); - switch(cap) { case GL_LIGHTING: - FLUSH_BATCH(imesa); - imesa->dirty |= I830_UPLOAD_CTX; - imesa->Setup[I830_CTXREG_ENABLES_1] &= ~ENABLE_SPEC_ADD_MASK; + I830_STATECHANGE(imesa, I830_UPLOAD_CTX); + imesa->Setup[I830_CTXREG_ENABLES_1] &= ~ENABLE_SPEC_ADD_MASK; - if (ctx->Texture.ReallyEnabled && - ctx->Light.Enabled && - ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR) - imesa->Setup[I830_CTXREG_ENABLES_1] |= ENABLE_SPEC_ADD; - else - imesa->Setup[I830_CTXREG_ENABLES_1] |= DISABLE_SPEC_ADD; + if (ctx->Texture._ReallyEnabled && + ctx->Light.Enabled && + ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR) + imesa->Setup[I830_CTXREG_ENABLES_1] |= ENABLE_SPEC_ADD; + else + imesa->Setup[I830_CTXREG_ENABLES_1] |= DISABLE_SPEC_ADD; + + break; - break; case GL_ALPHA_TEST: - FLUSH_BATCH(imesa); - imesa->dirty |= I830_UPLOAD_CTX; - imesa->Setup[I830_CTXREG_ENABLES_1] &= ~ENABLE_DIS_ALPHA_TEST_MASK; - if(state) - imesa->Setup[I830_CTXREG_ENABLES_1] |= ENABLE_ALPHA_TEST; - else - imesa->Setup[I830_CTXREG_ENABLES_1] |= DISABLE_ALPHA_TEST; - break; + I830_STATECHANGE(imesa, I830_UPLOAD_CTX); + imesa->Setup[I830_CTXREG_ENABLES_1] &= ~ENABLE_DIS_ALPHA_TEST_MASK; + if(state) + imesa->Setup[I830_CTXREG_ENABLES_1] |= ENABLE_ALPHA_TEST; + else + imesa->Setup[I830_CTXREG_ENABLES_1] |= DISABLE_ALPHA_TEST; + + break; case GL_BLEND: case GL_COLOR_LOGIC_OP: case GL_INDEX_LOGIC_OP: - i830EvalLogicOpBlendState(ctx); - break; - case GL_DITHER: - { - unsigned int temp; + i830EvalLogicOpBlendState(ctx); + break; - FLUSH_BATCH(imesa); - temp = imesa->Setup[I830_CTXREG_ENABLES_2]; - - temp &= ~ENABLE_DITHER; + case GL_DITHER: + I830_STATECHANGE(imesa, I830_UPLOAD_CTX); + imesa->Setup[I830_CTXREG_ENABLES_2] &= ~ENABLE_DITHER; - if(state) temp |= ENABLE_DITHER; - else temp |= DISABLE_DITHER; - - if(temp != imesa->Setup[I830_CTXREG_ENABLES_2]) { - imesa->dirty |= I830_UPLOAD_CTX; - imesa->Setup[I830_CTXREG_ENABLES_2] = temp; - } - } - break; + if(state) + imesa->Setup[I830_CTXREG_ENABLES_2] |= ENABLE_DITHER; + else + imesa->Setup[I830_CTXREG_ENABLES_2] |= DISABLE_DITHER; + break; case GL_DEPTH_TEST: - FLUSH_BATCH(imesa); - imesa->dirty |= I830_UPLOAD_CTX; - imesa->Setup[I830_CTXREG_ENABLES_1] &= ~ENABLE_DIS_DEPTH_TEST_MASK; - - if(state) - imesa->Setup[I830_CTXREG_ENABLES_1] |= ENABLE_DEPTH_TEST; - else - imesa->Setup[I830_CTXREG_ENABLES_1] |= DISABLE_DEPTH_TEST; - break; + I830_STATECHANGE(imesa, I830_UPLOAD_CTX); + imesa->Setup[I830_CTXREG_ENABLES_1] &= ~ENABLE_DIS_DEPTH_TEST_MASK; - case GL_SCISSOR_TEST: - FLUSH_BATCH(imesa); + if(state) + imesa->Setup[I830_CTXREG_ENABLES_1] |= ENABLE_DEPTH_TEST; + else + imesa->Setup[I830_CTXREG_ENABLES_1] |= DISABLE_DEPTH_TEST; + break; - if(state) - imesa->BufferSetup[I830_DESTREG_SENABLE] = (STATE3D_SCISSOR_ENABLE_CMD | - ENABLE_SCISSOR_RECT); + case GL_SCISSOR_TEST: + I830_STATECHANGE(imesa, I830_UPLOAD_BUFFERS); + + if (state) + imesa->BufferSetup[I830_DESTREG_SENABLE] = + (STATE3D_SCISSOR_ENABLE_CMD | + ENABLE_SCISSOR_RECT); else - imesa->BufferSetup[I830_DESTREG_SENABLE] = (STATE3D_SCISSOR_ENABLE_CMD | - DISABLE_SCISSOR_RECT); - imesa->dirty |= I830_UPLOAD_BUFFERS; - break; + imesa->BufferSetup[I830_DESTREG_SENABLE] = + (STATE3D_SCISSOR_ENABLE_CMD | + DISABLE_SCISSOR_RECT); - case GL_POLYGON_STIPPLE: - if(ctx->PB->primitive == GL_POLYGON) { - FLUSH_BATCH(imesa); - /* Need a fallback here */ - } + imesa->upload_cliprects = GL_TRUE; break; case GL_LINE_SMOOTH: - if (ctx->PB->primitive == GL_LINE) { - FLUSH_BATCH(imesa); - if(0) fprintf(stderr, "Line smooth hit\n"); - imesa->dirty |= I830_UPLOAD_CTX; - imesa->Setup[I830_CTXREG_AA] &= ~AA_LINE_ENABLE; - /* imesa->Setup[I830_CTXREG_LCS] &= ~LCS_LINEWIDTH_0_5; */ - if (state) { - imesa->Setup[I830_CTXREG_AA] |= AA_LINE_ENABLE; - /* imesa->Setup[I830_CTXREG_LCS] |= LCS_LINEWIDTH_0_5; */ - } else { - imesa->Setup[I830_CTXREG_AA] |= AA_LINE_DISABLE; - /* imesa->Setup[I830_CTXREG_LCS] |= LCS_LINEWIDTH_0_5; */ - } - } - break; - - case GL_POINT_SMOOTH: - if (ctx->PB->primitive == GL_POINT) { - FLUSH_BATCH(imesa); - if(0) fprintf(stderr, "Point smooth hit\n"); - } - break; - - case GL_POLYGON_SMOOTH: - if (ctx->PB->primitive == GL_POLYGON) { - FLUSH_BATCH(imesa); - if(0) fprintf(stderr, "Polygon Smooth hit\n"); + if (imesa->reduced_primitive == GL_LINES) { + I830_STATECHANGE(imesa, I830_UPLOAD_CTX); + + imesa->Setup[I830_CTXREG_AA] &= ~AA_LINE_ENABLE; + if(state) + imesa->Setup[I830_CTXREG_AA] |= AA_LINE_ENABLE; + else + imesa->Setup[I830_CTXREG_AA] |= AA_LINE_DISABLE; } break; case GL_FOG: - FLUSH_BATCH(imesa); - imesa->dirty |= I830_UPLOAD_CTX; - imesa->Setup[I830_CTXREG_ENABLES_1] &= ~ENABLE_DIS_FOG_MASK; + I830_STATECHANGE(imesa, I830_UPLOAD_CTX); + imesa->Setup[I830_CTXREG_ENABLES_1] &= ~ENABLE_DIS_FOG_MASK; + if(state) + imesa->Setup[I830_CTXREG_ENABLES_1] |= I830_ENABLE_FOG; + else + imesa->Setup[I830_CTXREG_ENABLES_1] |= I830_DISABLE_FOG; + break; + + case GL_CULL_FACE: + I830_STATECHANGE(imesa, I830_UPLOAD_CTX); + imesa->Setup[I830_CTXREG_STATE3] &= ~CULLMODE_MASK; if(state) - imesa->Setup[I830_CTXREG_ENABLES_1] |= I830_ENABLE_FOG; + imesa->Setup[I830_CTXREG_STATE3] |= (ENABLE_CULL_MODE | + imesa->LcsCullMode); else - imesa->Setup[I830_CTXREG_ENABLES_1] |= I830_DISABLE_FOG; + imesa->Setup[I830_CTXREG_STATE3] |= (ENABLE_CULL_MODE | + CULLMODE_NONE); break; - case GL_CULL_FACE: - if (ctx->PB->primitive == GL_POLYGON) { - FLUSH_BATCH(imesa); - imesa->dirty |= I830_UPLOAD_CTX; - imesa->Setup[I830_CTXREG_STATE3] &= ~CULLMODE_MASK; - if (state) - imesa->Setup[I830_CTXREG_STATE3] |= (ENABLE_CULL_MODE | - imesa->LcsCullMode); - else - imesa->Setup[I830_CTXREG_STATE3] |= (ENABLE_CULL_MODE | - CULLMODE_NONE); - } - break; - case GL_TEXTURE_1D: - case GL_TEXTURE_3D: - FLUSH_BATCH(imesa); - imesa->new_state |= I830_NEW_TEXTURE; - break; case GL_TEXTURE_2D: - FLUSH_BATCH(imesa); - imesa->new_state |= I830_NEW_TEXTURE; - - imesa->dirty |= I830_UPLOAD_CTX; + if(0) { + if(state) fprintf(stderr, "\n\nTexturing Enabled\n\n"); + else fprintf(stderr, "\n\nTexturing Disabled\n\n"); + } + I830_STATECHANGE(imesa, I830_UPLOAD_CTX); imesa->Setup[I830_CTXREG_ENABLES_1] &= ~ENABLE_SPEC_ADD_MASK; - if (ctx->Texture.ReallyEnabled && + if (ctx->Texture._ReallyEnabled && ctx->Light.Enabled && ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR) imesa->Setup[I830_CTXREG_ENABLES_1] |= ENABLE_SPEC_ADD; @@ -1131,56 +965,29 @@ static void i830DDEnable(GLcontext *ctx, GLenum cap, GLboolean state) break; case GL_STENCIL_TEST: - FLUSH_BATCH(imesa); if(imesa->hw_stencil) { - imesa->dirty |= I830_UPLOAD_CTX; - imesa->Setup[I830_CTXREG_ENABLES_1] &= ~ENABLE_STENCIL_TEST; - - if(state) { - if(0) fprintf(stderr, "Enabling stencil test\n"); - imesa->Setup[I830_CTXREG_ENABLES_1] |= ENABLE_STENCIL_TEST; - } else { - if(0) fprintf(stderr, "Disabling stencil test\n"); - imesa->Setup[I830_CTXREG_ENABLES_1] |= DISABLE_STENCIL_TEST; - } - - if(I830_DEBUG&DEBUG_VERBOSE_STATE) - fprintf(stderr, "%s : state4 : 0x%x, stentst : 0x%x," - " enables_1 : 0x%x\n", __FUNCTION__, - imesa->Setup[I830_CTXREG_STATE4], - imesa->Setup[I830_CTXREG_STENCILTST], - imesa->Setup[I830_CTXREG_ENABLES_1]); - - } else if (state) { - imesa->Fallback |= I830_FALLBACK_STENCIL; + I830_STATECHANGE(imesa, I830_UPLOAD_CTX); + imesa->Setup[I830_CTXREG_ENABLES_1] &= ~ENABLE_STENCIL_TEST; + + if(state) { + imesa->Setup[I830_CTXREG_ENABLES_1] |= ENABLE_STENCIL_TEST; + } else { + imesa->Setup[I830_CTXREG_ENABLES_1] |= DISABLE_STENCIL_TEST; + } + + if(I830_DEBUG&DEBUG_VERBOSE_STATE) + fprintf(stderr, "%s : state4 : 0x%x, stentst : 0x%x," + " enables_1 : 0x%x\n", __FUNCTION__, + imesa->Setup[I830_CTXREG_STATE4], + imesa->Setup[I830_CTXREG_STENCILTST], + imesa->Setup[I830_CTXREG_ENABLES_1]); } else { - imesa->Fallback &= ~I830_FALLBACK_STENCIL; + FALLBACK( imesa, I830_FALLBACK_STENCIL, state ); } - + break; default: - ; - } -} - - - -/* ============================================================= - */ - - -void i830DDUpdateHwState( GLcontext *ctx ) -{ - i830ContextPtr imesa = I830_CONTEXT(ctx); - - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s\n", __FUNCTION__); - - if(imesa->new_state & I830_NEW_TEXTURE) { - FLUSH_BATCH(imesa); - i830UpdateTextureState( ctx ); + ; } - - imesa->new_state = 0; } @@ -1194,7 +1001,7 @@ void i830EmitDrawingRectangle( i830ContextPtr imesa ) int y1 = y0 + dPriv->h; /* Don't set drawing rectangle */ - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) + if(DEBUGGING) fprintf(stderr, "%s x0(%d) x1(%d) y0(%d) y1(%d)\n", __FUNCTION__, x0, x1, y0, y1); @@ -1215,9 +1022,18 @@ void i830EmitDrawingRectangle( i830ContextPtr imesa ) */ imesa->BufferSetup[I830_DESTREG_DR2] = ((y0<<16) | x0); imesa->BufferSetup[I830_DESTREG_DR3] = (((y1+1)<<16) | (x1+1)); + + + /* Just add in our dirty flag, since we might be called when locked */ + /* Might want to modify how this is done. */ +#if 0 + if (imesa->vertex_low != imesa->vertex_last_prim) + i830FlushPrimsLocked(imesa); +#endif + imesa->dirty |= I830_UPLOAD_BUFFERS; - if(I830_DEBUG&DEBUG_VERBOSE_STATE) + if(0) fprintf(stderr, "[%s] DR2(0x%08x) DR3(0x%08x) DR4(0x%08x)\n", __FUNCTION__, imesa->BufferSetup[I830_DESTREG_DR2], @@ -1225,102 +1041,130 @@ void i830EmitDrawingRectangle( i830ContextPtr imesa ) imesa->BufferSetup[I830_DESTREG_DR4]); } +/* This could be done in hardware, will do once I have the driver + * up and running. + */ +static void i830CalcViewport( GLcontext *ctx ) +{ + i830ContextPtr imesa = I830_CONTEXT(ctx); + const GLfloat *v = ctx->Viewport._WindowMap.m; + GLfloat *m = imesa->ViewportMatrix.m; + /* See also i830_translate_vertex. SUBPIXEL adjustments can be done + * via state vars, too. + */ + m[MAT_SX] = v[MAT_SX]; + m[MAT_TX] = v[MAT_TX] + SUBPIXEL_X; + m[MAT_SY] = - v[MAT_SY]; + m[MAT_TY] = - v[MAT_TY] + imesa->driDrawable->h + SUBPIXEL_Y; + m[MAT_SZ] = v[MAT_SZ] * imesa->depth_scale; + m[MAT_TZ] = v[MAT_TZ] * imesa->depth_scale; +} -static void i830DDPrintDirty( const char *msg, GLuint state ) +static void i830Viewport( GLcontext *ctx, + GLint x, GLint y, + GLsizei width, GLsizei height ) { - fprintf(stderr, "%s (0x%x): %s%s%s%s%s\n", + i830CalcViewport( ctx ); +} + +static void i830DepthRange( GLcontext *ctx, + GLclampd nearval, GLclampd farval ) +{ + i830CalcViewport( ctx ); +} + +void i830PrintDirty( const char *msg, GLuint state ) +{ + fprintf(stderr, "%s (0x%x): %s%s%s%s%s%s\n", msg, (unsigned int) state, - (state & I830_UPLOAD_TEX0_IMAGE) ? "upload-tex0, " : "", - (state & I830_UPLOAD_TEX1_IMAGE) ? "upload-tex1, " : "", + (state & I830_UPLOAD_TEX0) ? "upload-tex0, " : "", + (state & I830_UPLOAD_TEX1) ? "upload-tex1, " : "", (state & I830_UPLOAD_CTX) ? "upload-ctx, " : "", (state & I830_UPLOAD_BUFFERS) ? "upload-bufs, " : "", - (state & I830_UPLOAD_CLIPRECTS) ? "upload-cliprects, " : "" + (state & I830_UPLOAD_TEXBLEND0) ? "upload-blend0, " : "", + (state & I830_UPLOAD_TEXBLEND1) ? "upload-blend1, " : "" ); } - /* Push the state into the sarea and/or texture memory. */ void i830EmitHwStateLocked( i830ContextPtr imesa ) { int i; - if (I830_DEBUG & DEBUG_VERBOSE_API) - i830DDPrintDirty( "\n\n\ni830EmitHwStateLocked", imesa->dirty ); + if (DEBUGGING) + i830PrintDirty( "\n\n\ni830EmitHwStateLocked", imesa->dirty ); - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) + if (DEBUGGING) fprintf(stderr, "%s\n", __FUNCTION__); - if (imesa->dirty & ~I830_UPLOAD_CLIPRECTS) { - if ((imesa->dirty & I830_UPLOAD_TEX0_IMAGE) && imesa->CurrentTexObj[0]) - i830UploadTexImages(imesa, imesa->CurrentTexObj[0]); - - if ((imesa->dirty & I830_UPLOAD_TEX1_IMAGE) && imesa->CurrentTexObj[1]) - i830UploadTexImages(imesa, imesa->CurrentTexObj[1]); - - if (imesa->dirty & I830_UPLOAD_CTX) - memcpy( imesa->sarea->ContextState, - imesa->Setup, - sizeof(imesa->Setup) ); - - for(i = 0; i < I830_TEXTURE_COUNT; i++) { - if ((imesa->dirty & I830_UPLOAD_TEX_N(i)) && imesa->CurrentTexObj[i]) { - imesa->sarea->dirty |= I830_UPLOAD_TEX_N(i); - memcpy(imesa->sarea->TexState[i], - imesa->CurrentTexObj[i]->Setup, - sizeof(imesa->sarea->TexState[i])); - } + if ((imesa->dirty & I830_UPLOAD_TEX0_IMAGE) && imesa->CurrentTexObj[0]) + i830UploadTexImages(imesa, imesa->CurrentTexObj[0]); + if ((imesa->dirty & I830_UPLOAD_TEX1_IMAGE) && imesa->CurrentTexObj[1]) + i830UploadTexImages(imesa, imesa->CurrentTexObj[1]); + if (imesa->dirty & I830_UPLOAD_CTX) { + memcpy( imesa->sarea->ContextState, + imesa->Setup, sizeof(imesa->Setup) ); + } + + for(i = 0; i < I830_TEXTURE_COUNT; i++) { + if ((imesa->dirty & I830_UPLOAD_TEX_N(i)) && imesa->CurrentTexObj[i]) { + imesa->sarea->dirty |= I830_UPLOAD_TEX_N(i); + memcpy(imesa->sarea->TexState[i], + imesa->CurrentTexObj[i]->Setup, + sizeof(imesa->sarea->TexState[i])); + /* Update the LRU usage */ + i830UpdateTexLRU(imesa, imesa->CurrentTexObj[i]); } + } + /* Need to figure out if texturing state, or enable changed. */ - /* Need to figure out if texturing state, or enable changed. */ - - for(i = 0; i < I830_TEXBLEND_COUNT; i++) { - if (imesa->dirty & I830_UPLOAD_TEXBLEND_N(i)) { - imesa->sarea->dirty |= I830_UPLOAD_TEXBLEND_N(i); - memcpy(imesa->sarea->TexBlendState[i], - imesa->TexBlend[i], - imesa->TexBlendWordsUsed[i] * 4); - imesa->sarea->TexBlendStateWordsUsed[i] = - imesa->TexBlendWordsUsed[i]; - } + for(i = 0; i < I830_TEXBLEND_COUNT; i++) { + if (imesa->dirty & I830_UPLOAD_TEXBLEND_N(i)) { + imesa->sarea->dirty |= I830_UPLOAD_TEXBLEND_N(i); + memcpy(imesa->sarea->TexBlendState[i],imesa->TexBlend[i], + imesa->TexBlendWordsUsed[i] * 4); + imesa->sarea->TexBlendStateWordsUsed[i] = + imesa->TexBlendWordsUsed[i]; } + } - if (imesa->dirty & I830_UPLOAD_BUFFERS) - memcpy( imesa->sarea->BufferState, - imesa->BufferSetup, - sizeof(imesa->BufferSetup) ); + if (imesa->dirty & I830_UPLOAD_BUFFERS) { + if (DEBUGGING) + fprintf(stderr,"\nCopying BufferState to shared area\n"); + memcpy( imesa->sarea->BufferState,imesa->BufferSetup, + sizeof(imesa->BufferSetup) ); + } - if (imesa->dirty & I830_UPLOAD_TEX_PALETTE_SHARED) { - memcpy( imesa->sarea->Palette[0], - imesa->palette, - sizeof(imesa->sarea->Palette[0])); - } else { - i830TextureObjectPtr p; - - if (imesa->dirty & I830_UPLOAD_TEX_PALETTE_N(0)) { - p = imesa->CurrentTexObj[0]; - memcpy( imesa->sarea->Palette[0], - p->palette, - sizeof(imesa->sarea->Palette[0])); - } - if (imesa->dirty & I830_UPLOAD_TEX_PALETTE_N(1)) { - p = imesa->CurrentTexObj[1]; - memcpy( imesa->sarea->Palette[1], - p->palette, - sizeof(imesa->sarea->Palette[1])); - } + if (imesa->dirty & I830_UPLOAD_TEX_PALETTE_SHARED) { + memcpy( imesa->sarea->Palette[0],imesa->palette, + sizeof(imesa->sarea->Palette[0])); + } else { + i830TextureObjectPtr p; + if (imesa->dirty & I830_UPLOAD_TEX_PALETTE_N(0)) { + p = imesa->CurrentTexObj[0]; + memcpy( imesa->sarea->Palette[0],p->palette, + sizeof(imesa->sarea->Palette[0])); + } + if (imesa->dirty & I830_UPLOAD_TEX_PALETTE_N(1)) { + p = imesa->CurrentTexObj[1]; + memcpy( imesa->sarea->Palette[1], + p->palette, + sizeof(imesa->sarea->Palette[1])); } - - imesa->sarea->dirty |= (imesa->dirty & - ~(I830_UPLOAD_TEX_MASK | - I830_UPLOAD_TEXBLEND_MASK)); - imesa->dirty &= I830_UPLOAD_CLIPRECTS; } + imesa->sarea->dirty |= (imesa->dirty & ~(I830_UPLOAD_TEX_MASK | + I830_UPLOAD_TEXBLEND_MASK)); + + imesa->upload_cliprects = GL_TRUE; + imesa->dirty = 0; } -void i830DDInitState( i830ContextPtr imesa ) + +void i830DDInitState( GLcontext *ctx ) { + i830ContextPtr imesa = I830_CONTEXT(ctx); i830ScreenPrivate *i830Screen = imesa->i830Screen; int i, j; @@ -1411,11 +1255,15 @@ void i830DDInitState( i830ContextPtr imesa ) memset(imesa->Setup, 0, sizeof(imesa->Setup)); - imesa->Setup[I830_CTXREG_VF] = VRTX_FORMAT_NTEX(1); - + imesa->Setup[I830_CTXREG_VF] = (STATE3D_VERTEX_FORMAT_CMD | + VRTX_TEX_COORD_COUNT(1) | + VRTX_HAS_DIFFUSE | + VRTX_HAS_SPEC | + VRTX_HAS_XYZW); + imesa->vertex_format = 0; imesa->Setup[I830_CTXREG_VF2] = (STATE3D_VERTEX_FORMAT_2_CMD | VRTX_TEX_SET_0_FMT(TEXCOORDFMT_2D) | - VRTX_TEX_SET_1_FMT(TEXCOORDFMT_2D) | + VRTX_TEX_SET_1_FMT(TEXCOORDFMT_2D) | VRTX_TEX_SET_2_FMT(TEXCOORDFMT_2D) | VRTX_TEX_SET_3_FMT(TEXCOORDFMT_2D)); @@ -1457,41 +1305,41 @@ void i830DDInitState( i830ContextPtr imesa ) } imesa->Setup[I830_CTXREG_STATE1] = (STATE3D_MODES_1_CMD | - ENABLE_COLR_BLND_FUNC | - BLENDFUNC_ADD | - ENABLE_SRC_BLND_FACTOR | - SRC_BLND_FACT(BLENDFACT_ONE) | - ENABLE_DST_BLND_FACTOR | - DST_BLND_FACT(BLENDFACT_ZERO) ); + ENABLE_COLR_BLND_FUNC | + BLENDFUNC_ADD | + ENABLE_SRC_BLND_FACTOR | + SRC_BLND_FACT(BLENDFACT_ONE) | + ENABLE_DST_BLND_FACTOR | + DST_BLND_FACT(BLENDFACT_ZERO) ); imesa->Setup[I830_CTXREG_STATE2] = (STATE3D_MODES_2_CMD | - ENABLE_GLOBAL_DEPTH_BIAS | - GLOBAL_DEPTH_BIAS(0) | - ENABLE_ALPHA_TEST_FUNC | - ALPHA_TEST_FUNC(COMPAREFUNC_ALWAYS) | - ALPHA_REF_VALUE(0) ); + ENABLE_GLOBAL_DEPTH_BIAS | + GLOBAL_DEPTH_BIAS(0) | + ENABLE_ALPHA_TEST_FUNC | + ALPHA_TEST_FUNC(COMPAREFUNC_ALWAYS) | + ALPHA_REF_VALUE(0) ); imesa->Setup[I830_CTXREG_STATE3] = (STATE3D_MODES_3_CMD | - ENABLE_DEPTH_TEST_FUNC | - DEPTH_TEST_FUNC(COMPAREFUNC_LESS) | - ENABLE_ALPHA_SHADE_MODE | - ALPHA_SHADE_MODE(SHADE_MODE_LINEAR) | - ENABLE_FOG_SHADE_MODE | - FOG_SHADE_MODE(SHADE_MODE_LINEAR) | - ENABLE_SPEC_SHADE_MODE | - SPEC_SHADE_MODE(SHADE_MODE_LINEAR) | - ENABLE_COLOR_SHADE_MODE | - COLOR_SHADE_MODE(SHADE_MODE_LINEAR) | - ENABLE_CULL_MODE | - CULLMODE_NONE); + ENABLE_DEPTH_TEST_FUNC | + DEPTH_TEST_FUNC(COMPAREFUNC_LESS) | + ENABLE_ALPHA_SHADE_MODE | + ALPHA_SHADE_MODE(SHADE_MODE_LINEAR) | + ENABLE_FOG_SHADE_MODE | + FOG_SHADE_MODE(SHADE_MODE_LINEAR) | + ENABLE_SPEC_SHADE_MODE | + SPEC_SHADE_MODE(SHADE_MODE_LINEAR) | + ENABLE_COLOR_SHADE_MODE | + COLOR_SHADE_MODE(SHADE_MODE_LINEAR) | + ENABLE_CULL_MODE | + CULLMODE_NONE); imesa->Setup[I830_CTXREG_STATE4] = (STATE3D_MODES_4_CMD | - ENABLE_LOGIC_OP_FUNC | - LOGIC_OP_FUNC(LOGICOP_COPY) | - ENABLE_STENCIL_TEST_MASK | - STENCIL_TEST_MASK(0xff) | - ENABLE_STENCIL_WRITE_MASK | - STENCIL_WRITE_MASK(0xff)); + ENABLE_LOGIC_OP_FUNC | + LOGIC_OP_FUNC(LOGICOP_COPY) | + ENABLE_STENCIL_TEST_MASK | + STENCIL_TEST_MASK(0xff) | + ENABLE_STENCIL_WRITE_MASK | + STENCIL_WRITE_MASK(0xff)); imesa->Setup[I830_CTXREG_STENCILTST] = (STATE3D_STENCIL_TEST_CMD | ENABLE_STENCIL_PARMS | @@ -1513,14 +1361,14 @@ void i830DDInitState( i830ContextPtr imesa ) FIXED_POINT_WIDTH(1) ); imesa->Setup[I830_CTXREG_IALPHAB] = (STATE3D_INDPT_ALPHA_BLEND_CMD | - DISABLE_INDPT_ALPHA_BLEND | - ENABLE_ALPHA_BLENDFUNC | - ABLENDFUNC_ADD); + DISABLE_INDPT_ALPHA_BLEND | + ENABLE_ALPHA_BLENDFUNC | + ABLENDFUNC_ADD); imesa->Setup[I830_CTXREG_FOGCOLOR] = (STATE3D_FOG_COLOR_CMD | - FOG_COLOR_RED(0) | - FOG_COLOR_GREEN(0) | - FOG_COLOR_BLUE(0)); + FOG_COLOR_RED(0) | + FOG_COLOR_GREEN(0) | + FOG_COLOR_BLUE(0)); imesa->Setup[I830_CTXREG_BLENDCOLR0] = (STATE3D_CONST_BLEND_COLOR_CMD); @@ -1528,9 +1376,9 @@ void i830DDInitState( i830ContextPtr imesa ) imesa->Setup[I830_CTXREG_MCSB0] = STATE3D_MAP_COORD_SETBIND_CMD; imesa->Setup[I830_CTXREG_MCSB1] = (TEXBIND_SET3(TEXCOORDSRC_VTXSET_3) | - TEXBIND_SET2(TEXCOORDSRC_VTXSET_2) | - TEXBIND_SET1(TEXCOORDSRC_VTXSET_1) | - TEXBIND_SET0(TEXCOORDSRC_VTXSET_0)); + TEXBIND_SET2(TEXCOORDSRC_VTXSET_2) | + TEXBIND_SET1(TEXCOORDSRC_VTXSET_1) | + TEXBIND_SET0(TEXCOORDSRC_VTXSET_0)); imesa->LcsCullMode = CULLMODE_CW; /* GL default */ @@ -1555,21 +1403,21 @@ void i830DDInitState( i830ContextPtr imesa ) case DV_PF_555: case DV_PF_565: imesa->BufferSetup[I830_DESTREG_DV1] = (DSTORG_HORT_BIAS(0x8) | /* .5 */ - DSTORG_VERT_BIAS(0x8) | /* .5 */ - i830Screen->fbFormat | - DEPTH_IS_Z | - DEPTH_FRMT_16_FIXED); + DSTORG_VERT_BIAS(0x8) | /* .5 */ + i830Screen->fbFormat | + DEPTH_IS_Z | + DEPTH_FRMT_16_FIXED); break; case DV_PF_8888: imesa->BufferSetup[I830_DESTREG_DV1] = (DSTORG_HORT_BIAS(0x8) | /* .5 */ - DSTORG_VERT_BIAS(0x8) | /* .5 */ - i830Screen->fbFormat | - DEPTH_IS_Z | - DEPTH_FRMT_24_FIXED_8_OTHER); + DSTORG_VERT_BIAS(0x8) | /* .5 */ + i830Screen->fbFormat | + DEPTH_IS_Z | + DEPTH_FRMT_24_FIXED_8_OTHER); break; } imesa->BufferSetup[I830_DESTREG_SENABLE] = (STATE3D_SCISSOR_ENABLE_CMD | - DISABLE_SCISSOR_RECT); + DISABLE_SCISSOR_RECT); imesa->BufferSetup[I830_DESTREG_SR0] = STATE3D_SCISSOR_RECT_0_CMD; imesa->BufferSetup[I830_DESTREG_SR1] = 0; imesa->BufferSetup[I830_DESTREG_SR2] = 0; @@ -1590,86 +1438,64 @@ void i830DDInitState( i830ContextPtr imesa ) } -#define INTERESTED (~(NEW_MODELVIEW|NEW_PROJECTION|\ - NEW_TEXTURE_MATRIX|\ - NEW_USER_CLIP|NEW_CLIENT_STATE)) - -void i830DDUpdateState( GLcontext *ctx ) +static void i830InvalidateState( GLcontext *ctx, GLuint new_state ) { - i830ContextPtr imesa = I830_CONTEXT( ctx ); - - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s\n", __FUNCTION__); - - /* Have to do this here to detect texture fallbacks in time */ - if (imesa->new_state & I830_NEW_TEXTURE) - i830DDUpdateHwState( ctx ); - - - if (ctx->NewState & INTERESTED) { - i830DDChooseRenderState(ctx); - i830ChooseRasterSetupFunc(ctx); - } - - if (0) - fprintf(stderr, "IndirectTriangles %x Fallback %x\n", - imesa->IndirectTriangles, imesa->Fallback); - - if (!imesa->Fallback) { - ctx->IndirectTriangles &= ~DD_SW_RASTERIZE; - ctx->IndirectTriangles |= imesa->IndirectTriangles; - - ctx->Driver.PointsFunc=imesa->PointsFunc; - ctx->Driver.LineFunc=imesa->LineFunc; - ctx->Driver.TriangleFunc=imesa->TriangleFunc; - ctx->Driver.QuadFunc=imesa->QuadFunc; - } + _swrast_InvalidateState( ctx, new_state ); + _swsetup_InvalidateState( ctx, new_state ); + _ac_InvalidateState( ctx, new_state ); + _tnl_InvalidateState( ctx, new_state ); + I830_CONTEXT(ctx)->new_state |= new_state; } - void i830DDInitStateFuncs(GLcontext *ctx) { - i830ContextPtr imesa = I830_CONTEXT( ctx ); - - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s\n", __FUNCTION__); - - ctx->Driver.UpdateState = i830DDUpdateState; - ctx->Driver.Enable = i830DDEnable; - ctx->Driver.AlphaFunc = i830DDAlphaFunc; - ctx->Driver.BlendEquation = i830DDBlendEquation; - ctx->Driver.BlendFunc = i830DDBlendFunc; - ctx->Driver.BlendFuncSeparate = i830DDBlendFuncSeparate; - ctx->Driver.BlendConstColor = i830DDBlendConstColor; - ctx->Driver.DepthFunc = i830DDDepthFunc; - ctx->Driver.DepthMask = i830DDDepthMask; - ctx->Driver.Fogfv = i830DDFogfv; - ctx->Driver.Scissor = i830DDScissor; - ctx->Driver.CullFace = i830DDCullFaceFrontFace; - ctx->Driver.FrontFace = i830DDCullFaceFrontFace; - ctx->Driver.ColorMask = i830DDColorMask; - ctx->Driver.ReducedPrimitiveChange = i830DDReducedPrimitiveChange; - ctx->Driver.RenderStart = i830DDUpdateHwState; - ctx->Driver.RenderFinish = 0; - - ctx->Driver.LineStipple = 0; - ctx->Driver.LineWidth = i830DDLineWidth; - ctx->Driver.LogicOpcode = i830DDLogicOp; - ctx->Driver.SetReadBuffer = i830DDSetReadBuffer; - ctx->Driver.SetDrawBuffer = i830DDSetDrawBuffer; - ctx->Driver.Color = i830DDSetColor; - ctx->Driver.ClearColor = i830DDClearColor; - ctx->Driver.Dither = NULL; - ctx->Driver.Index = 0; - ctx->Driver.ClearIndex = 0; - ctx->Driver.IndexMask = 0; + /* Callbacks for internal Mesa events. + */ + ctx->Driver.UpdateState = i830InvalidateState; - if(imesa->hw_stencil) { - ctx->Driver.StencilFunc = i830DDStencilFunc; - ctx->Driver.StencilMask = i830DDStencilMask; - ctx->Driver.StencilOp = i830DDStencilOp; - } + /* API callbacks + */ + ctx->Driver.AlphaFunc = i830AlphaFunc; + ctx->Driver.BlendEquation = i830BlendEquation; + ctx->Driver.BlendFunc = i830BlendFunc; + ctx->Driver.BlendFuncSeparate = i830BlendFuncSeparate; + ctx->Driver.BlendColor = i830BlendColor; + ctx->Driver.ClearColor = i830ClearColor; + ctx->Driver.ColorMask = i830ColorMask; + ctx->Driver.CullFace = i830CullFaceFrontFace; + ctx->Driver.DepthFunc = i830DepthFunc; + ctx->Driver.DepthMask = i830DepthMask; + ctx->Driver.Enable = i830Enable; + ctx->Driver.Fogfv = i830Fogfv; + ctx->Driver.FrontFace = i830CullFaceFrontFace; + ctx->Driver.LineWidth = i830LineWidth; + ctx->Driver.PointSize = i830PointSize; + ctx->Driver.LogicOpcode = i830LogicOp; + ctx->Driver.PolygonStipple = i830PolygonStipple; + ctx->Driver.RenderMode = i830RenderMode; + ctx->Driver.Scissor = i830Scissor; + ctx->Driver.SetDrawBuffer = i830SetDrawBuffer; + ctx->Driver.ShadeModel = i830ShadeModel; + ctx->Driver.DepthRange = i830DepthRange; + ctx->Driver.Viewport = i830Viewport; + ctx->Driver.LightModelfv = i830LightModelfv; + + ctx->Driver.StencilFunc = i830StencilFunc; + ctx->Driver.StencilMask = i830StencilMask; + ctx->Driver.StencilOp = i830StencilOp; + + /* Pixel path fallbacks. + */ + ctx->Driver.Accum = _swrast_Accum; + ctx->Driver.Bitmap = _swrast_Bitmap; + ctx->Driver.CopyPixels = _swrast_CopyPixels; + ctx->Driver.DrawPixels = _swrast_DrawPixels; + ctx->Driver.ReadPixels = _swrast_ReadPixels; - ctx->Driver.LightModelfv = i830DDLightModelfv; - ctx->Driver.PointSize = i830DDPointSize; + /* Swrast hooks for imaging extensions: + */ + ctx->Driver.CopyColorTable = _swrast_CopyColorTable; + ctx->Driver.CopyColorSubTable = _swrast_CopyColorSubTable; + ctx->Driver.CopyConvolutionFilter1D = _swrast_CopyConvolutionFilter1D; + ctx->Driver.CopyConvolutionFilter2D = _swrast_CopyConvolutionFilter2D; } diff --git a/xc/lib/GL/mesa/src/drv/i830/i830_state.h b/xc/lib/GL/mesa/src/drv/i830/i830_state.h new file mode 100644 index 000000000..e6141e7a3 --- /dev/null +++ b/xc/lib/GL/mesa/src/drv/i830/i830_state.h @@ -0,0 +1,67 @@ +/************************************************************************** + +Copyright 2001 VA Linux Systems Inc., Fremont, California. + +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 +on 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 +ATI, VA LINUX SYSTEMS AND/OR THEIR 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. + +**************************************************************************/ + +/* $XFree86$ */ + +/* + * Author: + * Jeff Hartmann <jhartmann@2d3d.com> + * + * Heavily based on the I810 driver, which was written by: + * Keith Whitwell <keith@tungstengraphics.com> + */ +#ifndef _I830_STATE_H +#define _I830_STATE_H + +#include "i830_context.h" +/*Maths macros from mmath.h*/ +#define FloatToInt(F) ((int)(F)) + +/* + * * This function/macro is sensitive to precision. Test carefully + * * if you change it. + * */ +#define FLOAT_COLOR_TO_UBYTE_COLOR(b, f) \ + do { \ + union {GLfloat r; GLuint i; } tmp; \ + tmp.r = f; \ + b = ((tmp.i >= IEEE_ONE) \ + ? ((GLint)tmp.i < 0) ? (GLubyte)0 : (GLubyte)255 \ + : (tmp.r = tmp.r*(255.0F/256.0F) + 32768.0F, \ + (GLubyte)tmp.i)); \ + } while (0) + + + +extern void i830DDInitState( GLcontext *ctx ); +extern void i830DDInitStateFuncs( GLcontext *ctx ); + +extern void i830PrintDirty( const char *msg, GLuint state ); + +extern void i830Fallback( i830ContextPtr imesa, GLuint bit, GLboolean mode ); +#define FALLBACK( imesa, bit, mode ) i830Fallback( imesa, bit, mode ) +#endif diff --git a/xc/lib/GL/mesa/src/drv/i830/i830_tex.c b/xc/lib/GL/mesa/src/drv/i830/i830_tex.c index 783e765b1..a4dbc907c 100644 --- a/xc/lib/GL/mesa/src/drv/i830/i830_tex.c +++ b/xc/lib/GL/mesa/src/drv/i830/i830_tex.c @@ -1,6 +1,6 @@ /************************************************************************** -Copyright 2001 VA Linux Systems Inc., Fremont, California. +Copyright 2001 2d3d Inc., Delray Beach, FL All Rights Reserved. @@ -25,33 +25,48 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. **************************************************************************/ -/* $XFree86: xc/lib/GL/mesa/src/drv/i830/i830_tex.c,v 1.1 2001/10/04 18:28:21 alanh Exp $ */ +/* $XFree86$ */ /* * Author: - * Jeff Hartmann <jhartmann@valinux.com> + * Jeff Hartmann <jhartmann@2d3d.com> * * Heavily based on the I810 driver, which was written by: - * Keith Whitwell <keithw@valinux.com> + * Keith Whitwell <keithw@tungstengraphics.com> */ #include <stdlib.h> #include <stdio.h> #include <GL/gl.h> - -#include "types.h" +#include "glheader.h" +#include "mtypes.h" +#include "mem.h" +#include "simple_list.h" #include "enums.h" -#include "pb.h" -#include "dd.h" +#include "texstore.h" +#include "texformat.h" +#include "swrast/swrast.h" #include "mm.h" -#include "enums.h" -#include "i830_drv.h" +#include "i830_screen.h" +#include "i830_dri.h" +#include "i830_context.h" +#include "i830_tex.h" +#include "i830_state.h" #include "i830_ioctl.h" -#include "simple_list.h" -#include "texutil.h" + +/* + * Compute the 'S2.4' lod bias factor from the floating point OpenGL bias. + */ +static GLuint i830ComputeLodBias(GLfloat bias) +{ + int b = (int) (bias * 16.0) + 12; + if(b > 63) b = 63; + else if (b < -64) b = -64; + return (GLuint) (b & MAP_LOD_MASK); +} static void i830SetTexWrapping(i830TextureObjectPtr tex, GLenum swrap, GLenum twrap) @@ -72,7 +87,9 @@ static void i830SetTexWrapping(i830TextureObjectPtr tex, tex->Setup[I830_TEXREG_MCS] |= TEXCOORD_ADDR_U_MODE(TEXCOORDMODE_CLAMP_BORDER); break; + default: break; } + switch( twrap ) { case GL_REPEAT: tex->Setup[I830_TEXREG_MCS] |= TEXCOORD_ADDR_V_MODE(TEXCOORDMODE_WRAP); @@ -84,15 +101,15 @@ static void i830SetTexWrapping(i830TextureObjectPtr tex, tex->Setup[I830_TEXREG_MCS] |= TEXCOORD_ADDR_V_MODE(TEXCOORDMODE_CLAMP_BORDER); break; + default: break; } - } static void i830SetTexFilter(i830ContextPtr imesa, i830TextureObjectPtr t, - GLenum minf, GLenum magf) + GLenum minf, GLenum magf, + GLfloat bias) { - GLuint LastLevel; int minFilt = 0, mipFilt = 0, magFilt = 0; if(I830_DEBUG&DEBUG_VERBOSE_TRACE) @@ -110,6 +127,11 @@ static void i830SetTexFilter(i830ContextPtr imesa, case GL_NEAREST_MIPMAP_NEAREST: minFilt = FILTER_NEAREST; mipFilt = MIPFILTER_NEAREST; + + if(magf == GL_LINEAR) { + bias -= 0.5; + } + break; case GL_LINEAR_MIPMAP_NEAREST: minFilt = FILTER_LINEAR; @@ -118,6 +140,11 @@ static void i830SetTexFilter(i830ContextPtr imesa, case GL_NEAREST_MIPMAP_LINEAR: minFilt = FILTER_NEAREST; mipFilt = MIPFILTER_LINEAR; + + if(magf == GL_LINEAR) { + bias -= 0.5; + } + break; case GL_LINEAR_MIPMAP_LINEAR: minFilt = FILTER_LINEAR; @@ -129,10 +156,6 @@ static void i830SetTexFilter(i830ContextPtr imesa, break; } - I830_SET_FIELD(t->Setup[I830_TEXREG_MF], - MIN_FILTER_MASK | MIP_FILTER_MASK, - MIN_FILTER(minFilt) | mipFilt); - switch (magf) { case GL_NEAREST: magFilt = FILTER_NEAREST; @@ -147,39 +170,15 @@ static void i830SetTexFilter(i830ContextPtr imesa, } I830_SET_FIELD(t->Setup[I830_TEXREG_MF], - MAG_FILTER_MASK, MAG_FILTER(magFilt)); - - if (t->globj->MinFilter != GL_NEAREST && - t->globj->MinFilter != GL_LINEAR) { - LastLevel = t->max_level; - } else { - LastLevel = t->min_level; - } - - I830_SET_FIELD(t->Setup[I830_TEXREG_MLL], - LOD_MAX_MASK, - LOD_MAX(t->min_level << 4)); + MIN_FILTER_MASK | MIP_FILTER_MASK, + MIN_FILTER(minFilt) | mipFilt); - I830_SET_FIELD(t->Setup[I830_TEXREG_MLL], - LOD_MIN_MASK, - LOD_MIN(LastLevel)); + I830_SET_FIELD(t->Setup[I830_TEXREG_MF], + MAG_FILTER_MASK, MAG_FILTER(magFilt)); - /* See OpenGL 1.2 specification */ - if (magf == GL_LINEAR && (minf == GL_NEAREST_MIPMAP_NEAREST || - minf == GL_NEAREST_MIPMAP_LINEAR)) - { - /* c = 0.5 */ - I830_SET_FIELD(t->Setup[I830_TEXREG_MLC], - MAP_LOD_MASK, 0x10); - } else { - /* c = 0 */ - I830_SET_FIELD(t->Setup[I830_TEXREG_MLC], - MAP_LOD_MASK, 0x0); - } + t->Setup[I830_TEXREG_MLC] |= i830ComputeLodBias(bias); } - -/* XXX - have to make sure MI0 has length field set to include color */ static void i830SetTexBorderColor(i830TextureObjectPtr t, GLubyte color[4]) { if(I830_DEBUG&DEBUG_VERBOSE_TRACE) @@ -190,2069 +189,350 @@ static void i830SetTexBorderColor(i830TextureObjectPtr t, GLubyte color[4]) } -static void ReplicateMesaTexState(i830ContextPtr imesa, - i830TextureObjectPtr t, - struct gl_texture_object *mesatex) -{ - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s\n", __FUNCTION__); - - i830SetTexWrapping(t,mesatex->WrapS,mesatex->WrapT); - i830SetTexFilter(imesa, t,mesatex->MinFilter,mesatex->MagFilter); - i830SetTexBorderColor(t,mesatex->BorderColor); -} - -/* Utility function to setup the texture palette */ -static void -i830ConvertPalette(GLuint *data, const struct gl_color_table *table) +static void i830TexParameter( GLcontext *ctx, GLenum target, + struct gl_texture_object *tObj, + GLenum pname, const GLfloat *params ) { - const GLubyte *tableUB = (const GLubyte *) table->Table; - GLint width = table->Size; - GLuint r, g, b, a; - int i; + i830ContextPtr imesa = I830_CONTEXT(ctx); + i830TextureObjectPtr t = (i830TextureObjectPtr) tObj->DriverData; + GLuint unit = ctx->Texture.CurrentUnit; + if (!t) + return; - ASSERT(table->TableType == GL_UNSIGNED_BYTE); + if ( target != GL_TEXTURE_2D ) + return; - switch(table->Format) { - case GL_RGBA: - for(i = 0; i < width; i++) { - r = tableUB[i * 4 + 0]; - g = tableUB[i * 4 + 1]; - b = tableUB[i * 4 + 2]; - a = tableUB[i * 4 + 3]; - data[i] = I830PACKCOLOR4444(r, g, b, a); - } - break; - case GL_RGB: - for (i = 0; i < width; i++) { - r = tableUB[i * 3 + 0]; - g = tableUB[i * 3 + 1]; - b = tableUB[i * 3 + 2]; - data[i] = I830PACKCOLOR565(r, g, b); - } - break; - case GL_LUMINANCE: - for (i = 0; i < width; i++) { - r = tableUB[i]; - data[i] = (255 << 8) | r; - } - break; - case GL_ALPHA: - for (i = 0; i < width; i++) { - a = tableUB[i]; - data[i] = (a << 8) | 255; - } - break; - case GL_LUMINANCE_ALPHA: - for (i = 0; i < width; i++) { - r = tableUB[i * 2 + 0]; - a = tableUB[i * 2 + 1]; - data[i] = (a << 8) | r; - } - break; - case GL_INTENSITY: - for (i = 0; i < width; i++) { - a = tableUB[i]; - data[i] = (a << 8) | a; + /* Can't do the update now as we don't know whether to flush + * vertices or not. Setting imesa->new_state means that + * i830UpdateTextureState() will be called before any triangles are + * rendered. If a statechange has occurred, it will be detected at + * that point, and buffered vertices flushed. + */ + switch (pname) { + case GL_TEXTURE_MIN_FILTER: + case GL_TEXTURE_MAG_FILTER: + { + GLfloat bias = ctx->Texture.Unit[unit].LodBias; + i830SetTexFilter( imesa, t, tObj->MinFilter, tObj->MagFilter, bias ); } break; - } -} - -static i830TextureObjectPtr i830CreateTexObj(i830ContextPtr imesa, - struct gl_texture_object *tObj) -{ - i830TextureObjectPtr t; - GLuint height, width, pitch, i, textureFormat; - struct gl_texture_image *image; - - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s\n", __FUNCTION__); - - image = tObj->Image[ 0 ]; - if ( !image ) { - fprintf(stderr, "no image at level zero - not creating texobj\n"); - return 0; - } - - t = (i830TextureObjectPtr) calloc(1,sizeof(*t)); - if (!t) { - fprintf(stderr, "failed to allocate memory - not creating texobj\n"); - return 0; - } - switch( image->Format ) { - case GL_RGB: - image->TexFormat = &(_mesa_texformat_rgb565); - t->texelBytes = 2; - textureFormat = MAPSURF_16BIT | MT_16BIT_RGB565; - break; - case GL_RGBA: - image->TexFormat = &(_mesa_texformat_argb4444); - t->texelBytes = 2; - textureFormat = MAPSURF_16BIT | MT_16BIT_ARGB4444; + case GL_TEXTURE_WRAP_S: + case GL_TEXTURE_WRAP_T: + i830SetTexWrapping( t, tObj->WrapS, tObj->WrapT ); break; - case GL_ALPHA: - case GL_LUMINANCE: - case GL_LUMINANCE_ALPHA: - case GL_INTENSITY: - image->TexFormat = &(_mesa_texformat_al88); - t->texelBytes = 2; - textureFormat = MAPSURF_16BIT | MT_16BIT_AY88; + + case GL_TEXTURE_BORDER_COLOR: + i830SetTexBorderColor( t, tObj->BorderColor ); break; - case GL_COLOR_INDEX: - image->TexFormat = &(_mesa_texformat_ci8); - textureFormat = MAPSURF_8BIT_INDEXED; - t->texelBytes = 1; - - switch(tObj->Palette.Format) { - case GL_RGBA: - textureFormat |= MT_8BIT_IDX_ARGB4444; - break; - case GL_RGB: - textureFormat |= MT_8BIT_IDX_RGB565; - break; - case GL_LUMINANCE: - case GL_ALPHA: - case GL_LUMINANCE_ALPHA: - case GL_INTENSITY: - textureFormat |= MT_8BIT_IDX_AY88; break; - } - /* Insure the palette is loaded */ - i830ConvertPalette(t->palette, &tObj->Palette); - t->palette_format = tObj->Palette.Format; + case GL_TEXTURE_BASE_LEVEL: + case GL_TEXTURE_MAX_LEVEL: + case GL_TEXTURE_MIN_LOD: + case GL_TEXTURE_MAX_LOD: + /* This isn't the most efficient solution but there doesn't appear to + * be a nice alternative for Radeon. Since there's no LOD clamping, + * we just have to rely on loading the right subset of mipmap levels + * to simulate a clamped LOD. + */ + i830SwapOutTexObj( imesa, t ); break; - default: - fprintf(stderr, "i830CreateTexObj: bad image->Format\n"); - free( t ); - return 0; - } - - /* Figure out the size now (and count the levels). Upload won't be done - * until later. - */ - width = image->Width * t->texelBytes; - if(width % 4) { - fprintf(stderr, "Pitch is not a multiple of dwords\n"); - } - pitch = width; /* All pitches can be used, since we are not using - * tiled surfaces. - */ - - t->dirty_images = 0; - t->bound = 0; - - for ( height = i = 0 ; i < I830_TEX_MAXLEVELS && tObj->Image[i] ; i++ ) { - t->image[i].image = tObj->Image[i]; - t->image[i].offset = height * pitch; - t->image[i].internalFormat = image->Format; - t->dirty_images |= (1<<i); - height += t->image[i].image->Height; - } - - t->Pitch = pitch; - t->totalSize = height*pitch; - t->max_level = i-1; - t->min_level = 0; - t->globj = tObj; - t->age = 0; - - t->Setup[I830_TEXREG_MI0] = STATE3D_MAP_INFO_COLR_CMD; - - t->Setup[I830_TEXREG_MI1] = MAP_INFO_TEX(0) | - textureFormat | - MAP_INFO_OUTMUX_F0F1F2F3 | - MAP_INFO_VERTLINESTRIDE_0 | - MAP_INFO_VERTLINESTRIDEOFS_0 | - MAP_INFO_FORMAT_2D | - MAP_INFO_USE_FENCE; - - t->Setup[I830_TEXREG_MI2] = (((1 << image->HeightLog2) - 1) << 16) | - ((1 << image->WidthLog2) - 1); - - t->Setup[I830_TEXREG_MI3] = 0; - - t->Setup[I830_TEXREG_MI4] = ((pitch / 4) - 1) << 2; - - t->Setup[I830_TEXREG_MI5] = 0; - - t->Setup[I830_TEXREG_MLC] = STATE3D_MAP_LOD_CNTL_CMD | MAP_UNIT(0) | - ENABLE_TEXLOD_BIAS | - MAP_LOD_BIAS(0); - - t->Setup[I830_TEXREG_MLL] = STATE3D_MAP_LOD_LIMITS_CMD | MAP_UNIT(0) | - ENABLE_MAX_MIP_LVL | - LOD_MAX(t->min_level << 4) | - ENABLE_MIN_MIP_LVL | - LOD_MIN(t->max_level); - - /* I think this is context state, really. - */ - t->Setup[I830_TEXREG_MCS] = STATE3D_MAP_COORD_SET_CMD | MAP_UNIT(0) | - ENABLE_TEXCOORD_PARAMS | - TEXCOORDS_ARE_NORMAL | - TEXCOORDTYPE_CARTESIAN | - ENABLE_ADDR_V_CNTL | - TEXCOORD_ADDR_V_MODE(TEXCOORDMODE_WRAP) | - ENABLE_ADDR_U_CNTL | - TEXCOORD_ADDR_U_MODE(TEXCOORDMODE_WRAP); - - t->Setup[I830_TEXREG_MF] = STATE3D_MAP_FILTER_CMD | MAP_UNIT(0) | - ENABLE_MIP_MODE_FILTER | - MIPFILTER_NEAREST | - ENABLE_MAG_MODE_FILTER | - MAG_FILTER(FILTER_LINEAR) | - ENABLE_MIN_MODE_FILTER | - MIN_FILTER(FILTER_LINEAR); - - t->current_unit = 0; - - ReplicateMesaTexState(imesa, t,tObj); - tObj->DriverData = t; - /* Forces tex cache flush */ - imesa->dirty |= I830_UPLOAD_CTX; - make_empty_list( t ); - return t; -} - -void i830DestroyTexObj(i830ContextPtr imesa, i830TextureObjectPtr t) -{ - if (!t) return; - - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s\n", __FUNCTION__); - - /* This is sad - need to sync *in case* we upload a texture - * to this newly free memory... - */ - if (t->MemBlock) { - mmFreeMem(t->MemBlock); - t->MemBlock = 0; - - if (t->age > imesa->dirtyAge) - imesa->dirtyAge = t->age; - } - - if (t->globj) - t->globj->DriverData = 0; - - if (t->bound) - imesa->CurrentTexObj[t->bound - 1] = 0; - - remove_from_list(t); - free(t); -} - - -static void i830SwapOutTexObj(i830ContextPtr imesa, i830TextureObjectPtr t) -{ - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s\n", __FUNCTION__); - - if (t->MemBlock) { - mmFreeMem(t->MemBlock); - t->MemBlock = 0; - - if (t->age > imesa->dirtyAge) - imesa->dirtyAge = t->age; - } - - t->dirty_images = ~0; - move_to_tail(&(imesa->SwappedOut), t); -} - - - -/* Upload an image from mesa's internal copy. - */ -static void i830UploadTexLevel( i830TextureObjectPtr t, int level ) -{ - const struct gl_texture_image *image = t->image[level].image; - int i,j; - - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s\n", __FUNCTION__); - - if (I830_DEBUG & DEBUG_VERBOSE_LRU) - fprintf(stderr, "i830UploadTexLevel %d, BufAddr %p offset %x\n", - level, t->BufAddr, t->image[level].offset); - - switch (t->image[level].internalFormat) { - case GL_RGB: - { - GLushort *dst = (GLushort *)(t->BufAddr + t->image[level].offset); - GLubyte *src = (GLubyte *)image->Data; - - for (j = 0 ; j < image->Height ; j++, dst += (t->Pitch/2)) { - for (i = 0 ; i < image->Width ; i++) { - dst[i] = I830PACKCOLOR565(src[0],src[1],src[2]); - src += 3; - } - } - } - break; - - case GL_RGBA: - { - GLushort *dst = (GLushort *)(t->BufAddr + t->image[level].offset); - GLubyte *src = (GLubyte *)image->Data; - - for (j = 0 ; j < image->Height ; j++, dst += (t->Pitch/2)) { - for (i = 0 ; i < image->Width ; i++) { - dst[i] = I830PACKCOLOR4444(src[0],src[1],src[2],src[3]); - src += 4; - } - } - } - break; - - case GL_INTENSITY: - { - GLushort *dst = (GLushort *)(t->BufAddr + t->image[level].offset); - GLubyte *src = (GLubyte *)image->Data; - int i; - - for (j = 0 ; j < image->Height ; j++, dst += (t->Pitch/2)) { - for (i = 0 ; i < image->Width ; i++) { - dst[i] = (src[0] << 8) | (src[0]); - src ++; - } - } - } - break; - - case GL_LUMINANCE: - { - GLushort *dst = (GLushort *)(t->BufAddr + t->image[level].offset); - GLubyte *src = (GLubyte *)image->Data; - for (j = 0 ; j < image->Height ; j++, dst += (t->Pitch/2)) { - for (i = 0 ; i < image->Width ; i++) { - dst[i] = (255 << 8) | (src[0]); - src ++; - } - } - } - break; - - case GL_LUMINANCE_ALPHA: - { - GLushort *dst = (GLushort *)(t->BufAddr + t->image[level].offset); - GLubyte *src = (GLubyte *)image->Data; - - for (j = 0 ; j < image->Height ; j++, dst += (t->Pitch/2)) { - for (i = 0 ; i < image->Width ; i++) { - dst[i] = (src[1] << 8) | (src[0]); - src += 2; - } - } - } - break; - - case GL_ALPHA: - { - GLushort *dst = (GLushort *)(t->BufAddr + t->image[level].offset); - GLubyte *src = (GLubyte *)image->Data; - - for (j = 0 ; j < image->Height ; j++, dst += (t->Pitch/2)) { - for (i = 0 ; i < image->Width ; i++) { - dst[i] = (src[0] << 8) | 255; - src += 1; - } - } - } - break; - - case GL_COLOR_INDEX: - { - GLubyte *dst = (GLubyte *)(t->BufAddr + t->image[level].offset); - GLubyte *src = (GLubyte *)image->Data; - - for (j = 0 ; j < image->Height ; j++, dst += t->Pitch) { - for (i = 0 ; i < image->Width ; i++) { - dst[i] = src[0]; - src += 1; - } - } - } - break; - default: - fprintf(stderr, "Not supported texture format %s\n", - gl_lookup_enum_by_nr(image->Format)); - } -} - - - -void i830PrintLocalLRU( i830ContextPtr imesa ) -{ - i830TextureObjectPtr t; - int sz = 1 << (imesa->i830Screen->logTextureGranularity); - - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s\n", __FUNCTION__); - - foreach( t, &imesa->TexObjList ) { - if (!t->globj) - fprintf(stderr, "Placeholder %d at %x sz %x\n", - t->MemBlock->ofs / sz, - t->MemBlock->ofs, - t->MemBlock->size); - else - fprintf(stderr, "Texture (bound %d) at %x sz %x\n", - t->bound, - t->MemBlock->ofs, - t->MemBlock->size); - - } -} - -void i830PrintGlobalLRU( i830ContextPtr imesa ) -{ - int i, j; - I830TexRegion *list = imesa->sarea->texList; - - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s\n", __FUNCTION__); - - for (i = 0, j = I830_NR_TEX_REGIONS ; i < I830_NR_TEX_REGIONS ; i++) { - fprintf(stderr, "list[%d] age %d next %d prev %d\n", - j, list[j].age, list[j].next, list[j].prev); - j = list[j].next; - if (j == I830_NR_TEX_REGIONS) break; + return; } - - if (j != I830_NR_TEX_REGIONS) - fprintf(stderr, "Loop detected in global LRU\n"); -} - -void i830ResetGlobalLRU( i830ContextPtr imesa ) -{ - I830TexRegion *list = imesa->sarea->texList; - int sz = 1 << imesa->i830Screen->logTextureGranularity; - int i; - - /* (Re)initialize the global circular LRU list. The last element - * in the array (I830_NR_TEX_REGIONS) is the sentinal. Keeping it - * at the end of the array allows it to be addressed rationally - * when looking up objects at a particular location in texture - * memory. - */ - - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s\n", __FUNCTION__); - - for (i = 0 ; (i+1) * sz <= imesa->i830Screen->textureSize ; i++) { - list[i].prev = i-1; - list[i].next = i+1; - list[i].age = 0; + if (t == imesa->CurrentTexObj[unit]) { + I830_STATECHANGE( imesa, I830_UPLOAD_TEX0 ); } - - i--; - list[0].prev = I830_NR_TEX_REGIONS; - list[i].prev = i-1; - list[i].next = I830_NR_TEX_REGIONS; - list[I830_NR_TEX_REGIONS].prev = i; - list[I830_NR_TEX_REGIONS].next = 0; - imesa->sarea->texAge = 0; } -static void i830UpdateTexLRU( i830ContextPtr imesa, i830TextureObjectPtr t ) -{ - int i; - int logsz = imesa->i830Screen->logTextureGranularity; - int start = t->MemBlock->ofs >> logsz; - int end = (t->MemBlock->ofs + t->MemBlock->size - 1) >> logsz; - I830TexRegion *list = imesa->sarea->texList; - - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s\n", __FUNCTION__); - - imesa->texAge = ++imesa->sarea->texAge; - - /* Update our local LRU - */ - move_to_head( &(imesa->TexObjList), t ); - - /* Update the global LRU - */ - for (i = start ; i <= end ; i++) { - - list[i].in_use = 1; - list[i].age = imesa->texAge; - - /* remove_from_list(i) - */ - list[(unsigned)list[i].next].prev = list[i].prev; - list[(unsigned)list[i].prev].next = list[i].next; - - /* insert_at_head(list, i) - */ - list[i].prev = I830_NR_TEX_REGIONS; - list[i].next = list[I830_NR_TEX_REGIONS].next; - list[(unsigned)list[I830_NR_TEX_REGIONS].next].prev = i; - list[I830_NR_TEX_REGIONS].next = i; - } -} - - -/* Called for every shared texture region which has increased in age - * since we last held the lock. - * - * Figures out which of our textures have been ejected by other clients, - * and pushes a placeholder texture onto the LRU list to represent - * the other client's textures. - */ -void i830TexturesGone( i830ContextPtr imesa, - GLuint offset, - GLuint size, - GLuint in_use ) -{ - i830TextureObjectPtr t, tmp; - - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s\n", __FUNCTION__); - - foreach_s ( t, tmp, &imesa->TexObjList ) { - - if (t->MemBlock->ofs >= offset + size || - t->MemBlock->ofs + t->MemBlock->size <= offset) - continue; - - /* It overlaps - kick it off. Need to hold onto the currently bound - * objects, however. - */ - if (t->bound) - i830SwapOutTexObj( imesa, t ); - else - i830DestroyTexObj( imesa, t ); - } - - - if (in_use) { - t = (i830TextureObjectPtr) calloc(1,sizeof(*t)); - if (!t) return; - - t->MemBlock = mmAllocMem( imesa->texHeap, size, 0, offset); - insert_at_head( &imesa->TexObjList, t ); - } -} - -/* This is called with the lock held. May have to eject our own and/or - * other client's texture objects to make room for the upload. - */ -int i830UploadTexImages( i830ContextPtr imesa, i830TextureObjectPtr t ) +static void i830TexEnv( GLcontext *ctx, GLenum target, + GLenum pname, const GLfloat *param ) { - int i; - int ofs; - - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s\n", __FUNCTION__); + i830ContextPtr imesa = I830_CONTEXT( ctx ); + GLuint unit = ctx->Texture.CurrentUnit; - /* Do we need to eject LRU texture objects? + /* Only one env color. Need a fallback if env colors are different + * and texture setup references env color in both units. */ - if (!t->MemBlock) { - while (1) + switch (pname) { + case GL_TEXTURE_ENV_COLOR: + case GL_TEXTURE_ENV_MODE: + case GL_COMBINE_RGB_EXT: + case GL_COMBINE_ALPHA_EXT: + case GL_SOURCE0_RGB_EXT: + case GL_SOURCE1_RGB_EXT: + case GL_SOURCE2_RGB_EXT: + case GL_SOURCE0_ALPHA_EXT: + case GL_SOURCE1_ALPHA_EXT: + case GL_SOURCE2_ALPHA_EXT: + case GL_OPERAND0_RGB_EXT: + case GL_OPERAND1_RGB_EXT: + case GL_OPERAND2_RGB_EXT: + case GL_OPERAND0_ALPHA_EXT: + case GL_OPERAND1_ALPHA_EXT: + case GL_OPERAND2_ALPHA_EXT: + case GL_RGB_SCALE_EXT: + case GL_ALPHA_SCALE: + imesa->TexEnvImageFmt[unit] = 0; /* force recalc of env state */ + break; + + case GL_TEXTURE_LOD_BIAS_EXT: { - t->MemBlock = mmAllocMem( imesa->texHeap, t->totalSize, 12, 0 ); - if (t->MemBlock) - break; - - if (imesa->TexObjList.prev->bound) { - fprintf(stderr, "Hit bound texture in upload\n"); - i830PrintLocalLRU( imesa ); - return -1; - } - - if (imesa->TexObjList.prev == &(imesa->TexObjList)) { - fprintf(stderr, "Failed to upload texture, sz %d\n", t->totalSize); - mmDumpMemInfo( imesa->texHeap ); - return -1; + struct gl_texture_object *tObj = ctx->Texture.Unit[unit]._Current; + i830TextureObjectPtr t = (i830TextureObjectPtr) tObj->DriverData; + t->Setup[I830_TEXREG_MLC] &= ~(MLC_LOD_BIAS_MASK); + t->Setup[I830_TEXREG_MLC] |= i830ComputeLodBias(*param); + /* Do a state change */ + if (t == imesa->CurrentTexObj[unit]) { + I830_STATECHANGE( imesa, I830_UPLOAD_TEX_N(unit) ); } - - i830DestroyTexObj( imesa, imesa->TexObjList.prev ); - } - - ofs = t->MemBlock->ofs; - t->Setup[I830_TEXREG_MI3] = imesa->i830Screen->textureOffset + ofs; - t->BufAddr = imesa->i830Screen->tex.map + ofs; - imesa->dirty |= I830_UPLOAD_CTX; - } - - /* Let the world know we've used this memory recently. - */ - i830UpdateTexLRU( imesa, t ); - - if (I830_DEBUG & DEBUG_VERBOSE_LRU) - fprintf(stderr, "dispatch age: %d age freed memory: %d\n", - GET_DISPATCH_AGE(imesa), imesa->dirtyAge); - - if (imesa->dirtyAge >= GET_DISPATCH_AGE(imesa)) - i830WaitAgeLocked( imesa, imesa->dirtyAge ); - - - if (t->dirty_images) { - if (I830_DEBUG & DEBUG_VERBOSE_LRU) - fprintf(stderr, "*"); - - for (i = t->min_level ; i <= t->max_level ; i++) - if (t->dirty_images & (1<<i)) - i830UploadTexLevel( t, i ); - } - - - t->dirty_images = 0; - return 0; -} - -static void i830TexSetUnit( i830TextureObjectPtr t, GLuint unit ) -{ - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s unit(%d)\n", __FUNCTION__, unit); - - /* This will need to be changed when I support more then 2 t units */ - I830_SET_FIELD(t->Setup[I830_TEXREG_MI1], - MAP_INFO_MASK | MAP_INFO_USE_PALETTE_1, - MAP_INFO_TEX(unit) | MAP_INFO_USE_PALETTE_N(unit)); - I830_SET_FIELD(t->Setup[I830_TEXREG_MLC], MAP_UNIT_MASK, MAP_UNIT(unit)); - I830_SET_FIELD(t->Setup[I830_TEXREG_MLL], MAP_UNIT_MASK, MAP_UNIT(unit)); - I830_SET_FIELD(t->Setup[I830_TEXREG_MCS], MAP_UNIT_MASK, MAP_UNIT(unit)); - I830_SET_FIELD(t->Setup[I830_TEXREG_MF], MAP_UNIT_MASK, MAP_UNIT(unit)); - - t->current_unit = unit; -} - -static __inline__ GLuint GetTexelOp(GLint unit) -{ - switch(unit) { - case 0: return TEXBLENDARG_TEXEL0; - case 1: return TEXBLENDARG_TEXEL1; - case 2: return TEXBLENDARG_TEXEL2; - case 3: return TEXBLENDARG_TEXEL3; - default: return TEXBLENDARG_TEXEL0; - } -} - -/* Only 1.2 modes; make another func for combine, combine4, combiners */ -static void i830SetBlend_GL1_2(i830ContextPtr imesa, int curTex, - GLenum envMode, GLenum format) -{ - GLuint texel_op = GetTexelOp(curTex); - - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s %s %s unit (%d) texel_op(0x%x)\n", - __FUNCTION__, - gl_lookup_enum_by_nr(format), - gl_lookup_enum_by_nr(envMode), - curTex, - texel_op); - - switch(envMode) { - case GL_REPLACE: - switch(format) { - case GL_ALPHA: - imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_COLOR | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - DISABLE_TEX_CNTRL_STAGE | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ARG1); - imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_ALPHA | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ARG1); - imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_COLOR | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_ALPHA | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - texel_op); - imesa->TexBlendColorPipeNum[curTex] = 0; - imesa->TexBlendWordsUsed[curTex] = 4; - break; - case GL_LUMINANCE: - case GL_RGB: - imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_COLOR | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - DISABLE_TEX_CNTRL_STAGE | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ARG1); - imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_ALPHA | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ARG1); - imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_COLOR | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - texel_op); - imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_ALPHA | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlendColorPipeNum[curTex] = 0; - imesa->TexBlendWordsUsed[curTex] = 4; - break; - - case GL_INTENSITY: - case GL_LUMINANCE_ALPHA: - case GL_RGBA: - imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_COLOR | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - DISABLE_TEX_CNTRL_STAGE | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ARG1); - imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_ALPHA | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ARG1); - imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_COLOR | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - texel_op); - imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_ALPHA | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - texel_op); - imesa->TexBlendColorPipeNum[curTex] = 0; - imesa->TexBlendWordsUsed[curTex] = 4; - break; - default: - /* Always set to passthru if something is funny */ - imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(0) | - TEXPIPE_COLOR | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - DISABLE_TEX_CNTRL_STAGE | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ARG1); - imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(0) | - TEXPIPE_ALPHA | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ARG1); - imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(0) | - TEXPIPE_COLOR | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(0) | - TEXPIPE_ALPHA | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlendColorPipeNum[curTex] = 0; - imesa->TexBlendWordsUsed[curTex] = 4; - break; - } - break; - - case GL_MODULATE: - switch(format) { - case GL_ALPHA: - imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_COLOR | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - DISABLE_TEX_CNTRL_STAGE | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ARG1); - imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_ALPHA | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_MODULATE); - imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_COLOR | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_ALPHA | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - texel_op); - imesa->TexBlend[curTex][4] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_ALPHA | - TEXBLEND_ARG2 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlendColorPipeNum[curTex] = 0; - imesa->TexBlendWordsUsed[curTex] = 5; - break; - - case GL_LUMINANCE: - case GL_RGB: - imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_COLOR | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - DISABLE_TEX_CNTRL_STAGE | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_MODULATE); - imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_ALPHA | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ARG1); - imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_COLOR | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - texel_op); - imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_COLOR | - TEXBLEND_ARG2 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlend[curTex][4] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_ALPHA | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlendColorPipeNum[curTex] = 0; - imesa->TexBlendWordsUsed[curTex] = 5; - break; - - case GL_INTENSITY: - case GL_LUMINANCE_ALPHA: - case GL_RGBA: - imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_COLOR | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - DISABLE_TEX_CNTRL_STAGE | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_MODULATE); - imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_ALPHA | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_MODULATE); - imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_COLOR | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - texel_op); - imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_COLOR | - TEXBLEND_ARG2 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlend[curTex][4] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_ALPHA | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - texel_op); - imesa->TexBlend[curTex][5] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_ALPHA | - TEXBLEND_ARG2 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlendColorPipeNum[curTex] = 0; - imesa->TexBlendWordsUsed[curTex] = 6; - break; - default: - /* Always set to passthru if something is funny */ - imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(0) | - TEXPIPE_COLOR | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - DISABLE_TEX_CNTRL_STAGE | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ARG1); - imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(0) | - TEXPIPE_ALPHA | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ARG1); - imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(0) | - TEXPIPE_COLOR | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(0) | - TEXPIPE_ALPHA | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlendColorPipeNum[curTex] = 0; - imesa->TexBlendWordsUsed[curTex] = 4; - break; - } - break; - - case GL_DECAL: - switch(format) { - case GL_RGB: - imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_COLOR | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - DISABLE_TEX_CNTRL_STAGE | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ARG1); - imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_ALPHA | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ARG1); - imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_COLOR | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - texel_op); - imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_ALPHA | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlendColorPipeNum[curTex] = 0; - imesa->TexBlendWordsUsed[curTex] = 4; - break; - - case GL_RGBA: - imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_COLOR | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - DISABLE_TEX_CNTRL_STAGE | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_BLEND); - imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_ALPHA | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ARG1); - imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_COLOR | - TEXBLEND_ARG0 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_REPLICATE_ALPHA | - texel_op); - imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_COLOR | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - texel_op); - imesa->TexBlend[curTex][4] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_COLOR | - TEXBLEND_ARG2 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlend[curTex][5] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_ALPHA | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlendColorPipeNum[curTex] = 0; - imesa->TexBlendWordsUsed[curTex] = 6; - break; - default: - /* Always set to passthru if something is funny */ - imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(0) | - TEXPIPE_COLOR | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - DISABLE_TEX_CNTRL_STAGE | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ARG1); - imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(0) | - TEXPIPE_ALPHA | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ARG1); - imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(0) | - TEXPIPE_COLOR | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(0) | - TEXPIPE_ALPHA | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlendColorPipeNum[curTex] = 0; - imesa->TexBlendWordsUsed[curTex] = 4; - break; - } - break; - - case GL_BLEND: - switch(format) { - case GL_ALPHA: - imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_COLOR | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - DISABLE_TEX_CNTRL_STAGE | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ARG1); - imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_ALPHA | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_MODULATE); - imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_COLOR | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_ALPHA | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - texel_op); - imesa->TexBlend[curTex][4] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_ALPHA | - TEXBLEND_ARG2 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlendColorPipeNum[curTex] = 0; - imesa->TexBlendWordsUsed[curTex] = 5; - break; - - case GL_LUMINANCE: - case GL_RGB: - imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_COLOR | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - DISABLE_TEX_CNTRL_STAGE | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_BLEND); - imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_ALPHA | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ARG1); - imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_COLOR | - TEXBLEND_ARG0 | - TEXBLENDARG_MODIFY_PARMS | - texel_op); - imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_COLOR | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_FACTOR_N); - imesa->TexBlend[curTex][4] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_COLOR | - TEXBLEND_ARG2 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlend[curTex][5] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_ALPHA | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlendColorPipeNum[curTex] = 0; - imesa->TexBlendWordsUsed[curTex] = 6; - break; - - case GL_INTENSITY: - imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_COLOR | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - DISABLE_TEX_CNTRL_STAGE | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_BLEND); - imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_ALPHA | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_BLEND); - imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_COLOR | - TEXBLEND_ARG0 | - TEXBLENDARG_MODIFY_PARMS | - texel_op); - imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_COLOR | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_FACTOR_N); - imesa->TexBlend[curTex][4] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_COLOR | - TEXBLEND_ARG2 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlend[curTex][5] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_ALPHA | - TEXBLEND_ARG0 | - TEXBLENDARG_MODIFY_PARMS | - texel_op); - imesa->TexBlend[curTex][6] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_ALPHA | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_FACTOR_N); - imesa->TexBlend[curTex][7] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_ALPHA | - TEXBLEND_ARG2 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlendColorPipeNum[curTex] = 0; - imesa->TexBlendWordsUsed[curTex] = 8; - break; - - case GL_LUMINANCE_ALPHA: - case GL_RGBA: - imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_COLOR | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - DISABLE_TEX_CNTRL_STAGE | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_BLEND); - imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_ALPHA | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_MODULATE); - imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_COLOR | - TEXBLEND_ARG0 | - TEXBLENDARG_MODIFY_PARMS | - texel_op); - imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_COLOR | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_FACTOR_N); - imesa->TexBlend[curTex][4] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_COLOR | - TEXBLEND_ARG2 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlend[curTex][5] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_ALPHA | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - texel_op); - imesa->TexBlend[curTex][6] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_ALPHA | - TEXBLEND_ARG2 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlendColorPipeNum[curTex] = 0; - imesa->TexBlendWordsUsed[curTex] = 7; - break; - default: - /* Always set to passthru if something is funny */ - imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(0) | - TEXPIPE_COLOR | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - DISABLE_TEX_CNTRL_STAGE | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ARG1); - imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(0) | - TEXPIPE_ALPHA | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ARG1); - imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(0) | - TEXPIPE_COLOR | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(0) | - TEXPIPE_ALPHA | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlendColorPipeNum[curTex] = 0; - imesa->TexBlendWordsUsed[curTex] = 4; - break; } break; - case GL_ADD: - switch(format) { - case GL_ALPHA: - imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_COLOR | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - DISABLE_TEX_CNTRL_STAGE | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ARG1); - imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_ALPHA | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_MODULATE); - imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_COLOR | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_ALPHA | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - texel_op); - imesa->TexBlend[curTex][4] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_ALPHA | - TEXBLEND_ARG2 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlendColorPipeNum[curTex] = 0; - imesa->TexBlendWordsUsed[curTex] = 5; - break; - case GL_LUMINANCE: - case GL_RGB: - imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_COLOR | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - DISABLE_TEX_CNTRL_STAGE | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ADD); - imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_ALPHA | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ARG1); - imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_COLOR | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - texel_op); - imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_COLOR | - TEXBLEND_ARG2 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlend[curTex][4] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_ALPHA | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlendColorPipeNum[curTex] = 0; - imesa->TexBlendWordsUsed[curTex] = 5; - break; - - case GL_INTENSITY: - imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_COLOR | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - DISABLE_TEX_CNTRL_STAGE | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ADD); - imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_ALPHA | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ADD); - imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_COLOR | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - texel_op); - imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_COLOR | - TEXBLEND_ARG2 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlend[curTex][4] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_ALPHA | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - texel_op); - imesa->TexBlend[curTex][5] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_ALPHA | - TEXBLEND_ARG2 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlendColorPipeNum[curTex] = 0; - imesa->TexBlendWordsUsed[curTex] = 6; - break; - - case GL_LUMINANCE_ALPHA: - case GL_RGBA: - imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_COLOR | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - DISABLE_TEX_CNTRL_STAGE | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ADD); - imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | - TEXPIPE_ALPHA | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_MODULATE); - imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_COLOR | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - texel_op); - imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_COLOR | - TEXBLEND_ARG2 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlend[curTex][4] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_ALPHA | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - texel_op); - imesa->TexBlend[curTex][5] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | - TEXPIPE_ALPHA | - TEXBLEND_ARG2 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlendColorPipeNum[curTex] = 0; - imesa->TexBlendWordsUsed[curTex] = 6; - break; - default: - /* Always set to passthru if something is funny */ - imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(0) | - TEXPIPE_COLOR | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - DISABLE_TEX_CNTRL_STAGE | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ARG1); - imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(0) | - TEXPIPE_ALPHA | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ARG1); - imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(0) | - TEXPIPE_COLOR | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(0) | - TEXPIPE_ALPHA | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlendColorPipeNum[curTex] = 0; - imesa->TexBlendWordsUsed[curTex] = 4; - break; - } - break; default: - /* Always set to passthru if something is funny */ - imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(0) | - TEXPIPE_COLOR | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - DISABLE_TEX_CNTRL_STAGE | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ARG1); - imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(0) | - TEXPIPE_ALPHA | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ARG1); - imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(0) | - TEXPIPE_COLOR | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(0) | - TEXPIPE_ALPHA | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_CURRENT); - imesa->TexBlendColorPipeNum[curTex] = 0; - imesa->TexBlendWordsUsed[curTex] = 4; - break; + break; } +} - if (I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s\n", __FUNCTION__); -} - -static void i830SetTexEnvCombine(i830ContextPtr imesa, - struct gl_texture_unit *texUnit, - GLint unit) +static void i830TexImage2D( GLcontext *ctx, GLenum target, GLint level, + GLint internalFormat, + GLint width, GLint height, GLint border, + GLenum format, GLenum type, const GLvoid *pixels, + const struct gl_pixelstore_attrib *packing, + struct gl_texture_object *texObj, + struct gl_texture_image *texImage ) { - GLuint blendop; - GLuint ablendop; - GLuint args_RGB[3]; - GLuint args_A[3]; - GLuint texel_op = GetTexelOp(unit); - int i; - - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s\n", __FUNCTION__); - - switch(texUnit->CombineModeRGB) { - case GL_REPLACE: blendop = TEXBLENDOP_ARG1; break; - case GL_MODULATE: blendop = TEXBLENDOP_MODULATE; break; - case GL_ADD: blendop = TEXBLENDOP_ADD; break; - case GL_ADD_SIGNED_EXT: blendop = TEXBLENDOP_ADDSIGNED; break; - case GL_INTERPOLATE_EXT: blendop = TEXBLENDOP_BLEND; break; - default: return; - } - - switch(texUnit->CombineScaleShiftRGB) { - case 0: blendop |= TEXOP_SCALE_1X; break; - case 1: blendop |= TEXOP_SCALE_2X; break; - case 2: blendop |= TEXOP_SCALE_4X; break; - default: return; - } - - switch(texUnit->CombineModeA) { - case GL_REPLACE: ablendop = TEXBLENDOP_ARG1; break; - case GL_MODULATE: ablendop = TEXBLENDOP_MODULATE; break; - case GL_ADD: ablendop = TEXBLENDOP_ADD; break; - case GL_ADD_SIGNED_EXT: ablendop = TEXBLENDOP_ADDSIGNED; break; - case GL_INTERPOLATE_EXT: ablendop = TEXBLENDOP_BLEND; break; - default: return; - } - - switch(texUnit->CombineScaleShiftA) { - case 0: ablendop |= TEXOP_SCALE_1X; break; - case 1: ablendop |= TEXOP_SCALE_2X; break; - case 2: ablendop |= TEXOP_SCALE_4X; break; - default: return; - } - - /* Handle RGB args */ - for(i = 0; i < 3; i++) { - switch(texUnit->CombineSourceRGB[i]) { - case GL_TEXTURE: args_RGB[i] = texel_op; break; - case GL_CONSTANT_EXT: args_RGB[i] = TEXBLENDARG_FACTOR_N; break; - case GL_PRIMARY_COLOR_EXT: args_RGB[i] = TEXBLENDARG_DIFFUSE; break; - case GL_PREVIOUS_EXT: args_RGB[i] = TEXBLENDARG_CURRENT; break; - default: return; - } - - switch(texUnit->CombineOperandRGB[i]) { - case GL_SRC_COLOR: args_RGB[i] |= 0; break; - case GL_ONE_MINUS_SRC_COLOR: args_RGB[i] |= TEXBLENDARG_INV_ARG; break; - case GL_SRC_ALPHA: args_RGB[i] |= TEXBLENDARG_REPLICATE_ALPHA; break; - case GL_ONE_MINUS_SRC_ALPHA: - args_RGB[i] |= (TEXBLENDARG_REPLICATE_ALPHA | - TEXBLENDARG_INV_ARG); - break; - default: return; - } - } - - /* Handle A args */ - for(i = 0; i < 3; i++) { - switch(texUnit->CombineSourceA[i]) { - case GL_TEXTURE: args_A[i] = texel_op; break; - case GL_CONSTANT_EXT: args_A[i] = TEXBLENDARG_FACTOR_N; break; - case GL_PRIMARY_COLOR_EXT: args_A[i] = TEXBLENDARG_DIFFUSE; break; - case GL_PREVIOUS_EXT: args_A[i] = TEXBLENDARG_CURRENT; break; - default: return; - } - - switch(texUnit->CombineOperandA[i]) { - case GL_SRC_ALPHA: args_A[i] |= 0; break; - case GL_ONE_MINUS_SRC_ALPHA: args_A[i] |= TEXBLENDARG_INV_ARG; break; - default: return; - } - } - - /* Native Arg1 == Arg0 in GL_EXT_texture_env_combine spec */ - /* Native Arg2 == Arg1 in GL_EXT_texture_env_combine spec */ - /* Native Arg0 == Arg2 in GL_EXT_texture_env_combine spec */ - - /* When we render we need to figure out which is the last really enabled - * tex unit, and put last stage on it - */ - - imesa->TexBlendColorPipeNum[unit] = 0; - - /* Build color pipeline */ - - imesa->TexBlend[unit][0] = (STATE3D_MAP_BLEND_OP_CMD(unit) | - TEXPIPE_COLOR | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - DISABLE_TEX_CNTRL_STAGE | - TEXOP_MODIFY_PARMS | - blendop); - imesa->TexBlend[unit][1] = (STATE3D_MAP_BLEND_ARG_CMD(unit) | - TEXPIPE_COLOR | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - args_RGB[0]); - imesa->TexBlend[unit][2] = (STATE3D_MAP_BLEND_ARG_CMD(unit) | - TEXPIPE_COLOR | - TEXBLEND_ARG2 | - TEXBLENDARG_MODIFY_PARMS | - args_RGB[1]); - imesa->TexBlend[unit][3] = (STATE3D_MAP_BLEND_ARG_CMD(unit) | - TEXPIPE_COLOR | - TEXBLEND_ARG0 | - TEXBLENDARG_MODIFY_PARMS | - args_RGB[2]); - - /* Build Alpha pipeline */ - imesa->TexBlend[unit][4] = (STATE3D_MAP_BLEND_OP_CMD(unit) | - TEXPIPE_ALPHA | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - TEXOP_MODIFY_PARMS | - ablendop); - imesa->TexBlend[unit][5] = (STATE3D_MAP_BLEND_ARG_CMD(unit) | - TEXPIPE_ALPHA | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - args_A[0]); - imesa->TexBlend[unit][6] = (STATE3D_MAP_BLEND_ARG_CMD(unit) | - TEXPIPE_ALPHA | - TEXBLEND_ARG2 | - TEXBLENDARG_MODIFY_PARMS | - args_A[1]); - imesa->TexBlend[unit][7] = (STATE3D_MAP_BLEND_ARG_CMD(unit) | - TEXPIPE_ALPHA | - TEXBLEND_ARG0 | - TEXBLENDARG_MODIFY_PARMS | - args_A[2]); - - { - GLubyte r, g, b, a; - GLfloat *fc = texUnit->EnvColor; - - FLOAT_COLOR_TO_UBYTE_COLOR(r, fc[RCOMP]); - FLOAT_COLOR_TO_UBYTE_COLOR(g, fc[GCOMP]); - FLOAT_COLOR_TO_UBYTE_COLOR(b, fc[BCOMP]); - FLOAT_COLOR_TO_UBYTE_COLOR(a, fc[ACOMP]); - - imesa->TexBlend[unit][8] = STATE3D_COLOR_FACTOR_CMD(unit); - imesa->TexBlend[unit][9] = ((a << 24) | - (r << 16) | - (g << 8) | - b); + i830TextureObjectPtr t = (i830TextureObjectPtr) texObj->DriverData; + if (t) { + i830SwapOutTexObj( I830_CONTEXT(ctx), t ); } - imesa->TexBlendWordsUsed[unit] = 10; + _mesa_store_teximage2d( ctx, target, level, internalFormat, + width, height, border, format, type, + pixels, packing, texObj, texImage ); } -static void i830UpdateTexState( GLcontext *ctx, int unit ) +static void i830TexSubImage2D( GLcontext *ctx, + GLenum target, + GLint level, + GLint xoffset, GLint yoffset, + GLsizei width, GLsizei height, + GLenum format, GLenum type, + const GLvoid *pixels, + const struct gl_pixelstore_attrib *packing, + struct gl_texture_object *texObj, + struct gl_texture_image *texImage ) { - i830ContextPtr imesa = I830_CONTEXT(ctx); - struct gl_texture_object *tObj; - i830TextureObjectPtr t; - - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s\n", __FUNCTION__); - - tObj = ctx->Texture.Unit[unit].Current; - - if ( tObj != ctx->Texture.Unit[unit].CurrentD[2] ) - tObj = 0; - - /* XXX grantham - need to change this shift if "TEXTURE" flags change - in mesa/src/types.h */ - if (!(ctx->Texture.ReallyEnabled & (0xf << (4 * unit))) - || !tObj || !tObj->Complete) { - return; - } - - t = tObj->DriverData; - - if (!t) { - t = i830CreateTexObj( imesa, tObj ); - if (!t) return; - } - - i830TexSetUnit( t, unit ); - - if (t->dirty_images) { - if(unit == 0) imesa->dirty |= I830_UPLOAD_TEX0_IMAGE; - if(unit == 1) imesa->dirty |= I830_UPLOAD_TEX1_IMAGE; - } - - if((t->Setup[I830_TEXREG_MI1] & ((1<<26)|(1<<25)|(1<<24))) == - MAPSURF_8BIT_INDEXED) { - /* Texture palette needs updated, need to do this in a smarter - * way, since it will always be loaded each time paletted textures - * are used, and texture state is reeval'ed. - */ - if(0) fprintf(stderr, "\n\n\nUpdating texture palette\n"); - if(!ctx->Texture.SharedPalette) { - imesa->dirty |= I830_UPLOAD_TEX_PALETTE_N(unit); - if(0) fprintf(stderr, "per texobj palette\n"); - } else { - imesa->dirty |= I830_UPLOAD_TEX_PALETTE_SHARED; - if(0) fprintf(stderr, "shared palette\n"); - } + i830TextureObjectPtr t = (i830TextureObjectPtr) texObj->DriverData; + if (t) { + i830SwapOutTexObj( I830_CONTEXT(ctx), t ); } + _mesa_store_texsubimage2d(ctx, target, level, xoffset, yoffset, width, + height, format, type, pixels, packing, texObj, + texImage); - imesa->CurrentTexObj[unit] = t; - t->bound = 1; - - imesa->TexEnabledMask |= I830_TEX_UNIT_ENABLED(unit); - /* We only want the last texture unit, so we don't or this flag */ - imesa->LastTexEnabled = I830_TEX_UNIT_ENABLED(unit); - - /* Can't do this, we aren't locked here. Causes bad bad bad things */ -#if 0 - if (t->MemBlock) - i830UpdateTexLRU( imesa, t ); -#endif - } -static void i830UpdateTexBlend(GLcontext *ctx, int unit ) +static void i830BindTexture( GLcontext *ctx, GLenum target, + struct gl_texture_object *tObj ) { - i830ContextPtr imesa = I830_CONTEXT(ctx); - struct gl_texture_unit *texUnit; - struct gl_texture_object *texObj; - i830TextureObjectPtr t; - GLuint col; - - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s : unit %d\n", __FUNCTION__, unit); - - texUnit = &ctx->Texture.Unit[unit]; - texObj = ctx->Texture.Unit[unit].Current; - - if (!(ctx->Texture.ReallyEnabled & (0xf << (4 * unit))) - || !texObj || !texObj->Complete) { - return; - } - - t = (i830TextureObjectPtr) texObj->DriverData; - if (!t) { - t = i830CreateTexObj( imesa, texObj ); - if (!t) return; - } - - imesa->TexBlendWordsUsed[unit] = 0; - /* Could handle texenv_combine, register_combiners, combine4, etc */ - if(texUnit->EnvMode == GL_COMBINE_EXT) { - i830SetTexEnvCombine(imesa, - texUnit, - unit); - } else { - if(t->image[0].internalFormat == GL_COLOR_INDEX) { - if(!ctx->Texture.SharedPalette) { - i830SetBlend_GL1_2(imesa, unit, texUnit->EnvMode, - t->palette_format); - } else { - i830SetBlend_GL1_2(imesa, unit, texUnit->EnvMode, - imesa->palette_format); - - } - } else { - i830SetBlend_GL1_2(imesa, unit, texUnit->EnvMode, - t->image[0].internalFormat); + if (target == GL_TEXTURE_2D) { + i830ContextPtr imesa = I830_CONTEXT( ctx ); + i830TextureObjectPtr t = (i830TextureObjectPtr) tObj->DriverData; + + if (!t) { + GLfloat bias = ctx->Texture.Unit[ctx->Texture.CurrentUnit].LodBias; + t = CALLOC_STRUCT(i830_texture_object_t); + + /* Initialize non-image-dependent parts of the state: + */ + t->globj = tObj; + t->Setup[I830_TEXREG_MI0] = STATE3D_MAP_INFO_COLR_CMD; + t->Setup[I830_TEXREG_MI1] = (MAP_INFO_TEX(0) | + MAP_INFO_OUTMUX_F0F1F2F3 | + MAP_INFO_VERTLINESTRIDE_0 | + MAP_INFO_VERTLINESTRIDEOFS_0 | + MAP_INFO_FORMAT_2D | + MAP_INFO_USE_FENCE); + t->Setup[I830_TEXREG_MLC] = (STATE3D_MAP_LOD_CNTL_CMD | + MAP_UNIT(0) | + ENABLE_TEXLOD_BIAS | + MAP_LOD_BIAS(0)); + + t->Setup[I830_TEXREG_MCS] = (STATE3D_MAP_COORD_SET_CMD | + MAP_UNIT(0) | + ENABLE_TEXCOORD_PARAMS | + TEXCOORDS_ARE_NORMAL | + TEXCOORDTYPE_CARTESIAN | + ENABLE_ADDR_V_CNTL | + TEXCOORD_ADDR_V_MODE(TEXCOORDMODE_WRAP) | + ENABLE_ADDR_U_CNTL | + TEXCOORD_ADDR_U_MODE(TEXCOORDMODE_WRAP)); + + t->Setup[I830_TEXREG_MF] = (STATE3D_MAP_FILTER_CMD | + MAP_UNIT(0) | + ENABLE_MIP_MODE_FILTER | + MIPFILTER_NEAREST | + ENABLE_MAG_MODE_FILTER | + ENABLE_MIN_MODE_FILTER); + + t->dirty_images = ~0; + + tObj->DriverData = t; + make_empty_list( t ); + + i830SetTexWrapping( t, tObj->WrapS, tObj->WrapT ); + i830SetTexFilter( imesa, t, tObj->MinFilter, tObj->MagFilter, bias ); + i830SetTexBorderColor( t, tObj->BorderColor ); } - /* This only needs emitted when neccessary, fix it later */ - - /* add blend color */ - { - GLubyte r, g, b, a; - GLfloat *fc = texUnit->EnvColor; - - FLOAT_COLOR_TO_UBYTE_COLOR(r, fc[RCOMP]); - FLOAT_COLOR_TO_UBYTE_COLOR(g, fc[GCOMP]); - FLOAT_COLOR_TO_UBYTE_COLOR(b, fc[BCOMP]); - FLOAT_COLOR_TO_UBYTE_COLOR(a, fc[ACOMP]); - - col = ((a << 24) | - (r << 16) | - (g << 8) | - b); - } - - { - int i; - - i = imesa->TexBlendWordsUsed[unit]; - imesa->TexBlend[unit][i++] = STATE3D_COLOR_FACTOR_CMD(unit); - imesa->TexBlend[unit][i++] = col; - - imesa->TexBlendWordsUsed[unit] = i; - } - } - if(0) fprintf(stderr, "TexBlendWordsUsed : %d\n", imesa->TexBlendWordsUsed[unit]); -} - -void i830UpdateTextureState( GLcontext *ctx ) -{ - i830ContextPtr imesa = I830_CONTEXT(ctx); - int pipe_num = 0; - - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s\n", __FUNCTION__); - - if(ctx->Texture.ReallyEnabled & ~(TEXTURE0_2D|(TEXTURE0_2D<<4))) { - /* Bits are set for a fallback */ - if(0) fprintf(stderr, "Falling back to software for texturing\n"); - imesa->Fallback |= I830_FALLBACK_TEXTURE; - return; - } - imesa->LastTexEnabled = 0; - imesa->TexEnabledMask = 0; - - if (imesa->CurrentTexObj[0]) imesa->CurrentTexObj[0]->bound = 0; - if (imesa->CurrentTexObj[1]) imesa->CurrentTexObj[1]->bound = 0; - - imesa->CurrentTexObj[0] = 0; - imesa->CurrentTexObj[1] = 0; - - i830UpdateTexState( ctx, 0 ); - i830UpdateTexState( ctx, 1 ); - - i830UpdateTexBlend( ctx, 0 ); - i830UpdateTexBlend( ctx, 1 ); - - /* Need to decide the units to set to diffuse by looking at - * the texture units that actually got enabled */ - if(!(imesa->TexEnabledMask & I830_TEX_UNIT_ENABLED(0))) { - if(0) fprintf(stderr, "Diffuse got turned on\n"); - if(imesa->LastTexEnabled == 0) - imesa->LastTexEnabled = I830_TEX_UNIT_ENABLED(0); - - imesa->TexBlend[0][0] = (STATE3D_MAP_BLEND_OP_CMD(0) | - TEXPIPE_COLOR | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - DISABLE_TEX_CNTRL_STAGE | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ARG1); - imesa->TexBlend[0][1] = (STATE3D_MAP_BLEND_OP_CMD(0) | - TEXPIPE_ALPHA | - ENABLE_TEXOUTPUT_WRT_SEL | - TEXOP_OUTPUT_CURRENT | - TEXOP_SCALE_1X | - TEXOP_MODIFY_PARMS | - TEXBLENDOP_ARG1); - imesa->TexBlend[0][2] = (STATE3D_MAP_BLEND_ARG_CMD(0) | - TEXPIPE_COLOR | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_DIFFUSE); - imesa->TexBlend[0][3] = (STATE3D_MAP_BLEND_ARG_CMD(0) | - TEXPIPE_ALPHA | - TEXBLEND_ARG1 | - TEXBLENDARG_MODIFY_PARMS | - TEXBLENDARG_DIFFUSE); - imesa->TexBlendColorPipeNum[0] = 0; - imesa->TexBlendWordsUsed[0] = 4; - imesa->dirty |= I830_UPLOAD_TEXBLEND_N(0); - } - - switch(imesa->LastTexEnabled) { - case I830_TEX_UNIT_ENABLED(0): - if(0) fprintf(stderr, "Texture unit 0 is the last stage\n"); - pipe_num = imesa->TexBlendColorPipeNum[0]; - imesa->TexBlend[0][pipe_num] |= TEXOP_LAST_STAGE; - break; - case I830_TEX_UNIT_ENABLED(1): - if(0) fprintf(stderr, "Texture unit 1 is the last stage\n"); - pipe_num = imesa->TexBlendColorPipeNum[1]; - imesa->TexBlend[1][pipe_num] |= TEXOP_LAST_STAGE; - break; - default: break; - } - - /* Forces texture cache flush */ - imesa->dirty |= I830_UPLOAD_CTX; - if(imesa->TexEnabledMask & I830_TEX_UNIT_ENABLED(0)) { - if(0) fprintf(stderr, "Enabling Texture unit 0\n"); - imesa->dirty |= (I830_UPLOAD_TEX_N(0) | I830_UPLOAD_TEXBLEND_N(0)); - } - if(imesa->TexEnabledMask & I830_TEX_UNIT_ENABLED(1)) { - if(0) fprintf(stderr, "Enabling Texture unit 1\n"); - imesa->dirty |= (I830_UPLOAD_TEX_N(1) | I830_UPLOAD_TEXBLEND_N(1)); - } -} - - - -/***************************************** - * DRIVER functions - *****************************************/ - -/* TEXTURE_ENV_COLOR should be optimized, so we only flush when the - * color really changes - */ - -static void i830TexEnv( GLcontext *ctx, GLenum target, - GLenum pname, const GLfloat *param ) -{ - i830ContextPtr imesa = I830_CONTEXT( ctx ); - - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s\n", __FUNCTION__); - - /* Always flush texture state or texture_env_combine doesn't work */ - FLUSH_BATCH(imesa); - imesa->new_state |= I830_NEW_TEXTURE; -} - -static void i830TexImage( GLcontext *ctx, - GLenum target, - struct gl_texture_object *tObj, - GLint level, - GLint internalFormat, - const struct gl_texture_image *image ) -{ - i830ContextPtr imesa = I830_CONTEXT( ctx ); - i830TextureObjectPtr t; - - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s\n", __FUNCTION__); - - if (target != GL_TEXTURE_2D) - return; - - if (level >= I830_TEX_MAXLEVELS) - return; - - t = (i830TextureObjectPtr) tObj->DriverData; - if (t) { - if (t->bound) FLUSH_BATCH(imesa); - /* if this is the current object, it will force an update */ - i830DestroyTexObj( imesa, t ); - tObj->DriverData = 0; - imesa->new_state |= I830_NEW_TEXTURE; } } -static void i830TexSubImage( GLcontext *ctx, GLenum target, - struct gl_texture_object *tObj, GLint level, - GLint xoffset, GLint yoffset, - GLsizei width, GLsizei height, - GLint internalFormat, - const struct gl_texture_image *image ) +static void i830DeleteTexture( GLcontext *ctx, struct gl_texture_object *tObj ) { - i830ContextPtr imesa = I830_CONTEXT( ctx ); - i830TextureObjectPtr t; - - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s\n", __FUNCTION__); + i830TextureObjectPtr t = (i830TextureObjectPtr)tObj->DriverData; - if ( target != GL_TEXTURE_2D ) - return; - - t = (i830TextureObjectPtr) tObj->DriverData; if (t) { - if (t->bound) FLUSH_BATCH( imesa ); + i830ContextPtr imesa = I830_CONTEXT( ctx ); + if (imesa) + I830_FIREVERTICES( imesa ); i830DestroyTexObj( imesa, t ); tObj->DriverData = 0; - imesa->new_state |= I830_NEW_TEXTURE; } } -static void i830TexParameter( GLcontext *ctx, GLenum target, - struct gl_texture_object *tObj, - GLenum pname, const GLfloat *params ) -{ - i830TextureObjectPtr t = (i830TextureObjectPtr) tObj->DriverData; - i830ContextPtr imesa = I830_CONTEXT( ctx ); - - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s\n", __FUNCTION__); - - if (!t || target != GL_TEXTURE_2D) - return; - - switch (pname) { - case GL_TEXTURE_MIN_FILTER: - case GL_TEXTURE_MAG_FILTER: - if (t->bound) FLUSH_BATCH( imesa ); - i830SetTexFilter(imesa, t,tObj->MinFilter,tObj->MagFilter); - break; - - case GL_TEXTURE_WRAP_S: - case GL_TEXTURE_WRAP_T: - if (t->bound) FLUSH_BATCH( imesa ); - i830SetTexWrapping(t,tObj->WrapS,tObj->WrapT); - break; - - case GL_TEXTURE_BORDER_COLOR: - if (t->bound) FLUSH_BATCH( imesa ); - i830SetTexBorderColor(t,tObj->BorderColor); - break; - - default: - return; - } - - imesa->new_state |= I830_NEW_TEXTURE; -} - -static void i830BindTexture( GLcontext *ctx, GLenum target, - struct gl_texture_object *tObj ) +static GLboolean i830IsTextureResident( GLcontext *ctx, + struct gl_texture_object *tObj ) { - i830ContextPtr imesa = I830_CONTEXT( ctx ); - - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s\n", __FUNCTION__); - - FLUSH_BATCH(imesa); - - if (imesa->CurrentTexObj[ctx->Texture.CurrentUnit]) { - imesa->CurrentTexObj[ctx->Texture.CurrentUnit]->bound = 0; - imesa->CurrentTexObj[ctx->Texture.CurrentUnit] = 0; - } - - imesa->new_state |= I830_NEW_TEXTURE; + i830TextureObjectPtr t = (i830TextureObjectPtr)tObj->DriverData; + return t && t->MemBlock; } -static void i830DeleteTexture( GLcontext *ctx, struct gl_texture_object *tObj ) +static const struct gl_texture_format * +i830ChooseTextureFormat( GLcontext *ctx, GLint internalFormat, + GLenum format, GLenum type ) { - i830TextureObjectPtr t = (i830TextureObjectPtr)tObj->DriverData; i830ContextPtr imesa = I830_CONTEXT( ctx ); + const GLboolean do32bpt = ( imesa->i830Screen->cpp == 4 && + imesa->i830Screen->textureSize > 4*1024*1024); - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s\n", __FUNCTION__); - - if (t) { + switch ( internalFormat ) { + case 4: + case GL_RGBA: + if ( format == GL_BGRA ) { + if ( type == GL_UNSIGNED_INT_8_8_8_8_REV ) { + return &_mesa_texformat_argb8888; + } + else if ( type == GL_UNSIGNED_SHORT_4_4_4_4_REV ) { + return &_mesa_texformat_argb4444; + } + else if ( type == GL_UNSIGNED_SHORT_1_5_5_5_REV ) { + return &_mesa_texformat_argb1555; + } + } + return do32bpt ? &_mesa_texformat_argb8888 : &_mesa_texformat_argb4444; - if (t->bound) { - FLUSH_BATCH(imesa); - imesa->CurrentTexObj[t->bound-1] = 0; - imesa->new_state |= I830_NEW_TEXTURE; + case 3: + case GL_RGB: + if ( format == GL_RGB && type == GL_UNSIGNED_SHORT_5_6_5 ) { + return &_mesa_texformat_rgb565; } + return do32bpt ? &_mesa_texformat_argb8888 : &_mesa_texformat_rgb565; - i830DestroyTexObj(imesa,t); - tObj->DriverData=0; - } -} + case GL_RGBA8: + case GL_RGB10_A2: + case GL_RGBA12: + case GL_RGBA16: + return do32bpt ? &_mesa_texformat_argb8888 : &_mesa_texformat_argb4444; + case GL_RGBA4: + case GL_RGBA2: + return &_mesa_texformat_argb4444; -static GLboolean i830IsTextureResident( GLcontext *ctx, - struct gl_texture_object *t ) -{ - i830TextureObjectPtr mt; + case GL_RGB5_A1: + return &_mesa_texformat_argb1555; -/* LOCK_HARDWARE; */ - mt = (i830TextureObjectPtr)t->DriverData; -/* UNLOCK_HARDWARE; */ + case GL_RGB8: + case GL_RGB10: + case GL_RGB12: + case GL_RGB16: + return do32bpt ? &_mesa_texformat_argb8888 : &_mesa_texformat_rgb565; - return mt && mt->MemBlock; -} + case GL_RGB5: + case GL_RGB4: + case GL_R3_G3_B2: + return &_mesa_texformat_rgb565; -static void -i830DDTexturePalette(GLcontext *ctx, struct gl_texture_object *tObj) -{ - i830ContextPtr imesa = I830_CONTEXT(ctx); - i830TextureObjectPtr t; + case GL_ALPHA: + case GL_ALPHA4: + case GL_ALPHA8: + case GL_ALPHA12: + case GL_ALPHA16: + return &_mesa_texformat_al88; - imesa->new_state |= I830_NEW_TEXTURE; + case 1: + case GL_LUMINANCE: + case GL_LUMINANCE4: + case GL_LUMINANCE8: + case GL_LUMINANCE12: + case GL_LUMINANCE16: + return &_mesa_texformat_l8; - if(tObj) { - t = tObj->DriverData; + case 2: + case GL_LUMINANCE_ALPHA: + case GL_LUMINANCE4_ALPHA4: + case GL_LUMINANCE6_ALPHA2: + case GL_LUMINANCE8_ALPHA8: + case GL_LUMINANCE12_ALPHA4: + case GL_LUMINANCE12_ALPHA12: + case GL_LUMINANCE16_ALPHA16: + return &_mesa_texformat_al88; - if(!t) { - /* Will be handled elsewhere */ - return; - } + case GL_INTENSITY: + case GL_INTENSITY4: + case GL_INTENSITY8: + case GL_INTENSITY12: + case GL_INTENSITY16: + return &_mesa_texformat_i8; - i830ConvertPalette(t->palette, &tObj->Palette); - t->palette_format = tObj->Palette.Format; - } else { - i830ConvertPalette(imesa->palette, &ctx->Texture.Palette); - imesa->palette_format = ctx->Texture.Palette.Format; + default: + fprintf(stderr, "unexpected texture format in %s", __FUNCTION__); + return NULL; } + + return NULL; /* never get here */ } void i830DDInitTextureFuncs( GLcontext *ctx ) { - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s\n", __FUNCTION__); - ctx->Driver.TexEnv = i830TexEnv; - ctx->Driver.TexImage = i830TexImage; - ctx->Driver.TexSubImage = i830TexSubImage; + ctx->Driver.ChooseTextureFormat = i830ChooseTextureFormat; + ctx->Driver.TexImage1D = _mesa_store_teximage1d; + ctx->Driver.TexImage2D = i830TexImage2D; + ctx->Driver.TexImage3D = _mesa_store_teximage3d; + ctx->Driver.TexSubImage1D = _mesa_store_texsubimage1d; + ctx->Driver.TexSubImage2D = i830TexSubImage2D; + ctx->Driver.TexSubImage3D = _mesa_store_texsubimage3d; + ctx->Driver.CopyTexImage1D = _swrast_copy_teximage1d; + ctx->Driver.CopyTexImage2D = _swrast_copy_teximage2d; + ctx->Driver.CopyTexSubImage1D = _swrast_copy_texsubimage1d; + ctx->Driver.CopyTexSubImage2D = _swrast_copy_texsubimage2d; + ctx->Driver.CopyTexSubImage3D = _swrast_copy_texsubimage3d; ctx->Driver.BindTexture = i830BindTexture; ctx->Driver.DeleteTexture = i830DeleteTexture; ctx->Driver.TexParameter = i830TexParameter; - ctx->Driver.UpdateTexturePalette = i830DDTexturePalette; + ctx->Driver.UpdateTexturePalette = 0; ctx->Driver.IsTextureResident = i830IsTextureResident; + ctx->Driver.TestProxyTexImage = _mesa_test_proxy_teximage; + + { + GLuint tmp = ctx->Texture.CurrentUnit; + ctx->Texture.CurrentUnit = 0; + i830BindTexture( ctx, GL_TEXTURE_2D, ctx->Texture.Unit[0].Current2D); + ctx->Texture.CurrentUnit = 1; + i830BindTexture( ctx, GL_TEXTURE_2D, ctx->Texture.Unit[1].Current2D); + ctx->Texture.CurrentUnit = tmp; + } } diff --git a/xc/lib/GL/mesa/src/drv/i830/i830_tex.h b/xc/lib/GL/mesa/src/drv/i830/i830_tex.h new file mode 100644 index 000000000..03a898074 --- /dev/null +++ b/xc/lib/GL/mesa/src/drv/i830/i830_tex.h @@ -0,0 +1,90 @@ +/* + * GLX Hardware Device Driver for Intel i810 + * Copyright (C) 1999 Keith Whitwell + * + * 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 + * KEITH WHITWELL, OR ANY OTHER CONTRIBUTORS 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. + * + * Adapted for use in the I830M driver: + * Jeff Hartmann <jhartmann@2d3d.com> + */ + +#ifndef I830TEX_INC +#define I830TEX_INC + +#include "mtypes.h" +#include "mmath.h" +#include "mm.h" +#include "i830_context.h" +#include "i830_3d_reg.h" + +#define I830_TEX_MAXLEVELS 10 + +struct i830_texture_object_t +{ + struct i830_texture_object_t *next, *prev; + GLuint age; + struct gl_texture_object *globj; + int Pitch; + int Height; + int texelBytes; + int totalSize; + int bound; + PMemBlock MemBlock; + char *BufAddr; + GLuint min_level; + GLuint max_level; + GLuint dirty_images; + GLenum palette_format; + GLuint palette[256]; + struct + { + const struct gl_texture_image *image; + int offset; /* into BufAddr */ + int height; + int internalFormat; + }image[I830_TEX_MAXLEVELS]; + + /* Support for multitexture. + * */ + GLuint current_unit; + GLuint Setup[I830_TEX_SETUP_SIZE]; + GLuint dirty; + GLuint firstLevel,lastLevel; +}; + +void i830UpdateTextureState( GLcontext *ctx ); +void i830DDInitTextureFuncs( GLcontext *ctx ); +void i830UpdateTexUnitProj( GLcontext *ctx, GLuint unit, GLboolean state ); + + +void i830DestroyTexObj( i830ContextPtr imesa, i830TextureObjectPtr t ); +void i830SwapOutTexObj( i830ContextPtr imesa, i830TextureObjectPtr t ); +int i830UploadTexImages( i830ContextPtr imesa, i830TextureObjectPtr t ); + +void i830ResetGlobalLRU( i830ContextPtr imesa ); +void i830TexturesGone( i830ContextPtr imesa, + GLuint start, GLuint end, + GLuint in_use ); + +void i830PrintLocalLRU( i830ContextPtr imesa ); +void i830PrintGlobalLRU( i830ContextPtr imesa ); +void i830UpdateTexLRU( i830ContextPtr imesa, i830TextureObjectPtr t ); + + +#endif diff --git a/xc/lib/GL/mesa/src/drv/i830/i830_texmem.c b/xc/lib/GL/mesa/src/drv/i830/i830_texmem.c new file mode 100644 index 000000000..16a5709ed --- /dev/null +++ b/xc/lib/GL/mesa/src/drv/i830/i830_texmem.c @@ -0,0 +1,380 @@ +/************************************************************************** + +Copyright 2001 2d3d Inc., Delray Beach, FL + +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 +on 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 +ATI, VA LINUX SYSTEMS AND/OR THEIR 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. + +**************************************************************************/ + +/* $XFree86$ */ + +/* + * Author: + * Jeff Hartmann <jhartmann@2d3d.com> + * + * Heavily based on the I810 driver, which was written by: + * Keith Whitwell <keithw@tungstengraphics.com> + */ + +#include <stdlib.h> +#include <stdio.h> + +#include "glheader.h" +#include "macros.h" +#include "mtypes.h" +#include "simple_list.h" +#include "enums.h" +#include "texformat.h" + +#include "mm.h" + +#include "i830_screen.h" +#include "i830_dri.h" + +#include "i830_context.h" +#include "i830_tex.h" +#include "i830_state.h" +#include "i830_ioctl.h" + + +void i830DestroyTexObj(i830ContextPtr imesa, i830TextureObjectPtr t) +{ + if (!t) return; + + /* This is sad - need to sync *in case* we upload a texture + * to this newly free memory... + */ + if (t->MemBlock) { + mmFreeMem(t->MemBlock); + t->MemBlock = 0; + + if (imesa && t->age > imesa->dirtyAge) + imesa->dirtyAge = t->age; + } + + if (t->globj) + t->globj->DriverData = 0; + + if (imesa) { + if (imesa->CurrentTexObj[0] == t) { + imesa->CurrentTexObj[0] = 0; + imesa->dirty &= ~I830_UPLOAD_TEX0; + } + + if (imesa->CurrentTexObj[1] == t) { + imesa->CurrentTexObj[1] = 0; + imesa->dirty &= ~I830_UPLOAD_TEX1; + } + } + + remove_from_list(t); + free(t); +} + + +void i830SwapOutTexObj(i830ContextPtr imesa, i830TextureObjectPtr t) +{ +/* fprintf(stderr, "%s\n", __FUNCTION__); */ + + if (t->MemBlock) { + mmFreeMem(t->MemBlock); + t->MemBlock = 0; + + if (t->age > imesa->dirtyAge) + imesa->dirtyAge = t->age; + } + + t->dirty_images = ~0; + move_to_tail(&(imesa->SwappedOut), t); +} + + + +/* Upload an image from mesa's internal copy. + */ +static void i830UploadTexLevel( i830TextureObjectPtr t, int level ) +{ + const struct gl_texture_image *image = t->image[level].image; + int i,j; + + if (0) fprintf(stderr, "Uploading level : %d\n", level); + + switch (image->TexFormat->MesaFormat) { + case MESA_FORMAT_I8: + case MESA_FORMAT_L8: + { + GLubyte *dst = (GLubyte *)(t->BufAddr + t->image[level].offset); + GLubyte *src = (GLubyte *)image->Data; + + for (j = 0 ; j < image->Height ; j++, dst += t->Pitch) { + for (i = 0 ; i < image->Width ; i++) { + dst[i] = src[0]; + src++; + } + } + } + break; + + case MESA_FORMAT_AL88: + case MESA_FORMAT_RGB565: + case MESA_FORMAT_ARGB1555: + case MESA_FORMAT_ARGB4444: + { + GLushort *dst = (GLushort *)(t->BufAddr + t->image[level].offset); + GLushort *src = (GLushort *)image->Data; + + for (j = 0 ; j < image->Height ; j++, dst += (t->Pitch/2)) { + for (i = 0 ; i < image->Width ; i++) { + dst[i] = src[0]; + src++; + } + } + } + break; + + case MESA_FORMAT_ARGB8888: + { + GLuint *dst = (GLuint *)(t->BufAddr + t->image[level].offset); + GLuint *src = (GLuint *)image->Data; + + for (j = 0 ; j < image->Height ; j++, dst += (t->Pitch/4)) { + for (i = 0 ; i < image->Width ; i++) { + dst[i] = src[0]; + src++; + } + } + } + break; + + default: + fprintf(stderr, "Not supported texture format %s\n", + _mesa_lookup_enum_by_nr(image->Format)); + } +} + +void i830PrintLocalLRU( i830ContextPtr imesa ) +{ + i830TextureObjectPtr t; + int sz = 1 << (imesa->i830Screen->logTextureGranularity); + + foreach( t, &imesa->TexObjList ) { + if (!t->globj) + fprintf(stderr, "Placeholder %d at %x sz %x\n", + t->MemBlock->ofs / sz, + t->MemBlock->ofs, + t->MemBlock->size); + else + fprintf(stderr, "Texture at %x sz %x\n", + t->MemBlock->ofs, + t->MemBlock->size); + + } +} + +void i830PrintGlobalLRU( i830ContextPtr imesa ) +{ + int i, j; + I830TexRegion *list = imesa->sarea->texList; + + for (i = 0, j = I830_NR_TEX_REGIONS ; i < I830_NR_TEX_REGIONS ; i++) { + fprintf(stderr, "list[%d] age %d next %d prev %d\n", + j, list[j].age, list[j].next, list[j].prev); + j = list[j].next; + if (j == I830_NR_TEX_REGIONS) break; + } + + if (j != I830_NR_TEX_REGIONS) + fprintf(stderr, "Loop detected in global LRU\n"); +} + + +void i830ResetGlobalLRU( i830ContextPtr imesa ) +{ + I830TexRegion *list = imesa->sarea->texList; + int sz = 1 << imesa->i830Screen->logTextureGranularity; + int i; + + /* (Re)initialize the global circular LRU list. The last element + * in the array (I830_NR_TEX_REGIONS) is the sentinal. Keeping it + * at the end of the array allows it to be addressed rationally + * when looking up objects at a particular location in texture + * memory. + */ + for (i = 0 ; (i+1) * sz <= imesa->i830Screen->textureSize ; i++) { + list[i].prev = i-1; + list[i].next = i+1; + list[i].age = 0; + } + + i--; + list[0].prev = I830_NR_TEX_REGIONS; + list[i].prev = i-1; + list[i].next = I830_NR_TEX_REGIONS; + list[I830_NR_TEX_REGIONS].prev = i; + list[I830_NR_TEX_REGIONS].next = 0; + imesa->sarea->texAge = 0; +} + + +void i830UpdateTexLRU( i830ContextPtr imesa, i830TextureObjectPtr t ) +{ + int i; + int logsz = imesa->i830Screen->logTextureGranularity; + int start = t->MemBlock->ofs >> logsz; + int end = (t->MemBlock->ofs + t->MemBlock->size - 1) >> logsz; + I830TexRegion *list = imesa->sarea->texList; + + imesa->texAge = ++imesa->sarea->texAge; + + /* Update our local LRU + */ + move_to_head( &(imesa->TexObjList), t ); + + /* Update the global LRU + */ + for (i = start ; i <= end ; i++) { + + list[i].in_use = 1; + list[i].age = imesa->texAge; + + /* remove_from_list(i) + */ + list[(unsigned)list[i].next].prev = list[i].prev; + list[(unsigned)list[i].prev].next = list[i].next; + + /* insert_at_head(list, i) + */ + list[i].prev = I830_NR_TEX_REGIONS; + list[i].next = list[I830_NR_TEX_REGIONS].next; + list[(unsigned)list[I830_NR_TEX_REGIONS].next].prev = i; + list[I830_NR_TEX_REGIONS].next = i; + } +} + + +/* Called for every shared texture region which has increased in age + * since we last held the lock. + * + * Figures out which of our textures have been ejected by other clients, + * and pushes a placeholder texture onto the LRU list to represent + * the other client's textures. + */ +void i830TexturesGone( i830ContextPtr imesa, + GLuint offset, + GLuint size, + GLuint in_use ) +{ + i830TextureObjectPtr t, tmp; + + if (I830_DEBUG&DEBUG_VERBOSE_TRACE) + fprintf(stderr, "%s\n", __FUNCTION__); + + foreach_s ( t, tmp, &imesa->TexObjList ) { + if (t->MemBlock->ofs >= offset + size || + t->MemBlock->ofs + t->MemBlock->size <= offset) + continue; + + /* It overlaps - kick it off. Need to hold onto the currently bound + * objects, however. + */ + if (t->bound) + i830SwapOutTexObj( imesa, t ); + else + i830DestroyTexObj( imesa, t ); + } + + if (in_use) { + t = (i830TextureObjectPtr) calloc(1,sizeof(*t)); + if (!t) return; + + t->MemBlock = mmAllocMem( imesa->texHeap, size, 0, offset); + insert_at_head( &imesa->TexObjList, t ); + } +} + + +/* This is called with the lock held. May have to eject our own and/or + * other client's texture objects to make room for the upload. + */ + +int i830UploadTexImages( i830ContextPtr imesa, i830TextureObjectPtr t ) +{ + int i; + int ofs; + int numLevels; + + /* Do we need to eject LRU texture objects? + */ + if (!t->MemBlock) { + while (1) + { + t->MemBlock = mmAllocMem( imesa->texHeap, t->totalSize, 12, 0 ); + if (t->MemBlock) + break; + + if (imesa->TexObjList.prev == imesa->CurrentTexObj[0] || + imesa->TexObjList.prev == imesa->CurrentTexObj[1]) { + fprintf(stderr, "Hit bound texture in upload\n"); + i830PrintLocalLRU( imesa ); + return -1; + } + + if (imesa->TexObjList.prev == &(imesa->TexObjList)) { + fprintf(stderr, "Failed to upload texture, sz %d\n", t->totalSize); + mmDumpMemInfo( imesa->texHeap ); + return -1; + } + + i830SwapOutTexObj( imesa, imesa->TexObjList.prev ); + } + + ofs = t->MemBlock->ofs; + t->BufAddr = imesa->i830Screen->tex.map + ofs; + t->Setup[I830_TEXREG_MI3] = imesa->i830Screen->textureOffset + ofs; + + if (t == imesa->CurrentTexObj[0]) + I830_STATECHANGE(imesa, I830_UPLOAD_TEX0); + + if (t == imesa->CurrentTexObj[1]) + I830_STATECHANGE(imesa, I830_UPLOAD_TEX1); +#if 0 + if (t == imesa->CurrentTexObj[2]) + I830_STATECHANGE(imesa, I830_UPLOAD_TEX2); + + if (t == imesa->CurrentTexObj[3]) + I830_STATECHANGE(imesa, I830_UPLOAD_TEX3); +#endif + i830UpdateTexLRU( imesa, t ); + } + + if (imesa->dirtyAge >= GET_DISPATCH_AGE(imesa)) + i830WaitAgeLocked( imesa, imesa->dirtyAge ); + + numLevels = t->lastLevel - t->firstLevel + 1; + for (i = 0 ; i < numLevels ; i++) + if (t->dirty_images & (1<<i)) + i830UploadTexLevel( t, i ); + + t->dirty_images = 0; + + return 0; +} diff --git a/xc/lib/GL/mesa/src/drv/i830/i830_texstate.c b/xc/lib/GL/mesa/src/drv/i830/i830_texstate.c new file mode 100644 index 000000000..0f002cd50 --- /dev/null +++ b/xc/lib/GL/mesa/src/drv/i830/i830_texstate.c @@ -0,0 +1,1430 @@ +/************************************************************************** + +Copyright 2001 2d3d Inc., Delray Beach, FL + +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 +on 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 +ATI, VA LINUX SYSTEMS AND/OR THEIR 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. + +**************************************************************************/ + +/* $XFree86$ */ + +/* + * Author: + * Jeff Hartmann <jhartmann@2d3d.com> + * + * Heavily based on the I810 driver, which was written by: + * Keith Whitwell <keithw@tungstengraphics.com> + */ +#include <stdlib.h> +#include <stdio.h> + +#include "glheader.h" +#include "macros.h" +#include "mtypes.h" +#include "simple_list.h" +#include "enums.h" +#include "texformat.h" +#include "texstore.h" +#include "texutil.h" + +#include "mm.h" + +#include "i830_screen.h" +#include "i830_dri.h" + +#include "i830_context.h" +#include "i830_tex.h" +#include "i830_state.h" +#include "i830_ioctl.h" + +static void i830SetTexImages( i830ContextPtr imesa, + struct gl_texture_object *tObj ) +{ + GLuint height, width, pitch, i, textureFormat; + i830TextureObjectPtr t = (i830TextureObjectPtr) tObj->DriverData; + const struct gl_texture_image *baseImage = tObj->Image[tObj->BaseLevel]; + GLint firstLevel, lastLevel, numLevels; + GLint log2Width, log2Height; + + switch( baseImage->TexFormat->MesaFormat ) { + case MESA_FORMAT_L8: + t->texelBytes = 1; + textureFormat = MAPSURF_8BIT | MT_8BIT_L8; + break; + + case MESA_FORMAT_I8: + t->texelBytes = 1; + textureFormat = MAPSURF_8BIT | MT_8BIT_I8; + break; + + case MESA_FORMAT_AL88: + t->texelBytes = 2; + textureFormat = MAPSURF_16BIT | MT_16BIT_AY88; + break; + + case MESA_FORMAT_RGB565: + t->texelBytes = 2; + textureFormat = MAPSURF_16BIT | MT_16BIT_RGB565; + break; + + case MESA_FORMAT_ARGB1555: + t->texelBytes = 2; + textureFormat = MAPSURF_16BIT | MT_16BIT_ARGB1555; + break; + + case MESA_FORMAT_ARGB4444: + t->texelBytes = 2; + textureFormat = MAPSURF_16BIT | MT_16BIT_ARGB4444; + break; + + case MESA_FORMAT_ARGB8888: + t->texelBytes = 4; + textureFormat = MAPSURF_32BIT | MT_32BIT_ARGB8888; + break; + + default: + fprintf(stderr, "%s: bad image format\n", __FUNCTION__); + free( t ); + return; + } + + /* Compute which mipmap levels we really want to send to the hardware. + * This depends on the base image size, GL_TEXTURE_MIN_LOD, + * GL_TEXTURE_MAX_LOD, GL_TEXTURE_BASE_LEVEL, and GL_TEXTURE_MAX_LEVEL. + * Yes, this looks overly complicated, but it's all needed. + */ + if (tObj->MinFilter == GL_LINEAR || tObj->MinFilter == GL_NEAREST) { + firstLevel = lastLevel = tObj->BaseLevel; + } else { + firstLevel = tObj->BaseLevel + (GLint) (tObj->MinLod + 0.5); + firstLevel = MAX2(firstLevel, tObj->BaseLevel); + lastLevel = tObj->BaseLevel + (GLint) (tObj->MaxLod + 0.5); + lastLevel = MAX2(lastLevel, tObj->BaseLevel); + lastLevel = MIN2(lastLevel, tObj->BaseLevel + baseImage->MaxLog2); + lastLevel = MIN2(lastLevel, tObj->MaxLevel); + lastLevel = MAX2(firstLevel, lastLevel); /* need at least one level */ + } + + /* save these values */ + t->firstLevel = firstLevel; + t->lastLevel = lastLevel; + + numLevels = lastLevel - firstLevel + 1; + + if (0) fprintf(stderr, + "%s : " + "NumLevels : %d\n" + "firstLevel : %d\n" + "lastLevel : %d\n", + __FUNCTION__, + numLevels, + firstLevel, + lastLevel); + + log2Width = tObj->Image[firstLevel]->WidthLog2; + log2Height = tObj->Image[firstLevel]->HeightLog2; + + /* Figure out the amount of memory required to hold all the mipmap + * levels. Choose the smallest pitch to accomodate the largest + * mipmap: + */ + width = tObj->Image[firstLevel]->Width * t->texelBytes; + + pitch = width; + + /* All images must be loaded at this pitch. Count the number of + * lines required: + */ + for ( height = i = 0 ; i < numLevels ; i++ ) { + t->image[i].image = tObj->Image[firstLevel + i]; + t->image[i].offset = height * pitch; + t->image[i].internalFormat = baseImage->Format; + height += t->image[i].image->Height; + } + + t->Pitch = pitch; + t->totalSize = height*pitch; + t->max_level = i-1; + + t->Setup[I830_TEXREG_MI1] = (MAP_INFO_TEX(0) | + textureFormat | + MAP_INFO_OUTMUX_F0F1F2F3 | + MAP_INFO_VERTLINESTRIDE_0 | + MAP_INFO_VERTLINESTRIDEOFS_0 | + MAP_INFO_FORMAT_2D | + MAP_INFO_USE_FENCE); + t->Setup[I830_TEXREG_MI2] = (((1 << log2Height) - 1) << 16) | + ((1 << log2Width) - 1); + t->Setup[I830_TEXREG_MI4] = ((pitch / 4) - 1) << 2; + + t->Setup[I830_TEXREG_MLL] = (STATE3D_MAP_LOD_LIMITS_CMD | + MAP_UNIT(0) | + ENABLE_MAX_MIP_LVL | + LOD_MAX(0) | + ENABLE_MIN_MIP_LVL | + LOD_MIN(numLevels - 1)); + + t->dirty = I830_UPLOAD_TEX0 | I830_UPLOAD_TEX1; + i830UploadTexImages( imesa, t ); +} + +/* ================================================================ + * Texture combine functions + */ +static __inline__ GLuint GetTexelOp(GLint unit) +{ + switch(unit) { + case 0: return TEXBLENDARG_TEXEL0; + case 1: return TEXBLENDARG_TEXEL1; + case 2: return TEXBLENDARG_TEXEL2; + case 3: return TEXBLENDARG_TEXEL3; + default: return TEXBLENDARG_TEXEL0; + } +} + +static void i830SetBlend_GL1_2(i830ContextPtr imesa, int curTex, + GLenum envMode, GLenum format) +{ + GLuint texel_op = GetTexelOp(curTex); + + if(I830_DEBUG&DEBUG_VERBOSE_TRACE) + fprintf(stderr, "%s %s %s unit (%d) texel_op(0x%x)\n", + __FUNCTION__, + _mesa_lookup_enum_by_nr(format), + _mesa_lookup_enum_by_nr(envMode), + curTex, + texel_op); + + switch(envMode) { + case GL_REPLACE: + switch(format) { + case GL_ALPHA: + imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_COLOR | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + DISABLE_TEX_CNTRL_STAGE | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ARG1); + imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_ALPHA | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ARG1); + imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_ALPHA | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + texel_op); + imesa->TexBlendColorPipeNum[curTex] = 0; + imesa->TexBlendWordsUsed[curTex] = 4; + break; + case GL_LUMINANCE: + case GL_RGB: + imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_COLOR | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + DISABLE_TEX_CNTRL_STAGE | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ARG1); + imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_ALPHA | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ARG1); + imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + texel_op); + imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_ALPHA | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlendColorPipeNum[curTex] = 0; + imesa->TexBlendWordsUsed[curTex] = 4; + break; + + case GL_INTENSITY: + case GL_LUMINANCE_ALPHA: + case GL_RGBA: + imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_COLOR | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + DISABLE_TEX_CNTRL_STAGE | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ARG1); + imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_ALPHA | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ARG1); + imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + texel_op); + imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_ALPHA | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + texel_op); + imesa->TexBlendColorPipeNum[curTex] = 0; + imesa->TexBlendWordsUsed[curTex] = 4; + break; + default: + /* Always set to passthru if something is funny */ + imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_COLOR | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + DISABLE_TEX_CNTRL_STAGE | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ARG1); + imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_ALPHA | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ARG1); + imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_ALPHA | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlendColorPipeNum[curTex] = 0; + imesa->TexBlendWordsUsed[curTex] = 4; + break; + } + break; + + case GL_MODULATE: + switch(format) { + case GL_ALPHA: + imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_COLOR | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + DISABLE_TEX_CNTRL_STAGE | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ARG1); + imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_ALPHA | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_MODULATE); + imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_ALPHA | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + texel_op); + imesa->TexBlend[curTex][4] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_ALPHA | + TEXBLEND_ARG2 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlendColorPipeNum[curTex] = 0; + imesa->TexBlendWordsUsed[curTex] = 5; + break; + + case GL_LUMINANCE: + case GL_RGB: + imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_COLOR | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + DISABLE_TEX_CNTRL_STAGE | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_MODULATE); + imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_ALPHA | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ARG1); + imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + texel_op); + imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG2 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlend[curTex][4] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_ALPHA | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlendColorPipeNum[curTex] = 0; + imesa->TexBlendWordsUsed[curTex] = 5; + break; + + case GL_INTENSITY: + case GL_LUMINANCE_ALPHA: + case GL_RGBA: + imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_COLOR | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + DISABLE_TEX_CNTRL_STAGE | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_MODULATE); + imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_ALPHA | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_MODULATE); + imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + texel_op); + imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG2 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlend[curTex][4] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_ALPHA | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + texel_op); + imesa->TexBlend[curTex][5] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_ALPHA | + TEXBLEND_ARG2 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlendColorPipeNum[curTex] = 0; + imesa->TexBlendWordsUsed[curTex] = 6; + break; + default: + /* Always set to passthru if something is funny */ + imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_COLOR | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + DISABLE_TEX_CNTRL_STAGE | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ARG1); + imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_ALPHA | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ARG1); + imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_ALPHA | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlendColorPipeNum[curTex] = 0; + imesa->TexBlendWordsUsed[curTex] = 4; + break; + } + break; + + case GL_DECAL: + switch(format) { + case GL_RGB: + imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_COLOR | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + DISABLE_TEX_CNTRL_STAGE | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ARG1); + imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_ALPHA | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ARG1); + imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + texel_op); + imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_ALPHA | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlendColorPipeNum[curTex] = 0; + imesa->TexBlendWordsUsed[curTex] = 4; + break; + + case GL_RGBA: + imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_COLOR | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + DISABLE_TEX_CNTRL_STAGE | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_BLEND); + imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_ALPHA | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ARG1); + imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG0 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_REPLICATE_ALPHA | + texel_op); + imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + texel_op); + imesa->TexBlend[curTex][4] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG2 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlend[curTex][5] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_ALPHA | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlendColorPipeNum[curTex] = 0; + imesa->TexBlendWordsUsed[curTex] = 6; + break; + default: + /* Always set to passthru if something is funny */ + imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_COLOR | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + DISABLE_TEX_CNTRL_STAGE | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ARG1); + imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_ALPHA | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ARG1); + imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_ALPHA | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlendColorPipeNum[curTex] = 0; + imesa->TexBlendWordsUsed[curTex] = 4; + break; + } + break; + + case GL_BLEND: + switch(format) { + case GL_ALPHA: + imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_COLOR | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + DISABLE_TEX_CNTRL_STAGE | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ARG1); + imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_ALPHA | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_MODULATE); + imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_ALPHA | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + texel_op); + imesa->TexBlend[curTex][4] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_ALPHA | + TEXBLEND_ARG2 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlendColorPipeNum[curTex] = 0; + imesa->TexBlendWordsUsed[curTex] = 5; + break; + + case GL_LUMINANCE: + case GL_RGB: + imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_COLOR | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + DISABLE_TEX_CNTRL_STAGE | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_BLEND); + imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_ALPHA | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ARG1); + imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG0 | + TEXBLENDARG_MODIFY_PARMS | + texel_op); + imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_FACTOR_N); + imesa->TexBlend[curTex][4] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG2 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlend[curTex][5] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_ALPHA | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlendColorPipeNum[curTex] = 0; + imesa->TexBlendWordsUsed[curTex] = 6; + break; + + case GL_INTENSITY: + imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_COLOR | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + DISABLE_TEX_CNTRL_STAGE | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_BLEND); + imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_ALPHA | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_BLEND); + imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG0 | + TEXBLENDARG_MODIFY_PARMS | + texel_op); + imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_FACTOR_N); + imesa->TexBlend[curTex][4] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG2 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlend[curTex][5] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_ALPHA | + TEXBLEND_ARG0 | + TEXBLENDARG_MODIFY_PARMS | + texel_op); + imesa->TexBlend[curTex][6] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_ALPHA | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_FACTOR_N); + imesa->TexBlend[curTex][7] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_ALPHA | + TEXBLEND_ARG2 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlendColorPipeNum[curTex] = 0; + imesa->TexBlendWordsUsed[curTex] = 8; + break; + + case GL_LUMINANCE_ALPHA: + case GL_RGBA: + imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_COLOR | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + DISABLE_TEX_CNTRL_STAGE | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_BLEND); + imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_ALPHA | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_MODULATE); + imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG0 | + TEXBLENDARG_MODIFY_PARMS | + texel_op); + imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_FACTOR_N); + imesa->TexBlend[curTex][4] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG2 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlend[curTex][5] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_ALPHA | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + texel_op); + imesa->TexBlend[curTex][6] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_ALPHA | + TEXBLEND_ARG2 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlendColorPipeNum[curTex] = 0; + imesa->TexBlendWordsUsed[curTex] = 7; + break; + default: + /* Always set to passthru if something is funny */ + imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_COLOR | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + DISABLE_TEX_CNTRL_STAGE | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ARG1); + imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_ALPHA | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ARG1); + imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_ALPHA | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlendColorPipeNum[curTex] = 0; + imesa->TexBlendWordsUsed[curTex] = 4; + break; + } + break; + + case GL_ADD: + switch(format) { + case GL_ALPHA: + imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_COLOR | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + DISABLE_TEX_CNTRL_STAGE | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ARG1); + imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_ALPHA | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_MODULATE); + imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_ALPHA | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + texel_op); + imesa->TexBlend[curTex][4] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_ALPHA | + TEXBLEND_ARG2 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlendColorPipeNum[curTex] = 0; + imesa->TexBlendWordsUsed[curTex] = 5; + break; + case GL_LUMINANCE: + case GL_RGB: + imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_COLOR | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + DISABLE_TEX_CNTRL_STAGE | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ADD); + imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_ALPHA | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ARG1); + imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + texel_op); + imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG2 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlend[curTex][4] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_ALPHA | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlendColorPipeNum[curTex] = 0; + imesa->TexBlendWordsUsed[curTex] = 5; + break; + + case GL_INTENSITY: + imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_COLOR | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + DISABLE_TEX_CNTRL_STAGE | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ADD); + imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_ALPHA | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ADD); + imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + texel_op); + imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG2 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlend[curTex][4] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_ALPHA | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + texel_op); + imesa->TexBlend[curTex][5] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_ALPHA | + TEXBLEND_ARG2 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlendColorPipeNum[curTex] = 0; + imesa->TexBlendWordsUsed[curTex] = 6; + break; + + case GL_LUMINANCE_ALPHA: + case GL_RGBA: + imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_COLOR | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + DISABLE_TEX_CNTRL_STAGE | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ADD); + imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_ALPHA | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_MODULATE); + imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + texel_op); + imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG2 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlend[curTex][4] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_ALPHA | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + texel_op); + imesa->TexBlend[curTex][5] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_ALPHA | + TEXBLEND_ARG2 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlendColorPipeNum[curTex] = 0; + imesa->TexBlendWordsUsed[curTex] = 6; + break; + default: + /* Always set to passthru if something is funny */ + imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_COLOR | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + DISABLE_TEX_CNTRL_STAGE | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ARG1); + imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_ALPHA | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ARG1); + imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_ALPHA | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlendColorPipeNum[curTex] = 0; + imesa->TexBlendWordsUsed[curTex] = 4; + break; + } + break; + default: + /* Always set to passthru if something is funny */ + imesa->TexBlend[curTex][0] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_COLOR | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + DISABLE_TEX_CNTRL_STAGE | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ARG1); + imesa->TexBlend[curTex][1] = (STATE3D_MAP_BLEND_OP_CMD(curTex) | + TEXPIPE_ALPHA | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ARG1); + imesa->TexBlend[curTex][2] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_COLOR | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlend[curTex][3] = (STATE3D_MAP_BLEND_ARG_CMD(curTex) | + TEXPIPE_ALPHA | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlendColorPipeNum[curTex] = 0; + imesa->TexBlendWordsUsed[curTex] = 4; + break; + } + + if (I830_DEBUG&DEBUG_VERBOSE_TRACE) + fprintf(stderr, "%s\n", __FUNCTION__); +} + +static void i830SetTexEnvCombine(i830ContextPtr imesa, + const struct gl_texture_unit *texUnit, + GLint unit) +{ + GLuint blendop; + GLuint ablendop; + GLuint args_RGB[3]; + GLuint args_A[3]; + GLuint texel_op = GetTexelOp(unit); + int i; + + if(I830_DEBUG&DEBUG_VERBOSE_TRACE) + fprintf(stderr, "%s\n", __FUNCTION__); + + switch(texUnit->CombineModeRGB) { + case GL_REPLACE: blendop = TEXBLENDOP_ARG1; break; + case GL_MODULATE: blendop = TEXBLENDOP_MODULATE; break; + case GL_ADD: blendop = TEXBLENDOP_ADD; break; + case GL_ADD_SIGNED_ARB: + blendop = TEXBLENDOP_ADDSIGNED; break; + case GL_INTERPOLATE_ARB: + blendop = TEXBLENDOP_BLEND; break; + case GL_SUBTRACT_ARB: blendop = TEXBLENDOP_SUBTRACT; break; + default: return; + } + + switch(texUnit->CombineScaleShiftRGB) { + case 0: blendop |= TEXOP_SCALE_1X; break; + case 1: blendop |= TEXOP_SCALE_2X; break; + case 2: blendop |= TEXOP_SCALE_4X; break; + default: return; + } + + switch(texUnit->CombineModeA) { + case GL_REPLACE: ablendop = TEXBLENDOP_ARG1; break; + case GL_MODULATE: ablendop = TEXBLENDOP_MODULATE; break; + case GL_ADD: ablendop = TEXBLENDOP_ADD; break; + case GL_ADD_SIGNED_ARB: + ablendop = TEXBLENDOP_ADDSIGNED; break; + case GL_INTERPOLATE_ARB: + ablendop = TEXBLENDOP_BLEND; break; + case GL_SUBTRACT_ARB: ablendop = TEXBLENDOP_SUBTRACT; break; + default: return; + } + + switch(texUnit->CombineScaleShiftA) { + case 0: ablendop |= TEXOP_SCALE_1X; break; + case 1: ablendop |= TEXOP_SCALE_2X; break; + case 2: ablendop |= TEXOP_SCALE_4X; break; + default: return; + } + + /* Handle RGB args */ + for(i = 0; i < 3; i++) { + switch(texUnit->CombineSourceRGB[i]) { + case GL_TEXTURE: args_RGB[i] = texel_op; break; + case GL_CONSTANT_ARB: + args_RGB[i] = TEXBLENDARG_FACTOR_N; break; + case GL_PRIMARY_COLOR_ARB: + args_RGB[i] = TEXBLENDARG_DIFFUSE; break; + case GL_PREVIOUS_ARB: + args_RGB[i] = TEXBLENDARG_CURRENT; break; + default: return; + } + + switch(texUnit->CombineOperandRGB[i]) { + case GL_SRC_COLOR: args_RGB[i] |= 0; break; + case GL_ONE_MINUS_SRC_COLOR: args_RGB[i] |= TEXBLENDARG_INV_ARG; break; + case GL_SRC_ALPHA: args_RGB[i] |= TEXBLENDARG_REPLICATE_ALPHA; break; + case GL_ONE_MINUS_SRC_ALPHA: + args_RGB[i] |= (TEXBLENDARG_REPLICATE_ALPHA | + TEXBLENDARG_INV_ARG); + break; + default: return; + } + } + + /* Handle A args */ + for(i = 0; i < 3; i++) { + switch(texUnit->CombineSourceA[i]) { + case GL_TEXTURE: args_A[i] = texel_op; break; + case GL_CONSTANT_ARB: + args_A[i] = TEXBLENDARG_FACTOR_N; break; + case GL_PRIMARY_COLOR_ARB: + args_A[i] = TEXBLENDARG_DIFFUSE; break; + case GL_PREVIOUS_ARB: + args_A[i] = TEXBLENDARG_CURRENT; break; + default: return; + } + + switch(texUnit->CombineOperandA[i]) { + case GL_SRC_ALPHA: args_A[i] |= 0; break; + case GL_ONE_MINUS_SRC_ALPHA: args_A[i] |= TEXBLENDARG_INV_ARG; break; + default: return; + } + } + + /* Native Arg1 == Arg0 in GL_EXT_texture_env_combine spec */ + /* Native Arg2 == Arg1 in GL_EXT_texture_env_combine spec */ + /* Native Arg0 == Arg2 in GL_EXT_texture_env_combine spec */ + + /* When we render we need to figure out which is the last really enabled + * tex unit, and put last stage on it + */ + + imesa->TexBlendColorPipeNum[unit] = 0; + + /* Build color pipeline */ + + imesa->TexBlend[unit][0] = (STATE3D_MAP_BLEND_OP_CMD(unit) | + TEXPIPE_COLOR | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + DISABLE_TEX_CNTRL_STAGE | + TEXOP_MODIFY_PARMS | + blendop); + imesa->TexBlend[unit][1] = (STATE3D_MAP_BLEND_ARG_CMD(unit) | + TEXPIPE_COLOR | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + args_RGB[0]); + imesa->TexBlend[unit][2] = (STATE3D_MAP_BLEND_ARG_CMD(unit) | + TEXPIPE_COLOR | + TEXBLEND_ARG2 | + TEXBLENDARG_MODIFY_PARMS | + args_RGB[1]); + imesa->TexBlend[unit][3] = (STATE3D_MAP_BLEND_ARG_CMD(unit) | + TEXPIPE_COLOR | + TEXBLEND_ARG0 | + TEXBLENDARG_MODIFY_PARMS | + args_RGB[2]); + + /* Build Alpha pipeline */ + imesa->TexBlend[unit][4] = (STATE3D_MAP_BLEND_OP_CMD(unit) | + TEXPIPE_ALPHA | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + TEXOP_MODIFY_PARMS | + ablendop); + imesa->TexBlend[unit][5] = (STATE3D_MAP_BLEND_ARG_CMD(unit) | + TEXPIPE_ALPHA | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + args_A[0]); + imesa->TexBlend[unit][6] = (STATE3D_MAP_BLEND_ARG_CMD(unit) | + TEXPIPE_ALPHA | + TEXBLEND_ARG2 | + TEXBLENDARG_MODIFY_PARMS | + args_A[1]); + imesa->TexBlend[unit][7] = (STATE3D_MAP_BLEND_ARG_CMD(unit) | + TEXPIPE_ALPHA | + TEXBLEND_ARG0 | + TEXBLENDARG_MODIFY_PARMS | + args_A[2]); + + { + GLubyte r, g, b, a; + GLfloat *fc = texUnit->EnvColor; + + FLOAT_COLOR_TO_UBYTE_COLOR(r, fc[RCOMP]); + FLOAT_COLOR_TO_UBYTE_COLOR(g, fc[GCOMP]); + FLOAT_COLOR_TO_UBYTE_COLOR(b, fc[BCOMP]); + FLOAT_COLOR_TO_UBYTE_COLOR(a, fc[ACOMP]); + + imesa->TexBlend[unit][8] = STATE3D_COLOR_FACTOR_CMD(unit); + imesa->TexBlend[unit][9] = ((a << 24) | + (r << 16) | + (g << 8) | + b); + } + imesa->TexBlendWordsUsed[unit] = 10; +} + + + + +static void i830UpdateTexEnv( GLcontext *ctx, GLuint unit ) +{ + i830ContextPtr imesa = I830_CONTEXT(ctx); + const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit]; + const struct gl_texture_object *tObj = texUnit->_Current; + i830TextureObjectPtr t = (i830TextureObjectPtr)tObj->DriverData; + GLuint col; + + imesa->TexBlendWordsUsed[unit] = 0; + + if (0) fprintf(stderr, "i830UpdateTexEnv called : %s\n", + _mesa_lookup_enum_by_nr(texUnit->EnvMode)); + + if(texUnit->EnvMode == GL_COMBINE_ARB) { + i830SetTexEnvCombine(imesa, + texUnit, + unit); + } else { + i830SetBlend_GL1_2(imesa, + unit, + texUnit->EnvMode, + t->image[0].internalFormat); + + /* add blend color */ + { + GLubyte r, g, b, a; + GLfloat *fc = texUnit->EnvColor; + + FLOAT_COLOR_TO_UBYTE_COLOR(r, fc[RCOMP]); + FLOAT_COLOR_TO_UBYTE_COLOR(g, fc[GCOMP]); + FLOAT_COLOR_TO_UBYTE_COLOR(b, fc[BCOMP]); + FLOAT_COLOR_TO_UBYTE_COLOR(a, fc[ACOMP]); + + col = ((a << 24) | + (r << 16) | + (g << 8) | + b); + } + + { + int i; + + i = imesa->TexBlendWordsUsed[unit]; + imesa->TexBlend[unit][i++] = STATE3D_COLOR_FACTOR_CMD(unit); + imesa->TexBlend[unit][i++] = col; + + imesa->TexBlendWordsUsed[unit] = i; + } + } + + I830_STATECHANGE( imesa, I830_UPLOAD_TEXBLEND_N(unit) ); +} + + +static void i830TexSetUnit( i830TextureObjectPtr t, GLuint unit ) +{ + if(I830_DEBUG&DEBUG_VERBOSE_TRACE) + fprintf(stderr, "%s unit(%d)\n", __FUNCTION__, unit); + + /* This will need to be changed when I support more then 2 t units */ + I830_SET_FIELD(t->Setup[I830_TEXREG_MI1], + MAP_INFO_MASK | MAP_INFO_USE_PALETTE_1, + MAP_INFO_TEX(unit) | MAP_INFO_USE_PALETTE_N(unit)); + I830_SET_FIELD(t->Setup[I830_TEXREG_MLC], MAP_UNIT_MASK, MAP_UNIT(unit)); + I830_SET_FIELD(t->Setup[I830_TEXREG_MLL], MAP_UNIT_MASK, MAP_UNIT(unit)); + I830_SET_FIELD(t->Setup[I830_TEXREG_MCS], MAP_UNIT_MASK, MAP_UNIT(unit)); + I830_SET_FIELD(t->Setup[I830_TEXREG_MF], MAP_UNIT_MASK, MAP_UNIT(unit)); + + t->current_unit = unit; +} + +#define TEXCOORDTYPE_MASK (~((1<<13)|(1<<12)|(1<<11))) + +static void i830UpdateTexUnit( GLcontext *ctx, GLuint unit ) +{ + i830ContextPtr imesa = I830_CONTEXT(ctx); + struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit]; + + imesa->TexEnabledMask &= ~(I830_TEX_UNIT_ENABLED(unit)); + + if (texUnit->_ReallyEnabled == TEXTURE0_2D) { + struct gl_texture_object *tObj = texUnit->_Current; + i830TextureObjectPtr t = (i830TextureObjectPtr)tObj->DriverData; + GLuint mcs = t->Setup[I830_TEXREG_MCS] & TEXCOORDTYPE_MASK; + + /* Handle projective texturing */ + if (imesa->vertex_format & (1<<31)) { + mcs |= TEXCOORDTYPE_HOMOGENEOUS; + } else { + mcs |= TEXCOORDTYPE_CARTESIAN; + } + + /* Upload teximages (not pipelined) + */ + if (t->dirty_images) { + I830_FIREVERTICES(imesa); + i830SetTexImages( imesa, tObj ); + if (!t->MemBlock) { + FALLBACK( imesa, I830_FALLBACK_TEXTURE, GL_TRUE ); + return; + } + } + + /* Update state if this is a different texture object to last + * time. + */ + if (imesa->CurrentTexObj[unit] != t || + mcs != t->Setup[I830_TEXREG_MCS]) { + I830_STATECHANGE(imesa, (I830_UPLOAD_TEX0<<unit)); + t->Setup[I830_TEXREG_MCS] = mcs; + imesa->CurrentTexObj[unit] = t; + i830TexSetUnit(t, unit); + } + + /* Update texture environment if texture object image format or + * texture environment state has changed. + */ + if (tObj->Image[tObj->BaseLevel]->Format != + imesa->TexEnvImageFmt[unit]) { + imesa->TexEnvImageFmt[unit] = tObj->Image[tObj->BaseLevel]->Format; + i830UpdateTexEnv( ctx, unit ); + } + imesa->TexEnabledMask |= I830_TEX_UNIT_ENABLED(unit); + } + else if (texUnit->_ReallyEnabled) { + FALLBACK( imesa, I830_FALLBACK_TEXTURE, GL_TRUE ); + } + else if (unit == 0) { + /* This is happening too often. I need to conditionally send diffuse + * state to the card. Perhaps a diffuse dirty flag of some kind. + * Will need to change this logic if more than 2 texture units are + * used. We need to only do this up to the last unit enabled, or unit + * one if nothing is enabled. + */ + imesa->CurrentTexObj[unit] = 0; + imesa->TexEnvImageFmt[unit] = 0; + imesa->dirty &= ~(I830_UPLOAD_TEX_N(unit)); + + imesa->TexBlend[unit][0] = (STATE3D_MAP_BLEND_OP_CMD(unit) | + TEXPIPE_COLOR | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + DISABLE_TEX_CNTRL_STAGE | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ARG1); + imesa->TexBlend[unit][1] = (STATE3D_MAP_BLEND_OP_CMD(unit) | + TEXPIPE_ALPHA | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | + TEXBLENDOP_ARG1); + imesa->TexBlend[unit][2] = (STATE3D_MAP_BLEND_ARG_CMD(unit) | + TEXPIPE_COLOR | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlend[unit][3] = (STATE3D_MAP_BLEND_ARG_CMD(unit) | + TEXPIPE_ALPHA | + TEXBLEND_ARG1 | + TEXBLENDARG_MODIFY_PARMS | + TEXBLENDARG_CURRENT); + imesa->TexBlendColorPipeNum[unit] = 0; + imesa->TexBlendWordsUsed[unit] = 4; + I830_STATECHANGE(imesa, (I830_UPLOAD_TEXBLEND_N(unit))); + } +} + +/* Called from vb code to update projective texturing properly */ +void i830UpdateTexUnitProj( GLcontext *ctx, GLuint unit, GLboolean state ) +{ + i830ContextPtr imesa = I830_CONTEXT(ctx); + struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit]; + + if (texUnit->_ReallyEnabled == TEXTURE0_2D) { + struct gl_texture_object *tObj = texUnit->_Current; + i830TextureObjectPtr t = (i830TextureObjectPtr)tObj->DriverData; + GLuint mcs = t->Setup[I830_TEXREG_MCS] & TEXCOORDTYPE_MASK; + + /* Handle projective texturing */ + if (state) { + mcs |= TEXCOORDTYPE_HOMOGENEOUS; + } else { + mcs |= TEXCOORDTYPE_CARTESIAN; + } + + if (mcs != t->Setup[I830_TEXREG_MCS]) { + I830_STATECHANGE(imesa, (I830_UPLOAD_TEX0<<unit)); + t->Setup[I830_TEXREG_MCS] = mcs; + } + } +} + +/* Only deal with unit 0 and 1 for right now */ +void i830UpdateTextureState( GLcontext *ctx ) +{ + i830ContextPtr imesa = I830_CONTEXT(ctx); + int pipe_num = 0; + + if (0) fprintf(stderr, "%s\n", __FUNCTION__); + FALLBACK( imesa, I830_FALLBACK_TEXTURE, GL_FALSE ); + + i830UpdateTexUnit( ctx, 0 ); + i830UpdateTexUnit( ctx, 1 ); +#if 0 + i830UpdateTexUnit( ctx, 2 ); + i830UpdateTexUnit( ctx, 3 ); +#endif + + /* Make sure last stage is set correctly */ +#if 0 + if(imesa->TexEnabledMask & I830_TEX_UNIT_ENABLED(3)) { + pipe_num = imesa->TexBlendColorPipeNum[3]; + imesa->TexBlend[3][pipe_num] |= TEXOP_LAST_STAGE; + } else if(imesa->TexEnabledMask & I830_TEX_UNIT_ENABLED(2)) { + pipe_num = imesa->TexBlendColorPipeNum[2]; + imesa->TexBlend[2][pipe_num] |= TEXOP_LAST_STAGE; + } else +#endif + if(imesa->TexEnabledMask & I830_TEX_UNIT_ENABLED(1)) { + pipe_num = imesa->TexBlendColorPipeNum[1]; + imesa->TexBlend[1][pipe_num] |= TEXOP_LAST_STAGE; + if (0) fprintf(stderr, "Unit One is last enabled\n"); + } else { + pipe_num = imesa->TexBlendColorPipeNum[0]; + imesa->TexBlend[0][pipe_num] |= TEXOP_LAST_STAGE; + if (0) fprintf(stderr, "Unit Zero is last enabled\n"); + } +} + + + diff --git a/xc/lib/GL/mesa/src/drv/i830/i830_tris.c b/xc/lib/GL/mesa/src/drv/i830/i830_tris.c index d9a547a56..a239fd4f9 100644 --- a/xc/lib/GL/mesa/src/drv/i830/i830_tris.c +++ b/xc/lib/GL/mesa/src/drv/i830/i830_tris.c @@ -1,3 +1,4 @@ +/* $XFree86$ */ /************************************************************************** Copyright 2001 VA Linux Systems Inc., Fremont, California. @@ -25,159 +26,820 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. **************************************************************************/ -/* $XFree86: xc/lib/GL/mesa/src/drv/i830/i830_tris.c,v 1.1 2001/10/04 18:28:21 alanh Exp $ */ - /* - * Author: - * Jeff Hartmann <jhartmann@valinux.com> - * - * Heavily based on the I810 driver, which was written by: - * Keith Whitwell <keithw@valinux.com> + * Original Authors: + * Keith Whitwell <keith@tungstengraphics.com> + * Adapted for use on the I830M: + * Jeff Hartmann <jhartmann@2d3d.com> */ #include <stdio.h> #include <math.h> -#include "types.h" -#include "vb.h" -#include "pipeline.h" +#include "glheader.h" +#include "context.h" +#include "macros.h" +#include "enums.h" +#include "dd.h" -#include "mm.h" +#include "swrast/swrast.h" +#include "swrast_setup/swrast_setup.h" +#include "tnl/t_context.h" +#include "tnl/t_pipeline.h" + +#include "i830_screen.h" +#include "i830_dri.h" -#include "i830_drv.h" #include "i830_tris.h" +#include "i830_state.h" +#include "i830_vb.h" +#include "i830_ioctl.h" + +static void i830RenderPrimitive( GLcontext *ctx, GLenum prim ); + +/*********************************************************************** + * Emit primitives as inline vertices * + ***********************************************************************/ + +#if defined(USE_X86_ASM) +#define COPY_DWORDS( j, vb, vertsize, v ) \ +do { \ + int __tmp; \ + __asm__ __volatile__( "rep ; movsl" \ + : "=%c" (j), "=D" (vb), "=S" (__tmp) \ + : "0" (vertsize), \ + "D" ((long)vb), \ + "S" ((long)v) ); \ +} while (0) +#else +#define COPY_DWORDS( j, vb, vertsize, v ) \ +do { \ + for ( j = 0 ; j < vertsize ; j++ ) \ + vb[j] = ((GLuint *)v)[j]; \ + vb += vertsize; \ +} while (0) +#endif + +static void __inline__ i830_draw_triangle( i830ContextPtr imesa, + i830VertexPtr v0, + i830VertexPtr v1, + i830VertexPtr v2 ) +{ + GLuint vertsize = imesa->vertex_size; + GLuint *vb = i830AllocDmaLow( imesa, 3 * 4 * vertsize ); + int j; -/* Used in i830tritmp.h - */ -#define I830_COLOR(to, from) { \ - (to)[0] = (from)[2]; \ - (to)[1] = (from)[1]; \ - (to)[2] = (from)[0]; \ - (to)[3] = (from)[3]; \ + COPY_DWORDS( j, vb, vertsize, v0 ); + COPY_DWORDS( j, vb, vertsize, v1 ); + COPY_DWORDS( j, vb, vertsize, v2 ); } -#define I830_COLOR3(to, from) { \ - (to)[0] = (from)[2]; \ - (to)[1] = (from)[1]; \ - (to)[2] = (from)[0]; \ + +static void __inline__ i830_draw_quad( i830ContextPtr imesa, + i830VertexPtr v0, + i830VertexPtr v1, + i830VertexPtr v2, + i830VertexPtr v3 ) +{ + GLuint vertsize = imesa->vertex_size; + GLuint *vb = i830AllocDmaLow( imesa, 6 * 4 * vertsize ); + int j; + + COPY_DWORDS( j, vb, vertsize, v0 ); + COPY_DWORDS( j, vb, vertsize, v1 ); + COPY_DWORDS( j, vb, vertsize, v3 ); + COPY_DWORDS( j, vb, vertsize, v1 ); + COPY_DWORDS( j, vb, vertsize, v2 ); + COPY_DWORDS( j, vb, vertsize, v3 ); } -static triangle_func tri_tab[0x10]; -static quad_func quad_tab[0x10]; -static line_func line_tab[0x10]; -static points_func points_tab[0x10]; -#define IND (0) +static __inline__ void i830_draw_point( i830ContextPtr imesa, + i830VertexPtr tmp ) +{ + GLuint vertsize = imesa->vertex_size; + GLuint *vb = i830AllocDmaLow( imesa, 4 * vertsize ); + int j; + + /* Adjust for sub pixel position */ + *(float *)&vb[0] = tmp->v.x - 0.125; + *(float *)&vb[1] = tmp->v.y - 0.125; + for (j = 2 ; j < vertsize ; j++) + vb[j] = tmp->ui[j]; +} + + +static __inline__ void i830_draw_line( i830ContextPtr imesa, + i830VertexPtr v0, + i830VertexPtr v1 ) +{ + GLuint vertsize = imesa->vertex_size; + GLuint *vb = i830AllocDmaLow( imesa, 2 * 4 * vertsize ); + int j; + + COPY_DWORDS( j, vb, vertsize, v0 ); + COPY_DWORDS( j, vb, vertsize, v1 ); +} + + + +/*********************************************************************** + * Macros for t_dd_tritmp.h to draw basic primitives * + ***********************************************************************/ + +#define TRI( a, b, c ) \ +do { \ + if (DO_FALLBACK) \ + imesa->draw_tri( imesa, a, b, c ); \ + else \ + i830_draw_triangle( imesa, a, b, c ); \ +} while (0) + +#define QUAD( a, b, c, d ) \ +do { \ + if (DO_FALLBACK) { \ + imesa->draw_tri( imesa, a, b, d ); \ + imesa->draw_tri( imesa, b, c, d ); \ + } else \ + i830_draw_quad( imesa, a, b, c, d ); \ +} while (0) + +#define LINE( v0, v1 ) \ +do { \ + if (DO_FALLBACK) \ + imesa->draw_line( imesa, v0, v1 ); \ + else \ + i830_draw_line( imesa, v0, v1 ); \ +} while (0) + +#define POINT( v0 ) \ +do { \ + if (DO_FALLBACK) \ + imesa->draw_point( imesa, v0 ); \ + else \ + i830_draw_point( imesa, v0 ); \ +} while (0) + + +/*********************************************************************** + * Build render functions from dd templates * + ***********************************************************************/ + +#define I830_OFFSET_BIT 0x01 +#define I830_TWOSIDE_BIT 0x02 +#define I830_UNFILLED_BIT 0x04 +#define I830_FALLBACK_BIT 0x08 +#define I830_MAX_TRIFUNC 0x10 + + +static struct { + points_func points; + line_func line; + triangle_func triangle; + quad_func quad; +} rast_tab[I830_MAX_TRIFUNC]; + + +#define DO_FALLBACK (IND & I830_FALLBACK_BIT) +#define DO_OFFSET (IND & I830_OFFSET_BIT) +#define DO_UNFILLED (IND & I830_UNFILLED_BIT) +#define DO_TWOSIDE (IND & I830_TWOSIDE_BIT) +#define DO_FLAT 0 +#define DO_TRI 1 +#define DO_QUAD 1 +#define DO_LINE 1 +#define DO_POINTS 1 +#define DO_FULL_QUAD 1 + +#define HAVE_RGBA 1 +#define HAVE_SPEC 1 +#define HAVE_BACK_COLORS 0 +#define HAVE_HW_FLATSHADE 1 +#define VERTEX i830Vertex +#define TAB rast_tab + +/* Only used to pull back colors into vertices (ie, we know color is + * floating point). + */ +#define I830_COLOR( dst, src ) \ +do { \ + dst[0] = src[2]; \ + dst[1] = src[1]; \ + dst[2] = src[0]; \ + dst[3] = src[3]; \ +} while (0) + +#define I830_SPEC( dst, src ) \ +do { \ + dst[0] = src[2]; \ + dst[1] = src[1]; \ + dst[2] = src[0]; \ +} while (0) + + +#define DEPTH_SCALE (imesa->depth_scale) +#define UNFILLED_TRI unfilled_tri +#define UNFILLED_QUAD unfilled_quad +#define VERT_X(_v) _v->v.x +#define VERT_Y(_v) _v->v.y +#define VERT_Z(_v) _v->v.z +#define AREA_IS_CCW( a ) (a > 0) +#define GET_VERTEX(e) (imesa->verts + (e<<imesa->vertex_stride_shift)) + +#define VERT_SET_RGBA( v, c ) I830_COLOR( v->ub4[coloroffset], c ) +#define VERT_COPY_RGBA( v0, v1 ) v0->ui[coloroffset] = v1->ui[coloroffset] +#define VERT_SAVE_RGBA( idx ) color[idx] = v[idx]->ui[coloroffset] +#define VERT_RESTORE_RGBA( idx ) v[idx]->ui[coloroffset] = color[idx] + +#define VERT_SET_SPEC( v, c ) if (havespec) I830_SPEC( v->ub4[5], c ) +#define VERT_COPY_SPEC( v0, v1 ) if (havespec) COPY_3V(v0->ub4[5], v1->ub4[5]) +#define VERT_SAVE_SPEC( idx ) if (havespec) spec[idx] = v[idx]->ui[5] +#define VERT_RESTORE_SPEC( idx ) if (havespec) v[idx]->ui[5] = spec[idx] + +#define LOCAL_VARS(n) \ + i830ContextPtr imesa = I830_CONTEXT(ctx); \ + GLuint color[n], spec[n]; \ + GLuint coloroffset = (imesa->vertex_size == 4 ? 3 : 4); \ + GLboolean havespec = (imesa->vertex_size > 4); \ + (void) color; (void) spec; (void) coloroffset; (void) havespec; + + +/*********************************************************************** + * Helpers for rendering unfilled primitives * + ***********************************************************************/ + +static const GLuint hw_prim[GL_POLYGON+1] = { + PRIM3D_POINTLIST, + PRIM3D_LINELIST, + PRIM3D_LINELIST, + PRIM3D_LINELIST, + PRIM3D_TRILIST, + PRIM3D_TRILIST, + PRIM3D_TRILIST, + PRIM3D_TRILIST, + PRIM3D_TRILIST, + PRIM3D_TRILIST +}; + +#define RASTERIZE(x) if (imesa->hw_primitive != hw_prim[x]) \ + i830RasterPrimitive( ctx, x, hw_prim[x] ) +#define RENDER_PRIMITIVE imesa->render_primitive #define TAG(x) x -#include "i830_tritmp.h" +#define IND I830_FALLBACK_BIT +#include "tnl_dd/t_dd_unfilled.h" +#undef IND -#define IND (I830_FLAT_BIT) -#define TAG(x) x##_flat -#include "i830_tritmp.h" +/*********************************************************************** + * Generate GL render functions * + ***********************************************************************/ -#define IND (I830_OFFSET_BIT) -#define TAG(x) x##_offset -#include "i830_tritmp.h" +#define IND (0) +#define TAG(x) x +#include "tnl_dd/t_dd_tritmp.h" -#define IND (I830_OFFSET_BIT|I830_FLAT_BIT) -#define TAG(x) x##_offset_flat -#include "i830_tritmp.h" +#define IND (I830_OFFSET_BIT) +#define TAG(x) x##_offset +#include "tnl_dd/t_dd_tritmp.h" -#define IND (I830_TWOSIDE_BIT) +#define IND (I830_TWOSIDE_BIT) #define TAG(x) x##_twoside -#include "i830_tritmp.h" - -#define IND (I830_TWOSIDE_BIT|I830_FLAT_BIT) -#define TAG(x) x##_twoside_flat -#include "i830_tritmp.h" +#include "tnl_dd/t_dd_tritmp.h" -#define IND (I830_TWOSIDE_BIT|I830_OFFSET_BIT) +#define IND (I830_TWOSIDE_BIT|I830_OFFSET_BIT) #define TAG(x) x##_twoside_offset -#include "i830_tritmp.h" +#include "tnl_dd/t_dd_tritmp.h" + +#define IND (I830_UNFILLED_BIT) +#define TAG(x) x##_unfilled +#include "tnl_dd/t_dd_tritmp.h" + +#define IND (I830_OFFSET_BIT|I830_UNFILLED_BIT) +#define TAG(x) x##_offset_unfilled +#include "tnl_dd/t_dd_tritmp.h" + +#define IND (I830_TWOSIDE_BIT|I830_UNFILLED_BIT) +#define TAG(x) x##_twoside_unfilled +#include "tnl_dd/t_dd_tritmp.h" + +#define IND (I830_TWOSIDE_BIT|I830_OFFSET_BIT|I830_UNFILLED_BIT) +#define TAG(x) x##_twoside_offset_unfilled +#include "tnl_dd/t_dd_tritmp.h" + +#define IND (I830_FALLBACK_BIT) +#define TAG(x) x##_fallback +#include "tnl_dd/t_dd_tritmp.h" + +#define IND (I830_OFFSET_BIT|I830_FALLBACK_BIT) +#define TAG(x) x##_offset_fallback +#include "tnl_dd/t_dd_tritmp.h" + +#define IND (I830_TWOSIDE_BIT|I830_FALLBACK_BIT) +#define TAG(x) x##_twoside_fallback +#include "tnl_dd/t_dd_tritmp.h" -#define IND (I830_TWOSIDE_BIT|I830_OFFSET_BIT|I830_FLAT_BIT) -#define TAG(x) x##_twoside_offset_flat -#include "i830_tritmp.h" +#define IND (I830_TWOSIDE_BIT|I830_OFFSET_BIT|I830_FALLBACK_BIT) +#define TAG(x) x##_twoside_offset_fallback +#include "tnl_dd/t_dd_tritmp.h" +#define IND (I830_UNFILLED_BIT|I830_FALLBACK_BIT) +#define TAG(x) x##_unfilled_fallback +#include "tnl_dd/t_dd_tritmp.h" +#define IND (I830_OFFSET_BIT|I830_UNFILLED_BIT|I830_FALLBACK_BIT) +#define TAG(x) x##_offset_unfilled_fallback +#include "tnl_dd/t_dd_tritmp.h" -void i830DDTrifuncInit() +#define IND (I830_TWOSIDE_BIT|I830_UNFILLED_BIT|I830_FALLBACK_BIT) +#define TAG(x) x##_twoside_unfilled_fallback +#include "tnl_dd/t_dd_tritmp.h" + +#define IND (I830_TWOSIDE_BIT|I830_OFFSET_BIT|I830_UNFILLED_BIT| \ + I830_FALLBACK_BIT) +#define TAG(x) x##_twoside_offset_unfilled_fallback +#include "tnl_dd/t_dd_tritmp.h" + + +static void init_rast_tab( void ) { init(); - init_flat(); init_offset(); - init_offset_flat(); init_twoside(); - init_twoside_flat(); init_twoside_offset(); - init_twoside_offset_flat(); -} - - - -#define ALL_FALLBACK (DD_SELECT | DD_FEEDBACK) -#define POINT_FALLBACK (ALL_FALLBACK | DD_POINT_SMOOTH | DD_POINT_ATTEN) -#define LINE_FALLBACK (ALL_FALLBACK | DD_LINE_STIPPLE) -#define TRI_FALLBACK (ALL_FALLBACK | DD_TRI_UNFILLED | DD_TRI_STIPPLE | DD_TRI_SMOOTH) -#define ANY_FALLBACK (POINT_FALLBACK|LINE_FALLBACK|TRI_FALLBACK|DD_TRI_STIPPLE) -#define ANY_RASTER_FLAGS (DD_FLATSHADE|DD_TRI_LIGHT_TWOSIDE|DD_TRI_OFFSET) - -void i830DDChooseRenderState(GLcontext *ctx) -{ - i830ContextPtr imesa = I830_CONTEXT(ctx); - GLuint flags = ctx->TriangleCaps; - CARD32 index = 0; - - if (imesa->Fallback) { - imesa->renderindex = I830_FALLBACK_BIT; - return; - } - - if (flags & ANY_RASTER_FLAGS) { - if (flags & DD_FLATSHADE) index |= I830_FLAT_BIT; - if (flags & DD_TRI_LIGHT_TWOSIDE) index |= I830_TWOSIDE_BIT; - if (flags & DD_TRI_OFFSET) index |= I830_OFFSET_BIT; - } - - imesa->PointsFunc = points_tab[index]; - imesa->LineFunc = line_tab[index]; - imesa->TriangleFunc = tri_tab[index]; - imesa->QuadFunc = quad_tab[index]; - imesa->renderindex = index; - imesa->IndirectTriangles = 0; - - if (flags & ANY_FALLBACK) { - if (flags & POINT_FALLBACK) { - imesa->renderindex |= I830_FALLBACK_BIT; - imesa->PointsFunc = 0; - imesa->IndirectTriangles |= DD_POINT_SW_RASTERIZE; - } - - if (flags & LINE_FALLBACK) { - imesa->renderindex |= I830_FALLBACK_BIT; - imesa->LineFunc = 0; - imesa->IndirectTriangles |= DD_LINE_SW_RASTERIZE; - } - - if (flags & TRI_FALLBACK) { - imesa->renderindex |= I830_FALLBACK_BIT; - imesa->TriangleFunc = 0; - imesa->QuadFunc = 0; - imesa->IndirectTriangles |= (DD_TRI_SW_RASTERIZE | - DD_QUAD_SW_RASTERIZE); - } - /* Special cases: - */ - if ((flags & DD_TRI_STIPPLE) && - (ctx->IndirectTriangles & DD_TRI_STIPPLE)) { - imesa->renderindex |= I830_FALLBACK_BIT; - imesa->TriangleFunc = 0; - imesa->QuadFunc = 0; - imesa->IndirectTriangles |= (DD_TRI_SW_RASTERIZE | - DD_QUAD_SW_RASTERIZE); - } - } + init_unfilled(); + init_offset_unfilled(); + init_twoside_unfilled(); + init_twoside_offset_unfilled(); + init_fallback(); + init_offset_fallback(); + init_twoside_fallback(); + init_twoside_offset_fallback(); + init_unfilled_fallback(); + init_offset_unfilled_fallback(); + init_twoside_unfilled_fallback(); + init_twoside_offset_unfilled_fallback(); +} + + +/*********************************************************************** + * Rasterization fallback helpers * + ***********************************************************************/ + + +/* This code is hit only when a mix of accelerated and unaccelerated + * primitives are being drawn, and only for the unaccelerated + * primitives. + */ +static void +i830_fallback_tri( i830ContextPtr imesa, + i830Vertex *v0, + i830Vertex *v1, + i830Vertex *v2 ) +{ + GLcontext *ctx = imesa->glCtx; + SWvertex v[3]; + + if (DEBUGGING) + fprintf(stderr, "\n%s\n", __FUNCTION__); + + i830_translate_vertex( ctx, v0, &v[0] ); + i830_translate_vertex( ctx, v1, &v[1] ); + i830_translate_vertex( ctx, v2, &v[2] ); + _swrast_Triangle( ctx, &v[0], &v[1], &v[2] ); +} + + +static void +i830_fallback_line( i830ContextPtr imesa, + i830Vertex *v0, + i830Vertex *v1 ) +{ + GLcontext *ctx = imesa->glCtx; + SWvertex v[2]; + + if (DEBUGGING) + fprintf(stderr, "\n%s\n", __FUNCTION__); + + i830_translate_vertex( ctx, v0, &v[0] ); + i830_translate_vertex( ctx, v1, &v[1] ); + _swrast_Line( ctx, &v[0], &v[1] ); } +static void +i830_fallback_point( i830ContextPtr imesa, + i830Vertex *v0 ) +{ + GLcontext *ctx = imesa->glCtx; + SWvertex v[1]; + + if (DEBUGGING) + fprintf(stderr, "\n%s\n", __FUNCTION__); + + i830_translate_vertex( ctx, v0, &v[0] ); + _swrast_Point( ctx, &v[0] ); +} + + + +/**********************************************************************/ +/* Render unclipped begin/end objects */ +/**********************************************************************/ + +#define IND 0 +#define V(x) (i830Vertex *)(vertptr + ((x)<<vertshift)) +#define RENDER_POINTS( start, count ) \ + for ( ; start < count ; start++) POINT( V(ELT(start)) ); +#define RENDER_LINE( v0, v1 ) LINE( V(v0), V(v1) ) +#define RENDER_TRI( v0, v1, v2 ) TRI( V(v0), V(v1), V(v2) ) +#define RENDER_QUAD( v0, v1, v2, v3 ) QUAD( V(v0), V(v1), V(v2), V(v3) ) +#define INIT(x) i830RenderPrimitive( ctx, x ) +#undef LOCAL_VARS +#define LOCAL_VARS \ + i830ContextPtr imesa = I830_CONTEXT(ctx); \ + GLubyte *vertptr = (GLubyte *)imesa->verts; \ + const GLuint vertshift = imesa->vertex_stride_shift; \ + const GLuint * const elt = TNL_CONTEXT(ctx)->vb.Elts; \ + (void) elt; +#define RESET_STIPPLE +#define RESET_OCCLUSION +#define PRESERVE_VB_DEFS +#define ELT(x) x +#define TAG(x) i830_##x##_verts +#include "tnl/t_vb_rendertmp.h" +#undef ELT +#undef TAG +#define TAG(x) i830_##x##_elts +#define ELT(x) elt[x] +#include "tnl/t_vb_rendertmp.h" + +/**********************************************************************/ +/* Render clipped primitives */ +/**********************************************************************/ + + + +static void i830RenderClippedPoly( GLcontext *ctx, const GLuint *elts, + GLuint n ) +{ + i830ContextPtr imesa = I830_CONTEXT(ctx); + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb; + GLuint prim = imesa->render_primitive; + + if (DEBUGGING) + fprintf(stderr, "\n%s\n", __FUNCTION__); + + /* Render the new vertices as an unclipped polygon. + */ + { + GLuint *tmp = VB->Elts; + VB->Elts = (GLuint *)elts; + tnl->Driver.Render.PrimTabElts[GL_POLYGON]( ctx, 0, n, + PRIM_BEGIN|PRIM_END ); + VB->Elts = tmp; + } + + /* Restore the render primitive + */ + if (prim != GL_POLYGON) + tnl->Driver.Render.PrimitiveNotify( ctx, prim ); +} + +static void i830RenderClippedLine( GLcontext *ctx, GLuint ii, GLuint jj ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + + if (DEBUGGING) + fprintf(stderr, "\n%s\n", __FUNCTION__); + tnl->Driver.Render.Line( ctx, ii, jj ); +} + +static void i830FastRenderClippedPoly( GLcontext *ctx, const GLuint *elts, + GLuint n ) +{ + i830ContextPtr imesa = I830_CONTEXT( ctx ); + GLuint vertsize = imesa->vertex_size; + GLuint *vb = i830AllocDmaLow( imesa, (n-2) * 3 * 4 * vertsize ); + GLubyte *vertptr = (GLubyte *)imesa->verts; + const GLuint vertshift = imesa->vertex_stride_shift; + const GLuint *start = (const GLuint *)V(elts[0]); + int i,j; + + if (DEBUGGING) + fprintf(stderr, "\n%s\n", __FUNCTION__); + + for (i = 2 ; i < n ; i++) { + COPY_DWORDS( j, vb, vertsize, start ); + COPY_DWORDS( j, vb, vertsize, V(elts[i-1]) ); + COPY_DWORDS( j, vb, vertsize, V(elts[i]) ); + } +} + +/**********************************************************************/ +/* Choose render functions */ +/**********************************************************************/ + + + +#define _I830_NEW_RENDERSTATE (_DD_NEW_LINE_STIPPLE | \ + _DD_NEW_TRI_UNFILLED | \ + _DD_NEW_TRI_LIGHT_TWOSIDE | \ + _DD_NEW_TRI_OFFSET | \ + _DD_NEW_TRI_STIPPLE | \ + _NEW_POLYGONSTIPPLE) + +#define POINT_FALLBACK (0) +#define LINE_FALLBACK (DD_LINE_STIPPLE) +#define TRI_FALLBACK (DD_TRI_STIPPLE) +#define ANY_FALLBACK_FLAGS (POINT_FALLBACK|LINE_FALLBACK|TRI_FALLBACK|\ + DD_TRI_STIPPLE) +#define ANY_RASTER_FLAGS (DD_TRI_LIGHT_TWOSIDE|DD_TRI_OFFSET|DD_TRI_UNFILLED) + +static void i830ChooseRenderState(GLcontext *ctx) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + i830ContextPtr imesa = I830_CONTEXT(ctx); + GLuint flags = ctx->_TriangleCaps; + GLuint index = 0; + if (DEBUGGING) + fprintf(stderr,"\n%s\n",__FUNCTION__); + + if (flags & (ANY_FALLBACK_FLAGS|ANY_RASTER_FLAGS)) { + if (flags & ANY_RASTER_FLAGS) { + if (flags & DD_TRI_LIGHT_TWOSIDE) index |= I830_TWOSIDE_BIT; + if (flags & DD_TRI_OFFSET) index |= I830_OFFSET_BIT; + if (flags & DD_TRI_UNFILLED) index |= I830_UNFILLED_BIT; + } + + imesa->draw_point = i830_draw_point; + imesa->draw_line = i830_draw_line; + imesa->draw_tri = i830_draw_triangle; + + /* Hook in fallbacks for specific primitives. + */ + if (flags & ANY_FALLBACK_FLAGS) + { + if (flags & POINT_FALLBACK) + imesa->draw_point = i830_fallback_point; + + if (flags & LINE_FALLBACK) + imesa->draw_line = i830_fallback_line; + + if (flags & TRI_FALLBACK) + imesa->draw_tri = i830_fallback_tri; + + if (flags & DD_TRI_STIPPLE) + imesa->draw_tri = i830_fallback_tri; + + index |= I830_FALLBACK_BIT; + } + } + + if (imesa->RenderIndex != index) { + imesa->RenderIndex = index; + + tnl->Driver.Render.Points = rast_tab[index].points; + tnl->Driver.Render.Line = rast_tab[index].line; + tnl->Driver.Render.Triangle = rast_tab[index].triangle; + tnl->Driver.Render.Quad = rast_tab[index].quad; + + if (index == 0) { + tnl->Driver.Render.PrimTabVerts = i830_render_tab_verts; + tnl->Driver.Render.PrimTabElts = i830_render_tab_elts; + tnl->Driver.Render.ClippedLine = line; /* from tritmp.h */ + tnl->Driver.Render.ClippedPolygon = i830FastRenderClippedPoly; + } else { + tnl->Driver.Render.PrimTabVerts = _tnl_render_tab_verts; + tnl->Driver.Render.PrimTabElts = _tnl_render_tab_elts; + tnl->Driver.Render.ClippedLine = i830RenderClippedLine; + tnl->Driver.Render.ClippedPolygon = i830RenderClippedPoly; + } + } +} + +static const GLenum reduced_prim[GL_POLYGON+1] = { + GL_POINTS, + GL_LINES, + GL_LINES, + GL_LINES, + GL_TRIANGLES, + GL_TRIANGLES, + GL_TRIANGLES, + GL_TRIANGLES, + GL_TRIANGLES, + GL_TRIANGLES +}; + + +/**********************************************************************/ +/* High level hooks for t_vb_render.c */ +/**********************************************************************/ + + + +/* Determine the rasterized primitive when not drawing unfilled + * polygons. + * + * Used only for the default render stage which always decomposes + * primitives to trianges/lines/points. For the accelerated stage, + * which renders strips as strips, the equivalent calculations are + * performed in i810render.c. + */ +static void i830RenderPrimitive( GLcontext *ctx, GLenum prim ) +{ + i830ContextPtr imesa = I830_CONTEXT(ctx); + GLuint rprim = reduced_prim[prim]; + + imesa->render_primitive = prim; + + if (rprim == GL_TRIANGLES && (ctx->_TriangleCaps & DD_TRI_UNFILLED)) + return; + + if (imesa->reduced_primitive != rprim || + hw_prim[prim] != imesa->hw_primitive) { + i830RasterPrimitive( ctx, rprim, hw_prim[prim] ); + } +} + +static void i830RunPipeline( GLcontext *ctx ) +{ + i830ContextPtr imesa = I830_CONTEXT(ctx); + + if (imesa->new_state) { + if (imesa->new_state & _NEW_TEXTURE) + i830UpdateTextureState( ctx ); /* may modify imesa->new_state */ + + if (!imesa->Fallback) { + if (imesa->new_state & _I830_NEW_VERTEX) + i830ChooseVertexState( ctx ); + + if (imesa->new_state & _I830_NEW_RENDERSTATE) + i830ChooseRenderState( ctx ); + } + + imesa->new_state = 0; + } + + _tnl_run_pipeline( ctx ); +} + +static void i830RenderStart( GLcontext *ctx ) +{ + /* Check for projective textureing. Make sure all texcoord + * pointers point to something. (fix in mesa?) + */ + + i830CheckTexSizes( ctx ); +} + +static void i830RenderFinish( GLcontext *ctx ) +{ + if (I830_CONTEXT(ctx)->RenderIndex & I830_FALLBACK_BIT) + _swrast_flush( ctx ); +} + + + + +/* System to flush dma and emit state changes based on the rasterized + * primitive. + */ +void i830RasterPrimitive( GLcontext *ctx, + GLenum rprim, + GLuint hwprim ) +{ + i830ContextPtr imesa = I830_CONTEXT(ctx); + GLuint aa = imesa->Setup[I830_CTXREG_AA]; + + aa &= ~AA_LINE_ENABLE; + + if (0) { + /* Prints reduced prim, and hw prim */ + char *prim_name = "Unknown"; + + switch(hwprim) { + case PRIM3D_POINTLIST: + prim_name = "PointList"; + break; + case PRIM3D_LINELIST: + prim_name = "LineList"; + break; + case PRIM3D_LINESTRIP: + prim_name = "LineStrip"; + break; + case PRIM3D_TRILIST: + prim_name = "TriList"; + break; + case PRIM3D_TRISTRIP: + prim_name = "TriStrip"; + break; + case PRIM3D_TRIFAN: + prim_name = "TriFan"; + break; + case PRIM3D_POLY: + prim_name = "Polygons"; + break; + default: + break; + } + + fprintf(stderr, "%s : rprim(%s), hwprim(%s)\n", + __FUNCTION__, + _mesa_lookup_enum_by_nr(rprim), + prim_name); + } + + switch (rprim) { + case GL_TRIANGLES: + aa |= AA_LINE_DISABLE; + break; + case GL_LINES: + if (ctx->Line.SmoothFlag) { + aa |= AA_LINE_ENABLE; + } else { + aa |= AA_LINE_DISABLE; + } + break; + case GL_POINTS: + aa |= AA_LINE_DISABLE; + break; + default: + return; + } + + imesa->reduced_primitive = rprim; + + if (aa != imesa->Setup[I830_CTXREG_AA]) { + I830_STATECHANGE(imesa, I830_UPLOAD_CTX); + imesa->hw_primitive = hwprim; + imesa->Setup[I830_CTXREG_AA] = aa; + } + else if (hwprim != imesa->hw_primitive) { + I830_STATECHANGE(imesa, 0); + imesa->hw_primitive = hwprim; + } +} + +/**********************************************************************/ +/* Transition to/from hardware rasterization. */ +/**********************************************************************/ + + +void i830Fallback( i830ContextPtr imesa, GLuint bit, GLboolean mode ) +{ + GLcontext *ctx = imesa->glCtx; + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLuint oldfallback = imesa->Fallback; + + if (0) fprintf(stderr, "%s old %x bit %x mode %d\n", __FUNCTION__, + imesa->Fallback, bit, mode ); + + if (mode) { + imesa->Fallback |= bit; + if (oldfallback == 0) { + if (0) fprintf(stderr, "ENTER FALLBACK\n"); + I830_FIREVERTICES(imesa); + _swsetup_Wakeup( ctx ); + imesa->RenderIndex = ~0; + } + } + else { + imesa->Fallback &= ~bit; + if (oldfallback == bit) { + if (0) fprintf(stderr, "LEAVE FALLBACK\n"); + _swrast_flush( ctx ); + tnl->Driver.Render.Start = i830RenderStart; + tnl->Driver.Render.PrimitiveNotify = i830RenderPrimitive; + tnl->Driver.Render.Finish = i830RenderFinish; + tnl->Driver.Render.BuildVertices = i830BuildVertices; + imesa->new_state |= (_I830_NEW_RENDERSTATE|_I830_NEW_VERTEX); + } + } +} + + + + +/**********************************************************************/ +/* Initialization. */ +/**********************************************************************/ + + +void i830InitTriFuncs( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + static int firsttime = 1; + + if (firsttime) { + init_rast_tab(); + firsttime = 0; + } + + tnl->Driver.RunPipeline = i830RunPipeline; + tnl->Driver.Render.Start = i830RenderStart; + tnl->Driver.Render.Finish = i830RenderFinish; + tnl->Driver.Render.PrimitiveNotify = i830RenderPrimitive; + tnl->Driver.Render.ResetLineStipple = _swrast_ResetLineStipple; + tnl->Driver.Render.BuildVertices = i830BuildVertices; +} diff --git a/xc/lib/GL/mesa/src/drv/i830/i830_tris.h b/xc/lib/GL/mesa/src/drv/i830/i830_tris.h index e27939cd0..2096f42d5 100644 --- a/xc/lib/GL/mesa/src/drv/i830/i830_tris.h +++ b/xc/lib/GL/mesa/src/drv/i830/i830_tris.h @@ -1,263 +1,37 @@ -/************************************************************************** - -Copyright 2001 VA Linux Systems Inc., Fremont, California. - -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 -on 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 -ATI, VA LINUX SYSTEMS AND/OR THEIR 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. - -**************************************************************************/ - -/* $XFree86: xc/lib/GL/mesa/src/drv/i830/i830_tris.h,v 1.2 2002/01/17 09:50:58 eich Exp $ */ - /* - * Author: - * Jeff Hartmann <jhartmann@valinux.com> + * GLX Hardware Device Driver for Intel i810 + * Copyright (C) 1999 Keith Whitwell + * + * 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: * - * Heavily based on the I810 driver, which was written by: - * Keith Whitwell <keithw@valinux.com> + * 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 + * KEITH WHITWELL, OR ANY OTHER CONTRIBUTORS 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. + * + * Adapted for use in the I830M: + * Jeff Hartmann <jhartmann@2d3d.com> */ +/* $XFree86$ */ -#ifndef i830_TRIS_INC -#define i830_TRIS_INC - -#include "types.h" +#ifndef I830TRIS_INC +#define I830TRIS_INC -#include "i830_drv.h" -#include "i830_ioctl.h" +#include "mtypes.h" extern void i830PrintRenderState( const char *msg, GLuint state ); -extern void i830DDChooseRenderState(GLcontext *ctx); -extern void i830DDTrifuncInit( void ); - - -#define I830_FLAT_BIT 0x1 -#define I830_OFFSET_BIT 0x2 -#define I830_TWOSIDE_BIT 0x4 -#define I830_FALLBACK_BIT 0x8 - - - - -static void __inline__ i830_draw_triangle( i830ContextPtr imesa, - i830VertexPtr v0, - i830VertexPtr v1, - i830VertexPtr v2 ) -{ - GLuint vertsize = imesa->vertsize; - int j; - GLuint *vb = i830AllocDwordsInline(imesa, 3 * vertsize); - -#if 0 - - if(imesa->vertex_prim != PRIM3D_TRILIST) fprintf(stderr, "Not tris and rendering tris\n"); - - fprintf(stderr, "\n\n\n\nDrawTriangle :\n"); - fprintf(stderr, "v0\n"); - fprintf(stderr, "u: %f\n", v0->f[6]); - fprintf(stderr, "v: %f\n", v0->f[7]); - fprintf(stderr, "v1\n"); - fprintf(stderr, "u: %f\n", v1->f[6]); - fprintf(stderr, "v: %f\n", v1->f[7]); - fprintf(stderr, "v2\n"); - fprintf(stderr, "u: %f\n", v2->f[6]); - fprintf(stderr, "v: %f\n", v2->f[7]); -#endif - -#if 0 - fprintf(stderr, "\n\n\n\nDrawTriangle :\n"); - fprintf(stderr, "v0\n"); - fprintf(stderr, "0x%x\n", v0->ui[0]); - fprintf(stderr, "0x%x\n", v0->ui[1]); - fprintf(stderr, "0x%x\n", v0->ui[2]); - fprintf(stderr, "0x%x\n", v0->ui[3]); - fprintf(stderr, "0x%x\n", v0->ui[4]); - fprintf(stderr, "0x%x\n", v0->ui[5]); - fprintf(stderr, "0x%x\n", v0->ui[6]); - fprintf(stderr, "0x%x\n", v0->ui[7]); - fprintf(stderr, "0x%x\n", v0->ui[8]); - fprintf(stderr, "0x%x\n", v0->ui[9]); - fprintf(stderr, "0x%x\n", v0->ui[10]); - fprintf(stderr, "0x%x\n", v0->ui[11]); - fprintf(stderr, "0x%x\n", v0->ui[12]); - fprintf(stderr, "0x%x\n", v0->ui[13]); - fprintf(stderr, "0x%x\n", v0->ui[14]); - fprintf(stderr, "0x%x\n", v0->ui[15]); - fprintf(stderr, "v1\n"); - fprintf(stderr, "0x%x\n", v1->ui[0]); - fprintf(stderr, "0x%x\n", v1->ui[1]); - fprintf(stderr, "0x%x\n", v1->ui[2]); - fprintf(stderr, "0x%x\n", v1->ui[3]); - fprintf(stderr, "0x%x\n", v1->ui[4]); - fprintf(stderr, "0x%x\n", v1->ui[5]); - fprintf(stderr, "0x%x\n", v1->ui[6]); - fprintf(stderr, "0x%x\n", v1->ui[7]); - fprintf(stderr, "0x%x\n", v1->ui[8]); - fprintf(stderr, "0x%x\n", v1->ui[9]); - fprintf(stderr, "0x%x\n", v1->ui[10]); - fprintf(stderr, "0x%x\n", v1->ui[11]); - fprintf(stderr, "0x%x\n", v1->ui[12]); - fprintf(stderr, "0x%x\n", v1->ui[13]); - fprintf(stderr, "0x%x\n", v1->ui[14]); - fprintf(stderr, "0x%x\n", v1->ui[15]); - fprintf(stderr, "v2\n"); - fprintf(stderr, "0x%x\n", v2->ui[0]); - fprintf(stderr, "0x%x\n", v2->ui[1]); - fprintf(stderr, "0x%x\n", v2->ui[2]); - fprintf(stderr, "0x%x\n", v2->ui[3]); - fprintf(stderr, "0x%x\n", v2->ui[4]); - fprintf(stderr, "0x%x\n", v2->ui[5]); - fprintf(stderr, "0x%x\n", v2->ui[6]); - fprintf(stderr, "0x%x\n", v2->ui[7]); - fprintf(stderr, "0x%x\n", v2->ui[8]); - fprintf(stderr, "0x%x\n", v2->ui[9]); - fprintf(stderr, "0x%x\n", v2->ui[10]); - fprintf(stderr, "0x%x\n", v2->ui[11]); - fprintf(stderr, "0x%x\n", v2->ui[12]); - fprintf(stderr, "0x%x\n", v2->ui[13]); - fprintf(stderr, "0x%x\n", v2->ui[14]); - fprintf(stderr, "0x%x\n", v2->ui[15]); -#endif - -#if defined(USE_X86_ASM) - __asm__ __volatile__( "rep ; movsl" - : "=%c" (j) - : "0" (vertsize), "D" ((long)vb), "S" ((long)v0) - : "memory" ); - __asm__ __volatile__( "rep ; movsl" - : "=%c" (j) - : "0" (vertsize), "S" ((long)v1) - : "memory" ); - __asm__ __volatile__( "rep ; movsl" - : "=%c" (j) - : "0" (vertsize), "S" ((long)v2) - : "memory" ); -#else - - for (j = 0 ; j < vertsize ; j++) - vb[j] = v0->ui[j]; - - vb += vertsize; - for (j = 0 ; j < vertsize ; j++) - vb[j] = v1->ui[j]; - - vb += vertsize; - for (j = 0 ; j < vertsize ; j++) - vb[j] = v2->ui[j]; -#endif -} - -/* We aren't supporting point params, so we are ignoring size */ -static __inline__ void i830_draw_point( i830ContextPtr imesa, - i830VertexPtr tmp, - float sz ) -{ - GLuint vertsize = imesa->vertsize; - int j; - GLuint *vb = i830AllocDwordsInline( imesa, 1 * vertsize ); - -#if 0 - if(imesa->vertex_prim != PRIM3D_POINTLIST) fprintf(stderr, "Not points and rendering points\n"); -#endif - -#if defined(USE_X86_ASM) - __asm__ __volatile__( "rep ; movsl" - : "=%c" (j) - : "0" (vertsize), "D" ((long)vb), "S" ((long)tmp) - : "memory" ); -#else - for (j = 0 ; j < vertsize ; j++) - vb[j] = tmp->ui[j]; - -#endif - -} - -static __inline__ void i830_draw_line( i830ContextPtr imesa, - i830VertexPtr v0, - i830VertexPtr v1 ) -{ - GLuint vertsize = imesa->vertsize; - int j; - GLuint *vb = i830AllocDwordsInline( imesa, 2 * vertsize ); - -#if 0 - if(imesa->vertex_prim != PRIM3D_LINELIST) fprintf(stderr, "Not lines and rendering lines : prim %d\n", imesa->vertex_prim); -#endif - -#if 0 - fprintf(stderr, "\n\n\n\nDrawLine"); - fprintf(stderr, "v0\n"); - fprintf(stderr, "0x%x\n", v0->ui[0]); - fprintf(stderr, "0x%x\n", v0->ui[1]); - fprintf(stderr, "0x%x\n", v0->ui[2]); - fprintf(stderr, "0x%x\n", v0->ui[3]); - fprintf(stderr, "0x%x\n", v0->ui[4]); - fprintf(stderr, "0x%x\n", v0->ui[5]); - fprintf(stderr, "0x%x\n", v0->ui[6]); - fprintf(stderr, "0x%x\n", v0->ui[7]); - fprintf(stderr, "0x%x\n", v0->ui[8]); - fprintf(stderr, "0x%x\n", v0->ui[9]); - fprintf(stderr, "0x%x\n", v0->ui[10]); - fprintf(stderr, "0x%x\n", v0->ui[11]); - fprintf(stderr, "0x%x\n", v0->ui[12]); - fprintf(stderr, "0x%x\n", v0->ui[13]); - fprintf(stderr, "0x%x\n", v0->ui[14]); - fprintf(stderr, "0x%x\n", v0->ui[15]); - fprintf(stderr, "v1\n"); - fprintf(stderr, "0x%x\n", v1->ui[0]); - fprintf(stderr, "0x%x\n", v1->ui[1]); - fprintf(stderr, "0x%x\n", v1->ui[2]); - fprintf(stderr, "0x%x\n", v1->ui[3]); - fprintf(stderr, "0x%x\n", v1->ui[4]); - fprintf(stderr, "0x%x\n", v1->ui[5]); - fprintf(stderr, "0x%x\n", v1->ui[6]); - fprintf(stderr, "0x%x\n", v1->ui[7]); - fprintf(stderr, "0x%x\n", v1->ui[8]); - fprintf(stderr, "0x%x\n", v1->ui[9]); - fprintf(stderr, "0x%x\n", v1->ui[10]); - fprintf(stderr, "0x%x\n", v1->ui[11]); - fprintf(stderr, "0x%x\n", v1->ui[12]); - fprintf(stderr, "0x%x\n", v1->ui[13]); - fprintf(stderr, "0x%x\n", v1->ui[14]); - fprintf(stderr, "0x%x\n", v1->ui[15]); -#endif - -#if defined(USE_X86_ASM) - __asm__ __volatile__( "rep ; movsl" - : "=%c" (j) - : "0" (vertsize), "D" ((long)vb), "S" ((long)v0) - : "memory" ); - __asm__ __volatile__( "rep ; movsl" - : "=%c" (j) - : "0" (vertsize), "S" ((long)v1) - : "memory" ); -#else - for (j = 0 ; j < vertsize ; j++) - vb[j] = v0->ui[j]; - - vb += vertsize; - for (j = 0 ; j < vertsize ; j++) - vb[j] = v1->ui[j]; -#endif -} - +extern void i830InitTriFuncs( GLcontext *ctx ); +extern void i830RasterPrimitive( GLcontext *ctx, GLenum rprim, GLuint hwprim ); #endif diff --git a/xc/lib/GL/mesa/src/drv/i830/i830_tritmp.h b/xc/lib/GL/mesa/src/drv/i830/i830_tritmp.h deleted file mode 100644 index b2ab90d36..000000000 --- a/xc/lib/GL/mesa/src/drv/i830/i830_tritmp.h +++ /dev/null @@ -1,276 +0,0 @@ -/************************************************************************** - -Copyright 2001 VA Linux Systems Inc., Fremont, California. - -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 -on 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 -ATI, VA LINUX SYSTEMS AND/OR THEIR 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. - -**************************************************************************/ - -/* $XFree86: xc/lib/GL/mesa/src/drv/i830/i830_tritmp.h,v 1.1 2001/10/04 18:28:21 alanh Exp $ */ - -/* - * Author: - * Jeff Hartmann <jhartmann@valinux.com> - * - * Heavily based on the I810 driver, which was written by: - * Keith Whitwell <keithw@valinux.com> - */ - -static __inline void TAG(triangle)(GLcontext *ctx, - GLuint e0, GLuint e1, GLuint e2, - GLuint pv) -{ - i830ContextPtr imesa = I830_CONTEXT(ctx); - struct vertex_buffer *VB = ctx->VB; - i830VertexPtr i830verts = I830_DRIVER_DATA(VB)->verts; - i830Vertex *v[3]; - -#if (IND & I830_OFFSET_BIT) - GLfloat offset; - GLfloat z[3]; -#endif - -#if (IND & (I830_TWOSIDE_BIT | I830_FLAT_BIT)) - GLuint c[3]; - GLuint s[3]; -#endif - - v[0] = &i830verts[e0]; - v[1] = &i830verts[e1]; - v[2] = &i830verts[e2]; - -#if (IND & (I830_TWOSIDE_BIT | I830_FLAT_BIT)) - c[0] = v[0]->ui[4]; - c[1] = v[1]->ui[4]; - c[2] = v[2]->ui[4]; - s[0] = v[0]->ui[5]; - s[1] = v[1]->ui[5]; - s[2] = v[2]->ui[5]; -#endif - - -#if (IND & (I830_TWOSIDE_BIT | I830_OFFSET_BIT)) - { - GLfloat ex = v[0]->v.x - v[2]->v.x; - GLfloat ey = v[0]->v.y - v[2]->v.y; - GLfloat fx = v[1]->v.x - v[2]->v.x; - GLfloat fy = v[1]->v.y - v[2]->v.y; - GLfloat cc = ex*fy - ey*fx; - -#if (IND & I830_TWOSIDE_BIT) - { - GLuint facing = (cc > 0.0) ^ ctx->Polygon.FrontBit; - GLubyte (*vbcolor)[4] = VB->Color[facing]->data; - GLubyte (*vbspec)[4] = VB->Spec[facing]; - if (IND & I830_FLAT_BIT) { - I830_COLOR((char *)&v[0]->ui[4], vbcolor[pv]); - v[2]->ui[4] = v[1]->ui[4] = v[0]->ui[4]; - I830_COLOR3((char *)&v[0]->ui[5], vbspec[pv]); - v[2]->ui[5] = v[1]->ui[5] = v[0]->ui[5]; - } else { - I830_COLOR((char *)&v[0]->ui[4], vbcolor[e0]); - I830_COLOR((char *)&v[1]->ui[4], vbcolor[e1]); - I830_COLOR((char *)&v[2]->ui[4], vbcolor[e2]); - I830_COLOR3((char *)&v[0]->ui[5], vbspec[e0]); - I830_COLOR3((char *)&v[1]->ui[5], vbspec[e1]); - I830_COLOR3((char *)&v[2]->ui[5], vbspec[e2]); - } - } -#endif - -#if (IND & I830_OFFSET_BIT) - { - /*offset = ctx->Polygon.OffsetUnits * 1.0/0x10000;*/ - offset = ctx->Polygon.OffsetUnits * imesa->depth_scale; - z[0] = v[0]->v.z; - z[1] = v[1]->v.z; - z[2] = v[2]->v.z; - if (cc * cc > 1e-16) { - GLfloat ez = z[0] - z[2]; - GLfloat fz = z[1] - z[2]; - GLfloat a = ey*fz - ez*fy; - GLfloat b = ez*fx - ex*fz; - GLfloat ic = 1.0 / cc; - GLfloat ac = a * ic; - GLfloat bc = b * ic; - if (ac < 0.0f) ac = -ac; - if (bc < 0.0f) bc = -bc; - offset += MAX2(ac, bc) * ctx->Polygon.OffsetFactor; - } - v[0]->v.z += offset; - v[1]->v.z += offset; - v[2]->v.z += offset; - } -#endif - } -#elif (IND & I830_FLAT_BIT) - { - GLuint color = i830verts[pv].ui[4]; - GLuint spec = i830verts[pv].ui[5]; - v[0]->ui[4] = color; - v[1]->ui[4] = color; - v[2]->ui[4] = color; - v[0]->ui[5] = spec; - v[1]->ui[5] = spec; - v[2]->ui[5] = spec; - } -#endif - - i830_draw_triangle( imesa, v[0], v[1], v[2] ); - -#if (IND & I830_OFFSET_BIT) - v[0]->v.z = z[0]; - v[1]->v.z = z[1]; - v[2]->v.z = z[2]; -#endif - -#if (IND & (I830_FLAT_BIT | I830_TWOSIDE_BIT)) - v[0]->ui[4] = c[0]; - v[1]->ui[4] = c[1]; - v[2]->ui[4] = c[2]; - v[0]->ui[5] = s[0]; - v[1]->ui[5] = s[1]; - v[2]->ui[5] = s[2]; -#endif - -} - - - - -static void TAG(quad)( GLcontext *ctx, GLuint v0, - GLuint v1, GLuint v2, GLuint v3, - GLuint pv ) -{ - TAG(triangle)( ctx, v0, v1, v3, pv ); - TAG(triangle)( ctx, v1, v2, v3, pv ); -} - - -static void TAG(line)( GLcontext *ctx, GLuint v0, GLuint v1, GLuint pv ) -{ - i830ContextPtr imesa = I830_CONTEXT( ctx ); - i830VertexPtr i830VB = I830_DRIVER_DATA(ctx->VB)->verts; - GLfloat z0, z1; - GLuint c0, c1; - GLuint s0, s1; - i830Vertex *vert0 = &i830VB[v0]; - i830Vertex *vert1 = &i830VB[v1]; - - if (IND & I830_TWOSIDE_BIT) { - GLubyte (*vbcolor)[4] = ctx->VB->ColorPtr->data; - GLubyte (*vbspec)[4] = ctx->VB->Specular; - - if (IND & I830_FLAT_BIT) { - I830_COLOR((char *)&vert0->v.color,vbcolor[pv]); - *(int *)&vert1->v.color = *(int *)&vert0->v.color; - I830_COLOR3((char *)&vert0->v.specular, vbspec[pv]); - *(int *)&vert1->v.specular = *(int *)&vert0->v.specular; - } else { - I830_COLOR((char *)&vert0->v.color,vbcolor[v0]); - I830_COLOR((char *)&vert1->v.color,vbcolor[v1]); - I830_COLOR3((char *)&vert0->v.specular, vbspec[v0]); - I830_COLOR3((char *)&vert1->v.specular, vbspec[v1]); - } - } else if (IND & I830_FLAT_BIT) { - c0 = *(GLuint *) &(vert0->v.color); - c1 = *(GLuint *) &(vert1->v.color); - *(int *)&vert0->v.color = - *(int *)&vert1->v.color = *(int *)&i830VB[pv].v.color; - s0 = *(GLuint *) &(vert0->v.specular); - s1 = *(GLuint *) &(vert1->v.specular); - *(int *)&vert0->v.specular = - *(int *)&vert1->v.specular = *(int *)&i830VB[pv].v.specular; - } - - if (IND & I830_OFFSET_BIT) { - /*GLfloat offset = ctx->LineZoffset * (1.0 / 0x10000);*/ - GLfloat offset = ctx->LineZoffset * imesa->depth_scale; - z0 = vert0->v.z; - z1 = vert1->v.z; - vert0->v.z += offset; - vert1->v.z += offset; - } - - i830_draw_line( imesa, &i830VB[v0], &i830VB[v1]); - - if (IND & I830_OFFSET_BIT) { - vert0->v.z = z0; - vert1->v.z = z1; - } - - if ((IND & I830_FLAT_BIT) && !(IND & I830_TWOSIDE_BIT)) { - *(GLuint *) &(vert0->v.color) = c0; - *(GLuint *) &(vert1->v.color) = c1; - *(GLuint *) &(vert0->v.specular) = s0; - *(GLuint *) &(vert1->v.specular) = s1; - } -} - -static void TAG(points)( GLcontext *ctx, GLuint first, GLuint last ) -{ - i830ContextPtr imesa = I830_CONTEXT( ctx ); - struct vertex_buffer *VB = ctx->VB; - i830VertexPtr i830VB = I830_DRIVER_DATA(VB)->verts; - GLfloat sz = ctx->Point.Size * .5; - int i; - - for(i=first;i<last;i++) - if(VB->ClipMask[i]==0) { - if (IND & (I830_TWOSIDE_BIT|I830_OFFSET_BIT)) { - i830Vertex tmp0 = i830VB[i]; - if (IND & I830_TWOSIDE_BIT) { - GLubyte (*vbcolor)[4] = VB->ColorPtr->data; - I830_COLOR((char *)&tmp0.v.color, vbcolor[i]); - } - if (IND & I830_OFFSET_BIT) { - /*GLfloat offset = ctx->PointZoffset * (1.0 / 0x10000);*/ - GLfloat offset = ctx->PointZoffset * imesa->depth_scale; - tmp0.v.z += offset; - } - tmp0.f[0] -= 0.125; - tmp0.f[1] -= 0.125; - i830_draw_point( imesa, &tmp0, sz ); - } else { - i830VB[i].f[0] -= 0.125; - i830VB[i].f[1] -= 0.125; - i830_draw_point( imesa, &i830VB[i], sz ); - i830VB[i].f[0] += 0.125; - i830VB[i].f[1] += 0.125; - } - } -} - - - - -static void TAG(init)( void ) -{ - tri_tab[IND] = TAG(triangle); - quad_tab[IND] = TAG(quad); - line_tab[IND] = TAG(line); - points_tab[IND] = TAG(points); -} - - -#undef IND -#undef TAG diff --git a/xc/lib/GL/mesa/src/drv/i830/i830_vb.c b/xc/lib/GL/mesa/src/drv/i830/i830_vb.c index dad88fa2f..671598b7f 100644 --- a/xc/lib/GL/mesa/src/drv/i830/i830_vb.c +++ b/xc/lib/GL/mesa/src/drv/i830/i830_vb.c @@ -1,480 +1,592 @@ -/************************************************************************** - -Copyright 2001 VA Linux Systems Inc., Fremont, California. - -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 -on 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 -ATI, VA LINUX SYSTEMS AND/OR THEIR 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. - -**************************************************************************/ - -/* $XFree86: xc/lib/GL/mesa/src/drv/i830/i830_vb.c,v 1.1 2001/10/04 18:28:21 alanh Exp $ */ - /* - * Author: - * Jeff Hartmann <jhartmann@valinux.com> + * GLX Hardware Device Driver for Intel i810 + * Copyright (C) 1999 Keith Whitwell + * + * 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. * - * Heavily based on the I810 driver, which was written by: - * Keith Whitwell <keithw@valinux.com> + * 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 + * KEITH WHITWELL, OR ANY OTHER CONTRIBUTORS 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. + * + * Adapted for use on the I830M: + * Jeff Hartmann <jhartmann@2d3d.com> */ - -#include <stdio.h> -#include <stdlib.h> +/* $XFree86$ */ -#include "i830_drv.h" +#include "glheader.h" +#include "mtypes.h" #include "mem.h" -#include "stages.h" +#include "macros.h" +#include "colormac.h" +#include "mmath.h" -#define TEX0 { \ - v->v.tu0 = tc0[i][0]; \ - v->v.tv0 = tc0[i][1]; \ -} - -#define TEX1 { \ - v->v.tu1 = tc1[i][0]; \ - v->v.tv1 = tc1[i][1]; \ -} +#include "swrast_setup/swrast_setup.h" +#include "tnl/t_context.h" -/* Doesn't seem to work very well (golly). - */ -#define SPC { \ - GLubyte *spec = &(VB->Spec[0][i][0]); \ - v->v.specular.red = spec[0]; \ - v->v.specular.green = spec[1]; \ - v->v.specular.blue = spec[2]; \ -} - -#define FOG { \ - GLubyte *spec = &(VB->Spec[0][i][0]); \ - v->v.specular.alpha = spec[3]; \ -} +#include "i830_screen.h" +#include "i830_dri.h" -#define COL { \ - GLubyte *col = &(VB->Color[0]->data[i][0]); \ - v->v.color.blue = col[2]; \ - v->v.color.green = col[1]; \ - v->v.color.red = col[0]; \ - v->v.color.alpha = col[3]; \ -} +#include "i830_context.h" +#include "i830_vb.h" +#include "i830_ioctl.h" +#include "i830_tris.h" +#include "i830_state.h" +#include "i830_drv.h" -/* The vertex formats we have don't seem to support projective texturing - * in the multitexture case. (Would require another 1/w value for the - * second set of texcoords). - * XXX grantham - i830 does q coordinate, haven't spent time to figure out - * how to implement dynamic HOMOGENOUS coord; plus need to copy tc[i][2] - * for cube maps, not tc[i][3] +#define I830_TEX1_BIT 0x1 +#define I830_TEX0_BIT 0x2 +#define I830_RGBA_BIT 0x4 +#define I830_SPEC_BIT 0x8 +#define I830_FOG_BIT 0x10 +#define I830_XYZW_BIT 0x20 +#define I830_PTEX_BIT 0x40 +#define I830_MAX_SETUP 0x80 + +static struct { + void (*emit)( GLcontext *, GLuint, GLuint, void *, GLuint ); + interp_func interp; + copy_pv_func copy_pv; + GLboolean (*check_tex_sizes)( GLcontext *ctx ); + GLuint vertex_size; + GLuint vertex_stride_shift; + GLuint vertex_format; +} setup_tab[I830_MAX_SETUP]; + +#define TINY_VERTEX_FORMAT (STATE3D_VERTEX_FORMAT_CMD | \ + VRTX_TEX_COORD_COUNT(0) | \ + VRTX_HAS_DIFFUSE | \ + VRTX_HAS_XYZ) + +#define NOTEX_VERTEX_FORMAT (STATE3D_VERTEX_FORMAT_CMD | \ + VRTX_TEX_COORD_COUNT(0) | \ + VRTX_HAS_DIFFUSE | \ + VRTX_HAS_SPEC | \ + VRTX_HAS_XYZW) + +#define TEX0_VERTEX_FORMAT (STATE3D_VERTEX_FORMAT_CMD | \ + VRTX_TEX_COORD_COUNT(1) | \ + VRTX_HAS_DIFFUSE | \ + VRTX_HAS_SPEC | \ + VRTX_HAS_XYZW) + +#define TEX1_VERTEX_FORMAT (STATE3D_VERTEX_FORMAT_CMD | \ + VRTX_TEX_COORD_COUNT(2) | \ + VRTX_HAS_DIFFUSE | \ + VRTX_HAS_SPEC | \ + VRTX_HAS_XYZW) + + +/* I'm cheating here hardcore : if bit 31 is set I know to emit + * a vf2 state == TEXCOORDFMT_3D. We never mix 2d/3d texcoords, + * so this solution works for now. */ -#define TEX0_4 \ - if (VB->TexCoordPtr[0]->size == 4) \ - { \ - GLfloat (*tc)[4] = VB->TexCoordPtr[0]->data; \ - v = &(I830_DRIVER_DATA(VB)->verts[start]); \ - imesa->setupdone &= ~I830_WIN_BIT; \ - for (i=start; i < end; i++, v++) { \ - float oow = 1.0 / tc[i][3]; \ - v->v.oow *= tc[i][3]; \ - v->v.tu0 *= oow; \ - v->v.tv0 *= oow; \ - } \ - } - -#define COORD \ - GLfloat *win = VB->Win.data[i]; \ - v->v.x = xoffset + win[0]; \ - v->v.y = yoffset - win[1]; \ - v->v.z = depth_scale * win[2]; \ - v->v.oow = win[3]; - - -#define NOP -#define SUBPIXEL_X 0.125 -#define SUBPIXEL_Y 0.125 - -#define SETUPFUNC(name,win,col,tex0,tex1,tex0_4,spec,fog) \ -static void name(struct vertex_buffer *VB, GLuint start, GLuint end) \ -{ \ - i830ContextPtr imesa = I830_CONTEXT( VB->ctx ); \ - __DRIdrawablePrivate *dPriv = imesa->driDrawable; \ - i830VertexPtr v; \ - GLfloat (*tc0)[4]; \ - GLfloat (*tc1)[4]; \ - const GLfloat depth_scale = imesa->depth_scale; \ - const GLfloat xoffset = SUBPIXEL_X; \ - const GLfloat yoffset = dPriv->h + SUBPIXEL_Y; \ - int i; \ - (void) xoffset; \ - (void) yoffset; \ - (void) imesa; \ - (void) depth_scale; \ - \ - \ - gl_import_client_data( VB, VB->ctx->RenderFlags, \ - (VB->ClipOrMask \ - ? VEC_WRITABLE|VEC_GOOD_STRIDE \ - : VEC_GOOD_STRIDE)); \ - \ - tc0 = VB->TexCoordPtr[0]->data; \ - tc1 = VB->TexCoordPtr[1]->data; \ - \ - v = &(I830_DRIVER_DATA(VB)->verts[start]); \ - \ - if (VB->ClipOrMask == 0) \ - for (i=start; i < end; i++, v++) { \ - win; \ - col; \ - spec; \ - fog; \ - tex0; \ - tex1; \ - } \ - else \ - for (i=start; i < end; i++, v++) { \ - if (VB->ClipMask[i] == 0) { \ - win; \ - spec; \ - fog; \ - tex0; \ - tex1; \ - } \ - col; \ - } \ - tex0_4; \ - /* tex1_4; */ \ - /* tex2_4; */ \ - /* tex3_4; */ \ -} - -SETUPFUNC(rs_wt0, COORD,NOP,TEX0,NOP,TEX0_4,NOP,NOP) -SETUPFUNC(rs_wt0t1, COORD,NOP,TEX0,TEX1,TEX0_4,NOP,NOP) -SETUPFUNC(rs_wft0, COORD,NOP,TEX0,NOP,TEX0_4,NOP,FOG) -SETUPFUNC(rs_wft0t1, COORD,NOP,TEX0,TEX1,TEX0_4,NOP,FOG) -SETUPFUNC(rs_wg, COORD,COL,NOP,NOP,NOP,NOP,NOP) -SETUPFUNC(rs_wgs, COORD,COL,NOP,NOP,NOP,SPC,NOP) -SETUPFUNC(rs_wgt0, COORD,COL,TEX0,NOP,TEX0_4,NOP,NOP) -SETUPFUNC(rs_wgt0t1, COORD,COL,TEX0,TEX1,TEX0_4,NOP,NOP) -SETUPFUNC(rs_wgst0, COORD,COL,TEX0,NOP,TEX0_4,SPC,NOP) -SETUPFUNC(rs_wgst0t1, COORD,COL,TEX0,TEX1,TEX0_4,SPC,NOP) -SETUPFUNC(rs_wgf, COORD,COL,NOP,NOP,NOP,NOP,FOG) -SETUPFUNC(rs_wgfs, COORD,COL,NOP,NOP,NOP,SPC,FOG) -SETUPFUNC(rs_wgft0, COORD,COL,TEX0,NOP,TEX0_4,NOP,FOG) -SETUPFUNC(rs_wgft0t1, COORD,COL,TEX0,TEX1,TEX0_4,NOP,FOG) -SETUPFUNC(rs_wgfst0, COORD,COL,TEX0,NOP,TEX0_4,SPC,FOG) -SETUPFUNC(rs_wgfst0t1, COORD,COL,TEX0,TEX1,TEX0_4,SPC,FOG) - -SETUPFUNC(rs_t0, NOP,NOP,TEX0,NOP,TEX0_4,NOP,NOP) -SETUPFUNC(rs_t0t1, NOP,NOP,TEX0,TEX1,TEX0_4,NOP,NOP) -SETUPFUNC(rs_f, NOP,NOP,NOP,NOP,NOP,NOP,FOG) -SETUPFUNC(rs_ft0, NOP,NOP,TEX0,NOP,TEX0_4,NOP,FOG) -SETUPFUNC(rs_ft0t1, NOP,NOP,TEX0,TEX1,TEX0_4,NOP,FOG) -SETUPFUNC(rs_g, NOP,COL,NOP,NOP,NOP,NOP,NOP) -SETUPFUNC(rs_gs, NOP,COL,NOP,NOP,NOP,SPC,NOP) -SETUPFUNC(rs_gt0, NOP,COL,TEX0,NOP,TEX0_4,NOP,NOP) -SETUPFUNC(rs_gt0t1, NOP,COL,TEX0,TEX1,TEX0_4,NOP,NOP) -SETUPFUNC(rs_gst0, NOP,COL,TEX0,NOP,TEX0_4,SPC,NOP) -SETUPFUNC(rs_gst0t1, NOP,COL,TEX0,TEX1,TEX0_4,SPC,NOP) -SETUPFUNC(rs_gf, NOP,COL,NOP,NOP,NOP,NOP,FOG) -SETUPFUNC(rs_gfs, NOP,COL,NOP,NOP,NOP,SPC,FOG) -SETUPFUNC(rs_gft0, NOP,COL,TEX0,NOP,TEX0_4,NOP,FOG) -SETUPFUNC(rs_gft0t1, NOP,COL,TEX0,TEX1,TEX0_4,NOP,FOG) -SETUPFUNC(rs_gfst0, NOP,COL,TEX0,NOP,TEX0_4,SPC,FOG) -SETUPFUNC(rs_gfst0t1, NOP,COL,TEX0,TEX1,TEX0_4,SPC,FOG) - - - -static void rs_invalid(struct vertex_buffer *VB, GLuint start, GLuint end) -{ - - fprintf(stderr, "i830RasterSetup(): invalid setup function\n"); -} +#define PROJ_TEX1_VERTEX_FORMAT ((1<<31) | \ + STATE3D_VERTEX_FORMAT_CMD | \ + VRTX_TEX_COORD_COUNT(2) | \ + VRTX_HAS_DIFFUSE | \ + VRTX_HAS_SPEC | \ + VRTX_HAS_XYZW) + +/* Might want to do these later */ +#define TEX2_VERTEX_FORMAT 0 +#define TEX3_VERTEX_FORMAT 0 +#define PROJ_TEX3_VERTEX_FORMAT 0 + +#define DO_XYZW (IND & I830_XYZW_BIT) +#define DO_RGBA (IND & I830_RGBA_BIT) +#define DO_SPEC (IND & I830_SPEC_BIT) +#define DO_FOG (IND & I830_FOG_BIT) +#define DO_TEX0 (IND & I830_TEX0_BIT) +#define DO_TEX1 (IND & I830_TEX1_BIT) +#define DO_TEX2 0 +#define DO_TEX3 0 +#define DO_PTEX (IND & I830_PTEX_BIT) + +#define VERTEX i830Vertex +#define GET_VIEWPORT_MAT() I830_CONTEXT(ctx)->ViewportMatrix.m +#define GET_TEXSOURCE(n) n +#define GET_VERTEX_FORMAT() I830_CONTEXT(ctx)->vertex_format +#define GET_VERTEX_STORE() I830_CONTEXT(ctx)->verts +#define GET_VERTEX_STRIDE_SHIFT() I830_CONTEXT(ctx)->vertex_stride_shift +#define GET_UBYTE_COLOR_STORE() &I830_CONTEXT(ctx)->UbyteColor +#define GET_UBYTE_SPEC_COLOR_STORE() &I830_CONTEXT(ctx)->UbyteSecondaryColor +#define INVALIDATE_STORED_VERTICES() + +#define HAVE_HW_VIEWPORT 0 +#define HAVE_HW_DIVIDE 0 +#define HAVE_RGBA_COLOR 0 +#define HAVE_TINY_VERTICES 1 +#define HAVE_NOTEX_VERTICES 1 +#define HAVE_TEX0_VERTICES 1 +#define HAVE_TEX1_VERTICES 1 +#define HAVE_TEX2_VERTICES 0 +#define HAVE_TEX3_VERTICES 0 +#define HAVE_PTEX_VERTICES 1 + +#define UNVIEWPORT_VARS GLfloat h = I830_CONTEXT(ctx)->driDrawable->h +#define UNVIEWPORT_X(x) x - SUBPIXEL_X +#define UNVIEWPORT_Y(y) - y + h + SUBPIXEL_Y +#define UNVIEWPORT_Z(z) z * (float)I830_CONTEXT(ctx)->ClearDepth + +#define PTEX_FALLBACK() FALLBACK(I830_CONTEXT(ctx), I830_FALLBACK_TEXTURE, 1) + +#define IMPORT_FLOAT_COLORS i830_import_float_colors +#define IMPORT_FLOAT_SPEC_COLORS i830_import_float_spec_colors + +#define INTERP_VERTEX setup_tab[I830_CONTEXT(ctx)->SetupIndex].interp +#define COPY_PV_VERTEX setup_tab[I830_CONTEXT(ctx)->SetupIndex].copy_pv + + +/*********************************************************************** + * Generate pv-copying and translation functions * + ***********************************************************************/ + +#define TAG(x) i830_##x +#include "tnl_dd/t_dd_vb.c" + +/*********************************************************************** + * Generate vertex emit and interp functions * + ***********************************************************************/ + +#define IND (I830_XYZW_BIT|I830_RGBA_BIT) +#define TAG(x) x##_wg +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_XYZW_BIT|I830_RGBA_BIT|I830_SPEC_BIT) +#define TAG(x) x##_wgs +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_XYZW_BIT|I830_RGBA_BIT|I830_TEX0_BIT) +#define TAG(x) x##_wgt0 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_XYZW_BIT|I830_RGBA_BIT|I830_TEX0_BIT|I830_TEX1_BIT) +#define TAG(x) x##_wgt0t1 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_XYZW_BIT|I830_RGBA_BIT|I830_TEX0_BIT|I830_PTEX_BIT) +#define TAG(x) x##_wgpt0 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_XYZW_BIT|I830_RGBA_BIT|I830_SPEC_BIT|I830_TEX0_BIT) +#define TAG(x) x##_wgst0 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_XYZW_BIT|I830_RGBA_BIT|I830_SPEC_BIT|I830_TEX0_BIT|\ + I830_TEX1_BIT) +#define TAG(x) x##_wgst0t1 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_XYZW_BIT|I830_RGBA_BIT|I830_SPEC_BIT|I830_TEX0_BIT|\ + I830_PTEX_BIT) +#define TAG(x) x##_wgspt0 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_XYZW_BIT|I830_RGBA_BIT|I830_FOG_BIT) +#define TAG(x) x##_wgf +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_XYZW_BIT|I830_RGBA_BIT|I830_FOG_BIT|I830_SPEC_BIT) +#define TAG(x) x##_wgfs +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_XYZW_BIT|I830_RGBA_BIT|I830_FOG_BIT|I830_TEX0_BIT) +#define TAG(x) x##_wgft0 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_XYZW_BIT|I830_RGBA_BIT|I830_FOG_BIT|I830_TEX0_BIT|\ + I830_TEX1_BIT) +#define TAG(x) x##_wgft0t1 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_XYZW_BIT|I830_RGBA_BIT|I830_FOG_BIT|I830_TEX0_BIT|\ + I830_PTEX_BIT) +#define TAG(x) x##_wgfpt0 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_XYZW_BIT|I830_RGBA_BIT|I830_FOG_BIT|I830_SPEC_BIT|\ + I830_TEX0_BIT) +#define TAG(x) x##_wgfst0 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_XYZW_BIT|I830_RGBA_BIT|I830_FOG_BIT|I830_SPEC_BIT|\ + I830_TEX0_BIT|I830_TEX1_BIT) +#define TAG(x) x##_wgfst0t1 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_XYZW_BIT|I830_RGBA_BIT|I830_FOG_BIT|I830_SPEC_BIT|\ + I830_TEX0_BIT|I830_PTEX_BIT) +#define TAG(x) x##_wgfspt0 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_TEX0_BIT) +#define TAG(x) x##_t0 +#include "tnl_dd/t_dd_vbtmp.h" -typedef void (*setupFunc)(struct vertex_buffer *,GLuint,GLuint); +#define IND (I830_TEX0_BIT|I830_TEX1_BIT) +#define TAG(x) x##_t0t1 +#include "tnl_dd/t_dd_vbtmp.h" -static setupFunc setup_func[0x80]; +#define IND (I830_FOG_BIT) +#define TAG(x) x##_f +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_FOG_BIT|I830_TEX0_BIT) +#define TAG(x) x##_ft0 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_FOG_BIT|I830_TEX0_BIT|I830_TEX1_BIT) +#define TAG(x) x##_ft0t1 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_RGBA_BIT) +#define TAG(x) x##_g +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_RGBA_BIT|I830_SPEC_BIT) +#define TAG(x) x##_gs +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_RGBA_BIT|I830_TEX0_BIT) +#define TAG(x) x##_gt0 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_RGBA_BIT|I830_TEX0_BIT|I830_TEX1_BIT) +#define TAG(x) x##_gt0t1 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_RGBA_BIT|I830_SPEC_BIT|I830_TEX0_BIT) +#define TAG(x) x##_gst0 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_RGBA_BIT|I830_SPEC_BIT|I830_TEX0_BIT|I830_TEX1_BIT) +#define TAG(x) x##_gst0t1 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_RGBA_BIT|I830_FOG_BIT) +#define TAG(x) x##_gf +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_RGBA_BIT|I830_FOG_BIT|I830_SPEC_BIT) +#define TAG(x) x##_gfs +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_RGBA_BIT|I830_FOG_BIT|I830_TEX0_BIT) +#define TAG(x) x##_gft0 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_RGBA_BIT|I830_FOG_BIT|I830_TEX0_BIT|I830_TEX1_BIT) +#define TAG(x) x##_gft0t1 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_RGBA_BIT|I830_FOG_BIT|I830_SPEC_BIT|I830_TEX0_BIT) +#define TAG(x) x##_gfst0 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_RGBA_BIT|I830_FOG_BIT|I830_SPEC_BIT|I830_TEX0_BIT|\ + I830_TEX1_BIT) +#define TAG(x) x##_gfst0t1 +#include "tnl_dd/t_dd_vbtmp.h" + +/* Add functions for proj texturing for t0 and t1 */ +#define IND (I830_XYZW_BIT|I830_RGBA_BIT|I830_TEX0_BIT|I830_TEX1_BIT|\ + I830_PTEX_BIT) +#define TAG(x) x##_wgpt0t1 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_XYZW_BIT|I830_RGBA_BIT|I830_SPEC_BIT|I830_TEX0_BIT|\ + I830_TEX1_BIT|I830_PTEX_BIT) +#define TAG(x) x##_wgspt0t1 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_XYZW_BIT|I830_RGBA_BIT|I830_FOG_BIT|I830_TEX0_BIT|\ + I830_TEX1_BIT|I830_PTEX_BIT) +#define TAG(x) x##_wgfpt0t1 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (I830_XYZW_BIT|I830_RGBA_BIT|I830_FOG_BIT|I830_SPEC_BIT|\ + I830_TEX1_BIT|I830_TEX0_BIT|I830_PTEX_BIT) +#define TAG(x) x##_wgfspt0t1 +#include "tnl_dd/t_dd_vbtmp.h" -void i830DDSetupInit( void ) + +static void init_setup_tab( void ) { - int i; - - for (i = 0 ; i < 0x80 ; i++) - setup_func[i] = rs_invalid; - - /* Functions to build vert's from scratch */ - setup_func[I830_WIN_BIT|I830_TEX0_BIT] = rs_wt0; - setup_func[I830_WIN_BIT|I830_TEX0_BIT|I830_TEX1_BIT] = rs_wt0t1; - setup_func[I830_WIN_BIT|I830_FOG_BIT|I830_TEX0_BIT] = rs_wft0; - setup_func[I830_WIN_BIT|I830_FOG_BIT|I830_TEX0_BIT|I830_TEX1_BIT] = rs_wft0t1; - setup_func[I830_WIN_BIT|I830_RGBA_BIT] = rs_wg; - setup_func[I830_WIN_BIT|I830_RGBA_BIT|I830_SPEC_BIT] = rs_wgs; - setup_func[I830_WIN_BIT|I830_RGBA_BIT|I830_TEX0_BIT] = rs_wgt0; - setup_func[I830_WIN_BIT|I830_RGBA_BIT|I830_TEX0_BIT|I830_TEX1_BIT] = rs_wgt0t1; - setup_func[I830_WIN_BIT|I830_RGBA_BIT|I830_SPEC_BIT|I830_TEX0_BIT] = rs_wgst0; - setup_func[I830_WIN_BIT|I830_RGBA_BIT|I830_SPEC_BIT|I830_TEX0_BIT|I830_TEX1_BIT] = rs_wgst0t1; - setup_func[I830_WIN_BIT|I830_RGBA_BIT|I830_FOG_BIT] = rs_wgf; - setup_func[I830_WIN_BIT|I830_RGBA_BIT|I830_FOG_BIT|I830_SPEC_BIT] = rs_wgfs; - setup_func[I830_WIN_BIT|I830_RGBA_BIT|I830_FOG_BIT|I830_TEX0_BIT] = rs_wgft0; - setup_func[I830_WIN_BIT|I830_RGBA_BIT|I830_FOG_BIT|I830_TEX0_BIT|I830_TEX1_BIT] = rs_wgft0t1; - setup_func[I830_WIN_BIT|I830_RGBA_BIT|I830_FOG_BIT|I830_SPEC_BIT|I830_TEX0_BIT] = rs_wgfst0; - setup_func[I830_WIN_BIT|I830_RGBA_BIT|I830_FOG_BIT|I830_SPEC_BIT|I830_TEX0_BIT|I830_TEX1_BIT] = rs_wgfst0t1; - - /* Repair functions */ - setup_func[I830_TEX0_BIT] = rs_t0; - setup_func[I830_TEX0_BIT|I830_TEX1_BIT] = rs_t0t1; - setup_func[I830_FOG_BIT] = rs_f; - setup_func[I830_FOG_BIT|I830_TEX0_BIT] = rs_ft0; - setup_func[I830_FOG_BIT|I830_TEX0_BIT|I830_TEX1_BIT] = rs_ft0t1; - setup_func[I830_RGBA_BIT] = rs_g; - setup_func[I830_RGBA_BIT|I830_SPEC_BIT] = rs_gs; - setup_func[I830_RGBA_BIT|I830_TEX0_BIT] = rs_gt0; - setup_func[I830_RGBA_BIT|I830_TEX0_BIT|I830_TEX1_BIT] = rs_gt0t1; - setup_func[I830_RGBA_BIT|I830_SPEC_BIT|I830_TEX0_BIT] = rs_gst0; - setup_func[I830_RGBA_BIT|I830_SPEC_BIT|I830_TEX0_BIT|I830_TEX1_BIT] = rs_gst0t1; - setup_func[I830_RGBA_BIT|I830_FOG_BIT] = rs_gf; - setup_func[I830_RGBA_BIT|I830_FOG_BIT|I830_SPEC_BIT] = rs_gfs; - setup_func[I830_RGBA_BIT|I830_FOG_BIT|I830_TEX0_BIT] = rs_gft0; - setup_func[I830_RGBA_BIT|I830_FOG_BIT|I830_TEX0_BIT|I830_TEX1_BIT] = rs_gft0t1; - setup_func[I830_RGBA_BIT|I830_FOG_BIT|I830_SPEC_BIT|I830_TEX0_BIT] = rs_gfst0; - setup_func[I830_RGBA_BIT|I830_FOG_BIT|I830_SPEC_BIT|I830_TEX0_BIT|I830_TEX1_BIT] = rs_gfst0t1; - + init_wg(); + init_wgs(); + init_wgt0(); + init_wgt0t1(); + init_wgpt0(); + init_wgst0(); + init_wgst0t1(); + init_wgspt0(); + init_wgf(); + init_wgfs(); + init_wgft0(); + init_wgft0t1(); + init_wgfpt0(); + init_wgfst0(); + init_wgfst0t1(); + init_wgfspt0(); + init_t0(); + init_t0t1(); + init_f(); + init_ft0(); + init_ft0t1(); + init_g(); + init_gs(); + init_gt0(); + init_gt0t1(); + init_gst0(); + init_gst0t1(); + init_gf(); + init_gfs(); + init_gft0(); + init_gft0t1(); + init_gfst0(); + init_gfst0t1(); + /* Add proj texturing on t1 */ + init_wgpt0t1(); + init_wgspt0t1(); + init_wgfpt0t1(); + init_wgfspt0t1(); } + void i830PrintSetupFlags(char *msg, GLuint flags ) { - fprintf(stderr, "%s: %d %s%s%s%s%s%s%s\n", + fprintf(stderr, "%s(%x): %s%s%s%s%s%s%s\n", msg, (int)flags, - (flags & I830_WIN_BIT) ? " xyzw," : "", + (flags & I830_XYZW_BIT) ? " xyzw," : "", (flags & I830_RGBA_BIT) ? " rgba," : "", (flags & I830_SPEC_BIT) ? " spec," : "", (flags & I830_FOG_BIT) ? " fog," : "", (flags & I830_TEX0_BIT) ? " tex-0," : "", (flags & I830_TEX1_BIT) ? " tex-1," : "", - (flags & I830_ALPHA_BIT) ? " alpha," : ""); + (flags & I830_PTEX_BIT) ? " ptex," : ""); } - -void i830ChooseRasterSetupFunc(GLcontext *ctx) +void i830CheckTexSizes( GLcontext *ctx ) { - i830ContextPtr imesa = I830_CONTEXT( ctx ); - int funcindex = (I830_WIN_BIT | I830_RGBA_BIT); - - if(I830_DEBUG&DEBUG_VERBOSE_TRACE) - fprintf(stderr, "%s\n", __FUNCTION__); - - imesa->vertsize = 8; - imesa->Setup[I830_CTXREG_VF] = VRTX_FORMAT_NTEX(1); - - if (ctx->Texture.ReallyEnabled & 0xf) - funcindex |= I830_TEX0_BIT; - - if (ctx->Texture.ReallyEnabled & 0xf0) { - funcindex |= (I830_TEX0_BIT | I830_TEX1_BIT); - imesa->vertsize = 10; - imesa->Setup[I830_CTXREG_VF] = VRTX_FORMAT_NTEX(2); - } - - if (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR) - funcindex |= I830_SPEC_BIT; - - if (ctx->FogMode == FOG_FRAGMENT) - funcindex |= I830_FOG_BIT; - - if (MESA_VERBOSE) - i830PrintSetupFlags("xsmesa: full setup function", funcindex); - - imesa->setupindex = funcindex; - ctx->Driver.RasterSetup = setup_func[funcindex]; - if(0) fprintf(stderr, "funcindex : 0x%x\n", funcindex); -} - + TNLcontext *tnl = TNL_CONTEXT(ctx); + i830ContextPtr imesa = I830_CONTEXT( ctx ); + if (!setup_tab[imesa->SetupIndex].check_tex_sizes(ctx)) { + int ind = imesa->SetupIndex |= I830_PTEX_BIT; + + if(setup_tab[ind].vertex_format != imesa->vertex_format) { + int vfmt = setup_tab[ind].vertex_format; + + I830_STATECHANGE(imesa, I830_UPLOAD_CTX); + imesa->Setup[I830_CTXREG_VF] = ~(1<<31) & vfmt; + + if (vfmt & (1<<31)) { + /* Proj texturing */ + imesa->Setup[I830_CTXREG_VF2] = (STATE3D_VERTEX_FORMAT_2_CMD | + VRTX_TEX_SET_0_FMT(TEXCOORDFMT_3D) | + VRTX_TEX_SET_1_FMT(TEXCOORDFMT_3D) | + VRTX_TEX_SET_2_FMT(TEXCOORDFMT_3D) | + VRTX_TEX_SET_3_FMT(TEXCOORDFMT_3D)); + i830UpdateTexUnitProj( ctx, 0, GL_TRUE ); + i830UpdateTexUnitProj( ctx, 1, GL_TRUE ); + + } else { + /* Normal texturing */ + imesa->Setup[I830_CTXREG_VF2] = (STATE3D_VERTEX_FORMAT_2_CMD | + VRTX_TEX_SET_0_FMT(TEXCOORDFMT_2D) | + VRTX_TEX_SET_1_FMT(TEXCOORDFMT_2D) | + VRTX_TEX_SET_2_FMT(TEXCOORDFMT_2D) | + VRTX_TEX_SET_3_FMT(TEXCOORDFMT_2D)); + i830UpdateTexUnitProj( ctx, 0, GL_FALSE ); + i830UpdateTexUnitProj( ctx, 1, GL_FALSE ); + } + imesa->vertex_format = vfmt; + imesa->vertex_size = setup_tab[ind].vertex_size; + imesa->vertex_stride_shift = setup_tab[ind].vertex_stride_shift; + } + if (!imesa->Fallback && + !(ctx->_TriangleCaps & (DD_TRI_LIGHT_TWOSIDE|DD_TRI_UNFILLED))) { + tnl->Driver.Render.Interp = setup_tab[imesa->SetupIndex].interp; + tnl->Driver.Render.CopyPV = setup_tab[imesa->SetupIndex].copy_pv; + } + } +} -void i830DDCheckPartialRasterSetup( GLcontext *ctx, - struct gl_pipeline_stage *d ) +void i830BuildVertices( GLcontext *ctx, + GLuint start, + GLuint count, + GLuint newinputs ) { i830ContextPtr imesa = I830_CONTEXT( ctx ); - GLuint tmp = imesa->setupdone; + GLubyte *v = ((GLubyte *) + imesa->verts + (start<<imesa->vertex_stride_shift)); + GLuint stride = 1<<imesa->vertex_stride_shift; - d->type = 0; - imesa->setupdone = 0; /* cleared if we return */ + if (0) fprintf(stderr, "%s\n", __FUNCTION__); - if ((ctx->Array.Summary & VERT_OBJ_ANY) == 0) - return; + newinputs |= imesa->SetupNewInputs; + imesa->SetupNewInputs = 0; - if (ctx->IndirectTriangles) + if (!newinputs) return; - imesa->setupdone = tmp; + if (newinputs & VERT_CLIP) { + setup_tab[imesa->SetupIndex].emit( ctx, start, count, v, stride ); + } else { + GLuint ind = 0; - /* disabled until we have a merge&render op */ - /* d->inputs = available; */ - /* d->outputs = VERT_RAST_SETUP_PART; */ - /* d->type = PIPE_PRECALC; */ -} - - -/* Repair existing precalculated vertices with new data. - */ -void i830DDPartialRasterSetup( struct vertex_buffer *VB ) -{ - i830ContextPtr imesa = I830_CONTEXT( VB->ctx ); - GLuint new = VB->pipeline->new_outputs; - GLuint available = VB->pipeline->outputs; - GLuint ind = 0; - - if (new & VERT_WIN) { - new = available; - ind |= I830_WIN_BIT | I830_FOG_BIT; - } + if (newinputs & VERT_RGBA) + ind |= I830_RGBA_BIT; - if (new & VERT_RGBA) - ind |= I830_RGBA_BIT | I830_SPEC_BIT; + if (newinputs & VERT_SPEC_RGB) + ind |= I830_SPEC_BIT; - if (new & VERT_TEX0_ANY) - ind |= I830_TEX0_BIT; + if (newinputs & VERT_TEX0) + ind |= I830_TEX0_BIT; - if (new & VERT_TEX1_ANY) - ind |= I830_TEX1_BIT; + if (newinputs & VERT_TEX1) + ind |= I830_TEX1_BIT; - if (new & VERT_FOG_COORD) - ind |= I830_FOG_BIT; + if (newinputs & VERT_FOG_COORD) + ind |= I830_FOG_BIT; - imesa->setupdone &= ~ind; - ind &= imesa->setupindex; - imesa->setupdone |= ind; +#if 0 + if (imesa->SetupIndex & I830_PTEX_BIT) + ind = ~0; +#endif - if (0) i830PrintSetupFlags("xsmesa: partial setup function", ind); + ind &= imesa->SetupIndex; - if (ind) - setup_func[ind&~I830_ALPHA_BIT]( VB, VB->Start, VB->Count ); + if (ind) { + setup_tab[ind].emit( ctx, start, count, v, stride ); + } + } } - -void i830DDDoRasterSetup( struct vertex_buffer *VB ) +void i830ChooseVertexState( GLcontext *ctx ) { - GLcontext *ctx = VB->ctx; - - if (VB->Type == VB_CVA_PRECALC) - i830DDPartialRasterSetup( VB ); - else if (ctx->Driver.RasterSetup) - ctx->Driver.RasterSetup( VB, VB->CopyStart, VB->Count ); -} + TNLcontext *tnl = TNL_CONTEXT(ctx); + i830ContextPtr imesa = I830_CONTEXT( ctx ); + GLuint ind = I830_XYZW_BIT|I830_RGBA_BIT; + if (ctx->_TriangleCaps & DD_SEPARATE_SPECULAR) + ind |= I830_SPEC_BIT; + if (ctx->Fog.Enabled) + ind |= I830_FOG_BIT; + if (ctx->Texture._ReallyEnabled & 0xf0) + ind |= I830_TEX1_BIT|I830_TEX0_BIT; + else if (ctx->Texture._ReallyEnabled & 0xf) + ind |= I830_TEX0_BIT; -void i830DDResizeVB( struct vertex_buffer *VB, GLuint size ) -{ - i830VertexBufferPtr mvb = I830_DRIVER_DATA(VB); + imesa->SetupIndex = ind; - while (mvb->size < size) - mvb->size *= 2; + if (ctx->_TriangleCaps & (DD_TRI_LIGHT_TWOSIDE|DD_TRI_UNFILLED)) { + tnl->Driver.Render.Interp = i830_interp_extras; + tnl->Driver.Render.CopyPV = i830_copy_pv_extras; + } else { + tnl->Driver.Render.Interp = setup_tab[ind].interp; + tnl->Driver.Render.CopyPV = setup_tab[ind].copy_pv; + } - free( mvb->vert_store ); - mvb->vert_store = malloc( sizeof(i830Vertex) * mvb->size + 31); - if (!mvb->vert_store) { - fprintf(stderr, "i830glx: out of memory !\n"); - exit(1); + if (setup_tab[ind].vertex_format != imesa->vertex_format) { + int vfmt = setup_tab[ind].vertex_format; + + I830_STATECHANGE(imesa, I830_UPLOAD_CTX); + imesa->Setup[I830_CTXREG_VF] = ~(1<<31) & vfmt; + + if (vfmt & (1<<31)) { + /* Proj texturing */ + imesa->Setup[I830_CTXREG_VF2] = (STATE3D_VERTEX_FORMAT_2_CMD | + VRTX_TEX_SET_0_FMT(TEXCOORDFMT_3D) | + VRTX_TEX_SET_1_FMT(TEXCOORDFMT_3D) | + VRTX_TEX_SET_2_FMT(TEXCOORDFMT_3D) | + VRTX_TEX_SET_3_FMT(TEXCOORDFMT_3D)); + i830UpdateTexUnitProj( ctx, 0, GL_TRUE ); + i830UpdateTexUnitProj( ctx, 1, GL_TRUE ); + } else { + /* Normal texturing */ + imesa->Setup[I830_CTXREG_VF2] = (STATE3D_VERTEX_FORMAT_2_CMD | + VRTX_TEX_SET_0_FMT(TEXCOORDFMT_2D) | + VRTX_TEX_SET_1_FMT(TEXCOORDFMT_2D) | + VRTX_TEX_SET_2_FMT(TEXCOORDFMT_2D) | + VRTX_TEX_SET_3_FMT(TEXCOORDFMT_2D)); + i830UpdateTexUnitProj( ctx, 0, GL_FALSE ); + i830UpdateTexUnitProj( ctx, 1, GL_FALSE ); + } + imesa->vertex_format = vfmt; + imesa->vertex_size = setup_tab[ind].vertex_size; + imesa->vertex_stride_shift = setup_tab[ind].vertex_stride_shift; } +} - mvb->verts = (i830VertexPtr)(((unsigned long)mvb->vert_store + 31) & ~31); - gl_vector1ui_free( &mvb->clipped_elements ); - gl_vector1ui_alloc( &mvb->clipped_elements, VEC_WRITABLE, mvb->size, 32 ); - if (!mvb->clipped_elements.start) { - fprintf(stderr, "i830glx: out of memory !\n"); - exit(1); - } - ALIGN_FREE( VB->ClipMask ); - VB->ClipMask = (GLubyte *) ALIGN_MALLOC(sizeof(GLubyte) * mvb->size, 4); - if (!VB->ClipMask) { - fprintf(stderr, "i830glx: out of memory !\n"); - exit(1); - } +void i830_emit_contiguous_verts( GLcontext *ctx, + GLuint start, + GLuint count ) +{ + i830ContextPtr imesa = I830_CONTEXT(ctx); + GLuint vertex_size = imesa->vertex_size * 4; + GLuint *dest = i830AllocDmaLow( imesa, (count-start) * vertex_size); + setup_tab[imesa->SetupIndex].emit( ctx, start, count, dest, vertex_size ); +} - if (VB->Type == VB_IMMEDIATE) { - free( mvb->primitive ); - free( mvb->next_primitive ); - mvb->primitive = (GLuint *)malloc( sizeof(GLuint) * mvb->size ); - mvb->next_primitive = (GLuint *)malloc( sizeof(GLuint) * mvb->size ); - if (!mvb->primitive || !mvb->next_primitive) { - fprintf(stderr, "i830glx: out of memory !\n"); - exit(1); + +void i830InitVB( GLcontext *ctx ) +{ + i830ContextPtr imesa = I830_CONTEXT(ctx); + GLuint size = TNL_CONTEXT(ctx)->vb.Size; + if (DEBUGGING) + fprintf (stderr,"\n%s\n",__FUNCTION__); + + imesa->verts = (char *)ALIGN_MALLOC(size * 4 * 16, 32); + + { + static int firsttime = 1; + if (firsttime) { + init_setup_tab(); + firsttime = 0; } } + if (DEBUGGING) + fprintf(stderr,"\nFinished InitVB\n"); } -void i830DDRegisterVB( struct vertex_buffer *VB ) +void i830FreeVB( GLcontext *ctx ) { - i830VertexBufferPtr mvb; - - mvb = (i830VertexBufferPtr)calloc( 1, sizeof(*mvb) ); - - mvb->size = VB->Size * 2; - mvb->vert_store = malloc( sizeof(i830Vertex) * mvb->size + 31); - if (!mvb->vert_store) { - fprintf(stderr, "i830glx: out of memory !\n"); - exit(1); + i830ContextPtr imesa = I830_CONTEXT(ctx); + if (imesa->verts) { + ALIGN_FREE(imesa->verts); + imesa->verts = 0; } - - mvb->verts = (i830VertexPtr)(((unsigned long)mvb->vert_store + 31) & ~31); - gl_vector1ui_alloc( &mvb->clipped_elements, VEC_WRITABLE, mvb->size, 32 ); - if (!mvb->clipped_elements.start) { - fprintf(stderr, "i830glx: out of memory !\n"); - exit(1); - } - - ALIGN_FREE( VB->ClipMask ); - VB->ClipMask = (GLubyte *) ALIGN_MALLOC(sizeof(GLubyte) * mvb->size, 4); - if (!VB->ClipMask) { - fprintf(stderr, "i830glx: out of memory !\n"); - exit(1); + if (imesa->UbyteSecondaryColor.Ptr) { + ALIGN_FREE(imesa->UbyteSecondaryColor.Ptr); + imesa->UbyteSecondaryColor.Ptr = 0; } - mvb->primitive = (GLuint *)malloc( sizeof(GLuint) * mvb->size ); - mvb->next_primitive = (GLuint *)malloc( sizeof(GLuint) * mvb->size ); - if (!mvb->primitive || !mvb->next_primitive) { - fprintf(stderr, "i830glx: out of memory !\n"); - exit(1); + if (imesa->UbyteColor.Ptr) { + ALIGN_FREE(imesa->UbyteColor.Ptr); + imesa->UbyteColor.Ptr = 0; } - - VB->driver_data = mvb; -} - - -void i830DDUnregisterVB( struct vertex_buffer *VB ) -{ - i830VertexBufferPtr mvb = I830_DRIVER_DATA(VB); - - if (mvb) { - if (mvb->vert_store) free(mvb->vert_store); - if (mvb->primitive) free(mvb->primitive); - if (mvb->next_primitive) free(mvb->next_primitive); - gl_vector1ui_free( &mvb->clipped_elements ); - free(mvb); - VB->driver_data = 0; - } } diff --git a/xc/lib/GL/mesa/src/drv/i830/i830_vb.h b/xc/lib/GL/mesa/src/drv/i830/i830_vb.h new file mode 100644 index 000000000..143659146 --- /dev/null +++ b/xc/lib/GL/mesa/src/drv/i830/i830_vb.h @@ -0,0 +1,63 @@ +/* + * GLX Hardware Device Driver for Intel i810 + * Copyright (C) 1999 Keith Whitwell + * + * 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 + * KEITH WHITWELL, OR ANY OTHER CONTRIBUTORS 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. + * + * Adapted for use in the I830M: + * Jeff Hartmann <jhartmann@2d3d.com> + */ +/* $XFree86$ */ + +#ifndef I830VB_INC +#define I830VB_INC + +#include "mtypes.h" +#include "swrast/swrast.h" + +#define _I830_NEW_VERTEX (_NEW_TEXTURE | \ + _DD_NEW_SEPARATE_SPECULAR | \ + _DD_NEW_TRI_UNFILLED | \ + _DD_NEW_TRI_LIGHT_TWOSIDE | \ + _NEW_FOG) + + +extern void i830ChooseVertexState( GLcontext *ctx ); +extern void i830CheckTexSizes( GLcontext *ctx ); +extern void i830BuildVertices( GLcontext *ctx, + GLuint start, + GLuint count, + GLuint newinputs ); + + +extern void i830_emit_contiguous_verts( GLcontext *ctx, + GLuint start, + GLuint count ); + +extern void i830_translate_vertex( GLcontext *ctx, + const i830Vertex *src, + SWvertex *dst ); + +extern void i830InitVB( GLcontext *ctx ); +extern void i830FreeVB( GLcontext *ctx ); + +extern void i830_print_vertex( GLcontext *ctx, const i830Vertex *v ); +extern void i830PrintSetupFlags(char *msg, GLuint flags ); + +#endif diff --git a/xc/lib/GL/mesa/src/drv/i830/i830_vert_form_points.h b/xc/lib/GL/mesa/src/drv/i830/i830_vert_form_points.h index bffeb400a..6b0ebef76 100644 --- a/xc/lib/GL/mesa/src/drv/i830/i830_vert_form_points.h +++ b/xc/lib/GL/mesa/src/drv/i830/i830_vert_form_points.h @@ -29,7 +29,7 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. /* * Author: - * Jeff Hartmann <jhartmann@valinux.com> + * Jeff Hartmann <jhartmann@2d3d.com> * * Heavily based on the I810 driver, which was written by: * Keith Whitwell <keithw@valinux.com> diff --git a/xc/lib/GL/mesa/src/drv/i830/i830_vert_form_tris.h b/xc/lib/GL/mesa/src/drv/i830/i830_vert_form_tris.h index 328055ad7..915add2e2 100644 --- a/xc/lib/GL/mesa/src/drv/i830/i830_vert_form_tris.h +++ b/xc/lib/GL/mesa/src/drv/i830/i830_vert_form_tris.h @@ -29,7 +29,7 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. /* * Author: - * Jeff Hartmann <jhartmann@valinux.com> + * Jeff Hartmann <jhartmann@2d3d.com> * * Heavily based on the I810 driver, which was written by: * Keith Whitwell <keithw@valinux.com> diff --git a/xc/lib/GL/mesa/src/drv/i830/i830_xmesa.c b/xc/lib/GL/mesa/src/drv/i830/i830_xmesa.c deleted file mode 100644 index 436f789c3..000000000 --- a/xc/lib/GL/mesa/src/drv/i830/i830_xmesa.c +++ /dev/null @@ -1,722 +0,0 @@ -/************************************************************************** - -Copyright 2001 VA Linux Systems Inc., Fremont, California. - -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 -on 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 -ATI, VA LINUX SYSTEMS AND/OR THEIR 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. - -**************************************************************************/ - -/* $XFree86: xc/lib/GL/mesa/src/drv/i830/i830_xmesa.c,v 1.1 2001/10/04 18:28:21 alanh Exp $ */ - -/* - * Author: - * Jeff Hartmann <jhartmann@valinux.com> - * - * Heavily based on the I810 driver, which was written by: - * Keith Whitwell <keithw@valinux.com> - */ - -#ifdef GLX_DIRECT_RENDERING - -#include <X11/Xlibint.h> -#include <stdio.h> - -#include "context.h" -#include "vbxform.h" -#include "matrix.h" -#include "simple_list.h" - -#include "i830_drv.h" -#include "i830_tris.h" -#include "i830_ioctl.h" - -#include "i830_dri.h" - - - -#ifndef I830_DEBUG -int I830_DEBUG = (0 - | DEBUG_VERBOSE_TRACE -/* | DEBUG_VERBOSE_STATE */ -/* | DEBUG_ALWAYS_SYNC */ -/* | DEBUG_VERBOSE_RING */ -/* | DEBUG_VERBOSE_OUTREG */ -/* | DEBUG_VERBOSE_MSG */ -/* | DEBUG_NO_OUTRING */ -/* | DEBUG_NO_OUTREG */ -/* | DEBUG_VERBOSE_API */ -/* | DEBUG_VERBOSE_2D */ -/* | DEBUG_VERBOSE_DRI */ -/* | DEBUG_VALIDATE_RING */ -/* | DEBUG_VERBOSE_IOCTL */ - ); -#endif - - -static i830ContextPtr i830Ctx = 0; - - -/* These functions are accessed externally to the driver: - * - * XMesaInitDriver - * XMesaResetDriver - * XMesaCreateVisual - * XMesaDestroyVisual - * XMesaCreateContext - * XMesaDestroyContext - * XMesaCreateWindowBuffer - * XMesaCreatePixmapBuffer - * XMesaDestroyBuffer - * XMesaSwapBuffers - * XMesaMakeCurrent - * - */ - - -static int i830_malloc_proxy_buf(drmBufMapPtr buffers) -{ - char *buffer; - drmBufPtr buf; - int i; - - buffer = Xmalloc(I830_DMA_BUF_SZ); - if(buffer == NULL) return -1; - for(i = 0; i < I830_DMA_BUF_NR; i++) { - buf = &(buffers->list[i]); - buf->address = (drmAddress)buffer; - } - return 0; -} - -static drmBufMapPtr i830_create_empty_buffers(void) -{ - drmBufMapPtr retval; - - retval = (drmBufMapPtr)Xmalloc(sizeof(drmBufMap)); - if(retval == NULL) return NULL; - memset(retval, 0, sizeof(drmBufMap)); - retval->list = (drmBufPtr)Xmalloc(sizeof(drmBuf) * I830_DMA_BUF_NR); - if(retval->list == NULL) { - Xfree(retval); - return NULL; - } - memset(retval->list, 0, sizeof(drmBuf) * I830_DMA_BUF_NR); - /* - fprintf(stderr, "retval : %p, retval->list : %p\n", retval, retval->list); - */ - return retval; -} - -GLboolean XMesaInitDriver(__DRIscreenPrivate *sPriv) -{ - i830ScreenPrivate *i830Screen; - I830DRIPtr gDRIPriv = (I830DRIPtr)sPriv->pDevPriv; - - /* Check the DRI version */ - { - int major, minor, patch; - if (XF86DRIQueryVersion(sPriv->display, &major, &minor, &patch)) { - if (major != 4 || minor < 0) { - char msg[1000]; - sprintf(msg, "i830 DRI driver expected DRI version 4.0.x but got version %d.%d.%d", major, minor, patch); - __driMesaMessage(msg); - return GL_FALSE; - } - } - } - - /* Check that the DDX driver version is compatible */ - if (sPriv->ddxMajor != 1 || - sPriv->ddxMinor < 0) { - char msg[1000]; - sprintf(msg, "i830 DRI driver expected DDX driver version 1.0.x but got version %d.%d.%d", sPriv->ddxMajor, sPriv->ddxMinor, sPriv->ddxPatch); - __driMesaMessage(msg); - return GL_FALSE; - } - - /* Check that the DRM driver version is compatible */ - if (sPriv->drmMajor != 1 || - sPriv->drmMinor < 2) { - char msg[1000]; - sprintf(msg, "i830 DRI driver expected DRM driver version 1.2.x but got version %d.%d.%d", sPriv->drmMajor, sPriv->drmMinor, sPriv->drmPatch); - __driMesaMessage(msg); - return GL_FALSE; - } - - /* Allocate the private area */ - i830Screen = (i830ScreenPrivate *)Xmalloc(sizeof(i830ScreenPrivate)); - if (!i830Screen) - return GL_FALSE; - - i830Screen->driScrnPriv = sPriv; - sPriv->private = (void *)i830Screen; - - i830Screen->deviceID=gDRIPriv->deviceID; - i830Screen->width=gDRIPriv->width; - i830Screen->height=gDRIPriv->height; - i830Screen->mem=gDRIPriv->mem; - i830Screen->cpp=gDRIPriv->cpp; - i830Screen->fbStride=gDRIPriv->fbStride; - i830Screen->fbOffset=gDRIPriv->fbOffset; - - switch (gDRIPriv->bitsPerPixel) { - case 15: i830Screen->fbFormat = DV_PF_555; break; - case 16: i830Screen->fbFormat = DV_PF_565; break; - case 32: i830Screen->fbFormat = DV_PF_8888; break; - } - - i830Screen->backOffset=gDRIPriv->backOffset; - i830Screen->depthOffset=gDRIPriv->depthOffset; - i830Screen->backPitch = gDRIPriv->auxPitch; - i830Screen->backPitchBits = gDRIPriv->auxPitchBits; - i830Screen->textureOffset=gDRIPriv->textureOffset; - i830Screen->textureSize=gDRIPriv->textureSize; - i830Screen->logTextureGranularity = gDRIPriv->logTextureGranularity; - i830Screen->sarea_priv_offset = gDRIPriv->sarea_priv_offset; - - if (0) - fprintf(stderr, "Tex heap size %x, granularity %x bytes\n", - i830Screen->textureSize, 1<<(i830Screen->logTextureGranularity)); - - i830Screen->bufs = i830_create_empty_buffers(); - if(i830Screen->bufs == NULL) - { - Xfree(i830Screen); - return GL_FALSE; - } - - /* Check if you need to create a fake buffer */ - if(i830_check_copy(sPriv->fd) == 1) - { - i830_malloc_proxy_buf(i830Screen->bufs); - i830Screen->use_copy_buf = 1; - } - else - { - i830Screen->use_copy_buf = 0; - } - - i830Screen->back.handle = gDRIPriv->backbuffer; - i830Screen->back.size = gDRIPriv->backbufferSize; - - if (drmMap(sPriv->fd, - i830Screen->back.handle, - i830Screen->back.size, - (drmAddress *)&i830Screen->back.map) != 0) - { - Xfree(i830Screen); - sPriv->private = NULL; - return GL_FALSE; - } - - i830Screen->depth.handle = gDRIPriv->depthbuffer; - i830Screen->depth.size = gDRIPriv->depthbufferSize; - - if (drmMap(sPriv->fd, - i830Screen->depth.handle, - i830Screen->depth.size, - (drmAddress *)&i830Screen->depth.map) != 0) - { - Xfree(i830Screen); - drmUnmap(i830Screen->back.map, i830Screen->back.size); - sPriv->private = NULL; - return GL_FALSE; - } - - i830Screen->tex.handle = gDRIPriv->textures; - i830Screen->tex.size = gDRIPriv->textureSize; - - if (drmMap(sPriv->fd, - i830Screen->tex.handle, - i830Screen->tex.size, - (drmAddress *)&i830Screen->tex.map) != 0) - { - Xfree(i830Screen); - drmUnmap(i830Screen->back.map, i830Screen->back.size); - drmUnmap(i830Screen->depth.map, i830Screen->depth.size); - sPriv->private = NULL; - return GL_FALSE; - } - - - i830DDFastPathInit(); - i830DDTrifuncInit(); - i830DDSetupInit(); - - return GL_TRUE; -} - -/* Accessed by dlsym from dri_mesa_init.c - */ -void XMesaResetDriver(__DRIscreenPrivate *sPriv) -{ - i830ScreenPrivate *i830Screen = (i830ScreenPrivate *)sPriv->private; - - /* Need to unmap all the bufs and maps here: - */ - drmUnmap(i830Screen->back.map, i830Screen->back.size); - drmUnmap(i830Screen->depth.map, i830Screen->depth.size); - drmUnmap(i830Screen->tex.map, i830Screen->tex.size); - - Xfree(i830Screen); - sPriv->private = NULL; -} - - -GLvisual *XMesaCreateVisual(Display *dpy, - __DRIscreenPrivate *driScrnPriv, - const XVisualInfo *visinfo, - const __GLXvisualConfig *config) -{ - /* Drivers may change the args to _mesa_create_visual() in order to - * setup special visuals. - */ - return _mesa_create_visual( config->rgba, - config->doubleBuffer, - config->stereo, - _mesa_bitcount(visinfo->red_mask), - _mesa_bitcount(visinfo->green_mask), - _mesa_bitcount(visinfo->blue_mask), - config->alphaSize, - 0, /* index bits */ - config->depthSize, - config->stencilSize, - config->accumRedSize, - config->accumGreenSize, - config->accumBlueSize, - config->accumAlphaSize, - 0 /* num samples */ ); -} - - -GLboolean XMesaCreateContext( Display *dpy, GLvisual *mesaVis, - __DRIcontextPrivate *driContextPriv ) -{ - GLcontext *ctx = driContextPriv->mesaContext; - i830ContextPtr imesa; - __DRIscreenPrivate *sPriv = driContextPriv->driScreenPriv; - i830ScreenPrivate *i830Screen = (i830ScreenPrivate *)sPriv->private; - I830SAREAPtr saPriv=(I830SAREAPtr)(((char*)sPriv->pSAREA)+ - i830Screen->sarea_priv_offset); - - imesa = (i830ContextPtr)Xcalloc(sizeof(i830Context), 1); - if (!imesa) { - return GL_FALSE; - } - - - /* Set the maximum texture size small enough that we can guarentee - * that both texture units can bind a maximal texture and have them - * in memory at once. - */ - if (i830Screen->textureSize < 2*1024*1024) { - ctx->Const.MaxTextureLevels = 9; - ctx->Const.MaxTextureSize = 1<<8; - } else if (i830Screen->textureSize < 8*1024*1024) { - ctx->Const.MaxTextureLevels = 10; - ctx->Const.MaxTextureSize = 1<<9; - } else { - ctx->Const.MaxTextureLevels = 11; - ctx->Const.MaxTextureSize = 1<<10; - } - - ctx->Const.MinLineWidth = 1.0; - ctx->Const.MinLineWidthAA = 1.0; - ctx->Const.MaxLineWidth = 3.0; - ctx->Const.MaxLineWidthAA = 3.0; - ctx->Const.LineWidthGranularity = 1.0; - - - /* Dri stuff - */ - imesa->display = dpy; - imesa->hHWContext = driContextPriv->hHWContext; - imesa->driFd = sPriv->fd; - imesa->driHwLock = &sPriv->pSAREA->lock; - - imesa->i830Screen = i830Screen; - imesa->driScreen = sPriv; - imesa->sarea = saPriv; - imesa->glBuffer = NULL; - - imesa->texHeap = mmInit( 0, i830Screen->textureSize ); - - - /* Utah stuff - */ - imesa->renderindex = -1; /* impossible value */ - imesa->new_state = ~0; - imesa->dirty = ~0; - - make_empty_list(&imesa->TexObjList); - make_empty_list(&imesa->SwappedOut); - - imesa->TextureMode = ctx->Texture.Unit[0].EnvMode; - imesa->CurrentTexObj[0] = 0; - imesa->CurrentTexObj[1] = 0; - - ctx->DriverCtx = (void *) imesa; - imesa->glCtx = ctx; - - i830DDExtensionsInit( ctx ); - - imesa->hw_stencil = mesaVis->StencilBits && mesaVis->DepthBits == 24; - - switch(mesaVis->DepthBits) { - case 16: - imesa->depth_scale = 1.0/0x10000; - imesa->depth_clear_mask = ~0; - imesa->ClearDepth = 0xffff; - break; - case 24: - imesa->depth_scale = 1.0/0x1000000; - imesa->depth_clear_mask = 0x00ffffff; - imesa->stencil_clear_mask = 0xff000000; - imesa->ClearDepth = 0x00ffffff; - break; - case 32: /* Not supported I don't believe */ - default: -#define DUMMY() /* keep gcc happy */ - DUMMY(); - } - - /* Completely disable stenciling for now, there are some serious issues - * with stencil. - */ -#if 1 - imesa->hw_stencil = 0; -#endif - - i830DDInitStateFuncs( ctx ); - i830DDInitTextureFuncs( ctx ); - i830DDInitSpanFuncs( ctx ); - i830DDInitDriverFuncs( ctx ); - i830DDInitIoctlFuncs( ctx ); - - ctx->Driver.TriangleCaps = (DD_TRI_CULL| - DD_TRI_LIGHT_TWOSIDE| - DD_TRI_STIPPLE| - DD_TRI_OFFSET); - - /* Ask mesa to clip fog coordinates for us. - */ - ctx->TriangleCaps |= DD_CLIP_FOG_COORD; - - if (ctx->VB) - i830DDRegisterVB( ctx->VB ); - - if (ctx->NrPipelineStages) - ctx->NrPipelineStages = - i830DDRegisterPipelineStages(ctx->PipelineStage, - ctx->PipelineStage, - ctx->NrPipelineStages); - - i830DDInitState( imesa ); - - driContextPriv->driverPrivate = (void *) imesa; - - return GL_TRUE; -} - -void XMesaDestroyContext(__DRIcontextPrivate *driContextPriv) -{ - i830ContextPtr imesa = (i830ContextPtr) driContextPriv->driverPrivate; - - if (imesa) { - i830TextureObjectPtr next_t, t; - - foreach_s (t, next_t, &(imesa->TexObjList)) - i830DestroyTexObj(imesa, t); - - foreach_s (t, next_t, &(imesa->SwappedOut)) - i830DestroyTexObj(imesa, t); - - Xfree(imesa); - } -} - -GLframebuffer *XMesaCreateWindowBuffer( Display *dpy, - __DRIscreenPrivate *driScrnPriv, - __DRIdrawablePrivate *driDrawPriv, - GLvisual *mesaVis) -{ -#if 0 - GLboolean swStencil = mesaVis->StencilBits > 0 && mesaVis->DepthBits != 24; -#else - GLboolean swStencil = mesaVis->StencilBits > 0; -#endif - return gl_create_framebuffer(mesaVis, - GL_FALSE, - swStencil, - mesaVis->AccumRedBits > 0, - mesaVis->AlphaBits > 0 - ); -} - - -GLframebuffer *XMesaCreatePixmapBuffer( Display *dpy, - __DRIscreenPrivate *driScrnPriv, - __DRIdrawablePrivate *driDrawPriv, - GLvisual *mesaVis) -{ -#if 0 - /* Different drivers may have different combinations of hardware and - * software ancillary buffers. - */ - return gl_create_framebuffer(mesaVis, - GL_FALSE, /* software depth buffer? */ - mesaVis->StencilBits > 0, - mesaVis->AccumRedBits > 0, - mesaVis->AlphaBits > 0 - ); -#else - return NULL; /* not implemented yet */ -#endif -} - - -void XMesaSwapBuffers(__DRIdrawablePrivate *driDrawPriv) -{ - /* XXX should do swap according to the buffer, not the context! */ - i830ContextPtr imesa = i830Ctx; - - if( !driDrawPriv->mesaBuffer->Visual->DBflag ) return; - - FLUSH_VB( imesa->glCtx, "swap buffers" ); - i830SwapBuffers(imesa); -} - - - -void i830XMesaSetFrontClipRects( i830ContextPtr imesa ) -{ - __DRIdrawablePrivate *dPriv = imesa->driDrawable; - - imesa->numClipRects = dPriv->numClipRects; - imesa->pClipRects = dPriv->pClipRects; - imesa->dirty |= I830_UPLOAD_CLIPRECTS; - imesa->drawX = dPriv->x; - imesa->drawY = dPriv->y; - - i830EmitDrawingRectangle( imesa ); -} - - -void i830XMesaSetBackClipRects( i830ContextPtr imesa ) -{ - __DRIdrawablePrivate *dPriv = imesa->driDrawable; - int i; - - if (dPriv->numBackClipRects == 0) - { - if (I830_DEBUG & DEBUG_VERBOSE_DRI) - fprintf(stderr, "FRONT_CLIPRECTS, %d rects\n", - dPriv->numClipRects); - - imesa->numClipRects = dPriv->numClipRects; - imesa->pClipRects = dPriv->pClipRects; - imesa->drawX = dPriv->x; - imesa->drawY = dPriv->y; - } else { - if (I830_DEBUG & DEBUG_VERBOSE_DRI) - fprintf(stderr, "BACK_RECTS, %d rects\n", - dPriv->numBackClipRects); - - imesa->numClipRects = dPriv->numBackClipRects; - imesa->pClipRects = dPriv->pBackClipRects; - imesa->drawX = dPriv->backX; - imesa->drawY = dPriv->backY; - } - - i830EmitDrawingRectangle( imesa ); - imesa->dirty |= I830_UPLOAD_CLIPRECTS; - - if (I830_DEBUG & DEBUG_VERBOSE_DRI) - for (i = 0 ; i < imesa->numClipRects ; i++) - fprintf(stderr, "cliprect %d: %d,%d - %d,%d\n", - i, - imesa->pClipRects[i].x1, - imesa->pClipRects[i].y1, - imesa->pClipRects[i].x2, - imesa->pClipRects[i].y2); -} - - -static void i830XMesaWindowMoved( i830ContextPtr imesa ) -{ - if (0) - fprintf(stderr, "i830XMesaWindowMoved\n\n"); - - switch (imesa->glCtx->Color.DriverDrawBuffer) { - case GL_FRONT_LEFT: - i830XMesaSetFrontClipRects( imesa ); - break; - case GL_BACK_LEFT: - i830XMesaSetBackClipRects( imesa ); - break; - default: - /*fprintf(stderr, "fallback buffer\n");*/ - break; - } -} - -GLboolean -XMesaOpenFullScreen(__DRIcontextPrivate *driContextPriv) -{ - return GL_TRUE; -} - -GLboolean -XMesaCloseFullScreen(__DRIcontextPrivate *driContextPriv) -{ - return GL_TRUE; -} - -GLboolean XMesaUnbindContext(__DRIcontextPrivate *driContextPriv) -{ - i830ContextPtr i830 = (i830ContextPtr) driContextPriv->driverPrivate; - if (i830) - i830->dirty = ~0; - - return GL_TRUE; -} - - -GLboolean XMesaMakeCurrent(__DRIcontextPrivate *driContextPriv, - __DRIdrawablePrivate *driDrawPriv, - __DRIdrawablePrivate *driReadPriv) -{ - if (driContextPriv) { - i830Ctx = (i830ContextPtr) driContextPriv->driverPrivate; - - gl_make_current2(i830Ctx->glCtx, driDrawPriv->mesaBuffer, - driReadPriv->mesaBuffer); - - - i830Ctx->driDrawable = driDrawPriv; - i830Ctx->dirty = ~0; - - i830XMesaWindowMoved( i830Ctx ); - - if (!i830Ctx->glCtx->Viewport.Width) - gl_Viewport(i830Ctx->glCtx, 0, 0, driDrawPriv->w, driDrawPriv->h); - } - else - { - gl_make_current(0,0); - i830Ctx = NULL; - } - return GL_TRUE; -} - - -void i830GetLock( i830ContextPtr imesa, GLuint flags ) -{ - __DRIdrawablePrivate *dPriv = imesa->driDrawable; - __DRIscreenPrivate *sPriv = imesa->driScreen; - I830SAREAPtr sarea = imesa->sarea; - int me = imesa->hHWContext; - int stamp = dPriv->lastStamp; - - - if (0) fprintf(stderr, ".\n"); - - /* We know there has been contention. - */ - drmGetLock(imesa->driFd, imesa->hHWContext, flags); - - - /* Note contention for throttling hint - */ - imesa->any_contend = 1; - - /* If the window moved, may need to set a new cliprect now. - * - * NOTE: This releases and regains the hw lock, so all state - * checking must be done *after* this call: - */ - XMESA_VALIDATE_DRAWABLE_INFO(imesa->display, sPriv, dPriv); - - - if (0) - fprintf(stderr, "i830GetLock, last enque: %d last dispatch: %d\n", - sarea->last_enqueue, - sarea->last_dispatch); - - /* If we lost context, need to dump all registers to hardware. - * Note that we don't care about 2d contexts, even if they perform - * accelerated commands, so the DRI locking in the X server is even - * more broken than usual. - */ - if (sarea->ctxOwner != me) { - imesa->dirty |= (I830_UPLOAD_CTX | - I830_UPLOAD_CLIPRECTS | - I830_UPLOAD_BUFFERS | - I830_UPLOAD_TEX0 | - I830_UPLOAD_TEX1); - - if(imesa->TexBlendWordsUsed[0]) imesa->dirty |= I830_UPLOAD_TEXBLEND0; - if(imesa->TexBlendWordsUsed[1]) imesa->dirty |= I830_UPLOAD_TEXBLEND1; - - sarea->ctxOwner = me; - } - - /* Shared texture managment - if another client has played with - * texture space, figure out which if any of our textures have been - * ejected, and update our global LRU. - */ - if (sarea->texAge != imesa->texAge) { - int sz = 1 << (imesa->i830Screen->logTextureGranularity); - int idx, nr = 0; - - /* Have to go right round from the back to ensure stuff ends up - * LRU in our local list... - */ - for (idx = sarea->texList[I830_NR_TEX_REGIONS].prev ; - idx != I830_NR_TEX_REGIONS && nr < I830_NR_TEX_REGIONS ; - idx = sarea->texList[idx].prev, nr++) - { - if (sarea->texList[idx].age > imesa->texAge) - i830TexturesGone(imesa, idx * sz, sz, sarea->texList[idx].in_use); - } - - if (nr == I830_NR_TEX_REGIONS) { - i830TexturesGone(imesa, 0, imesa->i830Screen->textureSize, 0); - i830ResetGlobalLRU( imesa ); - } - - if (0) fprintf(stderr, "imesa %d sarea %d\n", imesa->texAge, sarea->texAge); - imesa->dirty |= I830_UPLOAD_TEX0_IMAGE; - imesa->dirty |= I830_UPLOAD_TEX1_IMAGE; - imesa->texAge = sarea->texAge; - } - - - if (dPriv->lastStamp != stamp) - i830XMesaWindowMoved( imesa ); - - - sarea->last_quiescent = -1; /* just kill it for now */ -} - - -#endif |