diff options
Diffstat (limited to 'nx-X11/extras/Mesa/src/mesa/drivers/dri/trident')
9 files changed, 3020 insertions, 0 deletions
diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/trident/Makefile b/nx-X11/extras/Mesa/src/mesa/drivers/dri/trident/Makefile new file mode 100644 index 000000000..9ee24c504 --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/trident/Makefile @@ -0,0 +1,26 @@ +# src/mesa/drivers/dri/trident/Makefile + +TOP = ../../../../.. +include $(TOP)/configs/current + +LIBNAME = trident_dri.so + +# Not yet +# MINIGLX_SOURCES = server/trident_dri.c + +DRIVER_SOURCES = \ + trident_context.c \ + trident_state.c \ + trident_vb.c \ + trident_dd.c \ + trident_tris.c + +C_SOURCES = \ + $(COMMON_SOURCES) \ + $(DRIVER_SOURCES) + +ASM_SOURCES = + +include ../Makefile.template + +symlinks: diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/trident/trident_context.c b/nx-X11/extras/Mesa/src/mesa/drivers/dri/trident/trident_context.c new file mode 100644 index 000000000..b44c6205c --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/trident/trident_context.c @@ -0,0 +1,472 @@ +/* + * Copyright 2002 by Alan Hourihane, Sychdyn, North Wales, UK. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Alan Hourihane not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Alan Hourihane makes no representations + * about the suitability of this software for any purpose. It is provided + * "as is" without express or implied warranty. + * + * ALAN HOURIHANE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL ALAN HOURIHANE BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + * + * Authors: Alan Hourihane, <alanh@fairlite.demon.co.uk> + * + * Trident CyberBladeXP driver. + * + */ +#include "trident_dri.h" +#include "trident_context.h" +#include "trident_lock.h" + +#include "swrast/swrast.h" +#include "swrast_setup/swrast_setup.h" +#include "array_cache/acache.h" + +#include "tnl/tnl.h" +#include "tnl/t_pipeline.h" + +#include "context.h" +#include "simple_list.h" +#include "matrix.h" +#include "extensions.h" +#include "framebuffer.h" +#include "renderbuffer.h" +#if defined(USE_X86_ASM) +#include "x86/common_x86_asm.h" +#endif +#include "simple_list.h" +#include "mm.h" +#include "drirenderbuffer.h" + +#include "drivers/common/driverfuncs.h" +#include "dri_util.h" + +static const struct tnl_pipeline_stage *trident_pipeline[] = { + &_tnl_vertex_transform_stage, + &_tnl_normal_transform_stage, + &_tnl_lighting_stage, + &_tnl_texgen_stage, + &_tnl_texture_transform_stage, + &_tnl_render_stage, + 0, +}; + + +GLboolean tridentCreateContext( const __GLcontextModes *glVisual, + __DRIcontextPrivate *driContextPriv, + void *sharedContextPrivate) +{ + GLcontext *ctx, *shareCtx; + __DRIscreenPrivate *sPriv = driContextPriv->driScreenPriv; + tridentContextPtr tmesa; + tridentScreenPtr tridentscrn; + struct dd_function_table functions; +#if 0 + drm_trident_sarea_t *saPriv=(drm_trident_sarea_t *)(((char*)sPriv->pSAREA)+ + sizeof(XF86DRISAREARec)); +#endif + + tmesa = (tridentContextPtr) CALLOC( sizeof(*tmesa) ); + if ( !tmesa ) return GL_FALSE; + + /* Allocate the Mesa context */ + if (sharedContextPrivate) + shareCtx = ((tridentContextPtr) sharedContextPrivate)->glCtx; + else + shareCtx = NULL; + + _mesa_init_driver_functions(&functions); + + tmesa->glCtx = + _mesa_create_context(glVisual, shareCtx, &functions, (void *)tmesa); + + if (!tmesa->glCtx) { + FREE(tmesa); + return GL_FALSE; + } + + tmesa->driContext = driContextPriv; + tmesa->driScreen = sPriv; + tmesa->driDrawable = NULL; /* Set by XMesaMakeCurrent */ + + tmesa->hHWContext = driContextPriv->hHWContext; + tmesa->driHwLock = (drmLock *)&sPriv->pSAREA->lock; + tmesa->driFd = sPriv->fd; +#if 0 + tmesa->sarea = saPriv; +#endif + + tridentscrn = tmesa->tridentScreen = (tridentScreenPtr)(sPriv->private); + + ctx = tmesa->glCtx; + + ctx->Const.MaxTextureLevels = 13; /* 4K by 4K? Is that right? */ + ctx->Const.MaxTextureUnits = 1; /* Permedia 3 */ + + ctx->Const.MinLineWidth = 0.0; + ctx->Const.MaxLineWidth = 255.0; + + ctx->Const.MinLineWidthAA = 0.0; + ctx->Const.MaxLineWidthAA = 65536.0; + + ctx->Const.MinPointSize = 0.0; + ctx->Const.MaxPointSize = 255.0; + + ctx->Const.MinPointSizeAA = 0.5; /* 4x4 quality mode */ + ctx->Const.MaxPointSizeAA = 16.0; + ctx->Const.PointSizeGranularity = 0.25; + +#if 0 + tmesa->texHeap = mmInit( 0, tmesa->tridentScreen->textureSize ); + + make_empty_list(&tmesa->TexObjList); + make_empty_list(&tmesa->SwappedOut); + + tmesa->CurrentTexObj[0] = 0; + tmesa->CurrentTexObj[1] = 0; /* Permedia 3, second texture */ + + tmesa->RenderIndex = ~0; +#endif + + /* 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, trident_pipeline ); + + /* Configure swrast to match hardware characteristics: + */ + _swrast_allow_pixel_fog( ctx, GL_FALSE ); + _swrast_allow_vertex_fog( ctx, GL_TRUE ); + + tridentInitVB( ctx ); + tridentDDInitExtensions( ctx ); + tridentDDInitDriverFuncs( ctx ); + tridentDDInitStateFuncs( ctx ); +#if 0 + tridentDDInitSpanFuncs( ctx ); + tridentDDInitTextureFuncs( ctx ); +#endif + tridentDDInitTriFuncs( ctx ); + tridentDDInitState( tmesa ); + + driContextPriv->driverPrivate = (void *)tmesa; + + UNLOCK_HARDWARE(tmesa); + + return GL_TRUE; +} + +static void +tridentDestroyContext(__DRIcontextPrivate *driContextPriv) +{ + tridentContextPtr tmesa = (tridentContextPtr)driContextPriv->driverPrivate; + + if (tmesa) { + _swsetup_DestroyContext( tmesa->glCtx ); + _tnl_DestroyContext( tmesa->glCtx ); + _ac_DestroyContext( tmesa->glCtx ); + _swrast_DestroyContext( tmesa->glCtx ); + + /* free the Mesa context */ + tmesa->glCtx->DriverCtx = NULL; + _mesa_destroy_context(tmesa->glCtx); + + _mesa_free(tmesa); + driContextPriv->driverPrivate = NULL; + } +} + + +static GLboolean +tridentCreateBuffer( __DRIscreenPrivate *driScrnPriv, + __DRIdrawablePrivate *driDrawPriv, + const __GLcontextModes *mesaVis, + GLboolean isPixmap ) +{ + tridentScreenPtr screen = (tridentScreenPtr) driScrnPriv->private; + + if (isPixmap) { + return GL_FALSE; /* not implemented */ + } + else { +#if 0 + driDrawPriv->driverPrivate = (void *) + _mesa_create_framebuffer(mesaVis, + GL_FALSE, /* software depth buffer? */ + mesaVis->stencilBits > 0, + mesaVis->accumRedBits > 0, + mesaVis->alphaBits > 0 + ); +#else + struct gl_framebuffer *fb = _mesa_create_framebuffer(mesaVis); + + { + driRenderbuffer *frontRb + = driNewRenderbuffer(GL_RGBA, screen->cpp, + screen->frontOffset, screen->frontPitch); + /* + tridentSetSpanFunctions(frontRb, mesaVis); + */ + _mesa_add_renderbuffer(fb, BUFFER_FRONT_LEFT, &frontRb->Base); + } + + if (mesaVis->doubleBufferMode) { + driRenderbuffer *backRb + = driNewRenderbuffer(GL_RGBA, screen->cpp, + screen->backOffset, screen->backPitch); + /* + tridentSetSpanFunctions(backRb, mesaVis); + */ + _mesa_add_renderbuffer(fb, BUFFER_BACK_LEFT, &backRb->Base); + } + + if (mesaVis->depthBits == 16) { + driRenderbuffer *depthRb + = driNewRenderbuffer(GL_DEPTH_COMPONENT16, screen->cpp, + screen->depthOffset, screen->depthPitch); + /* + tridentSetSpanFunctions(depthRb, mesaVis); + */ + _mesa_add_renderbuffer(fb, BUFFER_DEPTH, &depthRb->Base); + } + else if (mesaVis->depthBits == 24) { + driRenderbuffer *depthRb + = driNewRenderbuffer(GL_DEPTH_COMPONENT24, screen->cpp, + screen->depthOffset, screen->depthPitch); + /* + tridentSetSpanFunctions(depthRb, mesaVis); + */ + _mesa_add_renderbuffer(fb, BUFFER_DEPTH, &depthRb->Base); + } + + /* no h/w stencil? + if (mesaVis->stencilBits > 0 && !swStencil) { + driRenderbuffer *stencilRb + = driNewRenderbuffer(GL_STENCIL_INDEX8_EXT); + tridentSetSpanFunctions(stencilRb, mesaVis); + _mesa_add_renderbuffer(fb, BUFFER_STENCIL, &stencilRb->Base); + } + */ + + _mesa_add_soft_renderbuffers(fb, + GL_FALSE, /* color */ + GL_FALSE, /* depth */ + mesaVis->stencilBits > 0, + mesaVis->accumRedBits > 0, + GL_FALSE, /* alpha */ + GL_FALSE /* aux */); + driDrawPriv->driverPrivate = (void *) fb; +#endif + return (driDrawPriv->driverPrivate != NULL); + } +} + + +static void +tridentDestroyBuffer(__DRIdrawablePrivate *driDrawPriv) +{ + _mesa_destroy_framebuffer((GLframebuffer *) (driDrawPriv->driverPrivate)); +} + +static void +tridentSwapBuffers(__DRIdrawablePrivate *drawablePrivate) +{ + __DRIdrawablePrivate *dPriv = (__DRIdrawablePrivate *) drawablePrivate; + + if (dPriv->driContextPriv && dPriv->driContextPriv->driverPrivate) { + tridentContextPtr tmesa; + GLcontext *ctx; + tmesa = (tridentContextPtr) dPriv->driContextPriv->driverPrivate; + ctx = tmesa->glCtx; + if (ctx->Visual.doubleBufferMode) { + _mesa_notifySwapBuffers( ctx ); /* flush pending rendering comands */ + tridentCopyBuffer( dPriv ); + } + } + else { + /* XXX this shouldn't be an error but we can't handle it for now */ + _mesa_problem(NULL, "tridentSwapBuffers: drawable has no context!\n"); + } +} + +static GLboolean +tridentMakeCurrent(__DRIcontextPrivate *driContextPriv, + __DRIdrawablePrivate *driDrawPriv, + __DRIdrawablePrivate *driReadPriv) +{ + if (driContextPriv) { + GET_CURRENT_CONTEXT(ctx); + tridentContextPtr oldCtx = ctx ? TRIDENT_CONTEXT(ctx) : NULL; + tridentContextPtr newCtx = (tridentContextPtr) driContextPriv->driverPrivate; + + if ( newCtx != oldCtx ) { + newCtx->dirty = ~0; + } + + if (newCtx->driDrawable != driDrawPriv) { + newCtx->driDrawable = driDrawPriv; +#if 0 + tridentUpdateWindow ( newCtx->glCtx ); + tridentUpdateViewportOffset( newCtx->glCtx ); +#endif + } + + newCtx->drawOffset = newCtx->tridentScreen->backOffset; + newCtx->drawPitch = newCtx->tridentScreen->backPitch; + + _mesa_make_current( newCtx->glCtx, + (GLframebuffer *) driDrawPriv->driverPrivate, + (GLframebuffer *) driReadPriv->driverPrivate ); + + if (!newCtx->glCtx->Viewport.Width) { + _mesa_set_viewport(newCtx->glCtx, 0, 0, + driDrawPriv->w, driDrawPriv->h); + } + } else { + _mesa_make_current( NULL, NULL, NULL ); + } + return GL_TRUE; +} + + +static GLboolean +tridentUnbindContext( __DRIcontextPrivate *driContextPriv ) +{ + return GL_TRUE; +} + + +tridentScreenPtr tridentCreateScreen( __DRIscreenPrivate *sPriv ) +{ + TRIDENTDRIPtr tDRIPriv = (TRIDENTDRIPtr)sPriv->pDevPriv; + tridentScreenPtr tridentScreen; + + if (sPriv->devPrivSize != sizeof(TRIDENTDRIRec)) { + fprintf(stderr,"\nERROR! sizeof(TRIDENTDRIRec) does not match passed size from device driver\n"); + return GL_FALSE; + } + + /* Allocate the private area */ + tridentScreen = (tridentScreenPtr) CALLOC( sizeof(*tridentScreen) ); + if ( !tridentScreen ) return NULL; + + tridentScreen->driScreen = sPriv; + + tridentScreen->frontOffset = tDRIPriv->frontOffset; + tridentScreen->backOffset = tDRIPriv->backOffset; + tridentScreen->depthOffset = tDRIPriv->depthOffset; + tridentScreen->frontPitch = tDRIPriv->frontPitch; + tridentScreen->backPitch = tDRIPriv->backPitch; + tridentScreen->depthPitch = tDRIPriv->depthPitch; + tridentScreen->width = tDRIPriv->width; + tridentScreen->height = tDRIPriv->height; + +printf("%d %d\n",tridentScreen->width,tridentScreen->height); +printf("%d %d\n",tridentScreen->frontPitch,tridentScreen->backPitch); +printf("offset 0x%x 0x%x\n",tridentScreen->backOffset,tridentScreen->depthOffset); + + tridentScreen->mmio.handle = tDRIPriv->regs; + tridentScreen->mmio.size = 0x20000; + + if (drmMap(sPriv->fd, + tridentScreen->mmio.handle, tridentScreen->mmio.size, + (drmAddressPtr)&tridentScreen->mmio.map)) { + FREE(tridentScreen); + return GL_FALSE; + } +printf("MAPPED at %p\n", tridentScreen->mmio.map); + + return tridentScreen; +} + +/* Destroy the device specific screen private data struct. + */ +void tridentDestroyScreen( __DRIscreenPrivate *sPriv ) +{ + tridentScreenPtr tridentScreen = (tridentScreenPtr)sPriv->private; + + FREE(tridentScreen); +} +static GLboolean +tridentInitDriver(__DRIscreenPrivate *sPriv) +{ + sPriv->private = (void *) tridentCreateScreen( sPriv ); + + if (!sPriv->private) { + tridentDestroyScreen( sPriv ); + return GL_FALSE; + } + + return GL_TRUE; +} + +static struct __DriverAPIRec tridentAPI = { + tridentInitDriver, + tridentDestroyScreen, + tridentCreateContext, + tridentDestroyContext, + tridentCreateBuffer, + tridentDestroyBuffer, + tridentSwapBuffers, + tridentMakeCurrent, + tridentUnbindContext, +}; + + +PUBLIC void *__driCreateNewScreen_20050727( __DRInativeDisplay *dpy, int scrn, + __DRIscreen *psc, + const __GLcontextModes * modes, + const __DRIversion * ddx_version, + const __DRIversion * dri_version, + const __DRIversion * drm_version, + const __DRIframebuffer * frame_buffer, + drmAddress pSAREA, int fd, + int internal_api_version, + const __DRIinterfaceMethods * interface, + __GLcontextModes ** driver_modes ) +{ + __DRIscreenPrivate *psp; + static const __DRIversion ddx_expected = { 4, 0, 0 }; + static const __DRIversion dri_expected = { 3, 1, 0 }; + static const __DRIversion drm_expected = { 1, 0, 0 }; + + dri_interface = interface; + + if ( ! driCheckDriDdxDrmVersions2( "Trident", + dri_version, & dri_expected, + ddx_version, & ddx_expected, + drm_version, & drm_expected ) ) { + return NULL; + } + + psp = __driUtilCreateNewScreen(dpy, scrn, psc, NULL, + ddx_version, dri_version, drm_version, + frame_buffer, pSAREA, fd, + internal_api_version, &tridentAPI); + + if ( psp != NULL ) { +#if 0 + TRIDENTDRIPtr dri_priv = (TRIDENTDRIPtr) psp->pDevPriv; + *driver_modes = tridentFillInModes( dri_priv->bytesPerPixel * 8, + GL_TRUE ); +#endif + } + return (void *) psp; +} diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/trident/trident_context.h b/nx-X11/extras/Mesa/src/mesa/drivers/dri/trident/trident_context.h new file mode 100644 index 000000000..7ebb5f204 --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/trident/trident_context.h @@ -0,0 +1,242 @@ +/* + * Copyright 2002 by Alan Hourihane, Sychdyn, North Wales, UK. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Alan Hourihane not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Alan Hourihane makes no representations + * about the suitability of this software for any purpose. It is provided + * "as is" without express or implied warranty. + * + * ALAN HOURIHANE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL ALAN HOURIHANE BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + * + * Authors: Alan Hourihane, <alanh@fairlite.demon.co.uk> + * + * Trident CyberBladeXP driver. + * + */ +#ifndef _TRIDENT_CONTEXT_H_ +#define _TRIDENT_CONTEXT_H_ + +#include "dri_util.h" +#include "macros.h" +#include "mtypes.h" +#include "drm.h" +#include "mm.h" + +#define SUBPIXEL_X (0.0F) +#define SUBPIXEL_Y (0.125F) + +#define _TRIDENT_NEW_VERTEX (_NEW_TEXTURE | \ + _DD_NEW_TRI_UNFILLED | \ + _DD_NEW_TRI_LIGHT_TWOSIDE) + +#define TRIDENT_FALLBACK_TEXTURE 0x01 +#define TRIDENT_FALLBACK_DRAW_BUFFER 0x02 + +#define TRIDENT_NEW_CLIP 0x01 + +#define TRIDENT_UPLOAD_COMMAND_D 0x00000001 +#define TRIDENT_UPLOAD_CONTEXT 0x04000000 +#define TRIDENT_UPLOAD_CLIPRECTS 0x80000000 + +#define TAG(x) trident##x +#include "tnl_dd/t_dd_vertex.h" +#undef TAG + +/* these require that base be dword-aligned */ +static inline void MMIO_OUT32(unsigned char *base, unsigned int offset, + unsigned int val) +{ + unsigned int *addr = (unsigned int *)(base + offset); + *addr = val; +} + +static inline unsigned int MMIO_IN32(unsigned char *base, unsigned int offset) +{ + unsigned int *addr = (unsigned int *)(base + offset); + return *addr; +} + +#define MMIO_OUT8(base, offset, val) *((base) + (offset)) = (val) +#define MMIO_IN8(base, offset) *((base) + (offset)) + +struct trident_context; +typedef struct trident_context tridentContextRec; +typedef struct trident_context *tridentContextPtr; + +typedef void (*trident_quad_func)( tridentContextPtr, + const tridentVertex *, + const tridentVertex *, + const tridentVertex *, + const tridentVertex * ); +typedef void (*trident_tri_func)( tridentContextPtr, + const tridentVertex *, + const tridentVertex *, + const tridentVertex * ); +typedef void (*trident_line_func)( tridentContextPtr, + const tridentVertex *, + const tridentVertex * ); +typedef void (*trident_point_func)( tridentContextPtr, + const tridentVertex * ); + +typedef struct { + drm_handle_t handle; /* Handle to the DRM region */ + drmSize size; /* Size of the DRM region */ + unsigned char *map; /* Mapping of the DRM region */ +} tridentRegionRec, *tridentRegionPtr; + +typedef struct { + __DRIscreenPrivate *driScreen; /* Back pointer to DRI screen */ + + drmBufMapPtr buffers; + + unsigned int frontOffset; + unsigned int frontPitch; + unsigned int backOffset; + unsigned int backPitch; + unsigned int depthOffset; + unsigned int depthPitch; + unsigned int width; + unsigned int height; + unsigned int cpp; + +#if 0 + unsigned int sarea_priv_offset; +#endif + + tridentRegionRec mmio; +} tridentScreenRec, *tridentScreenPtr; + +/** + * tridentRenderbuffer, derived from Mesa's gl_renderbuffer + */ +typedef struct { + struct gl_renderbuffer Base; + /* XXX per-window info should go here */ + int foo, bar; +} tridentRenderbuffer; + + +struct trident_context { + GLcontext *glCtx; /* Mesa context */ + + __DRIcontextPrivate *driContext; + __DRIscreenPrivate *driScreen; + __DRIdrawablePrivate *driDrawable; + + GLuint new_gl_state; + GLuint new_state; + GLuint dirty; + +#if 0 + drm_trident_sarea_t *sarea; +#endif + + /* Temporaries for translating away float colors: + */ + struct gl_client_array UbyteColor; + struct gl_client_array UbyteSecondaryColor; + + /* Mirrors of some DRI state + */ + int lastStamp; /* mirror driDrawable->lastStamp */ + + drm_context_t hHWContext; + drmLock *driHwLock; + int driFd; + + tridentScreenPtr tridentScreen; /* Screen private DRI data */ + + /* Visual, drawable, cliprect and scissor information + */ + GLenum DrawBuffer; + GLint drawOffset, drawPitch; + GLint drawX, drawY; /* origin of drawable in draw buffer */ + GLint readOffset, readPitch; + + GLuint numClipRects; /* Cliprects for the draw buffer */ + drm_clip_rect_t *pClipRects; + + GLint scissor; + drm_clip_rect_t ScissorRect; /* Current software scissor */ + + GLuint Fallback; + GLuint RenderIndex; + GLuint SetupNewInputs; + GLuint SetupIndex; + GLfloat hw_viewport[16]; + GLfloat depth_scale; + GLuint vertex_format; + GLuint vertex_size; + GLuint vertex_stride_shift; + char *verts; + + GLint tmu_source[2]; + + GLuint hw_primitive; + GLenum render_primitive; + + trident_point_func draw_point; + trident_line_func draw_line; + trident_tri_func draw_tri; + trident_quad_func draw_quad; + +#if 0 + gammaTextureObjectPtr CurrentTexObj[2]; + struct gamma_texture_object_t TexObjList; + struct gamma_texture_object_t SwappedOut; + GLenum TexEnvImageFmt[2]; + + memHeap_t *texHeap; + + int lastSwap; + int texAge; + int ctxAge; + int dirtyAge; + int lastStamp; +#endif + + /* Chip state */ + + int commandD; + + /* Context State */ + + int ClearColor; +}; + +void tridentDDInitExtensions( GLcontext *ctx ); +void tridentDDInitDriverFuncs( GLcontext *ctx ); +void tridentDDInitSpanFuncs( GLcontext *ctx ); +void tridentDDInitState( tridentContextPtr tmesa ); +void tridentInitHW( tridentContextPtr tmesa ); +void tridentDDInitStateFuncs( GLcontext *ctx ); +void tridentDDInitTextureFuncs( GLcontext *ctx ); +void tridentDDInitTriFuncs( GLcontext *ctx ); + +extern void tridentBuildVertices( GLcontext *ctx, + GLuint start, + GLuint count, + GLuint newinputs ); +extern void tridentInitVB( GLcontext *ctx ); +extern void tridentCopyBuffer( const __DRIdrawablePrivate *dPriv ); +extern void tridentFallback( tridentContextPtr tmesa, GLuint bit, + GLboolean mode ); +extern void tridentCheckTexSizes( GLcontext *ctx ); +extern void tridentChooseVertexState( GLcontext *ctx ); +extern void tridentDDUpdateHWState( GLcontext *ctx ); +extern void tridentUploadHwStateLocked( tridentContextPtr tmesa ); + +#define TRIDENT_CONTEXT(ctx) ((tridentContextPtr)(ctx->DriverCtx)) + +#endif /* _TRIDENT_CONTEXT_H_ */ diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/trident/trident_dd.c b/nx-X11/extras/Mesa/src/mesa/drivers/dri/trident/trident_dd.c new file mode 100644 index 000000000..8c3af2001 --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/trident/trident_dd.c @@ -0,0 +1,127 @@ +/* + * Copyright 2002 by Alan Hourihane, Sychdyn, North Wales, UK. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Alan Hourihane not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Alan Hourihane makes no representations + * about the suitability of this software for any purpose. It is provided + * "as is" without express or implied warranty. + * + * ALAN HOURIHANE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL ALAN HOURIHANE BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + * + * Authors: Alan Hourihane, <alanh@fairlite.demon.co.uk> + * + * Trident CyberBladeXP driver. + * + */ +#include "trident_context.h" +#include "trident_lock.h" +#if defined(USE_X86_ASM) +#include "x86/common_x86_asm.h" +#endif + +#include "swrast/swrast.h" +#include "context.h" +#include "framebuffer.h" + +#define TRIDENT_DATE "20041223" + +/* Return the width and height of the current color buffer. + */ +static void tridentDDGetBufferSize( GLframebuffer *framebuffer, + GLuint *width, GLuint *height ) +{ + GET_CURRENT_CONTEXT(ctx); + tridentContextPtr tmesa = TRIDENT_CONTEXT(ctx); + + LOCK_HARDWARE(tmesa); + *width = tmesa->driDrawable->w; + *height = tmesa->driDrawable->h; + UNLOCK_HARDWARE(tmesa); +} + + +/* Return various strings for glGetString(). + */ +static const GLubyte *tridentDDGetString( GLcontext *ctx, GLenum name ) +{ + static char buffer[128]; + + switch ( name ) { + case GL_VENDOR: + return (GLubyte *)"Alan Hourihane"; + + case GL_RENDERER: + sprintf( buffer, "Mesa DRI Trident " TRIDENT_DATE ); + + /* Append any CPU-specific information. + */ +#ifdef USE_X86_ASM + if ( _mesa_x86_cpu_features ) { + strncat( buffer, " x86", 4 ); + } +#ifdef USE_MMX_ASM + if ( cpu_has_mmx ) { + strncat( buffer, "/MMX", 4 ); + } +#endif +#ifdef USE_3DNOW_ASM + if ( cpu_has_3dnow ) { + strncat( buffer, "/3DNow!", 7 ); + } +#endif +#ifdef USE_SSE_ASM + if ( cpu_has_xmm ) { + strncat( buffer, "/SSE", 4 ); + } +#endif +#endif + return (GLubyte *)buffer; + + default: + return NULL; + } +} + +/* Enable the extensions supported by this driver. + */ +void tridentDDInitExtensions( GLcontext *ctx ) +{ + /* None... */ +} + +/* Initialize the driver's misc functions. + */ +void tridentDDInitDriverFuncs( GLcontext *ctx ) +{ + ctx->Driver.GetBufferSize = tridentDDGetBufferSize; + ctx->Driver.GetString = tridentDDGetString; + + ctx->Driver.Error = NULL; + + /* 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.ResizeBuffers = _mesa_resize_framebuffer; + + /* 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/nx-X11/extras/Mesa/src/mesa/drivers/dri/trident/trident_dri.h b/nx-X11/extras/Mesa/src/mesa/drivers/dri/trident/trident_dri.h new file mode 100644 index 000000000..c1ce3c468 --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/trident/trident_dri.h @@ -0,0 +1,28 @@ +#ifndef _TRIDENT_DRI_ +#define _TRIDENT_DRI_ + +#include "xf86drm.h" + +typedef struct { + drm_handle_t regs; + drmSize regsSize; + drmAddress regsMap; + int deviceID; + int width; + int height; + int mem; + int frontOffset; + int frontPitch; + int backOffset; + int backPitch; + int depthOffset; + int depthPitch; + int cpp; +#if 0 + int textureOffset; + int textureSize; +#endif + unsigned int sarea_priv_offset; +} TRIDENTDRIRec, *TRIDENTDRIPtr; + +#endif diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/trident/trident_lock.h b/nx-X11/extras/Mesa/src/mesa/drivers/dri/trident/trident_lock.h new file mode 100644 index 000000000..ee0819f5c --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/trident/trident_lock.h @@ -0,0 +1,11 @@ +/* XXX tridentGetLock doesn't exist... */ + +#define LOCK_HARDWARE(tmesa) \ + do { \ + char __ret = 0; \ + DRM_CAS(tmesa->driHwLock, tmesa->hHWContext, \ + DRM_LOCK_HELD | tmesa->hHWContext, __ret); \ + } while (0) + +#define UNLOCK_HARDWARE(tmesa) \ + DRM_UNLOCK(tmesa->driFd, tmesa->driHwLock, tmesa->hHWContext) diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/trident/trident_state.c b/nx-X11/extras/Mesa/src/mesa/drivers/dri/trident/trident_state.c new file mode 100644 index 000000000..76b2a8ef3 --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/trident/trident_state.c @@ -0,0 +1,555 @@ +/* + * Copyright 2002 by Alan Hourihane, Sychdyn, North Wales, UK. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Alan Hourihane not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Alan Hourihane makes no representations + * about the suitability of this software for any purpose. It is provided + * "as is" without express or implied warranty. + * + * ALAN HOURIHANE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL ALAN HOURIHANE BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + * + * Authors: Alan Hourihane, <alanh@fairlite.demon.co.uk> + * + * Trident CyberBladeXP driver. + * + */ +#include "trident_context.h" +#include "trident_lock.h" +#include "array_cache/acache.h" +#include "swrast/swrast.h" +#include "swrast_setup/swrast_setup.h" +#include "tnl/tnl.h" +#include "framebuffer.h" + +#define TRIDENTPACKCOLOR332(r, g, b) \ + (((r) & 0xe0) | (((g) & 0xe0) >> 3) | (((b) & 0xc0) >> 6)) + +#define TRIDENTPACKCOLOR1555(r, g, b, a) \ + ((((r) & 0xf8) << 7) | (((g) & 0xf8) << 2) | (((b) & 0xf8) >> 3) | \ + ((a) ? 0x8000 : 0)) + +#define TRIDENTPACKCOLOR565(r, g, b) \ + ((((r) & 0xf8) << 8) | (((g) & 0xfc) << 3) | (((b) & 0xf8) >> 3)) + +#define TRIDENTPACKCOLOR888(r, g, b) \ + (((r) << 16) | ((g) << 8) | (b)) + +#define TRIDENTPACKCOLOR8888(r, g, b, a) \ + (((a) << 24) | ((r) << 16) | ((g) << 8) | (b)) + +#define TRIDENTPACKCOLOR4444(r, g, b, a) \ + ((((a) & 0xf0) << 8) | (((r) & 0xf0) << 4) | ((g) & 0xf0) | ((b) >> 4)) + +static __inline__ GLuint tridentPackColor( GLuint cpp, + GLubyte r, GLubyte g, + GLubyte b, GLubyte a ) +{ + switch ( cpp ) { + case 2: + return TRIDENTPACKCOLOR565( r, g, b ); + case 4: + return TRIDENTPACKCOLOR8888( r, g, b, a ); + default: + return 0; + } +} + +void tridentUploadHwStateLocked( tridentContextPtr tmesa ) +{ + unsigned char *MMIO = tmesa->tridentScreen->mmio.map; +#if 0 + ATISAREAPrivPtr sarea = tmesa->sarea; + trident_context_regs_t *regs = &(sarea->ContextState); +#endif + + if ( tmesa->dirty & TRIDENT_UPLOAD_COMMAND_D ) { + MMIO_OUT32(MMIO, 0x00281C, tmesa->commandD ); + tmesa->dirty &= ~TRIDENT_UPLOAD_COMMAND_D; + } + + if ( tmesa->dirty & TRIDENT_UPLOAD_CLIPRECTS ) { + /* XXX FIX ME ! */ + MMIO_OUT32(MMIO, 0x002C80 , 0x20008000 | tmesa->tridentScreen->height ); + MMIO_OUT32(MMIO, 0x002C84 , 0x20000000 | tmesa->tridentScreen->width ); + tmesa->dirty &= ~TRIDENT_UPLOAD_CLIPRECTS; + } + + tmesa->dirty = 0; +} + +/* Copy the back color buffer to the front color buffer. + */ +void tridentCopyBuffer( const __DRIdrawablePrivate *dPriv ) +{ + unsigned char *MMIO; + tridentContextPtr tmesa; + GLint nbox, i; + int busy; + drm_clip_rect_t *pbox; + + assert(dPriv); + assert(dPriv->driContextPriv); + assert(dPriv->driContextPriv->driverPrivate); + + tmesa = (tridentContextPtr) dPriv->driContextPriv->driverPrivate; + MMIO = tmesa->tridentScreen->mmio.map; + + LOCK_HARDWARE( tmesa ); + + /* use front buffer cliprects */ + nbox = dPriv->numClipRects; + pbox = dPriv->pClipRects; + + for ( i = 0 ; i < nbox ; i++ ) { +#if 0 + GLint nr = MIN2( i + MACH64_NR_SAREA_CLIPRECTS , nbox ); + drm_clip_rect_t *b = tmesa->sarea->boxes; + GLint n = 0; + + for ( ; i < nr ; i++ ) { + *b++ = pbox[i]; + n++; + } + tmesa->sarea->nbox = n; +#endif + + MMIO_OUT32(MMIO, 0x2150, tmesa->tridentScreen->frontPitch << 20 | tmesa->tridentScreen->frontOffset>>4); + MMIO_OUT32(MMIO, 0x2154, tmesa->tridentScreen->backPitch << 20 | tmesa->tridentScreen->backOffset>>4); + MMIO_OUT8(MMIO, 0x2127, 0xCC); /* Copy Rop */ + MMIO_OUT32(MMIO, 0x2128, 0x4); /* scr2scr */ + MMIO_OUT32(MMIO, 0x2138, (pbox->x1 << 16) | pbox->y1); + MMIO_OUT32(MMIO, 0x213C, (pbox->x1 << 16) | pbox->y1); + MMIO_OUT32(MMIO, 0x2140, (pbox->x2 - pbox->x1) << 16 | (pbox->y2 - pbox->y1) ); + MMIO_OUT8(MMIO, 0x2124, 0x01); /* BLT */ +#define GE_BUSY 0x80 + for (;;) { + busy = MMIO_IN8(MMIO, 0x2120); + if ( !(busy & GE_BUSY) ) + break; + } + } + + UNLOCK_HARDWARE( tmesa ); + +#if 0 + tmesa->dirty |= (MACH64_UPLOAD_CONTEXT | + MACH64_UPLOAD_MISC | + MACH64_UPLOAD_CLIPRECTS); +#endif +} + + +static void tridentDDClear( GLcontext *ctx, GLbitfield mask, GLboolean all, + GLint cx, GLint cy, GLint cw, GLint ch ) +{ + tridentContextPtr tmesa = TRIDENT_CONTEXT(ctx); + unsigned char *MMIO = tmesa->tridentScreen->mmio.map; + int busy; + GLuint flags = 0; + GLint i; + +#define DRM_TRIDENT_FRONT 0x01 +#define DRM_TRIDENT_BACK 0x02 +#define DRM_TRIDENT_DEPTH 0x04 + + if ( tmesa->new_state ) + tridentDDUpdateHWState( ctx ); + + if ( mask & BUFFER_BIT_FRONT_LEFT ) { + flags |= DRM_TRIDENT_FRONT; + mask &= ~BUFFER_BIT_FRONT_LEFT; + } + + if ( mask & BUFFER_BIT_BACK_LEFT ) { + flags |= DRM_TRIDENT_BACK; + mask &= ~BUFFER_BIT_BACK_LEFT; + } + + if ( ( mask & BUFFER_BIT_DEPTH ) && ctx->Depth.Mask ) { + flags |= DRM_TRIDENT_DEPTH; + mask &= ~BUFFER_BIT_DEPTH; + } + + LOCK_HARDWARE(tmesa); + + if ( flags ) { + + cx += tmesa->drawX; + cy += tmesa->drawY; + + /* HACK!!! + */ + if ( tmesa->dirty & ~TRIDENT_UPLOAD_CLIPRECTS ) { + tridentUploadHwStateLocked( tmesa ); + } + + for ( i = 0 ; i < tmesa->numClipRects ; i++ ) { +#if 0 + int nr = MIN2( i + TRIDENT_NR_SAREA_CLIPRECTS, tmesa->numClipRects ); + drm_clip_rect_t *box = tmesa->pClipRects; + drm_clip_rect_t *b = tmesa->sarea->boxes; + GLint 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++ = box[i]; + n++; + } + } + + tmesa->sarea->nbox = n; +#endif + +if (flags & DRM_TRIDENT_BACK) { + MMIO_OUT32(MMIO, 0x2150, tmesa->tridentScreen->backPitch << 20 | tmesa->tridentScreen->backOffset>>4); + MMIO_OUT8(MMIO, 0x2127, 0xF0); /* Pat Rop */ + MMIO_OUT32(MMIO, 0x2158, tmesa->ClearColor); + MMIO_OUT32(MMIO, 0x2128, 0x4000); /* solidfill */ + MMIO_OUT32(MMIO, 0x2138, cx << 16 | cy); + MMIO_OUT32(MMIO, 0x2140, cw << 16 | ch); + MMIO_OUT8(MMIO, 0x2124, 0x01); /* BLT */ +#define GE_BUSY 0x80 + for (;;) { + busy = MMIO_IN8(MMIO, 0x2120); + if ( !(busy & GE_BUSY) ) + break; + } +} +if (flags & DRM_TRIDENT_DEPTH) { + MMIO_OUT32(MMIO, 0x2150, tmesa->tridentScreen->depthPitch << 20 | tmesa->tridentScreen->depthOffset>>4); + MMIO_OUT8(MMIO, 0x2127, 0xF0); /* Pat Rop */ + MMIO_OUT32(MMIO, 0x2158, tmesa->ClearColor); + MMIO_OUT32(MMIO, 0x2128, 0x4000); /* solidfill */ + MMIO_OUT32(MMIO, 0x2138, cx << 16 | cy); + MMIO_OUT32(MMIO, 0x2140, cw << 16 | ch); + MMIO_OUT8(MMIO, 0x2124, 0x01); /* BLT */ +#define GE_BUSY 0x80 + for (;;) { + busy = MMIO_IN8(MMIO, 0x2120); + if ( !(busy & GE_BUSY) ) + break; + } +} + MMIO_OUT32(MMIO, 0x2150, tmesa->tridentScreen->frontPitch << 20 | tmesa->tridentScreen->frontOffset>>4); +if (flags & DRM_TRIDENT_FRONT) { + MMIO_OUT8(MMIO, 0x2127, 0xF0); /* Pat Rop */ + MMIO_OUT32(MMIO, 0x2158, tmesa->ClearColor); + MMIO_OUT32(MMIO, 0x2128, 0x4000); /* solidfill */ + MMIO_OUT32(MMIO, 0x2138, cx << 16 | cy); + MMIO_OUT32(MMIO, 0x2140, cw << 16 | ch); + MMIO_OUT8(MMIO, 0x2124, 0x01); /* BLT */ +#define GE_BUSY 0x80 + for (;;) { + busy = MMIO_IN8(MMIO, 0x2120); + if ( !(busy & GE_BUSY) ) + break; + } +} + + } + +#if 0 + tmesa->dirty |= (TRIDENT_UPLOAD_CONTEXT | + TRIDENT_UPLOAD_MISC | + TRIDENT_UPLOAD_CLIPRECTS); +#endif + } + + UNLOCK_HARDWARE(tmesa); + + if ( mask ) + _swrast_Clear( ctx, mask, all, cx, cy, cw, ch ); +} + +static void tridentDDShadeModel( GLcontext *ctx, GLenum mode ) +{ + tridentContextPtr tmesa = TRIDENT_CONTEXT(ctx); + GLuint s = tmesa->commandD; + +#define TRIDENT_FLAT_SHADE 0x000000E0 +#define TRIDENT_FLAT_SHADE_VERTEX_C 0x00000060 +#define TRIDENT_FLAT_SHADE_GOURAUD 0x00000080 + + s &= ~TRIDENT_FLAT_SHADE; + + switch ( mode ) { + case GL_FLAT: + s |= TRIDENT_FLAT_SHADE_VERTEX_C; + break; + case GL_SMOOTH: + s |= TRIDENT_FLAT_SHADE_GOURAUD; + break; + default: + return; + } + + if ( tmesa->commandD != s ) { + tmesa->commandD = s; + + tmesa->dirty |= TRIDENT_UPLOAD_COMMAND_D; + } +} + +void tridentCalcViewport( GLcontext *ctx ) +{ + tridentContextPtr tmesa = TRIDENT_CONTEXT(ctx); + const GLfloat *v = ctx->Viewport._WindowMap.m; + GLfloat *m = tmesa->hw_viewport; + + /* See also trident_translate_vertex. + */ + m[MAT_SX] = v[MAT_SX]; + m[MAT_TX] = v[MAT_TX] + tmesa->drawX + SUBPIXEL_X; + m[MAT_SY] = - v[MAT_SY]; + m[MAT_TY] = - v[MAT_TY] + tmesa->driDrawable->h + tmesa->drawY + SUBPIXEL_Y; +#if 0 + m[MAT_SZ] = v[MAT_SZ] * tmesa->depth_scale; + m[MAT_TZ] = v[MAT_TZ] * tmesa->depth_scale; +#else + m[MAT_SZ] = v[MAT_SZ]; + m[MAT_TZ] = v[MAT_TZ]; +#endif + + tmesa->SetupNewInputs = ~0; +} + +static void tridentDDViewport( GLcontext *ctx, + GLint x, GLint y, + GLsizei width, GLsizei height ) +{ + tridentCalcViewport( ctx ); +} + +static void tridentDDDepthRange( GLcontext *ctx, + GLclampd nearval, GLclampd farval ) +{ + tridentCalcViewport( ctx ); +} + +void tridentSetCliprects( tridentContextPtr tmesa, GLenum mode ) +{ + __DRIdrawablePrivate *dPriv = tmesa->driDrawable; + + switch ( mode ) { + case GL_FRONT_LEFT: + if (dPriv->numClipRects == 0) { + static drm_clip_rect_t zeroareacliprect = {0,0,0,0}; + tmesa->numClipRects = 1; + tmesa->pClipRects = &zeroareacliprect; + } else { + tmesa->numClipRects = dPriv->numClipRects; + tmesa->pClipRects = (drm_clip_rect_t *)dPriv->pClipRects; + } + tmesa->drawX = dPriv->x; + tmesa->drawY = dPriv->y; + break; + case GL_BACK_LEFT: + if ( dPriv->numBackClipRects == 0 ) { + if (dPriv->numClipRects == 0) { + static drm_clip_rect_t zeroareacliprect = {0,0,0,0}; + tmesa->numClipRects = 1; + tmesa->pClipRects = &zeroareacliprect; + } else { + tmesa->numClipRects = dPriv->numClipRects; + tmesa->pClipRects = (drm_clip_rect_t *)dPriv->pClipRects; + tmesa->drawX = dPriv->x; + tmesa->drawY = dPriv->y; + } + } + else { + tmesa->numClipRects = dPriv->numBackClipRects; + tmesa->pClipRects = (drm_clip_rect_t *)dPriv->pBackClipRects; + tmesa->drawX = dPriv->backX; + tmesa->drawY = dPriv->backY; + } + break; + default: + return; + } + +#if 0 + tmesa->dirty |= TRIDENT_UPLOAD_CLIPRECTS; +#endif +} + +#if 0 +static GLboolean tridentDDSetDrawBuffer( GLcontext *ctx, GLenum mode ) +{ + tridentContextPtr tmesa = TRIDENT_CONTEXT(ctx); + int found = GL_TRUE; + + if ( tmesa->DrawBuffer != mode ) { + tmesa->DrawBuffer = mode; + + switch ( mode ) { + case GL_FRONT_LEFT: + tridentFallback( tmesa, TRIDENT_FALLBACK_DRAW_BUFFER, GL_FALSE ); + tmesa->drawOffset = tmesa->tridentScreen->frontOffset; + tmesa->drawPitch = tmesa->tridentScreen->frontPitch; + tridentSetCliprects( tmesa, GL_FRONT_LEFT ); + break; + case GL_BACK_LEFT: + tridentFallback( tmesa, TRIDENT_FALLBACK_DRAW_BUFFER, GL_FALSE ); + tmesa->drawOffset = tmesa->tridentScreen->backOffset; + tmesa->drawPitch = tmesa->tridentScreen->backPitch; + tridentSetCliprects( tmesa, GL_BACK_LEFT ); + break; + default: + tridentFallback( tmesa, TRIDENT_FALLBACK_DRAW_BUFFER, GL_TRUE ); + found = GL_FALSE; + break; + } + +#if 0 + tmesa->setup.dst_off_pitch = (((tmesa->drawPitch/8) << 22) | + (tmesa->drawOffset >> 3)); + + tmesa->dirty |= MACH64_UPLOAD_DST_OFF_PITCH | MACH64_UPLOAD_CONTEXT; +#endif + + } + + return found; +} + +static void tridentDDClearColor( GLcontext *ctx, + const GLchan color[4] ) +{ + tridentContextPtr tmesa = TRIDENT_CONTEXT(ctx); + + tmesa->ClearColor = tridentPackColor( tmesa->tridentScreen->cpp, + color[0], color[1], + color[2], color[3] ); +} +#endif + +void tridentDDUpdateState( GLcontext *ctx, GLuint new_state ) +{ + _swrast_InvalidateState( ctx, new_state ); + _swsetup_InvalidateState( ctx, new_state ); + _ac_InvalidateState( ctx, new_state ); + _tnl_InvalidateState( ctx, new_state ); + TRIDENT_CONTEXT(ctx)->new_gl_state |= new_state; +} + + +/* Initialize the context's hardware state. + */ +void tridentDDInitState( tridentContextPtr tmesa ) +{ + tmesa->new_state = 0; + + switch ( tmesa->glCtx->Visual.depthBits ) { + case 16: + tmesa->depth_scale = 1.0 / (GLfloat)0xffff; + break; + case 24: + tmesa->depth_scale = 1.0 / (GLfloat)0xffffff; + break; + } +} + +void tridentDDUpdateHWState( GLcontext *ctx ) +{ + tridentContextPtr tmesa = TRIDENT_CONTEXT(ctx); + int new_state = tmesa->new_state; + + if ( new_state ) + { + tmesa->new_state = 0; + +#if 0 + /* Update the various parts of the context's state. + */ + if ( new_state & GAMMA_NEW_ALPHA ) + tridentUpdateAlphaMode( ctx ); + + if ( new_state & GAMMA_NEW_DEPTH ) + tridentUpdateZMode( ctx ); + + if ( new_state & GAMMA_NEW_FOG ) + gammaUpdateFogAttrib( ctx ); + + if ( new_state & GAMMA_NEW_CLIP ) + gammaUpdateClipping( ctx ); + + if ( new_state & GAMMA_NEW_POLYGON ) + gammaUpdatePolygon( ctx ); + + if ( new_state & GAMMA_NEW_CULL ) + gammaUpdateCull( ctx ); + + if ( new_state & GAMMA_NEW_MASKS ) + gammaUpdateMasks( ctx ); + + if ( new_state & GAMMA_NEW_STIPPLE ) + gammaUpdateStipple( ctx ); +#endif + } + + /* HACK ! */ + +#if 0 + gammaEmitHwState( tmesa ); +#endif +} + +/* Initialize the driver's state functions. + */ +void tridentDDInitStateFuncs( GLcontext *ctx ) +{ + ctx->Driver.UpdateState = tridentDDUpdateState; + + ctx->Driver.Clear = tridentDDClear; + ctx->Driver.DepthRange = tridentDDDepthRange; + ctx->Driver.ShadeModel = tridentDDShadeModel; + ctx->Driver.Viewport = tridentDDViewport; + + /* 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.ResizeBuffers = _mesa_resize_framebuffer; + + /* 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/nx-X11/extras/Mesa/src/mesa/drivers/dri/trident/trident_tris.c b/nx-X11/extras/Mesa/src/mesa/drivers/dri/trident/trident_tris.c new file mode 100644 index 000000000..ee85ab482 --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/trident/trident_tris.c @@ -0,0 +1,1125 @@ +/* + * Copyright 2002 by Alan Hourihane, Sychdyn, North Wales, UK. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Alan Hourihane not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Alan Hourihane makes no representations + * about the suitability of this software for any purpose. It is provided + * "as is" without express or implied warranty. + * + * ALAN HOURIHANE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL ALAN HOURIHANE BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + * + * Authors: Alan Hourihane, <alanh@fairlite.demon.co.uk> + * + * Trident CyberBladeXP driver. + * + */ + +#include "trident_context.h" +#include "trident_lock.h" +#include "tnl/tnl.h" +#include "tnl/t_context.h" +#include "tnl/t_pipeline.h" +#include "swrast/swrast.h" +#include "swrast_setup/swrast_setup.h" + +static int first = 1; + +typedef struct reg { + int addr; + int data; +} RegData; + +RegData initRegData[]={ + {0x2804, 0x19980824}, + {0x2F70, 0x46455858}, + {0x2F74, 0x41584998}, + {0x2F00, 0x00000000}, + {0x2F04, 0x80000800}, + {0x2F08, 0x00550200}, + {0x2F40, 0x00000001}, + {0x2F40, 0x00000001}, + {0x2F44, 0x00830097}, + {0x2F48, 0x0087009F}, + {0x2F4C, 0x00BF0003}, + {0x2F50, 0xF00B6C1B}, + {0x2C04, 0x00000000}, + {0x2D00, 0x00000080}, + {0x2D00, 0x00000000}, + {0x2DD4, 0x00100000}, + {0x2DD4, 0x00100010}, + {0x2DD8, 0x00100000}, + {0x2DD8, 0x00100010}, + {0x2C88, 0xFFFFFFFF}, + {0x2C94 , 0xFFFFFFFF}, + {0x281C, 0x00008000}, + {0x2C80, 0x00000000}, + {0x2C80, 0x00000000}, + {0x2C80 , 0x00008000}, + {0x2C00 , 0x00000000}, + {0x2C04 , 0x00000000}, + {0x2C08 , 0x00000000}, + {0x2C0C , 0x00000000}, + {0x2C10 , 0x00000000}, + {0x2C14 , 0x00000000}, + {0x2C18 , 0x00000000}, + {0x2C1C , 0x00000000}, + {0x2C20 , 0x00000000}, + {0x2C24 , 0x00000000}, + {0x2C2C , 0x00000000}, + {0x2C30 , 0x00000000}, + {0x2C34 , 0x00000000}, + {0x2C38 , 0x00000000}, + {0x2C3C , 0x00000000}, + {0x2C40 , 0x00000000}, + {0x2C44 , 0x00000000}, + {0x2C48 , 0x00000000}, + {0x2C4C , 0x00000000}, + {0x2C50 , 0x00000000}, + {0x2C54 , 0x00000000}, + {0x2C58 , 0x00000000}, + {0x2C5C , 0x00000000}, + {0x2C60 , 0x00000000}, + {0x2C64 , 0x00000000}, + {0x2C68 , 0x00000000}, + {0x2C6C , 0x00000000}, + {0x2C70 , 0x00000000}, + {0x2C74 , 0x00000000}, + {0x2C78 , 0x00000000}, + {0x2C7C , 0x00000000}, + {0x2C80 , 0x00008000}, + {0x2C84 , 0x00000000}, + {0x2C88 , 0xFFFFFFFF}, + {0x2C8C , 0x00000000}, + {0x2C90 , 0x00000000}, + {0x2C94 , 0xFFFFFFFF}, + {0x2C98 , 0x00000000}, + {0x2C9C , 0x00000000}, + {0x2CA0 , 0x00000000}, + {0x2CA4 , 0x00000000}, + {0x2CA8 , 0x00000000}, + {0x2CAC , 0x00000000}, + {0x2CB0 , 0x00000000}, + {0x2CB4 , 0x00000000}, + {0x2CB8 , 0x00000000}, + {0x2CBC , 0x00000000}, + {0x2CC0 , 0x00000000}, + {0x2CC4 , 0x00000000}, + {0x2CC8 , 0x00000000}, + {0x2CCC , 0x00000000}, + {0x2CD0 , 0x00000000}, + {0x2CD4 , 0x00000000}, + {0x2CD8 , 0x00000000}, + {0x2CDC , 0x00000000}, + {0x2CE0 , 0x00000000}, + {0x2CE4 , 0x00000000}, + {0x2CE8 , 0x00000000}, + {0x2CEC , 0x00000000}, + {0x2CF0 , 0x00000000}, + {0x2CF4 , 0x00000000}, + {0x2CF8 , 0x00000000}, + {0x2CFC , 0x00000000}, + {0x2D00 , 0x00000000}, + {0x2D04 , 0x00000000}, + {0x2D08 , 0x00000000}, + {0x2D0C , 0x00000000}, + {0x2D10 , 0x00000000}, + {0x2D14 , 0x00000000}, + {0x2D18 , 0x00000000}, + {0x2D1C , 0x00000000}, + {0x2D20 , 0x00000000}, + {0x2D24 , 0x00000000}, + {0x2D28 , 0x00000000}, + {0x2D2C , 0x00000000}, + {0x2D30 , 0x00000000}, + {0x2D34 , 0x00000000}, + {0x2D38 , 0x00000000}, + {0x2D3C , 0x00000000}, + {0x2D40 , 0x00000000}, + {0x2D44 , 0x00000000}, + {0x2D48 , 0x00000000}, + {0x2D4C , 0x00000000}, + {0x2D50 , 0x00000000}, + {0x2D54 , 0x00000000}, + {0x2D58 , 0x00000000}, + {0x2D5C , 0x00000000}, + {0x2D60 , 0x00000000}, + {0x2D64 , 0x00000000}, + {0x2D68 , 0x00000000}, + {0x2D6C , 0x00000000}, + {0x2D70 , 0x00000000}, + {0x2D74 , 0x00000000}, + {0x2D78 , 0x00000000}, + {0x2D7C , 0x00000000}, + {0x2D80 , 0x00000000}, + {0x2D84 , 0x00000000}, + {0x2D88 , 0x00000000}, + {0x2D8C , 0x00000000}, + {0x2D90 , 0x00000000}, + {0x2D94 , 0x00000000}, + {0x2D98 , 0x00000000}, + {0x2D9C , 0x00000000}, + {0x2DA0 , 0x00000000}, + {0x2DA4 , 0x00000000}, + {0x2DA8 , 0x00000000}, + {0x2DAC , 0x00000000}, + {0x2DB0 , 0x00000000}, + {0x2DB4 , 0x00000000}, + {0x2DB8 , 0x00000000}, + {0x2DBC , 0x00000000}, + {0x2DC0 , 0x00000000}, + {0x2DC4 , 0x00000000}, + {0x2DC8 , 0x00000000}, + {0x2DCC , 0x00000000}, + {0x2DD0 , 0x00000000}, + {0x2DD4 , 0x00100010}, + {0x2DD8 , 0x00100010}, + {0x2DDC , 0x00000000}, + {0x2DE0 , 0x00000000}, + {0x2DE4 , 0x00000000}, + {0x2DE8 , 0x00000000}, + {0x2DEC , 0x00000000}, + {0x2DF0 , 0x00000000}, + {0x2DF4 , 0x00000000}, + {0x2DF8 , 0x00000000}, + {0x2DFC , 0x00000000}, + {0x2E00 , 0x00000000}, + {0x2E04 , 0x00000000}, + {0x2E08 , 0x00000000}, + {0x2E0C , 0x00000000}, + {0x2E10 , 0x00000000}, + {0x2E14 , 0x00000000}, + {0x2E18 , 0x00000000}, + {0x2E1C , 0x00000000}, + {0x2E20 , 0x00000000}, + {0x2E24 , 0x00000000}, + {0x2E28 , 0x00000000}, + {0x2E2C , 0x00000000}, + {0x2E30 , 0x00000000}, + {0x2E34 , 0x00000000}, + {0x2E38 , 0x00000000}, + {0x2E3C , 0x00000000}, + {0x2E40 , 0x00000000}, + {0x2E44 , 0x00000000}, + {0x2E48 , 0x00000000}, + {0x2E4C , 0x00000000}, + {0x2E50 , 0x00000000}, + {0x2E54 , 0x00000000}, + {0x2E58 , 0x00000000}, + {0x2E5C , 0x00000000}, + {0x2E60 , 0x00000000}, + {0x2E64 , 0x00000000}, + {0x2E68 , 0x00000000}, + {0x2E6C , 0x00000000}, + {0x2E70 , 0x00000000}, + {0x2E74 , 0x00000000}, + {0x2E78 , 0x00000000}, + {0x2E7C , 0x00000000}, + {0x2E80 , 0x00000000}, + {0x2E84 , 0x00000000}, + {0x2E88 , 0x00000000}, + {0x2E8C , 0x00000000}, + {0x2E90 , 0x00000000}, + {0x2E94 , 0x00000000}, + {0x2E98 , 0x00000000}, + {0x2E9C , 0x00000000}, + {0x2EA0 , 0x00000000}, + {0x2EA4 , 0x00000000}, + {0x2EA8 , 0x00000000}, + {0x2EAC , 0x00000000}, + {0x2EB0 , 0x00000000}, + {0x2EB4 , 0x00000000}, + {0x2EB8 , 0x00000000}, + {0x2EBC , 0x00000000}, + {0x2EC0 , 0x00000000}, + {0x2EC4 , 0x00000000}, + {0x2EC8 , 0x00000000}, + {0x2ECC , 0x00000000}, + {0x2ED0 , 0x00000000}, + {0x2ED4 , 0x00000000}, + {0x2ED8 , 0x00000000}, + {0x2EDC , 0x00000000}, + {0x2EE0 , 0x00000000}, + {0x2EE4 ,0x00000000}, + {0x2EE8 ,0x00000000}, + {0x2EEC , 0x00000000}, + {0x2EF0 , 0x00000000}, + {0x2EF4 , 0x00000000}, + {0x2EF8 , 0x00000000}, + {0x2EFC , 0x00000000}, + /*{0x2F60 , 0x00000000},*/ +}; + +int initRegDataNum=sizeof(initRegData)/sizeof(RegData); + +typedef union { + unsigned int i; + float f; +} dmaBufRec, *dmaBuf; + +void Init3D( tridentContextPtr tmesa ) +{ + unsigned char *MMIO = tmesa->tridentScreen->mmio.map; + int i; + + for(i=0;i<initRegDataNum;++i) + MMIO_OUT32(MMIO, initRegData[i].addr, initRegData[i].data); +} + +int DrawTriangle( tridentContextPtr tmesa) +{ + unsigned char *MMIO = tmesa->tridentScreen->mmio.map; + dmaBufRec clr; + +printf("DRAW TRI\n"); + Init3D(tmesa); + +printf("ENGINE STATUS 0x%x\n",MMIO_IN32(MMIO, 0x2800)); + MMIO_OUT32(MMIO, 0x002800, 0x00000000 ); +#if 0 + MMIO_OUT32(MMIO, 0x002368 , MMIO_IN32(MMIO,0x002368)|1 ); +#endif + + MMIO_OUT32(MMIO, 0x002C00 , 0x00000014 ); +#if 0 + MMIO_OUT32(MMIO, 0x002C04 , 0x0A8004C0 ); +#else + MMIO_OUT32(MMIO, 0x002C04 , 0x0A8000C0 ); +#endif + +#if 0 + MMIO_OUT32(MMIO, 0x002C08 , 0x00000000 ); + MMIO_OUT32(MMIO, 0x002C0C , 0xFFCCCCCC ); + MMIO_OUT32(MMIO, 0x002C10 , 0x3F800000 ); + MMIO_OUT32(MMIO, 0x002C14 , 0x3D0D3DCB ); + MMIO_OUT32(MMIO, 0x002C2C , 0x70000000 ); + MMIO_OUT32(MMIO, 0x002C24 , 0x00202C00 ); + MMIO_OUT32(MMIO, 0x002C28 , 0xE0002500 ); + MMIO_OUT32(MMIO, 0x002C30 , 0x00000000 ); + MMIO_OUT32(MMIO, 0x002C34 , 0xE0000000 ); + MMIO_OUT32(MMIO, 0x002C38 , 0x00000000 ); +#endif + + MMIO_OUT32(MMIO, 0x002C50 , 0x00000000 ); + MMIO_OUT32(MMIO, 0x002C54 , 0x0C320C80 ); + MMIO_OUT32(MMIO, 0x002C50 , 0x00000000 ); + MMIO_OUT32(MMIO, 0x002C54 , 0x0C320C80 ); + MMIO_OUT32(MMIO, 0x002C80 , 0x20008258 ); + MMIO_OUT32(MMIO, 0x002C84 , 0x20000320 ); + MMIO_OUT32(MMIO, 0x002C94 , 0xFFFFFFFF ); + +#if 0 + MMIO_OUT32(MMIO, 0x002D00 , 0x00009009 ); + MMIO_OUT32(MMIO, 0x002D38 , 0x00000000 ); + MMIO_OUT32(MMIO, 0x002D94 , 0x20002000 ); + MMIO_OUT32(MMIO, 0x002D50 , 0xf0000000 ); + MMIO_OUT32(MMIO, 0x002D80 , 0x24002000 ); + MMIO_OUT32(MMIO, 0x002D98 , 0x81000000 ); + MMIO_OUT32(MMIO, 0x002DB0 , 0x81000000 ); + MMIO_OUT32(MMIO, 0x002DC8 , 0x808000FF ); + MMIO_OUT32(MMIO, 0x002DD4 , 0x02000200 ); + MMIO_OUT32(MMIO, 0x002DD8 , 0x02000200 ); + MMIO_OUT32(MMIO, 0x002D30 , 0x02092400 ); + MMIO_OUT32(MMIO, 0x002D04 , 0x00102120 ); + MMIO_OUT32(MMIO, 0x002D08 , 0xFFFFFFFF ); + MMIO_OUT32(MMIO, 0x002D0C , 0xF00010D0 ); + MMIO_OUT32(MMIO, 0x002D10 , 0xC0000400 ); +#endif + + MMIO_OUT32(MMIO, 0x002814, 0x00000000 ); +#if 0 + MMIO_OUT32(MMIO, 0x002818 , 0x00036C20 ); +#else + MMIO_OUT32(MMIO, 0x002818 , 0x00036020 ); +#endif + MMIO_OUT32(MMIO, 0x00281C , 0x00098081 ); + +printf("first TRI\n"); + clr.f = 5.0; + MMIO_OUT32(MMIO, 0x002820 , clr.i ); + clr.f = 595.0; + MMIO_OUT32(MMIO, 0x002824 , clr.i ); + clr.f = 1.0; + MMIO_OUT32(MMIO, 0x002828 , clr.i ); + MMIO_OUT32(MMIO, 0x00282C , 0x00FF00 ); +#if 0 + clr.f = 0.0; + MMIO_OUT32(MMIO, 0x002830 , clr.i ); + clr.f = 1.0; + MMIO_OUT32(MMIO, 0x002834 , clr.i ); +#endif + + clr.f = 5.0; + MMIO_OUT32(MMIO, 0x002820 , clr.i ); + clr.f = 5.0; + MMIO_OUT32(MMIO, 0x002824 , clr.i ); + clr.f = 1.0; + MMIO_OUT32(MMIO, 0x002828 , clr.i ); + MMIO_OUT32(MMIO, 0x00282C , 0xFF0000 ); +#if 0 + clr.f = 0.0; + MMIO_OUT32(MMIO, 0x002830 , clr.i ); + clr.f = 0.0; + MMIO_OUT32(MMIO, 0x002834 , clr.i ); +#endif + + clr.f = 395.0; +printf("0x%x\n",clr.i); + MMIO_OUT32(MMIO, 0x002820 , clr.i ); + clr.f = 5.0; + MMIO_OUT32(MMIO, 0x002824 , clr.i ); + clr.f = 1.0; + MMIO_OUT32(MMIO, 0x002828 , clr.i ); + MMIO_OUT32(MMIO, 0x00282C , 0xFF ); +#if 0 + clr.f = 1.0; + MMIO_OUT32(MMIO, 0x002830 , clr.i ); + clr.f = 0.0; + MMIO_OUT32(MMIO, 0x002834 , clr.i ); +#endif + +printf("sec TRI\n"); + MMIO_OUT32(MMIO, 0x00281C , 0x00093980 ); + clr.f = 395.0; + MMIO_OUT32(MMIO, 0x002820 , clr.i ); + clr.f = 595.0; + MMIO_OUT32(MMIO, 0x002824 , clr.i ); + clr.f = 1.0; + MMIO_OUT32(MMIO, 0x002828 , clr.i ); + MMIO_OUT32(MMIO, 0x00282C , 0x00FF00 ); +#if 0 + clr.f = 1.0; + MMIO_OUT32(MMIO, 0x002830 , clr.i ); + clr.f = 1.0; + MMIO_OUT32(MMIO, 0x002834 , clr.i ); +#endif + +#if 0 + MMIO_OUT32(MMIO, 0x002368 , MMIO_IN32(MMIO,0x002368)&0xfffffffe ); +#endif + +printf("fin TRI\n"); + + return 0; +} + +static INLINE void trident_draw_point(tridentContextPtr tmesa, + const tridentVertex *v0 ) +{ + unsigned char *MMIO = tmesa->tridentScreen->mmio.map; + (void) MMIO; +} + +static INLINE void trident_draw_line( tridentContextPtr tmesa, + const tridentVertex *v0, + const tridentVertex *v1 ) +{ + unsigned char *MMIO = tmesa->tridentScreen->mmio.map; + (void) MMIO; +} + +static INLINE void trident_draw_triangle( tridentContextPtr tmesa, + const tridentVertex *v0, + const tridentVertex *v1, + const tridentVertex *v2 ) +{ +} + +static INLINE void trident_draw_quad( tridentContextPtr tmesa, + const tridentVertex *v0, + const tridentVertex *v1, + const tridentVertex *v2, + const tridentVertex *v3 ) +{ + GLuint vertsize = tmesa->vertex_size; + GLint coloridx = (vertsize > 4) ? 4 : 3; + unsigned char *MMIO = tmesa->tridentScreen->mmio.map; + int clr; + float *ftmp = (float *)(&clr); + + if (tmesa->dirty) + tridentUploadHwStateLocked( tmesa ); +#if 0 + DrawTriangle(tmesa); + exit(0); +#else +#if 1 + if (first) { + Init3D(tmesa); +#if 0 + DrawTriangle(tmesa); +#endif + first = 0; + } +#endif + + LOCK_HARDWARE( tmesa ); + + MMIO_OUT32(MMIO, 0x002C00 , 0x00000010 ); + MMIO_OUT32(MMIO, 0x002C04 , 0x029C00C0 ); + + /* Z buffer */ + MMIO_OUT32(MMIO, 0x002C24 , 0x00100000 /*| (tmesa->tridentScreen->depthOffset)*/ ); + MMIO_OUT32(MMIO, 0x002C28 , 0xE0000000 | (tmesa->tridentScreen->depthPitch * 4) ); + + /* front buffer */ + MMIO_OUT32(MMIO, 0x002C50 , 0x00000000 | (tmesa->drawOffset) ); + MMIO_OUT32(MMIO, 0x002C54 , 0x0C320000 | (tmesa->drawPitch * 4) ); + + /* clipper */ + MMIO_OUT32(MMIO, 0x002C80 , 0x20008000 | tmesa->tridentScreen->height ); + MMIO_OUT32(MMIO, 0x002C84 , 0x20000000 | tmesa->tridentScreen->width ); + + /* writemask */ + MMIO_OUT32(MMIO, 0x002C94 , 0xFFFFFFFF ); + +if (vertsize == 4) { + MMIO_OUT32(MMIO, 0x002818 , 0x0003A020 ); + MMIO_OUT32(MMIO, 0x00281C , 0x00098021 ); + + *ftmp = v0->v.x; + MMIO_OUT32(MMIO, 0x002820 , clr ); + *ftmp = v0->v.y; + MMIO_OUT32(MMIO, 0x002824 , clr ); + *ftmp = v0->v.z; + MMIO_OUT32(MMIO, 0x002828 , clr ); +#if 0 + *ftmp = v0->v.w; + MMIO_OUT32(MMIO, 0x00282C , clr ); +#endif + MMIO_OUT32(MMIO, 0x00282C , v0->ui[coloridx] ); + + *ftmp = v1->v.x; + MMIO_OUT32(MMIO, 0x002820 , clr ); + *ftmp = v1->v.y; + MMIO_OUT32(MMIO, 0x002824 , clr ); + *ftmp = v1->v.z; + MMIO_OUT32(MMIO, 0x002828 , clr ); +#if 0 + *ftmp = v1->v.w; + MMIO_OUT32(MMIO, 0x00282C , clr ); +#endif + MMIO_OUT32(MMIO, 0x00282C , v1->ui[coloridx] ); + + *ftmp = v2->v.x; + MMIO_OUT32(MMIO, 0x002820 , clr ); + *ftmp = v2->v.y; + MMIO_OUT32(MMIO, 0x002824 , clr ); + *ftmp = v2->v.z; + MMIO_OUT32(MMIO, 0x002828 , clr ); +#if 0 + *ftmp = v2->v.w; + MMIO_OUT32(MMIO, 0x00282C , clr ); +#endif + MMIO_OUT32(MMIO, 0x00282C , v2->ui[coloridx] ); + + MMIO_OUT32(MMIO, 0x00281C , 0x00093020 ); + *ftmp = v3->v.x; + MMIO_OUT32(MMIO, 0x002820 , clr ); + *ftmp = v3->v.y; + MMIO_OUT32(MMIO, 0x002824 , clr ); + *ftmp = v3->v.z; + MMIO_OUT32(MMIO, 0x002828 , clr ); +#if 0 + *ftmp = v3->v.w; + MMIO_OUT32(MMIO, 0x00282C , clr ); +#endif + MMIO_OUT32(MMIO, 0x00282C , v3->ui[coloridx] ); + +} +#endif + + UNLOCK_HARDWARE( tmesa ); +} +/*********************************************************************** + * 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. + */ +#if 0 +static void +trident_fallback_quad( tridentContextPtr tmesa, + const tridentVertex *v0, + const tridentVertex *v1, + const tridentVertex *v2, + const tridentVertex *v3 ) +{ + GLcontext *ctx = tmesa->glCtx; + SWvertex v[4]; + trident_translate_vertex( ctx, v0, &v[0] ); + trident_translate_vertex( ctx, v1, &v[1] ); + trident_translate_vertex( ctx, v2, &v[2] ); + trident_translate_vertex( ctx, v3, &v[3] ); + _swrast_Quad( ctx, &v[0], &v[1], &v[2], &v[3] ); +} +#endif + +/* XXX hack to get the prototype defined in time... */ +void trident_translate_vertex(GLcontext *ctx, const tridentVertex *src, + SWvertex *dst); + +static void +trident_fallback_tri( tridentContextPtr tmesa, + const tridentVertex *v0, + const tridentVertex *v1, + const tridentVertex *v2 ) +{ + GLcontext *ctx = tmesa->glCtx; + SWvertex v[3]; + trident_translate_vertex( ctx, v0, &v[0] ); + trident_translate_vertex( ctx, v1, &v[1] ); + trident_translate_vertex( ctx, v2, &v[2] ); + _swrast_Triangle( ctx, &v[0], &v[1], &v[2] ); +} + +static void +trident_fallback_line( tridentContextPtr tmesa, + const tridentVertex *v0, + const tridentVertex *v1 ) +{ + GLcontext *ctx = tmesa->glCtx; + SWvertex v[2]; + trident_translate_vertex( ctx, v0, &v[0] ); + trident_translate_vertex( ctx, v1, &v[1] ); + _swrast_Line( ctx, &v[0], &v[1] ); +} + + +static void +trident_fallback_point( tridentContextPtr tmesa, + const tridentVertex *v0 ) +{ + GLcontext *ctx = tmesa->glCtx; + SWvertex v[1]; + trident_translate_vertex( ctx, v0, &v[0] ); + _swrast_Point( ctx, &v[0] ); +} + +/*********************************************************************** + * Macros for t_dd_tritmp.h to draw basic primitives * + ***********************************************************************/ + +#define TRI( a, b, c ) \ +do { \ + if (DO_FALLBACK) \ + tmesa->draw_tri( tmesa, a, b, c ); \ + else \ + trident_draw_triangle( tmesa, a, b, c ); \ +} while (0) + +#define QUAD( a, b, c, d ) \ +do { \ + if (DO_FALLBACK) { \ + tmesa->draw_tri( tmesa, a, b, d ); \ + tmesa->draw_tri( tmesa, b, c, d ); \ + } else \ + trident_draw_quad( tmesa, a, b, c, d ); \ +} while (0) + +#define LINE( v0, v1 ) \ +do { \ + if (DO_FALLBACK) \ + tmesa->draw_line( tmesa, v0, v1 ); \ + else \ + trident_draw_line( tmesa, v0, v1 ); \ +} while (0) + +#define POINT( v0 ) \ +do { \ + if (DO_FALLBACK) \ + tmesa->draw_point( tmesa, v0 ); \ + else \ + trident_draw_point( tmesa, v0 ); \ +} while (0) + +/*********************************************************************** + * Build render functions from dd templates * + ***********************************************************************/ + +#define TRIDENT_OFFSET_BIT 0x01 +#define TRIDENT_TWOSIDE_BIT 0x02 +#define TRIDENT_UNFILLED_BIT 0x04 +#define TRIDENT_FALLBACK_BIT 0x08 +#define TRIDENT_MAX_TRIFUNC 0x10 + + +static struct { + tnl_points_func points; + tnl_line_func line; + tnl_triangle_func triangle; + tnl_quad_func quad; +} rast_tab[TRIDENT_MAX_TRIFUNC]; + + +#define DO_FALLBACK (IND & TRIDENT_FALLBACK_BIT) +#define DO_OFFSET (IND & TRIDENT_OFFSET_BIT) +#define DO_UNFILLED (IND & TRIDENT_UNFILLED_BIT) +#define DO_TWOSIDE (IND & TRIDENT_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 tridentVertex +#define TAB rast_tab + +#define DEPTH_SCALE 1.0 +#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) (tmesa->verts + (e<<tmesa->vertex_stride_shift)) + +#define TRIDENT_COLOR( dst, src ) \ +do { \ + dst[0] = src[2]; \ + dst[1] = src[1]; \ + dst[2] = src[0]; \ + dst[3] = src[3]; \ +} while (0) + +#define TRIDENT_SPEC( dst, src ) \ +do { \ + dst[0] = src[2]; \ + dst[1] = src[1]; \ + dst[2] = src[0]; \ +} while (0) + +#define VERT_SET_RGBA( v, c ) TRIDENT_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) TRIDENT_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) \ + tridentContextPtr tmesa = TRIDENT_CONTEXT(ctx); \ + GLuint color[n], spec[n]; \ + GLuint coloroffset = (tmesa->vertex_size == 4 ? 3 : 4); \ + GLboolean havespec = (tmesa->vertex_size == 4 ? 0 : 1); \ + (void) color; (void) spec; (void) coloroffset; (void) havespec; +/*********************************************************************** + * Helpers for rendering unfilled primitives * + ***********************************************************************/ +#if 0 +static const GLuint hw_prim[GL_POLYGON+1] = { + B_PrimType_Points, + B_PrimType_Lines, + B_PrimType_Lines, + B_PrimType_Lines, + B_PrimType_Triangles, + B_PrimType_Triangles, + B_PrimType_Triangles, + B_PrimType_Triangles, + B_PrimType_Triangles, + B_PrimType_Triangles +}; +#endif + +static void tridentResetLineStipple( GLcontext *ctx ); +#if 0 +static void tridentRasterPrimitive( GLcontext *ctx, GLuint hwprim ); +#endif +static void tridentRenderPrimitive( GLcontext *ctx, GLenum prim ); + +#define RASTERIZE(x) /*if (tmesa->hw_primitive != hw_prim[x]) \ + tridentRasterPrimitive( ctx, hw_prim[x] ) */ +#define RENDER_PRIMITIVE tmesa->render_primitive +#define TAG(x) x +#define IND TRIDENT_FALLBACK_BIT +#include "tnl_dd/t_dd_unfilled.h" +#undef IND + +/*********************************************************************** + * Generate GL render functions * + ***********************************************************************/ + +#define IND (0) +#define TAG(x) x +#include "tnl_dd/t_dd_tritmp.h" + +#define IND (TRIDENT_OFFSET_BIT) +#define TAG(x) x##_offset +#include "tnl_dd/t_dd_tritmp.h" + +#define IND (TRIDENT_TWOSIDE_BIT) +#define TAG(x) x##_twoside +#include "tnl_dd/t_dd_tritmp.h" + +#define IND (TRIDENT_TWOSIDE_BIT|TRIDENT_OFFSET_BIT) +#define TAG(x) x##_twoside_offset +#include "tnl_dd/t_dd_tritmp.h" + +#define IND (TRIDENT_UNFILLED_BIT) +#define TAG(x) x##_unfilled +#include "tnl_dd/t_dd_tritmp.h" + +#define IND (TRIDENT_OFFSET_BIT|TRIDENT_UNFILLED_BIT) +#define TAG(x) x##_offset_unfilled +#include "tnl_dd/t_dd_tritmp.h" + +#define IND (TRIDENT_TWOSIDE_BIT|TRIDENT_UNFILLED_BIT) +#define TAG(x) x##_twoside_unfilled +#include "tnl_dd/t_dd_tritmp.h" + +#define IND (TRIDENT_TWOSIDE_BIT|TRIDENT_OFFSET_BIT|TRIDENT_UNFILLED_BIT) +#define TAG(x) x##_twoside_offset_unfilled +#include "tnl_dd/t_dd_tritmp.h" + +#define IND (TRIDENT_FALLBACK_BIT) +#define TAG(x) x##_fallback +#include "tnl_dd/t_dd_tritmp.h" + +#define IND (TRIDENT_OFFSET_BIT|TRIDENT_FALLBACK_BIT) +#define TAG(x) x##_offset_fallback +#include "tnl_dd/t_dd_tritmp.h" + +#define IND (TRIDENT_TWOSIDE_BIT|TRIDENT_FALLBACK_BIT) +#define TAG(x) x##_twoside_fallback +#include "tnl_dd/t_dd_tritmp.h" + +#define IND (TRIDENT_TWOSIDE_BIT|TRIDENT_OFFSET_BIT|TRIDENT_FALLBACK_BIT) +#define TAG(x) x##_twoside_offset_fallback +#include "tnl_dd/t_dd_tritmp.h" + +#define IND (TRIDENT_UNFILLED_BIT|TRIDENT_FALLBACK_BIT) +#define TAG(x) x##_unfilled_fallback +#include "tnl_dd/t_dd_tritmp.h" + +#define IND (TRIDENT_OFFSET_BIT|TRIDENT_UNFILLED_BIT|TRIDENT_FALLBACK_BIT) +#define TAG(x) x##_offset_unfilled_fallback +#include "tnl_dd/t_dd_tritmp.h" + +#define IND (TRIDENT_TWOSIDE_BIT|TRIDENT_UNFILLED_BIT|TRIDENT_FALLBACK_BIT) +#define TAG(x) x##_twoside_unfilled_fallback +#include "tnl_dd/t_dd_tritmp.h" + +#define IND (TRIDENT_TWOSIDE_BIT|TRIDENT_OFFSET_BIT|TRIDENT_UNFILLED_BIT|TRIDENT_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_offset(); + init_twoside(); + init_twoside_offset(); + 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(); +} + + +/**********************************************************************/ +/* Render unclipped begin/end objects */ +/**********************************************************************/ + +#define VERT(x) (tridentVertex *)(tridentverts + (x << shift)) +#define RENDER_POINTS( start, count ) \ + for ( ; start < count ; start++) \ + trident_draw_point( tmesa, VERT(start) ) +#define RENDER_LINE( v0, v1 ) \ + trident_draw_line( tmesa, VERT(v0), VERT(v1) ) +#define RENDER_TRI( v0, v1, v2 ) \ + trident_draw_triangle( tmesa, VERT(v0), VERT(v1), VERT(v2) ) +#define RENDER_QUAD( v0, v1, v2, v3 ) \ + trident_draw_quad( tmesa, VERT(v0), VERT(v1), VERT(v2), VERT(v3) ) +#define INIT(x) tridentRenderPrimitive( ctx, x ); +#undef LOCAL_VARS +#define LOCAL_VARS \ + tridentContextPtr tmesa = TRIDENT_CONTEXT(ctx); \ + const GLuint shift = tmesa->vertex_stride_shift; \ + const char *tridentverts = (char *)tmesa->verts; \ + const GLboolean stipple = ctx->Line.StippleFlag; \ + const GLuint * const elt = TNL_CONTEXT(ctx)->vb.Elts; \ + (void) elt; +#define RESET_STIPPLE if ( stipple ) tridentResetLineStipple( ctx ); +#define RESET_OCCLUSION +#define PRESERVE_VB_DEFS +#define ELT(x) (x) +#define TAG(x) trident_##x##_verts +#include "tnl/t_vb_rendertmp.h" +#undef ELT +#undef TAG +#define TAG(x) trident_##x##_elts +#define ELT(x) elt[x] +#include "tnl/t_vb_rendertmp.h" + +/**********************************************************************/ +/* Render clipped primitives */ +/**********************************************************************/ + +static void tridentRenderClippedPoly( GLcontext *ctx, const GLuint *elts, + GLuint n ) +{ + tridentContextPtr tmesa = TRIDENT_CONTEXT(ctx); + struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb; + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLuint prim = tmesa->render_primitive; + + /* 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 tridentRenderClippedLine( GLcontext *ctx, GLuint ii, GLuint jj ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + tnl->Driver.Render.Line( ctx, ii, jj ); +} + + +/**********************************************************************/ +/* Choose render functions */ +/**********************************************************************/ + +#define _TRIDENT_NEW_RENDER_STATE (_DD_NEW_LINE_STIPPLE | \ + _DD_NEW_LINE_SMOOTH | \ + _DD_NEW_POINT_SMOOTH | \ + _DD_NEW_TRI_SMOOTH | \ + _DD_NEW_TRI_UNFILLED | \ + _DD_NEW_TRI_LIGHT_TWOSIDE | \ + _DD_NEW_TRI_OFFSET) \ + + +#define POINT_FALLBACK (DD_POINT_SMOOTH) +#define LINE_FALLBACK (DD_LINE_STIPPLE|DD_LINE_SMOOTH) +#define TRI_FALLBACK (DD_TRI_SMOOTH) +#define ANY_FALLBACK_FLAGS (POINT_FALLBACK|LINE_FALLBACK|TRI_FALLBACK) +#define ANY_RASTER_FLAGS (DD_TRI_LIGHT_TWOSIDE|DD_TRI_OFFSET|DD_TRI_UNFILLED) + + +static void tridentChooseRenderState(GLcontext *ctx) +{ + tridentContextPtr tmesa = TRIDENT_CONTEXT(ctx); + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLuint flags = ctx->_TriangleCaps; + GLuint index = 0; + + if (flags & (ANY_RASTER_FLAGS|ANY_FALLBACK_FLAGS)) { + tmesa->draw_point = trident_draw_point; + tmesa->draw_line = trident_draw_line; + tmesa->draw_tri = trident_draw_triangle; + + if (flags & ANY_RASTER_FLAGS) { + if (flags & DD_TRI_LIGHT_TWOSIDE) index |= TRIDENT_TWOSIDE_BIT; + if (flags & DD_TRI_OFFSET) index |= TRIDENT_OFFSET_BIT; + if (flags & DD_TRI_UNFILLED) index |= TRIDENT_UNFILLED_BIT; + } + + /* Hook in fallbacks for specific primitives. + */ + if (flags & (POINT_FALLBACK|LINE_FALLBACK|TRI_FALLBACK)) { + if (flags & POINT_FALLBACK) tmesa->draw_point = trident_fallback_point; + if (flags & LINE_FALLBACK) tmesa->draw_line = trident_fallback_line; + if (flags & TRI_FALLBACK) tmesa->draw_tri = trident_fallback_tri; + index |= TRIDENT_FALLBACK_BIT; + } + } + + if (tmesa->RenderIndex != index) { + tmesa->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 (tmesa->RenderIndex == 0) { + tnl->Driver.Render.PrimTabVerts = trident_render_tab_verts; + tnl->Driver.Render.PrimTabElts = trident_render_tab_elts; + } else { + tnl->Driver.Render.PrimTabVerts = _tnl_render_tab_verts; + tnl->Driver.Render.PrimTabElts = _tnl_render_tab_elts; + } + tnl->Driver.Render.ClippedLine = tridentRenderClippedLine; + tnl->Driver.Render.ClippedPolygon = tridentRenderClippedPoly; + } +} + + +/**********************************************************************/ +/* 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 tridentrender.c. + */ +#if 0 +static void tridentRasterPrimitive( GLcontext *ctx, GLuint hwprim ) +{ + tridentContextPtr tmesa = TRIDENT_CONTEXT(ctx); + if (tmesa->hw_primitive != hwprim) + tmesa->hw_primitive = hwprim; +} +#endif + +static void tridentRenderPrimitive( GLcontext *ctx, GLenum prim ) +{ + tridentContextPtr tmesa = TRIDENT_CONTEXT(ctx); + tmesa->render_primitive = prim; +} + +static void tridentRunPipeline( GLcontext *ctx ) +{ + tridentContextPtr tmesa = TRIDENT_CONTEXT(ctx); + + if ( tmesa->new_state ) + tridentDDUpdateHWState( ctx ); + + if (tmesa->new_gl_state) { +#if 0 + if (tmesa->new_gl_state & _NEW_TEXTURE) + tridentUpdateTextureState( ctx ); +#endif + + if (!tmesa->Fallback) { + if (tmesa->new_gl_state & _TRIDENT_NEW_VERTEX) + tridentChooseVertexState( ctx ); + + if (tmesa->new_gl_state & _TRIDENT_NEW_RENDER_STATE) + tridentChooseRenderState( ctx ); + } + + tmesa->new_gl_state = 0; + } + + _tnl_run_pipeline( ctx ); +} + +static void tridentRenderStart( GLcontext *ctx ) +{ + /* Check for projective texturing. Make sure all texcoord + * pointers point to something. (fix in mesa?) + */ + tridentCheckTexSizes( ctx ); +} + +static void tridentRenderFinish( GLcontext *ctx ) +{ + if (0) + _swrast_flush( ctx ); /* never needed */ +} + +static void tridentResetLineStipple( GLcontext *ctx ) +{ + tridentContextPtr tmesa = TRIDENT_CONTEXT(ctx); + (void) tmesa; + + /* Reset the hardware stipple counter. + */ +} + + +/**********************************************************************/ +/* Transition to/from hardware rasterization. */ +/**********************************************************************/ + + +void tridentFallback( tridentContextPtr tmesa, GLuint bit, GLboolean mode ) +{ + GLcontext *ctx = tmesa->glCtx; + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLuint oldfallback = tmesa->Fallback; + + _tnl_need_projected_coords( ctx, GL_FALSE ); + + if (mode) { + tmesa->Fallback |= bit; + if (oldfallback == 0) { + _swsetup_Wakeup( ctx ); + tmesa->RenderIndex = ~0; + } + } + else { + tmesa->Fallback &= ~bit; + if (oldfallback == bit) { + _swrast_flush( ctx ); + tnl->Driver.Render.Start = tridentRenderStart; + tnl->Driver.Render.PrimitiveNotify = tridentRenderPrimitive; + tnl->Driver.Render.Finish = tridentRenderFinish; + tnl->Driver.Render.BuildVertices = tridentBuildVertices; + tnl->Driver.Render.ResetLineStipple = tridentResetLineStipple; + tmesa->new_gl_state |= (_TRIDENT_NEW_RENDER_STATE| + _TRIDENT_NEW_VERTEX); + } + } +} + + +/**********************************************************************/ +/* Initialization. */ +/**********************************************************************/ + + +void tridentDDInitTriFuncs( GLcontext *ctx ) +{ + tridentContextPtr tmesa = TRIDENT_CONTEXT(ctx); + TNLcontext *tnl = TNL_CONTEXT(ctx); + static int firsttime = 1; + + if (firsttime) { + init_rast_tab(); + firsttime = 0; + } + + tmesa->RenderIndex = ~0; + + tnl->Driver.RunPipeline = tridentRunPipeline; + tnl->Driver.Render.Start = tridentRenderStart; + tnl->Driver.Render.Finish = tridentRenderFinish; + tnl->Driver.Render.PrimitiveNotify = tridentRenderPrimitive; + tnl->Driver.Render.ResetLineStipple = tridentResetLineStipple; + tnl->Driver.Render.BuildVertices = tridentBuildVertices; +} diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/trident/trident_vb.c b/nx-X11/extras/Mesa/src/mesa/drivers/dri/trident/trident_vb.c new file mode 100644 index 000000000..77e4d9b76 --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/trident/trident_vb.c @@ -0,0 +1,434 @@ +/* + * Copyright 2002 by Alan Hourihane, Sychdyn, North Wales, UK. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Alan Hourihane not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Alan Hourihane makes no representations + * about the suitability of this software for any purpose. It is provided + * "as is" without express or implied warranty. + * + * ALAN HOURIHANE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL ALAN HOURIHANE BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + * + * Authors: Alan Hourihane, <alanh@fairlite.demon.co.uk> + * + * Trident CyberBladeXP driver. + * + */ +#include "glheader.h" +#include "mtypes.h" +#include "macros.h" +#include "colormac.h" + +#include "swrast_setup/swrast_setup.h" +#include "swrast/swrast.h" +#include "tnl/t_context.h" +#include "tnl/tnl.h" + +#include "trident_context.h" + +#define TRIDENT_TEX1_BIT 0x1 +#define TRIDENT_TEX0_BIT 0x2 +#define TRIDENT_RGBA_BIT 0x4 +#define TRIDENT_SPEC_BIT 0x8 +#define TRIDENT_FOG_BIT 0x10 +#define TRIDENT_XYZW_BIT 0x20 +#define TRIDENT_PTEX_BIT 0x40 +#define TRIDENT_MAX_SETUP 0x80 + +static struct { + void (*emit)( GLcontext *, GLuint, GLuint, void *, GLuint ); + tnl_interp_func interp; + tnl_copy_pv_func copy_pv; + GLboolean (*check_tex_sizes)( GLcontext *ctx ); + GLuint vertex_size; + GLuint vertex_stride_shift; + GLuint vertex_format; +} setup_tab[TRIDENT_MAX_SETUP]; + +#define TINY_VERTEX_FORMAT 1 +#define NOTEX_VERTEX_FORMAT 2 +#define TEX0_VERTEX_FORMAT 3 +#define TEX1_VERTEX_FORMAT 4 +#define PROJ_TEX1_VERTEX_FORMAT 5 +#define TEX2_VERTEX_FORMAT 6 +#define TEX3_VERTEX_FORMAT 7 +#define PROJ_TEX3_VERTEX_FORMAT 8 + +#define DO_XYZW (IND & TRIDENT_XYZW_BIT) +#define DO_RGBA (IND & TRIDENT_RGBA_BIT) +#define DO_SPEC (IND & TRIDENT_SPEC_BIT) +#define DO_FOG (IND & TRIDENT_FOG_BIT) +#define DO_TEX0 (IND & TRIDENT_TEX0_BIT) +#define DO_TEX1 (IND & TRIDENT_TEX1_BIT) +#define DO_TEX2 0 +#define DO_TEX3 0 +#define DO_PTEX (IND & TRIDENT_PTEX_BIT) + +#define VERTEX tridentVertex +#define VERTEX_COLOR trident_color_t +#define LOCALVARS tridentContextPtr tmesa = TRIDENT_CONTEXT(ctx); +#define GET_VIEWPORT_MAT() tmesa->hw_viewport +#define GET_TEXSOURCE(n) tmesa->tmu_source[n] +#define GET_VERTEX_FORMAT() tmesa->vertex_format +#define GET_VERTEX_SIZE() tmesa->vertex_size +#define GET_VERTEX_STORE() tmesa->verts +#define GET_VERTEX_STRIDE_SHIFT() tmesa->vertex_stride_shift +#define GET_UBYTE_COLOR_STORE() &tmesa->UbyteColor +#define GET_UBYTE_SPEC_COLOR_STORE() &tmesa->UbyteSecondaryColor + +#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 0 + +#define UNVIEWPORT_VARS \ + const GLfloat dx = - tmesa->drawX - SUBPIXEL_X; \ + const GLfloat dy = (tmesa->driDrawable->h + \ + tmesa->drawY + SUBPIXEL_Y); \ + const GLfloat sz = 1.0 / tmesa->depth_scale + +#define UNVIEWPORT_X(x) x + dx; +#define UNVIEWPORT_Y(y) - y + dy; +#define UNVIEWPORT_Z(z) z * sz; + +#define PTEX_FALLBACK() tridentFallback(TRIDENT_CONTEXT(ctx), TRIDENT_FALLBACK_TEXTURE, 1) + +#define IMPORT_FLOAT_COLORS trident_import_float_colors +#define IMPORT_FLOAT_SPEC_COLORS trident_import_float_spec_colors + +#define INTERP_VERTEX setup_tab[tmesa->SetupIndex].interp +#define COPY_PV_VERTEX setup_tab[tmesa->SetupIndex].copy_pv + +/*********************************************************************** + * Generate pv-copying and translation functions * + ***********************************************************************/ + +#define TAG(x) trident_##x +#include "tnl_dd/t_dd_vb.c" + +/*********************************************************************** + * Generate vertex emit and interp functions * + ***********************************************************************/ + +#define IND (TRIDENT_XYZW_BIT|TRIDENT_RGBA_BIT) +#define TAG(x) x##_wg +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_XYZW_BIT|TRIDENT_RGBA_BIT|TRIDENT_SPEC_BIT) +#define TAG(x) x##_wgs +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_XYZW_BIT|TRIDENT_RGBA_BIT|TRIDENT_TEX0_BIT) +#define TAG(x) x##_wgt0 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_XYZW_BIT|TRIDENT_RGBA_BIT|TRIDENT_TEX0_BIT|TRIDENT_TEX1_BIT) +#define TAG(x) x##_wgt0t1 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_XYZW_BIT|TRIDENT_RGBA_BIT|TRIDENT_TEX0_BIT|TRIDENT_PTEX_BIT) +#define TAG(x) x##_wgpt0 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_XYZW_BIT|TRIDENT_RGBA_BIT|TRIDENT_SPEC_BIT|TRIDENT_TEX0_BIT) +#define TAG(x) x##_wgst0 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_XYZW_BIT|TRIDENT_RGBA_BIT|TRIDENT_SPEC_BIT|TRIDENT_TEX0_BIT|TRIDENT_TEX1_BIT) +#define TAG(x) x##_wgst0t1 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_XYZW_BIT|TRIDENT_RGBA_BIT|TRIDENT_SPEC_BIT|TRIDENT_TEX0_BIT|TRIDENT_PTEX_BIT) +#define TAG(x) x##_wgspt0 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_XYZW_BIT|TRIDENT_RGBA_BIT|TRIDENT_FOG_BIT) +#define TAG(x) x##_wgf +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_XYZW_BIT|TRIDENT_RGBA_BIT|TRIDENT_FOG_BIT|TRIDENT_SPEC_BIT) +#define TAG(x) x##_wgfs +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_XYZW_BIT|TRIDENT_RGBA_BIT|TRIDENT_FOG_BIT|TRIDENT_TEX0_BIT) +#define TAG(x) x##_wgft0 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_XYZW_BIT|TRIDENT_RGBA_BIT|TRIDENT_FOG_BIT|TRIDENT_TEX0_BIT|TRIDENT_TEX1_BIT) +#define TAG(x) x##_wgft0t1 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_XYZW_BIT|TRIDENT_RGBA_BIT|TRIDENT_FOG_BIT|TRIDENT_TEX0_BIT|TRIDENT_PTEX_BIT) +#define TAG(x) x##_wgfpt0 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_XYZW_BIT|TRIDENT_RGBA_BIT|TRIDENT_FOG_BIT|TRIDENT_SPEC_BIT|TRIDENT_TEX0_BIT) +#define TAG(x) x##_wgfst0 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_XYZW_BIT|TRIDENT_RGBA_BIT|TRIDENT_FOG_BIT|TRIDENT_SPEC_BIT|TRIDENT_TEX0_BIT|TRIDENT_TEX1_BIT) +#define TAG(x) x##_wgfst0t1 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_XYZW_BIT|TRIDENT_RGBA_BIT|TRIDENT_FOG_BIT|TRIDENT_SPEC_BIT|TRIDENT_TEX0_BIT|TRIDENT_PTEX_BIT) +#define TAG(x) x##_wgfspt0 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_TEX0_BIT) +#define TAG(x) x##_t0 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_TEX0_BIT|TRIDENT_TEX1_BIT) +#define TAG(x) x##_t0t1 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_FOG_BIT) +#define TAG(x) x##_f +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_FOG_BIT|TRIDENT_TEX0_BIT) +#define TAG(x) x##_ft0 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_FOG_BIT|TRIDENT_TEX0_BIT|TRIDENT_TEX1_BIT) +#define TAG(x) x##_ft0t1 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_RGBA_BIT) +#define TAG(x) x##_g +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_RGBA_BIT|TRIDENT_SPEC_BIT) +#define TAG(x) x##_gs +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_RGBA_BIT|TRIDENT_TEX0_BIT) +#define TAG(x) x##_gt0 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_RGBA_BIT|TRIDENT_TEX0_BIT|TRIDENT_TEX1_BIT) +#define TAG(x) x##_gt0t1 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_RGBA_BIT|TRIDENT_SPEC_BIT|TRIDENT_TEX0_BIT) +#define TAG(x) x##_gst0 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_RGBA_BIT|TRIDENT_SPEC_BIT|TRIDENT_TEX0_BIT|TRIDENT_TEX1_BIT) +#define TAG(x) x##_gst0t1 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_RGBA_BIT|TRIDENT_FOG_BIT) +#define TAG(x) x##_gf +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_RGBA_BIT|TRIDENT_FOG_BIT|TRIDENT_SPEC_BIT) +#define TAG(x) x##_gfs +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_RGBA_BIT|TRIDENT_FOG_BIT|TRIDENT_TEX0_BIT) +#define TAG(x) x##_gft0 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_RGBA_BIT|TRIDENT_FOG_BIT|TRIDENT_TEX0_BIT|TRIDENT_TEX1_BIT) +#define TAG(x) x##_gft0t1 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_RGBA_BIT|TRIDENT_FOG_BIT|TRIDENT_SPEC_BIT|TRIDENT_TEX0_BIT) +#define TAG(x) x##_gfst0 +#include "tnl_dd/t_dd_vbtmp.h" + +#define IND (TRIDENT_RGBA_BIT|TRIDENT_FOG_BIT|TRIDENT_SPEC_BIT|TRIDENT_TEX0_BIT|TRIDENT_TEX1_BIT) +#define TAG(x) x##_gfst0t1 +#include "tnl_dd/t_dd_vbtmp.h" + +static void init_setup_tab( void ) +{ + 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(); +} + +void tridentBuildVertices( GLcontext *ctx, + GLuint start, + GLuint count, + GLuint newinputs ) +{ + tridentContextPtr tmesa = TRIDENT_CONTEXT( ctx ); + GLubyte *v = ((GLubyte *)tmesa->verts + (start<<tmesa->vertex_stride_shift)); + GLuint stride = 1<<tmesa->vertex_stride_shift; + + newinputs |= tmesa->SetupNewInputs; + tmesa->SetupNewInputs = 0; + + if (!newinputs) + return; + + if (newinputs & VERT_BIT_POS) { + setup_tab[tmesa->SetupIndex].emit( ctx, start, count, v, stride ); + } else { + GLuint ind = 0; + + if (newinputs & VERT_BIT_COLOR0) + ind |= TRIDENT_RGBA_BIT; + + if (newinputs & VERT_BIT_COLOR1) + ind |= TRIDENT_SPEC_BIT; + + if (newinputs & VERT_BIT_TEX0) + ind |= TRIDENT_TEX0_BIT; + + if (newinputs & VERT_BIT_TEX1) + ind |= TRIDENT_TEX1_BIT; + + if (newinputs & VERT_BIT_FOG) + ind |= TRIDENT_FOG_BIT; + + if (tmesa->SetupIndex & TRIDENT_PTEX_BIT) + ind = ~0; + + ind &= tmesa->SetupIndex; + + if (ind) { + setup_tab[ind].emit( ctx, start, count, v, stride ); + } + } +} + +void tridentCheckTexSizes( GLcontext *ctx ) +{ + tridentContextPtr tmesa = TRIDENT_CONTEXT( ctx ); + + if (!setup_tab[tmesa->SetupIndex].check_tex_sizes(ctx)) { + TNLcontext *tnl = TNL_CONTEXT(ctx); + + /* Invalidate stored verts + */ + tmesa->SetupNewInputs = ~0; + tmesa->SetupIndex |= TRIDENT_PTEX_BIT; + + if (!tmesa->Fallback && + !(ctx->_TriangleCaps & (DD_TRI_LIGHT_TWOSIDE|DD_TRI_UNFILLED))) { + tnl->Driver.Render.Interp = setup_tab[tmesa->SetupIndex].interp; + tnl->Driver.Render.CopyPV = setup_tab[tmesa->SetupIndex].copy_pv; + } + } +} + +void tridentChooseVertexState( GLcontext *ctx ) +{ + tridentContextPtr tmesa = TRIDENT_CONTEXT( ctx ); + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLuint ind = TRIDENT_XYZW_BIT|TRIDENT_RGBA_BIT; + + if (ctx->_TriangleCaps & DD_SEPARATE_SPECULAR) + ind |= TRIDENT_SPEC_BIT; + + if (ctx->Fog.Enabled) + ind |= TRIDENT_FOG_BIT; + + if (ctx->Texture.Unit[0]._ReallyEnabled) { + ind |= TRIDENT_TEX0_BIT; + if (ctx->Texture.Unit[1]._ReallyEnabled) { + ind |= TRIDENT_TEX1_BIT; + } + } + + tmesa->SetupIndex = ind; + + if (ctx->_TriangleCaps & (DD_TRI_LIGHT_TWOSIDE|DD_TRI_UNFILLED)) { + tnl->Driver.Render.Interp = trident_interp_extras; + tnl->Driver.Render.CopyPV = trident_copy_pv_extras; + } else { + tnl->Driver.Render.Interp = setup_tab[ind].interp; + tnl->Driver.Render.CopyPV = setup_tab[ind].copy_pv; + } + + if (setup_tab[ind].vertex_format != tmesa->vertex_format) { + tmesa->vertex_format = setup_tab[ind].vertex_format; + tmesa->vertex_size = setup_tab[ind].vertex_size; + tmesa->vertex_stride_shift = setup_tab[ind].vertex_stride_shift; + } +} + +void tridentInitVB( GLcontext *ctx ) +{ + tridentContextPtr tmesa = TRIDENT_CONTEXT(ctx); + GLuint size = TNL_CONTEXT(ctx)->vb.Size; + + tmesa->verts = (char *)ALIGN_MALLOC( size * 16 * 4, 32 ); + + { + static int firsttime = 1; + if (firsttime) { + init_setup_tab(); + firsttime = 0; + } + } +} + +void tridentFreeVB( GLcontext *ctx ) +{ + tridentContextPtr tmesa = TRIDENT_CONTEXT(ctx); + + if (tmesa->verts) { + ALIGN_FREE(tmesa->verts); + tmesa->verts = 0; + } + + if (tmesa->UbyteSecondaryColor.Ptr) { + ALIGN_FREE((void *)tmesa->UbyteSecondaryColor.Ptr); + tmesa->UbyteSecondaryColor.Ptr = 0; + } + + if (tmesa->UbyteColor.Ptr) { + ALIGN_FREE((void *)tmesa->UbyteColor.Ptr); + tmesa->UbyteColor.Ptr = 0; + } +} |