struct st_visual stvis;
struct pipe_resource *textures[ST_ATTACHMENT_COUNT];
+ struct pipe_resource *msaa_textures[ST_ATTACHMENT_COUNT];
unsigned texture_width, texture_height;
unsigned texture_mask;
};
-static INLINE struct stw_st_framebuffer *
-stw_st_framebuffer(struct st_framebuffer_iface *stfb)
+static uint32_t stwfb_ID = 0;
+
+/**
+ * Is the given mutex held by the calling thread?
+ */
+bool
+stw_own_mutex(const CRITICAL_SECTION *cs)
{
- return (struct stw_st_framebuffer *) stfb;
+ // We can't compare OwningThread with our thread handle/id (see
+ // http://stackoverflow.com/a/12675635 ) but we can compare with the
+ // OwningThread member of a critical section we know we own.
+ CRITICAL_SECTION dummy;
+ InitializeCriticalSection(&dummy);
+ EnterCriticalSection(&dummy);
+ if (0)
+ _debug_printf("%p %p\n", cs->OwningThread, dummy.OwningThread);
+ bool ret = cs->OwningThread == dummy.OwningThread;
+ LeaveCriticalSection(&dummy);
+ DeleteCriticalSection(&dummy);
+ return ret;
}
+
/**
* Remove outdated textures and create the requested ones.
*/
/* remove outdated textures */
if (stwfb->texture_width != width || stwfb->texture_height != height) {
- for (i = 0; i < ST_ATTACHMENT_COUNT; i++)
+ for (i = 0; i < ST_ATTACHMENT_COUNT; i++) {
+ pipe_resource_reference(&stwfb->msaa_textures[i], NULL);
pipe_resource_reference(&stwfb->textures[i], NULL);
+ }
}
memset(&templ, 0, sizeof(templ));
case ST_ATTACHMENT_BACK_LEFT:
format = stwfb->stvis.color_format;
bind = PIPE_BIND_DISPLAY_TARGET |
+ PIPE_BIND_SAMPLER_VIEW |
PIPE_BIND_RENDER_TARGET;
break;
case ST_ATTACHMENT_DEPTH_STENCIL:
if (format != PIPE_FORMAT_NONE) {
templ.format = format;
- templ.bind = bind;
+ if (bind != PIPE_BIND_DEPTH_STENCIL && stwfb->stvis.samples > 1) {
+ templ.bind = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET;
+ templ.nr_samples = templ.nr_storage_samples =
+ stwfb->stvis.samples;
+
+ stwfb->msaa_textures[i] =
+ stw_dev->screen->resource_create(stw_dev->screen, &templ);
+ }
+
+ templ.bind = bind;
+ templ.nr_samples = templ.nr_storage_samples = 1;
stwfb->textures[i] =
stw_dev->screen->resource_create(stw_dev->screen, &templ);
}
stwfb->texture_mask = mask;
}
-static boolean
+static bool
stw_st_framebuffer_validate(struct st_context_iface *stctx,
struct st_framebuffer_iface *stfb,
const enum st_attachment_type *statts,
for (i = 0; i < count; i++)
statt_mask |= 1 << statts[i];
- pipe_mutex_lock(stwfb->fb->mutex);
+ stw_framebuffer_lock(stwfb->fb);
if (stwfb->fb->must_resize || (statt_mask & ~stwfb->texture_mask)) {
stw_st_framebuffer_validate_locked(&stwfb->base,
stwfb->fb->must_resize = FALSE;
}
- for (i = 0; i < count; i++) {
- out[i] = NULL;
- pipe_resource_reference(&out[i], stwfb->textures[statts[i]]);
- }
+ struct pipe_resource **textures =
+ stwfb->stvis.samples > 1 ? stwfb->msaa_textures
+ : stwfb->textures;
+
+ for (i = 0; i < count; i++)
+ pipe_resource_reference(&out[i], textures[statts[i]]);
- stw_framebuffer_release(stwfb->fb);
+ stw_framebuffer_unlock(stwfb->fb);
- return TRUE;
+ return true;
+}
+
+static void
+stw_pipe_blit(struct pipe_context *pipe,
+ struct pipe_resource *dst,
+ struct pipe_resource *src)
+{
+ struct pipe_blit_info blit;
+
+ /* From the GL spec, version 4.2, section 4.1.11 (Additional Multisample
+ * Fragment Operations):
+ *
+ * If a framebuffer object is not bound, after all operations have
+ * been completed on the multisample buffer, the sample values for
+ * each color in the multisample buffer are combined to produce a
+ * single color value, and that value is written into the
+ * corresponding color buffers selected by DrawBuffer or
+ * DrawBuffers. An implementation may defer the writing of the color
+ * buffers until a later time, but the state of the framebuffer must
+ * behave as if the color buffers were updated as each fragment was
+ * processed. The method of combination is not specified. If the
+ * framebuffer contains sRGB values, then it is recommended that the
+ * an average of sample values is computed in a linearized space, as
+ * for blending (see section 4.1.7).
+ *
+ * In other words, to do a resolve operation in a linear space, we have
+ * to set sRGB formats if the original resources were sRGB, so don't use
+ * util_format_linear.
+ */
+
+ memset(&blit, 0, sizeof(blit));
+ blit.dst.resource = dst;
+ blit.dst.box.width = dst->width0;
+ blit.dst.box.height = dst->height0;
+ blit.dst.box.depth = 1;
+ blit.dst.format = dst->format;
+ blit.src.resource = src;
+ blit.src.box.width = src->width0;
+ blit.src.box.height = src->height0;
+ blit.src.box.depth = 1;
+ blit.src.format = src->format;
+ blit.mask = PIPE_MASK_RGBA;
+ blit.filter = PIPE_TEX_FILTER_NEAREST;
+
+ pipe->blit(pipe, &blit);
}
/**
* Present an attachment of the framebuffer.
*/
-static boolean
+static bool
stw_st_framebuffer_present_locked(HDC hdc,
+ struct st_context_iface *stctx,
struct st_framebuffer_iface *stfb,
enum st_attachment_type statt)
{
struct stw_st_framebuffer *stwfb = stw_st_framebuffer(stfb);
struct pipe_resource *resource;
+ assert(stw_own_mutex(&stwfb->fb->mutex));
+
+ if (stwfb->stvis.samples > 1) {
+ stw_pipe_blit(stctx->pipe,
+ stwfb->textures[statt],
+ stwfb->msaa_textures[statt]);
+ }
+
resource = stwfb->textures[statt];
if (resource) {
stw_framebuffer_present_locked(hdc, stwfb->fb, resource);
}
+ else {
+ stw_framebuffer_unlock(stwfb->fb);
+ }
+
+ assert(!stw_own_mutex(&stwfb->fb->mutex));
- return TRUE;
+ return true;
}
-static boolean
+static bool
stw_st_framebuffer_flush_front(struct st_context_iface *stctx,
struct st_framebuffer_iface *stfb,
enum st_attachment_type statt)
{
struct stw_st_framebuffer *stwfb = stw_st_framebuffer(stfb);
- boolean ret;
+ bool ret;
HDC hDC;
- pipe_mutex_lock(stwfb->fb->mutex);
+ stw_framebuffer_lock(stwfb->fb);
/* We must not cache HDCs anywhere, as they can be invalidated by the
* application, or screen resolution changes. */
hDC = GetDC(stwfb->fb->hWnd);
- ret = stw_st_framebuffer_present_locked(hDC, &stwfb->base, statt);
+ ret = stw_st_framebuffer_present_locked(hDC, stctx, &stwfb->base, statt);
ReleaseDC(stwfb->fb->hWnd, hDC);
stwfb->fb = fb;
stwfb->stvis = fb->pfi->stvis;
+ stwfb->base.ID = p_atomic_inc_return(&stwfb_ID);
+ stwfb->base.state_manager = stw_dev->smapi;
stwfb->base.visual = &stwfb->stvis;
p_atomic_set(&stwfb->base.stamp, 1);
struct stw_st_framebuffer *stwfb = stw_st_framebuffer(stfb);
int i;
- for (i = 0; i < ST_ATTACHMENT_COUNT; i++)
+ for (i = 0; i < ST_ATTACHMENT_COUNT; i++) {
+ pipe_resource_reference(&stwfb->msaa_textures[i], NULL);
pipe_resource_reference(&stwfb->textures[i], NULL);
+ }
+
+ /* Notify the st manager that the framebuffer interface is no
+ * longer valid.
+ */
+ stw_dev->stapi->destroy_drawable(stw_dev->stapi, &stwfb->base);
FREE(stwfb);
}
/**
* Swap the buffers of the given framebuffer.
*/
-boolean
-stw_st_swap_framebuffer_locked(HDC hdc, struct st_framebuffer_iface *stfb)
+bool
+stw_st_swap_framebuffer_locked(HDC hdc, struct st_context_iface *stctx,
+ struct st_framebuffer_iface *stfb)
{
struct stw_st_framebuffer *stwfb = stw_st_framebuffer(stfb);
unsigned front = ST_ATTACHMENT_FRONT_LEFT, back = ST_ATTACHMENT_BACK_LEFT;
stwfb->textures[front] = stwfb->textures[back];
stwfb->textures[back] = ptex;
+ /* swap msaa_textures */
+ ptex = stwfb->msaa_textures[front];
+ stwfb->msaa_textures[front] = stwfb->msaa_textures[back];
+ stwfb->msaa_textures[back] = ptex;
+
/* convert to mask */
front = 1 << front;
back = 1 << back;
stwfb->texture_mask = mask;
front = ST_ATTACHMENT_FRONT_LEFT;
- return stw_st_framebuffer_present_locked(hdc, &stwfb->base, front);
+ return stw_st_framebuffer_present_locked(hdc, stctx, &stwfb->base, front);
}
projects / mesa.git / blobdiff