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