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

Rename GrTextureAccess to GrProcessor::TextureSampler.

Browse Source 
Renames vars and methods that used the work "access" to refer to this type.

GOLD_TRYBOT_URL= https://gold.skia.org/search?issue=4931

Change-Id: Ibcf488fbd445c5119fc13d190544cd98981bdbee
Reviewed-on: https://skia-review.googlesource.com/4931
Commit-Queue: Brian Salomon <bsalomon@google.com>
Reviewed-by: Greg Daniel <egdaniel@google.com>
This commit is contained in:
Brian Salomon 2016-11-17 11:38:22 -05:00 committed by Skia Commit-Bot
parent 9de097639f
commit 0bbecb21ab
53 changed files with 303 additions and 333 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.cpp
View File

@ -683,25 +683,25 @@ private:
: fType(type)
, fNumOctaves(numOctaves)
, fStitchTiles(stitchTiles)
, fPermutationsAccess(permutationsTexture)
, fNoiseAccess(noiseTexture)
, fPermutationsSampler(permutationsTexture)
, fNoiseSampler(noiseTexture)
, fPaintingData(paintingData) {
this->initClassID<GrPerlinNoise2Effect>();
this->addTextureAccess(&fPermutationsAccess);
this->addTextureAccess(&fNoiseAccess);
this->addTextureSampler(&fPermutationsSampler);
this->addTextureSampler(&fNoiseSampler);
fCoordTransform.reset(matrix);
this->addCoordTransform(&fCoordTransform);
}
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
SkPerlinNoiseShader2::Type fType;
GrCoordTransform fCoordTransform;
int fNumOctaves;
bool fStitchTiles;
GrTextureAccess fPermutationsAccess;
GrTextureAccess fNoiseAccess;
SkPerlinNoiseShader2::PaintingData *fPaintingData;
SkPerlinNoiseShader2::Type fType;
GrCoordTransform fCoordTransform;
int fNumOctaves;
bool fStitchTiles;
TextureSampler fPermutationsSampler;
TextureSampler fNoiseSampler;
SkPerlinNoiseShader2::PaintingData* fPaintingData;
private:
typedef GrFragmentProcessor INHERITED;
@ -1093,24 +1093,24 @@ private:
const SkMatrix& matrix)
: fOctaves(octaves)
, fZ(z)
, fPermutationsAccess(permutationsTexture)
, fGradientAccess(gradientTexture)
, fPermutationsSampler(permutationsTexture)
, fGradientSampler(gradientTexture)
, fPaintingData(paintingData) {
this->initClassID<GrImprovedPerlinNoiseEffect>();
this->addTextureAccess(&fPermutationsAccess);
this->addTextureAccess(&fGradientAccess);
this->addTextureSampler(&fPermutationsSampler);
this->addTextureSampler(&fGradientSampler);
fCoordTransform.reset(matrix);
this->addCoordTransform(&fCoordTransform);
}
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
GrCoordTransform fCoordTransform;
int fOctaves;
SkScalar fZ;
GrTextureAccess fPermutationsAccess;
GrTextureAccess fGradientAccess;
SkPerlinNoiseShader2::PaintingData *fPaintingData;
GrCoordTransform fCoordTransform;
int fOctaves;
SkScalar fZ;
TextureSampler fPermutationsSampler;
TextureSampler fGradientSampler;
SkPerlinNoiseShader2::PaintingData* fPaintingData;
private:
typedef GrFragmentProcessor INHERITED;

2
gn/gpu.gni
View File

@ -35,7 +35,6 @@ skia_gpu_sources = [
"$_include/gpu/GrTexture.h",
"$_include/gpu/GrTextureParams.h",
"$_include/gpu/GrTextureProvider.h",
"$_include/gpu/GrTextureAccess.h",
"$_include/gpu/GrTestUtils.h",
"$_include/gpu/GrTypes.h",
"$_include/gpu/GrTypesPriv.h",
@ -204,7 +203,6 @@ skia_gpu_sources = [
"$_src/gpu/GrTextureRenderTargetProxy.cpp",
"$_src/gpu/GrTextureToYUVPlanes.cpp",
"$_src/gpu/GrTextureToYUVPlanes.h",
"$_src/gpu/GrTextureAccess.cpp",
"$_src/gpu/GrTRecorder.h",
"$_src/gpu/GrUserStencilSettings.h",
"$_src/gpu/GrWindowRectangles.h",

6
include/gpu/GrFragmentProcessor.h
View File

@ -183,10 +183,10 @@ public:
&GrFragmentProcessor::numCoordTransforms,
&GrFragmentProcessor::coordTransform>;
using TextureAccessIter = FPItemIter<GrTextureAccess,
using TextureAccessIter = FPItemIter<TextureSampler,
GrProcessor,
&GrProcessor::numTextures,
&GrProcessor::textureAccess>;
&GrProcessor::numTextureSamplers,
&GrProcessor::textureSampler>;
protected:
/**

74
include/gpu/GrProcessor.h
View File

@ -11,7 +11,6 @@
#include "GrColor.h"
#include "GrProcessorUnitTest.h"
#include "GrProgramElement.h"
#include "GrTextureAccess.h"
#include "GrBufferAccess.h"
#include "SkMath.h"
#include "SkString.h"
@ -59,6 +58,8 @@ private:
*/
class GrProcessor : public GrProgramElement {
public:
class TextureSampler;
virtual ~GrProcessor();
/** Human-meaningful string to identify this prcoessor; may be embedded
@ -72,14 +73,11 @@ public:
return str;
}
int numTextures() const { return fTextureAccesses.count(); }
int numTextureSamplers() const { return fTextureSamplers.count(); }
/** Returns the access pattern for the texture at index. index must be valid according to
numTextures(). */
const GrTextureAccess& textureAccess(int index) const { return *fTextureAccesses[index]; }
/** Shortcut for textureAccess(index).texture(); */
GrTexture* texture(int index) const { return this->textureAccess(index).getTexture(); }
numTextureSamplers(). */
const TextureSampler& textureSampler(int index) const { return *fTextureSamplers[index]; }
int numBuffers() const { return fBufferAccesses.count(); }
@ -125,11 +123,11 @@ protected:
/**
* Subclasses call these from their constructor to register sampler sources. The processor
* subclass manages the lifetime of the objects (these functions only store pointers). The
* GrTextureAccess and/or GrBufferAccess instances are typically member fields of the
* TextureSampler and/or GrBufferAccess instances are typically member fields of the
* GrProcessor subclass. These must only be called from the constructor because GrProcessors
* are immutable.
*/
void addTextureAccess(const GrTextureAccess* textureAccess);
void addTextureSampler(const TextureSampler*);
void addBufferAccess(const GrBufferAccess* bufferAccess);
bool hasSameSamplers(const GrProcessor&) const;
@ -171,12 +169,66 @@ private:
static int32_t gCurrProcessorClassID;
RequiredFeatures fRequiredFeatures;
SkSTArray<4, const GrTextureAccess*, true> fTextureAccesses;
SkSTArray<2, const GrBufferAccess*, true> fBufferAccesses;
SkSTArray<4, const TextureSampler*, true> fTextureSamplers;
SkSTArray<2, const GrBufferAccess*, true> fBufferAccesses;
typedef GrProgramElement INHERITED;
};
GR_MAKE_BITFIELD_OPS(GrProcessor::RequiredFeatures);
/**
* Used to represent a texture that is required by a GrProcessor. It holds a GrTexture along with
* an associated GrTextureParams
*/
class GrProcessor::TextureSampler : public SkNoncopyable {
public:
/**
* Must be initialized before adding to a GrProcessor's texture access list.
*/
TextureSampler();
TextureSampler(GrTexture*, const GrTextureParams&);
explicit TextureSampler(GrTexture*,
GrTextureParams::FilterMode = GrTextureParams::kNone_FilterMode,
SkShader::TileMode tileXAndY = SkShader::kClamp_TileMode,
GrShaderFlags visibility = kFragment_GrShaderFlag);
void reset(GrTexture*, const GrTextureParams&,
GrShaderFlags visibility = kFragment_GrShaderFlag);
void reset(GrTexture*,
GrTextureParams::FilterMode = GrTextureParams::kNone_FilterMode,
SkShader::TileMode tileXAndY = SkShader::kClamp_TileMode,
GrShaderFlags visibility = kFragment_GrShaderFlag);
bool operator==(const TextureSampler& that) const {
return this->getTexture() == that.getTexture() &&
fParams == that.fParams &&
fVisibility == that.fVisibility;
}
bool operator!=(const TextureSampler& other) const { return !(*this == other); }
GrTexture* getTexture() const { return fTexture.get(); }
GrShaderFlags getVisibility() const { return fVisibility; }
/**
* For internal use by GrProcessor.
*/
const GrGpuResourceRef* getProgramTexture() const { return &fTexture; }
const GrTextureParams& getParams() const { return fParams; }
private:
typedef GrTGpuResourceRef<GrTexture> ProgramTexture;
ProgramTexture fTexture;
GrTextureParams fParams;
GrShaderFlags fVisibility;
typedef SkNoncopyable INHERITED;
};
#endif

2
include/gpu/GrProcessorUnitTest.h
View File

@ -36,7 +36,7 @@ sk_sp<GrFragmentProcessor> MakeChildFP(GrProcessorTestData*);
/*
* GrProcessorTestData is an argument struct to TestCreate functions
* fTextures are valid textures that can optionally be used to construct
* GrTextureAccesses. The first texture has config kSkia8888_GrPixelConfig and the second has
* TextureSampler. The first texture has config kSkia8888_GrPixelConfig and the second has
* kAlpha_8_GrPixelConfig. TestCreate functions are also free to create additional textures using
* the GrContext.
*/

71
include/gpu/GrTextureAccess.h
View File

@ -1,71 +0,0 @@
/*
* 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 GrTextureAccess_DEFINED
#define GrTextureAccess_DEFINED
#include "GrGpuResourceRef.h"
#include "GrTexture.h"
#include "GrTextureParams.h"
#include "SkRefCnt.h"
#include "SkShader.h"
/**
* Used to represent a texture that is required by a GrProcessor. It holds a GrTexture along with
* an associated GrTextureParams
*/
class GrTextureAccess : public SkNoncopyable {
public:
/**
* Must be initialized before adding to a GrProcessor's texture access list.
*/
GrTextureAccess();
GrTextureAccess(GrTexture*, const GrTextureParams&);
explicit GrTextureAccess(GrTexture*,
GrTextureParams::FilterMode = GrTextureParams::kNone_FilterMode,
SkShader::TileMode tileXAndY = SkShader::kClamp_TileMode,
GrShaderFlags visibility = kFragment_GrShaderFlag);
void reset(GrTexture*, const GrTextureParams&,
GrShaderFlags visibility = kFragment_GrShaderFlag);
void reset(GrTexture*,
GrTextureParams::FilterMode = GrTextureParams::kNone_FilterMode,
SkShader::TileMode tileXAndY = SkShader::kClamp_TileMode,
GrShaderFlags visibility = kFragment_GrShaderFlag);
bool operator==(const GrTextureAccess& that) const {
return this->getTexture() == that.getTexture() &&
fParams == that.fParams &&
fVisibility == that.fVisibility;
}
bool operator!=(const GrTextureAccess& other) const { return !(*this == other); }
GrTexture* getTexture() const { return fTexture.get(); }
GrShaderFlags getVisibility() const { return fVisibility; }
/**
* For internal use by GrProcessor.
*/
const GrGpuResourceRef* getProgramTexture() const { return &fTexture; }
const GrTextureParams& getParams() const { return fParams; }
private:
typedef GrTGpuResourceRef<GrTexture> ProgramTexture;
ProgramTexture fTexture;
GrTextureParams fParams;
GrShaderFlags fVisibility;
typedef SkNoncopyable INHERITED;
};
#endif

2
include/gpu/GrXferProcessor.h
View File

@ -277,7 +277,7 @@ private:
bool fWillReadDstColor;
bool fDstReadUsesMixedSamples;
SkIPoint fDstTextureOffset;
GrTextureAccess fDstTexture;
TextureSampler fDstTexture;
typedef GrFragmentProcessor INHERITED;
};

3
include/gpu/SkGr.h
View File

@ -9,7 +9,7 @@
#define SkGr_DEFINED
#include "GrColor.h"
#include "GrTextureAccess.h"
#include "GrTextureParams.h"
#include "SkColor.h"
#include "SkColorPriv.h"
#include "SkFilterQuality.h"
@ -19,7 +19,6 @@ class GrCaps;
class GrColorSpaceXform;
class GrContext;
class GrTexture;
class GrTextureParams;
class SkBitmap;
////////////////////////////////////////////////////////////////////////////////

1
src/core/SkLightingShader.cpp
View File

@ -105,7 +105,6 @@ private:
#include "GrCoordTransform.h"
#include "GrFragmentProcessor.h"
#include "GrInvariantOutput.h"
#include "GrTextureAccess.h"
#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"

6
src/core/SkShadowShader.cpp
View File

@ -140,8 +140,8 @@ public:
fTexture[fNumNonAmbLights] = sk_sp<GrTexture>(shadowMap->asTextureRef(context,
GrTextureParams::ClampNoFilter(),
SkDestinationSurfaceColorMode::kLegacy));
fDepthMapAccess[fNumNonAmbLights].reset(fTexture[fNumNonAmbLights].get());
this->addTextureAccess(&fDepthMapAccess[fNumNonAmbLights]);
fDepthMapSampler[fNumNonAmbLights].reset(fTexture[fNumNonAmbLights].get());
this->addTextureSampler(&fDepthMapSampler[fNumNonAmbLights]);
fDepthMapHeight[fNumNonAmbLights] = shadowMap->height();
fDepthMapWidth[fNumNonAmbLights] = shadowMap->width();
@ -628,7 +628,7 @@ private:
bool fIsRadialLight[SkShadowShader::kMaxNonAmbientLights];
SkVector3 fLightDirOrPos[SkShadowShader::kMaxNonAmbientLights];
SkColor3f fLightColor[SkShadowShader::kMaxNonAmbientLights];
GrTextureAccess fDepthMapAccess[SkShadowShader::kMaxNonAmbientLights];
TextureSampler fDepthMapSampler[SkShadowShader::kMaxNonAmbientLights];
sk_sp<GrTexture> fTexture[SkShadowShader::kMaxNonAmbientLights];
int fDepthMapWidth[SkShadowShader::kMaxNonAmbientLights];

14
src/effects/GrAlphaThresholdFragmentProcessor.cpp
View File

@ -10,7 +10,6 @@
#if SK_SUPPORT_GPU
#include "GrInvariantOutput.h"
#include "GrTextureAccess.h"
#include "SkRefCnt.h"
#include "glsl/GrGLSLColorSpaceXformHelper.h"
@ -49,17 +48,17 @@ GrAlphaThresholdFragmentProcessor::GrAlphaThresholdFragmentProcessor(
, fOuterThreshold(outerThreshold)
, fImageCoordTransform(GrCoordTransform::MakeDivByTextureWHMatrix(texture), texture,
GrTextureParams::kNone_FilterMode)
, fImageTextureAccess(texture)
, fImageTextureSampler(texture)
, fColorSpaceXform(std::move(colorSpaceXform))
, fMaskCoordTransform(make_div_and_translate_matrix(maskTexture, -bounds.x(), -bounds.y()),
maskTexture,
GrTextureParams::kNone_FilterMode)
, fMaskTextureAccess(maskTexture) {
, fMaskTextureSampler(maskTexture) {
this->initClassID<GrAlphaThresholdFragmentProcessor>();
this->addCoordTransform(&fImageCoordTransform);
this->addTextureAccess(&fImageTextureAccess);
this->addTextureSampler(&fImageTextureSampler);
this->addCoordTransform(&fMaskCoordTransform);
this->addTextureAccess(&fMaskTextureAccess);
this->addTextureSampler(&fMaskTextureSampler);
}
bool GrAlphaThresholdFragmentProcessor::onIsEqual(const GrFragmentProcessor& sBase) const {
@ -69,9 +68,10 @@ bool GrAlphaThresholdFragmentProcessor::onIsEqual(const GrFragmentProcessor& sBa
}
void GrAlphaThresholdFragmentProcessor::onComputeInvariantOutput(GrInvariantOutput* inout) const {
if (GrPixelConfigIsAlphaOnly(this->texture(0)->config())) {
GrPixelConfig config = this->textureSampler(0).getTexture()->config();
if (GrPixelConfigIsAlphaOnly(config)) {
inout->mulByUnknownSingleComponent();
} else if (GrPixelConfigIsOpaque(this->texture(0)->config()) && fOuterThreshold >= 1.f) {
} else if (GrPixelConfigIsOpaque(config) && fOuterThreshold >= 1.f) {
inout->mulByUnknownOpaqueFourComponents();
} else {
inout->mulByUnknownFourComponents();

4
src/effects/GrAlphaThresholdFragmentProcessor.h
View File

@ -55,11 +55,11 @@ private:
float fInnerThreshold;
float fOuterThreshold;
GrCoordTransform fImageCoordTransform;
GrTextureAccess fImageTextureAccess;
TextureSampler fImageTextureSampler;
// Color space transform is for the image (not the mask)
sk_sp<GrColorSpaceXform> fColorSpaceXform;
GrCoordTransform fMaskCoordTransform;
GrTextureAccess fMaskTextureAccess;
TextureSampler fMaskTextureSampler;
typedef GrFragmentProcessor INHERITED;
};

4
src/effects/GrCircleBlurFragmentProcessor.cpp
View File

@ -92,9 +92,9 @@ GrCircleBlurFragmentProcessor::GrCircleBlurFragmentProcessor(const SkRect& circl
: fCircle(circle)
, fSolidRadius(solidRadius)
, fTextureRadius(textureRadius)
, fBlurProfileAccess(blurProfile, GrTextureParams::kBilerp_FilterMode) {
, fBlurProfileSampler(blurProfile, GrTextureParams::kBilerp_FilterMode) {
this->initClassID<GrCircleBlurFragmentProcessor>();
this->addTextureAccess(&fBlurProfileAccess);
this->addTextureSampler(&fBlurProfileSampler);
this->setWillReadFragmentPosition();
}

2
src/effects/GrCircleBlurFragmentProcessor.h
View File

@ -64,7 +64,7 @@ private:
SkRect fCircle;
SkScalar fSolidRadius;
float fTextureRadius;
GrTextureAccess fBlurProfileAccess;
TextureSampler fBlurProfileSampler;
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;

1
src/effects/SkArithmeticMode_gpu.h
View File

@ -15,7 +15,6 @@
#include "GrCaps.h"
#include "GrCoordTransform.h"
#include "GrFragmentProcessor.h"
#include "GrTextureAccess.h"
#include "GrTypes.h"
#include "GrXferProcessor.h"

12
src/effects/SkBlurMaskFilter.cpp
View File

@ -825,7 +825,7 @@ private:
SkRect fRect;
float fSigma;
GrTextureAccess fBlurProfileAccess;
TextureSampler fBlurProfileSampler;
GrSLPrecision fPrecision;
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
@ -975,10 +975,10 @@ GrRectBlurEffect::GrRectBlurEffect(const SkRect& rect, float sigma, GrTexture *b
GrSLPrecision precision)
: fRect(rect)
, fSigma(sigma)
, fBlurProfileAccess(blurProfile)
, fBlurProfileSampler(blurProfile)
, fPrecision(precision) {
this->initClassID<GrRectBlurEffect>();
this->addTextureAccess(&fBlurProfileAccess);
this->addTextureSampler(&fBlurProfileSampler);
this->setWillReadFragmentPosition();
}
@ -1093,7 +1093,7 @@ private:
SkRRect fRRect;
float fSigma;
GrTextureAccess fNinePatchAccess;
TextureSampler fNinePatchSampler;
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
@ -1205,9 +1205,9 @@ void GrRRectBlurEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const
GrRRectBlurEffect::GrRRectBlurEffect(float sigma, const SkRRect& rrect, GrTexture *ninePatchTexture)
: fRRect(rrect),
fSigma(sigma),
fNinePatchAccess(ninePatchTexture) {
fNinePatchSampler(ninePatchTexture) {
this->initClassID<GrRRectBlurEffect>();
this->addTextureAccess(&fNinePatchAccess);
this->addTextureSampler(&fNinePatchSampler);
this->setWillReadFragmentPosition();
}

8
src/effects/SkColorCubeFilter.cpp
View File

@ -170,7 +170,7 @@ public:
const char* name() const override { return "ColorCube"; }
int colorCubeSize() const { return fColorCubeAccess.getTexture()->width(); }
int colorCubeSize() const { return fColorCubeSampler.getTexture()->width(); }
void onComputeInvariantOutput(GrInvariantOutput*) const override;
@ -201,7 +201,7 @@ private:
GrColorCubeEffect(GrTexture* colorCube);
GrTextureAccess fColorCubeAccess;
TextureSampler fColorCubeSampler;
typedef GrFragmentProcessor INHERITED;
};
@ -209,9 +209,9 @@ private:
///////////////////////////////////////////////////////////////////////////////
GrColorCubeEffect::GrColorCubeEffect(GrTexture* colorCube)
: fColorCubeAccess(colorCube, GrTextureParams::kBilerp_FilterMode) {
: fColorCubeSampler(colorCube, GrTextureParams::kBilerp_FilterMode) {
this->initClassID<GrColorCubeEffect>();
this->addTextureAccess(&fColorCubeAccess);
this->addTextureSampler(&fColorCubeSampler);
}
GrColorCubeEffect::~GrColorCubeEffect() {

14
src/effects/SkDisplacementMapEffect.cpp
View File

@ -259,10 +259,10 @@ private:
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
GrCoordTransform fDisplacementTransform;
GrTextureAccess fDisplacementAccess;
TextureSampler fDisplacementSampler;
GrCoordTransform fColorTransform;
GrTextureDomain fDomain;
GrTextureAccess fColorAccess;
TextureSampler fColorSampler;
SkDisplacementMapEffect::ChannelSelectorType fXChannelSelector;
SkDisplacementMapEffect::ChannelSelectorType fYChannelSelector;
SkVector fScale;
@ -486,19 +486,19 @@ GrDisplacementMapEffect::GrDisplacementMapEffect(
GrTexture* color,
const SkISize& colorDimensions)
: fDisplacementTransform(offsetMatrix, displacement, GrTextureParams::kNone_FilterMode)
, fDisplacementAccess(displacement)
, fDisplacementSampler(displacement)
, fColorTransform(color, GrTextureParams::kNone_FilterMode)
, fDomain(GrTextureDomain::MakeTexelDomain(color, SkIRect::MakeSize(colorDimensions)),
GrTextureDomain::kDecal_Mode)
, fColorAccess(color)
, fColorSampler(color)
, fXChannelSelector(xChannelSelector)
, fYChannelSelector(yChannelSelector)
, fScale(scale) {
this->initClassID<GrDisplacementMapEffect>();
this->addCoordTransform(&fDisplacementTransform);
this->addTextureAccess(&fDisplacementAccess);
this->addTextureSampler(&fDisplacementSampler);
this->addCoordTransform(&fColorTransform);
this->addTextureAccess(&fColorAccess);
this->addTextureSampler(&fColorSampler);
}
GrDisplacementMapEffect::~GrDisplacementMapEffect() {
@ -625,7 +625,7 @@ void GrGLDisplacementMapEffect::emitCode(EmitArgs& args) {
void GrGLDisplacementMapEffect::onSetData(const GrGLSLProgramDataManager& pdman,
const GrProcessor& proc) {
const GrDisplacementMapEffect& displacementMap = proc.cast<GrDisplacementMapEffect>();
GrTexture* colorTex = displacementMap.texture(1);
GrTexture* colorTex = displacementMap.textureSampler(1).getTexture();
SkScalar scaleX = displacementMap.scale().fX / colorTex->width();
SkScalar scaleY = displacementMap.scale().fY / colorTex->height();
pdman.set2f(fScaleUni, SkScalarToFloat(scaleX),

2
src/effects/SkLightingImageFilter.cpp
View File

@ -1900,7 +1900,7 @@ void GrGLLightingEffect::onSetData(const GrGLSLProgramDataManager& pdman,
fLight = lighting.light()->createGLLight();
}
GrTexture* texture = lighting.texture(0);
GrTexture* texture = lighting.textureSampler(0).getTexture();
float ySign = texture->origin() == kTopLeft_GrSurfaceOrigin ? -1.0f : 1.0f;
pdman.set2f(fImageIncrementUni, 1.0f / texture->width(), ySign / texture->height());
pdman.set1f(fSurfaceScaleUni, lighting.surfaceScale());

2
src/effects/SkMorphologyImageFilter.cpp
View File

@ -294,7 +294,7 @@ void GrGLMorphologyEffect::GenKey(const GrProcessor& proc,
void GrGLMorphologyEffect::onSetData(const GrGLSLProgramDataManager& pdman,
const GrProcessor& proc) {
const GrMorphologyEffect& m = proc.cast<GrMorphologyEffect>();
GrTexture& texture = *m.texture(0);
GrTexture& texture = *m.textureSampler(0).getTexture();
float pixelSize = 0.0f;
switch (m.direction()) {

12
src/effects/SkPerlinNoiseShader.cpp
View File

@ -548,12 +548,12 @@ private:
: fType(type)
, fNumOctaves(numOctaves)
, fStitchTiles(stitchTiles)
, fPermutationsAccess(permutationsTexture)
, fNoiseAccess(noiseTexture)
, fPermutationsSampler(permutationsTexture)
, fNoiseSampler(noiseTexture)
, fPaintingData(paintingData) {
this->initClassID<GrPerlinNoiseEffect>();
this->addTextureAccess(&fPermutationsAccess);
this->addTextureAccess(&fNoiseAccess);
this->addTextureSampler(&fPermutationsSampler);
this->addTextureSampler(&fNoiseSampler);
fCoordTransform.reset(matrix);
this->addCoordTransform(&fCoordTransform);
}
@ -564,8 +564,8 @@ private:
GrCoordTransform fCoordTransform;
int fNumOctaves;
bool fStitchTiles;
GrTextureAccess fPermutationsAccess;
GrTextureAccess fNoiseAccess;
TextureSampler fPermutationsSampler;
TextureSampler fNoiseSampler;
SkPerlinNoiseShader::PaintingData *fPaintingData;
private:

6
src/effects/SkTableColorFilter.cpp
View File

@ -365,7 +365,7 @@ private:
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
GrTextureAccess fTextureAccess;
TextureSampler fTextureSampler;
// currently not used in shader code, just to assist onComputeInvariantOutput().
unsigned fFlags;
@ -485,12 +485,12 @@ sk_sp<GrFragmentProcessor> ColorTableEffect::Make(GrContext* context, SkBitmap b
ColorTableEffect::ColorTableEffect(GrTexture* texture, GrTextureStripAtlas* atlas, int row,
unsigned flags)
: fTextureAccess(texture)
: fTextureSampler(texture)
, fFlags(flags)
, fAtlas(atlas)
, fRow(row) {
this->initClassID<ColorTableEffect>();
this->addTextureAccess(&fTextureAccess);
this->addTextureSampler(&fTextureSampler);
}
ColorTableEffect::~ColorTableEffect() {

6
src/effects/gradients/SkGradientShader.cpp
View File

@ -1659,7 +1659,7 @@ GrGradientEffect::GrGradientEffect(const CreateArgs& args) {
if (-1 != fRow) {
fYCoord = fAtlas->getYOffset(fRow)+SK_ScalarHalf*fAtlas->getNormalizedTexelHeight();
fCoordTransform.reset(*args.fMatrix, fAtlas->getTexture(), params.filterMode());
fTextureAccess.reset(fAtlas->getTexture(), params);
fTextureSampler.reset(fAtlas->getTexture(), params);
} else {
sk_sp<GrTexture> texture(GrRefCachedBitmapTexture(
args.fContext, bitmap, params,
@ -1668,11 +1668,11 @@ GrGradientEffect::GrGradientEffect(const CreateArgs& args) {
return;
}
fCoordTransform.reset(*args.fMatrix, texture.get(), params.filterMode());
fTextureAccess.reset(texture.get(), params);
fTextureSampler.reset(texture.get(), params);
fYCoord = SK_ScalarHalf;
}
this->addTextureAccess(&fTextureAccess);
this->addTextureSampler(&fTextureSampler);
break;
}

2
src/effects/gradients/SkGradientShaderPriv.h
View File

@ -439,7 +439,7 @@ private:
SkShader::TileMode fTileMode;
GrCoordTransform fCoordTransform;
GrTextureAccess fTextureAccess;
TextureSampler fTextureSampler;
SkScalar fYCoord;
GrTextureStripAtlas* fAtlas;
int fRow;

8
src/gpu/GrPipeline.cpp
View File

@ -176,9 +176,9 @@ GrPipeline* GrPipeline::CreateAt(void* memory, const CreateArgs& args,
static void add_dependencies_for_processor(const GrFragmentProcessor* proc, GrRenderTarget* rt) {
GrFragmentProcessor::TextureAccessIter iter(proc);
while (const GrTextureAccess* access = iter.next()) {
while (const GrProcessor::TextureSampler* sampler = iter.next()) {
SkASSERT(rt->getLastOpList());
rt->getLastOpList()->addDependency(access->getTexture());
rt->getLastOpList()->addDependency(sampler->getTexture());
}
}
@ -189,8 +189,8 @@ void GrPipeline::addDependenciesTo(GrRenderTarget* rt) const {
const GrXferProcessor& xfer = this->getXferProcessor();
for (int i = 0; i < xfer.numTextures(); ++i) {
GrTexture* texture = xfer.textureAccess(i).getTexture();
for (int i = 0; i < xfer.numTextureSamplers(); ++i) {
GrTexture* texture = xfer.textureSampler(i).getTexture();
SkASSERT(rt->getLastOpList());
rt->getLastOpList()->addDependency(texture);
}

49
src/gpu/GrProcessor.cpp
View File

@ -10,6 +10,8 @@
#include "GrGeometryProcessor.h"
#include "GrInvariantOutput.h"
#include "GrMemoryPool.h"
#include "GrTextureParams.h"
#include "GrTexturePriv.h"
#include "GrXferProcessor.h"
#include "SkSpinlock.h"
@ -113,8 +115,8 @@ int32_t GrProcessor::gCurrProcessorClassID = GrProcessor::kIllegalProcessorClass
GrProcessor::~GrProcessor() {}
void GrProcessor::addTextureAccess(const GrTextureAccess* access) {
fTextureAccesses.push_back(access);
void GrProcessor::addTextureSampler(const TextureSampler* access) {
fTextureSamplers.push_back(access);
this->addGpuResource(access->getProgramTexture());
}
@ -132,11 +134,12 @@ void GrProcessor::operator delete(void* target) {
}
bool GrProcessor::hasSameSamplers(const GrProcessor& that) const {
if (this->numTextures() != that.numTextures() || this->numBuffers() != that.numBuffers()) {
if (this->numTextureSamplers() != that.numTextureSamplers() ||
this->numBuffers() != that.numBuffers()) {
return false;
}
for (int i = 0; i < this->numTextures(); ++i) {
if (this->textureAccess(i) != that.textureAccess(i)) {
for (int i = 0; i < this->numTextureSamplers(); ++i) {
if (this->textureSampler(i) != that.textureSampler(i)) {
return false;
}
}
@ -150,6 +153,42 @@ bool GrProcessor::hasSameSamplers(const GrProcessor& that) const {
///////////////////////////////////////////////////////////////////////////////////////////////////
GrProcessor::TextureSampler::TextureSampler() {}
GrProcessor::TextureSampler::TextureSampler(GrTexture* texture, const GrTextureParams& params) {
this->reset(texture, params);
}
GrProcessor::TextureSampler::TextureSampler(GrTexture* texture,
GrTextureParams::FilterMode filterMode,
SkShader::TileMode tileXAndY,
GrShaderFlags visibility) {
this->reset(texture, filterMode, tileXAndY, visibility);
}
void GrProcessor::TextureSampler::reset(GrTexture* texture,
const GrTextureParams& params,
GrShaderFlags visibility) {
SkASSERT(texture);
fTexture.set(SkRef(texture), kRead_GrIOType);
fParams = params;
fParams.setFilterMode(SkTMin(params.filterMode(), texture->texturePriv().highestFilterMode()));
fVisibility = visibility;
}
void GrProcessor::TextureSampler::reset(GrTexture* texture,
GrTextureParams::FilterMode filterMode,
SkShader::TileMode tileXAndY,
GrShaderFlags visibility) {
SkASSERT(texture);
fTexture.set(SkRef(texture), kRead_GrIOType);
filterMode = SkTMin(filterMode, texture->texturePriv().highestFilterMode());
fParams.reset(tileXAndY, filterMode);
fVisibility = visibility;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
// Initial static variable from GrXPFactory
int32_t GrXPFactory::gCurrXPFClassID =
GrXPFactory::kIllegalXPFClassID;

14
src/gpu/GrProgramDesc.cpp
View File

@ -34,8 +34,8 @@ static uint16_t sampler_key(GrSLType samplerType, GrPixelConfig config, GrShader
static void add_sampler_keys(GrProcessorKeyBuilder* b, const GrProcessor& proc,
const GrGLSLCaps& caps) {
int numTextures = proc.numTextures();
int numSamplers = numTextures + proc.numBuffers();
int numTextureSamplers = proc.numTextureSamplers();
int numSamplers = numTextureSamplers + proc.numBuffers();
// Need two bytes per key (swizzle, sampler type, and precision).
int word32Count = (numSamplers + 1) / 2;
if (0 == word32Count) {
@ -43,14 +43,14 @@ static void add_sampler_keys(GrProcessorKeyBuilder* b, const GrProcessor& proc,
}
uint16_t* k16 = SkTCast<uint16_t*>(b->add32n(word32Count));
int i = 0;
for (; i < numTextures; ++i) {
const GrTextureAccess& access = proc.textureAccess(i);
const GrTexture* tex = access.getTexture();
for (; i < numTextureSamplers; ++i) {
const GrProcessor::TextureSampler& textureSampler = proc.textureSampler(i);
const GrTexture* tex = textureSampler.getTexture();
k16[i] = sampler_key(tex->texturePriv().samplerType(), tex->config(),
access.getVisibility(), caps);
textureSampler.getVisibility(), caps);
}
for (; i < numSamplers; ++i) {
const GrBufferAccess& access = proc.bufferAccess(i - numTextures);
const GrBufferAccess& access = proc.bufferAccess(i - numTextureSamplers);
k16[i] = sampler_key(kBufferSampler_GrSLType, access.texelConfig(),
access.visibility(), caps);
}

45
src/gpu/GrTextureAccess.cpp
View File

@ -1,45 +0,0 @@
/*
* Copyright 2012 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "GrTextureAccess.h"
#include "GrColor.h"
#include "GrTexture.h"
#include "GrTexturePriv.h"
GrTextureAccess::GrTextureAccess() {}
GrTextureAccess::GrTextureAccess(GrTexture* texture, const GrTextureParams& params) {
this->reset(texture, params);
}
GrTextureAccess::GrTextureAccess(GrTexture* texture,
GrTextureParams::FilterMode filterMode,
SkShader::TileMode tileXAndY,
GrShaderFlags visibility) {
this->reset(texture, filterMode, tileXAndY, visibility);
}
void GrTextureAccess::reset(GrTexture* texture,
const GrTextureParams& params,
GrShaderFlags visibility) {
SkASSERT(texture);
fTexture.set(SkRef(texture), kRead_GrIOType);
fParams = params;
fParams.setFilterMode(SkTMin(params.filterMode(), texture->texturePriv().highestFilterMode()));
fVisibility = visibility;
}
void GrTextureAccess::reset(GrTexture* texture,
GrTextureParams::FilterMode filterMode,
SkShader::TileMode tileXAndY,
GrShaderFlags visibility) {
SkASSERT(texture);
fTexture.set(SkRef(texture), kRead_GrIOType);
filterMode = SkTMin(filterMode, texture->texturePriv().highestFilterMode());
fParams.reset(tileXAndY, filterMode);
fVisibility = visibility;
}

2
src/gpu/GrTexturePriv.h
View File

@ -51,7 +51,7 @@ public:
GrSLType samplerType() const { return fTexture->fSamplerType; }
/** The filter used is clamped to this value in GrTextureAccess. */
/** The filter used is clamped to this value in GrProcessor::TextureSampler. */
GrTextureParams::FilterMode highestFilterMode() const { return fTexture->fHighestFilterMode; }
void setMipColorMode(SkDestinationSurfaceColorMode colorMode) const {

2
src/gpu/GrXferProcessor.cpp
View File

@ -26,7 +26,7 @@ GrXferProcessor::GrXferProcessor(const DstTexture* dstTexture,
SkASSERT(willReadDstColor);
fDstTexture.reset(dstTexture->texture());
fDstTextureOffset = dstTexture->offset();
this->addTextureAccess(&fDstTexture);
this->addTextureSampler(&fDstTexture);
this->setWillReadFragmentPosition();
}
}

8
src/gpu/effects/GrBicubicEffect.cpp
View File

@ -126,13 +126,13 @@ void GrGLBicubicEffect::emitCode(EmitArgs& args) {
void GrGLBicubicEffect::onSetData(const GrGLSLProgramDataManager& pdman,
const GrProcessor& processor) {
const GrBicubicEffect& bicubicEffect = processor.cast<GrBicubicEffect>();
const GrTexture& texture = *processor.texture(0);
GrTexture* texture = processor.textureSampler(0).getTexture();
float imageIncrement[2];
imageIncrement[0] = 1.0f / texture.width();
imageIncrement[1] = 1.0f / texture.height();
imageIncrement[0] = 1.0f / texture->width();
imageIncrement[1] = 1.0f / texture->height();
pdman.set2fv(fImageIncrementUni, 1, imageIncrement);
pdman.setMatrix4f(fCoefficientsUni, bicubicEffect.coefficients());
fDomain.setData(pdman, bicubicEffect.domain(), texture.origin());
fDomain.setData(pdman, bicubicEffect.domain(), texture->origin());
if (SkToBool(bicubicEffect.colorSpaceXform())) {
pdman.setSkMatrix44(fColorSpaceXformUni, bicubicEffect.colorSpaceXform()->srcToDst());
}

12
src/gpu/effects/GrBitmapTextGeoProc.cpp
View File

@ -30,8 +30,8 @@ public:
varyingHandler->emitAttributes(cte);
// compute numbers to be hardcoded to convert texture coordinates from int to float
SkASSERT(cte.numTextures() == 1);
SkDEBUGCODE(GrTexture* atlas = cte.textureAccess(0).getTexture());
SkASSERT(cte.numTextureSamplers() == 1);
SkDEBUGCODE(GrTexture* atlas = cte.textureSampler(0).getTexture());
SkASSERT(atlas && SkIsPow2(atlas->width()) && SkIsPow2(atlas->height()));
GrGLSLVertToFrag v(kVec2f_GrSLType);
@ -108,8 +108,8 @@ public:
b->add32(key);
// Currently we hardcode numbers to convert atlas coordinates to normalized floating point
SkASSERT(gp.numTextures() == 1);
GrTexture* atlas = gp.textureAccess(0).getTexture();
SkASSERT(gp.numTextureSamplers() == 1);
GrTexture* atlas = gp.textureSampler(0).getTexture();
SkASSERT(atlas);
b->add32(atlas->width());
b->add32(atlas->height());
@ -130,7 +130,7 @@ GrBitmapTextGeoProc::GrBitmapTextGeoProc(GrColor color, GrTexture* texture,
: fColor(color)
, fLocalMatrix(localMatrix)
, fUsesLocalCoords(usesLocalCoords)
, fTextureAccess(texture, params)
, fTextureSampler(texture, params)
, fInColor(nullptr)
, fMaskFormat(format) {
this->initClassID<GrBitmapTextGeoProc>();
@ -143,7 +143,7 @@ GrBitmapTextGeoProc::GrBitmapTextGeoProc(GrColor color, GrTexture* texture,
}
fInTextureCoords = &this->addVertexAttrib("inTextureCoords", kVec2us_GrVertexAttribType,
kHigh_GrSLPrecision);
this->addTextureAccess(&fTextureAccess);
this->addTextureSampler(&fTextureSampler);
}
void GrBitmapTextGeoProc::getGLSLProcessorKey(const GrGLSLCaps& caps,

2
src/gpu/effects/GrBitmapTextGeoProc.h
View File

@ -53,7 +53,7 @@ private:
GrColor fColor;
SkMatrix fLocalMatrix;
bool fUsesLocalCoords;
GrTextureAccess fTextureAccess;
TextureSampler fTextureSampler;
const Attribute* fInPosition;
const Attribute* fInColor;
const Attribute* fInTextureCoords;

2
src/gpu/effects/GrConvolutionEffect.cpp
View File

@ -98,7 +98,7 @@ void GrGLConvolutionEffect::emitCode(EmitArgs& args) {
void GrGLConvolutionEffect::onSetData(const GrGLSLProgramDataManager& pdman,
const GrProcessor& processor) {
const GrConvolutionEffect& conv = processor.cast<GrConvolutionEffect>();
GrTexture& texture = *conv.texture(0);
GrTexture& texture = *conv.textureSampler(0).getTexture();
float imageIncrement[2] = { 0 };
float ySign = texture.origin() != kTopLeft_GrSurfaceOrigin ? 1.0f : -1.0f;

1
src/gpu/effects/GrCustomXfermode.cpp
View File

@ -14,7 +14,6 @@
#include "GrPipeline.h"
#include "GrProcessor.h"
#include "GrTexture.h"
#include "GrTextureAccess.h"
#include "SkXfermode.h"
#include "glsl/GrGLSLBlend.h"
#include "glsl/GrGLSLCaps.h"

30
src/gpu/effects/GrDistanceFieldGeoProc.cpp
View File

@ -85,8 +85,8 @@ public:
vertBuilder->codeAppendf("%s = %s;", uv.vsOut(), dfTexEffect.inTextureCoords()->fName);
// compute numbers to be hardcoded to convert texture coordinates from float to int
SkASSERT(dfTexEffect.numTextures() == 1);
GrTexture* atlas = dfTexEffect.textureAccess(0).getTexture();
SkASSERT(dfTexEffect.numTextureSamplers() == 1);
GrTexture* atlas = dfTexEffect.textureSampler(0).getTexture();
SkASSERT(atlas && SkIsPow2(atlas->width()) && SkIsPow2(atlas->height()));
GrGLSLVertToFrag st(kVec2f_GrSLType);
@ -207,8 +207,8 @@ public:
b->add32(key);
// Currently we hardcode numbers to convert atlas coordinates to normalized floating point
SkASSERT(gp.numTextures() == 1);
GrTexture* atlas = gp.textureAccess(0).getTexture();
SkASSERT(gp.numTextureSamplers() == 1);
GrTexture* atlas = gp.textureSampler(0).getTexture();
SkASSERT(atlas);
b->add32(atlas->width());
b->add32(atlas->height());
@ -238,7 +238,7 @@ GrDistanceFieldA8TextGeoProc::GrDistanceFieldA8TextGeoProc(GrColor color,
bool usesLocalCoords)
: fColor(color)
, fViewMatrix(viewMatrix)
, fTextureAccess(texture, params)
, fTextureSampler(texture, params)
#ifdef SK_GAMMA_APPLY_TO_A8
, fDistanceAdjust(distanceAdjust)
#endif
@ -252,7 +252,7 @@ GrDistanceFieldA8TextGeoProc::GrDistanceFieldA8TextGeoProc(GrColor color,
fInColor = &this->addVertexAttrib("inColor", kVec4ub_GrVertexAttribType);
fInTextureCoords = &this->addVertexAttrib("inTextureCoords", kVec2us_GrVertexAttribType,
kHigh_GrSLPrecision);
this->addTextureAccess(&fTextureAccess);
this->addTextureSampler(&fTextureSampler);
}
void GrDistanceFieldA8TextGeoProc::getGLSLProcessorKey(const GrGLSLCaps& caps,
@ -433,7 +433,7 @@ public:
FPCoordTransformIter&& transformIter) override {
SkASSERT(fTextureSizeUni.isValid());
GrTexture* texture = proc.texture(0);
GrTexture* texture = proc.textureSampler(0).getTexture();
if (texture->width() != fTextureSize.width() ||
texture->height() != fTextureSize.height()) {
fTextureSize = SkISize::Make(texture->width(), texture->height());
@ -484,7 +484,7 @@ GrDistanceFieldPathGeoProc::GrDistanceFieldPathGeoProc(
bool usesLocalCoords)
: fColor(color)
, fViewMatrix(viewMatrix)
, fTextureAccess(texture, params)
, fTextureSampler(texture, params)
, fFlags(flags & kNonLCD_DistanceFieldEffectMask)
, fInColor(nullptr)
, fUsesLocalCoords(usesLocalCoords) {
@ -494,7 +494,7 @@ GrDistanceFieldPathGeoProc::GrDistanceFieldPathGeoProc(
kHigh_GrSLPrecision);
fInColor = &this->addVertexAttrib("inColor", kVec4ub_GrVertexAttribType);
fInTextureCoords = &this->addVertexAttrib("inTextureCoords", kVec2f_GrVertexAttribType);
this->addTextureAccess(&fTextureAccess);
this->addTextureSampler(&fTextureSampler);
}
void GrDistanceFieldPathGeoProc::getGLSLProcessorKey(const GrGLSLCaps& caps,
@ -594,8 +594,8 @@ public:
vertBuilder->codeAppendf("%s = %s;", uv.vsOut(), dfTexEffect.inTextureCoords()->fName);
// compute numbers to be hardcoded to convert texture coordinates from float to int
SkASSERT(dfTexEffect.numTextures() == 1);
GrTexture* atlas = dfTexEffect.textureAccess(0).getTexture();
SkASSERT(dfTexEffect.numTextureSamplers() == 1);
GrTexture* atlas = dfTexEffect.textureSampler(0).getTexture();
SkASSERT(atlas && SkIsPow2(atlas->width()) && SkIsPow2(atlas->height()));
GrGLSLVertToFrag st(kVec2f_GrSLType);
@ -760,8 +760,8 @@ public:
b->add32(key);
// Currently we hardcode numbers to convert atlas coordinates to normalized floating point
SkASSERT(gp.numTextures() == 1);
GrTexture* atlas = gp.textureAccess(0).getTexture();
SkASSERT(gp.numTextureSamplers() == 1);
GrTexture* atlas = gp.textureSampler(0).getTexture();
SkASSERT(atlas);
b->add32(atlas->width());
b->add32(atlas->height());
@ -786,7 +786,7 @@ GrDistanceFieldLCDTextGeoProc::GrDistanceFieldLCDTextGeoProc(
uint32_t flags, bool usesLocalCoords)
: fColor(color)
, fViewMatrix(viewMatrix)
, fTextureAccess(texture, params)
, fTextureSampler(texture, params)
, fDistanceAdjust(distanceAdjust)
, fFlags(flags & kLCD_DistanceFieldEffectMask)
, fUsesLocalCoords(usesLocalCoords) {
@ -797,7 +797,7 @@ GrDistanceFieldLCDTextGeoProc::GrDistanceFieldLCDTextGeoProc(
fInColor = &this->addVertexAttrib("inColor", kVec4ub_GrVertexAttribType);
fInTextureCoords = &this->addVertexAttrib("inTextureCoords", kVec2us_GrVertexAttribType,
kHigh_GrSLPrecision);
this->addTextureAccess(&fTextureAccess);
this->addTextureSampler(&fTextureSampler);
}
void GrDistanceFieldLCDTextGeoProc::getGLSLProcessorKey(const GrGLSLCaps& caps,

6
src/gpu/effects/GrDistanceFieldGeoProc.h
View File

@ -96,7 +96,7 @@ private:
GrColor fColor;
SkMatrix fViewMatrix;
GrTextureAccess fTextureAccess;
TextureSampler fTextureSampler;
#ifdef SK_GAMMA_APPLY_TO_A8
float fDistanceAdjust;
#endif
@ -151,7 +151,7 @@ private:
GrColor fColor;
SkMatrix fViewMatrix;
GrTextureAccess fTextureAccess;
TextureSampler fTextureSampler;
uint32_t fFlags;
const Attribute* fInPosition;
const Attribute* fInColor;
@ -221,7 +221,7 @@ private:
GrColor fColor;
SkMatrix fViewMatrix;
GrTextureAccess fTextureAccess;
TextureSampler fTextureSampler;
DistanceAdjust fDistanceAdjust;
uint32_t fFlags;
const Attribute* fInPosition;

10
src/gpu/effects/GrMatrixConvolutionEffect.cpp
View File

@ -129,12 +129,12 @@ void GrGLMatrixConvolutionEffect::GenKey(const GrProcessor& processor,
void GrGLMatrixConvolutionEffect::onSetData(const GrGLSLProgramDataManager& pdman,
const GrProcessor& processor) {
const GrMatrixConvolutionEffect& conv = processor.cast<GrMatrixConvolutionEffect>();
GrTexture& texture = *conv.texture(0);
GrTexture* texture = conv.textureSampler(0).getTexture();
float imageIncrement[2];
float ySign = texture.origin() == kTopLeft_GrSurfaceOrigin ? 1.0f : -1.0f;
imageIncrement[0] = 1.0f / texture.width();
imageIncrement[1] = ySign / texture.height();
float ySign = texture->origin() == kTopLeft_GrSurfaceOrigin ? 1.0f : -1.0f;
imageIncrement[0] = 1.0f / texture->width();
imageIncrement[1] = ySign / texture->height();
pdman.set2fv(fImageIncrementUni, 1, imageIncrement);
pdman.set2fv(fKernelOffsetUni, 1, conv.kernelOffset());
int kernelCount = conv.kernelSize().width() * conv.kernelSize().height();
@ -143,7 +143,7 @@ void GrGLMatrixConvolutionEffect::onSetData(const GrGLSLProgramDataManager& pdma
pdman.set4fv(fKernelUni, arrayCount, conv.kernel());
pdman.set1f(fGainUni, conv.gain());
pdman.set1f(fBiasUni, conv.bias());
fDomain.setData(pdman, conv.domain(), texture.origin());
fDomain.setData(pdman, conv.domain(), texture->origin());
}
GrMatrixConvolutionEffect::GrMatrixConvolutionEffect(GrTexture* texture,

12
src/gpu/effects/GrSingleTextureEffect.cpp
View File

@ -11,10 +11,10 @@ GrSingleTextureEffect::GrSingleTextureEffect(GrTexture* texture,
sk_sp<GrColorSpaceXform> colorSpaceXform,
const SkMatrix& m)
: fCoordTransform(m, texture, GrTextureParams::kNone_FilterMode)
, fTextureAccess(texture)
, fTextureSampler(texture)
, fColorSpaceXform(std::move(colorSpaceXform)) {
this->addCoordTransform(&fCoordTransform);
this->addTextureAccess(&fTextureAccess);
this->addTextureSampler(&fTextureSampler);
}
GrSingleTextureEffect::GrSingleTextureEffect(GrTexture* texture,
@ -22,10 +22,10 @@ GrSingleTextureEffect::GrSingleTextureEffect(GrTexture* texture,
const SkMatrix& m,
GrTextureParams::FilterMode filterMode)
: fCoordTransform(m, texture, filterMode)
, fTextureAccess(texture, filterMode)
, fTextureSampler(texture, filterMode)
, fColorSpaceXform(std::move(colorSpaceXform)) {
this->addCoordTransform(&fCoordTransform);
this->addTextureAccess(&fTextureAccess);
this->addTextureSampler(&fTextureSampler);
}
GrSingleTextureEffect::GrSingleTextureEffect(GrTexture* texture,
@ -33,10 +33,10 @@ GrSingleTextureEffect::GrSingleTextureEffect(GrTexture* texture,
const SkMatrix& m,
const GrTextureParams& params)
: fCoordTransform(m, texture, params.filterMode())
, fTextureAccess(texture, params)
, fTextureSampler(texture, params)
, fColorSpaceXform(std::move(colorSpaceXform)) {
this->addCoordTransform(&fCoordTransform);
this->addTextureAccess(&fTextureAccess);
this->addTextureSampler(&fTextureSampler);
}
GrSingleTextureEffect::~GrSingleTextureEffect() {

9
src/gpu/effects/GrSingleTextureEffect.h
View File

@ -26,7 +26,7 @@ public:
SkString dumpInfo() const override {
SkString str;
str.appendf("Texture: %d", fTextureAccess.getTexture()->uniqueID().asUInt());
str.appendf("Texture: %d", fTextureSampler.getTexture()->uniqueID().asUInt());
return str;
}
@ -49,9 +49,10 @@ protected:
* texture.
*/
void updateInvariantOutputForModulation(GrInvariantOutput* inout) const {
if (GrPixelConfigIsAlphaOnly(this->texture(0)->config())) {
GrPixelConfig config = this->textureSampler(0).getTexture()->config();
if (GrPixelConfigIsAlphaOnly(config)) {
inout->mulByUnknownSingleComponent();
} else if (GrPixelConfigIsOpaque(this->texture(0)->config())) {
} else if (GrPixelConfigIsOpaque(config)) {
inout->mulByUnknownOpaqueFourComponents();
} else {
inout->mulByUnknownFourComponents();
@ -60,7 +61,7 @@ protected:
private:
GrCoordTransform fCoordTransform;
GrTextureAccess fTextureAccess;
TextureSampler fTextureSampler;
sk_sp<GrColorSpaceXform> fColorSpaceXform;
typedef GrFragmentProcessor INHERITED;

26
src/gpu/effects/GrTextureDomain.cpp
View File

@ -229,7 +229,7 @@ GrGLSLFragmentProcessor* GrTextureDomainEffect::onCreateGLSLInstance() const {
void onSetData(const GrGLSLProgramDataManager& pdman, const GrProcessor& fp) override {
const GrTextureDomainEffect& tde = fp.cast<GrTextureDomainEffect>();
const GrTextureDomain& domain = tde.fTextureDomain;
fGLDomain.setData(pdman, domain, tde.texture(0)->origin());
fGLDomain.setData(pdman, domain, tde.textureSampler(0).getTexture()->origin());
}
private:
@ -242,14 +242,13 @@ GrGLSLFragmentProcessor* GrTextureDomainEffect::onCreateGLSLInstance() const {
bool GrTextureDomainEffect::onIsEqual(const GrFragmentProcessor& sBase) const {
const GrTextureDomainEffect& s = sBase.cast<GrTextureDomainEffect>();
return this->fTextureDomain == s.fTextureDomain && s.texture(0) == this->texture(0) &&
s.textureAccess(0).getParams().filterMode() ==
this->textureAccess(0).getParams().filterMode();
return this->fTextureDomain == s.fTextureDomain &&
s.textureSampler(0) == this->textureSampler(0);
}
void GrTextureDomainEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
if (GrTextureDomain::kDecal_Mode == fTextureDomain.mode()) {
if (GrPixelConfigIsAlphaOnly(this->texture(0)->config())) {
if (GrPixelConfigIsAlphaOnly(this->textureSampler(0).getTexture()->config())) {
inout->mulByUnknownSingleComponent();
} else {
inout->mulByUnknownFourComponents();
@ -295,10 +294,10 @@ sk_sp<GrFragmentProcessor> GrDeviceSpaceTextureDecalFragmentProcessor::Make(GrTe
GrDeviceSpaceTextureDecalFragmentProcessor::GrDeviceSpaceTextureDecalFragmentProcessor(
GrTexture* texture, const SkIRect& subset, const SkIPoint& deviceSpaceOffset)
: fTextureAccess(texture, GrTextureParams::ClampNoFilter())
: fTextureSampler(texture, GrTextureParams::ClampNoFilter())
, fTextureDomain(GrTextureDomain::MakeTexelDomain(texture, subset),
GrTextureDomain::kDecal_Mode) {
this->addTextureAccess(&fTextureAccess);
this->addTextureSampler(&fTextureSampler);
fDeviceSpaceOffset.fX = deviceSpaceOffset.fX - subset.fLeft;
fDeviceSpaceOffset.fY = deviceSpaceOffset.fY - subset.fTop;
this->initClassID<GrDeviceSpaceTextureDecalFragmentProcessor>();
@ -334,14 +333,15 @@ GrGLSLFragmentProcessor* GrDeviceSpaceTextureDecalFragmentProcessor::onCreateGLS
void onSetData(const GrGLSLProgramDataManager& pdman, const GrProcessor& fp) override {
const GrDeviceSpaceTextureDecalFragmentProcessor& dstdfp =
fp.cast<GrDeviceSpaceTextureDecalFragmentProcessor>();
fGLDomain.setData(pdman, dstdfp.fTextureDomain, dstdfp.texture(0)->origin());
float iw = 1.f / dstdfp.texture(0)->width();
float ih = 1.f / dstdfp.texture(0)->height();
GrTexture* texture = dstdfp.textureSampler(0).getTexture();
fGLDomain.setData(pdman, dstdfp.fTextureDomain, texture->origin());
float iw = 1.f / texture->width();
float ih = 1.f / texture->height();
float scaleAndTransData[4] = {
iw, ih,
-dstdfp.fDeviceSpaceOffset.fX * iw, -dstdfp.fDeviceSpaceOffset.fY * ih
};
if (dstdfp.texture(0)->origin() == kBottomLeft_GrSurfaceOrigin) {
if (texture->origin() == kBottomLeft_GrSurfaceOrigin) {
scaleAndTransData[1] = -scaleAndTransData[1];
scaleAndTransData[3] = 1 - scaleAndTransData[3];
}
@ -359,14 +359,14 @@ GrGLSLFragmentProcessor* GrDeviceSpaceTextureDecalFragmentProcessor::onCreateGLS
bool GrDeviceSpaceTextureDecalFragmentProcessor::onIsEqual(const GrFragmentProcessor& fp) const {
const GrDeviceSpaceTextureDecalFragmentProcessor& dstdfp =
fp.cast<GrDeviceSpaceTextureDecalFragmentProcessor>();
return dstdfp.fTextureAccess.getTexture() == fTextureAccess.getTexture() &&
return dstdfp.fTextureSampler.getTexture() == fTextureSampler.getTexture() &&
dstdfp.fDeviceSpaceOffset == fDeviceSpaceOffset &&
dstdfp.fTextureDomain == fTextureDomain;
}
void GrDeviceSpaceTextureDecalFragmentProcessor::onComputeInvariantOutput(
GrInvariantOutput* inout) const {
if (GrPixelConfigIsAlphaOnly(this->texture(0)->config())) {
if (GrPixelConfigIsAlphaOnly(this->textureSampler(0).getTexture()->config())) {
inout->mulByUnknownSingleComponent();
} else {
inout->mulByUnknownFourComponents();

2
src/gpu/effects/GrTextureDomain.h
View File

@ -225,7 +225,7 @@ public:
}
private:
GrTextureAccess fTextureAccess;
TextureSampler fTextureSampler;
GrTextureDomain fTextureDomain;
SkIPoint fDeviceSpaceOffset;

20
src/gpu/effects/GrYUVEffect.cpp
View File

@ -155,21 +155,21 @@ private:
const SkMatrix yuvMatrix[3], GrTextureParams::FilterMode uvFilterMode,
SkYUVColorSpace colorSpace, bool nv12)
: fYTransform(yuvMatrix[0], yTexture, GrTextureParams::kNone_FilterMode)
, fYAccess(yTexture)
, fYSampler(yTexture)
, fUTransform(yuvMatrix[1], uTexture, uvFilterMode)
, fUAccess(uTexture, uvFilterMode)
, fVAccess(vTexture, uvFilterMode)
, fUSampler(uTexture, uvFilterMode)
, fVSampler(vTexture, uvFilterMode)
, fColorSpace(colorSpace)
, fNV12(nv12) {
this->initClassID<YUVtoRGBEffect>();
this->addCoordTransform(&fYTransform);
this->addTextureAccess(&fYAccess);
this->addTextureSampler(&fYSampler);
this->addCoordTransform(&fUTransform);
this->addTextureAccess(&fUAccess);
this->addTextureSampler(&fUSampler);
if (!fNV12) {
fVTransform = GrCoordTransform(yuvMatrix[2], vTexture, uvFilterMode);
this->addCoordTransform(&fVTransform);
this->addTextureAccess(&fVAccess);
this->addTextureSampler(&fVSampler);
}
}
@ -193,11 +193,11 @@ private:
}
GrCoordTransform fYTransform;
GrTextureAccess fYAccess;
TextureSampler fYSampler;
GrCoordTransform fUTransform;
GrTextureAccess fUAccess;
TextureSampler fUSampler;
GrCoordTransform fVTransform;
GrTextureAccess fVAccess;
TextureSampler fVSampler;
SkYUVColorSpace fColorSpace;
bool fNV12;
@ -353,7 +353,7 @@ private:
}
GrCoordTransform fTransform;
GrTextureAccess fAccess;
TextureSampler fTextureSampler;
SkYUVColorSpace fColorSpace;
OutputChannels fOutputChannels;

16
src/gpu/gl/GrGLProgram.cpp
View File

@ -152,10 +152,10 @@ void GrGLProgram::setRenderTargetState(const GrPrimitiveProcessor& primProc,
void GrGLProgram::bindTextures(const GrProcessor& processor,
bool allowSRGBInputs,
int* nextSamplerIdx) {
for (int i = 0; i < processor.numTextures(); ++i) {
const GrTextureAccess& access = processor.textureAccess(i);
fGpu->bindTexture((*nextSamplerIdx)++, access.getParams(),
allowSRGBInputs, static_cast<GrGLTexture*>(access.getTexture()));
for (int i = 0; i < processor.numTextureSamplers(); ++i) {
const GrProcessor::TextureSampler& sampler = processor.textureSampler(i);
fGpu->bindTexture((*nextSamplerIdx)++, sampler.getParams(),
allowSRGBInputs, static_cast<GrGLTexture*>(sampler.getTexture()));
}
for (int i = 0; i < processor.numBuffers(); ++i) {
const GrBufferAccess& access = processor.bufferAccess(i);
@ -166,9 +166,9 @@ void GrGLProgram::bindTextures(const GrProcessor& processor,
void GrGLProgram::generateMipmaps(const GrProcessor& processor,
bool allowSRGBInputs) {
for (int i = 0; i < processor.numTextures(); ++i) {
const GrTextureAccess& access = processor.textureAccess(i);
fGpu->generateMipmaps(access.getParams(), allowSRGBInputs,
static_cast<GrGLTexture*>(access.getTexture()));
for (int i = 0; i < processor.numTextureSamplers(); ++i) {
const GrProcessor::TextureSampler& sampler = processor.textureSampler(i);
fGpu->generateMipmaps(sampler.getParams(), allowSRGBInputs,
static_cast<GrGLTexture*>(sampler.getTexture()));
}
}

4
src/gpu/glsl/GrGLSLFragmentProcessor.h
View File

@ -72,7 +72,7 @@ public:
using TransformedCoordVars = BuilderInputProvider<GrShaderVar, GrFragmentProcessor,
&GrFragmentProcessor::numCoordTransforms>;
using TextureSamplers = BuilderInputProvider<SamplerHandle, GrProcessor,
&GrProcessor::numTextures>;
&GrProcessor::numTextureSamplers>;
using BufferSamplers = BuilderInputProvider<SamplerHandle, GrProcessor,
&GrProcessor::numBuffers>;
@ -94,7 +94,7 @@ public:
info about its output.
@param transformedCoords Fragment shader variables containing the coords computed using
each of the GrFragmentProcessor's GrCoordTransforms.
@param texSamplers Contains one entry for each GrTextureAccess of the GrProcessor.
@param texSamplers Contains one entry for each TextureSampler of the GrProcessor.
These can be passed to the builder to emit texture reads in the
generated code.
@param bufferSamplers Contains one entry for each GrBufferAccess of the GrProcessor.

20
src/gpu/glsl/GrGLSLProgramBuilder.cpp
View File

@ -96,7 +96,7 @@ void GrGLSLProgramBuilder::emitAndInstallPrimProc(const GrPrimitiveProcessor& pr
SkASSERT(!fGeometryProcessor);
fGeometryProcessor = proc.createGLSLInstance(*this->glslCaps());
SkSTArray<4, SamplerHandle> texSamplers(proc.numTextures());
SkSTArray<4, SamplerHandle> texSamplers(proc.numTextureSamplers());
SkSTArray<2, SamplerHandle> bufferSamplers(proc.numBuffers());
this->emitSamplers(proc, &texSamplers, &bufferSamplers);
@ -159,7 +159,7 @@ void GrGLSLProgramBuilder::emitAndInstallFragProc(const GrFragmentProcessor& fp,
GrGLSLFragmentProcessor* fragProc = fp.createGLSLInstance();
SkSTArray<4, SamplerHandle> textureSamplerArray(fp.numTextures());
SkSTArray<4, SamplerHandle> textureSamplerArray(fp.numTextureSamplers());
SkSTArray<2, SamplerHandle> bufferSamplerArray(fp.numBuffers());
GrFragmentProcessor::Iter iter(&fp);
while (const GrFragmentProcessor* subFP = iter.next()) {
@ -215,7 +215,7 @@ void GrGLSLProgramBuilder::emitAndInstallXferProc(const GrXferProcessor& xp,
openBrace.printf("{ // Xfer Processor: %s\n", xp.name());
fFS.codeAppend(openBrace.c_str());
SkSTArray<4, SamplerHandle> texSamplers(xp.numTextures());
SkSTArray<4, SamplerHandle> texSamplers(xp.numTextureSamplers());
SkSTArray<2, SamplerHandle> bufferSamplers(xp.numBuffers());
this->emitSamplers(xp, &texSamplers, &bufferSamplers);
@ -242,21 +242,21 @@ void GrGLSLProgramBuilder::emitSamplers(const GrProcessor& processor,
SkTArray<SamplerHandle>* outTexSamplers,
SkTArray<SamplerHandle>* outBufferSamplers) {
SkString name;
int numTextures = processor.numTextures();
for (int t = 0; t < numTextures; ++t) {
const GrTextureAccess& access = processor.textureAccess(t);
GrSLType samplerType = access.getTexture()->texturePriv().samplerType();
int numTextureSamplers = processor.numTextureSamplers();
for (int t = 0; t < numTextureSamplers; ++t) {
const GrProcessor::TextureSampler& sampler = processor.textureSampler(t);
GrSLType samplerType = sampler.getTexture()->texturePriv().samplerType();
if (kTextureExternalSampler_GrSLType == samplerType) {
const char* externalFeatureString = this->glslCaps()->externalTextureExtensionString();
// We shouldn't ever create a GrGLTexture that requires external sampler type
SkASSERT(externalFeatureString);
this->addFeature(access.getVisibility(),
this->addFeature(sampler.getVisibility(),
1 << GrGLSLShaderBuilder::kExternalTexture_GLSLPrivateFeature,
externalFeatureString);
}
name.printf("TextureSampler_%d", outTexSamplers->count());
this->emitSampler(samplerType, access.getTexture()->config(),
name.c_str(), access.getVisibility(), outTexSamplers);
this->emitSampler(samplerType, sampler.getTexture()->config(),
name.c_str(), sampler.getVisibility(), outTexSamplers);
}
if (int numBuffers = processor.numBuffers()) {

3
src/gpu/glsl/GrGLSLShaderBuilder.h
View File

@ -29,7 +29,8 @@ public:
/** Appends a 2D texture sample with projection if necessary. coordType must either be Vec2f or
Vec3f. The latter is interpreted as projective texture coords. The vec length and swizzle
order of the result depends on the GrTextureAccess associated with the GrGLSLSampler.
order of the result depends on the GrProcessor::TextureSampelr associated with the
GrGLSLSampler.
*/
void appendTextureLookup(SkString* out,
SamplerHandle,

9
src/gpu/vk/GrVkGpuCommandBuffer.cpp
View File

@ -12,7 +12,6 @@
#include "GrMesh.h"
#include "GrPipeline.h"
#include "GrRenderTargetPriv.h"
#include "GrTextureAccess.h"
#include "GrTexturePriv.h"
#include "GrVkCommandBuffer.h"
#include "GrVkGpu.h"
@ -427,9 +426,9 @@ sk_sp<GrVkPipelineState> GrVkGpuCommandBuffer::prepareDrawState(
}
static void prepare_sampled_images(const GrProcessor& processor, GrVkGpu* gpu) {
for (int i = 0; i < processor.numTextures(); ++i) {
const GrTextureAccess& texAccess = processor.textureAccess(i);
GrVkTexture* vkTexture = static_cast<GrVkTexture*>(processor.texture(i));
for (int i = 0; i < processor.numTextureSamplers(); ++i) {
const GrProcessor::TextureSampler& sampler = processor.textureSampler(i);
GrVkTexture* vkTexture = static_cast<GrVkTexture*>(sampler.getTexture());
SkASSERT(vkTexture);
// We may need to resolve the texture first if it is also a render target
@ -438,7 +437,7 @@ static void prepare_sampled_images(const GrProcessor& processor, GrVkGpu* gpu) {
gpu->onResolveRenderTarget(texRT);
}
const GrTextureParams& params = texAccess.getParams();
const GrTextureParams& params = sampler.getParams();
// Check if we need to regenerate any mip maps
if (GrTextureParams::kMipMap_FilterMode == params.filterMode()) {
if (vkTexture->texturePriv().mipMapsAreDirty()) {

20
src/gpu/vk/GrVkPipelineState.cpp
View File

@ -173,13 +173,14 @@ void GrVkPipelineState::abandonGPUResources() {
}
static void append_texture_bindings(const GrProcessor& processor,
SkTArray<const GrTextureAccess*>* textureBindings) {
if (int numTextures = processor.numTextures()) {
const GrTextureAccess** bindings = textureBindings->push_back_n(numTextures);
SkTArray<const GrProcessor::TextureSampler*>* textureBindings) {
if (int numTextureSamplers = processor.numTextureSamplers()) {
const GrProcessor::TextureSampler** bindings =
textureBindings->push_back_n(numTextureSamplers);
int i = 0;
do {
bindings[i] = &processor.textureAccess(i);
} while (++i < numTextures);
bindings[i] = &processor.textureSampler(i);
} while (++i < numTextureSamplers);
}
}
@ -192,7 +193,7 @@ void GrVkPipelineState::setData(GrVkGpu* gpu,
this->setRenderTargetState(pipeline);
SkSTArray<8, const GrTextureAccess*> textureBindings;
SkSTArray<8, const GrProcessor::TextureSampler*> textureBindings;
fGeometryProcessor->setData(fDataManager, primProc,
GrFragmentProcessor::CoordTransformIter(pipeline));
@ -302,9 +303,10 @@ void GrVkPipelineState::writeUniformBuffers(const GrVkGpu* gpu) {
}
}
void GrVkPipelineState::writeSamplers(GrVkGpu* gpu,
const SkTArray<const GrTextureAccess*>& textureBindings,
bool allowSRGBInputs) {
void GrVkPipelineState::writeSamplers(
GrVkGpu* gpu,
const SkTArray<const GrProcessor::TextureSampler*>& textureBindings,
bool allowSRGBInputs) {
SkASSERT(fNumSamplers == textureBindings.count());
for (int i = 0; i < textureBindings.count(); ++i) {

3
src/gpu/vk/GrVkPipelineState.h
View File

@ -141,7 +141,8 @@ private:
void writeUniformBuffers(const GrVkGpu* gpu);
void writeSamplers(GrVkGpu* gpu, const SkTArray<const GrTextureAccess*>& textureBindings,
void writeSamplers(GrVkGpu* gpu,
const SkTArray<const GrProcessor::TextureSampler*>& textureBindings,
bool allowSRGBInputs);
/**

1
src/gpu/vk/GrVkSampler.cpp
View File

@ -7,7 +7,6 @@
#include "GrVkSampler.h"
#include "GrTextureAccess.h"
#include "GrVkGpu.h"
static inline VkSamplerAddressMode tile_to_vk_sampler_address(SkShader::TileMode tm) {

1
src/gpu/vk/GrVkSampler.h
View File

@ -12,7 +12,6 @@
#include "vk/GrVkDefines.h"
class GrTextureAccess;
class GrTextureParams;
class GrVkGpu;

1
src/image/SkImageShader.cpp
View File

@ -175,7 +175,6 @@ void SkImageShader::toString(SkString* str) const {
#if SK_SUPPORT_GPU
#include "GrTextureAccess.h"
#include "SkGr.h"
#include "SkGrPriv.h"
#include "effects/GrSimpleTextureEffect.h"