blob: bda8529b8714ab2456fe0af18c8ce43b79036e54 [file] [log] [blame]
/*
* Copyright 2011 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "src/gpu/gl/GrGLRenderTarget.h"
#include "include/core/SkTraceMemoryDump.h"
#include "include/gpu/GrDirectContext.h"
#include "src/gpu/GrBackendUtils.h"
#include "src/gpu/GrDirectContextPriv.h"
#include "src/gpu/GrGpuResourcePriv.h"
#include "src/gpu/gl/GrGLGpu.h"
#include "src/gpu/gl/GrGLUtil.h"
#define GPUGL static_cast<GrGLGpu*>(this->getGpu())
#define GL_CALL(X) GR_GL_CALL(GPUGL->glInterface(), X)
// Because this class is virtually derived from GrSurface we must explicitly call its constructor.
// Constructor for wrapped render targets.
GrGLRenderTarget::GrGLRenderTarget(GrGLGpu* gpu,
const SkISize& dimensions,
GrGLFormat format,
int sampleCount,
const IDs& ids,
GrGLAttachment* stencil)
: GrSurface(gpu, dimensions, GrProtected::kNo)
, INHERITED(gpu, dimensions, sampleCount, GrProtected::kNo, stencil) {
this->setFlags(gpu->glCaps(), ids);
this->init(format, ids);
this->registerWithCacheWrapped(GrWrapCacheable::kNo);
}
GrGLRenderTarget::GrGLRenderTarget(GrGLGpu* gpu,
const SkISize& dimensions,
GrGLFormat format,
int sampleCount,
const IDs& ids)
: GrSurface(gpu, dimensions, GrProtected::kNo)
, INHERITED(gpu, dimensions, sampleCount, GrProtected::kNo) {
this->setFlags(gpu->glCaps(), ids);
this->init(format, ids);
}
inline void GrGLRenderTarget::setFlags(const GrGLCaps& glCaps, const IDs& idDesc) {
if (!idDesc.fRTFBOID) {
this->setGLRTFBOIDIs0();
}
}
void GrGLRenderTarget::init(GrGLFormat format, const IDs& idDesc) {
fRTFBOID = idDesc.fRTFBOID;
fTexFBOID = idDesc.fTexFBOID;
fMSColorRenderbufferID = idDesc.fMSColorRenderbufferID;
fRTFBOOwnership = idDesc.fRTFBOOwnership;
fRTFormat = format;
fNumSamplesOwnedPerPixel = this->totalSamples();
}
GrGLFormat stencil_bits_to_format(int stencilBits) {
SkASSERT(stencilBits);
switch (stencilBits) {
case 8:
// We pick the packed format here so when we query total size we are at least not
// underestimating the total size of the stencil buffer. However, in reality this
// rarely matters since we usually don't care about the size of wrapped objects.
return GrGLFormat::kDEPTH24_STENCIL8;
case 16:
return GrGLFormat::kSTENCIL_INDEX16;
default:
SkASSERT(false);
return GrGLFormat::kUnknown;
}
}
sk_sp<GrGLRenderTarget> GrGLRenderTarget::MakeWrapped(GrGLGpu* gpu,
const SkISize& dimensions,
GrGLFormat format,
int sampleCount,
const IDs& idDesc,
int stencilBits) {
GrGLAttachment* sb = nullptr;
if (stencilBits) {
GrGLAttachment::IDDesc sbDesc;
// We pick a "fake" actual format that matches the number of stencil bits. When wrapping
// an FBO with some number of stencil bits all we care about in the future is that we have
// a format with the same number of stencil bits. We don't even directly use the format or
// any other properties. Thus it is fine for us to just assign an arbitrary format that
// matches the stencil bit count.
GrGLFormat sFmt = stencil_bits_to_format(stencilBits);
// Ownership of sb is passed to the GrRenderTarget so doesn't need to be deleted
sb = new GrGLAttachment(gpu, sbDesc, dimensions,
GrAttachment::UsageFlags::kStencilAttachment, sampleCount, sFmt);
}
return sk_sp<GrGLRenderTarget>(
new GrGLRenderTarget(gpu, dimensions, format, sampleCount, idDesc, sb));
}
GrBackendRenderTarget GrGLRenderTarget::getBackendRenderTarget() const {
GrGLFramebufferInfo fbi;
fbi.fFBOID = fRTFBOID;
fbi.fFormat = GrGLFormatToEnum(this->format());
int numStencilBits = 0;
if (GrAttachment* stencil = this->getStencilAttachment()) {
numStencilBits = GrBackendFormatStencilBits(stencil->backendFormat());
}
return GrBackendRenderTarget(
this->width(), this->height(), this->numSamples(), numStencilBits, fbi);
}
GrBackendFormat GrGLRenderTarget::backendFormat() const {
// We should never have a GrGLRenderTarget (even a textureable one with a target that is not
// texture 2D.
return GrBackendFormat::MakeGL(GrGLFormatToEnum(fRTFormat), GR_GL_TEXTURE_2D);
}
size_t GrGLRenderTarget::onGpuMemorySize() const {
return GrSurface::ComputeSize(this->backendFormat(), this->dimensions(),
fNumSamplesOwnedPerPixel, GrMipmapped::kNo);
}
bool GrGLRenderTarget::completeStencilAttachment() {
GrGLGpu* gpu = this->getGLGpu();
const GrGLInterface* interface = gpu->glInterface();
GrAttachment* stencil = this->getStencilAttachment();
if (nullptr == stencil) {
GR_GL_CALL(interface, FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
GR_GL_STENCIL_ATTACHMENT,
GR_GL_RENDERBUFFER, 0));
GR_GL_CALL(interface, FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
GR_GL_DEPTH_ATTACHMENT,
GR_GL_RENDERBUFFER, 0));
#ifdef SK_DEBUG
if (!gpu->glCaps().skipErrorChecks()) {
// This check can cause problems in Chromium if the context has been asynchronously
// abandoned (see skbug.com/5200)
GrGLenum status;
GR_GL_CALL_RET(interface, status, CheckFramebufferStatus(GR_GL_FRAMEBUFFER));
SkASSERT(GR_GL_FRAMEBUFFER_COMPLETE == status);
}
#endif
return true;
} else {
const GrGLAttachment* glStencil = static_cast<const GrGLAttachment*>(stencil);
GrGLuint rb = glStencil->renderbufferID();
gpu->invalidateBoundRenderTarget();
gpu->bindFramebuffer(GR_GL_FRAMEBUFFER, this->renderFBOID());
GR_GL_CALL(interface, FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
GR_GL_STENCIL_ATTACHMENT,
GR_GL_RENDERBUFFER, rb));
if (GrGLFormatIsPackedDepthStencil(glStencil->format())) {
GR_GL_CALL(interface, FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
GR_GL_DEPTH_ATTACHMENT,
GR_GL_RENDERBUFFER, rb));
} else {
GR_GL_CALL(interface, FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
GR_GL_DEPTH_ATTACHMENT,
GR_GL_RENDERBUFFER, 0));
}
#ifdef SK_DEBUG
if (!gpu->glCaps().skipErrorChecks()) {
// This check can cause problems in Chromium if the context has been asynchronously
// abandoned (see skbug.com/5200)
GrGLenum status;
GR_GL_CALL_RET(interface, status, CheckFramebufferStatus(GR_GL_FRAMEBUFFER));
SkASSERT(GR_GL_FRAMEBUFFER_COMPLETE == status);
}
#endif
return true;
}
}
void GrGLRenderTarget::onRelease() {
if (GrBackendObjectOwnership::kBorrowed != fRTFBOOwnership) {
GrGLGpu* gpu = this->getGLGpu();
if (fTexFBOID) {
gpu->deleteFramebuffer(fTexFBOID);
}
if (fRTFBOID && fRTFBOID != fTexFBOID) {
gpu->deleteFramebuffer(fRTFBOID);
}
if (fMSColorRenderbufferID) {
GL_CALL(DeleteRenderbuffers(1, &fMSColorRenderbufferID));
}
}
fRTFBOID = 0;
fTexFBOID = 0;
fMSColorRenderbufferID = 0;
INHERITED::onRelease();
}
void GrGLRenderTarget::onAbandon() {
fRTFBOID = 0;
fTexFBOID = 0;
fMSColorRenderbufferID = 0;
INHERITED::onAbandon();
}
GrGLGpu* GrGLRenderTarget::getGLGpu() const {
SkASSERT(!this->wasDestroyed());
return static_cast<GrGLGpu*>(this->getGpu());
}
bool GrGLRenderTarget::canAttemptStencilAttachment() const {
if (this->getGpu()->getContext()->priv().caps()->avoidStencilBuffers()) {
return false;
}
// Only modify the FBO's attachments if we have created the FBO. Public APIs do not currently
// allow for borrowed FBO ownership, so we can safely assume that if an object is owned,
// Skia created it.
return this->fRTFBOOwnership == GrBackendObjectOwnership::kOwned;
}
void GrGLRenderTarget::dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const {
// Don't check this->fRefsWrappedObjects, as we might be the base of a GrGLTextureRenderTarget
// which is multiply inherited from both ourselves and a texture. In these cases, one part
// (texture, rt) may be wrapped, while the other is owned by Skia.
bool refsWrappedRenderTargetObjects =
this->fRTFBOOwnership == GrBackendObjectOwnership::kBorrowed;
if (refsWrappedRenderTargetObjects && !traceMemoryDump->shouldDumpWrappedObjects()) {
return;
}
// Don't log the framebuffer, as the framebuffer itself doesn't contribute to meaningful
// memory usage. It is always a wrapper around either:
// - a texture, which is owned elsewhere, and will be dumped there
// - a renderbuffer, which will be dumped below.
// Log any renderbuffer's contribution to memory.
if (fMSColorRenderbufferID) {
size_t size = GrSurface::ComputeSize(this->backendFormat(), this->dimensions(),
this->msaaSamples(), GrMipmapped::kNo);
// Due to this resource having both a texture and a renderbuffer component, dump as
// skia/gpu_resources/resource_#/renderbuffer
SkString resourceName = this->getResourceName();
resourceName.append("/renderbuffer");
this->dumpMemoryStatisticsPriv(traceMemoryDump, resourceName, "RenderTarget", size);
SkString renderbuffer_id;
renderbuffer_id.appendU32(fMSColorRenderbufferID);
traceMemoryDump->setMemoryBacking(resourceName.c_str(), "gl_renderbuffer",
renderbuffer_id.c_str());
}
}
int GrGLRenderTarget::msaaSamples() const {
if (fTexFBOID == kUnresolvableFBOID || fTexFBOID != fRTFBOID) {
// If the render target's FBO is external (fTexFBOID == kUnresolvableFBOID), or if we own
// the render target's FBO (fTexFBOID == fRTFBOID) then we use the provided sample count.
return this->numSamples();
}
// When fTexFBOID == fRTFBOID, we either are not using MSAA, or MSAA is auto resolving, so use
// 0 for the sample count.
return 0;
}
int GrGLRenderTarget::totalSamples() const {
int total_samples = this->msaaSamples();
if (fTexFBOID != kUnresolvableFBOID) {
// If we own the resolve buffer then that is one more sample per pixel.
total_samples += 1;
}
return total_samples;
}