1 /*
2 * Copyright (C) 2009 The Android Open Source Project
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
17 #include "rsContext.h"
18 #include "rsProgram.h"
19
20 #include <GLES2/gl2.h>
21 #include <GLES2/gl2ext.h>
22
23 using namespace android;
24 using namespace android::renderscript;
25
26
Program(Context * rsc)27 Program::Program(Context *rsc) : ObjectBase(rsc)
28 {
29 mAllocFile = __FILE__;
30 mAllocLine = __LINE__;
31 mDirty = true;
32 mShaderID = 0;
33 mAttribCount = 0;
34 mUniformCount = 0;
35
36 mInputElements = NULL;
37 mOutputElements = NULL;
38 mConstantTypes = NULL;
39 mInputCount = 0;
40 mOutputCount = 0;
41 mConstantCount = 0;
42 mIsValid = false;
43 }
44
Program(Context * rsc,const char * shaderText,uint32_t shaderLength,const uint32_t * params,uint32_t paramLength)45 Program::Program(Context *rsc, const char * shaderText, uint32_t shaderLength,
46 const uint32_t * params, uint32_t paramLength) :
47 ObjectBase(rsc)
48 {
49 mAllocFile = __FILE__;
50 mAllocLine = __LINE__;
51 mDirty = true;
52 mShaderID = 0;
53 mAttribCount = 0;
54 mUniformCount = 0;
55 mTextureCount = 0;
56
57 mInputCount = 0;
58 mOutputCount = 0;
59 mConstantCount = 0;
60
61 for (uint32_t ct=0; ct < paramLength; ct+=2) {
62 if (params[ct] == RS_PROGRAM_PARAM_INPUT) {
63 mInputCount++;
64 }
65 if (params[ct] == RS_PROGRAM_PARAM_OUTPUT) {
66 mOutputCount++;
67 }
68 if (params[ct] == RS_PROGRAM_PARAM_CONSTANT) {
69 mConstantCount++;
70 }
71 if (params[ct] == RS_PROGRAM_PARAM_TEXTURE_COUNT) {
72 mTextureCount = params[ct+1];
73 }
74 }
75
76 mInputElements = new ObjectBaseRef<Element>[mInputCount];
77 mOutputElements = new ObjectBaseRef<Element>[mOutputCount];
78 mConstantTypes = new ObjectBaseRef<Type>[mConstantCount];
79
80 uint32_t input = 0;
81 uint32_t output = 0;
82 uint32_t constant = 0;
83 for (uint32_t ct=0; ct < paramLength; ct+=2) {
84 if (params[ct] == RS_PROGRAM_PARAM_INPUT) {
85 mInputElements[input++].set(reinterpret_cast<Element *>(params[ct+1]));
86 }
87 if (params[ct] == RS_PROGRAM_PARAM_OUTPUT) {
88 mOutputElements[output++].set(reinterpret_cast<Element *>(params[ct+1]));
89 }
90 if (params[ct] == RS_PROGRAM_PARAM_CONSTANT) {
91 mConstantTypes[constant++].set(reinterpret_cast<Type *>(params[ct+1]));
92 }
93 }
94 mUserShader.setTo(shaderText, shaderLength);
95 }
96
~Program()97 Program::~Program()
98 {
99 for (uint32_t ct=0; ct < MAX_UNIFORMS; ct++) {
100 bindAllocation(NULL, ct);
101 }
102
103 delete[] mInputElements;
104 delete[] mOutputElements;
105 delete[] mConstantTypes;
106 mInputCount = 0;
107 mOutputCount = 0;
108 mConstantCount = 0;
109 }
110
111
bindAllocation(Allocation * alloc,uint32_t slot)112 void Program::bindAllocation(Allocation *alloc, uint32_t slot)
113 {
114 if (mConstants[slot].get() == alloc) {
115 return;
116 }
117 if (mConstants[slot].get()) {
118 mConstants[slot].get()->removeProgramToDirty(this);
119 }
120 mConstants[slot].set(alloc);
121 if (alloc) {
122 alloc->addProgramToDirty(this);
123 }
124 mDirty = true;
125 }
126
bindTexture(uint32_t slot,Allocation * a)127 void Program::bindTexture(uint32_t slot, Allocation *a)
128 {
129 if (slot >= MAX_TEXTURE) {
130 LOGE("Attempt to bind a texture to a slot > MAX_TEXTURE");
131 return;
132 }
133
134 //LOGE("bindtex %i %p", slot, a);
135 mTextures[slot].set(a);
136 mDirty = true;
137 }
138
bindSampler(uint32_t slot,Sampler * s)139 void Program::bindSampler(uint32_t slot, Sampler *s)
140 {
141 if (slot >= MAX_TEXTURE) {
142 LOGE("Attempt to bind a Sampler to a slot > MAX_TEXTURE");
143 return;
144 }
145
146 mSamplers[slot].set(s);
147 mDirty = true;
148 }
149
getGLSLInputString() const150 String8 Program::getGLSLInputString() const
151 {
152 String8 s;
153 for (uint32_t ct=0; ct < mInputCount; ct++) {
154 const Element *e = mInputElements[ct].get();
155 for (uint32_t field=0; field < e->getFieldCount(); field++) {
156 const Element *f = e->getField(field);
157
158 // Cannot be complex
159 rsAssert(!f->getFieldCount());
160 switch(f->getComponent().getVectorSize()) {
161 case 1: s.append("attribute float ATTRIB_"); break;
162 case 2: s.append("attribute vec2 ATTRIB_"); break;
163 case 3: s.append("attribute vec3 ATTRIB_"); break;
164 case 4: s.append("attribute vec4 ATTRIB_"); break;
165 default:
166 rsAssert(0);
167 }
168
169 s.append(e->getFieldName(field));
170 s.append(";\n");
171 }
172 }
173 return s;
174 }
175
getGLSLOutputString() const176 String8 Program::getGLSLOutputString() const
177 {
178 return String8();
179 }
180
getGLSLConstantString() const181 String8 Program::getGLSLConstantString() const
182 {
183 return String8();
184 }
185
186
createShader()187 void Program::createShader()
188 {
189 }
190
loadShader(Context * rsc,uint32_t type)191 bool Program::loadShader(Context *rsc, uint32_t type)
192 {
193 mShaderID = glCreateShader(type);
194 rsAssert(mShaderID);
195
196 if (rsc->props.mLogShaders) {
197 LOGV("Loading shader type %x, ID %i", type, mShaderID);
198 LOGV("%s", mShader.string());
199 }
200
201 if (mShaderID) {
202 const char * ss = mShader.string();
203 glShaderSource(mShaderID, 1, &ss, NULL);
204 glCompileShader(mShaderID);
205
206 GLint compiled = 0;
207 glGetShaderiv(mShaderID, GL_COMPILE_STATUS, &compiled);
208 if (!compiled) {
209 GLint infoLen = 0;
210 glGetShaderiv(mShaderID, GL_INFO_LOG_LENGTH, &infoLen);
211 if (infoLen) {
212 char* buf = (char*) malloc(infoLen);
213 if (buf) {
214 glGetShaderInfoLog(mShaderID, infoLen, NULL, buf);
215 LOGE("Could not compile shader \n%s\n", buf);
216 free(buf);
217 }
218 glDeleteShader(mShaderID);
219 mShaderID = 0;
220 rsc->setError(RS_ERROR_BAD_SHADER, "Error returned from GL driver loading shader text,");
221 return false;
222 }
223 }
224 }
225
226 if (rsc->props.mLogShaders) {
227 LOGV("--Shader load result %x ", glGetError());
228 }
229 mIsValid = true;
230 return true;
231 }
232
setShader(const char * txt,uint32_t len)233 void Program::setShader(const char *txt, uint32_t len)
234 {
235 mUserShader.setTo(txt, len);
236 }
237
238
239
240 namespace android {
241 namespace renderscript {
242
243
rsi_ProgramBindConstants(Context * rsc,RsProgram vp,uint32_t slot,RsAllocation constants)244 void rsi_ProgramBindConstants(Context *rsc, RsProgram vp, uint32_t slot, RsAllocation constants)
245 {
246 Program *p = static_cast<Program *>(vp);
247 p->bindAllocation(static_cast<Allocation *>(constants), slot);
248 }
249
rsi_ProgramBindTexture(Context * rsc,RsProgram vpf,uint32_t slot,RsAllocation a)250 void rsi_ProgramBindTexture(Context *rsc, RsProgram vpf, uint32_t slot, RsAllocation a)
251 {
252 Program *p = static_cast<Program *>(vpf);
253 p->bindTexture(slot, static_cast<Allocation *>(a));
254 }
255
rsi_ProgramBindSampler(Context * rsc,RsProgram vpf,uint32_t slot,RsSampler s)256 void rsi_ProgramBindSampler(Context *rsc, RsProgram vpf, uint32_t slot, RsSampler s)
257 {
258 Program *p = static_cast<Program *>(vpf);
259 p->bindSampler(slot, static_cast<Sampler *>(s));
260 }
261
262 }
263 }
264
265