static void sisRasterPrimitive( GLcontext *ctx, GLuint hwprim )
{
sisContextPtr smesa = SIS_CONTEXT(ctx);
if (smesa->hw_primitive != hwprim) {
if (smesa->AGPCmdModeEnabled) {
sisFireVertsAGP( smesa );
smesa->AGPParseSet &= ~(MASK_PsDataType | MASK_PsShadingMode);
smesa->AGPParseSet |= hw_prim_agp_type[hwprim];
if (ctx->Light.ShadeModel == GL_FLAT)
smesa->AGPParseSet |= hw_prim_agp_shade[hwprim];
else
smesa->AGPParseSet |= MASK_PsShadingSmooth;
} else {
mEndPrimitive();
smesa->dwPrimitiveSet &= ~(MASK_DrawPrimitiveCommand |
MASK_SetFirePosition | MASK_ShadingMode);
smesa->dwPrimitiveSet |= hwprim | hw_prim_mmio_fire[hwprim];
if (ctx->Light.ShadeModel == GL_FLAT)
smesa->dwPrimitiveSet |= hw_prim_mmio_shade[hwprim];
else
smesa->dwPrimitiveSet |= SHADE_GOURAUD;
}
}
smesa->hw_primitive = hwprim;
}
static void sisRunPipeline( GLcontext *ctx )
{
sisContextPtr smesa = SIS_CONTEXT( ctx );
LOCK_HARDWARE();
sisUpdateHWState( ctx );
if (smesa->AGPCmdModeEnabled) {
AGP_WritePtr = (GLfloat *)smesa->AGPCmdBufBase + *smesa->pAGPCmdBufNext;
AGP_StartPtr = AGP_WritePtr;
AGP_ReadPtr = (GLfloat *)((long)MMIO_READ(REG_3D_AGPCmBase) -
(long)smesa->AGPCmdBufAddr + (long)smesa->AGPCmdBufBase);
sisUpdateAGP( smesa );
}
if (!smesa->Fallback && smesa->NewGLState) {
if (smesa->NewGLState & _SIS_NEW_VERTEX_STATE)
sisChooseVertexState( ctx );
if (smesa->NewGLState & (_SIS_NEW_RENDER_STATE | _NEW_TEXTURE))
sisChooseRenderState( ctx );
smesa->NewGLState = 0;
}
_tnl_run_pipeline( ctx );
if (smesa->AGPCmdModeEnabled)
sisFireVertsAGP( smesa );
else
mEndPrimitive();
UNLOCK_HARDWARE();
}
void sisSpanRenderFinish( GLcontext *ctx )
{
sisContextPtr smesa = SIS_CONTEXT(ctx);
_swrast_flush( ctx );
UNLOCK_HARDWARE();
}
/* Send all commands to the hardware.
*/
static void
sisFlush( GLcontext *ctx )
{
sisContextPtr smesa = SIS_CONTEXT(ctx);
SIS_FIREVERTICES(smesa);
}
static void
sisTexEnv( GLcontext *ctx, GLenum target, GLenum pname, const GLfloat *param )
{
sisContextPtr smesa = SIS_CONTEXT(ctx);
smesa->TexStates[ctx->Texture.CurrentUnit] |= NEW_TEXTURE_ENV;
}
void sisUpdateTextureState( struct gl_context *ctx )
{
sisContextPtr smesa = SIS_CONTEXT( ctx );
int i;
__GLSiSHardware *current = &smesa->current;
#if 1
/* TODO : if unmark these, error in multitexture */ /* XXX */
for (i = 0; i < SIS_MAX_TEXTURES; i++)
smesa->TexStates[i] |= (NEW_TEXTURING | NEW_TEXTURE_ENV);
#endif
updateTextureUnit( ctx, 0 );
updateTextureUnit( ctx, 1 );
/* XXX Issues with the 2nd unit but not the first being enabled? */
if ( ctx->Texture.Unit[0]._ReallyEnabled &
(TEXTURE_1D_BIT | TEXTURE_2D_BIT) ||
ctx->Texture.Unit[1]._ReallyEnabled &
(TEXTURE_1D_BIT | TEXTURE_2D_BIT) )
{
current->hwCapEnable |= MASK_TextureEnable;
current->hwCapEnable &= ~MASK_TextureNumUsed;
if (ctx->Texture.Unit[1]._ReallyEnabled)
current->hwCapEnable |= 0x00002000;
else
current->hwCapEnable |= 0x00001000;
} else {
current->hwCapEnable &= ~MASK_TextureEnable;
}
}
GLboolean
sisMakeCurrent( __DRIcontextPrivate *driContextPriv,
__DRIdrawablePrivate *driDrawPriv,
__DRIdrawablePrivate *driReadPriv )
{
if ( driContextPriv ) {
GET_CURRENT_CONTEXT(ctx);
sisContextPtr oldSisCtx = ctx ? SIS_CONTEXT(ctx) : NULL;
sisContextPtr newSisCtx = (sisContextPtr) driContextPriv->driverPrivate;
if ( newSisCtx != oldSisCtx) {
newSisCtx->GlobalFlag = GFLAG_ALL;
}
newSisCtx->driDrawable = driDrawPriv;
_mesa_make_current2( newSisCtx->glCtx,
(GLframebuffer *) driDrawPriv->driverPrivate,
(GLframebuffer *) driReadPriv->driverPrivate );
sisUpdateBufferSize( newSisCtx );
sisUpdateClipping( newSisCtx->glCtx );
} else {
_mesa_make_current( 0, 0 );
}
return GL_TRUE;
}
static void updateTextureUnit( struct gl_context *ctx, int unit )
{
sisContextPtr smesa = SIS_CONTEXT( ctx );
const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
struct gl_texture_object *texObj = texUnit->_Current;
GLint fallbackbit;
if (unit == 0)
fallbackbit = SIS_FALLBACK_TEXTURE0;
else
fallbackbit = SIS_FALLBACK_TEXTURE1;
if (texUnit->_ReallyEnabled & (TEXTURE_1D_BIT | TEXTURE_2D_BIT)) {
if (smesa->TexStates[unit] & NEW_TEXTURING) {
GLboolean ok;
ok = sis_set_texobj_parm (ctx, texObj, unit);
FALLBACK( smesa, fallbackbit, !ok );
}
if (smesa->TexStates[unit] & NEW_TEXTURE_ENV) {
if (unit == 0)
sis_set_texture_env0( ctx, texObj, unit );
else
sis_set_texture_env1( ctx, texObj, unit );
}
smesa->TexStates[unit] = 0;
} else if ( texUnit->_ReallyEnabled ) {
/* fallback */
FALLBACK( smesa, fallbackbit, 1 );
} else {
sis_reset_texture_env( ctx, unit );
FALLBACK( smesa, fallbackbit, 0 );
}
}
static GLboolean multipass_cliprect( struct gl_context *ctx, GLuint pass )
{
sisContextPtr smesa = SIS_CONTEXT( ctx );
if (pass >= smesa->driDrawable->numClipRects) {
return GL_FALSE;
} else {
GLint x1, y1, x2, y2;
x1 = smesa->driDrawable->pClipRects[pass].x1 - smesa->driDrawable->x;
y1 = smesa->driDrawable->pClipRects[pass].y1 - smesa->driDrawable->y;
x2 = smesa->driDrawable->pClipRects[pass].x2 - smesa->driDrawable->x;
y2 = smesa->driDrawable->pClipRects[pass].y2 - smesa->driDrawable->y;
if (ctx->Scissor.Enabled) {
GLint scisy1 = Y_FLIP(ctx->Scissor.Y + ctx->Scissor.Height - 1);
GLint scisy2 = Y_FLIP(ctx->Scissor.Y);
if (ctx->Scissor.X > x1)
x1 = ctx->Scissor.X;
if (scisy1 > y1)
y1 = scisy1;
if (ctx->Scissor.X + ctx->Scissor.Width - 1 < x2)
x2 = ctx->Scissor.X + ctx->Scissor.Width - 1;
if (scisy2 < y2)
y2 = scisy2;
}
MMIO(REG_3D_ClipTopBottom, y1 << 13 | y2);
MMIO(REG_3D_ClipLeftRight, x1 << 13 | x2);
/* Mark that we clobbered these registers */
smesa->GlobalFlag |= GFLAG_CLIPPING;
return GL_TRUE;
}
}
static void
sisDeleteTexture( GLcontext * ctx, struct gl_texture_object *texObj )
{
sisContextPtr smesa = SIS_CONTEXT(ctx);
sisTexObjPtr t;
int i;
smesa->clearTexCache = GL_TRUE;
t = texObj->DriverData;
if (t == NULL) {
/*
* this shows the texture is default object and never be a
* argument of sisTexImage*
*/
return;
}
for (i = 0; i < SIS_MAX_TEXTURE_LEVELS; i++) {
sisFreeTexImage( smesa, t, i );
}
FREE(t);
texObj->DriverData = NULL;
/* Free mipmap images and the texture object itself */
_mesa_delete_texture_object(ctx, texObj);
}
static void sisRasterPrimitive( struct gl_context *ctx, GLuint hwprim )
{
sisContextPtr smesa = SIS_CONTEXT(ctx);
if (smesa->hw_primitive != hwprim) {
SIS_FIREVERTICES(smesa);
smesa->hw_primitive = hwprim;
smesa->AGPParseSet &= ~(MASK_PsDataType | MASK_PsShadingMode);
smesa->AGPParseSet |= hw_prim_agp_type[hwprim];
if (smesa->is6326) {
smesa->dwPrimitiveSet &= ~(MASK_6326_DrawPrimitiveCommand |
MASK_6326_SetFirePosition | MASK_6326_ShadingMode);
smesa->dwPrimitiveSet |= hwprim | hw_prim_6326_mmio_fire[hwprim];
} else {
smesa->dwPrimitiveSet &= ~(MASK_DrawPrimitiveCommand |
MASK_SetFirePosition | MASK_ShadingMode);
smesa->dwPrimitiveSet |= hwprim | hw_prim_mmio_fire[hwprim];
}
if (ctx->Light.ShadeModel == GL_FLAT) {
smesa->AGPParseSet |= hw_prim_agp_shade[hwprim];
smesa->dwPrimitiveSet |= hw_prim_mmio_shade[hwprim];
} else {
smesa->AGPParseSet |= MASK_PsShadingSmooth;
if (smesa->is6326) {
smesa->dwPrimitiveSet |= OP_6326_3D_SHADE_FLAT_GOURAUD;
} else {
smesa->dwPrimitiveSet |= SHADE_GOURAUD;
}
}
}
}
static void sis6326DDShadeModel( GLcontext *ctx, GLenum mode )
{
sisContextPtr smesa = SIS_CONTEXT(ctx);
/* Signal to sisRasterPrimitive to recalculate dwPrimitiveSet */
smesa->hw_primitive = -1;
}
static void sisTexImage2D( 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 )
{
sisContextPtr smesa = SIS_CONTEXT(ctx);
sisTexObjPtr t;
if ( texObj->DriverData == NULL )
sisAllocTexObj( texObj );
t = texObj->DriverData;
/* Note, this will call sisChooseTextureFormat */
_mesa_store_teximage2d(ctx, target, level, internalFormat,
width, height, border, format, type, pixels,
&ctx->Unpack, texObj, texImage);
/* Allocate offscreen space for the texture */
sisFreeTexImage(smesa, t, level);
sisAllocTexImage(smesa, t, level, texImage);
/* Upload the texture */
WaitEngIdle(smesa);
memcpy(t->image[level].Data, texImage->Data, t->image[level].size);
if (smesa->PrevTexFormat[ctx->Texture.CurrentUnit] != t->format)
{
smesa->TexStates[ctx->Texture.CurrentUnit] |= NEW_TEXTURE_ENV;
smesa->PrevTexFormat[ctx->Texture.CurrentUnit] = t->format;
}
smesa->TexStates[ctx->Texture.CurrentUnit] |= NEW_TEXTURING;
}
void sisFallback( GLcontext *ctx, GLuint bit, GLboolean mode )
{
TNLcontext *tnl = TNL_CONTEXT(ctx);
sisContextPtr smesa = SIS_CONTEXT(ctx);
GLuint oldfallback = smesa->Fallback;
if (mode) {
smesa->Fallback |= bit;
if (oldfallback == 0) {
_swsetup_Wakeup( ctx );
smesa->RenderIndex = ~0;
}
}
else {
smesa->Fallback &= ~bit;
if (oldfallback == bit) {
_swrast_flush( ctx );
tnl->Driver.Render.Start = sisRenderStart;
tnl->Driver.Render.PrimitiveNotify = sisRenderPrimitive;
tnl->Driver.Render.Finish = sisRenderFinish;
tnl->Driver.Render.BuildVertices = sisBuildVertices;
smesa->NewGLState |= (_SIS_NEW_RENDER_STATE|
_SIS_NEW_VERTEX_STATE);
}
}
}
void sisSpanRenderStart( GLcontext *ctx )
{
sisContextPtr smesa = SIS_CONTEXT(ctx);
SIS_FIREVERTICES(smesa);
LOCK_HARDWARE();
WaitEngIdle( smesa );
}
static void sisTexSubImage2D( 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 )
{
sisContextPtr smesa = SIS_CONTEXT(ctx);
sisTexObjPtr t;
GLuint copySize;
GLint texelBytes;
const char *src;
GLubyte *dst;
int j;
GLuint soffset;
if ( texObj->DriverData == NULL )
sisAllocTexObj( texObj );
t = texObj->DriverData;
_mesa_store_texsubimage2d(ctx, target, level, xoffset, yoffset, width,
height, format, type, pixels, packing, texObj,
texImage);
/* Allocate offscreen space for the texture */
sisFreeTexImage(smesa, t, level);
sisAllocTexImage(smesa, t, level, texImage);
/* Upload the texture */
WaitEngIdle(smesa);
texelBytes = _mesa_get_format_bytes(texImage->TexFormat);
copySize = width * texelBytes;
src = (char *)texImage->Data + (xoffset + yoffset * texImage->Width) *
texelBytes;
dst = t->image[level].Data + (xoffset + yoffset * texImage->Width) *
texelBytes;
soffset = texImage->Width * texelBytes;
for (j = yoffset; j < yoffset + height; j++) {
memcpy( dst, src, copySize );
src += soffset;
dst += soffset;
}
smesa->clearTexCache = GL_TRUE;
if (smesa->PrevTexFormat[ctx->Texture.CurrentUnit] != t->format)
{
smesa->TexStates[ctx->Texture.CurrentUnit] |= NEW_TEXTURE_ENV;
smesa->PrevTexFormat[ctx->Texture.CurrentUnit] = t->format;
}
smesa->TexStates[ctx->Texture.CurrentUnit] |= NEW_TEXTURING;
}
static void sisRenderPrimitive( GLcontext *ctx, GLenum prim )
{
sisContextPtr smesa = SIS_CONTEXT(ctx);
smesa->render_primitive = prim;
if (prim >= GL_TRIANGLES && (ctx->_TriangleCaps & DD_TRI_UNFILLED))
return;
sisRasterPrimitive( ctx, hw_prim[prim] );
}
static void
sisTexParameter( GLcontext *ctx, GLenum target,
struct gl_texture_object *texObj, GLenum pname,
const GLfloat *params )
{
sisContextPtr smesa = SIS_CONTEXT(ctx);
smesa->TexStates[ctx->Texture.CurrentUnit] |= NEW_TEXTURING;
}
/* Make sure all commands have been sent to the hardware and have
* completed processing.
*/
static void
sisFinish( GLcontext *ctx )
{
sisContextPtr smesa = SIS_CONTEXT(ctx);
SIS_FIREVERTICES(smesa);
LOCK_HARDWARE();
WaitEngIdle( smesa );
UNLOCK_HARDWARE();
}
static void sis6326UpdateSpecular(GLcontext *ctx)
{
sisContextPtr smesa = SIS_CONTEXT(ctx);
__GLSiSHardware *current = &smesa->current;
if (NEED_SECONDARY_COLOR(ctx))
current->hwCapEnable |= S_ENABLE_Specular;
else
current->hwCapEnable &= ~S_ENABLE_Specular;
}
static void
sis6326DDDepthMask( GLcontext *ctx, GLboolean flag )
{
sisContextPtr smesa = SIS_CONTEXT(ctx);
__GLSiSHardware *current = &smesa->current;
if (ctx->Depth.Test)
current->hwCapEnable |= S_ENABLE_ZWrite;
else
current->hwCapEnable &= ~S_ENABLE_ZWrite;
}
static void
sis6326DDInvalidateState( GLcontext *ctx, GLuint new_state )
{
sisContextPtr smesa = SIS_CONTEXT(ctx);
_swrast_InvalidateState( ctx, new_state );
_swsetup_InvalidateState( ctx, new_state );
_vbo_InvalidateState( ctx, new_state );
_tnl_InvalidateState( ctx, new_state );
smesa->NewGLState |= new_state;
}
static void sisChooseRenderState(struct gl_context *ctx)
{
TNLcontext *tnl = TNL_CONTEXT(ctx);
sisContextPtr smesa = SIS_CONTEXT( ctx );
GLuint flags = ctx->_TriangleCaps;
GLuint index = 0;
if (smesa->Fallback)
return;
if (flags & (ANY_RASTER_FLAGS|ANY_FALLBACK_FLAGS)) {
if (flags & ANY_RASTER_FLAGS) {
if (flags & DD_TRI_LIGHT_TWOSIDE) index |= SIS_TWOSIDE_BIT;
if (flags & DD_TRI_OFFSET) index |= SIS_OFFSET_BIT;
if (flags & DD_TRI_UNFILLED) index |= SIS_UNFILLED_BIT;
}
smesa->draw_point = sis_point;
smesa->draw_line = sis_line;
smesa->draw_tri = sis_triangle;
/* Hook in fallbacks for specific primitives.
*/
if (flags & ANY_FALLBACK_FLAGS) {
if (flags & POINT_FALLBACK)
smesa->draw_point = sis_fallback_point;
if (flags & LINE_FALLBACK)
smesa->draw_line = sis_fallback_line;
if (flags & TRI_FALLBACK)
smesa->draw_tri = sis_fallback_tri;
index |= SIS_FALLBACK_BIT;
}
}
if (index != smesa->RenderIndex) {
smesa->RenderIndex = index;
tnl->Driver.Render.Points = rast_tab[index].points;
tnl->Driver.Render.Line = rast_tab[index].line;
tnl->Driver.Render.ClippedLine = 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 = sis_render_tab_verts;
tnl->Driver.Render.PrimTabElts = sis_render_tab_elts;
tnl->Driver.Render.ClippedPolygon = sis_fast_clipped_poly;
} else {
tnl->Driver.Render.PrimTabVerts = _tnl_render_tab_verts;
tnl->Driver.Render.PrimTabElts = _tnl_render_tab_elts;
tnl->Driver.Render.ClippedPolygon = _tnl_RenderClippedPolygon;
}
}
}
/* Return the width and height of the given buffer.
*/
static void
sisGetBufferSize( GLframebuffer *buffer,
GLuint *width, GLuint *height )
{
GET_CURRENT_CONTEXT(ctx);
sisContextPtr smesa = SIS_CONTEXT(ctx);
LOCK_HARDWARE();
*width = smesa->driDrawable->w;
*height = smesa->driDrawable->h;
UNLOCK_HARDWARE();
}
static void sis6326DDColorMask( GLcontext *ctx,
GLboolean r, GLboolean g,
GLboolean b, GLboolean a )
{
sisContextPtr smesa = SIS_CONTEXT(ctx);
if (r && g && b && ((ctx->Visual.alphaBits == 0) || a)) {
FALLBACK(smesa, SIS_FALLBACK_WRITEMASK, 0);
} else {
FALLBACK(smesa, SIS_FALLBACK_WRITEMASK, 1);
}
}
static void sis6326CalcViewport( GLcontext *ctx )
{
sisContextPtr smesa = SIS_CONTEXT(ctx);
const GLfloat *v = ctx->Viewport._WindowMap.m;
GLfloat *m = smesa->hw_viewport;
/* See also sis_translate_vertex.
*/
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] + smesa->driDrawable->h + SUBPIXEL_Y;
m[MAT_SZ] = v[MAT_SZ] * smesa->depth_scale;
m[MAT_TZ] = v[MAT_TZ] * smesa->depth_scale;
}
static void
sis6326DDAlphaFunc( GLcontext *ctx, GLenum func, GLfloat ref )
{
sisContextPtr smesa = SIS_CONTEXT(ctx);
GLubyte refbyte;
__GLSiSHardware *prev = &smesa->prev;
__GLSiSHardware *current = &smesa->current;
CLAMPED_FLOAT_TO_UBYTE(refbyte, ref);
current->hwAlpha = refbyte << 16;
/* Alpha Test function */
switch (func)
{
case GL_NEVER:
current->hwAlpha |= S_ASET_PASS_NEVER;
break;
case GL_LESS:
current->hwAlpha |= S_ASET_PASS_LESS;
break;
case GL_EQUAL:
current->hwAlpha |= S_ASET_PASS_EQUAL;
break;
case GL_LEQUAL:
current->hwAlpha |= S_ASET_PASS_LEQUAL;
break;
case GL_GREATER:
current->hwAlpha |= S_ASET_PASS_GREATER;
break;
case GL_NOTEQUAL:
current->hwAlpha |= S_ASET_PASS_NOTEQUAL;
break;
case GL_GEQUAL:
current->hwAlpha |= S_ASET_PASS_GEQUAL;
break;
case GL_ALWAYS:
current->hwAlpha |= S_ASET_PASS_ALWAYS;
break;
}
prev->hwAlpha = current->hwAlpha;
smesa->GlobalFlag |= GFLAG_ALPHASETTING;
}
void sis6326DDDrawBuffer( GLcontext *ctx, GLenum mode )
{
sisContextPtr smesa = SIS_CONTEXT(ctx);
__GLSiSHardware *prev = &smesa->prev;
__GLSiSHardware *current = &smesa->current;
if(getenv("SIS_DRAW_FRONT"))
ctx->DrawBuffer->_ColorDrawBufferIndexes[0] = BUFFER_FRONT_LEFT;
if (ctx->DrawBuffer->_NumColorDrawBuffers > 1) {
FALLBACK( smesa, SIS_FALLBACK_DRAW_BUFFER, GL_TRUE );
return;
}
current->hwDstSet &= ~MASK_DstBufferPitch;
switch ( ctx->DrawBuffer->_ColorDrawBufferIndexes[0] ) {
case BUFFER_FRONT_LEFT:
current->hwOffsetDest = smesa->front.offset;
current->hwDstSet |= smesa->front.pitch;
FALLBACK( smesa, SIS_FALLBACK_DRAW_BUFFER, GL_FALSE );
break;
case BUFFER_BACK_LEFT:
current->hwOffsetDest = smesa->back.offset;
current->hwDstSet |= smesa->back.pitch;
FALLBACK( smesa, SIS_FALLBACK_DRAW_BUFFER, GL_FALSE );
break;
default:
FALLBACK( smesa, SIS_FALLBACK_DRAW_BUFFER, GL_TRUE );
return;
}
if (current->hwDstSet != prev->hwDstSet) {
prev->hwDstSet = current->hwDstSet;
smesa->GlobalFlag |= GFLAG_DESTSETTING;
}
if (current->hwOffsetDest != prev->hwOffsetDest) {
prev->hwOffsetDest = current->hwOffsetDest;
smesa->GlobalFlag |= GFLAG_DESTSETTING;
}
}
static void sisFastRenderClippedPoly( GLcontext *ctx, const GLuint *elts,
GLuint n )
{
sisContextPtr smesa = SIS_CONTEXT( ctx );
GLuint vertsize = smesa->vertex_size;
GLuint *vb = r128AllocDmaLow( rmesa, (n-2) * 3 * 4 * vertsize );
GLubyte *sisverts = (GLubyte *)smesa->verts;
const GLuint shift = smesa->vertex_stride_shift;
const GLuint *start = (const GLuint *)VERT(elts[0]);
int i,j;
smesa->num_verts += (n-2) * 3;
for (i = 2 ; i < n ; i++) {
COPY_DWORDS( j, vb, vertsize, (sisVertexPtr) VERT(elts[i-1]) );
COPY_DWORDS( j, vb, vertsize, (sisVertexPtr) VERT(elts[i]) );
COPY_DWORDS( j, vb, vertsize, (sisVertexPtr) start );
}
}
void
sis6326UpdateClipping(GLcontext *ctx)
{
sisContextPtr smesa = SIS_CONTEXT(ctx);
__GLSiSHardware *prev = &smesa->prev;
__GLSiSHardware *current = &smesa->current;
GLint x1, y1, x2, y2;
x1 = 0;
y1 = 0;
x2 = smesa->width - 1;
y2 = smesa->height - 1;
if (ctx->Scissor.Enabled) {
if (ctx->Scissor.X > x1)
x1 = ctx->Scissor.X;
if (ctx->Scissor.Y > y1)
y1 = ctx->Scissor.Y;
if (ctx->Scissor.X + ctx->Scissor.Width - 1 < x2)
x2 = ctx->Scissor.X + ctx->Scissor.Width - 1;
if (ctx->Scissor.Y + ctx->Scissor.Height - 1 < y2)
y2 = ctx->Scissor.Y + ctx->Scissor.Height - 1;
}
y1 = Y_FLIP(y1);
y2 = Y_FLIP(y2);
/*current->clipTopBottom = (y2 << 13) | y1;
current->clipLeftRight = (x1 << 13) | x2;*/ /* XXX */
current->clipTopBottom = (0 << 13) | smesa->height;
current->clipLeftRight = (0 << 13) | smesa->width;
if ((current->clipTopBottom != prev->clipTopBottom) ||
(current->clipLeftRight != prev->clipLeftRight)) {
prev->clipTopBottom = current->clipTopBottom;
prev->clipLeftRight = current->clipLeftRight;
smesa->GlobalFlag |= GFLAG_CLIPPING;
}
}