rsScriptC.cpp revision a0a1b6fbece2eb8d72d788422ab3e5f58d5a9216
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 "rsScriptC.h" 19#include "rsMatrix.h" 20 21#include "acc/acc.h" 22 23using namespace android; 24using namespace android::renderscript; 25 26 27ScriptC::ScriptC() 28{ 29 mAccScript = NULL; 30 memset(&mProgram, 0, sizeof(mProgram)); 31} 32 33ScriptC::~ScriptC() 34{ 35 if (mAccScript) { 36 accDeleteScript(mAccScript); 37 } 38} 39 40extern "C" void matrixLoadIdentity(void *con, rsc_Matrix *mat) 41{ 42 Matrix *m = reinterpret_cast<Matrix *>(mat); 43 m->loadIdentity(); 44} 45 46extern "C" void matrixLoadFloat(void *con, rsc_Matrix *mat, const float *f) 47{ 48 Matrix *m = reinterpret_cast<Matrix *>(mat); 49 m->load(f); 50} 51 52extern "C" void matrixLoadMat(void *con, rsc_Matrix *mat, const rsc_Matrix *newmat) 53{ 54 Matrix *m = reinterpret_cast<Matrix *>(mat); 55 m->load(reinterpret_cast<const Matrix *>(newmat)); 56} 57 58extern "C" void matrixLoadRotate(void *con, rsc_Matrix *mat, float rot, float x, float y, float z) 59{ 60 Matrix *m = reinterpret_cast<Matrix *>(mat); 61 m->loadRotate(rot, x, y, z); 62} 63 64extern "C" void matrixLoadScale(void *con, rsc_Matrix *mat, float x, float y, float z) 65{ 66 Matrix *m = reinterpret_cast<Matrix *>(mat); 67 m->loadScale(x, y, z); 68} 69 70extern "C" void matrixLoadTranslate(void *con, rsc_Matrix *mat, float x, float y, float z) 71{ 72 Matrix *m = reinterpret_cast<Matrix *>(mat); 73 m->loadTranslate(x, y, z); 74} 75 76extern "C" void matrixLoadMultiply(void *con, rsc_Matrix *mat, const rsc_Matrix *lhs, const rsc_Matrix *rhs) 77{ 78 Matrix *m = reinterpret_cast<Matrix *>(mat); 79 m->loadMultiply(reinterpret_cast<const Matrix *>(lhs), 80 reinterpret_cast<const Matrix *>(rhs)); 81} 82 83extern "C" void matrixMultiply(void *con, rsc_Matrix *mat, const rsc_Matrix *rhs) 84{ 85 Matrix *m = reinterpret_cast<Matrix *>(mat); 86 m->multiply(reinterpret_cast<const Matrix *>(rhs)); 87} 88 89extern "C" void matrixRotate(void *con, rsc_Matrix *mat, float rot, float x, float y, float z) 90{ 91 Matrix *m = reinterpret_cast<Matrix *>(mat); 92 m->rotate(rot, x, y, z); 93} 94 95extern "C" void matrixScale(void *con, rsc_Matrix *mat, float x, float y, float z) 96{ 97 Matrix *m = reinterpret_cast<Matrix *>(mat); 98 m->scale(x, y, z); 99} 100 101extern "C" void matrixTranslate(void *con, rsc_Matrix *mat, float x, float y, float z) 102{ 103 Matrix *m = reinterpret_cast<Matrix *>(mat); 104 m->translate(x, y, z); 105} 106 107 108extern "C" const void * loadVp(void *vp, uint32_t bank, uint32_t offset) 109{ 110 ScriptC::Env * env = static_cast<ScriptC::Env *>(vp); 111 return &static_cast<const uint8_t *>(env->mScript->mSlots[bank]->getPtr())[offset]; 112} 113 114extern "C" float loadF(void *vp, uint32_t bank, uint32_t offset) 115{ 116 ScriptC::Env * env = static_cast<ScriptC::Env *>(vp); 117 //LOGE("bank %i, offset %i", bank, offset); 118 //LOGE("%p", env->mScript->mSlots[bank]->getPtr()); 119 return static_cast<const float *>(env->mScript->mSlots[bank]->getPtr())[offset]; 120} 121 122extern "C" int32_t loadI32(void *vp, uint32_t bank, uint32_t offset) 123{ 124 ScriptC::Env * env = static_cast<ScriptC::Env *>(vp); 125 return static_cast<const int32_t *>(env->mScript->mSlots[bank]->getPtr())[offset]; 126} 127 128extern "C" uint32_t loadU32(void *vp, uint32_t bank, uint32_t offset) 129{ 130 ScriptC::Env * env = static_cast<ScriptC::Env *>(vp); 131 return static_cast<const uint32_t *>(env->mScript->mSlots[bank]->getPtr())[offset]; 132} 133 134extern "C" void loadEnvVec4(void *vp, uint32_t bank, uint32_t offset, rsc_Vector4 *v) 135{ 136 ScriptC::Env * env = static_cast<ScriptC::Env *>(vp); 137 memcpy(v, &static_cast<const float *>(env->mScript->mSlots[bank]->getPtr())[offset], sizeof(rsc_Vector4)); 138} 139 140extern "C" void loadEnvMatrix(void *vp, uint32_t bank, uint32_t offset, rsc_Matrix *m) 141{ 142 ScriptC::Env * env = static_cast<ScriptC::Env *>(vp); 143 memcpy(m, &static_cast<const float *>(env->mScript->mSlots[bank]->getPtr())[offset], sizeof(rsc_Matrix)); 144} 145 146 147extern "C" void storeF(void *vp, uint32_t bank, uint32_t offset, float v) 148{ 149 ScriptC::Env * env = static_cast<ScriptC::Env *>(vp); 150 static_cast<float *>(env->mScript->mSlots[bank]->getPtr())[offset] = v; 151} 152 153extern "C" void storeI32(void *vp, uint32_t bank, uint32_t offset, int32_t v) 154{ 155 ScriptC::Env * env = static_cast<ScriptC::Env *>(vp); 156 static_cast<int32_t *>(env->mScript->mSlots[bank]->getPtr())[offset] = v; 157} 158 159extern "C" void storeU32(void *vp, uint32_t bank, uint32_t offset, uint32_t v) 160{ 161 ScriptC::Env * env = static_cast<ScriptC::Env *>(vp); 162 static_cast<uint32_t *>(env->mScript->mSlots[bank]->getPtr())[offset] = v; 163} 164 165extern "C" void storeEnvVec4(void *vp, uint32_t bank, uint32_t offset, const rsc_Vector4 *v) 166{ 167 ScriptC::Env * env = static_cast<ScriptC::Env *>(vp); 168 memcpy(&static_cast<float *>(env->mScript->mSlots[bank]->getPtr())[offset], v, sizeof(rsc_Vector4)); 169} 170 171extern "C" void storeEnvMatrix(void *vp, uint32_t bank, uint32_t offset, const rsc_Matrix *m) 172{ 173 ScriptC::Env * env = static_cast<ScriptC::Env *>(vp); 174 memcpy(&static_cast<float *>(env->mScript->mSlots[bank]->getPtr())[offset], m, sizeof(rsc_Matrix)); 175} 176 177 178extern "C" void color(void *vp, float r, float g, float b, float a) 179{ 180 ScriptC::Env * env = static_cast<ScriptC::Env *>(vp); 181 glColor4f(r, g, b, a); 182} 183 184extern "C" void renderTriangleMesh(void *vp, RsTriangleMesh mesh) 185{ 186 ScriptC::Env * env = static_cast<ScriptC::Env *>(vp); 187 rsi_TriangleMeshRender(env->mContext, mesh); 188} 189 190extern "C" void renderTriangleMeshRange(void *vp, RsTriangleMesh mesh, uint32_t start, uint32_t count) 191{ 192 ScriptC::Env * env = static_cast<ScriptC::Env *>(vp); 193 rsi_TriangleMeshRenderRange(env->mContext, mesh, start, count); 194} 195 196extern "C" void materialDiffuse(void *vp, float r, float g, float b, float a) 197{ 198 ScriptC::Env * env = static_cast<ScriptC::Env *>(vp); 199 float v[] = {r, g, b, a}; 200 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, v); 201} 202 203extern "C" void materialSpecular(void *vp, float r, float g, float b, float a) 204{ 205 ScriptC::Env * env = static_cast<ScriptC::Env *>(vp); 206 float v[] = {r, g, b, a}; 207 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, v); 208} 209 210extern "C" void lightPosition(void *vp, float x, float y, float z, float w) 211{ 212 ScriptC::Env * env = static_cast<ScriptC::Env *>(vp); 213 float v[] = {x, y, z, w}; 214 glLightfv(GL_LIGHT0, GL_POSITION, v); 215} 216 217extern "C" void materialShininess(void *vp, float s) 218{ 219 ScriptC::Env * env = static_cast<ScriptC::Env *>(vp); 220 glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, &s); 221} 222 223extern "C" void uploadToTexture(void *vp, RsAllocation va, uint32_t baseMipLevel) 224{ 225 ScriptC::Env * env = static_cast<ScriptC::Env *>(vp); 226 rsi_AllocationUploadToTexture(env->mContext, va, baseMipLevel); 227} 228 229extern "C" void enable(void *vp, uint32_t p) 230{ 231 ScriptC::Env * env = static_cast<ScriptC::Env *>(vp); 232 glEnable(p); 233} 234 235extern "C" void disable(void *vp, uint32_t p) 236{ 237 ScriptC::Env * env = static_cast<ScriptC::Env *>(vp); 238 glDisable(p); 239} 240 241extern "C" uint32_t scriptRand(void *vp, uint32_t max) 242{ 243 return (uint32_t)(((float)rand()) * max / RAND_MAX); 244} 245 246// Assumes (GL_FIXED) x,y,z (GL_UNSIGNED_BYTE)r,g,b,a 247extern "C" void drawTriangleArray(void *vp, RsAllocation alloc, uint32_t count) 248{ 249 const Allocation *a = (const Allocation *)alloc; 250 const uint32_t *ptr = (const uint32_t *)a->getPtr(); 251 252 ScriptC::Env * env = static_cast<ScriptC::Env *>(vp); 253 env->mContext->setupCheck(); 254 255 glBindBuffer(GL_ARRAY_BUFFER, 0); 256 //glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, tm->mBufferObjects[1]); 257 258 glEnableClientState(GL_VERTEX_ARRAY); 259 glDisableClientState(GL_NORMAL_ARRAY); 260 glDisableClientState(GL_TEXTURE_COORD_ARRAY); 261 glEnableClientState(GL_COLOR_ARRAY); 262 263 glVertexPointer(2, GL_FIXED, 12, ptr + 1); 264 //glTexCoordPointer(2, GL_FIXED, 24, ptr + 1); 265 glColorPointer(4, GL_UNSIGNED_BYTE, 12, ptr); 266 267 glDrawArrays(GL_TRIANGLES, 0, count * 3); 268} 269 270extern "C" void drawRect(void *vp, int32_t x1, int32_t x2, int32_t y1, int32_t y2) 271{ 272 x1 = (x1 << 16); 273 x2 = (x2 << 16); 274 y1 = (y1 << 16); 275 y2 = (y2 << 16); 276 277 int32_t vtx[] = {x1,y1, x1,y2, x2,y1, x2,y2}; 278 static const int32_t tex[] = {0,0, 0,0x10000, 0x10000,0, 0x10000,0x10000}; 279 280 281 ScriptC::Env * env = static_cast<ScriptC::Env *>(vp); 282 env->mContext->setupCheck(); 283 284 glBindBuffer(GL_ARRAY_BUFFER, 0); 285 //glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, tm->mBufferObjects[1]); 286 287 glEnableClientState(GL_VERTEX_ARRAY); 288 glEnableClientState(GL_TEXTURE_COORD_ARRAY); 289 glDisableClientState(GL_NORMAL_ARRAY); 290 glDisableClientState(GL_COLOR_ARRAY); 291 292 glVertexPointer(2, GL_FIXED, 8, vtx); 293 glTexCoordPointer(2, GL_FIXED, 8, tex); 294 //glColorPointer(4, GL_UNSIGNED_BYTE, 12, ptr); 295 296 glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); 297} 298 299extern "C" void pfBindTexture(void *vp, RsProgramFragment vpf, uint32_t slot, RsAllocation va) 300{ 301 //LOGE("pfBindTexture %p", vpf); 302 ScriptC::Env * env = static_cast<ScriptC::Env *>(vp); 303 rsi_ProgramFragmentBindTexture(env->mContext, 304 static_cast<ProgramFragment *>(vpf), 305 slot, 306 static_cast<Allocation *>(va)); 307 308} 309 310extern "C" void pfBindSampler(void *vp, RsProgramFragment vpf, uint32_t slot, RsSampler vs) 311{ 312 ScriptC::Env * env = static_cast<ScriptC::Env *>(vp); 313 rsi_ProgramFragmentBindSampler(env->mContext, 314 static_cast<ProgramFragment *>(vpf), 315 slot, 316 static_cast<Sampler *>(vs)); 317 318} 319 320extern "C" void contextBindProgramFragmentStore(void *vp, RsProgramFragmentStore pfs) 321{ 322 //LOGE("contextBindProgramFragmentStore %p", pfs); 323 ScriptC::Env * env = static_cast<ScriptC::Env *>(vp); 324 rsi_ContextBindProgramFragmentStore(env->mContext, pfs); 325 326} 327 328extern "C" void contextBindProgramFragment(void *vp, RsProgramFragment pf) 329{ 330 //LOGE("contextBindProgramFragment %p", pf); 331 ScriptC::Env * env = static_cast<ScriptC::Env *>(vp); 332 rsi_ContextBindProgramFragment(env->mContext, pf); 333 334} 335 336 337static rsc_FunctionTable scriptCPtrTable = { 338 loadVp, 339 loadF, 340 loadI32, 341 loadU32, 342 loadEnvVec4, 343 loadEnvMatrix, 344 345 storeF, 346 storeI32, 347 storeU32, 348 storeEnvVec4, 349 storeEnvMatrix, 350 351 matrixLoadIdentity, 352 matrixLoadFloat, 353 matrixLoadMat, 354 matrixLoadRotate, 355 matrixLoadScale, 356 matrixLoadTranslate, 357 matrixLoadMultiply, 358 matrixMultiply, 359 matrixRotate, 360 matrixScale, 361 matrixTranslate, 362 363 color, 364 365 pfBindTexture, 366 pfBindSampler, 367 368 materialDiffuse, 369 materialSpecular, 370 lightPosition, 371 materialShininess, 372 uploadToTexture, 373 enable, 374 disable, 375 376 scriptRand, 377 contextBindProgramFragment, 378 contextBindProgramFragmentStore, 379 380 381 renderTriangleMesh, 382 renderTriangleMeshRange, 383 384 drawTriangleArray, 385 drawRect 386 387}; 388 389 390bool ScriptC::run(Context *rsc, uint32_t launchID) 391{ 392 Env e = {rsc, this}; 393 394 if (mEnviroment.mFragmentStore.get()) { 395 rsc->setFragmentStore(mEnviroment.mFragmentStore.get()); 396 } 397 if (mEnviroment.mFragment.get()) { 398 rsc->setFragment(mEnviroment.mFragment.get()); 399 } 400 401 return mProgram.mScript(&e, &scriptCPtrTable, launchID) != 0; 402} 403 404ScriptCState::ScriptCState() 405{ 406 clear(); 407} 408 409ScriptCState::~ScriptCState() 410{ 411 if (mAccScript) { 412 accDeleteScript(mAccScript); 413 } 414} 415 416void ScriptCState::clear() 417{ 418 memset(&mProgram, 0, sizeof(mProgram)); 419 420 mConstantBufferTypes.clear(); 421 422 memset(&mEnviroment, 0, sizeof(mEnviroment)); 423 mEnviroment.mClearColor[0] = 0; 424 mEnviroment.mClearColor[1] = 0; 425 mEnviroment.mClearColor[2] = 0; 426 mEnviroment.mClearColor[3] = 1; 427 mEnviroment.mClearDepth = 1; 428 mEnviroment.mClearStencil = 0; 429 mEnviroment.mIsRoot = false; 430 mEnviroment.mIsOrtho = true; 431 432 mAccScript = NULL; 433 434} 435 436void ScriptCState::runCompiler(Context *rsc) 437{ 438 mAccScript = accCreateScript(); 439 440 const char* scriptSource[] = {mProgram.mScriptText}; 441 int scriptLength[] = {mProgram.mScriptTextLength} ; 442 accScriptSource(mAccScript, 1, scriptSource, scriptLength); 443 accCompileScript(mAccScript); 444 accGetScriptLabel(mAccScript, "main", (ACCvoid**) &mProgram.mScript); 445 rsAssert(mProgram.mScript); 446 447 if (mProgram.mScript) { 448 const static int pragmaMax = 16; 449 ACCsizei pragmaCount; 450 ACCchar * str[pragmaMax]; 451 accGetPragmas(mAccScript, &pragmaCount, pragmaMax, &str[0]); 452 453 for (int ct=0; ct < pragmaCount; ct+=2) { 454 LOGE("pragma %i %s %s", ct, str[ct], str[ct+1]); 455 456 if (!strcmp(str[ct], "version")) { 457 continue; 458 459 } 460 461 462 if (!strcmp(str[ct], "stateVertex")) { 463 LOGE("Unreconized value %s passed to stateVertex", str[ct+1]); 464 } 465 466 if (!strcmp(str[ct], "stateRaster")) { 467 LOGE("Unreconized value %s passed to stateRaster", str[ct+1]); 468 } 469 470 if (!strcmp(str[ct], "stateFragment")) { 471 ProgramFragment * pf = 472 (ProgramFragment *)rsc->lookupName(str[ct+1]); 473 if (pf != NULL) { 474 mEnviroment.mFragment.set(pf); 475 continue; 476 } 477 LOGE("Unreconized value %s passed to stateFragment", str[ct+1]); 478 } 479 480 if (!strcmp(str[ct], "stateFragmentStore")) { 481 ProgramFragmentStore * pfs = 482 (ProgramFragmentStore *)rsc->lookupName(str[ct+1]); 483 if (pfs != NULL) { 484 mEnviroment.mFragmentStore.set(pfs); 485 continue; 486 } 487 488 if (!strcmp(str[ct+1], "parent")) { 489 //mEnviroment.mStateFragmentStore = 490 //Script::Enviroment_t::FRAGMENT_STORE_PARENT; 491 continue; 492 } 493 LOGE("Unreconized value %s passed to stateFragmentStore", str[ct+1]); 494 } 495 496 } 497 498 499 } else { 500 // Deal with an error. 501 } 502 503} 504 505namespace android { 506namespace renderscript { 507 508void rsi_ScriptCBegin(Context * rsc) 509{ 510 ScriptCState *ss = &rsc->mScriptC; 511 ss->clear(); 512} 513 514void rsi_ScriptCSetClearColor(Context * rsc, float r, float g, float b, float a) 515{ 516 ScriptCState *ss = &rsc->mScriptC; 517 ss->mEnviroment.mClearColor[0] = r; 518 ss->mEnviroment.mClearColor[1] = g; 519 ss->mEnviroment.mClearColor[2] = b; 520 ss->mEnviroment.mClearColor[3] = a; 521} 522 523void rsi_ScriptCSetClearDepth(Context * rsc, float v) 524{ 525 ScriptCState *ss = &rsc->mScriptC; 526 ss->mEnviroment.mClearDepth = v; 527} 528 529void rsi_ScriptCSetClearStencil(Context * rsc, uint32_t v) 530{ 531 ScriptCState *ss = &rsc->mScriptC; 532 ss->mEnviroment.mClearStencil = v; 533} 534 535void rsi_ScriptCAddType(Context * rsc, RsType vt) 536{ 537 ScriptCState *ss = &rsc->mScriptC; 538 ss->mConstantBufferTypes.add(static_cast<const Type *>(vt)); 539} 540 541void rsi_ScriptCSetScript(Context * rsc, void *vp) 542{ 543 ScriptCState *ss = &rsc->mScriptC; 544 ss->mProgram.mScript = reinterpret_cast<rsc_RunScript>(vp); 545} 546 547void rsi_ScriptCSetRoot(Context * rsc, bool isRoot) 548{ 549 ScriptCState *ss = &rsc->mScriptC; 550 ss->mEnviroment.mIsRoot = isRoot; 551} 552 553void rsi_ScriptCSetOrtho(Context * rsc, bool isOrtho) 554{ 555 ScriptCState *ss = &rsc->mScriptC; 556 ss->mEnviroment.mIsOrtho = isOrtho; 557} 558 559void rsi_ScriptCSetText(Context *rsc, const char *text, uint32_t len) 560{ 561 ScriptCState *ss = &rsc->mScriptC; 562 ss->mProgram.mScriptText = text; 563 ss->mProgram.mScriptTextLength = len; 564} 565 566 567RsScript rsi_ScriptCCreate(Context * rsc) 568{ 569 ScriptCState *ss = &rsc->mScriptC; 570 571 ss->runCompiler(rsc); 572 573 ScriptC *s = new ScriptC(); 574 s->incRef(); 575 s->mAccScript = ss->mAccScript; 576 ss->mAccScript = NULL; 577 s->mEnviroment = ss->mEnviroment; 578 s->mProgram = ss->mProgram; 579 ss->clear(); 580 581 return s; 582} 583 584} 585} 586 587 588