blob: d9efe0827787d75f85d035ce61fbf8f8ae337517 [file] [log] [blame]
junov@google.comf93e7172011-03-31 21:26:24 +00001/*
epoger@google.comec3ed6a2011-07-28 14:26:00 +00002 * 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.
junov@google.comf93e7172011-03-31 21:26:24 +00006 */
7
Mike Kleinc0bd9f92019-04-23 12:05:21 -05008#include "src/gpu/gl/GrGLGpu.h"
epoger@google.comec3ed6a2011-07-28 14:26:00 +00009
Brian Osman172bb442019-09-06 10:16:02 -040010#include "include/gpu/GrContextOptions.h"
11#include "src/gpu/GrContextPriv.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050012#include "src/gpu/GrProcessor.h"
13#include "src/gpu/GrProgramDesc.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050014#include "src/gpu/gl/builders/GrGLProgramBuilder.h"
15#include "src/gpu/glsl/GrGLSLFragmentProcessor.h"
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +000016
bsalomon861e1032014-12-16 07:33:49 -080017struct GrGLGpu::ProgramCache::Entry {
Brian Osmaned58e002019-09-06 14:42:43 -040018 Entry(sk_sp<GrGLProgram> program)
19 : fProgram(std::move(program)) {}
20
21 Entry(const GrGLPrecompiledProgram& precompiledProgram)
22 : fPrecompiledProgram(precompiledProgram) {}
halcanary9d524f22016-03-29 09:03:52 -070023
Ethan Nicholas1b9924f2016-12-15 15:28:42 -050024 sk_sp<GrGLProgram> fProgram;
Brian Osmaned58e002019-09-06 14:42:43 -040025 GrGLPrecompiledProgram fPrecompiledProgram;
bsalomon@google.com2db3ded2013-05-22 14:34:04 +000026};
junov@google.comf93e7172011-03-31 21:26:24 +000027
bsalomon861e1032014-12-16 07:33:49 -080028GrGLGpu::ProgramCache::ProgramCache(GrGLGpu* gpu)
Brian Osman172bb442019-09-06 10:16:02 -040029 : fMap(gpu->getContext()->priv().options().fRuntimeProgramCacheSize)
Brian Osmane9d9a322019-09-03 13:59:36 -040030 , fGpu(gpu) {}
jvanverth@google.com94878772013-03-12 16:00:54 +000031
Brian Osmane9d9a322019-09-03 13:59:36 -040032GrGLGpu::ProgramCache::~ProgramCache() {}
junov@google.comf93e7172011-03-31 21:26:24 +000033
egdaniel22281c12016-03-23 13:49:40 -070034void GrGLGpu::ProgramCache::abandon() {
Brian Osman0b8bb882019-04-12 11:47:19 -040035 fMap.foreach([](std::unique_ptr<Entry>* e) {
Brian Osmaned58e002019-09-06 14:42:43 -040036 if ((*e)->fProgram) {
37 (*e)->fProgram->abandon();
38 }
Brian Osman0b8bb882019-04-12 11:47:19 -040039 });
40
41 this->reset();
42}
43
44void GrGLGpu::ProgramCache::reset() {
Robert Phillips752e08b2018-06-22 09:48:38 -040045 fMap.reset();
joshualitt8fd844f2015-12-02 13:36:47 -080046}
47
Greg Daniel7a82edf2018-12-04 10:54:34 -050048GrGLProgram* GrGLGpu::ProgramCache::refProgram(GrGLGpu* gpu,
Robert Phillipsd0fe8752019-01-31 14:13:59 -050049 GrRenderTarget* renderTarget,
50 GrSurfaceOrigin origin,
bsalomon2eda5b32016-09-21 10:53:24 -070051 const GrPrimitiveProcessor& primProc,
Greg Daniel9a51a862018-11-30 10:18:14 -050052 const GrTextureProxy* const primProcProxies[],
Brian Salomonff168d92018-06-23 15:17:27 -040053 const GrPipeline& pipeline,
bsalomon2eda5b32016-09-21 10:53:24 -070054 bool isPoints) {
egdaniel0e1853c2016-03-17 11:35:45 -070055 // Get GrGLProgramDesc
egdaniel5d8f69f2016-09-07 07:24:12 -070056 GrProgramDesc desc;
Chris Daltond7291ba2019-03-07 14:17:03 -070057 if (!GrProgramDesc::Build(&desc, renderTarget, primProc, isPoints, pipeline, gpu)) {
egdaniel0e1853c2016-03-17 11:35:45 -070058 GrCapsDebugf(gpu->caps(), "Failed to gl program descriptor!\n");
59 return nullptr;
60 }
Brian Osmane11dfd32019-07-23 10:29:41 -040061 // If we knew the shader won't depend on origin, we could skip this (and use the same program
62 // for both origins). Instrumenting all fragment processors would be difficult and error prone.
63 desc.setSurfaceOriginKey(GrGLSLFragmentShaderBuilder::KeyForSurfaceOrigin(origin));
64
Ethan Nicholas1b9924f2016-12-15 15:28:42 -050065 std::unique_ptr<Entry>* entry = fMap.find(desc);
Brian Osmaned58e002019-09-06 14:42:43 -040066 if (entry && !(*entry)->fProgram) {
67 // We've pre-compiled the GL program, but don't have the GrGLProgram scaffolding
68 const GrGLPrecompiledProgram* precompiledProgram = &((*entry)->fPrecompiledProgram);
69 SkASSERT(precompiledProgram->fProgramID != 0);
70 GrGLProgram* program = GrGLProgramBuilder::CreateProgram(renderTarget, origin,
71 primProc, primProcProxies,
72 pipeline, &desc, fGpu,
73 precompiledProgram);
74 if (nullptr == program) {
75 // Should we purge the program ID from the cache at this point?
76 SkDEBUGFAIL("Couldn't create program from precompiled program");
77 return nullptr;
78 }
79 (*entry)->fProgram.reset(program);
80 } else if (!entry) {
bsalomon@google.com2db3ded2013-05-22 14:34:04 +000081 // We have a cache miss
Robert Phillipsd0fe8752019-01-31 14:13:59 -050082 GrGLProgram* program = GrGLProgramBuilder::CreateProgram(renderTarget, origin,
83 primProc, primProcProxies,
Greg Daniel9a51a862018-11-30 10:18:14 -050084 pipeline, &desc, fGpu);
halcanary96fcdcc2015-08-27 07:41:13 -070085 if (nullptr == program) {
86 return nullptr;
bsalomon@google.comc1d2a582012-06-01 15:08:19 +000087 }
Ethan Nicholas1b9924f2016-12-15 15:28:42 -050088 entry = fMap.insert(desc, std::unique_ptr<Entry>(new Entry(sk_sp<GrGLProgram>(program))));
junov@google.comf93e7172011-03-31 21:26:24 +000089 }
bsalomon@google.comc1d2a582012-06-01 15:08:19 +000090
Ethan Nicholas1b9924f2016-12-15 15:28:42 -050091 return SkRef((*entry)->fProgram.get());
bsalomon@google.comc1d2a582012-06-01 15:08:19 +000092}
Brian Osmaned58e002019-09-06 14:42:43 -040093
94bool GrGLGpu::ProgramCache::precompileShader(const SkData& key, const SkData& data) {
95 GrProgramDesc desc;
96 if (!GrProgramDesc::BuildFromData(&desc, key.data(), key.size())) {
97 return false;
98 }
99
100 std::unique_ptr<Entry>* entry = fMap.find(desc);
101 if (entry) {
102 // We've already seen/compiled this shader
103 return true;
104 }
105
106 GrGLPrecompiledProgram precompiledProgram;
107 if (!GrGLProgramBuilder::PrecompileProgram(&precompiledProgram, fGpu, data)) {
108 return false;
109 }
110
111 fMap.insert(desc, std::unique_ptr<Entry>(new Entry(precompiledProgram)));
112 return true;
113}