Jason Sams | c460e55 | 2009-11-25 13:22:07 -0800 | [diff] [blame] | 1 | /* |
Jason Sams | 3522f40 | 2012-03-23 11:47:26 -0700 | [diff] [blame] | 2 | * Copyright (C) 2011-2012 The Android Open Source Project |
Jason Sams | c460e55 | 2009-11-25 13:22:07 -0800 | [diff] [blame] | 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
Alex Sakhartchouk | a04e30d | 2011-04-29 16:49:08 -0700 | [diff] [blame] | 17 | #include <rs_hal.h> |
| 18 | #include <rsContext.h> |
| 19 | |
| 20 | #include "rsdShader.h" |
| 21 | #include "rsdShaderCache.h" |
Alex Sakhartchouk | c19ff01 | 2011-05-06 14:59:45 -0700 | [diff] [blame] | 22 | #include "rsdGL.h" |
Alex Sakhartchouk | a04e30d | 2011-04-29 16:49:08 -0700 | [diff] [blame] | 23 | |
Jason Sams | c460e55 | 2009-11-25 13:22:07 -0800 | [diff] [blame] | 24 | #include <GLES/gl.h> |
| 25 | #include <GLES2/gl2.h> |
| 26 | |
| 27 | using namespace android; |
| 28 | using namespace android::renderscript; |
| 29 | |
| 30 | |
Alex Sakhartchouk | a04e30d | 2011-04-29 16:49:08 -0700 | [diff] [blame] | 31 | RsdShaderCache::RsdShaderCache() { |
Chris Wailes | 93d6bc8 | 2014-07-28 16:54:38 -0700 | [diff] [blame] | 32 | mEntries.reserve(16); |
Alex Sakhartchouk | a04e30d | 2011-04-29 16:49:08 -0700 | [diff] [blame] | 33 | mVertexDirty = true; |
| 34 | mFragmentDirty = true; |
Jason Sams | c460e55 | 2009-11-25 13:22:07 -0800 | [diff] [blame] | 35 | } |
| 36 | |
Alex Sakhartchouk | a04e30d | 2011-04-29 16:49:08 -0700 | [diff] [blame] | 37 | RsdShaderCache::~RsdShaderCache() { |
Jason Sams | 2cbfc4c | 2011-01-05 03:37:48 -0800 | [diff] [blame] | 38 | cleanupAll(); |
Jason Sams | c460e55 | 2009-11-25 13:22:07 -0800 | [diff] [blame] | 39 | } |
| 40 | |
Chris Wailes | 6847e73 | 2014-08-11 17:30:51 -0700 | [diff] [blame] | 41 | void RsdShaderCache::updateUniformArrayData(const Context *rsc, |
| 42 | RsdShader *prog, |
| 43 | uint32_t linkedID, |
| 44 | UniformData *data, |
| 45 | const char* logTag, |
| 46 | UniformQueryData **uniformList, |
| 47 | uint32_t uniListSize) { |
Alex Sakhartchouk | 54929cc | 2010-11-08 15:10:52 -0800 | [diff] [blame] | 48 | |
| 49 | for (uint32_t ct=0; ct < prog->getUniformCount(); ct++) { |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 50 | if (data[ct].slot >= 0 && data[ct].arraySize > 1) { |
Alex Sakhartchouk | 54929cc | 2010-11-08 15:10:52 -0800 | [diff] [blame] | 51 | //Iterate over the list of active GL uniforms and find highest array index |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 52 | for (uint32_t ui = 0; ui < uniListSize; ui ++) { |
| 53 | if (prog->getUniformName(ct) == uniformList[ui]->name) { |
Alex Sakhartchouk | 54929cc | 2010-11-08 15:10:52 -0800 | [diff] [blame] | 54 | data[ct].arraySize = (uint32_t)uniformList[ui]->arraySize; |
| 55 | break; |
| 56 | } |
| 57 | } |
| 58 | } |
| 59 | |
| 60 | if (rsc->props.mLogShaders) { |
Steve Block | 6598201 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 61 | ALOGV("%s U, %s = %d, arraySize = %d\n", logTag, |
Chris Wailes | 6847e73 | 2014-08-11 17:30:51 -0700 | [diff] [blame] | 62 | prog->getUniformName(ct).c_str(), data[ct].slot, |
| 63 | data[ct].arraySize); |
Alex Sakhartchouk | 54929cc | 2010-11-08 15:10:52 -0800 | [diff] [blame] | 64 | } |
| 65 | } |
| 66 | } |
| 67 | |
Chris Wailes | 6847e73 | 2014-08-11 17:30:51 -0700 | [diff] [blame] | 68 | void RsdShaderCache::populateUniformData(RsdShader *prog, uint32_t linkedID, |
| 69 | UniformData *data) { |
Alex Sakhartchouk | 54929cc | 2010-11-08 15:10:52 -0800 | [diff] [blame] | 70 | for (uint32_t ct=0; ct < prog->getUniformCount(); ct++) { |
Chris Wailes | 6847e73 | 2014-08-11 17:30:51 -0700 | [diff] [blame] | 71 | data[ct].slot = glGetUniformLocation(linkedID, |
| 72 | prog->getUniformName(ct).c_str()); |
Alex Sakhartchouk | 54929cc | 2010-11-08 15:10:52 -0800 | [diff] [blame] | 73 | data[ct].arraySize = prog->getUniformArraySize(ct); |
| 74 | } |
| 75 | } |
| 76 | |
Alex Sakhartchouk | a04e30d | 2011-04-29 16:49:08 -0700 | [diff] [blame] | 77 | bool RsdShaderCache::hasArrayUniforms(RsdShader *vtx, RsdShader *frag) { |
Alex Sakhartchouk | 54929cc | 2010-11-08 15:10:52 -0800 | [diff] [blame] | 78 | UniformData *data = mCurrent->vtxUniforms; |
| 79 | for (uint32_t ct=0; ct < vtx->getUniformCount(); ct++) { |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 80 | if (data[ct].slot >= 0 && data[ct].arraySize > 1) { |
Alex Sakhartchouk | 54929cc | 2010-11-08 15:10:52 -0800 | [diff] [blame] | 81 | return true; |
| 82 | } |
| 83 | } |
| 84 | data = mCurrent->fragUniforms; |
| 85 | for (uint32_t ct=0; ct < frag->getUniformCount(); ct++) { |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 86 | if (data[ct].slot >= 0 && data[ct].arraySize > 1) { |
Alex Sakhartchouk | 54929cc | 2010-11-08 15:10:52 -0800 | [diff] [blame] | 87 | return true; |
| 88 | } |
| 89 | } |
| 90 | return false; |
| 91 | } |
| 92 | |
Alex Sakhartchouk | a04e30d | 2011-04-29 16:49:08 -0700 | [diff] [blame] | 93 | bool RsdShaderCache::setup(const Context *rsc) { |
| 94 | if (!mVertexDirty && !mFragmentDirty) { |
| 95 | return true; |
| 96 | } |
| 97 | |
| 98 | if (!link(rsc)) { |
| 99 | return false; |
| 100 | } |
| 101 | |
| 102 | if (mFragmentDirty) { |
| 103 | mFragment->setup(rsc, this); |
| 104 | mFragmentDirty = false; |
| 105 | } |
| 106 | if (mVertexDirty) { |
| 107 | mVertex->setup(rsc, this); |
| 108 | mVertexDirty = false; |
| 109 | } |
| 110 | |
| 111 | return true; |
| 112 | } |
| 113 | |
| 114 | bool RsdShaderCache::link(const Context *rsc) { |
| 115 | |
| 116 | RsdShader *vtx = mVertex; |
| 117 | RsdShader *frag = mFragment; |
Alex Sakhartchouk | 6d6e114 | 2012-03-26 13:52:24 -0700 | [diff] [blame] | 118 | |
| 119 | uint32_t vID = vtx->getStateBasedShaderID(rsc); |
| 120 | uint32_t fID = frag->getStateBasedShaderID(rsc); |
Alex Sakhartchouk | 886f11a | 2010-09-29 09:49:13 -0700 | [diff] [blame] | 121 | |
| 122 | // Don't try to cache if shaders failed to load |
Alex Sakhartchouk | 6d6e114 | 2012-03-26 13:52:24 -0700 | [diff] [blame] | 123 | if (!vID || !fID) { |
Alex Sakhartchouk | 886f11a | 2010-09-29 09:49:13 -0700 | [diff] [blame] | 124 | return false; |
| 125 | } |
Alex Sakhartchouk | 889fe50 | 2010-10-01 10:54:06 -0700 | [diff] [blame] | 126 | uint32_t entryCount = mEntries.size(); |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 127 | for (uint32_t ct = 0; ct < entryCount; ct ++) { |
Alex Sakhartchouk | 6d6e114 | 2012-03-26 13:52:24 -0700 | [diff] [blame] | 128 | if ((mEntries[ct]->vtx == vID) && (mEntries[ct]->frag == fID)) { |
Jason Sams | c460e55 | 2009-11-25 13:22:07 -0800 | [diff] [blame] | 129 | |
Steve Block | 6598201 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 130 | //ALOGV("SC using program %i", mEntries[ct]->program); |
Alex Sakhartchouk | 889fe50 | 2010-10-01 10:54:06 -0700 | [diff] [blame] | 131 | glUseProgram(mEntries[ct]->program); |
| 132 | mCurrent = mEntries[ct]; |
Steve Block | 6598201 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 133 | //ALOGV("RsdShaderCache hit, using %i", ct); |
Alex Sakhartchouk | c19ff01 | 2011-05-06 14:59:45 -0700 | [diff] [blame] | 134 | rsdGLCheckError(rsc, "RsdShaderCache::link (hit)"); |
Jason Sams | c460e55 | 2009-11-25 13:22:07 -0800 | [diff] [blame] | 135 | return true; |
| 136 | } |
| 137 | } |
Jason Sams | c460e55 | 2009-11-25 13:22:07 -0800 | [diff] [blame] | 138 | |
Alex Sakhartchouk | 54929cc | 2010-11-08 15:10:52 -0800 | [diff] [blame] | 139 | ProgramEntry *e = new ProgramEntry(vtx->getAttribCount(), |
| 140 | vtx->getUniformCount(), |
| 141 | frag->getUniformCount()); |
Chris Wailes | 93d6bc8 | 2014-07-28 16:54:38 -0700 | [diff] [blame] | 142 | mEntries.push_back(e); |
Jason Sams | c460e55 | 2009-11-25 13:22:07 -0800 | [diff] [blame] | 143 | mCurrent = e; |
Alex Sakhartchouk | 6d6e114 | 2012-03-26 13:52:24 -0700 | [diff] [blame] | 144 | e->vtx = vID; |
| 145 | e->frag = fID; |
Jason Sams | c460e55 | 2009-11-25 13:22:07 -0800 | [diff] [blame] | 146 | e->program = glCreateProgram(); |
Alex Sakhartchouk | 889fe50 | 2010-10-01 10:54:06 -0700 | [diff] [blame] | 147 | if (e->program) { |
Jason Sams | c460e55 | 2009-11-25 13:22:07 -0800 | [diff] [blame] | 148 | GLuint pgm = e->program; |
Alex Sakhartchouk | 6d6e114 | 2012-03-26 13:52:24 -0700 | [diff] [blame] | 149 | glAttachShader(pgm, vID); |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 150 | //ALOGE("e1 %x", glGetError()); |
Alex Sakhartchouk | 6d6e114 | 2012-03-26 13:52:24 -0700 | [diff] [blame] | 151 | glAttachShader(pgm, fID); |
Jason Sams | c460e55 | 2009-11-25 13:22:07 -0800 | [diff] [blame] | 152 | |
Alex Sakhartchouk | a04e30d | 2011-04-29 16:49:08 -0700 | [diff] [blame] | 153 | glBindAttribLocation(pgm, 0, "ATTRIB_position"); |
| 154 | glBindAttribLocation(pgm, 1, "ATTRIB_color"); |
| 155 | glBindAttribLocation(pgm, 2, "ATTRIB_normal"); |
| 156 | glBindAttribLocation(pgm, 3, "ATTRIB_texture0"); |
Jason Sams | c460e55 | 2009-11-25 13:22:07 -0800 | [diff] [blame] | 157 | |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 158 | //ALOGE("e2 %x", glGetError()); |
Jason Sams | c460e55 | 2009-11-25 13:22:07 -0800 | [diff] [blame] | 159 | glLinkProgram(pgm); |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 160 | //ALOGE("e3 %x", glGetError()); |
Jason Sams | c460e55 | 2009-11-25 13:22:07 -0800 | [diff] [blame] | 161 | GLint linkStatus = GL_FALSE; |
| 162 | glGetProgramiv(pgm, GL_LINK_STATUS, &linkStatus); |
| 163 | if (linkStatus != GL_TRUE) { |
| 164 | GLint bufLength = 0; |
| 165 | glGetProgramiv(pgm, GL_INFO_LOG_LENGTH, &bufLength); |
| 166 | if (bufLength) { |
| 167 | char* buf = (char*) malloc(bufLength); |
| 168 | if (buf) { |
Chris Wailes | 44bef6f | 2014-08-12 13:51:10 -0700 | [diff] [blame^] | 169 | glGetProgramInfoLog(pgm, bufLength, nullptr, buf); |
Alex Sakhartchouk | 7510992 | 2012-02-07 18:06:13 -0800 | [diff] [blame] | 170 | rsc->setError(RS_ERROR_FATAL_PROGRAM_LINK, buf); |
Jason Sams | c460e55 | 2009-11-25 13:22:07 -0800 | [diff] [blame] | 171 | free(buf); |
| 172 | } |
| 173 | } |
| 174 | glDeleteProgram(pgm); |
Jason Sams | a2cf755 | 2010-03-03 13:03:18 -0800 | [diff] [blame] | 175 | return false; |
Jason Sams | c460e55 | 2009-11-25 13:22:07 -0800 | [diff] [blame] | 176 | } |
Alex Sakhartchouk | 886f11a | 2010-09-29 09:49:13 -0700 | [diff] [blame] | 177 | |
| 178 | for (uint32_t ct=0; ct < e->vtxAttrCount; ct++) { |
Chris Wailes | 6847e73 | 2014-08-11 17:30:51 -0700 | [diff] [blame] | 179 | e->vtxAttrs[ct].slot = |
| 180 | glGetAttribLocation(pgm, vtx->getAttribName(ct).c_str()); |
| 181 | e->vtxAttrs[ct].name = vtx->getAttribName(ct).c_str(); |
Alex Sakhartchouk | 886f11a | 2010-09-29 09:49:13 -0700 | [diff] [blame] | 182 | if (rsc->props.mLogShaders) { |
Chris Wailes | 6847e73 | 2014-08-11 17:30:51 -0700 | [diff] [blame] | 183 | ALOGV("vtx A %i, %s = %d\n", ct, |
| 184 | vtx->getAttribName(ct).c_str(), e->vtxAttrs[ct].slot); |
Jason Sams | cd50653 | 2009-12-15 19:10:11 -0800 | [diff] [blame] | 185 | } |
Jason Sams | c460e55 | 2009-11-25 13:22:07 -0800 | [diff] [blame] | 186 | } |
Alex Sakhartchouk | 886f11a | 2010-09-29 09:49:13 -0700 | [diff] [blame] | 187 | |
Alex Sakhartchouk | 54929cc | 2010-11-08 15:10:52 -0800 | [diff] [blame] | 188 | populateUniformData(vtx, pgm, e->vtxUniforms); |
| 189 | populateUniformData(frag, pgm, e->fragUniforms); |
| 190 | |
| 191 | // Only populate this list if we have arrays in our uniforms |
Chris Wailes | 44bef6f | 2014-08-12 13:51:10 -0700 | [diff] [blame^] | 192 | UniformQueryData **uniformList = nullptr; |
Alex Sakhartchouk | 54929cc | 2010-11-08 15:10:52 -0800 | [diff] [blame] | 193 | GLint numUniforms = 0; |
| 194 | bool hasArrays = hasArrayUniforms(vtx, frag); |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 195 | if (hasArrays) { |
Alex Sakhartchouk | 54929cc | 2010-11-08 15:10:52 -0800 | [diff] [blame] | 196 | // Get the number of active uniforms and the length of the longest name |
| 197 | glGetProgramiv(pgm, GL_ACTIVE_UNIFORMS, &numUniforms); |
| 198 | GLint maxNameLength = 0; |
| 199 | glGetProgramiv(pgm, GL_ACTIVE_UNIFORM_MAX_LENGTH, &maxNameLength); |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 200 | if (numUniforms > 0 && maxNameLength > 0) { |
Alex Sakhartchouk | 54929cc | 2010-11-08 15:10:52 -0800 | [diff] [blame] | 201 | uniformList = new UniformQueryData*[numUniforms]; |
| 202 | // Iterate over all the uniforms and build the list we |
| 203 | // can later use to match our uniforms to |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 204 | for (uint32_t ct = 0; ct < (uint32_t)numUniforms; ct++) { |
Alex Sakhartchouk | 54929cc | 2010-11-08 15:10:52 -0800 | [diff] [blame] | 205 | uniformList[ct] = new UniformQueryData(maxNameLength); |
| 206 | glGetActiveUniform(pgm, ct, maxNameLength, &uniformList[ct]->writtenLength, |
| 207 | &uniformList[ct]->arraySize, &uniformList[ct]->type, |
| 208 | uniformList[ct]->name); |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 209 | //ALOGE("GL UNI idx=%u, arraySize=%u, name=%s", ct, |
Alex Sakhartchouk | 54929cc | 2010-11-08 15:10:52 -0800 | [diff] [blame] | 210 | // uniformList[ct]->arraySize, uniformList[ct]->name); |
| 211 | } |
Jason Sams | cd50653 | 2009-12-15 19:10:11 -0800 | [diff] [blame] | 212 | } |
Jason Sams | c460e55 | 2009-11-25 13:22:07 -0800 | [diff] [blame] | 213 | } |
Alex Sakhartchouk | 54929cc | 2010-11-08 15:10:52 -0800 | [diff] [blame] | 214 | |
| 215 | // We now know the highest index of all of the array uniforms |
| 216 | // and we need to update our cache to reflect that |
| 217 | // we may have declared [n], but only m < n elements are used |
| 218 | updateUniformArrayData(rsc, vtx, pgm, e->vtxUniforms, "vtx", |
| 219 | uniformList, (uint32_t)numUniforms); |
| 220 | updateUniformArrayData(rsc, frag, pgm, e->fragUniforms, "frag", |
| 221 | uniformList, (uint32_t)numUniforms); |
| 222 | |
| 223 | // Clean up the uniform data from GL |
Chris Wailes | 44bef6f | 2014-08-12 13:51:10 -0700 | [diff] [blame^] | 224 | if (uniformList != nullptr) { |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 225 | for (uint32_t ct = 0; ct < (uint32_t)numUniforms; ct++) { |
Alex Sakhartchouk | 54929cc | 2010-11-08 15:10:52 -0800 | [diff] [blame] | 226 | delete uniformList[ct]; |
Jason Sams | cd50653 | 2009-12-15 19:10:11 -0800 | [diff] [blame] | 227 | } |
Alex Sakhartchouk | 54929cc | 2010-11-08 15:10:52 -0800 | [diff] [blame] | 228 | delete[] uniformList; |
Chris Wailes | 44bef6f | 2014-08-12 13:51:10 -0700 | [diff] [blame^] | 229 | uniformList = nullptr; |
Jason Sams | c460e55 | 2009-11-25 13:22:07 -0800 | [diff] [blame] | 230 | } |
| 231 | } |
| 232 | |
Steve Block | 6598201 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 233 | //ALOGV("SC made program %i", e->program); |
Jason Sams | c460e55 | 2009-11-25 13:22:07 -0800 | [diff] [blame] | 234 | glUseProgram(e->program); |
Alex Sakhartchouk | c19ff01 | 2011-05-06 14:59:45 -0700 | [diff] [blame] | 235 | rsdGLCheckError(rsc, "RsdShaderCache::link (miss)"); |
Alex Sakhartchouk | a04e30d | 2011-04-29 16:49:08 -0700 | [diff] [blame] | 236 | |
Jason Sams | c460e55 | 2009-11-25 13:22:07 -0800 | [diff] [blame] | 237 | return true; |
| 238 | } |
| 239 | |
Chris Wailes | 93d6bc8 | 2014-07-28 16:54:38 -0700 | [diff] [blame] | 240 | int32_t RsdShaderCache::vtxAttribSlot(const std::string &attrName) const { |
Alex Sakhartchouk | 886f11a | 2010-09-29 09:49:13 -0700 | [diff] [blame] | 241 | for (uint32_t ct=0; ct < mCurrent->vtxAttrCount; ct++) { |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 242 | if (attrName == mCurrent->vtxAttrs[ct].name) { |
Alex Sakhartchouk | 54929cc | 2010-11-08 15:10:52 -0800 | [diff] [blame] | 243 | return mCurrent->vtxAttrs[ct].slot; |
Alex Sakhartchouk | 886f11a | 2010-09-29 09:49:13 -0700 | [diff] [blame] | 244 | } |
| 245 | } |
| 246 | return -1; |
| 247 | } |
| 248 | |
Alex Sakhartchouk | 6d6e114 | 2012-03-26 13:52:24 -0700 | [diff] [blame] | 249 | void RsdShaderCache::cleanupVertex(RsdShader *s) { |
Alex Sakhartchouk | 6d6e114 | 2012-03-26 13:52:24 -0700 | [diff] [blame] | 250 | uint32_t numShaderIDs = s->getStateBasedIDCount(); |
| 251 | for (uint32_t sId = 0; sId < numShaderIDs; sId ++) { |
| 252 | uint32_t id = s->getStateBasedID(sId); |
Alex Sakhartchouk | 889fe50 | 2010-10-01 10:54:06 -0700 | [diff] [blame] | 253 | |
Chris Wailes | 93d6bc8 | 2014-07-28 16:54:38 -0700 | [diff] [blame] | 254 | for (auto entry = mEntries.begin(); entry != mEntries.end();) { |
| 255 | if ((*entry)->vtx == id) { |
| 256 | glDeleteProgram((*entry)->program); |
| 257 | |
| 258 | delete *entry; |
| 259 | entry = mEntries.erase(entry); |
| 260 | } else { |
| 261 | entry++; |
Alex Sakhartchouk | 6d6e114 | 2012-03-26 13:52:24 -0700 | [diff] [blame] | 262 | } |
Alex Sakhartchouk | 889fe50 | 2010-10-01 10:54:06 -0700 | [diff] [blame] | 263 | } |
| 264 | } |
Jason Sams | c460e55 | 2009-11-25 13:22:07 -0800 | [diff] [blame] | 265 | } |
| 266 | |
Alex Sakhartchouk | 6d6e114 | 2012-03-26 13:52:24 -0700 | [diff] [blame] | 267 | void RsdShaderCache::cleanupFragment(RsdShader *s) { |
Alex Sakhartchouk | 6d6e114 | 2012-03-26 13:52:24 -0700 | [diff] [blame] | 268 | uint32_t numShaderIDs = s->getStateBasedIDCount(); |
| 269 | for (uint32_t sId = 0; sId < numShaderIDs; sId ++) { |
| 270 | uint32_t id = s->getStateBasedID(sId); |
Alex Sakhartchouk | 889fe50 | 2010-10-01 10:54:06 -0700 | [diff] [blame] | 271 | |
Chris Wailes | 93d6bc8 | 2014-07-28 16:54:38 -0700 | [diff] [blame] | 272 | for (auto entry = mEntries.begin(); entry != mEntries.end();) { |
| 273 | if ((*entry)->frag == id) { |
| 274 | glDeleteProgram((*entry)->program); |
| 275 | |
| 276 | delete *entry; |
| 277 | entry = mEntries.erase(entry); |
| 278 | } else { |
| 279 | entry++; |
Alex Sakhartchouk | 6d6e114 | 2012-03-26 13:52:24 -0700 | [diff] [blame] | 280 | } |
Alex Sakhartchouk | 889fe50 | 2010-10-01 10:54:06 -0700 | [diff] [blame] | 281 | } |
| 282 | } |
Jason Sams | c460e55 | 2009-11-25 13:22:07 -0800 | [diff] [blame] | 283 | } |
| 284 | |
Alex Sakhartchouk | a04e30d | 2011-04-29 16:49:08 -0700 | [diff] [blame] | 285 | void RsdShaderCache::cleanupAll() { |
Chris Wailes | 93d6bc8 | 2014-07-28 16:54:38 -0700 | [diff] [blame] | 286 | for (auto entry : mEntries) { |
| 287 | glDeleteProgram(entry->program); |
| 288 | delete entry; |
Jason Sams | 2cbfc4c | 2011-01-05 03:37:48 -0800 | [diff] [blame] | 289 | } |
| 290 | mEntries.clear(); |
Jason Sams | c460e55 | 2009-11-25 13:22:07 -0800 | [diff] [blame] | 291 | } |