/** * Prepare for softare rendering. Map current read/draw framebuffers' * renderbuffes and all currently bound texture objects. * * Old note: Moved locking out to get reasonable span performance. */ void intelSpanRenderStart(GLcontext * ctx) { struct intel_context *intel = intel_context(ctx); GLuint i; intelFinish(&intel->ctx); LOCK_HARDWARE(intel); #if 0 /* Just map the framebuffer and all textures. Bufmgr code will * take care of waiting on the necessary fences: */ intel_region_map(intel->intelScreen, intel->front_region); intel_region_map(intel->intelScreen, intel->back_region); intel_region_map(intel->intelScreen, 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_map_images(intel, intel_texture_object(texObj)); } } intel_map_unmap_buffers(intel, GL_TRUE); }
/** * Map or unmap all the renderbuffers which we may need during * software rendering. * XXX in the future, we could probably convey extra information to * reduce the number of mappings needed. I.e. if doing a glReadPixels * from the depth buffer, we really only need one mapping. * * XXX Rewrite this function someday. * We can probably just loop over all the renderbuffer attachments, * map/unmap all of them, and not worry about the _ColorDrawBuffers * _ColorReadBuffer, _DepthBuffer or _StencilBuffer fields. */ static void intel_map_unmap_framebuffer(struct intel_context *intel, struct gl_framebuffer *fb, GLboolean map) { GLuint i; /* color draw buffers */ for (i = 0; i < fb->_NumColorDrawBuffers; i++) { if (map) intel_renderbuffer_map(intel, fb->_ColorDrawBuffers[i]); else intel_renderbuffer_unmap(intel, fb->_ColorDrawBuffers[i]); } /* color read buffer */ if (map) intel_renderbuffer_map(intel, fb->_ColorReadBuffer); else intel_renderbuffer_unmap(intel, fb->_ColorReadBuffer); /* check for render to textures */ for (i = 0; i < BUFFER_COUNT; i++) { struct gl_renderbuffer_attachment *att = fb->Attachment + i; struct gl_texture_object *tex = att->Texture; if (tex) { /* render to texture */ ASSERT(att->Renderbuffer); if (map) intel_tex_map_images(intel, intel_texture_object(tex)); else intel_tex_unmap_images(intel, intel_texture_object(tex)); } } /* depth buffer (Note wrapper!) */ if (fb->_DepthBuffer) { if (map) intel_renderbuffer_map(intel, fb->_DepthBuffer->Wrapped); else intel_renderbuffer_unmap(intel, fb->_DepthBuffer->Wrapped); } /* stencil buffer (Note wrapper!) */ if (fb->_StencilBuffer) { if (map) intel_renderbuffer_map(intel, fb->_StencilBuffer->Wrapped); else intel_renderbuffer_unmap(intel, fb->_StencilBuffer->Wrapped); } intel_check_front_buffer_rendering(intel); }
void intel_map_vertex_shader_textures(struct gl_context *ctx) { struct intel_context *intel = intel_context(ctx); int i; if (ctx->VertexProgram._Current == NULL) return; for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) { if (ctx->Texture.Unit[i]._ReallyEnabled && ctx->VertexProgram._Current->Base.TexturesUsed[i] != 0) { struct gl_texture_object *texObj = ctx->Texture.Unit[i]._Current; intel_tex_map_images(intel, intel_texture_object(texObj)); } } }
/** * Prepare for software rendering. Map current read/draw framebuffers' * renderbuffes and all currently bound texture objects. * * Old note: Moved locking out to get reasonable span performance. */ void intelSpanRenderStart(struct gl_context * ctx) { struct intel_context *intel = intel_context(ctx); GLuint i; intel_flush(&intel->ctx); intel_prepare_render(intel); 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_finalize_mipmap_tree(intel, i); intel_tex_map_images(intel, intel_texture_object(texObj)); } } intel_map_unmap_framebuffer(intel, ctx->DrawBuffer, GL_TRUE); if (ctx->ReadBuffer != ctx->DrawBuffer) intel_map_unmap_framebuffer(intel, ctx->ReadBuffer, GL_TRUE); }
/** * Map or unmap all the renderbuffers which we may need during * software rendering. * XXX in the future, we could probably convey extra information to * reduce the number of mappings needed. I.e. if doing a glReadPixels * from the depth buffer, we really only need one mapping. * * XXX Rewrite this function someday. * We can probably just loop over all the renderbuffer attachments, * map/unmap all of them, and not worry about the _ColorDrawBuffers * _ColorReadBuffer, _DepthBuffer or _StencilBuffer fields. */ static void intel_map_unmap_buffers(struct intel_context *intel, GLboolean map) { GLcontext *ctx = &intel->ctx; GLuint i, j; struct intel_renderbuffer *irb; /* color draw buffers */ for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) { for (j = 0; j < ctx->DrawBuffer->_NumColorDrawBuffers[i]; j++) { struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[i][j]; irb = intel_renderbuffer(rb); if (irb) { /* this is a user-created intel_renderbuffer */ if (irb->region) { if (map) intel_region_map(intel->intelScreen, irb->region); else intel_region_unmap(intel->intelScreen, irb->region); } irb->pfMap = irb->region->map; irb->pfPitch = irb->region->pitch; } } } /* check for render to textures */ for (i = 0; i < BUFFER_COUNT; i++) { struct gl_renderbuffer_attachment *att = ctx->DrawBuffer->Attachment + i; struct gl_texture_object *tex = att->Texture; if (tex) { /* render to texture */ ASSERT(att->Renderbuffer); if (map) { struct gl_texture_image *texImg; texImg = tex->Image[att->CubeMapFace][att->TextureLevel]; intel_tex_map_images(intel, intel_texture_object(tex)); } else { intel_tex_unmap_images(intel, intel_texture_object(tex)); } } } /* color read buffers */ irb = intel_renderbuffer(ctx->ReadBuffer->_ColorReadBuffer); if (irb && irb->region) { if (map) intel_region_map(intel->intelScreen, irb->region); else intel_region_unmap(intel->intelScreen, irb->region); irb->pfMap = irb->region->map; irb->pfPitch = irb->region->pitch; } /* Account for front/back color page flipping. * The span routines use the pfMap and pfPitch fields which will * swap the front/back region map/pitch if we're page flipped. * Do this after mapping, above, so the map field is valid. */ #if 0 if (map && ctx->DrawBuffer->Name == 0) { struct intel_renderbuffer *irbFront = intel_get_renderbuffer(ctx->DrawBuffer, BUFFER_FRONT_LEFT); struct intel_renderbuffer *irbBack = intel_get_renderbuffer(ctx->DrawBuffer, BUFFER_BACK_LEFT); if (irbBack) { /* double buffered */ if (intel->sarea->pf_current_page == 0) { irbFront->pfMap = irbFront->region->map; irbFront->pfPitch = irbFront->region->pitch; irbBack->pfMap = irbBack->region->map; irbBack->pfPitch = irbBack->region->pitch; } else { irbFront->pfMap = irbBack->region->map; irbFront->pfPitch = irbBack->region->pitch; irbBack->pfMap = irbFront->region->map; irbBack->pfPitch = irbFront->region->pitch; } } } #endif /* depth buffer (Note wrapper!) */ if (ctx->DrawBuffer->_DepthBuffer) { irb = intel_renderbuffer(ctx->DrawBuffer->_DepthBuffer->Wrapped); if (irb && irb->region && irb->Base.Name != 0) { if (map) { intel_region_map(intel->intelScreen, irb->region); irb->pfMap = irb->region->map; irb->pfPitch = irb->region->pitch; } else { intel_region_unmap(intel->intelScreen, irb->region); irb->pfMap = NULL; irb->pfPitch = 0; } } } /* stencil buffer (Note wrapper!) */ if (ctx->DrawBuffer->_StencilBuffer) { irb = intel_renderbuffer(ctx->DrawBuffer->_StencilBuffer->Wrapped); if (irb && irb->region && irb->Base.Name != 0) { if (map) { intel_region_map(intel->intelScreen, irb->region); irb->pfMap = irb->region->map; irb->pfPitch = irb->region->pitch; } else { intel_region_unmap(intel->intelScreen, irb->region); irb->pfMap = NULL; irb->pfPitch = 0; } } } }