Add GrProgramInfo to centralize management of program information
This is the first step in moving the marshaling of program information earlier in renderTask processing (i.e., to onPrePrepare).
Change-Id: I91e3baed9a128e845bd32f9dbbacd9b21d852a3d
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/244118
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Robert Phillips <robertphillips@google.com>
diff --git a/src/gpu/gl/GrGLGpu.cpp b/src/gpu/gl/GrGLGpu.cpp
index 0c1559c..bf2b81a 100644
--- a/src/gpu/gl/GrGLGpu.cpp
+++ b/src/gpu/gl/GrGLGpu.cpp
@@ -26,6 +26,7 @@
#include "src/gpu/GrGpuResourcePriv.h"
#include "src/gpu/GrMesh.h"
#include "src/gpu/GrPipeline.h"
+#include "src/gpu/GrProgramInfo.h"
#include "src/gpu/GrRenderTargetPriv.h"
#include "src/gpu/GrShaderCaps.h"
#include "src/gpu/GrSurfaceProxyPriv.h"
@@ -1658,28 +1659,11 @@
}
bool GrGLGpu::flushGLState(GrRenderTarget* renderTarget,
- int numSamples,
- GrSurfaceOrigin origin,
- const GrPrimitiveProcessor& primProc,
- const GrPipeline& pipeline,
- const GrPipeline::FixedDynamicState* fixedDynamicState,
- const GrPipeline::DynamicStateArrays* dynamicStateArrays,
- int dynamicStateArraysLength,
+ const GrProgramInfo& programInfo,
bool willDrawPoints) {
- const GrTextureProxy* const* primProcProxies = nullptr;
- const GrTextureProxy* const* primProcProxiesToBind = nullptr;
- if (dynamicStateArrays && dynamicStateArrays->fPrimitiveProcessorTextures) {
- primProcProxies = dynamicStateArrays->fPrimitiveProcessorTextures;
- } else if (fixedDynamicState && fixedDynamicState->fPrimitiveProcessorTextures) {
- primProcProxies = fixedDynamicState->fPrimitiveProcessorTextures;
- primProcProxiesToBind = fixedDynamicState->fPrimitiveProcessorTextures;
- }
- SkASSERT(SkToBool(primProcProxies) == SkToBool(primProc.numTextureSamplers()));
-
- sk_sp<GrGLProgram> program(fProgramCache->refProgram(
- this, renderTarget, numSamples, origin, primProc, primProcProxies, pipeline,
- willDrawPoints));
+ sk_sp<GrGLProgram> program(fProgramCache->refProgram(this, renderTarget, programInfo,
+ willDrawPoints));
if (!program) {
GrCapsDebugf(this->caps(), "Failed to create program!\n");
return false;
@@ -1688,30 +1672,32 @@
this->flushProgram(std::move(program));
// Swizzle the blend to match what the shader will output.
- this->flushBlendAndColorWrite(
- pipeline.getXferProcessor().getBlendInfo(), pipeline.outputSwizzle());
+ this->flushBlendAndColorWrite(programInfo.pipeline().getXferProcessor().getBlendInfo(),
+ programInfo.pipeline().outputSwizzle());
- fHWProgram->updateUniformsAndTextureBindings(renderTarget, origin,
- primProc, pipeline, primProcProxiesToBind);
+ fHWProgram->updateUniformsAndTextureBindings(renderTarget, programInfo);
GrGLRenderTarget* glRT = static_cast<GrGLRenderTarget*>(renderTarget);
GrStencilSettings stencil;
- if (pipeline.isStencilEnabled()) {
+ if (programInfo.pipeline().isStencilEnabled()) {
// TODO: attach stencil and create settings during render target flush.
SkASSERT(glRT->renderTargetPriv().getStencilAttachment());
- stencil.reset(*pipeline.getUserStencil(), pipeline.hasStencilClip(),
+ stencil.reset(*programInfo.pipeline().getUserStencil(),
+ programInfo.pipeline().hasStencilClip(),
glRT->renderTargetPriv().numStencilBits());
}
- this->flushStencil(stencil, origin);
- if (pipeline.isScissorEnabled()) {
+ this->flushStencil(stencil, programInfo.origin());
+ if (programInfo.pipeline().isScissorEnabled()) {
static constexpr SkIRect kBogusScissor{0, 0, 1, 1};
- GrScissorState state(fixedDynamicState ? fixedDynamicState->fScissorRect : kBogusScissor);
- this->flushScissor(state, glRT->width(), glRT->height(), origin);
+ GrScissorState state(programInfo.fixedDynamicState() ? programInfo.fixedScissor()
+ : kBogusScissor);
+ this->flushScissor(state, glRT->width(), glRT->height(), programInfo.origin());
} else {
this->disableScissor();
}
- this->flushWindowRectangles(pipeline.getWindowRectsState(), glRT, origin);
- this->flushHWAAState(glRT, pipeline.isHWAntialiasState());
+ this->flushWindowRectangles(programInfo.pipeline().getWindowRectsState(),
+ glRT, programInfo.origin());
+ this->flushHWAAState(glRT, programInfo.pipeline().isHWAntialiasState());
// This must come after textures are flushed because a texture may need
// to be msaa-resolved (which will modify bound FBO state).
@@ -2180,15 +2166,16 @@
#endif
#endif
-void GrGLGpu::draw(GrRenderTarget* renderTarget, int numSamples, GrSurfaceOrigin origin,
- const GrPrimitiveProcessor& primProc,
- const GrPipeline& pipeline,
- const GrPipeline::FixedDynamicState* fixedDynamicState,
- const GrPipeline::DynamicStateArrays* dynamicStateArrays,
+void GrGLGpu::draw(GrRenderTarget* renderTarget,
+ const GrProgramInfo& programInfo,
const GrMesh meshes[],
int meshCount) {
this->handleDirtyContext();
+ if (meshCount == 0) {
+ return;
+ }
+
bool hasPoints = false;
for (int i = 0; i < meshCount; ++i) {
if (meshes[i].primitiveType() == GrPrimitiveType::kPoints) {
@@ -2196,32 +2183,28 @@
break;
}
}
- if (!this->flushGLState(renderTarget, numSamples, origin, primProc, pipeline, fixedDynamicState,
- dynamicStateArrays, meshCount, hasPoints)) {
+ if (!this->flushGLState(renderTarget, programInfo, hasPoints)) {
return;
}
- bool dynamicScissor = false;
- bool dynamicPrimProcTextures = false;
- if (dynamicStateArrays) {
- dynamicScissor = pipeline.isScissorEnabled() && dynamicStateArrays->fScissorRects;
- dynamicPrimProcTextures = dynamicStateArrays->fPrimitiveProcessorTextures;
- }
+ bool hasDynamicScissors = programInfo.hasDynamicScissors();
+ bool hasDynamicPrimProcTextures = programInfo.hasDynamicPrimProcTextures();
+
for (int m = 0; m < meshCount; ++m) {
- if (GrXferBarrierType barrierType = pipeline.xferBarrierType(renderTarget->asTexture(),
- *this->caps())) {
+ if (auto barrierType = programInfo.pipeline().xferBarrierType(renderTarget->asTexture(),
+ *this->caps())) {
this->xferBarrier(renderTarget, barrierType);
}
- if (dynamicScissor) {
+ if (hasDynamicScissors) {
GrGLRenderTarget* glRT = static_cast<GrGLRenderTarget*>(renderTarget);
- this->flushScissor(GrScissorState(dynamicStateArrays->fScissorRects[m]),
- glRT->width(), glRT->height(), origin);
+ this->flushScissor(GrScissorState(programInfo.dynamicScissor(m)),
+ glRT->width(), glRT->height(), programInfo.origin());
}
- if (dynamicPrimProcTextures) {
- auto texProxyArray = dynamicStateArrays->fPrimitiveProcessorTextures +
- m * primProc.numTextureSamplers();
- fHWProgram->updatePrimitiveProcessorTextureBindings(primProc, texProxyArray);
+ if (hasDynamicPrimProcTextures) {
+ auto texProxyArray = programInfo.dynamicPrimProcTextures(m);
+ fHWProgram->updatePrimitiveProcessorTextureBindings(programInfo.primProc(),
+ texProxyArray);
}
if (this->glCaps().requiresCullFaceEnableDisableWhenDrawingLinesAfterNonLines() &&
GrIsPrimTypeLines(meshes[m].primitiveType()) &&
diff --git a/src/gpu/gl/GrGLGpu.h b/src/gpu/gl/GrGLGpu.h
index 8fba42a..8633c32 100644
--- a/src/gpu/gl/GrGLGpu.h
+++ b/src/gpu/gl/GrGLGpu.h
@@ -75,13 +75,7 @@
// The GrGLOpsRenderPass does not buffer up draws before submitting them to the gpu.
// Thus this is the implementation of the draw call for the corresponding passthrough function
// on GrGLOpsRenderPass.
- void draw(GrRenderTarget*, int numSamples, GrSurfaceOrigin,
- const GrPrimitiveProcessor&,
- const GrPipeline&,
- const GrPipeline::FixedDynamicState*,
- const GrPipeline::DynamicStateArrays*,
- const GrMesh[],
- int meshCount);
+ void draw(GrRenderTarget*, const GrProgramInfo&, const GrMesh[], int meshCount);
// GrMesh::SendToGpuImpl methods. These issue the actual GL draw calls.
// Marked final as a hint to the compiler to not use virtual dispatch.
@@ -280,10 +274,7 @@
// willDrawPoints must be true if point primitives will be rendered after setting the GL state.
// If DynamicStateArrays is not null then dynamicStateArraysLength is the number of dynamic
// state entries in each array.
- bool flushGLState(GrRenderTarget*, int numSamples, GrSurfaceOrigin, const GrPrimitiveProcessor&,
- const GrPipeline&, const GrPipeline::FixedDynamicState*,
- const GrPipeline::DynamicStateArrays*, int dynamicStateArraysLength,
- bool willDrawPoints);
+ bool flushGLState(GrRenderTarget*, const GrProgramInfo&, bool willDrawPoints);
void flushProgram(sk_sp<GrGLProgram>);
@@ -321,10 +312,7 @@
void abandon();
void reset();
- GrGLProgram* refProgram(GrGLGpu*, GrRenderTarget*, int numSamples, GrSurfaceOrigin,
- const GrPrimitiveProcessor&,
- const GrTextureProxy* const primProcProxies[],
- const GrPipeline&, bool hasPointSize);
+ GrGLProgram* refProgram(GrGLGpu*, GrRenderTarget*, const GrProgramInfo&, bool hasPointSize);
bool precompileShader(const SkData& key, const SkData& data);
private:
diff --git a/src/gpu/gl/GrGLGpuProgramCache.cpp b/src/gpu/gl/GrGLGpuProgramCache.cpp
index 484048a..61ac321 100644
--- a/src/gpu/gl/GrGLGpuProgramCache.cpp
+++ b/src/gpu/gl/GrGLGpuProgramCache.cpp
@@ -47,30 +47,29 @@
GrGLProgram* GrGLGpu::ProgramCache::refProgram(GrGLGpu* gpu,
GrRenderTarget* renderTarget,
- int numSamples,
- GrSurfaceOrigin origin,
- const GrPrimitiveProcessor& primProc,
- const GrTextureProxy* const primProcProxies[],
- const GrPipeline& pipeline,
+ const GrProgramInfo& programInfo,
bool isPoints) {
+
+
+ // TODO: can this be unified between GL and Vk?
// Get GrGLProgramDesc
GrProgramDesc desc;
- if (!GrProgramDesc::Build(&desc, renderTarget, primProc, isPoints, pipeline, gpu)) {
+ if (!GrProgramDesc::Build(&desc, renderTarget, programInfo, isPoints, gpu)) {
GrCapsDebugf(gpu->caps(), "Failed to gl program descriptor!\n");
return nullptr;
}
// If we knew the shader won't depend on origin, we could skip this (and use the same program
// for both origins). Instrumenting all fragment processors would be difficult and error prone.
- desc.setSurfaceOriginKey(GrGLSLFragmentShaderBuilder::KeyForSurfaceOrigin(origin));
+ desc.setSurfaceOriginKey(
+ GrGLSLFragmentShaderBuilder::KeyForSurfaceOrigin(programInfo.origin()));
std::unique_ptr<Entry>* entry = fMap.find(desc);
if (entry && !(*entry)->fProgram) {
// We've pre-compiled the GL program, but don't have the GrGLProgram scaffolding
const GrGLPrecompiledProgram* precompiledProgram = &((*entry)->fPrecompiledProgram);
SkASSERT(precompiledProgram->fProgramID != 0);
- GrGLProgram* program = GrGLProgramBuilder::CreateProgram(renderTarget, numSamples, origin,
- primProc, primProcProxies,
- pipeline, &desc, fGpu,
+ GrGLProgram* program = GrGLProgramBuilder::CreateProgram(renderTarget, programInfo,
+ &desc, fGpu,
precompiledProgram);
if (nullptr == program) {
// Should we purge the program ID from the cache at this point?
@@ -80,9 +79,8 @@
(*entry)->fProgram.reset(program);
} else if (!entry) {
// We have a cache miss
- GrGLProgram* program = GrGLProgramBuilder::CreateProgram(renderTarget, numSamples, origin,
- primProc, primProcProxies,
- pipeline, &desc, fGpu);
+ GrGLProgram* program = GrGLProgramBuilder::CreateProgram(renderTarget, programInfo,
+ &desc, fGpu);
if (nullptr == program) {
return nullptr;
}
diff --git a/src/gpu/gl/GrGLOpsRenderPass.h b/src/gpu/gl/GrGLOpsRenderPass.h
index cd7e5a0..fc04883 100644
--- a/src/gpu/gl/GrGLOpsRenderPass.h
+++ b/src/gpu/gl/GrGLOpsRenderPass.h
@@ -52,15 +52,9 @@
private:
GrGpu* gpu() override { return fGpu; }
- void onDraw(const GrPrimitiveProcessor& primProc,
- const GrPipeline& pipeline,
- const GrPipeline::FixedDynamicState* fixedDynamicState,
- const GrPipeline::DynamicStateArrays* dynamicStateArrays,
- const GrMesh mesh[],
- int meshCount,
+ void onDraw(const GrProgramInfo& programInfo, const GrMesh mesh[], int meshCount,
const SkRect& bounds) override {
- fGpu->draw(fRenderTarget, fRenderTarget->numSamples(), fOrigin, primProc, pipeline,
- fixedDynamicState, dynamicStateArrays, mesh, meshCount);
+ fGpu->draw(fRenderTarget, programInfo, mesh, meshCount);
}
void onClear(const GrFixedClip& clip, const SkPMColor4f& color) override {
diff --git a/src/gpu/gl/GrGLPathRendering.cpp b/src/gpu/gl/GrGLPathRendering.cpp
index 9dc4437..327c8d2 100644
--- a/src/gpu/gl/GrGLPathRendering.cpp
+++ b/src/gpu/gl/GrGLPathRendering.cpp
@@ -112,14 +112,10 @@
}
void GrGLPathRendering::onDrawPath(GrRenderTarget* renderTarget,
- int numSamples, GrSurfaceOrigin origin,
- const GrPrimitiveProcessor& primProc,
- const GrPipeline& pipeline,
- const GrPipeline::FixedDynamicState& fixedDynamicState,
+ const GrProgramInfo& programInfo,
const GrStencilSettings& stencilPassSettings,
const GrPath* path) {
- if (!this->gpu()->flushGLState(renderTarget, numSamples, origin, primProc, pipeline,
- &fixedDynamicState, nullptr, 1, false)) {
+ if (!this->gpu()->flushGLState(renderTarget, programInfo, false)) {
return;
}
const GrGLPath* glPath = static_cast<const GrGLPath*>(path);
diff --git a/src/gpu/gl/GrGLPathRendering.h b/src/gpu/gl/GrGLPathRendering.h
index 167aa402..14284b4 100644
--- a/src/gpu/gl/GrGLPathRendering.h
+++ b/src/gpu/gl/GrGLPathRendering.h
@@ -65,11 +65,7 @@
protected:
void onStencilPath(const StencilPathArgs&, const GrPath*) override;
- void onDrawPath(GrRenderTarget*, int numSamples, GrSurfaceOrigin,
- const GrPrimitiveProcessor&,
- const GrPipeline&,
- const GrPipeline::FixedDynamicState&,
- const GrStencilSettings&,
+ void onDrawPath(GrRenderTarget*, const GrProgramInfo&, const GrStencilSettings&,
const GrPath*) override;
private:
diff --git a/src/gpu/gl/GrGLProgram.cpp b/src/gpu/gl/GrGLProgram.cpp
index e96ffa3..74cf539 100644
--- a/src/gpu/gl/GrGLProgram.cpp
+++ b/src/gpu/gl/GrGLProgram.cpp
@@ -10,6 +10,7 @@
#include "src/gpu/GrPathProcessor.h"
#include "src/gpu/GrPipeline.h"
#include "src/gpu/GrProcessor.h"
+#include "src/gpu/GrProgramInfo.h"
#include "src/gpu/GrTexturePriv.h"
#include "src/gpu/GrXferProcessor.h"
#include "src/gpu/gl/GrGLBuffer.h"
@@ -73,11 +74,9 @@
///////////////////////////////////////////////////////////////////////////////
void GrGLProgram::updateUniformsAndTextureBindings(const GrRenderTarget* renderTarget,
- GrSurfaceOrigin origin,
- const GrPrimitiveProcessor& primProc,
- const GrPipeline& pipeline,
- const GrTextureProxy* const primProcTextures[]) {
- this->setRenderTargetState(renderTarget, origin, primProc);
+ const GrProgramInfo& programInfo) {
+
+ this->setRenderTargetState(renderTarget, programInfo.origin(), programInfo.primProc());
// we set the textures, and uniforms for installed processors in a generic way, but subclasses
// of GLProgram determine how to set coord transforms
@@ -85,23 +84,24 @@
// We must bind to texture units in the same order in which we set the uniforms in
// GrGLProgramDataManager. That is, we bind textures for processors in this order:
// primProc, fragProcs, XP.
- fPrimitiveProcessor->setData(fProgramDataManager, primProc,
- GrFragmentProcessor::CoordTransformIter(pipeline));
- if (primProcTextures) {
- this->updatePrimitiveProcessorTextureBindings(primProc, primProcTextures);
+ fPrimitiveProcessor->setData(fProgramDataManager, programInfo.primProc(),
+ GrFragmentProcessor::CoordTransformIter(programInfo.pipeline()));
+ if (programInfo.hasFixedPrimProcTextures()) {
+ this->updatePrimitiveProcessorTextureBindings(programInfo.primProc(),
+ programInfo.fixedPrimProcTextures());
}
- int nextTexSamplerIdx = primProc.numTextureSamplers();
+ int nextTexSamplerIdx = programInfo.primProc().numTextureSamplers();
- this->setFragmentData(pipeline, &nextTexSamplerIdx);
+ this->setFragmentData(programInfo.pipeline(), &nextTexSamplerIdx);
- const GrXferProcessor& xp = pipeline.getXferProcessor();
+ const GrXferProcessor& xp = programInfo.pipeline().getXferProcessor();
SkIPoint offset;
- GrTexture* dstTexture = pipeline.peekDstTexture(&offset);
+ GrTexture* dstTexture = programInfo.pipeline().peekDstTexture(&offset);
fXferProcessor->setData(fProgramDataManager, xp, dstTexture, offset);
if (dstTexture) {
fGpu->bindTexture(nextTexSamplerIdx++, GrSamplerState::ClampNearest(),
- pipeline.dstTextureProxy()->textureSwizzle(),
+ programInfo.pipeline().dstTextureProxy()->textureSwizzle(),
static_cast<GrGLTexture*>(dstTexture));
}
SkASSERT(nextTexSamplerIdx == fNumTextureSamplers);
diff --git a/src/gpu/gl/GrGLProgram.h b/src/gpu/gl/GrGLProgram.h
index b28bedb..cf2e2aa 100644
--- a/src/gpu/gl/GrGLProgram.h
+++ b/src/gpu/gl/GrGLProgram.h
@@ -18,6 +18,7 @@
class GrGLSLXferProcessor;
class GrPipeline;
class GrPrimitiveProcessor;
+class GrProgramInfo;
class GrRenderTarget;
class GrTextureProxy;
@@ -118,9 +119,7 @@
*
* It is the caller's responsibility to ensure the program is bound before calling.
*/
- void updateUniformsAndTextureBindings(const GrRenderTarget*, GrSurfaceOrigin,
- const GrPrimitiveProcessor&, const GrPipeline&,
- const GrTextureProxy* const primitiveProcessorTextures[]);
+ void updateUniformsAndTextureBindings(const GrRenderTarget*, const GrProgramInfo&);
void updatePrimitiveProcessorTextureBindings(const GrPrimitiveProcessor&,
const GrTextureProxy* const[]);
diff --git a/src/gpu/gl/GrGLVaryingHandler.cpp b/src/gpu/gl/GrGLVaryingHandler.cpp
index 8f48a21..76ab128 100644
--- a/src/gpu/gl/GrGLVaryingHandler.cpp
+++ b/src/gpu/gl/GrGLVaryingHandler.cpp
@@ -18,10 +18,7 @@
GrGLProgramBuilder* glPB = (GrGLProgramBuilder*) fProgramBuilder;
// This call is not used for non-NVPR backends.
SkASSERT(glPB->gpu()->glCaps().shaderCaps()->pathRenderingSupport() &&
- glPB->fPrimProc.isPathRendering() &&
- !glPB->fPrimProc.willUseGeoShader() &&
- !glPB->fPrimProc.numVertexAttributes() &&
- !glPB->fPrimProc.numInstanceAttributes());
+ fProgramBuilder->fProgramInfo.isNVPR());
#endif
this->addVarying(name, v);
auto varyingInfo = fPathProcVaryingInfos.push_back();
diff --git a/src/gpu/gl/builders/GrGLProgramBuilder.cpp b/src/gpu/gl/builders/GrGLProgramBuilder.cpp
index 507d210..07ea39c 100644
--- a/src/gpu/gl/builders/GrGLProgramBuilder.cpp
+++ b/src/gpu/gl/builders/GrGLProgramBuilder.cpp
@@ -46,23 +46,18 @@
}
GrGLProgram* GrGLProgramBuilder::CreateProgram(GrRenderTarget* renderTarget,
- int numSamples,
- GrSurfaceOrigin origin,
- const GrPrimitiveProcessor& primProc,
- const GrTextureProxy* const primProcProxies[],
- const GrPipeline& pipeline,
+ const GrProgramInfo& programInfo,
GrProgramDesc* desc,
GrGLGpu* gpu,
const GrGLPrecompiledProgram* precompiledProgram) {
- SkASSERT(!pipeline.isBad());
+ SkASSERT(!programInfo.pipeline().isBad());
ATRACE_ANDROID_FRAMEWORK("Shader Compile");
GrAutoLocaleSetter als("C");
// create a builder. This will be handed off to effects so they can use it to add
// uniforms, varyings, textures, etc
- GrGLProgramBuilder builder(gpu, renderTarget, numSamples, origin,
- pipeline, primProc, primProcProxies, desc);
+ GrGLProgramBuilder builder(gpu, renderTarget, programInfo, desc);
auto persistentCache = gpu->getContext()->priv().getPersistentCache();
if (persistentCache && !precompiledProgram) {
@@ -82,13 +77,9 @@
GrGLProgramBuilder::GrGLProgramBuilder(GrGLGpu* gpu,
GrRenderTarget* renderTarget,
- int numSamples,
- GrSurfaceOrigin origin,
- const GrPipeline& pipeline,
- const GrPrimitiveProcessor& primProc,
- const GrTextureProxy* const primProcProxies[],
+ const GrProgramInfo& programInfo,
GrProgramDesc* desc)
- : INHERITED(renderTarget, numSamples, origin, primProc, primProcProxies, pipeline, desc)
+ : INHERITED(renderTarget, programInfo, desc)
, fGpu(gpu)
, fVaryingHandler(this)
, fUniformHandler(this)
@@ -170,7 +161,7 @@
if (!this->gpu()->getContext()->priv().getPersistentCache()) {
return;
}
- sk_sp<SkData> key = SkData::MakeWithoutCopy(desc()->asKey(), desc()->keyLength());
+ sk_sp<SkData> key = SkData::MakeWithoutCopy(this->desc()->asKey(), this->desc()->keyLength());
if (fGpu->glCaps().programBinarySupport()) {
// binary cache
GrGLsizei length = 0;
diff --git a/src/gpu/gl/builders/GrGLProgramBuilder.h b/src/gpu/gl/builders/GrGLProgramBuilder.h
index b0fa41f..800c64a 100644
--- a/src/gpu/gl/builders/GrGLProgramBuilder.h
+++ b/src/gpu/gl/builders/GrGLProgramBuilder.h
@@ -48,11 +48,7 @@
* @return true if generation was successful.
*/
static GrGLProgram* CreateProgram(GrRenderTarget*,
- int numSamples,
- GrSurfaceOrigin,
- const GrPrimitiveProcessor&,
- const GrTextureProxy* const primProcProxies[],
- const GrPipeline&,
+ const GrProgramInfo&,
GrProgramDesc*,
GrGLGpu*,
const GrGLPrecompiledProgram* = nullptr);
@@ -64,9 +60,7 @@
GrGLGpu* gpu() const { return fGpu; }
private:
- GrGLProgramBuilder(GrGLGpu*, GrRenderTarget*, int numSamples, GrSurfaceOrigin,
- const GrPipeline&, const GrPrimitiveProcessor&,
- const GrTextureProxy* const primProcProxies[], GrProgramDesc*);
+ GrGLProgramBuilder(GrGLGpu*, GrRenderTarget*, const GrProgramInfo&, GrProgramDesc*);
void addInputVars(const SkSL::Program::Inputs& inputs);
bool compileAndAttachShaders(const SkSL::String& glsl,