blob: 81727a402378000332861010db6c0686868771ad [file] [log] [blame]
/*
* Copyright 2017 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrTextureEffect_DEFINED
#define GrTextureEffect_DEFINED
#include "include/core/SkMatrix.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkSamplingOptions.h"
#include "src/gpu/ganesh/GrCaps.h"
#include "src/gpu/ganesh/GrFragmentProcessor.h"
#include "src/gpu/ganesh/GrProcessorUnitTest.h"
#include "src/gpu/ganesh/GrSamplerState.h"
#include "src/gpu/ganesh/GrSurfaceProxyView.h"
#include "src/gpu/ganesh/GrTextureProxy.h"
#include "src/gpu/ganesh/glsl/GrGLSLShaderBuilder.h"
#include <cstdint>
#include <memory>
class GrGLSLProgramDataManager;
class GrTexture;
enum SkAlphaType : int;
namespace skgpu { class KeyBuilder; }
struct GrShaderCaps;
class GrTextureEffect : public GrFragmentProcessor {
public:
inline static constexpr float kDefaultBorder[4] = {0};
// An extra inset amount to apply to subset clamp boundaries to ensure clamped coordinates will
// access texel (i-1) to i instead of i to (i+1), even if the weights should mean the clamped
// color is still equal to texel i's value.
#if defined(SK_USE_SAFE_INSET_FOR_TEXTURE_SAMPLING)
inline static constexpr float kInsetEpsilon = 0.0001f;
#else
// A value of 0 means that coordinates for linear filtering will be clamped to exactly 1/2px
// inset from the defined data boundary (for approx-fit textures that don't fill to the HW
// boundaries). For bottom/right edges this can then access the row or column outside of the
// defined data. The filtering weight should be 0, which should be safe for non-floating-point
// color types, and not have any impact on the clamped sample. In practice, devices with lower
// precision texture coordinates may not actually evaluate with a weight of 0, and it is
// caught by Swiftshader+MSAN.
inline static constexpr float kInsetEpsilon = 0.f;
#endif
inline static constexpr float kLinearInset = 0.5f + kInsetEpsilon;
/** Make from a filter. The sampler will be configured with clamp mode. */
static std::unique_ptr<GrFragmentProcessor> Make(
GrSurfaceProxyView,
SkAlphaType,
const SkMatrix& = SkMatrix::I(),
GrSamplerState::Filter = GrSamplerState::Filter::kNearest,
GrSamplerState::MipmapMode mipmapMode = GrSamplerState::MipmapMode::kNone);
/**
* Make from a full GrSamplerState. Caps are required to determine support for kClampToBorder.
* This will be emulated in the shader if there is no hardware support.
*/
static std::unique_ptr<GrFragmentProcessor> Make(GrSurfaceProxyView, SkAlphaType,
const SkMatrix&, GrSamplerState,
const GrCaps& caps,
const float border[4] = kDefaultBorder);
/**
* Makes a texture effect that samples a subset of a texture. The wrap modes of the
* GrSampleState are applied to the subset in the shader rather than using HW samplers.
* The 'subset' parameter specifies the texels in the base level. The shader code will
* avoid allowing linear filtering to read outside the texel window. However, if MIP
* filtering is used and a shader invocation reads from a level other than the base
* then it may read texel values that were computed from in part from base level texels
* outside the window. More specifically, we treat the MIP map case exactly like the
* linear case in terms of how the final texture coords are computed. If
* alwaysUseShaderTileMode is true then MakeSubset won't attempt to use HW wrap modes if the
* subset contains the entire texture.
*/
static std::unique_ptr<GrFragmentProcessor> MakeSubset(GrSurfaceProxyView,
SkAlphaType,
const SkMatrix&,
GrSamplerState,
const SkRect& subset,
const GrCaps& caps,
const float border[4] = kDefaultBorder,
bool alwaysUseShaderTileMode = false);
/**
* The same as above but also takes a 'domain' that specifies any known limit on the post-
* matrix texture coords that will be used to sample the texture. Specifying this requires
* knowledge of how this effect will be nested into a paint, the local coords used with the
* draw, etc. It is only used to attempt to optimize away the shader subset calculations.
*/
static std::unique_ptr<GrFragmentProcessor> MakeSubset(GrSurfaceProxyView,
SkAlphaType,
const SkMatrix&,
GrSamplerState,
const SkRect& subset,
const SkRect& domain,
const GrCaps& caps,
const float border[4] = kDefaultBorder);
/**
* Like MakeSubset() but always uses kLinear filtering. MakeSubset() uses the subset rect
* dimensions to determine the period of the wrap mode (for repeat and mirror). Once it computes
* the wrapped texture coordinate inside subset rect it further clamps it to a 0.5 inset rect of
* subset. When subset is an integer rectangle this clamping avoids the hw linear filtering from
* reading texels just outside the subset rect. This factory allows a custom inset clamping
* distance rather than 0.5, allowing those neighboring texels to influence the linear filtering
* sample result. If there is a known restriction on the post-matrix texture coords it can be
* specified using domain.
*/
static std::unique_ptr<GrFragmentProcessor> MakeCustomLinearFilterInset(
GrSurfaceProxyView,
SkAlphaType,
const SkMatrix&,
GrSamplerState::WrapMode wx,
GrSamplerState::WrapMode wy,
const SkRect& subset,
const SkRect* domain,
SkVector inset,
const GrCaps& caps,
const float border[4] = kDefaultBorder);
std::unique_ptr<GrFragmentProcessor> clone() const override;
const char* name() const override { return "TextureEffect"; }
GrSamplerState samplerState() const { return fSamplerState; }
GrTexture* texture() const { return fView.asTextureProxy()->peekTexture(); }
const GrSurfaceProxyView& view() const { return fView; }
// Gets a matrix that is concat'ed by wrapping GrMatrixEffect that handles y-flip and coord
// normalization if required. This matrix is not always known when we make the GrTextureEffect
// because of fully-lazy proxies. Hence, this method exists to allow this concat to happen
// after proxy instantiation with coordination from GrMatrixEffect.
SkMatrix coordAdjustmentMatrix() const;
class Impl : public ProgramImpl {
public:
void emitCode(EmitArgs&) override;
void setSamplerHandle(GrGLSLShaderBuilder::SamplerHandle handle) {
fSamplerHandle = handle;
}
private:
void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
UniformHandle fSubsetUni;
UniformHandle fClampUni;
UniformHandle fIDimsUni;
UniformHandle fBorderUni;
GrGLSLShaderBuilder::SamplerHandle fSamplerHandle;
};
private:
struct Sampling;
/**
* Possible implementation of wrap mode in shader code. Some modes are specialized by
* filter.
*/
enum class ShaderMode : uint16_t {
kNone, // Using HW mode
kClamp, // Shader based clamp, no filter specialization
kRepeat_Nearest_None, // Simple repeat for nearest sampling, no mipmapping
kRepeat_Linear_None, // Filter the subset boundary for kRepeat mode, no mip mapping
kRepeat_Linear_Mipmap, // Logic for linear filtering and LOD selection with kRepeat mode.
kRepeat_Nearest_Mipmap, // Logic for nearest filtering and LOD selection with kRepeat mode.
kMirrorRepeat, // Mirror repeat (doesn't depend on filter))
kClampToBorder_Nearest, // Logic for hard transition to border color when not filtering.
kClampToBorder_Filter, // Logic for fading to border color when filtering.
};
static ShaderMode GetShaderMode(GrSamplerState::WrapMode,
GrSamplerState::Filter,
GrSamplerState::MipmapMode);
static bool ShaderModeIsClampToBorder(ShaderMode);
// To keep things a little simpler, when we have filtering logic in the shader we
// operate on unnormalized texture coordinates. We will add a uniform that stores
// {1/w, 1/h} in a float2 and normalizes after the mode is handled if the texture
// is not rectangle.
static bool ShaderModeRequiresUnormCoord(ShaderMode);
GrSurfaceProxyView fView;
GrSamplerState fSamplerState;
float fBorder[4];
SkRect fSubset;
SkRect fClamp;
ShaderMode fShaderModes[2];
inline GrTextureEffect(GrSurfaceProxyView, SkAlphaType, const Sampling&);
explicit GrTextureEffect(const GrTextureEffect& src);
std::unique_ptr<ProgramImpl> onMakeProgramImpl() const override;
void onAddToKey(const GrShaderCaps&, skgpu::KeyBuilder*) const override;
bool onIsEqual(const GrFragmentProcessor&) const override;
bool matrixEffectShouldNormalize() const;
bool hasClampToBorderShaderMode() const {
return ShaderModeIsClampToBorder(fShaderModes[0]) ||
ShaderModeIsClampToBorder(fShaderModes[1]);
}
GR_DECLARE_FRAGMENT_PROCESSOR_TEST
using INHERITED = GrFragmentProcessor;
};
#endif