blob: 66eba9a2057a5eec7d240b781f9b1e196d4a8f6d [file] [log] [blame]
/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrPipeline_DEFINED
#define GrPipeline_DEFINED
#include "include/core/SkMatrix.h"
#include "include/core/SkRefCnt.h"
#include "src/gpu/GrColor.h"
#include "src/gpu/GrDstProxyView.h"
#include "src/gpu/GrFragmentProcessor.h"
#include "src/gpu/GrProcessorSet.h"
#include "src/gpu/GrScissorState.h"
#include "src/gpu/GrSurfaceProxyView.h"
#include "src/gpu/GrUserStencilSettings.h"
#include "src/gpu/GrWindowRectsState.h"
#include "src/gpu/effects/GrCoverageSetOpXP.h"
#include "src/gpu/effects/GrDisableColorXP.h"
#include "src/gpu/effects/GrPorterDuffXferProcessor.h"
#include "src/gpu/effects/GrTextureEffect.h"
#include "src/gpu/geometry/GrRect.h"
class GrAppliedClip;
class GrAppliedHardClip;
struct GrGLSLBuiltinUniformHandles;
class GrGLSLProgramDataManager;
class GrOp;
class GrSurfaceDrawContext;
/**
* This immutable object contains information needed to build a shader program and set API
* state for a draw. It is used along with a GrGeometryProcessor and a source of geometric
* data to draw.
*/
class GrPipeline {
public:
///////////////////////////////////////////////////////////////////////////
/// @name Creation
// Pipeline options that the caller may enable.
// NOTE: This enum is extended later by GrPipeline::Flags.
enum class InputFlags : uint8_t {
kNone = 0,
/**
* Perform HW anti-aliasing. This means either HW FSAA, if supported by the render target,
* or smooth-line rendering if a line primitive is drawn and line smoothing is supported by
* the 3D API.
*/
kHWAntialias = (1 << 0),
/**
* Cause every pixel to be rasterized that is touched by the triangle anywhere (not just at
* pixel center). Additionally, if using MSAA, the sample mask will always have 100%
* coverage.
* NOTE: The primitive type must be a triangle type.
*/
kConservativeRaster = (1 << 1),
/**
* Draws triangles as outlines.
*/
kWireframe = (1 << 2),
/**
* Modifies the vertex shader so that vertices will be positioned at pixel centers.
*/
kSnapVerticesToPixelCenters = (1 << 3), // This value must be last. (See kLastInputFlag.)
};
struct InitArgs {
InputFlags fInputFlags = InputFlags::kNone;
const GrCaps* fCaps = nullptr;
GrDstProxyView fDstProxyView;
GrSwizzle fWriteSwizzle;
};
/**
* Creates a simple pipeline with default settings and no processors. The provided blend mode
* must be "Porter Duff" (<= kLastCoeffMode). If using GrScissorTest::kEnabled, the caller must
* specify a scissor rectangle through the DynamicState struct.
**/
GrPipeline(GrScissorTest scissor,
SkBlendMode blend,
const GrSwizzle& writeSwizzle,
InputFlags flags = InputFlags::kNone)
: GrPipeline(scissor,
GrPorterDuffXPFactory::MakeNoCoverageXP(blend),
writeSwizzle,
flags) {}
GrPipeline(GrScissorTest,
sk_sp<const GrXferProcessor>,
const GrSwizzle& writeSwizzle,
InputFlags = InputFlags::kNone);
GrPipeline(const InitArgs& args, sk_sp<const GrXferProcessor>, const GrAppliedHardClip&);
GrPipeline(const InitArgs&, GrProcessorSet&&, GrAppliedClip&&);
GrPipeline(const GrPipeline&) = delete;
GrPipeline& operator=(const GrPipeline&) = delete;
/// @}
///////////////////////////////////////////////////////////////////////////
/// @name GrFragmentProcessors
int numFragmentProcessors() const { return fFragmentProcessors.count(); }
int numColorFragmentProcessors() const { return fNumColorProcessors; }
bool isColorFragmentProcessor(int idx) const { return idx < fNumColorProcessors; }
bool isCoverageFragmentProcessor(int idx) const { return idx >= fNumColorProcessors; }
bool usesVaryingCoords() const {
for (const auto& fp : fFragmentProcessors) {
if (fp->usesVaryingCoords()) {
return true;
}
}
return false;
}
void visitTextureEffects(const std::function<void(const GrTextureEffect&)>&) const;
const GrXferProcessor& getXferProcessor() const {
if (fXferProcessor) {
return *fXferProcessor;
} else {
// A null xp member means the common src-over case. GrXferProcessor's ref'ing
// mechanism is not thread safe so we do not hold a ref on this global.
return GrPorterDuffXPFactory::SimpleSrcOverXP();
}
}
// Helper functions to quickly know if this GrPipeline will access the dst as a texture or an
// input attachment.
bool usesDstTexture() const { return this->dstProxyView() && !this->usesDstInputAttachment(); }
bool usesDstInputAttachment() const {
return this->dstSampleFlags()& GrDstSampleFlags::kAsInputAttachment;
}
/**
* This returns the GrSurfaceProxyView for the texture used to access the dst color. If the
* GrXferProcessor does not use the dst color then the proxy on the GrSurfaceProxyView will be
* nullptr.
*/
const GrSurfaceProxyView& dstProxyView() const { return fDstProxy.proxyView(); }
SkIPoint dstTextureOffset() const { return fDstProxy.offset(); }
GrDstSampleFlags dstSampleFlags() const { return fDstProxy.dstSampleFlags(); }
/** If this GrXferProcessor uses a texture to access the dst color, returns that texture. */
GrTexture* peekDstTexture() const {
if (!this->usesDstTexture()) {
return nullptr;
}
if (GrTextureProxy* dstProxy = this->dstProxyView().asTextureProxy()) {
return dstProxy->peekTexture();
}
return nullptr;
}
const GrFragmentProcessor& getFragmentProcessor(int idx) const {
return *fFragmentProcessors[idx];
}
/// @}
bool isScissorTestEnabled() const {
return SkToBool(fFlags & Flags::kScissorTestEnabled);
}
const GrWindowRectsState& getWindowRectsState() const { return fWindowRectsState; }
bool isHWAntialiasState() const { return fFlags & InputFlags::kHWAntialias; }
bool usesConservativeRaster() const { return fFlags & InputFlags::kConservativeRaster; }
bool isWireframe() const { return fFlags & InputFlags::kWireframe; }
bool snapVerticesToPixelCenters() const {
return fFlags & InputFlags::kSnapVerticesToPixelCenters;
}
bool hasStencilClip() const {
return SkToBool(fFlags & Flags::kHasStencilClip);
}
#ifdef SK_DEBUG
bool allProxiesInstantiated() const {
for (int i = 0; i < fFragmentProcessors.count(); ++i) {
if (!fFragmentProcessors[i]->isInstantiated()) {
return false;
}
}
if (this->dstProxyView().proxy()) {
return this->dstProxyView().proxy()->isInstantiated();
}
return true;
}
#endif
GrXferBarrierType xferBarrierType(const GrCaps&) const;
// Used by Vulkan and Metal to cache their respective pipeline objects
void genKey(GrProcessorKeyBuilder*, const GrCaps&) const;
const GrSwizzle& writeSwizzle() const { return fWriteSwizzle; }
void visitProxies(const GrVisitProxyFunc&) const;
void setDstTextureUniforms(const GrGLSLProgramDataManager& pdm,
GrGLSLBuiltinUniformHandles* fBuiltinUniformHandles) const;
private:
static constexpr uint8_t kLastInputFlag = (uint8_t)InputFlags::kSnapVerticesToPixelCenters;
/** This is a continuation of the public "InputFlags" enum. */
enum class Flags : uint8_t {
kHasStencilClip = (kLastInputFlag << 1),
kScissorTestEnabled = (kLastInputFlag << 2),
};
GR_DECL_BITFIELD_CLASS_OPS_FRIENDS(Flags);
friend bool operator&(Flags, InputFlags);
// A pipeline can contain up to three processors: color, paint coverage, and clip coverage.
using FragmentProcessorArray = SkAutoSTArray<3, std::unique_ptr<const GrFragmentProcessor>>;
GrDstProxyView fDstProxy;
GrWindowRectsState fWindowRectsState;
Flags fFlags;
sk_sp<const GrXferProcessor> fXferProcessor;
FragmentProcessorArray fFragmentProcessors;
// This value is also the index in fFragmentProcessors where coverage processors begin.
int fNumColorProcessors = 0;
GrSwizzle fWriteSwizzle;
};
GR_MAKE_BITFIELD_CLASS_OPS(GrPipeline::InputFlags)
GR_MAKE_BITFIELD_CLASS_OPS(GrPipeline::Flags)
inline bool operator&(GrPipeline::Flags flags, GrPipeline::InputFlags inputFlag) {
return (flags & (GrPipeline::Flags)inputFlag);
}
#endif