reinterpret_cast<GrPlatform3DContext>(glctx.get()->gl());
context = GrContext::Create(kOpenGL_Shaders_GrEngine, ctx);
if (NULL != context) {
- GrPlatformSurfaceDesc desc;
- desc.reset();
+ GrPlatformRenderTargetDesc desc;
desc.fConfig = kRGBA_8888_GrPixelConfig;
desc.fWidth = contextWidth;
desc.fHeight = contextHeight;
desc.fStencilBits = 8;
- desc.fPlatformRenderTarget = glctx.get()->getFBOID();
- desc.fSurfaceType = kRenderTarget_GrPlatformSurfaceType;
- rt = static_cast<GrRenderTarget*>(context->createPlatformSurface(desc));
+ desc.fRenderTargetHandle = glctx.get()->getFBOID();
+ rt = context->createPlatformRenderTarget(desc);
if (NULL == rt) {
context->unref();
context = NULL;
reinterpret_cast<GrPlatform3DContext>(glContext.get()->gl());
gGrContext = GrContext::Create(kOpenGL_Shaders_GrEngine, ctx);
if (NULL != gGrContext) {
- GrPlatformSurfaceDesc desc;
- desc.reset();
+ GrPlatformRenderTargetDesc desc;
desc.fConfig = kRGBA_8888_GrPixelConfig;
desc.fWidth = maxW;
desc.fHeight = maxH;
desc.fStencilBits = 8;
- desc.fPlatformRenderTarget = glContext.get()->getFBOID();
- desc.fSurfaceType = kRenderTarget_GrPlatformSurfaceType;
- rt = static_cast<GrRenderTarget*>(gGrContext->createPlatformSurface(desc));
+ desc.fRenderTargetHandle = glContext.get()->getFBOID();
+ rt = gGrContext->createPlatformRenderTarget(desc);
if (NULL == rt) {
gGrContext->unref();
gGrContext = NULL;
// Platform Surfaces
/**
+ * Wraps an existing texture with a GrTexture object.
+ *
+ * OpenGL: if the object is a texture Gr may change its GL texture params
+ * when it is drawn.
+ *
+ * @param desc description of the object to create.
+ *
+ * @return GrTexture object or NULL on failure.
+ */
+ GrTexture* createPlatformTexture(const GrPlatformTextureDesc& desc);
+
+ /**
+ * Wraps an existing render target with a GrRenderTarget object. It is
+ * similar to createPlatformTexture but can be used to draw into surfaces
+ * that are not also textures (e.g. FBO 0 in OpenGL, or an MSAA buffer that
+ * the client will resolve to a texture).
+ *
+ * @param desc description of the object to create.
+ *
+ * @return GrTexture object or NULL on failure.
+ */
+ GrRenderTarget* createPlatformRenderTarget(
+ const GrPlatformRenderTargetDesc& desc);
+
+ /**
+ * This interface is depracted and will be removed in a future revision.
+ * Callers should use createPlatformTexture or createPlatformRenderTarget
+ * instead.
+ *
* Wraps an existing 3D API surface in a GrObject. desc.fFlags determines
* the type of object returned. If kIsTexture is set the returned object
* will be a GrTexture*. Otherwise, it will be a GrRenderTarget*. If both
///////////////////////////////////////////////////////////////////////////////
+// opaque type for 3D API object handles
+typedef intptr_t GrPlatform3DObject;
+
+/**
+ * Gr can wrap an existing texture created by the client with a GrTexture
+ * object. The client is responsible for ensuring that the texture lives at
+ * least as long as the GrTexture object wrapping it. We require the client to
+ * explicitly provide information about the texture, such as width, height,
+ * and pixel config, rather than querying the 3D APIfor these values. We expect
+ * these to be immutable even if the 3D API doesn't require this (OpenGL).
+ *
+ * Textures that are also render targets are supported as well. Gr will manage
+ * any ancillary 3D API (stencil buffer, FBO id, etc) objects necessary for
+ * Gr to draw into the render target. To access the render target object
+ * call GrTexture::asRenderTarget().
+ *
+ * If in addition to the render target flag, the caller also specifies a sample
+ * count Gr will create an MSAA buffer that resolves into the texture. Gr auto-
+ * resolves when it reads from the texture. The client can explictly resolve
+ * using the GrRenderTarget interface.
+ */
+
+enum GrPlatformTextureFlags {
+ /**
+ * No flags enabled
+ */
+ kNone_GrPlatformTextureFlag = 0x0,
+ /**
+ * Indicates that the texture is also a render target, and thus should have
+ * a GrRenderTarget object.
+ *
+ * D3D (future): client must have created the texture with flags that allow
+ * it to be used as a render target.
+ */
+ kRenderTarget_GrPlatformTextureFlag = 0x1,
+};
+GR_MAKE_BITFIELD_OPS(GrPlatformTextureFlags)
+
+struct GrPlatformTextureDesc {
+ GrPlatformTextureDesc() { memset(this, 0, sizeof(*this)); }
+ GrPlatformTextureFlags fFlags;
+ int fWidth; //<! width in pixels
+ int fHeight; //<! height in pixels
+ GrPixelConfig fConfig; //<! color format
+ /**
+ * If the render target flag is set and sample count is greater than 0
+ * then Gr will create an MSAA buffer that resolves to the texture.
+ */
+ int fSampleCnt;
+ /**
+ * Handle to the 3D API object.
+ * OpenGL: Texture ID.
+ */
+ GrPlatform3DObject fTextureHandle;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Gr can wrap an existing render target created by the client in the 3D API
+ * with a GrRenderTarget object. The client is responsible for ensuring that the
+ * underlying 3D API object lives at least as long as the GrRenderTarget object
+ * wrapping it. We require the client to explicitly provide information about
+ * the target, such as width, height, and pixel config rather than querying the
+ * 3D API for these values. We expect these properties to be immutable even if
+ * the 3D API doesn't require this (OpenGL).
+ */
+
+struct GrPlatformRenderTargetDesc {
+ GrPlatformRenderTargetDesc() { memset(this, 0, sizeof(*this)); }
+ int fWidth; //<! width in pixels
+ int fHeight; //<! height in pixels
+ GrPixelConfig fConfig; //<! color format
+ /**
+ * The number of samples per pixel. Gr uses this to influence decisions
+ * about applying other forms of antialiasing.
+ */
+ int fSampleCnt;
+ /**
+ * Number of bits of stencil per-pixel.
+ */
+ int fStencilBits;
+ /**
+ * Handle to the 3D API object.
+ * OpenGL: FBO ID
+ */
+ GrPlatform3DObject fRenderTargetHandle;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// DEPRECATED. createPlatformSurface is replaced by createPlatformTexture
+// and createPlatformRenderTarget. These enums and structs will be removed.
+
enum GrPlatformSurfaceType {
/**
* Specifies that the object being created is a render target.
GR_MAKE_BITFIELD_OPS(GrPlatformRenderTargetFlags)
-// opaque type for 3D API object handles
-typedef intptr_t GrPlatform3DObject;
-
-/**
- * Description of platform surface to create. See below for GL example.
- */
struct GrPlatformSurfaceDesc {
GrPlatformSurfaceType fSurfaceType; // type of surface to create
/**
if (fGrContext) {
win->attachGL();
- GrPlatformSurfaceDesc desc;
- desc.reset();
- desc.fSurfaceType = kRenderTarget_GrPlatformSurfaceType;
+ GrPlatformRenderTargetDesc desc;
desc.fWidth = SkScalarRound(win->width());
desc.fHeight = SkScalarRound(win->height());
desc.fConfig = kRGBA_8888_GrPixelConfig;
- GR_GL_GetIntegerv(fGL, GR_GL_STENCIL_BITS, &desc.fStencilBits);
GR_GL_GetIntegerv(fGL, GR_GL_SAMPLES, &desc.fSampleCnt);
+ GR_GL_GetIntegerv(fGL, GR_GL_STENCIL_BITS, &desc.fStencilBits);
GrGLint buffer;
GR_GL_GetIntegerv(fGL, GR_GL_FRAMEBUFFER_BINDING, &buffer);
- desc.fPlatformRenderTarget = buffer;
+ desc.fRenderTargetHandle = buffer;
SkSafeUnref(fGrRenderTarget);
- fGrRenderTarget = static_cast<GrRenderTarget*>(
- fGrContext->createPlatformSurface(desc));
+ fGrRenderTarget = fGrContext->createPlatformRenderTarget(desc);
}
if (NULL != fNullGrContext) {
- GrPlatformSurfaceDesc desc;
- desc.reset();
- desc.fSurfaceType = kRenderTarget_GrPlatformSurfaceType;
+ GrPlatformRenderTargetDesc desc;
desc.fWidth = SkScalarRound(win->width());
desc.fHeight = SkScalarRound(win->height());
desc.fConfig = kRGBA_8888_GrPixelConfig;
desc.fStencilBits = 8;
desc.fSampleCnt = 0;
- desc.fPlatformRenderTarget = 0;
- fNullGrRenderTarget = static_cast<GrRenderTarget*>(
- fNullGrContext->createPlatformSurface(desc));
+ desc.fRenderTargetHandle = 0;
+ fGrRenderTarget = fNullGrContext->createPlatformRenderTarget(desc);
}
}
///////////////////////////////////////////////////////////////////////////////
+GrTexture* GrContext::createPlatformTexture(const GrPlatformTextureDesc& desc) {
+ return fGpu->createPlatformTexture(desc);
+}
+
+GrRenderTarget* GrContext::createPlatformRenderTarget(const GrPlatformRenderTargetDesc& desc) {
+ return fGpu->createPlatformRenderTarget(desc);
+}
+
GrResource* GrContext::createPlatformSurface(const GrPlatformSurfaceDesc& desc) {
// validate flags here so that GrGpu subclasses don't have to check
if (kTexture_GrPlatformSurfaceType == desc.fSurfaceType &&
return this->textureFBOID();
}
virtual ResolveType getResolveType() const {
- if (fRTFBOID == fTexFBOID) {
+
+ if (!this->isMultisampled() ||
+ fRTFBOID == fTexFBOID) {
// catches FBO 0 and non MSAA case
return kAutoResolves_ResolveType;
} else if (kUnresolvableFBOID == fTexFBOID) {
}
}
+GrTexture* GrGpu::createPlatformTexture(const GrPlatformTextureDesc& desc) {
+ this->handleDirtyContext();
+ GrTexture* tex = this->onCreatePlatformTexture(desc);
+ // TODO: defer this and attach dynamically
+ GrRenderTarget* tgt = tex->asRenderTarget();
+ if (NULL != tgt &&
+ !this->attachStencilBufferToRenderTarget(tgt)) {
+ tex->unref();
+ return NULL;
+ } else {
+ return tex;
+ }
+}
+
+GrRenderTarget* GrGpu::createPlatformRenderTarget(const GrPlatformRenderTargetDesc& desc) {
+ this->handleDirtyContext();
+ return this->onCreatePlatformRenderTarget(desc);
+}
+
GrResource* GrGpu::createPlatformSurface(const GrPlatformSurfaceDesc& desc) {
this->handleDirtyContext();
return this->onCreatePlatformSurface(desc);
GrTexture* createTexture(const GrTextureDesc& desc,
const void* srcData, size_t rowBytes);
+ /**
+ * Implements GrContext::createPlatformTexture
+ */
+ GrTexture* createPlatformTexture(const GrPlatformTextureDesc& desc);
+
+ /**
+ * Implements GrContext::createPlatformTexture
+ */
+ GrRenderTarget* createPlatformRenderTarget(const GrPlatformRenderTargetDesc& desc);
+
+ /**
+ * DEPRECATED. This will be removed.
+ */
GrResource* createPlatformSurface(const GrPlatformSurfaceDesc& desc);
/**
virtual GrTexture* onCreateTexture(const GrTextureDesc& desc,
const void* srcData,
size_t rowBytes) = 0;
+ virtual GrTexture* onCreatePlatformTexture(const GrPlatformTextureDesc& desc) = 0;
+ virtual GrRenderTarget* onCreatePlatformRenderTarget(const GrPlatformRenderTargetDesc& desc) = 0;
virtual GrResource* onCreatePlatformSurface(const GrPlatformSurfaceDesc& desc) = 0;
virtual GrVertexBuffer* onCreateVertexBuffer(uint32_t size,
bool dynamic) = 0;
fHWDrawState.fRenderTarget = NULL;
}
+GrTexture* GrGpuGL::onCreatePlatformTexture(const GrPlatformTextureDesc& desc) {
+ GrGLenum internalFormat; // we don't need this value
+ GrGLTexture::Desc glTexDesc;
+ if (!this->canBeTexture(desc.fConfig, &internalFormat,
+ &glTexDesc.fUploadFormat, &glTexDesc.fUploadType)) {
+ return NULL;
+ }
+
+ glTexDesc.fContentWidth = glTexDesc.fAllocWidth = desc.fWidth;
+ glTexDesc.fContentHeight = glTexDesc.fAllocHeight = desc.fHeight;
+ glTexDesc.fConfig = desc.fConfig;
+ glTexDesc.fTextureID = static_cast<GrGLuint>(desc.fTextureHandle);
+ glTexDesc.fOwnsID = false;
+ glTexDesc.fOrientation = GrGLTexture::kBottomUp_Orientation;
+
+ GrGLTexture* texture = NULL;
+ if (desc.fFlags & kRenderTarget_GrPlatformTextureFlag) {
+ GrGLRenderTarget::Desc glRTDesc;
+ glRTDesc.fRTFBOID = 0;
+ glRTDesc.fTexFBOID = 0;
+ glRTDesc.fMSColorRenderbufferID = 0;
+ glRTDesc.fOwnIDs = true;
+ glRTDesc.fConfig = desc.fConfig;
+ glRTDesc.fSampleCnt = desc.fSampleCnt;
+ if (!this->createRenderTargetObjects(glTexDesc.fAllocWidth,
+ glTexDesc.fAllocHeight,
+ glTexDesc.fTextureID,
+ &glRTDesc)) {
+ return NULL;
+ }
+ texture = new GrGLTexture(this, glTexDesc, glRTDesc);
+ } else {
+ texture = new GrGLTexture(this, glTexDesc);
+ }
+ if (NULL == texture) {
+ return NULL;
+ }
+
+ this->setSpareTextureUnit();
+ return texture;
+}
+
+GrRenderTarget* GrGpuGL::onCreatePlatformRenderTarget(const GrPlatformRenderTargetDesc& desc) {
+ GrGLRenderTarget::Desc glDesc;
+ glDesc.fConfig = desc.fConfig;
+ glDesc.fRTFBOID = static_cast<GrGLuint>(desc.fRenderTargetHandle);
+ glDesc.fMSColorRenderbufferID = 0;
+ glDesc.fTexFBOID = GrGLRenderTarget::kUnresolvableFBOID;
+ glDesc.fSampleCnt = desc.fSampleCnt;
+ glDesc.fOwnIDs = false;
+ GrGLIRect viewport;
+ viewport.fLeft = 0;
+ viewport.fBottom = 0;
+ viewport.fWidth = desc.fWidth;
+ viewport.fHeight = desc.fHeight;
+
+ GrRenderTarget* tgt = new GrGLRenderTarget(this, glDesc, viewport);
+ if (desc.fStencilBits) {
+ GrGLStencilBuffer::Format format;
+ format.fInternalFormat = GrGLStencilBuffer::kUnknownInternalFormat;
+ format.fPacked = false;
+ format.fStencilBits = desc.fStencilBits;
+ format.fTotalBits = desc.fStencilBits;
+ GrGLStencilBuffer* sb = new GrGLStencilBuffer(this,
+ 0,
+ desc.fWidth,
+ desc.fHeight,
+ desc.fSampleCnt,
+ format);
+ tgt->setStencilBuffer(sb);
+ sb->unref();
+ }
+ return tgt;
+}
+
GrResource* GrGpuGL::onCreatePlatformSurface(const GrPlatformSurfaceDesc& desc) {
bool isTexture = kTexture_GrPlatformSurfaceType == desc.fSurfaceType ||
// If we are using multisampling we will create two FBOS. We render
// to one and then resolve to the texture bound to the other.
- if (desc->fSampleCnt > 1 && GLCaps::kNone_MSFBO != fGLCaps.fMSFBOType) {
+ if (desc->fSampleCnt > 0) {
+ if (GLCaps::kNone_MSFBO == fGLCaps.fMSFBOType) {
+ goto FAILED;
+ }
GL_CALL(GenFramebuffers(1, &desc->fRTFBOID));
GL_CALL(GenRenderbuffers(1, &desc->fMSColorRenderbufferID));
if (!desc->fRTFBOID ||
++fStats.fTextureCreateCnt;
#endif
- static const GrGLTexture::TexParams DEFAULT_PARAMS = {
- GR_GL_NEAREST,
- GR_GL_CLAMP_TO_EDGE,
- GR_GL_CLAMP_TO_EDGE
- };
-
GrGLTexture::Desc glTexDesc;
GrGLRenderTarget::Desc glRTDesc;
GrGLenum internalFormat;
this->setSpareTextureUnit();
GL_CALL(BindTexture(GR_GL_TEXTURE_2D, glTexDesc.fTextureID));
+
+ // Some drivers like to know these before seeing glTexImage2D. Some drivers
+ // have a bug where an FBO won't be complete if it includes a texture that
+ // is not complete (i.e. has mip levels or non-mip min filter).
+ static const GrGLTexture::TexParams DEFAULT_TEX_PARAMS = {
+ GR_GL_NEAREST,
+ GR_GL_CLAMP_TO_EDGE,
+ GR_GL_CLAMP_TO_EDGE
+ };
GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
GR_GL_TEXTURE_MAG_FILTER,
- DEFAULT_PARAMS.fFilter));
+ DEFAULT_TEX_PARAMS.fFilter));
GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
GR_GL_TEXTURE_MIN_FILTER,
- DEFAULT_PARAMS.fFilter));
+ DEFAULT_TEX_PARAMS.fFilter));
GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
GR_GL_TEXTURE_WRAP_S,
- DEFAULT_PARAMS.fWrapS));
+ DEFAULT_TEX_PARAMS.fWrapS));
GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
GR_GL_TEXTURE_WRAP_T,
- DEFAULT_PARAMS.fWrapT));
+ DEFAULT_TEX_PARAMS.fWrapT));
this->allocateAndUploadTexData(glTexDesc, internalFormat,srcData, rowBytes);
GrGLTexture* tex;
if (renderTarget) {
- GrGLenum msColorRenderbufferFormat = -1;
#if GR_COLLECT_STATS
++fStats.fRenderTargetCreateCnt;
#endif
} else {
tex = new GrGLTexture(this, glTexDesc);
}
- tex->setCachedTexParams(DEFAULT_PARAMS, this->getResetTimestamp());
+ tex->setCachedTexParams(DEFAULT_TEX_PARAMS, this->getResetTimestamp());
#ifdef TRACE_TEXTURE_CREATION
GrPrintf("--- new texture [%d] size=(%d %d) config=%d\n",
glTexDesc.fTextureID, desc.fWidth, desc.fHeight, desc.fConfig);
virtual GrIndexBuffer* onCreateIndexBuffer(uint32_t size,
bool dynamic);
virtual GrResource* onCreatePlatformSurface(const GrPlatformSurfaceDesc& desc);
+ virtual GrTexture* onCreatePlatformTexture(const GrPlatformTextureDesc& desc) SK_OVERRIDE;
+ virtual GrRenderTarget* onCreatePlatformRenderTarget(const GrPlatformRenderTargetDesc& desc) SK_OVERRIDE;
virtual bool createStencilBufferForRenderTarget(GrRenderTarget* rt,
int width, int height);
virtual bool attachStencilBufferToRenderTarget(GrStencilBuffer* sb,