Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 1 | /* |
Alex Sakhartchouk | a04e30d | 2011-04-29 16:49:08 -0700 | [diff] [blame] | 2 | * Copyright (C) 2011 The Android Open Source Project |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [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 | |
| 17 | #include "rsContext.h" |
Alex Sakhartchouk | fb6b614 | 2010-05-21 12:53:13 -0700 | [diff] [blame] | 18 | #include "rsProgramVertex.h" |
Alex Sakhartchouk | 4edf030 | 2012-03-09 10:47:27 -0800 | [diff] [blame] | 19 | #include "rsMatrix4x4.h" |
Jason Sams | 1aa5a4e | 2009-06-22 17:15:15 -0700 | [diff] [blame] | 20 | |
Chih-Hung Hsieh | 11496ac | 2016-11-15 15:14:05 -0800 | [diff] [blame] | 21 | using android::renderscript::ProgramVertex; |
| 22 | using android::renderscript::ProgramVertexState; |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 23 | |
Alex Sakhartchouk | 748eb07 | 2012-02-15 16:21:46 -0800 | [diff] [blame] | 24 | ProgramVertex::ProgramVertex(Context *rsc, const char * shaderText, size_t shaderLength, |
| 25 | const char** textureNames, size_t textureNamesCount, const size_t *textureNamesLength, |
| 26 | |
Ian Rogers | f8852d0 | 2014-01-29 15:35:17 -0800 | [diff] [blame] | 27 | const uintptr_t * params, size_t paramLength) |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 28 | : Program(rsc, shaderText, shaderLength, params, paramLength) { |
Jason Sams | f313dc3 | 2013-07-09 14:29:39 -0700 | [diff] [blame] | 29 | mRSC->mHal.funcs.vertex.init(mRSC, this, mUserShader, mUserShaderLen, |
Alex Sakhartchouk | 748eb07 | 2012-02-15 16:21:46 -0800 | [diff] [blame] | 30 | textureNames, textureNamesCount, textureNamesLength); |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 31 | } |
| 32 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 33 | ProgramVertex::~ProgramVertex() { |
Alex Sakhartchouk | a04e30d | 2011-04-29 16:49:08 -0700 | [diff] [blame] | 34 | mRSC->mHal.funcs.vertex.destroy(mRSC, this); |
Jason Sams | 56bc1af | 2009-06-16 17:49:58 -0700 | [diff] [blame] | 35 | } |
| 36 | |
Alex Sakhartchouk | c19ff01 | 2011-05-06 14:59:45 -0700 | [diff] [blame] | 37 | void ProgramVertex::setup(Context *rsc, ProgramVertexState *state) { |
Jason Sams | c460e55 | 2009-11-25 13:22:07 -0800 | [diff] [blame] | 38 | if ((state->mLast.get() == this) && !mDirty) { |
Jason Sams | e64c2f1 | 2010-06-22 17:22:13 -0700 | [diff] [blame] | 39 | return; |
Jason Sams | c460e55 | 2009-11-25 13:22:07 -0800 | [diff] [blame] | 40 | } |
| 41 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 42 | if (!isUserProgram()) { |
Chris Wailes | 44bef6f | 2014-08-12 13:51:10 -0700 | [diff] [blame] | 43 | if (mHal.state.constants[0] == nullptr) { |
Jason Sams | 87319de | 2010-11-22 16:20:16 -0800 | [diff] [blame] | 44 | rsc->setError(RS_ERROR_FATAL_UNKNOWN, |
| 45 | "Unable to set fixed function emulation matrices because allocation is missing"); |
Alex Sakhartchouk | 0bd3c86 | 2010-09-27 10:29:47 -0700 | [diff] [blame] | 46 | return; |
| 47 | } |
Jason Sams | 807fdc4 | 2012-07-25 17:55:39 -0700 | [diff] [blame] | 48 | float *f = static_cast<float *>(rsc->mHal.funcs.allocation.lock1D( |
| 49 | rsc, mHal.state.constants[0])); |
Jason Sams | 87fe59a | 2011-04-20 15:09:01 -0700 | [diff] [blame] | 50 | Matrix4x4 mvp; |
Alex Sakhartchouk | e7ae69f | 2010-09-14 09:50:43 -0700 | [diff] [blame] | 51 | mvp.load(&f[RS_PROGRAM_VERTEX_PROJECTION_OFFSET]); |
Jason Sams | 87fe59a | 2011-04-20 15:09:01 -0700 | [diff] [blame] | 52 | Matrix4x4 t; |
Alex Sakhartchouk | e7ae69f | 2010-09-14 09:50:43 -0700 | [diff] [blame] | 53 | t.load(&f[RS_PROGRAM_VERTEX_MODELVIEW_OFFSET]); |
| 54 | mvp.multiply(&t); |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 55 | for (uint32_t i = 0; i < 16; i ++) { |
Alex Sakhartchouk | e7ae69f | 2010-09-14 09:50:43 -0700 | [diff] [blame] | 56 | f[RS_PROGRAM_VERTEX_MVP_OFFSET + i] = mvp.m[i]; |
| 57 | } |
Jason Sams | 807fdc4 | 2012-07-25 17:55:39 -0700 | [diff] [blame] | 58 | rsc->mHal.funcs.allocation.unlock1D(rsc, mHal.state.constants[0]); |
Jason Sams | c460e55 | 2009-11-25 13:22:07 -0800 | [diff] [blame] | 59 | } |
| 60 | |
| 61 | state->mLast.set(this); |
Alex Sakhartchouk | a04e30d | 2011-04-29 16:49:08 -0700 | [diff] [blame] | 62 | |
| 63 | rsc->mHal.funcs.vertex.setActive(rsc, this); |
Jason Sams | c460e55 | 2009-11-25 13:22:07 -0800 | [diff] [blame] | 64 | } |
| 65 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 66 | void ProgramVertex::setProjectionMatrix(Context *rsc, const rsc_Matrix *m) const { |
| 67 | if (isUserProgram()) { |
Jason Sams | 87319de | 2010-11-22 16:20:16 -0800 | [diff] [blame] | 68 | rsc->setError(RS_ERROR_FATAL_UNKNOWN, |
| 69 | "Attempting to set fixed function emulation matrix projection on user program"); |
Alex Sakhartchouk | 383e5b1 | 2010-09-23 16:16:33 -0700 | [diff] [blame] | 70 | return; |
| 71 | } |
Chris Wailes | 44bef6f | 2014-08-12 13:51:10 -0700 | [diff] [blame] | 72 | if (mHal.state.constants[0] == nullptr) { |
Jason Sams | 87319de | 2010-11-22 16:20:16 -0800 | [diff] [blame] | 73 | rsc->setError(RS_ERROR_FATAL_UNKNOWN, |
| 74 | "Unable to set fixed function emulation matrix projection because allocation is missing"); |
Alex Sakhartchouk | e7ae69f | 2010-09-14 09:50:43 -0700 | [diff] [blame] | 75 | return; |
| 76 | } |
Jason Sams | 807fdc4 | 2012-07-25 17:55:39 -0700 | [diff] [blame] | 77 | float *f = static_cast<float *>(rsc->mHal.funcs.allocation.lock1D( |
| 78 | rsc, mHal.state.constants[0])); |
Jason Sams | c9d43db | 2009-07-28 12:02:16 -0700 | [diff] [blame] | 79 | memcpy(&f[RS_PROGRAM_VERTEX_PROJECTION_OFFSET], m, sizeof(rsc_Matrix)); |
Jason Sams | cfb1d11 | 2009-08-05 13:57:03 -0700 | [diff] [blame] | 80 | mDirty = true; |
Jason Sams | 807fdc4 | 2012-07-25 17:55:39 -0700 | [diff] [blame] | 81 | rsc->mHal.funcs.allocation.unlock1D(rsc, mHal.state.constants[0]); |
Jason Sams | c9d43db | 2009-07-28 12:02:16 -0700 | [diff] [blame] | 82 | } |
| 83 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 84 | void ProgramVertex::setModelviewMatrix(Context *rsc, const rsc_Matrix *m) const { |
| 85 | if (isUserProgram()) { |
Jason Sams | 87319de | 2010-11-22 16:20:16 -0800 | [diff] [blame] | 86 | rsc->setError(RS_ERROR_FATAL_UNKNOWN, |
| 87 | "Attempting to set fixed function emulation matrix modelview on user program"); |
Alex Sakhartchouk | 383e5b1 | 2010-09-23 16:16:33 -0700 | [diff] [blame] | 88 | return; |
| 89 | } |
Chris Wailes | 44bef6f | 2014-08-12 13:51:10 -0700 | [diff] [blame] | 90 | if (mHal.state.constants[0] == nullptr) { |
Jason Sams | 87319de | 2010-11-22 16:20:16 -0800 | [diff] [blame] | 91 | rsc->setError(RS_ERROR_FATAL_UNKNOWN, |
| 92 | "Unable to set fixed function emulation matrix modelview because allocation is missing"); |
Alex Sakhartchouk | e7ae69f | 2010-09-14 09:50:43 -0700 | [diff] [blame] | 93 | return; |
| 94 | } |
Jason Sams | 807fdc4 | 2012-07-25 17:55:39 -0700 | [diff] [blame] | 95 | float *f = static_cast<float *>(rsc->mHal.funcs.allocation.lock1D( |
| 96 | rsc, mHal.state.constants[0])); |
Jason Sams | c9d43db | 2009-07-28 12:02:16 -0700 | [diff] [blame] | 97 | memcpy(&f[RS_PROGRAM_VERTEX_MODELVIEW_OFFSET], m, sizeof(rsc_Matrix)); |
Jason Sams | cfb1d11 | 2009-08-05 13:57:03 -0700 | [diff] [blame] | 98 | mDirty = true; |
Jason Sams | 807fdc4 | 2012-07-25 17:55:39 -0700 | [diff] [blame] | 99 | rsc->mHal.funcs.allocation.unlock1D(rsc, mHal.state.constants[0]); |
Jason Sams | c9d43db | 2009-07-28 12:02:16 -0700 | [diff] [blame] | 100 | } |
| 101 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 102 | void ProgramVertex::setTextureMatrix(Context *rsc, const rsc_Matrix *m) const { |
| 103 | if (isUserProgram()) { |
Jason Sams | 87319de | 2010-11-22 16:20:16 -0800 | [diff] [blame] | 104 | rsc->setError(RS_ERROR_FATAL_UNKNOWN, |
| 105 | "Attempting to set fixed function emulation matrix texture on user program"); |
Alex Sakhartchouk | 383e5b1 | 2010-09-23 16:16:33 -0700 | [diff] [blame] | 106 | return; |
| 107 | } |
Chris Wailes | 44bef6f | 2014-08-12 13:51:10 -0700 | [diff] [blame] | 108 | if (mHal.state.constants[0] == nullptr) { |
Jason Sams | 87319de | 2010-11-22 16:20:16 -0800 | [diff] [blame] | 109 | rsc->setError(RS_ERROR_FATAL_UNKNOWN, |
| 110 | "Unable to set fixed function emulation matrix texture because allocation is missing"); |
Alex Sakhartchouk | e7ae69f | 2010-09-14 09:50:43 -0700 | [diff] [blame] | 111 | return; |
| 112 | } |
Jason Sams | 807fdc4 | 2012-07-25 17:55:39 -0700 | [diff] [blame] | 113 | float *f = static_cast<float *>(rsc->mHal.funcs.allocation.lock1D( |
| 114 | rsc, mHal.state.constants[0])); |
Jason Sams | c9d43db | 2009-07-28 12:02:16 -0700 | [diff] [blame] | 115 | memcpy(&f[RS_PROGRAM_VERTEX_TEXTURE_OFFSET], m, sizeof(rsc_Matrix)); |
Jason Sams | cfb1d11 | 2009-08-05 13:57:03 -0700 | [diff] [blame] | 116 | mDirty = true; |
Jason Sams | 807fdc4 | 2012-07-25 17:55:39 -0700 | [diff] [blame] | 117 | rsc->mHal.funcs.allocation.unlock1D(rsc, mHal.state.constants[0]); |
Jason Sams | c9d43db | 2009-07-28 12:02:16 -0700 | [diff] [blame] | 118 | } |
| 119 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 120 | void ProgramVertex::getProjectionMatrix(Context *rsc, rsc_Matrix *m) const { |
| 121 | if (isUserProgram()) { |
Jason Sams | 87319de | 2010-11-22 16:20:16 -0800 | [diff] [blame] | 122 | rsc->setError(RS_ERROR_FATAL_UNKNOWN, |
| 123 | "Attempting to get fixed function emulation matrix projection on user program"); |
Alex Sakhartchouk | 383e5b1 | 2010-09-23 16:16:33 -0700 | [diff] [blame] | 124 | return; |
| 125 | } |
Chris Wailes | 44bef6f | 2014-08-12 13:51:10 -0700 | [diff] [blame] | 126 | if (mHal.state.constants[0] == nullptr) { |
Jason Sams | 87319de | 2010-11-22 16:20:16 -0800 | [diff] [blame] | 127 | rsc->setError(RS_ERROR_FATAL_UNKNOWN, |
| 128 | "Unable to get fixed function emulation matrix projection because allocation is missing"); |
Alex Sakhartchouk | e7ae69f | 2010-09-14 09:50:43 -0700 | [diff] [blame] | 129 | return; |
| 130 | } |
Jason Sams | 807fdc4 | 2012-07-25 17:55:39 -0700 | [diff] [blame] | 131 | float *f = static_cast<float *>( |
| 132 | rsc->mHal.funcs.allocation.lock1D(rsc, mHal.state.constants[0])); |
Alex Sakhartchouk | 95333f9 | 2010-08-16 17:40:10 -0700 | [diff] [blame] | 133 | memcpy(m, &f[RS_PROGRAM_VERTEX_PROJECTION_OFFSET], sizeof(rsc_Matrix)); |
Jason Sams | 807fdc4 | 2012-07-25 17:55:39 -0700 | [diff] [blame] | 134 | rsc->mHal.funcs.allocation.unlock1D(rsc, mHal.state.constants[0]); |
Alex Sakhartchouk | 95333f9 | 2010-08-16 17:40:10 -0700 | [diff] [blame] | 135 | } |
| 136 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 137 | void ProgramVertex::transformToScreen(Context *rsc, float *v4out, const float *v3in) const { |
| 138 | if (isUserProgram()) { |
Alex Sakhartchouk | e7ae69f | 2010-09-14 09:50:43 -0700 | [diff] [blame] | 139 | return; |
| 140 | } |
Jason Sams | 807fdc4 | 2012-07-25 17:55:39 -0700 | [diff] [blame] | 141 | float *f = static_cast<float *>( |
| 142 | rsc->mHal.funcs.allocation.lock1D(rsc, mHal.state.constants[0])); |
Jason Sams | 87fe59a | 2011-04-20 15:09:01 -0700 | [diff] [blame] | 143 | Matrix4x4 mvp; |
| 144 | mvp.loadMultiply((Matrix4x4 *)&f[RS_PROGRAM_VERTEX_MODELVIEW_OFFSET], |
| 145 | (Matrix4x4 *)&f[RS_PROGRAM_VERTEX_PROJECTION_OFFSET]); |
Jason Sams | 3a97c59 | 2009-09-30 17:36:20 -0700 | [diff] [blame] | 146 | mvp.vectorMultiply(v4out, v3in); |
Jason Sams | 807fdc4 | 2012-07-25 17:55:39 -0700 | [diff] [blame] | 147 | rsc->mHal.funcs.allocation.unlock1D(rsc, mHal.state.constants[0]); |
Jason Sams | 3a97c59 | 2009-09-30 17:36:20 -0700 | [diff] [blame] | 148 | } |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 149 | |
Jason Sams | e3150cf | 2012-07-24 18:10:20 -0700 | [diff] [blame] | 150 | void ProgramVertex::serialize(Context *rsc, OStream *stream) const { |
Alex Sakhartchouk | fb6b614 | 2010-05-21 12:53:13 -0700 | [diff] [blame] | 151 | } |
| 152 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 153 | ProgramVertex *ProgramVertex::createFromStream(Context *rsc, IStream *stream) { |
Chris Wailes | 44bef6f | 2014-08-12 13:51:10 -0700 | [diff] [blame] | 154 | return nullptr; |
Alex Sakhartchouk | fb6b614 | 2010-05-21 12:53:13 -0700 | [diff] [blame] | 155 | } |
| 156 | |
Jason Sams | 4815c0d | 2009-12-15 12:58:36 -0800 | [diff] [blame] | 157 | |
Jason Sams | c460e55 | 2009-11-25 13:22:07 -0800 | [diff] [blame] | 158 | /////////////////////////////////////////////////////////////////////// |
| 159 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 160 | ProgramVertexState::ProgramVertexState() { |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 161 | } |
| 162 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 163 | ProgramVertexState::~ProgramVertexState() { |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 164 | } |
| 165 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 166 | void ProgramVertexState::init(Context *rsc) { |
Alex Sakhartchouk | c700e64 | 2011-08-16 13:09:46 -0700 | [diff] [blame] | 167 | ObjectBaseRef<const Element> matrixElem = Element::createRef(rsc, RS_TYPE_MATRIX_4X4, |
| 168 | RS_KIND_USER, false, 1); |
| 169 | ObjectBaseRef<const Element> f2Elem = Element::createRef(rsc, RS_TYPE_FLOAT_32, |
| 170 | RS_KIND_USER, false, 2); |
| 171 | ObjectBaseRef<const Element> f3Elem = Element::createRef(rsc, RS_TYPE_FLOAT_32, |
| 172 | RS_KIND_USER, false, 3); |
| 173 | ObjectBaseRef<const Element> f4Elem = Element::createRef(rsc, RS_TYPE_FLOAT_32, |
| 174 | RS_KIND_USER, false, 4); |
Jason Sams | 8287c0c | 2009-09-24 12:33:45 -0700 | [diff] [blame] | 175 | |
Jason Sams | f313dc3 | 2013-07-09 14:29:39 -0700 | [diff] [blame] | 176 | const char *ebn1[] = { "MV", "P", "TexMatrix", "MVP" }; |
| 177 | const Element *ebe1[] = {matrixElem.get(), matrixElem.get(), |
| 178 | matrixElem.get(), matrixElem.get()}; |
| 179 | ObjectBaseRef<const Element> constInput = Element::create(rsc, 4, ebe1, ebn1); |
Jason Sams | 8287c0c | 2009-09-24 12:33:45 -0700 | [diff] [blame] | 180 | |
Jason Sams | f313dc3 | 2013-07-09 14:29:39 -0700 | [diff] [blame] | 181 | const char *ebn2[] = { "position", "color", "normal", "texture0" }; |
| 182 | const Element *ebe2[] = {f4Elem.get(), f4Elem.get(), f3Elem.get(), f2Elem.get()}; |
| 183 | ObjectBaseRef<const Element> attrElem = Element::create(rsc, 4, ebe2, ebn2); |
Alex Sakhartchouk | e7ae69f | 2010-09-14 09:50:43 -0700 | [diff] [blame] | 184 | |
Jason Sams | c7968a0 | 2014-11-11 16:24:36 -0800 | [diff] [blame] | 185 | ObjectBaseRef<Type> inputType = Type::getTypeRef(rsc, constInput.get(), 1); |
Alex Sakhartchouk | e7ae69f | 2010-09-14 09:50:43 -0700 | [diff] [blame] | 186 | |
Jason Sams | a7f5e04 | 2013-07-08 16:46:18 -0700 | [diff] [blame] | 187 | const char *shaderString = |
| 188 | RS_SHADER_INTERNAL |
| 189 | "varying vec4 varColor;\n" |
| 190 | "varying vec2 varTex0;\n" |
| 191 | "void main() {\n" |
| 192 | " gl_Position = UNI_MVP * ATTRIB_position;\n" |
| 193 | " gl_PointSize = 1.0;\n" |
| 194 | " varColor = ATTRIB_color;\n" |
| 195 | " varTex0 = ATTRIB_texture0;\n" |
| 196 | "}\n"; |
Alex Sakhartchouk | e7ae69f | 2010-09-14 09:50:43 -0700 | [diff] [blame] | 197 | |
Ian Rogers | f8852d0 | 2014-01-29 15:35:17 -0800 | [diff] [blame] | 198 | uintptr_t tmp[4]; |
Alex Sakhartchouk | e7ae69f | 2010-09-14 09:50:43 -0700 | [diff] [blame] | 199 | tmp[0] = RS_PROGRAM_PARAM_CONSTANT; |
Ian Rogers | f8852d0 | 2014-01-29 15:35:17 -0800 | [diff] [blame] | 200 | tmp[1] = (uintptr_t)inputType.get(); |
Alex Sakhartchouk | e7ae69f | 2010-09-14 09:50:43 -0700 | [diff] [blame] | 201 | tmp[2] = RS_PROGRAM_PARAM_INPUT; |
Ian Rogers | f8852d0 | 2014-01-29 15:35:17 -0800 | [diff] [blame] | 202 | tmp[3] = (uintptr_t)attrElem.get(); |
Alex Sakhartchouk | e7ae69f | 2010-09-14 09:50:43 -0700 | [diff] [blame] | 203 | |
Jason Sams | a7f5e04 | 2013-07-08 16:46:18 -0700 | [diff] [blame] | 204 | ProgramVertex *pv = new ProgramVertex(rsc, shaderString, strlen(shaderString), |
Chris Wailes | 44bef6f | 2014-08-12 13:51:10 -0700 | [diff] [blame] | 205 | nullptr, 0, nullptr, tmp, 4); |
Alex Sakhartchouk | c700e64 | 2011-08-16 13:09:46 -0700 | [diff] [blame] | 206 | Allocation *alloc = Allocation::createAllocation(rsc, inputType.get(), |
Jason Sams | eb4fe18 | 2011-05-26 16:33:01 -0700 | [diff] [blame] | 207 | RS_ALLOCATION_USAGE_SCRIPT | RS_ALLOCATION_USAGE_GRAPHICS_CONSTANTS); |
Alex Sakhartchouk | 383e5b1 | 2010-09-23 16:16:33 -0700 | [diff] [blame] | 208 | pv->bindAllocation(rsc, alloc, 0); |
Alex Sakhartchouk | fb6b614 | 2010-05-21 12:53:13 -0700 | [diff] [blame] | 209 | |
Jason Sams | 8ce125b | 2009-06-17 16:52:59 -0700 | [diff] [blame] | 210 | mDefaultAlloc.set(alloc); |
| 211 | mDefault.set(pv); |
Jason Sams | cfb1d11 | 2009-08-05 13:57:03 -0700 | [diff] [blame] | 212 | |
Jason Sams | 771565f | 2010-05-14 15:30:29 -0700 | [diff] [blame] | 213 | updateSize(rsc); |
Jason Sams | e18844a | 2009-11-12 16:09:45 -0800 | [diff] [blame] | 214 | } |
| 215 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 216 | void ProgramVertexState::updateSize(Context *rsc) { |
Jason Sams | 807fdc4 | 2012-07-25 17:55:39 -0700 | [diff] [blame] | 217 | float *f = static_cast<float *>(rsc->mHal.funcs.allocation.lock1D(rsc, mDefaultAlloc.get())); |
Alex Sakhartchouk | e7ae69f | 2010-09-14 09:50:43 -0700 | [diff] [blame] | 218 | |
Alex Sakhartchouk | a74a8f6 | 2011-11-16 12:22:10 -0800 | [diff] [blame] | 219 | float surfaceWidth = (float)rsc->getCurrentSurfaceWidth(); |
| 220 | float surfaceHeight = (float)rsc->getCurrentSurfaceHeight(); |
| 221 | |
Jason Sams | 87fe59a | 2011-04-20 15:09:01 -0700 | [diff] [blame] | 222 | Matrix4x4 m; |
Alex Sakhartchouk | a74a8f6 | 2011-11-16 12:22:10 -0800 | [diff] [blame] | 223 | m.loadOrtho(0, surfaceWidth, surfaceHeight, 0, -1, 1); |
Alex Sakhartchouk | e7ae69f | 2010-09-14 09:50:43 -0700 | [diff] [blame] | 224 | memcpy(&f[RS_PROGRAM_VERTEX_PROJECTION_OFFSET], m.m, sizeof(m)); |
| 225 | memcpy(&f[RS_PROGRAM_VERTEX_MVP_OFFSET], m.m, sizeof(m)); |
Jason Sams | 8ce125b | 2009-06-17 16:52:59 -0700 | [diff] [blame] | 226 | |
| 227 | m.loadIdentity(); |
Alex Sakhartchouk | e7ae69f | 2010-09-14 09:50:43 -0700 | [diff] [blame] | 228 | memcpy(&f[RS_PROGRAM_VERTEX_MODELVIEW_OFFSET], m.m, sizeof(m)); |
| 229 | memcpy(&f[RS_PROGRAM_VERTEX_TEXTURE_OFFSET], m.m, sizeof(m)); |
Jason Sams | 807fdc4 | 2012-07-25 17:55:39 -0700 | [diff] [blame] | 230 | rsc->mHal.funcs.allocation.unlock1D(rsc, mDefaultAlloc.get()); |
Jason Sams | 8ce125b | 2009-06-17 16:52:59 -0700 | [diff] [blame] | 231 | } |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 232 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 233 | void ProgramVertexState::deinit(Context *rsc) { |
Jason Sams | f2649a9 | 2009-09-25 16:37:33 -0700 | [diff] [blame] | 234 | mDefaultAlloc.clear(); |
| 235 | mDefault.clear(); |
Jason Sams | f2649a9 | 2009-09-25 16:37:33 -0700 | [diff] [blame] | 236 | mLast.clear(); |
Jason Sams | f2649a9 | 2009-09-25 16:37:33 -0700 | [diff] [blame] | 237 | } |
| 238 | |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 239 | |
| 240 | namespace android { |
| 241 | namespace renderscript { |
| 242 | |
Alex Sakhartchouk | 748eb07 | 2012-02-15 16:21:46 -0800 | [diff] [blame] | 243 | RsProgramVertex rsi_ProgramVertexCreate(Context *rsc, const char * shaderText, size_t shaderLength, |
| 244 | const char** textureNames, size_t textureNamesCount, |
| 245 | const size_t *textureNamesLength, |
Ian Rogers | f8852d0 | 2014-01-29 15:35:17 -0800 | [diff] [blame] | 246 | const uintptr_t * params, size_t paramLength) { |
Alex Sakhartchouk | 748eb07 | 2012-02-15 16:21:46 -0800 | [diff] [blame] | 247 | ProgramVertex *pv = new ProgramVertex(rsc, shaderText, shaderLength, |
| 248 | textureNames, textureNamesCount, textureNamesLength, |
| 249 | params, paramLength); |
Jason Sams | 4815c0d | 2009-12-15 12:58:36 -0800 | [diff] [blame] | 250 | pv->incUserRef(); |
| 251 | return pv; |
Jason Sams | b5909ce | 2009-07-21 12:20:54 -0700 | [diff] [blame] | 252 | } |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 253 | |
Rahul Chaudhry | 7974fc0 | 2017-02-09 12:33:28 -0800 | [diff] [blame] | 254 | } // namespace renderscript |
| 255 | } // namespace android |