2012-06-21 21:09:06 +00:00
|
|
|
/*
|
|
|
|
* Copyright 2012 Google Inc.
|
|
|
|
*
|
|
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
|
|
* found in the LICENSE file.
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
#ifndef GrSurface_DEFINED
|
|
|
|
#define GrSurface_DEFINED
|
|
|
|
|
|
|
|
#include "GrTypes.h"
|
2014-07-25 15:35:45 +00:00
|
|
|
#include "GrGpuResource.h"
|
2014-09-30 19:18:44 +00:00
|
|
|
#include "SkImageInfo.h"
|
2013-08-14 21:56:37 +00:00
|
|
|
#include "SkRect.h"
|
2012-06-21 21:09:06 +00:00
|
|
|
|
2016-10-25 18:20:06 +00:00
|
|
|
class GrOpList;
|
2014-09-30 13:58:20 +00:00
|
|
|
class GrRenderTarget;
|
2014-09-30 19:18:44 +00:00
|
|
|
class GrSurfacePriv;
|
|
|
|
class GrTexture;
|
2012-06-21 21:09:06 +00:00
|
|
|
|
2015-07-08 14:53:10 +00:00
|
|
|
class SK_API GrSurface : public GrGpuResource {
|
2012-06-21 21:09:06 +00:00
|
|
|
public:
|
|
|
|
/**
|
|
|
|
* Retrieves the width of the surface.
|
|
|
|
*/
|
|
|
|
int width() const { return fDesc.fWidth; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Retrieves the height of the surface.
|
|
|
|
*/
|
|
|
|
int height() const { return fDesc.fHeight; }
|
|
|
|
|
2013-08-14 21:56:37 +00:00
|
|
|
/**
|
|
|
|
* Helper that gets the width and height of the surface as a bounding rectangle.
|
|
|
|
*/
|
2016-08-31 22:06:24 +00:00
|
|
|
SkRect getBoundsRect() const { return SkRect::MakeIWH(this->width(), this->height()); }
|
2013-08-14 21:56:37 +00:00
|
|
|
|
2013-01-28 16:42:38 +00:00
|
|
|
GrSurfaceOrigin origin() const {
|
2013-08-17 00:02:59 +00:00
|
|
|
SkASSERT(kTopLeft_GrSurfaceOrigin == fDesc.fOrigin || kBottomLeft_GrSurfaceOrigin == fDesc.fOrigin);
|
2013-02-05 19:50:46 +00:00
|
|
|
return fDesc.fOrigin;
|
2012-10-26 19:01:17 +00:00
|
|
|
}
|
|
|
|
|
2012-06-21 21:09:06 +00:00
|
|
|
/**
|
|
|
|
* Retrieves the pixel config specified when the surface was created.
|
|
|
|
* For render targets this can be kUnknown_GrPixelConfig
|
|
|
|
* 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; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Return the descriptor describing the surface
|
|
|
|
*/
|
2014-10-28 21:33:06 +00:00
|
|
|
const GrSurfaceDesc& desc() const { return fDesc; }
|
2012-06-21 21:09:06 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @return the texture associated with the surface, may be NULL.
|
|
|
|
*/
|
2014-11-03 16:47:23 +00:00
|
|
|
virtual GrTexture* asTexture() { return NULL; }
|
|
|
|
virtual const GrTexture* asTexture() const { return NULL; }
|
2012-06-21 21:09:06 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @return the render target underlying this surface, may be NULL.
|
|
|
|
*/
|
2014-11-03 16:47:23 +00:00
|
|
|
virtual GrRenderTarget* asRenderTarget() { return NULL; }
|
|
|
|
virtual const GrRenderTarget* asRenderTarget() const { return NULL; }
|
2012-06-21 21:09:06 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Reads a rectangle of pixels from the surface.
|
|
|
|
* @param left left edge of the rectangle to read (inclusive)
|
|
|
|
* @param top top edge of the rectangle to read (inclusive)
|
|
|
|
* @param width width of rectangle to read in pixels.
|
|
|
|
* @param height height of rectangle to read in pixels.
|
|
|
|
* @param config the pixel config of the destination buffer
|
|
|
|
* @param buffer memory to read the rectangle into.
|
2012-10-26 19:01:17 +00:00
|
|
|
* @param rowBytes number of bytes between consecutive rows. Zero means rows are tightly
|
2012-08-20 19:22:38 +00:00
|
|
|
* packed.
|
|
|
|
* @param pixelOpsFlags See the GrContext::PixelOpsFlags enum.
|
2012-06-21 21:09:06 +00:00
|
|
|
*
|
2012-08-20 19:22:38 +00:00
|
|
|
* @return true if the read succeeded, false if not. The read can fail because of an unsupported
|
|
|
|
* pixel config.
|
2012-06-21 21:09:06 +00:00
|
|
|
*/
|
2014-10-13 19:32:55 +00:00
|
|
|
bool readPixels(int left, int top, int width, int height,
|
|
|
|
GrPixelConfig config,
|
|
|
|
void* buffer,
|
|
|
|
size_t rowBytes = 0,
|
|
|
|
uint32_t pixelOpsFlags = 0);
|
2012-06-21 21:09:06 +00:00
|
|
|
|
|
|
|
/**
|
2012-08-20 19:22:38 +00:00
|
|
|
* Copy the src pixels [buffer, rowbytes, pixelconfig] into the surface at the specified
|
|
|
|
* rectangle.
|
2012-06-21 21:09:06 +00:00
|
|
|
* @param left left edge of the rectangle to write (inclusive)
|
|
|
|
* @param top top edge of the rectangle to write (inclusive)
|
|
|
|
* @param width width of rectangle to write in pixels.
|
|
|
|
* @param height height of rectangle to write in pixels.
|
|
|
|
* @param config the pixel config of the source buffer
|
|
|
|
* @param buffer memory to read the rectangle from.
|
2012-10-26 19:01:17 +00:00
|
|
|
* @param rowBytes number of bytes between consecutive rows. Zero means rows are tightly
|
2012-08-20 19:22:38 +00:00
|
|
|
* packed.
|
|
|
|
* @param pixelOpsFlags See the GrContext::PixelOpsFlags enum.
|
2014-10-14 18:47:22 +00:00
|
|
|
*
|
2016-05-05 19:24:31 +00:00
|
|
|
* @return true if the write succeeded, false if not. The write can fail because of an
|
2016-01-26 17:10:48 +00:00
|
|
|
* unsupported pixel config.
|
2012-06-21 21:09:06 +00:00
|
|
|
*/
|
2014-10-13 19:32:55 +00:00
|
|
|
bool writePixels(int left, int top, int width, int height,
|
|
|
|
GrPixelConfig config,
|
|
|
|
const void* buffer,
|
|
|
|
size_t rowBytes = 0,
|
|
|
|
uint32_t pixelOpsFlags = 0);
|
2012-06-21 21:09:06 +00:00
|
|
|
|
2014-10-07 12:56:02 +00:00
|
|
|
/**
|
|
|
|
* After this returns any pending writes to the surface will be issued to the backend 3D API.
|
|
|
|
*/
|
|
|
|
void flushWrites();
|
|
|
|
|
2014-09-30 19:18:44 +00:00
|
|
|
/** Access methods that are only to be used within Skia code. */
|
|
|
|
inline GrSurfacePriv surfacePriv();
|
|
|
|
inline const GrSurfacePriv surfacePriv() const;
|
2014-09-30 13:58:20 +00:00
|
|
|
|
2015-06-18 20:41:40 +00:00
|
|
|
typedef void* ReleaseCtx;
|
|
|
|
typedef void (*ReleaseProc)(ReleaseCtx);
|
2015-06-26 18:45:03 +00:00
|
|
|
|
2015-06-18 20:41:40 +00:00
|
|
|
void setRelease(ReleaseProc proc, ReleaseCtx ctx) {
|
|
|
|
fReleaseProc = proc;
|
|
|
|
fReleaseCtx = ctx;
|
|
|
|
}
|
|
|
|
|
2016-10-25 18:20:06 +00:00
|
|
|
void setLastOpList(GrOpList* opList);
|
|
|
|
GrOpList* getLastOpList() { return fLastOpList; }
|
|
|
|
|
2016-11-17 19:43:51 +00:00
|
|
|
static size_t WorstCaseSize(const GrSurfaceDesc& desc, bool useNextPow2 = false);
|
|
|
|
static size_t ComputeSize(const GrSurfaceDesc& desc, int colorSamplesPerPixel,
|
|
|
|
bool hasMIPMaps, bool useNextPow2 = false);
|
2016-11-07 13:23:48 +00:00
|
|
|
|
2014-09-30 19:18:44 +00:00
|
|
|
protected:
|
|
|
|
// Methods made available via GrSurfacePriv
|
|
|
|
bool savePixels(const char* filename);
|
2014-09-22 19:21:08 +00:00
|
|
|
bool hasPendingRead() const;
|
|
|
|
bool hasPendingWrite() const;
|
|
|
|
bool hasPendingIO() const;
|
2014-09-30 19:18:44 +00:00
|
|
|
|
|
|
|
// Provides access to methods that should be public within Skia code.
|
|
|
|
friend class GrSurfacePriv;
|
2014-09-22 19:21:08 +00:00
|
|
|
|
Refactor to separate backend object lifecycle and GpuResource budget decision
Refactor GrGpuResource to contain two different pieces of state:
a) instance is budgeted or not budgeted
b) instance references wrapped backend objects or not
The "object lifecycle" was also attached to backend object
handles (ids), which made the code a bit unclear. Backend objects
would be associated with GrGpuResource::LifeCycle, even though
GrGpuResource::LifeCycle refers to the GpuResource, and individual
backend objects in one GpuResource might be governed with different
"lifecycle".
Mark the budgeted/not budgeted with SkBudgeted::kYes, SkBudgeted::kNo.
This was previously GrGpuResource::kCached_LifeCycle,
GrGpuResource::kUncached_LifeCycle.
Mark the "references wrapped object" with boolean. This was previously
GrGpuResource::kBorrowed_LifeCycle,
GrGpuResource::kAdopted_LifeCycle for GrGpuResource.
Associate the backend object ownership status with
GrBackendObjectOwnership for the backend object handles.
The resource type leaf constuctors, such has GrGLTexture or
GrGLTextureRenderTarget take "budgeted" parameter. This parameter
is passed to GrGpuResource::registerWithCache().
The resource type intermediary constructors, such as GrGLTexture
constructors for class GrGLTextureRenderTarget do not take "budgeted"
parameters, intermediary construtors do not call registerWithCache.
Removes the need for tagging GrGpuResource -derived subclass
constructors with "Derived" parameter.
Makes instances that wrap backend objects be registered with
a new function GrGpuResource::registerWithCacheWrapped().
Removes "budgeted" parameter from classes such as StencilAttahment, as
they are always cached and never wrap any external backend objects.
Removes the use of concept "external" from the member function names.
The API refers to the objects as "wrapped", so make all related
functions use the term consistently.
No change in functionality. Resources referencing wrapped objects are
always inserted to the cache with budget decision kNo.
BUG=594928
GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1862043002
Review URL: https://codereview.chromium.org/1862043002
2016-04-22 08:48:29 +00:00
|
|
|
GrSurface(GrGpu* gpu, const GrSurfaceDesc& desc)
|
|
|
|
: INHERITED(gpu)
|
2015-06-18 20:41:40 +00:00
|
|
|
, fDesc(desc)
|
|
|
|
, fReleaseProc(NULL)
|
|
|
|
, fReleaseCtx(NULL)
|
2016-10-25 18:20:06 +00:00
|
|
|
, fLastOpList(nullptr) {
|
2012-06-21 21:09:06 +00:00
|
|
|
}
|
2016-10-25 18:20:06 +00:00
|
|
|
~GrSurface() override;
|
2012-06-21 21:09:06 +00:00
|
|
|
|
2014-10-28 21:33:06 +00:00
|
|
|
GrSurfaceDesc fDesc;
|
2012-10-26 19:01:17 +00:00
|
|
|
|
2015-06-18 21:05:07 +00:00
|
|
|
void onRelease() override;
|
|
|
|
void onAbandon() override;
|
|
|
|
|
|
|
|
private:
|
2015-06-18 20:41:40 +00:00
|
|
|
void invokeReleaseProc() {
|
|
|
|
if (fReleaseProc) {
|
|
|
|
fReleaseProc(fReleaseCtx);
|
|
|
|
fReleaseProc = NULL;
|
|
|
|
}
|
|
|
|
}
|
2015-06-26 18:45:03 +00:00
|
|
|
|
2015-06-18 20:41:40 +00:00
|
|
|
ReleaseProc fReleaseProc;
|
|
|
|
ReleaseCtx fReleaseCtx;
|
|
|
|
|
2016-10-25 18:20:06 +00:00
|
|
|
// The last opList that wrote to or is currently going to write to this surface
|
2016-10-27 18:47:55 +00:00
|
|
|
// The opList can be closed (e.g., no render target or texture context is currently bound
|
2016-10-25 18:20:06 +00:00
|
|
|
// to this renderTarget or texture).
|
|
|
|
// This back-pointer is required so that we can add a dependancy between
|
|
|
|
// the opList used to create the current contents of this surface
|
|
|
|
// and the opList of a destination surface to which this one is being drawn or copied.
|
|
|
|
GrOpList* fLastOpList;
|
|
|
|
|
2014-07-25 15:35:45 +00:00
|
|
|
typedef GrGpuResource INHERITED;
|
2012-06-21 21:09:06 +00:00
|
|
|
};
|
|
|
|
|
2014-09-30 19:18:44 +00:00
|
|
|
#endif
|