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);
}
}
}
void i830Fallback( i830ContextPtr imesa, GLuint bit, GLboolean mode )
{
GLcontext *ctx = imesa->glCtx;
TNLcontext *tnl = TNL_CONTEXT(ctx);
GLuint oldfallback = imesa->Fallback;
if (mode) {
imesa->Fallback |= bit;
if (oldfallback == 0) {
I830_FIREVERTICES(imesa);
if (I830_DEBUG & DEBUG_FALLBACKS)
fprintf(stderr, "ENTER FALLBACK %s\n", getFallbackString( bit ));
_swsetup_Wakeup( ctx );
imesa->RenderIndex = ~0;
}
}
else {
imesa->Fallback &= ~bit;
if (oldfallback == bit) {
_swrast_flush( ctx );
if (I830_DEBUG & DEBUG_FALLBACKS)
fprintf(stderr, "LEAVE FALLBACK %s\n", getFallbackString( bit ));
tnl->Driver.Render.Start = i830RenderStart;
tnl->Driver.Render.PrimitiveNotify = i830RenderPrimitive;
tnl->Driver.Render.Finish = i830RenderFinish;
tnl->Driver.Render.BuildVertices = i830BuildVertices;
imesa->NewGLState |= (_I830_NEW_RENDERSTATE|_I830_NEW_VERTEX);
}
}
}
void sisSpanRenderFinish( GLcontext *ctx )
{
sisContextPtr smesa = SIS_CONTEXT(ctx);
_swrast_flush( ctx );
UNLOCK_HARDWARE();
}
/**
* Called when done softare rendering. Unmap the buffers we mapped in
* the above function.
*/
void
intelSpanRenderFinish(GLcontext * ctx)
{
struct intel_context *intel = intel_context(ctx);
GLuint i;
_swrast_flush(ctx);
/* Now unmap the framebuffer:
*/
#if 0
intel_region_unmap(intel, intel->front_region);
intel_region_unmap(intel, intel->back_region);
intel_region_unmap(intel, intel->intelScreen->depth_region);
#endif
for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) {
if (ctx->Texture.Unit[i]._ReallyEnabled) {
struct gl_texture_object *texObj = ctx->Texture.Unit[i]._Current;
intel_tex_unmap_images(intel, intel_texture_object(texObj));
}
}
intel_map_unmap_buffers(intel, GL_FALSE);
UNLOCK_HARDWARE(intel);
}
void mgaFallback( GLcontext *ctx, GLuint bit, GLboolean mode )
{
TNLcontext *tnl = TNL_CONTEXT(ctx);
mgaContextPtr mmesa = MGA_CONTEXT(ctx);
GLuint oldfallback = mmesa->Fallback;
if (mode) {
mmesa->Fallback |= bit;
if (oldfallback == 0) {
FLUSH_BATCH(mmesa);
_swsetup_Wakeup( ctx );
mmesa->RenderIndex = ~0;
if (MGA_DEBUG & DEBUG_VERBOSE_FALLBACK) {
fprintf(stderr, "MGA begin rasterization fallback: 0x%x %s\n",
bit, getFallbackString(bit));
}
}
}
else {
mmesa->Fallback &= ~bit;
if (oldfallback == bit) {
_swrast_flush( ctx );
tnl->Driver.Render.Start = mgaCheckTexSizes;
tnl->Driver.Render.PrimitiveNotify = mgaRenderPrimitive;
tnl->Driver.Render.Finish = mgaRenderFinish;
tnl->Driver.Render.BuildVertices = mgaBuildVertices;
mmesa->NewGLState |= (_MGA_NEW_RENDERSTATE |
_MGA_NEW_RASTERSETUP);
if (MGA_DEBUG & DEBUG_VERBOSE_FALLBACK) {
fprintf(stderr, "MGA end rasterization fallback: 0x%x %s\n",
bit, getFallbackString(bit));
}
}
}
}
void mgaFallback( GLcontext *ctx, GLuint bit, GLboolean mode )
{
TNLcontext *tnl = TNL_CONTEXT(ctx);
mgaContextPtr mmesa = MGA_CONTEXT(ctx);
GLuint oldfallback = mmesa->Fallback;
if (mode) {
mmesa->Fallback |= bit;
if (oldfallback == 0) {
FLUSH_BATCH(mmesa);
_swsetup_Wakeup( ctx );
mmesa->RenderIndex = ~0;
}
}
else {
mmesa->Fallback &= ~bit;
if (oldfallback == bit) {
_swrast_flush( ctx );
tnl->Driver.Render.Start = mgaCheckTexSizes;
tnl->Driver.Render.PrimitiveNotify = mgaRenderPrimitive;
tnl->Driver.Render.Finish = mgaRenderFinish;
tnl->Driver.Render.BuildVertices = mgaBuildVertices;
mmesa->new_gl_state |= (_MGA_NEW_RENDERSTATE |
_MGA_NEW_RASTERSETUP);
}
}
}
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);
}
}
}
static void
nouveauSpanRenderFinish( GLcontext *ctx )
{
nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
_swrast_flush( ctx );
nouveauWaitForIdleLocked( nmesa );
UNLOCK_HARDWARE( nmesa );
}
static void
r128SpanRenderFinish( GLcontext *ctx )
{
r128ContextPtr rmesa = R128_CONTEXT(ctx);
_swrast_flush( ctx );
r128WaitForIdleLocked( rmesa );
UNLOCK_HARDWARE( rmesa );
}
void
_swrast_render_finish( GLcontext *ctx )
{
SWcontext *swrast = SWRAST_CONTEXT(ctx);
if (swrast->Driver.SpanRenderFinish)
swrast->Driver.SpanRenderFinish( ctx );
_swrast_flush(ctx);
}
void
_swrast_render_primitive( GLcontext *ctx, GLenum prim )
{
SWcontext *swrast = SWRAST_CONTEXT(ctx);
if (swrast->Primitive == GL_POINTS && prim != GL_POINTS) {
_swrast_flush(ctx);
}
swrast->Primitive = prim;
}
static void radeonSpanRenderFinish(struct gl_context * ctx)
{
_swrast_flush(ctx);
_swrast_unmap_textures(ctx);
radeon_unmap_framebuffer(ctx, ctx->DrawBuffer);
if (ctx->ReadBuffer != ctx->DrawBuffer)
radeon_unmap_framebuffer(ctx, ctx->ReadBuffer);
}
void
intel_flush_rendering_to_batch(struct gl_context *ctx)
{
struct intel_context *intel = intel_context(ctx);
if (intel->Fallback)
_swrast_flush(ctx);
INTEL_FIREVERTICES(intel);
}
static void
intelRenderFinish(GLcontext * ctx)
{
struct intel_context *intel = intel_context(ctx);
if (intel->RenderIndex & INTEL_FALLBACK_BIT)
_swrast_flush(ctx);
INTEL_FIREVERTICES(intel);
}
/**
* NOT directly called via glFlush.
*/
void intelFlush( GLcontext *ctx )
{
intelContextPtr intel = INTEL_CONTEXT( ctx );
if (intel->Fallback)
_swrast_flush( ctx );
INTEL_FIREVERTICES( intel );
if (intel->batch.size != intel->batch.space)
intelFlushBatch( intel, GL_FALSE );
}
static void
sis_fallback_point( sisContextPtr smesa,
sisVertex *v0 )
{
struct gl_context *ctx = smesa->glCtx;
SWvertex v[1];
_swsetup_Translate( ctx, v0, &v[0] );
sisSpanRenderStart( ctx );
_swrast_Point( ctx, &v[0] );
sisSpanRenderFinish( ctx );
_swrast_flush( ctx );
}
void radeonFallback( struct gl_context *ctx, GLuint bit, GLboolean mode )
{
r100ContextPtr rmesa = R100_CONTEXT(ctx);
TNLcontext *tnl = TNL_CONTEXT(ctx);
GLuint oldfallback = rmesa->radeon.Fallback;
if (mode) {
rmesa->radeon.Fallback |= bit;
if (oldfallback == 0) {
radeon_firevertices(&rmesa->radeon);
TCL_FALLBACK( ctx, RADEON_TCL_FALLBACK_RASTER, GL_TRUE );
_swsetup_Wakeup( ctx );
rmesa->radeon.swtcl.RenderIndex = ~0;
if (RADEON_DEBUG & RADEON_FALLBACKS) {
fprintf(stderr, "Radeon begin rasterization fallback: 0x%x %s\n",
bit, getFallbackString(bit));
}
}
}
else {
rmesa->radeon.Fallback &= ~bit;
if (oldfallback == bit) {
_swrast_flush( ctx );
tnl->Driver.Render.Start = radeonRenderStart;
tnl->Driver.Render.PrimitiveNotify = radeonRenderPrimitive;
tnl->Driver.Render.Finish = radeonRenderFinish;
tnl->Driver.Render.BuildVertices = _tnl_build_vertices;
tnl->Driver.Render.CopyPV = _tnl_copy_pv;
tnl->Driver.Render.Interp = _tnl_interp;
tnl->Driver.Render.ResetLineStipple = radeonResetLineStipple;
TCL_FALLBACK( ctx, RADEON_TCL_FALLBACK_RASTER, GL_FALSE );
if (rmesa->radeon.TclFallback) {
/* These are already done if rmesa->radeon.TclFallback goes to
* zero above. But not if it doesn't (RADEON_NO_TCL for
* example?)
*/
_tnl_invalidate_vertex_state( ctx, ~0 );
_tnl_invalidate_vertices( ctx, ~0 );
rmesa->radeon.tnl_index_bitset = 0;
radeonChooseVertexState( ctx );
radeonChooseRenderState( ctx );
}
if (RADEON_DEBUG & RADEON_FALLBACKS) {
fprintf(stderr, "Radeon end rasterization fallback: 0x%x %s\n",
bit, getFallbackString(bit));
}
}
}
}
static void
sis_fallback_line( sisContextPtr smesa,
sisVertex *v0,
sisVertex *v1 )
{
GLcontext *ctx = smesa->glCtx;
SWvertex v[2];
_swsetup_Translate( ctx, v0, &v[0] );
_swsetup_Translate( ctx, v1, &v[1] );
sisSpanRenderStart( ctx );
_swrast_Line( ctx, &v[0], &v[1] );
sisSpanRenderFinish( ctx );
_swrast_flush( ctx );
}
void
_swrast_render_finish( struct gl_context *ctx )
{
SWcontext *swrast = SWRAST_CONTEXT(ctx);
struct gl_query_object *query = ctx->Query.CurrentOcclusionObject;
_swrast_flush(ctx);
if (swrast->Driver.SpanRenderFinish)
swrast->Driver.SpanRenderFinish( ctx );
if (query && (query->Target == GL_ANY_SAMPLES_PASSED ||
query->Target == GL_ANY_SAMPLES_PASSED_CONSERVATIVE))
query->Result = !!query->Result;
}
/*
* Render a triangle using points and respecting edge flags.
*/
static void
_swsetup_edge_render_point_tri(struct gl_context *ctx,
const GLubyte *ef,
GLuint e0,
GLuint e1,
GLuint e2,
const SWvertex *v0,
const SWvertex *v1,
const SWvertex *v2)
{
if (ef[e0]) _swrast_Point( ctx, v0 );
if (ef[e1]) _swrast_Point( ctx, v1 );
if (ef[e2]) _swrast_Point( ctx, v2 );
_swrast_flush(ctx);
}
static void
sis_fallback_tri( sisContextPtr smesa,
sisVertex *v0,
sisVertex *v1,
sisVertex *v2 )
{
struct gl_context *ctx = smesa->glCtx;
SWvertex v[3];
_swsetup_Translate( ctx, v0, &v[0] );
_swsetup_Translate( ctx, v1, &v[1] );
_swsetup_Translate( ctx, v2, &v[2] );
sisSpanRenderStart( ctx );
_swrast_Triangle( ctx, &v[0], &v[1], &v[2] );
sisSpanRenderFinish( ctx );
_swrast_flush( ctx );
}
/**
* Called when done software rendering. Unmap the buffers we mapped in
* the above function.
*/
void
intelSpanRenderFinish(struct gl_context * ctx)
{
struct intel_context *intel = intel_context(ctx);
GLuint i;
_swrast_flush(ctx);
for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) {
if (ctx->Texture.Unit[i]._ReallyEnabled) {
struct gl_texture_object *texObj = ctx->Texture.Unit[i]._Current;
intel_tex_unmap_images(intel, intel_texture_object(texObj));
}
}
intel_map_unmap_framebuffer(intel, ctx->DrawBuffer, GL_FALSE);
if (ctx->ReadBuffer != ctx->DrawBuffer)
intel_map_unmap_framebuffer(intel, ctx->ReadBuffer, GL_FALSE);
}
void intelFallback( intelContextPtr intel, GLuint bit, GLboolean mode )
{
GLcontext *ctx = &intel->ctx;
TNLcontext *tnl = TNL_CONTEXT(ctx);
GLuint oldfallback = intel->Fallback;
if (mode) {
intel->Fallback |= bit;
if (oldfallback == 0) {
intelFlush(ctx);
if (INTEL_DEBUG & DEBUG_FALLBACKS)
fprintf(stderr, "ENTER FALLBACK 0x%x: %s\n",
bit, getFallbackString(bit));
_swsetup_Wakeup( ctx );
intel->RenderIndex = ~0;
}
}
else {
intel->Fallback &= ~bit;
if (oldfallback == bit) {
_swrast_flush( ctx );
if (INTEL_DEBUG & DEBUG_FALLBACKS)
fprintf(stderr, "LEAVE FALLBACK 0x%x: %s\n",
bit, getFallbackString(bit));
tnl->Driver.Render.Start = intelRenderStart;
tnl->Driver.Render.PrimitiveNotify = intelRenderPrimitive;
tnl->Driver.Render.Finish = intelRenderFinish;
tnl->Driver.Render.BuildVertices = _tnl_build_vertices;
tnl->Driver.Render.CopyPV = _tnl_copy_pv;
tnl->Driver.Render.Interp = _tnl_interp;
_tnl_invalidate_vertex_state( ctx, ~0 );
_tnl_invalidate_vertices( ctx, ~0 );
_tnl_install_attrs( ctx,
intel->vertex_attrs,
intel->vertex_attr_count,
intel->ViewportMatrix.m, 0 );
intel->NewGLState |= _INTEL_NEW_RENDERSTATE;
}
}
}
void ffbFallback( GLcontext *ctx, GLuint bit, GLboolean mode )
{
ffbContextPtr fmesa = FFB_CONTEXT(ctx);
TNLcontext *tnl = TNL_CONTEXT(ctx);
GLuint oldfallback = fmesa->bad_fragment_attrs;
if (mode) {
fmesa->bad_fragment_attrs |= bit;
if (oldfallback == 0) {
/* FFB_FIREVERTICES(fmesa); */
_swsetup_Wakeup( ctx );
if (fmesa->debugFallbacks)
fprintf(stderr, "FFB begin software fallback: 0x%x %s\n",
bit, getFallbackString(bit));
}
} else {
fmesa->bad_fragment_attrs &= ~bit;
if (oldfallback == bit) {
_swrast_flush( ctx );
tnl->Driver.Render.Start = ffbRenderStart;
tnl->Driver.Render.PrimitiveNotify = ffbRenderPrimitive;
tnl->Driver.Render.Finish = ffbRenderFinish;
fmesa->new_gl_state = ~0;
/* Just re-choose everything:
*/
ffbChooseVertexState(ctx);
ffbChooseRenderState(ctx);
ffbChooseTriangleState(ctx);
ffbChooseLineState(ctx);
ffbChoosePointState(ctx);
if (fmesa->debugFallbacks)
fprintf(stderr, "FFB end software fallback: 0x%x %s\n",
bit, getFallbackString(bit));
}
}
}
void nouveauFallback(struct nouveau_context *nmesa, GLuint bit, GLboolean mode)
{
GLcontext *ctx = nmesa->glCtx;
GLuint oldfallback = nmesa->Fallback;
if (mode) {
nmesa->Fallback |= bit;
if (oldfallback == 0) {
if (nmesa->screen->card->type<NV_10) {
//nv04FinishPrimitive(nmesa);
} else {
//nv10FinishPrimitive(nmesa);
}
_swsetup_Wakeup(ctx);
nmesa->render_index = ~0;
}
}
else {
nmesa->Fallback &= ~bit;
if (oldfallback == bit) {
_swrast_flush( ctx );
if (nmesa->screen->card->type<NV_10) {
nv04TriInitFunctions(ctx);
} else {
nv10TriInitFunctions(ctx);
}
_tnl_invalidate_vertex_state( ctx, ~0 );
_tnl_invalidate_vertices( ctx, ~0 );
_tnl_install_attrs( ctx,
nmesa->vertex_attrs,
nmesa->vertex_attr_count,
nmesa->viewport.m, 0 );
}
}
}
void
intel_flush(GLcontext *ctx, GLboolean needs_mi_flush)
{
struct intel_context *intel = intel_context(ctx);
if (intel->Fallback)
_swrast_flush(ctx);
if (intel->gen < 4)
INTEL_FIREVERTICES(intel);
if (intel->batch->map != intel->batch->ptr)
intel_batchbuffer_flush(intel->batch);
if ((ctx->DrawBuffer->Name == 0) && intel->front_buffer_dirty) {
__DRIscreen *const screen = intel->intelScreen->driScrnPriv;
if (screen->dri2.loader &&
(screen->dri2.loader->base.version >= 2)
&& (screen->dri2.loader->flushFrontBuffer != NULL) &&
intel->driDrawable && intel->driDrawable->loaderPrivate) {
(*screen->dri2.loader->flushFrontBuffer)(intel->driDrawable,
intel->driDrawable->loaderPrivate);
/* Only clear the dirty bit if front-buffer rendering is no longer
* enabled. This is done so that the dirty bit can only be set in
* glDrawBuffer. Otherwise the dirty bit would have to be set at
* each of N places that do rendering. This has worse performances,
* but it is much easier to get correct.
*/
if (!intel->is_front_buffer_rendering) {
intel->front_buffer_dirty = GL_FALSE;
}
}
}
}
void viaSpanRenderFinish( GLcontext *ctx )
{
struct via_context *vmesa = VIA_CONTEXT(ctx);
_swrast_flush( ctx );
UNLOCK_HARDWARE( vmesa );
}
static void mach64SpanRenderFinish( GLcontext *ctx )
{
mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
_swrast_flush( ctx );
UNLOCK_HARDWARE( mmesa );
}
static void intelRenderFinish( GLcontext *ctx )
{
if (INTEL_CONTEXT(ctx)->RenderIndex & INTEL_FALLBACK_BIT)
_swrast_flush( ctx );
}
void i810SpanRenderFinish( GLcontext *ctx )
{
i810ContextPtr imesa = I810_CONTEXT( ctx );
_swrast_flush( ctx );
UNLOCK_HARDWARE( imesa );
}
