AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove GrSurfaceDesc member from GrSurface.

Browse Source 
Change-Id: I0fe979994e1e3fc457b952dfb5e0090c45fad771
Reviewed-on: https://skia-review.googlesource.com/17273
Commit-Queue: Brian Salomon <bsalomon@google.com>
Reviewed-by: Robert Phillips <robertphillips@google.com>
This commit is contained in:
Brian Salomon 2017-05-18 12:30:34 -04:00 committed by Skia Commit-Bot
parent 955235fa13
commit 84911546b9
10 changed files with 68 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
include/gpu/GrRenderTarget.h
View File

@ -30,10 +30,10 @@ public:
const GrRenderTarget* asRenderTarget() const override { return this; }
// GrRenderTarget
bool isStencilBufferMultisampled() const { return fDesc.fSampleCnt > 0; }
bool isStencilBufferMultisampled() const { return fSampleCnt > 0; }
GrFSAAType fsaaType() const {
if (!fDesc.fSampleCnt) {
if (!fSampleCnt) {
SkASSERT(!(fFlags & Flags::kMixedSampled));
return GrFSAAType::kNone;
}
@ -44,13 +44,13 @@ public:
/**
* Returns the number of samples/pixel in the stencil buffer (Zero if non-MSAA).
*/
int numStencilSamples() const { return fDesc.fSampleCnt; }
int numStencilSamples() const { return fSampleCnt; }
/**
* Returns the number of samples/pixel in the color buffer (Zero if non-MSAA or mixed sampled).
*/
int numColorSamples() const {
return GrFSAAType::kMixedSamples == this->fsaaType() ? 0 : fDesc.fSampleCnt;
return GrFSAAType::kMixedSamples == this->fsaaType() ? 0 : fSampleCnt;
}
/**
@ -135,6 +135,7 @@ private:
friend class GrRenderTargetPriv;
friend class GrRenderTargetProxy; // for Flags
int fSampleCnt;
GrStencilAttachment* fStencilAttachment;
uint8_t fMultisampleSpecsID;
Flags fFlags;

25
include/gpu/GrSurface.h
View File

@ -23,12 +23,12 @@ public:
/**
* Retrieves the width of the surface.
*/
int width() const { return fDesc.fWidth; }
int width() const { return fWidth; }
/**
* Retrieves the height of the surface.
*/
int height() const { return fDesc.fHeight; }
int height() const { return fHeight; }
/**
* Helper that gets the width and height of the surface as a bounding rectangle.
@ -36,9 +36,8 @@ public:
SkRect getBoundsRect() const { return SkRect::MakeIWH(this->width(), this->height()); }
GrSurfaceOrigin origin() const {
SkASSERT(kTopLeft_GrSurfaceOrigin == fDesc.fOrigin ||
kBottomLeft_GrSurfaceOrigin == fDesc.fOrigin);
return fDesc.fOrigin;
SkASSERT(kTopLeft_GrSurfaceOrigin == fOrigin || kBottomLeft_GrSurfaceOrigin == fOrigin);
return fOrigin;
}
/**
@ -47,7 +46,7 @@ public:
* if client asked us to render to a target that has a pixel
* config that isn't equivalent with one of our configs.
*/
GrPixelConfig config() const { return fDesc.fConfig; }
GrPixelConfig config() const { return fConfig; }
/**
* @return the texture associated with the surface, may be null.
@ -79,17 +78,23 @@ protected:
friend class GrSurfacePriv;
GrSurface(GrGpu* gpu, const GrSurfaceDesc& desc)
: INHERITED(gpu)
, fDesc(desc) {
}
: INHERITED(gpu)
, fConfig(desc.fConfig)
, fWidth(desc.fWidth)
, fHeight(desc.fHeight)
, fOrigin(desc.fOrigin) {}
~GrSurface() override {}
GrSurfaceDesc fDesc;
void onRelease() override;
void onAbandon() override;
private:
GrPixelConfig fConfig;
int fWidth;
int fHeight;
GrSurfaceOrigin fOrigin;
typedef GrGpuResource INHERITED;
};

3
include/gpu/GrTexture.h
View File

@ -36,7 +36,6 @@ public:
#ifdef SK_DEBUG
void validate() const {
this->INHERITED::validate();
this->validateDesc();
}
#endif
@ -54,8 +53,6 @@ protected:
GrTexture(GrGpu*, const GrSurfaceDesc&, GrSLType samplerType,
GrSamplerParams::FilterMode highestFilterMode, bool wasMipMapDataProvided);
void validateDesc() const;
private:
void computeScratchKey(GrScratchKey*) const override;
size_t onGpuMemorySize() const override;

12
src/gpu/GrRenderTarget.cpp
View File

@ -19,11 +19,13 @@
GrRenderTarget::GrRenderTarget(GrGpu* gpu, const GrSurfaceDesc& desc, Flags flags,
GrStencilAttachment* stencil)
: INHERITED(gpu, desc)
, fStencilAttachment(stencil)
, fMultisampleSpecsID(0)
, fFlags(flags) {
SkASSERT(!(fFlags & Flags::kMixedSampled) || fDesc.fSampleCnt > 0);
: INHERITED(gpu, desc)
, fSampleCnt(desc.fSampleCnt)
, fStencilAttachment(stencil)
, fMultisampleSpecsID(0)
, fFlags(flags) {
SkASSERT(desc.fFlags & kRenderTarget_GrSurfaceFlag);
SkASSERT(!(fFlags & Flags::kMixedSampled) || fSampleCnt > 0);
SkASSERT(!(fFlags & Flags::kWindowRectsSupport) || gpu->caps()->maxWindowRectangles() > 0);
fResolveRect.setLargestInverted();
}

52
src/gpu/GrTexture.cpp
View File

@ -40,18 +40,7 @@ size_t GrTexture::onGpuMemorySize() const {
this->texturePriv().hasMipMaps(), false);
}
void GrTexture::validateDesc() const {
if (this->asRenderTarget()) {
// This texture has a render target
SkASSERT(0 != (fDesc.fFlags & kRenderTarget_GrSurfaceFlag));
SkASSERT(fDesc.fSampleCnt == this->asRenderTarget()->numColorSamples());
} else {
SkASSERT(0 == (fDesc.fFlags & kRenderTarget_GrSurfaceFlag));
SkASSERT(0 == fDesc.fSampleCnt);
}
}
//////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
namespace {
@ -79,7 +68,7 @@ GrTexture::GrTexture(GrGpu* gpu, const GrSurfaceDesc& desc, GrSLType samplerType
, fMipColorMode(SkDestinationSurfaceColorMode::kLegacy) {
if (wasMipMapDataProvided) {
fMipMapsStatus = kValid_MipMapsStatus;
fMaxMipMapLevel = SkMipMap::ComputeLevelCount(fDesc.fWidth, fDesc.fHeight);
fMaxMipMapLevel = SkMipMap::ComputeLevelCount(this->width(), this->height());
} else {
fMipMapsStatus = kNotAllocated_MipMapsStatus;
fMaxMipMapLevel = 0;
@ -87,27 +76,42 @@ GrTexture::GrTexture(GrGpu* gpu, const GrSurfaceDesc& desc, GrSLType samplerType
}
void GrTexture::computeScratchKey(GrScratchKey* key) const {
if (!GrPixelConfigIsCompressed(fDesc.fConfig)) {
GrTexturePriv::ComputeScratchKey(fDesc, key);
if (!GrPixelConfigIsCompressed(this->config())) {
const GrRenderTarget* rt = this->asRenderTarget();
int sampleCount = 0;
if (rt) {
sampleCount = rt->numStencilSamples();
}
GrTexturePriv::ComputeScratchKey(this->config(), this->width(), this->height(),
this->origin(), SkToBool(rt), sampleCount,
this->texturePriv().hasMipMaps(), key);
}
}
void GrTexturePriv::ComputeScratchKey(const GrSurfaceDesc& desc, GrScratchKey* key) {
void GrTexturePriv::ComputeScratchKey(GrPixelConfig config, int width, int height,
GrSurfaceOrigin origin, bool isRenderTarget, int sampleCnt,
bool isMipMapped, GrScratchKey* key) {
static const GrScratchKey::ResourceType kType = GrScratchKey::GenerateResourceType();
uint32_t flags = isRenderTarget;
GrSurfaceOrigin origin = resolve_origin(desc);
uint32_t flags = desc.fFlags;
SkASSERT(0 == sampleCnt || isRenderTarget);
// make sure desc.fConfig fits in 5 bits
SkASSERT(sk_float_log2(kLast_GrPixelConfig) <= 5);
SkASSERT(static_cast<int>(desc.fConfig) < (1 << 5));
SkASSERT(desc.fSampleCnt < (1 << 8));
SkASSERT(static_cast<int>(config) < (1 << 5));
SkASSERT(sampleCnt < (1 << 8));
SkASSERT(flags < (1 << 10));
SkASSERT(static_cast<int>(origin) < (1 << 8));
GrScratchKey::Builder builder(key, kType, 3);
builder[0] = desc.fWidth;
builder[1] = desc.fHeight;
builder[2] = desc.fConfig | (desc.fIsMipMapped << 5) | (desc.fSampleCnt << 6) | (flags << 14)
| (origin << 24);
builder[0] = width;
builder[1] = height;
builder[2] = config | (isMipMapped << 5) | (sampleCnt << 6) | (flags << 14) | (origin << 24);
}
void GrTexturePriv::ComputeScratchKey(const GrSurfaceDesc& desc, GrScratchKey* key) {
GrSurfaceOrigin origin = resolve_origin(desc);
return ComputeScratchKey(desc.fConfig, desc.fWidth, desc.fHeight, origin,
SkToBool(desc.fFlags & kRenderTarget_GrSurfaceFlag), desc.fSampleCnt,
desc.fIsMipMapped, key);
}

16
src/gpu/GrTexturePriv.h
View File

@ -17,18 +17,6 @@
implemented privately in GrTexture with a inline public method here). */
class GrTexturePriv {
public:
void setFlag(GrSurfaceFlags flags) {
fTexture->fDesc.fFlags = fTexture->fDesc.fFlags | flags;
}
void resetFlag(GrSurfaceFlags flags) {
fTexture->fDesc.fFlags = fTexture->fDesc.fFlags & ~flags;
}
bool isSetFlag(GrSurfaceFlags flags) const {
return 0 != (fTexture->fDesc.fFlags & flags);
}
void dirtyMipMaps(bool mipMapsDirty) {
fTexture->dirtyMipMaps(mipMapsDirty);
}
@ -70,6 +58,10 @@ public:
static void ComputeScratchKey(const GrSurfaceDesc&, GrScratchKey*);
private:
static void ComputeScratchKey(GrPixelConfig config, int width, int height,
GrSurfaceOrigin origin, bool isRenderTarget, int sampleCnt,
bool isMipMapped, GrScratchKey* key);
GrTexturePriv(GrTexture* texture) : fTexture(texture) { }
GrTexturePriv(const GrTexturePriv& that) : fTexture(that.fTexture) { }
GrTexturePriv& operator=(const GrTexturePriv&); // unimpl

6
src/gpu/gl/GrGLGpu.cpp
View File

@ -1524,12 +1524,12 @@ GrTexture* GrGLGpu::onCreateTexture(const GrSurfaceDesc& desc,
return return_null_texture();
}
bool renderTarget = SkToBool(desc.fFlags & kRenderTarget_GrSurfaceFlag);
bool isRenderTarget = SkToBool(desc.fFlags & kRenderTarget_GrSurfaceFlag);
GrGLTexture::IDDesc idDesc;
idDesc.fOwnership = GrBackendObjectOwnership::kOwned;
GrGLTexture::TexParams initialTexParams;
if (!this->createTextureImpl(desc, &idDesc.fInfo, renderTarget, &initialTexParams, texels)) {
if (!this->createTextureImpl(desc, &idDesc.fInfo, isRenderTarget, &initialTexParams, texels)) {
return return_null_texture();
}
@ -1539,7 +1539,7 @@ GrTexture* GrGLGpu::onCreateTexture(const GrSurfaceDesc& desc,
}
GrGLTexture* tex;
if (renderTarget) {
if (isRenderTarget) {
// unbind the texture from the texture unit before binding it to the frame buffer
GL_CALL(BindTexture(idDesc.fInfo.fTarget, 0));
GrGLRenderTarget::IDDesc rtIDDesc;

2
src/gpu/gl/GrGLRenderTarget.cpp
View File

@ -215,7 +215,7 @@ 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 SkTMax(1, fDesc.fSampleCnt);
return SkTMax(1, this->numStencilSamples());
}
// When fTexFBOID == fRTFBOID, we either are not using MSAA, or MSAA is auto resolving, so use

6
src/gpu/vk/GrVkTexture.cpp
View File

@ -186,7 +186,7 @@ bool GrVkTexture::reallocForMipmap(GrVkGpu* gpu, uint32_t mipLevels) {
return false;
}
bool renderTarget = SkToBool(fDesc.fFlags & kRenderTarget_GrSurfaceFlag);
bool renderTarget = SkToBool(this->asRenderTarget());
VkImageUsageFlags usageFlags = VK_IMAGE_USAGE_SAMPLED_BIT;
if (renderTarget) {
@ -197,8 +197,8 @@ bool GrVkTexture::reallocForMipmap(GrVkGpu* gpu, uint32_t mipLevels) {
GrVkImage::ImageDesc imageDesc;
imageDesc.fImageType = VK_IMAGE_TYPE_2D;
imageDesc.fFormat = fInfo.fFormat;
imageDesc.fWidth = fDesc.fWidth;
imageDesc.fHeight = fDesc.fHeight;
imageDesc.fWidth = this->width();
imageDesc.fHeight = this->height();
imageDesc.fLevels = mipLevels;
imageDesc.fSamples = 1;
imageDesc.fImageTiling = VK_IMAGE_TILING_OPTIMAL;

4
src/gpu/vk/GrVkTextureRenderTarget.cpp
View File

@ -152,8 +152,8 @@ GrVkTextureRenderTarget::MakeWrappedTextureRenderTarget(GrVkGpu* gpu,
bool GrVkTextureRenderTarget::updateForMipmap(GrVkGpu* gpu, const GrVkImageInfo& newInfo) {
VkFormat pixelFormat;
GrPixelConfigToVkFormat(fDesc.fConfig, &pixelFormat);
if (fDesc.fSampleCnt) {
GrPixelConfigToVkFormat(this->config(), &pixelFormat);
if (this->numStencilSamples()) {
const GrVkImageView* resolveAttachmentView =
GrVkImageView::Create(gpu,
newInfo.fImage,