1 /*
2 * Copyright (C) 2011 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 "rsProgramVertex.h"
19 #include "rsMatrix4x4.h"
20
21 using namespace android;
22 using namespace android::renderscript;
23
24
ProgramVertex(Context * rsc,const char * shaderText,size_t shaderLength,const char ** textureNames,size_t textureNamesCount,const size_t * textureNamesLength,const uint32_t * params,size_t paramLength)25 ProgramVertex::ProgramVertex(Context *rsc, const char * shaderText, size_t shaderLength,
26 const char** textureNames, size_t textureNamesCount, const size_t *textureNamesLength,
27
28 const uint32_t * params, size_t paramLength)
29 : Program(rsc, shaderText, shaderLength, params, paramLength) {
30 mRSC->mHal.funcs.vertex.init(mRSC, this, mUserShader.string(), mUserShader.length(),
31 textureNames, textureNamesCount, textureNamesLength);
32 }
33
~ProgramVertex()34 ProgramVertex::~ProgramVertex() {
35 mRSC->mHal.funcs.vertex.destroy(mRSC, this);
36 }
37
setup(Context * rsc,ProgramVertexState * state)38 void ProgramVertex::setup(Context *rsc, ProgramVertexState *state) {
39 if ((state->mLast.get() == this) && !mDirty) {
40 return;
41 }
42
43 if (!isUserProgram()) {
44 if (mHal.state.constants[0] == NULL) {
45 rsc->setError(RS_ERROR_FATAL_UNKNOWN,
46 "Unable to set fixed function emulation matrices because allocation is missing");
47 return;
48 }
49 float *f = static_cast<float *>(mHal.state.constants[0]->getPtr());
50 Matrix4x4 mvp;
51 mvp.load(&f[RS_PROGRAM_VERTEX_PROJECTION_OFFSET]);
52 Matrix4x4 t;
53 t.load(&f[RS_PROGRAM_VERTEX_MODELVIEW_OFFSET]);
54 mvp.multiply(&t);
55 for (uint32_t i = 0; i < 16; i ++) {
56 f[RS_PROGRAM_VERTEX_MVP_OFFSET + i] = mvp.m[i];
57 }
58 }
59
60 state->mLast.set(this);
61
62 rsc->mHal.funcs.vertex.setActive(rsc, this);
63 }
64
setProjectionMatrix(Context * rsc,const rsc_Matrix * m) const65 void ProgramVertex::setProjectionMatrix(Context *rsc, const rsc_Matrix *m) const {
66 if (isUserProgram()) {
67 rsc->setError(RS_ERROR_FATAL_UNKNOWN,
68 "Attempting to set fixed function emulation matrix projection on user program");
69 return;
70 }
71 if (mHal.state.constants[0] == NULL) {
72 rsc->setError(RS_ERROR_FATAL_UNKNOWN,
73 "Unable to set fixed function emulation matrix projection because allocation is missing");
74 return;
75 }
76 float *f = static_cast<float *>(mHal.state.constants[0]->getPtr());
77 memcpy(&f[RS_PROGRAM_VERTEX_PROJECTION_OFFSET], m, sizeof(rsc_Matrix));
78 mDirty = true;
79 }
80
setModelviewMatrix(Context * rsc,const rsc_Matrix * m) const81 void ProgramVertex::setModelviewMatrix(Context *rsc, const rsc_Matrix *m) const {
82 if (isUserProgram()) {
83 rsc->setError(RS_ERROR_FATAL_UNKNOWN,
84 "Attempting to set fixed function emulation matrix modelview on user program");
85 return;
86 }
87 if (mHal.state.constants[0] == NULL) {
88 rsc->setError(RS_ERROR_FATAL_UNKNOWN,
89 "Unable to set fixed function emulation matrix modelview because allocation is missing");
90 return;
91 }
92 float *f = static_cast<float *>(mHal.state.constants[0]->getPtr());
93 memcpy(&f[RS_PROGRAM_VERTEX_MODELVIEW_OFFSET], m, sizeof(rsc_Matrix));
94 mDirty = true;
95 }
96
setTextureMatrix(Context * rsc,const rsc_Matrix * m) const97 void ProgramVertex::setTextureMatrix(Context *rsc, const rsc_Matrix *m) const {
98 if (isUserProgram()) {
99 rsc->setError(RS_ERROR_FATAL_UNKNOWN,
100 "Attempting to set fixed function emulation matrix texture on user program");
101 return;
102 }
103 if (mHal.state.constants[0] == NULL) {
104 rsc->setError(RS_ERROR_FATAL_UNKNOWN,
105 "Unable to set fixed function emulation matrix texture because allocation is missing");
106 return;
107 }
108 float *f = static_cast<float *>(mHal.state.constants[0]->getPtr());
109 memcpy(&f[RS_PROGRAM_VERTEX_TEXTURE_OFFSET], m, sizeof(rsc_Matrix));
110 mDirty = true;
111 }
112
getProjectionMatrix(Context * rsc,rsc_Matrix * m) const113 void ProgramVertex::getProjectionMatrix(Context *rsc, rsc_Matrix *m) const {
114 if (isUserProgram()) {
115 rsc->setError(RS_ERROR_FATAL_UNKNOWN,
116 "Attempting to get fixed function emulation matrix projection on user program");
117 return;
118 }
119 if (mHal.state.constants[0] == NULL) {
120 rsc->setError(RS_ERROR_FATAL_UNKNOWN,
121 "Unable to get fixed function emulation matrix projection because allocation is missing");
122 return;
123 }
124 float *f = static_cast<float *>(mHal.state.constants[0]->getPtr());
125 memcpy(m, &f[RS_PROGRAM_VERTEX_PROJECTION_OFFSET], sizeof(rsc_Matrix));
126 }
127
transformToScreen(Context * rsc,float * v4out,const float * v3in) const128 void ProgramVertex::transformToScreen(Context *rsc, float *v4out, const float *v3in) const {
129 if (isUserProgram()) {
130 return;
131 }
132 float *f = static_cast<float *>(mHal.state.constants[0]->getPtr());
133 Matrix4x4 mvp;
134 mvp.loadMultiply((Matrix4x4 *)&f[RS_PROGRAM_VERTEX_MODELVIEW_OFFSET],
135 (Matrix4x4 *)&f[RS_PROGRAM_VERTEX_PROJECTION_OFFSET]);
136 mvp.vectorMultiply(v4out, v3in);
137 }
138
serialize(OStream * stream) const139 void ProgramVertex::serialize(OStream *stream) const {
140 }
141
createFromStream(Context * rsc,IStream * stream)142 ProgramVertex *ProgramVertex::createFromStream(Context *rsc, IStream *stream) {
143 return NULL;
144 }
145
146
147 ///////////////////////////////////////////////////////////////////////
148
ProgramVertexState()149 ProgramVertexState::ProgramVertexState() {
150 }
151
~ProgramVertexState()152 ProgramVertexState::~ProgramVertexState() {
153 }
154
init(Context * rsc)155 void ProgramVertexState::init(Context *rsc) {
156 ObjectBaseRef<const Element> matrixElem = Element::createRef(rsc, RS_TYPE_MATRIX_4X4,
157 RS_KIND_USER, false, 1);
158 ObjectBaseRef<const Element> f2Elem = Element::createRef(rsc, RS_TYPE_FLOAT_32,
159 RS_KIND_USER, false, 2);
160 ObjectBaseRef<const Element> f3Elem = Element::createRef(rsc, RS_TYPE_FLOAT_32,
161 RS_KIND_USER, false, 3);
162 ObjectBaseRef<const Element> f4Elem = Element::createRef(rsc, RS_TYPE_FLOAT_32,
163 RS_KIND_USER, false, 4);
164
165 Element::Builder constBuilder;
166 constBuilder.add(matrixElem.get(), "MV", 1);
167 constBuilder.add(matrixElem.get(), "P", 1);
168 constBuilder.add(matrixElem.get(), "TexMatrix", 1);
169 constBuilder.add(matrixElem.get(), "MVP", 1);
170 ObjectBaseRef<const Element> constInput = constBuilder.create(rsc);
171
172 Element::Builder inputBuilder;
173 inputBuilder.add(f4Elem.get(), "position", 1);
174 inputBuilder.add(f4Elem.get(), "color", 1);
175 inputBuilder.add(f3Elem.get(), "normal", 1);
176 inputBuilder.add(f2Elem.get(), "texture0", 1);
177 ObjectBaseRef<const Element> attrElem = inputBuilder.create(rsc);
178
179 ObjectBaseRef<Type> inputType = Type::getTypeRef(rsc, constInput.get(), 1, 0, 0, false, false);
180
181 String8 shaderString(RS_SHADER_INTERNAL);
182 shaderString.append("varying vec4 varColor;\n");
183 shaderString.append("varying vec2 varTex0;\n");
184 shaderString.append("void main() {\n");
185 shaderString.append(" gl_Position = UNI_MVP * ATTRIB_position;\n");
186 shaderString.append(" gl_PointSize = 1.0;\n");
187 shaderString.append(" varColor = ATTRIB_color;\n");
188 shaderString.append(" varTex0 = ATTRIB_texture0;\n");
189 shaderString.append("}\n");
190
191 uint32_t tmp[4];
192 tmp[0] = RS_PROGRAM_PARAM_CONSTANT;
193 tmp[1] = (uint32_t)inputType.get();
194 tmp[2] = RS_PROGRAM_PARAM_INPUT;
195 tmp[3] = (uint32_t)attrElem.get();
196
197 ProgramVertex *pv = new ProgramVertex(rsc, shaderString.string(), shaderString.length(),
198 NULL, 0, NULL, tmp, 4);
199 Allocation *alloc = Allocation::createAllocation(rsc, inputType.get(),
200 RS_ALLOCATION_USAGE_SCRIPT | RS_ALLOCATION_USAGE_GRAPHICS_CONSTANTS);
201 pv->bindAllocation(rsc, alloc, 0);
202
203 mDefaultAlloc.set(alloc);
204 mDefault.set(pv);
205
206 updateSize(rsc);
207 }
208
updateSize(Context * rsc)209 void ProgramVertexState::updateSize(Context *rsc) {
210 float *f = static_cast<float *>(mDefaultAlloc->getPtr());
211
212 float surfaceWidth = (float)rsc->getCurrentSurfaceWidth();
213 float surfaceHeight = (float)rsc->getCurrentSurfaceHeight();
214
215 Matrix4x4 m;
216 m.loadOrtho(0, surfaceWidth, surfaceHeight, 0, -1, 1);
217 memcpy(&f[RS_PROGRAM_VERTEX_PROJECTION_OFFSET], m.m, sizeof(m));
218 memcpy(&f[RS_PROGRAM_VERTEX_MVP_OFFSET], m.m, sizeof(m));
219
220 m.loadIdentity();
221 memcpy(&f[RS_PROGRAM_VERTEX_MODELVIEW_OFFSET], m.m, sizeof(m));
222 memcpy(&f[RS_PROGRAM_VERTEX_TEXTURE_OFFSET], m.m, sizeof(m));
223 }
224
deinit(Context * rsc)225 void ProgramVertexState::deinit(Context *rsc) {
226 mDefaultAlloc.clear();
227 mDefault.clear();
228 mLast.clear();
229 }
230
231
232 namespace android {
233 namespace renderscript {
234
rsi_ProgramVertexCreate(Context * rsc,const char * shaderText,size_t shaderLength,const char ** textureNames,size_t textureNamesCount,const size_t * textureNamesLength,const uint32_t * params,size_t paramLength)235 RsProgramVertex rsi_ProgramVertexCreate(Context *rsc, const char * shaderText, size_t shaderLength,
236 const char** textureNames, size_t textureNamesCount,
237 const size_t *textureNamesLength,
238 const uint32_t * params, size_t paramLength) {
239 ProgramVertex *pv = new ProgramVertex(rsc, shaderText, shaderLength,
240 textureNames, textureNamesCount, textureNamesLength,
241 params, paramLength);
242 pv->incUserRef();
243 return pv;
244 }
245
246 }
247 }
248