rsProgramVertex.cpp revision 87319de2b16a185cf360827c96a42cf1fcaae744 
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#ifndef ANDROID_RS_BUILD_FOR_HOST
18#include "rsContext.h"
19#include <GLES/gl.h>
20#include <GLES/glext.h>
21#include <GLES2/gl2.h>
22#include <GLES2/gl2ext.h>
23#else
24#include "rsContextHostStub.h"
25#include <OpenGL/gl.h>
26#include <OpenGL/glext.h>
27#endif //ANDROID_RS_BUILD_FOR_HOST
28
29#include "rsProgramVertex.h"
30
31using namespace android;
32using namespace android::renderscript;
33
34
35ProgramVertex::ProgramVertex(Context *rsc, const char * shaderText,
36                             uint32_t shaderLength, const uint32_t * params,
37                             uint32_t paramLength)
38    : Program(rsc, shaderText, shaderLength, params, paramLength) {
39    init(rsc);
40}
41
42ProgramVertex::~ProgramVertex() {
43    if (mShaderID) {
44        mRSC->mShaderCache.cleanupVertex(mShaderID);
45    }
46}
47
48void ProgramVertex::loadShader(Context *rsc) {
49    Program::loadShader(rsc, GL_VERTEX_SHADER);
50}
51
52void ProgramVertex::createShader(Context *rsc) {
53    if (mUserShader.length() > 1) {
54
55        appendUserConstants();
56
57        for (uint32_t ct=0; ct < mInputCount; ct++) {
58            const Element *e = mInputElements[ct].get();
59            for (uint32_t field=0; field < e->getFieldCount(); field++) {
60                const Element *f = e->getField(field);
61                const char *fn = e->getFieldName(field);
62
63                if (fn[0] == '#') {
64                    continue;
65                }
66
67                // Cannot be complex
68                rsAssert(!f->getFieldCount());
69                switch (f->getComponent().getVectorSize()) {
70                case 1: mShader.append("attribute float ATTRIB_"); break;
71                case 2: mShader.append("attribute vec2 ATTRIB_"); break;
72                case 3: mShader.append("attribute vec3 ATTRIB_"); break;
73                case 4: mShader.append("attribute vec4 ATTRIB_"); break;
74                default:
75                    rsAssert(0);
76                }
77
78                mShader.append(fn);
79                mShader.append(";\n");
80            }
81        }
82        mShader.append(mUserShader);
83    } else {
84        rsc->setError(RS_ERROR_FATAL_UNKNOWN,
85                      "ProgramFragment::createShader cannot create program, shader code not defined");
86    }
87}
88
89void ProgramVertex::setupGL2(Context *rsc, ProgramVertexState *state, ShaderCache *sc) {
90    if ((state->mLast.get() == this) && !mDirty) {
91        return;
92    }
93
94    rsc->checkError("ProgramVertex::setupGL2 start");
95
96    if (!isUserProgram()) {
97        if (mConstants[0].get() == NULL) {
98            rsc->setError(RS_ERROR_FATAL_UNKNOWN,
99                          "Unable to set fixed function emulation matrices because allocation is missing");
100            return;
101        }
102        float *f = static_cast<float *>(mConstants[0]->getPtr());
103        Matrix mvp;
104        mvp.load(&f[RS_PROGRAM_VERTEX_PROJECTION_OFFSET]);
105        Matrix t;
106        t.load(&f[RS_PROGRAM_VERTEX_MODELVIEW_OFFSET]);
107        mvp.multiply(&t);
108        for (uint32_t i = 0; i < 16; i ++) {
109            f[RS_PROGRAM_VERTEX_MVP_OFFSET + i] = mvp.m[i];
110        }
111    }
112
113    rsc->checkError("ProgramVertex::setupGL2 begin uniforms");
114    setupUserConstants(rsc, sc, false);
115
116    state->mLast.set(this);
117    rsc->checkError("ProgramVertex::setupGL2");
118}
119
120void ProgramVertex::setProjectionMatrix(Context *rsc, const rsc_Matrix *m) const {
121    if (isUserProgram()) {
122        rsc->setError(RS_ERROR_FATAL_UNKNOWN,
123                      "Attempting to set fixed function emulation matrix projection on user program");
124        return;
125    }
126    if (mConstants[0].get() == NULL) {
127        rsc->setError(RS_ERROR_FATAL_UNKNOWN,
128                      "Unable to set fixed function emulation matrix projection because allocation is missing");
129        return;
130    }
131    float *f = static_cast<float *>(mConstants[0]->getPtr());
132    memcpy(&f[RS_PROGRAM_VERTEX_PROJECTION_OFFSET], m, sizeof(rsc_Matrix));
133    mDirty = true;
134}
135
136void ProgramVertex::setModelviewMatrix(Context *rsc, const rsc_Matrix *m) const {
137    if (isUserProgram()) {
138        rsc->setError(RS_ERROR_FATAL_UNKNOWN,
139                      "Attempting to set fixed function emulation matrix modelview on user program");
140        return;
141    }
142    if (mConstants[0].get() == NULL) {
143        rsc->setError(RS_ERROR_FATAL_UNKNOWN,
144                      "Unable to set fixed function emulation matrix modelview because allocation is missing");
145        return;
146    }
147    float *f = static_cast<float *>(mConstants[0]->getPtr());
148    memcpy(&f[RS_PROGRAM_VERTEX_MODELVIEW_OFFSET], m, sizeof(rsc_Matrix));
149    mDirty = true;
150}
151
152void ProgramVertex::setTextureMatrix(Context *rsc, const rsc_Matrix *m) const {
153    if (isUserProgram()) {
154        rsc->setError(RS_ERROR_FATAL_UNKNOWN,
155                      "Attempting to set fixed function emulation matrix texture on user program");
156        return;
157    }
158    if (mConstants[0].get() == NULL) {
159        rsc->setError(RS_ERROR_FATAL_UNKNOWN,
160                      "Unable to set fixed function emulation matrix texture because allocation is missing");
161        return;
162    }
163    float *f = static_cast<float *>(mConstants[0]->getPtr());
164    memcpy(&f[RS_PROGRAM_VERTEX_TEXTURE_OFFSET], m, sizeof(rsc_Matrix));
165    mDirty = true;
166}
167
168void ProgramVertex::getProjectionMatrix(Context *rsc, rsc_Matrix *m) const {
169    if (isUserProgram()) {
170        rsc->setError(RS_ERROR_FATAL_UNKNOWN,
171                      "Attempting to get fixed function emulation matrix projection on user program");
172        return;
173    }
174    if (mConstants[0].get() == NULL) {
175        rsc->setError(RS_ERROR_FATAL_UNKNOWN,
176                      "Unable to get fixed function emulation matrix projection because allocation is missing");
177        return;
178    }
179    float *f = static_cast<float *>(mConstants[0]->getPtr());
180    memcpy(m, &f[RS_PROGRAM_VERTEX_PROJECTION_OFFSET], sizeof(rsc_Matrix));
181}
182
183void ProgramVertex::transformToScreen(Context *rsc, float *v4out, const float *v3in) const {
184    if (isUserProgram()) {
185        return;
186    }
187    float *f = static_cast<float *>(mConstants[0]->getPtr());
188    Matrix mvp;
189    mvp.loadMultiply((Matrix *)&f[RS_PROGRAM_VERTEX_MODELVIEW_OFFSET],
190                     (Matrix *)&f[RS_PROGRAM_VERTEX_PROJECTION_OFFSET]);
191    mvp.vectorMultiply(v4out, v3in);
192}
193
194void ProgramVertex::init(Context *rsc) {
195    uint32_t attribCount = 0;
196    uint32_t uniformCount = 0;
197    if (mUserShader.size() > 0) {
198        for (uint32_t ct=0; ct < mInputCount; ct++) {
199            initAddUserElement(mInputElements[ct].get(), mAttribNames, NULL, &attribCount, RS_SHADER_ATTR);
200        }
201        for (uint32_t ct=0; ct < mConstantCount; ct++) {
202            initAddUserElement(mConstantTypes[ct]->getElement(), mUniformNames, mUniformArraySizes, &uniformCount, RS_SHADER_UNI);
203        }
204    }
205    createShader(rsc);
206}
207
208void ProgramVertex::serialize(OStream *stream) const {
209}
210
211ProgramVertex *ProgramVertex::createFromStream(Context *rsc, IStream *stream) {
212    return NULL;
213}
214
215
216///////////////////////////////////////////////////////////////////////
217
218ProgramVertexState::ProgramVertexState() {
219}
220
221ProgramVertexState::~ProgramVertexState() {
222}
223
224void ProgramVertexState::init(Context *rsc) {
225    const Element *matrixElem = Element::create(rsc, RS_TYPE_MATRIX_4X4, RS_KIND_USER, false, 1);
226    const Element *f2Elem = Element::create(rsc, RS_TYPE_FLOAT_32, RS_KIND_USER, false, 2);
227    const Element *f3Elem = Element::create(rsc, RS_TYPE_FLOAT_32, RS_KIND_USER, false, 3);
228    const Element *f4Elem = Element::create(rsc, RS_TYPE_FLOAT_32, RS_KIND_USER, false, 4);
229
230    rsc->mStateElement.elementBuilderBegin();
231    rsc->mStateElement.elementBuilderAdd(matrixElem, "MV", 1);
232    rsc->mStateElement.elementBuilderAdd(matrixElem, "P", 1);
233    rsc->mStateElement.elementBuilderAdd(matrixElem, "TexMatrix", 1);
234    rsc->mStateElement.elementBuilderAdd(matrixElem, "MVP", 1);
235    const Element *constInput = rsc->mStateElement.elementBuilderCreate(rsc);
236
237    rsc->mStateElement.elementBuilderBegin();
238    rsc->mStateElement.elementBuilderAdd(f4Elem, "position", 1);
239    rsc->mStateElement.elementBuilderAdd(f4Elem, "color", 1);
240    rsc->mStateElement.elementBuilderAdd(f3Elem, "normal", 1);
241    rsc->mStateElement.elementBuilderAdd(f2Elem, "texture0", 1);
242    const Element *attrElem = rsc->mStateElement.elementBuilderCreate(rsc);
243
244    Type *inputType = Type::getType(rsc, constInput, 1, 0, 0, false, false);
245
246    String8 shaderString(RS_SHADER_INTERNAL);
247    shaderString.append("varying vec4 varColor;\n");
248    shaderString.append("varying vec2 varTex0;\n");
249    shaderString.append("void main() {\n");
250    shaderString.append("  gl_Position = UNI_MVP * ATTRIB_position;\n");
251    shaderString.append("  gl_PointSize = 1.0;\n");
252    shaderString.append("  varColor = ATTRIB_color;\n");
253    shaderString.append("  varTex0 = ATTRIB_texture0;\n");
254    shaderString.append("}\n");
255
256    uint32_t tmp[4];
257    tmp[0] = RS_PROGRAM_PARAM_CONSTANT;
258    tmp[1] = (uint32_t)inputType;
259    tmp[2] = RS_PROGRAM_PARAM_INPUT;
260    tmp[3] = (uint32_t)attrElem;
261
262    ProgramVertex *pv = new ProgramVertex(rsc, shaderString.string(),
263                                          shaderString.length(), tmp, 4);
264    Allocation *alloc = new Allocation(rsc, inputType);
265    pv->bindAllocation(rsc, alloc, 0);
266
267    mDefaultAlloc.set(alloc);
268    mDefault.set(pv);
269
270    updateSize(rsc);
271}
272
273void ProgramVertexState::updateSize(Context *rsc) {
274    float *f = static_cast<float *>(mDefaultAlloc->getPtr());
275
276    Matrix m;
277    m.loadOrtho(0,rsc->getWidth(), rsc->getHeight(),0, -1,1);
278    memcpy(&f[RS_PROGRAM_VERTEX_PROJECTION_OFFSET], m.m, sizeof(m));
279    memcpy(&f[RS_PROGRAM_VERTEX_MVP_OFFSET], m.m, sizeof(m));
280
281    m.loadIdentity();
282    memcpy(&f[RS_PROGRAM_VERTEX_MODELVIEW_OFFSET], m.m, sizeof(m));
283    memcpy(&f[RS_PROGRAM_VERTEX_TEXTURE_OFFSET], m.m, sizeof(m));
284}
285
286void ProgramVertexState::deinit(Context *rsc) {
287    mDefaultAlloc.clear();
288    mDefault.clear();
289    mLast.clear();
290}
291
292
293namespace android {
294namespace renderscript {
295
296RsProgramVertex rsi_ProgramVertexCreate(Context *rsc, const char * shaderText,
297                             uint32_t shaderLength, const uint32_t * params,
298                             uint32_t paramLength) {
299    ProgramVertex *pv = new ProgramVertex(rsc, shaderText, shaderLength, params, paramLength);
300    pv->incUserRef();
301    return pv;
302}
303
304}
305}
306