static void nv20_clear(struct gl_context *ctx, GLbitfield buffers) { struct nouveau_context *nctx = to_nouveau_context(ctx); struct nouveau_pushbuf *push = context_push(ctx); struct gl_framebuffer *fb = ctx->DrawBuffer; uint32_t clear = 0; nouveau_validate_framebuffer(ctx); nouveau_pushbuf_bufctx(push, nctx->hw.bufctx); if (nouveau_pushbuf_validate(push)) { nouveau_pushbuf_bufctx(push, NULL); return; } if (buffers & BUFFER_BITS_COLOR) { struct nouveau_surface *s = &to_nouveau_renderbuffer( fb->_ColorDrawBuffers[0])->surface; if (ctx->Color.ColorMask[0][RCOMP]) clear |= NV20_3D_CLEAR_BUFFERS_COLOR_R; if (ctx->Color.ColorMask[0][GCOMP]) clear |= NV20_3D_CLEAR_BUFFERS_COLOR_G; if (ctx->Color.ColorMask[0][BCOMP]) clear |= NV20_3D_CLEAR_BUFFERS_COLOR_B; if (ctx->Color.ColorMask[0][ACOMP]) clear |= NV20_3D_CLEAR_BUFFERS_COLOR_A; BEGIN_NV04(push, NV20_3D(CLEAR_VALUE), 1); PUSH_DATA (push, pack_rgba_clamp_f(s->format, ctx->Color.ClearColor.f)); buffers &= ~BUFFER_BITS_COLOR; } if (buffers & (BUFFER_BIT_DEPTH | BUFFER_BIT_STENCIL)) { struct nouveau_surface *s = &to_nouveau_renderbuffer( fb->Attachment[BUFFER_DEPTH].Renderbuffer)->surface; if (buffers & BUFFER_BIT_DEPTH && ctx->Depth.Mask) clear |= NV20_3D_CLEAR_BUFFERS_DEPTH; if (buffers & BUFFER_BIT_STENCIL && ctx->Stencil.WriteMask[0]) clear |= NV20_3D_CLEAR_BUFFERS_STENCIL; BEGIN_NV04(push, NV20_3D(CLEAR_DEPTH_VALUE), 1); PUSH_DATA (push, pack_zs_f(s->format, ctx->Depth.Clear, ctx->Stencil.Clear)); buffers &= ~(BUFFER_BIT_DEPTH | BUFFER_BIT_STENCIL); } BEGIN_NV04(push, NV20_3D(CLEAR_BUFFERS), 1); PUSH_DATA (push, clear); nouveau_pushbuf_bufctx(push, NULL); nouveau_clear(ctx, buffers); }
void nv20_emit_framebuffer(struct gl_context *ctx, int emit) { struct nouveau_pushbuf *push = context_push(ctx); struct gl_framebuffer *fb = ctx->DrawBuffer; struct nouveau_surface *s; unsigned rt_format = NV20_3D_RT_FORMAT_TYPE_LINEAR; unsigned rt_pitch = 0, zeta_pitch = 0; unsigned bo_flags = NOUVEAU_BO_VRAM | NOUVEAU_BO_RDWR; if (fb->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) return; PUSH_RESET(push, BUFCTX_FB); /* Render target */ if (fb->_ColorDrawBuffers[0]) { s = &to_nouveau_renderbuffer( fb->_ColorDrawBuffers[0])->surface; rt_format |= get_rt_format(s->format); rt_pitch = s->pitch; BEGIN_NV04(push, NV20_3D(COLOR_OFFSET), 1); PUSH_MTHDl(push, NV20_3D(COLOR_OFFSET), BUFCTX_FB, s->bo, 0, bo_flags); } /* depth/stencil */ if (fb->Attachment[BUFFER_DEPTH].Renderbuffer) { s = &to_nouveau_renderbuffer( fb->Attachment[BUFFER_DEPTH].Renderbuffer)->surface; rt_format |= get_rt_format(s->format); zeta_pitch = s->pitch; BEGIN_NV04(push, NV20_3D(ZETA_OFFSET), 1); PUSH_MTHDl(push, NV20_3D(ZETA_OFFSET), BUFCTX_FB, s->bo, 0, bo_flags); if (context_chipset(ctx) >= 0x25) setup_hierz_buffer(ctx); } else { rt_format |= get_rt_format(MESA_FORMAT_S8_UINT_Z24_UNORM); zeta_pitch = rt_pitch; } BEGIN_NV04(push, NV20_3D(RT_FORMAT), 2); PUSH_DATA (push, rt_format); PUSH_DATA (push, zeta_pitch << 16 | rt_pitch); /* Recompute the viewport/scissor state. */ context_dirty(ctx, VIEWPORT); context_dirty(ctx, SCISSOR); context_dirty(ctx, DEPTH); }
void nv20_emit_framebuffer(GLcontext *ctx, int emit) { struct nouveau_channel *chan = context_chan(ctx); struct nouveau_grobj *kelvin = context_eng3d(ctx); struct nouveau_bo_context *bctx = context_bctx(ctx, FRAMEBUFFER); struct gl_framebuffer *fb = ctx->DrawBuffer; struct nouveau_surface *s; unsigned rt_format = NV20TCL_RT_FORMAT_TYPE_LINEAR; unsigned rt_pitch = 0, zeta_pitch = 0; unsigned bo_flags = NOUVEAU_BO_VRAM | NOUVEAU_BO_RDWR; if (fb->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) return; /* Render target */ if (fb->_ColorDrawBuffers[0]) { s = &to_nouveau_renderbuffer( fb->_ColorDrawBuffers[0])->surface; rt_format |= get_rt_format(s->format); rt_pitch = s->pitch; nouveau_bo_markl(bctx, kelvin, NV20TCL_COLOR_OFFSET, s->bo, 0, bo_flags); } /* depth/stencil */ if (fb->_DepthBuffer) { s = &to_nouveau_renderbuffer( fb->_DepthBuffer->Wrapped)->surface; rt_format |= get_rt_format(s->format); zeta_pitch = s->pitch; nouveau_bo_markl(bctx, kelvin, NV20TCL_ZETA_OFFSET, s->bo, 0, bo_flags); } else { rt_format |= get_rt_format(MESA_FORMAT_Z24_S8); zeta_pitch = rt_pitch; } BEGIN_RING(chan, kelvin, NV20TCL_RT_FORMAT, 2); OUT_RING(chan, rt_format); OUT_RING(chan, zeta_pitch << 16 | rt_pitch); /* Recompute the viewport/scissor state. */ context_dirty(ctx, VIEWPORT); context_dirty(ctx, SCISSOR); }
void nv04_emit_framebuffer(struct gl_context *ctx, int emit) { struct nouveau_pushbuf *push = context_push(ctx); struct gl_framebuffer *fb = ctx->DrawBuffer; struct nouveau_surface *s; uint32_t rt_format = NV04_CONTEXT_SURFACES_3D_FORMAT_TYPE_PITCH; uint32_t rt_pitch = 0, zeta_pitch = 0; unsigned bo_flags = NOUVEAU_BO_VRAM | NOUVEAU_BO_RDWR; if (fb->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) return; PUSH_RESET(push, BUFCTX_FB); /* Render target */ if (fb->_ColorDrawBuffers[0]) { s = &to_nouveau_renderbuffer( fb->_ColorDrawBuffers[0])->surface; rt_format |= get_rt_format(s->format); zeta_pitch = rt_pitch = s->pitch; BEGIN_NV04(push, NV04_SF3D(OFFSET_COLOR), 1); PUSH_MTHDl(push, NV04_SF3D(OFFSET_COLOR), BUFCTX_FB, s->bo, 0, bo_flags); } /* depth/stencil */ if (fb->Attachment[BUFFER_DEPTH].Renderbuffer) { s = &to_nouveau_renderbuffer( fb->Attachment[BUFFER_DEPTH].Renderbuffer)->surface; zeta_pitch = s->pitch; BEGIN_NV04(push, NV04_SF3D(OFFSET_ZETA), 1); PUSH_MTHDl(push, NV04_SF3D(OFFSET_ZETA), BUFCTX_FB, s->bo, 0, bo_flags); } BEGIN_NV04(push, NV04_SF3D(FORMAT), 1); PUSH_DATA (push, rt_format); BEGIN_NV04(push, NV04_SF3D(PITCH), 1); PUSH_DATA (push, zeta_pitch << 16 | rt_pitch); /* Recompute the scissor state. */ context_dirty(ctx, SCISSOR); context_dirty(ctx, CONTROL); }
void nv04_emit_framebuffer(GLcontext *ctx, int emit) { struct nouveau_channel *chan = context_chan(ctx); struct nouveau_hw_state *hw = &to_nouveau_context(ctx)->hw; struct nouveau_grobj *surf3d = hw->surf3d; struct nouveau_bo_context *bctx = context_bctx(ctx, FRAMEBUFFER); struct gl_framebuffer *fb = ctx->DrawBuffer; struct nouveau_surface *s; uint32_t rt_format = NV04_CONTEXT_SURFACES_3D_FORMAT_TYPE_PITCH; uint32_t rt_pitch = 0, zeta_pitch = 0; unsigned bo_flags = NOUVEAU_BO_VRAM | NOUVEAU_BO_RDWR; if (fb->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) return; /* Render target */ if (fb->_NumColorDrawBuffers) { s = &to_nouveau_renderbuffer( fb->_ColorDrawBuffers[0])->surface; rt_format |= get_rt_format(s->format); zeta_pitch = rt_pitch = s->pitch; nouveau_bo_markl(bctx, surf3d, NV04_CONTEXT_SURFACES_3D_OFFSET_COLOR, s->bo, 0, bo_flags); } /* depth/stencil */ if (fb->_DepthBuffer) { s = &to_nouveau_renderbuffer( fb->_DepthBuffer->Wrapped)->surface; zeta_pitch = s->pitch; nouveau_bo_markl(bctx, surf3d, NV04_CONTEXT_SURFACES_3D_OFFSET_ZETA, s->bo, 0, bo_flags); } BEGIN_RING(chan, surf3d, NV04_CONTEXT_SURFACES_3D_FORMAT, 1); OUT_RING(chan, rt_format); BEGIN_RING(chan, surf3d, NV04_CONTEXT_SURFACES_3D_PITCH, 1); OUT_RING(chan, zeta_pitch << 16 | rt_pitch); /* Recompute the scissor state. */ context_dirty(ctx, SCISSOR); }
static void nouveau_renderbuffer_map(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint x, GLuint y, GLuint w, GLuint h, GLbitfield mode, GLubyte **out_map, GLint *out_stride) { struct nouveau_surface *s = &to_nouveau_renderbuffer(rb)->surface; GLubyte *map; int stride; int flags = 0; if (mode & GL_MAP_READ_BIT) flags |= NOUVEAU_BO_RD; if (mode & GL_MAP_WRITE_BIT) flags |= NOUVEAU_BO_WR; nouveau_bo_map(s->bo, flags); map = s->bo->map; stride = s->pitch; if (rb->Name == 0) { map += stride * (rb->Height - 1); stride = -stride; } map += x * s->cpp; map += (int)y * stride; *out_map = map; *out_stride = stride; }
static void renderbuffer_map_unmap(struct gl_renderbuffer *rb, GLboolean map) { struct nouveau_surface *s = &to_nouveau_renderbuffer(rb)->surface; if (map) { switch (rb->Format) { case MESA_FORMAT_RGB565: nouveau_InitPointers_rgb565(rb); break; case MESA_FORMAT_XRGB8888: nouveau_InitPointers_rgb888(rb); break; case MESA_FORMAT_ARGB8888: nouveau_InitPointers_argb8888(rb); break; case MESA_FORMAT_Z16: nouveau_InitDepthPointers_z16(rb); break; case MESA_FORMAT_Z24_S8: nouveau_InitDepthPointers_z24s8(rb); break; default: assert(0); } nouveau_bo_map(s->bo, NOUVEAU_BO_RDWR); } else { nouveau_bo_unmap(s->bo); } }
static void nouveau_render_texture(struct gl_context *ctx, struct gl_framebuffer *fb, struct gl_renderbuffer_attachment *att) { struct gl_renderbuffer *rb = att->Renderbuffer; struct gl_texture_image *ti = att->Texture->Image[att->CubeMapFace][att->TextureLevel]; /* Allocate a renderbuffer object for the texture if we * haven't already done so. */ if (!rb) { rb = nouveau_renderbuffer_new(ctx, ~0); assert(rb); rb->AllocStorage = NULL; _mesa_reference_renderbuffer(&att->Renderbuffer, rb); } /* Update the renderbuffer fields from the texture. */ set_renderbuffer_format(rb, get_tex_format(ti)); rb->Width = ti->Width; rb->Height = ti->Height; nouveau_surface_ref(&to_nouveau_teximage(ti)->surface, &to_nouveau_renderbuffer(rb)->surface); context_dirty(ctx, FRAMEBUFFER); }
static void nv17_zclear(struct gl_context *ctx, GLbitfield *buffers) { struct nouveau_context *nctx = to_nouveau_context(ctx); struct nouveau_channel *chan = context_chan(ctx); struct nouveau_grobj *celsius = context_eng3d(ctx); struct nouveau_framebuffer *nfb = to_nouveau_framebuffer( ctx->DrawBuffer); struct nouveau_surface *s = &to_nouveau_renderbuffer( nfb->base.Attachment[BUFFER_DEPTH].Renderbuffer)->surface; /* Clear the hierarchical depth buffer */ BEGIN_RING(chan, celsius, NV17_3D_HIERZ_FILL_VALUE, 1); OUT_RING(chan, pack_zs_f(s->format, ctx->Depth.Clear, 0)); BEGIN_RING(chan, celsius, NV17_3D_HIERZ_BUFFER_CLEAR, 1); OUT_RING(chan, 1); /* Mark the depth buffer as cleared */ if (use_fast_zclear(ctx, *buffers)) { if (nctx->hierz.clear_seq) *buffers &= ~BUFFER_BIT_DEPTH; nfb->hierz.clear_value = pack_zs_f(s->format, ctx->Depth.Clear, 0); nctx->hierz.clear_seq++; context_dirty(ctx, ZCLEAR); } }
static void nv17_zclear(struct gl_context *ctx, GLbitfield *buffers) { struct nouveau_context *nctx = to_nouveau_context(ctx); struct nouveau_pushbuf *push = context_push(ctx); struct nouveau_framebuffer *nfb = to_nouveau_framebuffer( ctx->DrawBuffer); struct nouveau_surface *s = &to_nouveau_renderbuffer( nfb->base.Attachment[BUFFER_DEPTH].Renderbuffer)->surface; /* Clear the hierarchical depth buffer */ BEGIN_NV04(push, NV17_3D(HIERZ_FILL_VALUE), 1); PUSH_DATA (push, pack_zs_f(s->format, ctx->Depth.Clear, 0)); BEGIN_NV04(push, NV17_3D(HIERZ_BUFFER_CLEAR), 1); PUSH_DATA (push, 1); /* Mark the depth buffer as cleared */ if (use_fast_zclear(ctx, *buffers)) { if (nctx->hierz.clear_seq) *buffers &= ~BUFFER_BIT_DEPTH; nfb->hierz.clear_value = pack_zs_f(s->format, ctx->Depth.Clear, 0); nctx->hierz.clear_seq++; context_dirty(ctx, ZCLEAR); } }
static void nv10_zclear(struct gl_context *ctx, GLbitfield *buffers) { /* * Pre-nv17 cards don't have native support for fast Z clears, * but in some cases we can still "clear" the Z buffer without * actually blitting to it if we're willing to sacrifice a few * bits of depth precision. * * Each time a clear is requested we modify the viewport * transform in such a way that the old contents of the depth * buffer are clamped to the requested clear value when * they're read by the GPU. */ struct nouveau_context *nctx = to_nouveau_context(ctx); struct gl_framebuffer *fb = ctx->DrawBuffer; struct nouveau_framebuffer *nfb = to_nouveau_framebuffer(fb); struct nouveau_surface *s = &to_nouveau_renderbuffer( fb->Attachment[BUFFER_DEPTH].Renderbuffer)->surface; if (nv10_use_viewport_zclear(ctx)) { int x, y, w, h; float z = ctx->Depth.Clear; uint32_t value = pack_zs_f(s->format, z, 0); get_scissors(fb, &x, &y, &w, &h); *buffers &= ~BUFFER_BIT_DEPTH; if (use_fast_zclear(ctx, *buffers)) { if (nfb->hierz.clear_value != value) { /* Don't fast clear if we're changing * the depth value. */ nfb->hierz.clear_value = value; } else if (z == 0.0) { nctx->hierz.clear_seq++; context_dirty(ctx, ZCLEAR); if ((nctx->hierz.clear_seq & 7) != 0 && nctx->hierz.clear_seq != 1) /* We didn't wrap around -- no need to * clear the depth buffer for real. */ return; } else if (z == 1.0) { nctx->hierz.clear_seq--; context_dirty(ctx, ZCLEAR); if ((nctx->hierz.clear_seq & 7) != 7) /* No wrap around */ return; } } value = pack_zs_f(s->format, (z + (nctx->hierz.clear_seq & 7)) / 8, 0); context_drv(ctx)->surface_fill(ctx, s, ~0, value, x, y, w, h); } }
static void nouveau_renderbuffer_unmap(struct gl_context *ctx, struct gl_renderbuffer *rb) { struct nouveau_surface *s = &to_nouveau_renderbuffer(rb)->surface; nouveau_bo_unmap(s->bo); }
static void nouveau_renderbuffer_del(struct gl_context *ctx, struct gl_renderbuffer *rb) { struct nouveau_surface *s = &to_nouveau_renderbuffer(rb)->surface; nouveau_surface_ref(NULL, s); _mesa_delete_renderbuffer(ctx, rb); }
static void nouveau_renderbuffer_del(struct gl_renderbuffer *rb) { struct nouveau_surface *s = &to_nouveau_renderbuffer(rb)->surface; nouveau_surface_ref(NULL, s); FREE(rb); }
static void renderbuffer_map_unmap(struct gl_context *ctx, struct gl_renderbuffer *rb, GLboolean map) { struct nouveau_surface *s = &to_nouveau_renderbuffer(rb)->surface; if (map) nouveau_bo_map(s->bo, NOUVEAU_BO_RDWR, context_client(ctx)); }
static void renderbuffer_map_unmap(struct gl_renderbuffer *rb, GLboolean map) { struct nouveau_surface *s = &to_nouveau_renderbuffer(rb)->surface; if (map) { nouveau_bo_map(s->bo, NOUVEAU_BO_RDWR); } else { nouveau_bo_unmap(s->bo); } }
void nouveau_clear(GLcontext *ctx, GLbitfield buffers) { struct gl_framebuffer *fb = ctx->DrawBuffer; int x, y, w, h; int i, buf; nouveau_validate_framebuffer(ctx); get_scissors(fb, &x, &y, &w, &h); for (i = 0; i < BUFFER_COUNT; i++) { struct nouveau_surface *s; unsigned mask, value; buf = buffers & (1 << i); if (!buf) continue; s = &to_nouveau_renderbuffer( fb->Attachment[i].Renderbuffer->Wrapped)->surface; if (buf & BUFFER_BITS_COLOR) { mask = pack_rgba_i(s->format, ctx->Color.ColorMask[0]); value = pack_rgba_f(s->format, ctx->Color.ClearColor); if (mask) context_drv(ctx)->surface_fill( ctx, s, mask, value, x, y, w, h); buffers &= ~buf; } else if (buf & (BUFFER_BIT_DEPTH | BUFFER_BIT_STENCIL)) { mask = pack_zs_i(s->format, (buffers & BUFFER_BIT_DEPTH && ctx->Depth.Mask) ? ~0 : 0, (buffers & BUFFER_BIT_STENCIL ? ctx->Stencil.WriteMask[0] : 0)); value = pack_zs_f(s->format, ctx->Depth.Clear, ctx->Stencil.Clear); if (mask) context_drv(ctx)->surface_fill( ctx, s, mask, value, x, y, w, h); buffers &= ~(BUFFER_BIT_DEPTH | BUFFER_BIT_STENCIL); } } if (buffers) _mesa_meta_Clear(ctx, buffers); }
static void nouveau_render_texture(struct gl_context *ctx, struct gl_framebuffer *fb, struct gl_renderbuffer_attachment *att) { struct gl_renderbuffer *rb = att->Renderbuffer; struct gl_texture_image *ti = rb->TexImage; /* Update the renderbuffer fields from the texture. */ nouveau_surface_ref(&to_nouveau_teximage(ti)->surface, &to_nouveau_renderbuffer(rb)->surface); context_dirty(ctx, FRAMEBUFFER); }
static GLboolean set_renderbuffer_format(struct gl_renderbuffer *rb, GLenum internalFormat) { struct nouveau_surface *s = &to_nouveau_renderbuffer(rb)->surface; rb->InternalFormat = internalFormat; switch (internalFormat) { case GL_RGB: case GL_RGB8: rb->_BaseFormat = GL_RGB; rb->Format = MESA_FORMAT_XRGB8888; rb->DataType = GL_UNSIGNED_BYTE; s->cpp = 4; break; case GL_RGBA: case GL_RGBA8: rb->_BaseFormat = GL_RGBA; rb->Format = MESA_FORMAT_ARGB8888; rb->DataType = GL_UNSIGNED_BYTE; s->cpp = 4; break; case GL_RGB5: rb->_BaseFormat = GL_RGB; rb->Format = MESA_FORMAT_RGB565; rb->DataType = GL_UNSIGNED_BYTE; s->cpp = 2; break; case GL_DEPTH_COMPONENT16: rb->_BaseFormat = GL_DEPTH_COMPONENT; rb->Format = MESA_FORMAT_Z16; rb->DataType = GL_UNSIGNED_SHORT; s->cpp = 2; break; case GL_DEPTH_COMPONENT: case GL_DEPTH_COMPONENT24: case GL_STENCIL_INDEX8_EXT: case GL_DEPTH24_STENCIL8_EXT: rb->_BaseFormat = GL_DEPTH_STENCIL; rb->Format = MESA_FORMAT_Z24_S8; rb->DataType = GL_UNSIGNED_INT_24_8_EXT; s->cpp = 4; break; default: return GL_FALSE; } s->format = rb->Format; return GL_TRUE; }
static GLboolean set_renderbuffer_format(struct gl_renderbuffer *rb, GLenum internalFormat) { struct nouveau_surface *s = &to_nouveau_renderbuffer(rb)->surface; rb->InternalFormat = internalFormat; switch (internalFormat) { case GL_RGB: case GL_RGB8: rb->_BaseFormat = GL_RGB; rb->Format = MESA_FORMAT_B8G8R8X8_UNORM; s->cpp = 4; break; case GL_RGBA: case GL_RGBA8: rb->_BaseFormat = GL_RGBA; rb->Format = MESA_FORMAT_B8G8R8A8_UNORM; s->cpp = 4; break; case GL_RGB5: rb->_BaseFormat = GL_RGB; rb->Format = MESA_FORMAT_B5G6R5_UNORM; s->cpp = 2; break; case GL_DEPTH_COMPONENT16: rb->_BaseFormat = GL_DEPTH_COMPONENT; rb->Format = MESA_FORMAT_Z_UNORM16; s->cpp = 2; break; case GL_DEPTH_COMPONENT: case GL_DEPTH_COMPONENT24: case GL_STENCIL_INDEX8_EXT: case GL_DEPTH24_STENCIL8_EXT: rb->_BaseFormat = GL_DEPTH_STENCIL; rb->Format = MESA_FORMAT_S8_UINT_Z24_UNORM; s->cpp = 4; break; default: return GL_FALSE; } s->format = rb->Format; return GL_TRUE; }
static GLboolean nouveau_renderbuffer_storage(struct gl_context *ctx, struct gl_renderbuffer *rb, GLenum internalFormat, GLuint width, GLuint height) { struct nouveau_surface *s = &to_nouveau_renderbuffer(rb)->surface; if (!set_renderbuffer_format(rb, internalFormat)) return GL_FALSE; rb->Width = width; rb->Height = height; nouveau_surface_alloc(ctx, s, TILED, NOUVEAU_BO_VRAM | NOUVEAU_BO_MAP, rb->Format, width, height); context_dirty(ctx, FRAMEBUFFER); return GL_TRUE; }
static void setup_hierz_buffer(struct gl_context *ctx) { struct nouveau_pushbuf *push = context_push(ctx); struct gl_framebuffer *fb = ctx->DrawBuffer; struct nouveau_framebuffer *nfb = to_nouveau_framebuffer(fb); unsigned pitch = align(fb->Width, 128), height = align(fb->Height, 2), size = pitch * height; if (!nfb->hierz.bo || nfb->hierz.bo->size != size) { union nouveau_bo_config config = { .nv04.surf_flags = NV04_BO_ZETA, .nv04.surf_pitch = 0 }; nouveau_bo_ref(NULL, &nfb->hierz.bo); nouveau_bo_new(context_dev(ctx), NOUVEAU_BO_VRAM, 0, size, &config, &nfb->hierz.bo); } PUSH_SPACE(push, 11); BEGIN_NV04(push, NV17_3D(HIERZ_OFFSET), 1); PUSH_MTHDl(push, NV17_3D(HIERZ_OFFSET), BUFCTX_FB, nfb->hierz.bo, 0, NOUVEAU_BO_VRAM | NOUVEAU_BO_RDWR); BEGIN_NV04(push, NV17_3D(HIERZ_WINDOW_X), 4); PUSH_DATAf(push, - 1792); PUSH_DATAf(push, - 2304 + fb->Height); PUSH_DATAf(push, fb->_DepthMaxF / 2); PUSH_DATAf(push, 0); BEGIN_NV04(push, NV17_3D(HIERZ_PITCH), 1); PUSH_DATA (push, pitch); BEGIN_NV04(push, NV17_3D(HIERZ_ENABLE), 1); PUSH_DATA (push, 1); } void nv10_emit_framebuffer(struct gl_context *ctx, int emit) { struct nouveau_pushbuf *push = context_push(ctx); struct gl_framebuffer *fb = ctx->DrawBuffer; struct nouveau_surface *s; unsigned rt_format = NV10_3D_RT_FORMAT_TYPE_LINEAR; unsigned rt_pitch = 0, zeta_pitch = 0; unsigned bo_flags = NOUVEAU_BO_VRAM | NOUVEAU_BO_RDWR; if (fb->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) return; PUSH_RESET(push, BUFCTX_FB); /* At least nv11 seems to get sad if we don't do this before * swapping RTs.*/ if (context_eng3d(ctx)->oclass < NV17_3D_CLASS) { int i; for (i = 0; i < 6; i++) { BEGIN_NV04(push, NV04_GRAPH(3D, NOP), 1); PUSH_DATA (push, 0); } } /* Render target */ if (fb->_ColorDrawBuffers[0]) { s = &to_nouveau_renderbuffer( fb->_ColorDrawBuffers[0])->surface; rt_format |= get_rt_format(s->format); zeta_pitch = rt_pitch = s->pitch; BEGIN_NV04(push, NV10_3D(COLOR_OFFSET), 1); PUSH_MTHDl(push, NV10_3D(COLOR_OFFSET), BUFCTX_FB, s->bo, 0, bo_flags); } /* depth/stencil */ if (fb->Attachment[BUFFER_DEPTH].Renderbuffer) { s = &to_nouveau_renderbuffer( fb->Attachment[BUFFER_DEPTH].Renderbuffer)->surface; rt_format |= get_rt_format(s->format); zeta_pitch = s->pitch; BEGIN_NV04(push, NV10_3D(ZETA_OFFSET), 1); PUSH_MTHDl(push, NV10_3D(ZETA_OFFSET), BUFCTX_FB, s->bo, 0, bo_flags); if (context_eng3d(ctx)->oclass >= NV17_3D_CLASS) { setup_hierz_buffer(ctx); context_dirty(ctx, ZCLEAR); } } BEGIN_NV04(push, NV10_3D(RT_FORMAT), 2); PUSH_DATA (push, rt_format); PUSH_DATA (push, zeta_pitch << 16 | rt_pitch); context_dirty(ctx, VIEWPORT); context_dirty(ctx, SCISSOR); context_dirty(ctx, DEPTH); } void nv10_emit_render_mode(struct gl_context *ctx, int emit) { } void nv10_emit_scissor(struct gl_context *ctx, int emit) { struct nouveau_pushbuf *push = context_push(ctx); int x, y, w, h; get_scissors(ctx->DrawBuffer, &x, &y, &w, &h); BEGIN_NV04(push, NV10_3D(RT_HORIZ), 2); PUSH_DATA (push, w << 16 | x); PUSH_DATA (push, h << 16 | y); } void nv10_emit_viewport(struct gl_context *ctx, int emit) { struct nouveau_pushbuf *push = context_push(ctx); struct gl_viewport_attrib *vp = &ctx->ViewportArray[0]; struct gl_framebuffer *fb = ctx->DrawBuffer; float a[4] = {}; get_viewport_translate(ctx, a); a[0] -= 2048; a[1] -= 2048; if (nv10_use_viewport_zclear(ctx)) a[2] = nv10_transform_depth(ctx, (vp->Far + vp->Near) / 2); BEGIN_NV04(push, NV10_3D(VIEWPORT_TRANSLATE_X), 4); PUSH_DATAp(push, a, 4); BEGIN_NV04(push, NV10_3D(VIEWPORT_CLIP_HORIZ(0)), 1); PUSH_DATA (push, (fb->Width - 1) << 16 | 0x08000800); BEGIN_NV04(push, NV10_3D(VIEWPORT_CLIP_VERT(0)), 1); PUSH_DATA (push, (fb->Height - 1) << 16 | 0x08000800); context_dirty(ctx, PROJECTION); } void nv10_emit_zclear(struct gl_context *ctx, int emit) { struct nouveau_context *nctx = to_nouveau_context(ctx); struct nouveau_pushbuf *push = context_push(ctx); struct nouveau_framebuffer *nfb = to_nouveau_framebuffer(ctx->DrawBuffer); if (nfb->hierz.bo) { BEGIN_NV04(push, NV17_3D(ZCLEAR_ENABLE), 2); PUSH_DATAb(push, !nctx->hierz.clear_blocked); PUSH_DATA (push, nfb->hierz.clear_value | (nctx->hierz.clear_seq & 0xff)); } else { BEGIN_NV04(push, NV10_3D(DEPTH_RANGE_NEAR), 2); PUSH_DATAf(push, nv10_transform_depth(ctx, 0)); PUSH_DATAf(push, nv10_transform_depth(ctx, 1)); context_dirty(ctx, VIEWPORT); } }
void nv10_emit_framebuffer(struct gl_context *ctx, int emit) { struct nouveau_channel *chan = context_chan(ctx); struct nouveau_grobj *celsius = context_eng3d(ctx); struct nouveau_bo_context *bctx = context_bctx(ctx, FRAMEBUFFER); struct gl_framebuffer *fb = ctx->DrawBuffer; struct nouveau_surface *s; unsigned rt_format = NV10_3D_RT_FORMAT_TYPE_LINEAR; unsigned rt_pitch = 0, zeta_pitch = 0; unsigned bo_flags = NOUVEAU_BO_VRAM | NOUVEAU_BO_RDWR; if (fb->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) return; /* At least nv11 seems to get sad if we don't do this before * swapping RTs.*/ if (context_chipset(ctx) < 0x17) { int i; for (i = 0; i < 6; i++) { BEGIN_RING(chan, celsius, NV04_GRAPH_NOP, 1); OUT_RING(chan, 0); } } /* Render target */ if (fb->_ColorDrawBuffers[0]) { s = &to_nouveau_renderbuffer( fb->_ColorDrawBuffers[0])->surface; rt_format |= get_rt_format(s->format); zeta_pitch = rt_pitch = s->pitch; nouveau_bo_markl(bctx, celsius, NV10_3D_COLOR_OFFSET, s->bo, 0, bo_flags); } /* depth/stencil */ if (fb->Attachment[BUFFER_DEPTH].Renderbuffer) { s = &to_nouveau_renderbuffer( fb->Attachment[BUFFER_DEPTH].Renderbuffer)->surface; rt_format |= get_rt_format(s->format); zeta_pitch = s->pitch; nouveau_bo_markl(bctx, celsius, NV10_3D_ZETA_OFFSET, s->bo, 0, bo_flags); if (context_chipset(ctx) >= 0x17) { setup_hierz_buffer(ctx); context_dirty(ctx, ZCLEAR); } } BEGIN_RING(chan, celsius, NV10_3D_RT_FORMAT, 2); OUT_RING(chan, rt_format); OUT_RING(chan, zeta_pitch << 16 | rt_pitch); context_dirty(ctx, VIEWPORT); context_dirty(ctx, SCISSOR); }
void nouveau_clear(struct gl_context *ctx, GLbitfield buffers) { struct gl_framebuffer *fb = ctx->DrawBuffer; int x, y, w, h; int i, buf; nouveau_validate_framebuffer(ctx); get_scissors(fb, &x, &y, &w, &h); for (i = 0; i < BUFFER_COUNT; i++) { struct nouveau_surface *s; unsigned mask, value; buf = buffers & (1 << i); if (!buf) continue; s = &to_nouveau_renderbuffer( fb->Attachment[i].Renderbuffer)->surface; if (buf & BUFFER_BITS_COLOR) { const float *color = ctx->Color.ClearColor.f; if (fb->Attachment[i].Renderbuffer->_BaseFormat == GL_LUMINANCE_ALPHA) value = pack_la_clamp_f( s->format, color[0], color[3]); else value = pack_rgba_clamp_f(s->format, color); const uint8_t colormask[4] = { GET_COLORMASK_BIT(ctx->Color.ColorMask, 0, 0) ? 0xff : 0, GET_COLORMASK_BIT(ctx->Color.ColorMask, 0, 1) ? 0xff : 0, GET_COLORMASK_BIT(ctx->Color.ColorMask, 0, 2) ? 0xff : 0, GET_COLORMASK_BIT(ctx->Color.ColorMask, 0, 3) ? 0xff : 0, }; mask = pack_rgba_i(s->format, colormask); if (mask) context_drv(ctx)->surface_fill( ctx, s, mask, value, x, y, w, h); buffers &= ~buf; } else if (buf & (BUFFER_BIT_DEPTH | BUFFER_BIT_STENCIL)) { mask = pack_zs_i(s->format, (buffers & BUFFER_BIT_DEPTH && ctx->Depth.Mask) ? ~0 : 0, (buffers & BUFFER_BIT_STENCIL ? ctx->Stencil.WriteMask[0] : 0)); value = pack_zs_f(s->format, ctx->Depth.Clear, ctx->Stencil.Clear); if (mask) context_drv(ctx)->surface_fill( ctx, s, mask, value, x, y, w, h); buffers &= ~(BUFFER_BIT_DEPTH | BUFFER_BIT_STENCIL); } } if (buffers) _mesa_meta_Clear(ctx, buffers); }