1 /*
2 * Copyright 2011 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7 #include "src/gpu/ganesh/gl/GrGLProgram.h"
8
9 #include "include/core/SkSamplingOptions.h"
10 #include "include/gpu/ganesh/GrTypes.h"
11 #include "include/gpu/ganesh/gl/GrGLFunctions.h"
12 #include "include/gpu/ganesh/gl/GrGLInterface.h"
13 #include "src/gpu/Swizzle.h"
14 #include "src/gpu/ganesh/GrCaps.h"
15 #include "src/gpu/ganesh/GrFragmentProcessor.h"
16 #include "src/gpu/ganesh/GrGeometryProcessor.h"
17 #include "src/gpu/ganesh/GrPipeline.h"
18 #include "src/gpu/ganesh/GrProgramInfo.h"
19 #include "src/gpu/ganesh/GrRenderTarget.h"
20 #include "src/gpu/ganesh/GrSamplerState.h"
21 #include "src/gpu/ganesh/GrSurfaceProxy.h"
22 #include "src/gpu/ganesh/GrSurfaceProxyView.h"
23 #include "src/gpu/ganesh/GrXferProcessor.h"
24 #include "src/gpu/ganesh/effects/GrTextureEffect.h"
25 #include "src/gpu/ganesh/gl/GrGLGpu.h"
26 #include "src/gpu/ganesh/gl/GrGLTexture.h"
27 #include "src/gpu/ganesh/gl/GrGLUtil.h"
28 #include "src/sksl/SkSLCompiler.h"
29
30 #include <array>
31 #include <functional>
32 #include <utility>
33
34 class GrTexture;
35
36 #define GL_CALL(X) GR_GL_CALL(fGpu->glInterface(), X)
37 #define GL_CALL_RET(R, X) GR_GL_CALL_RET(fGpu->glInterface(), R, X)
38
39 ///////////////////////////////////////////////////////////////////////////////////////////////////
40
Make(GrGLGpu * gpu,const GrGLSLBuiltinUniformHandles & builtinUniforms,GrGLuint programID,const UniformInfoArray & uniforms,const UniformInfoArray & textureSamplers,std::unique_ptr<GrGeometryProcessor::ProgramImpl> gpImpl,std::unique_ptr<GrXferProcessor::ProgramImpl> xpImpl,std::vector<std::unique_ptr<GrFragmentProcessor::ProgramImpl>> fpImpls,std::unique_ptr<Attribute[]> attributes,int vertexAttributeCnt,int instanceAttributeCnt,int vertexStride,int instanceStride)41 sk_sp<GrGLProgram> GrGLProgram::Make(
42 GrGLGpu* gpu,
43 const GrGLSLBuiltinUniformHandles& builtinUniforms,
44 GrGLuint programID,
45 const UniformInfoArray& uniforms,
46 const UniformInfoArray& textureSamplers,
47 std::unique_ptr<GrGeometryProcessor::ProgramImpl> gpImpl,
48 std::unique_ptr<GrXferProcessor::ProgramImpl> xpImpl,
49 std::vector<std::unique_ptr<GrFragmentProcessor::ProgramImpl>> fpImpls,
50 std::unique_ptr<Attribute[]> attributes,
51 int vertexAttributeCnt,
52 int instanceAttributeCnt,
53 int vertexStride,
54 int instanceStride) {
55 sk_sp<GrGLProgram> program(new GrGLProgram(gpu,
56 builtinUniforms,
57 programID,
58 uniforms,
59 textureSamplers,
60 std::move(gpImpl),
61 std::move(xpImpl),
62 std::move(fpImpls),
63 std::move(attributes),
64 vertexAttributeCnt,
65 instanceAttributeCnt,
66 vertexStride,
67 instanceStride));
68 // Assign texture units to sampler uniforms one time up front.
69 gpu->flushProgram(program);
70 program->fProgramDataManager.setSamplerUniforms(textureSamplers, 0);
71 return program;
72 }
73
GrGLProgram(GrGLGpu * gpu,const GrGLSLBuiltinUniformHandles & builtinUniforms,GrGLuint programID,const UniformInfoArray & uniforms,const UniformInfoArray & textureSamplers,std::unique_ptr<GrGeometryProcessor::ProgramImpl> gpImpl,std::unique_ptr<GrXferProcessor::ProgramImpl> xpImpl,std::vector<std::unique_ptr<GrFragmentProcessor::ProgramImpl>> fpImpls,std::unique_ptr<Attribute[]> attributes,int vertexAttributeCnt,int instanceAttributeCnt,int vertexStride,int instanceStride)74 GrGLProgram::GrGLProgram(GrGLGpu* gpu,
75 const GrGLSLBuiltinUniformHandles& builtinUniforms,
76 GrGLuint programID,
77 const UniformInfoArray& uniforms,
78 const UniformInfoArray& textureSamplers,
79 std::unique_ptr<GrGeometryProcessor::ProgramImpl> gpImpl,
80 std::unique_ptr<GrXferProcessor::ProgramImpl> xpImpl,
81 std::vector<std::unique_ptr<GrFragmentProcessor::ProgramImpl>> fpImpls,
82 std::unique_ptr<Attribute[]> attributes,
83 int vertexAttributeCnt,
84 int instanceAttributeCnt,
85 int vertexStride,
86 int instanceStride)
87 : fBuiltinUniformHandles(builtinUniforms)
88 , fProgramID(programID)
89 , fGPImpl(std::move(gpImpl))
90 , fXPImpl(std::move(xpImpl))
91 , fFPImpls(std::move(fpImpls))
92 , fAttributes(std::move(attributes))
93 , fVertexAttributeCnt(vertexAttributeCnt)
94 , fInstanceAttributeCnt(instanceAttributeCnt)
95 , fVertexStride(vertexStride)
96 , fInstanceStride(instanceStride)
97 , fGpu(gpu)
98 , fProgramDataManager(gpu, uniforms)
99 , fNumTextureSamplers(textureSamplers.count()) {}
100
~GrGLProgram()101 GrGLProgram::~GrGLProgram() {
102 if (fProgramID) {
103 GL_CALL(DeleteProgram(fProgramID));
104 }
105 }
106
abandon()107 void GrGLProgram::abandon() {
108 fProgramID = 0;
109 }
110
111 ///////////////////////////////////////////////////////////////////////////////
112
updateUniforms(const GrRenderTarget * renderTarget,const GrProgramInfo & programInfo)113 void GrGLProgram::updateUniforms(const GrRenderTarget* renderTarget,
114 const GrProgramInfo& programInfo) {
115 this->setRenderTargetState(renderTarget, programInfo.origin(), programInfo.geomProc());
116
117 // we set the uniforms for installed processors in a generic way, but subclasses of GLProgram
118 // determine how to set coord transforms
119
120 // We must bind to texture units in the same order in which we set the uniforms in
121 // GrGLProgramDataManager. That is, we bind textures for processors in this order:
122 // primProc, fragProcs, XP.
123 fGPImpl->setData(fProgramDataManager, *fGpu->caps()->shaderCaps(), programInfo.geomProc());
124
125 for (int i = 0; i < programInfo.pipeline().numFragmentProcessors(); ++i) {
126 const auto& fp = programInfo.pipeline().getFragmentProcessor(i);
127 fp.visitWithImpls([&](const GrFragmentProcessor& fp,
128 GrFragmentProcessor::ProgramImpl& impl) {
129 impl.setData(fProgramDataManager, fp);
130 }, *fFPImpls[i]);
131 }
132
133 programInfo.pipeline().setDstTextureUniforms(fProgramDataManager, &fBuiltinUniformHandles);
134 fXPImpl->setData(fProgramDataManager, programInfo.pipeline().getXferProcessor());
135 }
136
bindTextures(const GrGeometryProcessor & geomProc,const GrSurfaceProxy * const geomProcTextures[],const GrPipeline & pipeline)137 void GrGLProgram::bindTextures(const GrGeometryProcessor& geomProc,
138 const GrSurfaceProxy* const geomProcTextures[],
139 const GrPipeline& pipeline) {
140 // Bind textures from the geometry processor.
141 for (int i = 0; i < geomProc.numTextureSamplers(); ++i) {
142 SkASSERT(geomProcTextures[i]->asTextureProxy());
143 auto* overrideTexture = static_cast<GrGLTexture*>(geomProcTextures[i]->peekTexture());
144 fGpu->bindTexture(i, geomProc.textureSampler(i).samplerState(),
145 geomProc.textureSampler(i).swizzle(), overrideTexture);
146 }
147 int nextTexSamplerIdx = geomProc.numTextureSamplers();
148 // Bind texture from the destination proxy view.
149 GrTexture* dstTexture = pipeline.peekDstTexture();
150 if (dstTexture) {
151 fGpu->bindTexture(nextTexSamplerIdx++, GrSamplerState::Filter::kNearest,
152 pipeline.dstProxyView().swizzle(), static_cast<GrGLTexture*>(dstTexture));
153 }
154 // Bind textures from all of the fragment processors.
155 pipeline.visitTextureEffects([&](const GrTextureEffect& te) {
156 GrSamplerState samplerState = te.samplerState();
157 skgpu::Swizzle swizzle = te.view().swizzle();
158 auto* texture = static_cast<GrGLTexture*>(te.texture());
159 fGpu->bindTexture(nextTexSamplerIdx++, samplerState, swizzle, texture);
160 });
161
162 SkASSERT(nextTexSamplerIdx == fNumTextureSamplers);
163 }
164
setRenderTargetState(const GrRenderTarget * rt,GrSurfaceOrigin origin,const GrGeometryProcessor & geomProc)165 void GrGLProgram::setRenderTargetState(const GrRenderTarget* rt,
166 GrSurfaceOrigin origin,
167 const GrGeometryProcessor& geomProc) {
168 // Set RT adjustment and RT flip
169 SkISize dimensions = rt->dimensions();
170 if (fRenderTargetState.fRenderTargetOrigin != origin ||
171 fRenderTargetState.fRenderTargetSize != dimensions) {
172 fRenderTargetState.fRenderTargetSize = dimensions;
173 fRenderTargetState.fRenderTargetOrigin = origin;
174
175 // The client will mark a swap buffer as kBottomLeft when making a SkSurface because
176 // GL's framebuffer space has (0, 0) at the bottom left. In NDC (-1, -1) is also the
177 // bottom left. However, Skia's device coords has (0, 0) at the top left, so a flip is
178 // required when the origin is kBottomLeft.
179 bool flip = (origin == kBottomLeft_GrSurfaceOrigin);
180 std::array<float, 4> v = SkSL::Compiler::GetRTAdjustVector(dimensions, flip);
181 fProgramDataManager.set4fv(fBuiltinUniformHandles.fRTAdjustmentUni, 1, v.data());
182 if (fBuiltinUniformHandles.fRTFlipUni.isValid()) {
183 std::array<float, 2> d = SkSL::Compiler::GetRTFlipVector(dimensions.height(), flip);
184 fProgramDataManager.set2fv(fBuiltinUniformHandles.fRTFlipUni, 1, d.data());
185 }
186 }
187 }
188