diff options
Diffstat (limited to 'libs/rs/java')
28 files changed, 3291 insertions, 0 deletions
diff --git a/libs/rs/java/Android.mk b/libs/rs/java/Android.mk new file mode 100644 index 0000000..5053e7d --- /dev/null +++ b/libs/rs/java/Android.mk @@ -0,0 +1 @@ +include $(call all-subdir-makefiles) diff --git a/libs/rs/java/Film/Android.mk b/libs/rs/java/Film/Android.mk new file mode 100644 index 0000000..2e9c243 --- /dev/null +++ b/libs/rs/java/Film/Android.mk @@ -0,0 +1,25 @@ +# +# Copyright (C) 2008 The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +LOCAL_PATH := $(call my-dir) +include $(CLEAR_VARS) + +LOCAL_SRC_FILES := $(call all-java-files-under, src) +LOCAL_STATIC_JAVA_LIBRARIES := android.renderscript + +LOCAL_PACKAGE_NAME := Film + +include $(BUILD_PACKAGE) diff --git a/libs/rs/java/Film/AndroidManifest.xml b/libs/rs/java/Film/AndroidManifest.xml new file mode 100644 index 0000000..a5ce8a1 --- /dev/null +++ b/libs/rs/java/Film/AndroidManifest.xml @@ -0,0 +1,14 @@ +<?xml version="1.0" encoding="utf-8"?> +<manifest xmlns:android="http://schemas.android.com/apk/res/android" + package="com.android.film"> + <application android:label="Film"> + <activity android:name="Film" + android:screenOrientation="portrait" + android:theme="@android:style/Theme.Black.NoTitleBar"> + <intent-filter> + <action android:name="android.intent.action.MAIN" /> + <category android:name="android.intent.category.LAUNCHER" /> + </intent-filter> + </activity> + </application> +</manifest> diff --git a/libs/rs/java/Film/res/raw/filmimage.c b/libs/rs/java/Film/res/raw/filmimage.c new file mode 100644 index 0000000..3bd9496 --- /dev/null +++ b/libs/rs/java/Film/res/raw/filmimage.c @@ -0,0 +1,110 @@ +// Fountain test script + +#pragma version(1) +#pragma stateVertex(orthoWindow) +#pragma stateRaster(flat) +#pragma stateFragment(PgmFragBackground) +#pragma stateFragmentStore(MyBlend) + + +int main(void* con, int ft, int launchID) { + int count, touch, x, y, rate, maxLife, lifeShift; + int life; + int ct, ct2; + int newPart; + int drawCount; + int dx, dy, idx; + int posx,posy; + int c; + int srcIdx; + int dstIdx; + + count = loadI32(con, 0, 1); + touch = loadI32(con, 0, 2); + x = loadI32(con, 0, 3); + y = loadI32(con, 0, 4); + + rate = 4; + maxLife = (count / rate) - 1; + lifeShift = 0; + { + life = maxLife; + while (life > 255) { + life = life >> 1; + lifeShift ++; + } + } + + drawRect(con, 0, 256, 0, 512); + contextBindProgramFragment(con, NAMED_PgmFragParts); + + if (touch) { + newPart = loadI32(con, 2, 0); + for (ct2=0; ct2<rate; ct2++) { + dx = scriptRand(con, 0x10000) - 0x8000; + dy = scriptRand(con, 0x10000) - 0x8000; + + idx = newPart * 5 + 1; + storeI32(con, 2, idx, dx); + storeI32(con, 2, idx + 1, dy); + storeI32(con, 2, idx + 2, maxLife); + storeI32(con, 2, idx + 3, x << 16); + storeI32(con, 2, idx + 4, y << 16); + + newPart++; + if (newPart >= count) { + newPart = 0; + } + } + storeI32(con, 2, 0, newPart); + } + + drawCount = 0; + for (ct=0; ct < count; ct++) { + srcIdx = ct * 5 + 1; + + dx = loadI32(con, 2, srcIdx); + dy = loadI32(con, 2, srcIdx + 1); + life = loadI32(con, 2, srcIdx + 2); + posx = loadI32(con, 2, srcIdx + 3); + posy = loadI32(con, 2, srcIdx + 4); + + if (life) { + if (posy < (480 << 16)) { + dstIdx = drawCount * 9; + c = 0xffafcf | ((life >> lifeShift) << 24); + + storeU32(con, 1, dstIdx, c); + storeI32(con, 1, dstIdx + 1, posx); + storeI32(con, 1, dstIdx + 2, posy); + + storeU32(con, 1, dstIdx + 3, c); + storeI32(con, 1, dstIdx + 4, posx + 0x10000); + storeI32(con, 1, dstIdx + 5, posy + dy * 4); + + storeU32(con, 1, dstIdx + 6, c); + storeI32(con, 1, dstIdx + 7, posx - 0x10000); + storeI32(con, 1, dstIdx + 8, posy + dy * 4); + drawCount ++; + } else { + if (dy > 0) { + dy = (-dy) >> 1; + } + } + + posx = posx + dx; + posy = posy + dy; + dy = dy + 0x400; + life --; + + //storeI32(con, 2, srcIdx, dx); + storeI32(con, 2, srcIdx + 1, dy); + storeI32(con, 2, srcIdx + 2, life); + storeI32(con, 2, srcIdx + 3, posx); + storeI32(con, 2, srcIdx + 4, posy); + } + } + + drawTriangleArray(con, NAMED_PartBuffer, drawCount); + return 1; +} diff --git a/libs/rs/java/Film/res/raw/filmstrip.c b/libs/rs/java/Film/res/raw/filmstrip.c new file mode 100644 index 0000000..a3b3d90 --- /dev/null +++ b/libs/rs/java/Film/res/raw/filmstrip.c @@ -0,0 +1,120 @@ +// Fountain test script + +#pragma version(1) +#pragma stateVertex(PV) +#pragma stateFragment(PFBackground) +#pragma stateFragmentStore(PFSBackground) + +/* +typedef struct FilmScriptUserEnvRec { + RsAllocation tex[13]; + int32_t triangleOffsets[64]; + float triangleOffsetsTex[64]; + int32_t triangleOffsetsCount; +} FilmScriptUserEnv; +*/ + +// The script enviroment has 3 env allocations. +// bank0: (r) The enviroment structure +// bank1: (r) The position information +// bank2: (rw) The temporary texture state + +int main(int index) +{ + int f1,f2,f3,f4, f5,f6,f7,f8, f9,f10,f11,f12, f13,f14,f15,f16; + int g1,g2,g3,g4, g5,g6,g7,g8, g9,g10,g11,g12, g13,g14,g15,g16; + int float_1; + int float_0; + int float_2; + int float_90; + int float_0_5; + int trans; // float + int rot; // float + int x; + + float_2 = intToFloat(2); + float_1 = intToFloat(1); + float_0 = intToFloat(0); + float_90= intToFloat(90); + float_0_5 = fixedtoFloat(0x8000); + + trans = loadF(1, 0); + rot = loadF(1, 1); + + matrixLoadScale(&f16, float_2, float_2, float_2); + matrixTranslate(&f16, 0, 0, trans); + matrixRotate(&f16, float_90, 0, 0, float_1); + matrixRotate(&f16, rot, float_1, 0, 0); + storeEnvMatrix(3, 0, &f16); + + //materialDiffuse(con, 0.0f, 0.0f, 0.0f, 1.0f); + //materialSpecular(con, 0.5f, 0.5f, 0.5f, 0.5f); + //materialShininess(intToFloat(20)); + //lightPosition(con, 0.2f, -0.2f, -2.0f, 0.0f); + //enable(con, GL_LIGHTING); + renderTriangleMesh(NAMED_mesh); + + + + //int imgId = 0; + +/* + contextBindProgramFragmentStore(env->fsImages); + contextBindProgramFragment(env->fpImages); + disable(GL_LIGHTING); + + float focusPos = loadEnvF(1, 2); + int focusID = 0; + int lastFocusID = loadEnvI32(2, 0); + int imgCount = 13; + + if (trans > (-.3)) { + focusID = -1.0 - focusPos; + if (focusID >= imgCount) { + focusID = -1; + } + } else { + focusID = -1; + } + + if (focusID != lastFocusID) { + if (lastFocusID >= 0) { + uploadToTexture(con, env->tex[lastFocusID], 1); + } + if (focusID >= 0) { + uploadToTexture(con, env->tex[focusID], 0); + } + } + storeEnvI32(con, 2, 0, focusID); + + + for (imgId=1; imgId <= imgCount; imgId++) { + float pos = focusPos + imgId + .4f; + int offset = (int)floor(pos*2); + pos -= 0.75; + + offset += env->triangleOffsetsCount / 2; + + if ((offset < 0) || (offset >= env->triangleOffsetsCount)) { + continue; + } + + int start = offset -2; + int end = offset + 2; + + if (start < 0) { + start = 0; + } + if (end > env->triangleOffsetsCount) { + end = env->triangleOffsetsCount; + } + + programFragmentBindTexture(con, env->fpImages, 0, env->tex[imgId - 1]); + matrixLoadTranslate(con, &m, -pos - env->triangleOffsetsTex[env->triangleOffsetsCount / 2], 0, 0); + storeEnvMatrix(con, 3, RS_PROGRAM_VERTEX_TEXTURE_OFFSET, &m); + renderTriangleMeshRange(con, env->mesh, env->triangleOffsets[start], env->triangleOffsets[end] - env->triangleOffsets[start]); + } +*/ + return 0; +} + diff --git a/libs/rs/java/Film/src/com/android/film/Film.java b/libs/rs/java/Film/src/com/android/film/Film.java new file mode 100644 index 0000000..6e99816 --- /dev/null +++ b/libs/rs/java/Film/src/com/android/film/Film.java @@ -0,0 +1,90 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.film; + +import android.renderscript.RSSurfaceView; +import android.renderscript.RenderScript; + +import android.app.Activity; +import android.content.res.Configuration; +import android.os.Bundle; +import android.os.Handler; +import android.os.Looper; +import android.os.Message; +import android.provider.Settings.System; +import android.util.Config; +import android.util.Log; +import android.view.Menu; +import android.view.MenuItem; +import android.view.View; +import android.view.Window; +import android.widget.Button; +import android.widget.ListView; + +import java.lang.Runtime; + +public class Film extends Activity { + //EventListener mListener = new EventListener(); + + private static final String LOG_TAG = "libRS_jni"; + private static final boolean DEBUG = false; + private static final boolean LOG_ENABLED = DEBUG ? Config.LOGD : Config.LOGV; + + private FilmView mView; + + // get the current looper (from your Activity UI thread for instance + + + + @Override + public void onCreate(Bundle icicle) { + super.onCreate(icicle); + + // Create our Preview view and set it as the content of our + // Activity + mView = new FilmView(this); + setContentView(mView); + } + + @Override + protected void onResume() { + // Ideally a game should implement onResume() and onPause() + // to take appropriate action when the activity looses focus + super.onResume(); + mView.onResume(); + } + + @Override + protected void onPause() { + // Ideally a game should implement onResume() and onPause() + // to take appropriate action when the activity looses focus + super.onPause(); + mView.onPause(); + + Runtime.getRuntime().exit(0); + } + + + static void log(String message) { + if (LOG_ENABLED) { + Log.v(LOG_TAG, message); + } + } + + +} + diff --git a/libs/rs/java/Film/src/com/android/film/FilmRS.java b/libs/rs/java/Film/src/com/android/film/FilmRS.java new file mode 100644 index 0000000..2711bf0 --- /dev/null +++ b/libs/rs/java/Film/src/com/android/film/FilmRS.java @@ -0,0 +1,234 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.film; + +import java.io.Writer; + +import android.renderscript.RenderScript; +import android.renderscript.ProgramVertexAlloc; +import android.renderscript.Matrix; + +import android.content.Context; +import android.content.res.Resources; +import android.graphics.Bitmap; +import android.graphics.drawable.BitmapDrawable; +import android.graphics.drawable.Drawable; +import android.os.Handler; +import android.os.Message; +import android.util.AttributeSet; +import android.util.Log; +import android.view.Surface; +import android.view.SurfaceHolder; +import android.view.SurfaceView; +import android.view.KeyEvent; +import android.view.MotionEvent; + +public class FilmRS { + + public FilmRS() { + } + + public void init(RenderScript rs, Resources res, int width, int height) { + mRS = rs; + mRes = res; + initNamed(); + initRS(); + } + + public void setFilmStripPosition(int x, int y) + { + if (x < 50) { + x = 50; + } + if (x > 270) { + x = 270; + } + + float anim = ((float)x-50) / 270.f; + mBufferPos[0] = 2f * anim + 0.5f; // translation + mBufferPos[1] = (anim * 40); // rotation + mBufferPos[2] = ((float)y) / 16.f - 8; // focusPos + mAllocPos.data(mBufferPos); + } + + + private Resources mRes; + private RenderScript mRS; + private RenderScript.Script mScriptStrip; + private RenderScript.Script mScriptImage; + private RenderScript.Element mElementVertex; + private RenderScript.Element mElementIndex; + private RenderScript.Sampler mSampler; + private RenderScript.ProgramFragmentStore mPFSBackground; + private RenderScript.ProgramFragmentStore mPFSImages; + private RenderScript.ProgramFragment mPFBackground; + private RenderScript.ProgramFragment mPFImages; + private RenderScript.ProgramVertex mPV; + private ProgramVertexAlloc mPVA; + + private RenderScript.Allocation mAllocEnv; + private RenderScript.Allocation mAllocPos; + private RenderScript.Allocation mAllocState; + private RenderScript.Allocation mAllocPV; + private RenderScript.TriangleMesh mMesh; + private RenderScript.Light mLight; + + private float[] mBufferPos; + private float[] mBufferPV; + + private void initNamed() { + mElementVertex = mRS.elementGetPredefined( + RenderScript.ElementPredefined.NORM_ST_XYZ_F32); + mElementIndex = mRS.elementGetPredefined( + RenderScript.ElementPredefined.INDEX_16); + + mRS.triangleMeshBegin(mElementVertex, mElementIndex); + FilmStripMesh fsm = new FilmStripMesh(); + fsm.init(mRS); + mMesh = mRS.triangleMeshCreate(); + mMesh.setName("mesh"); + Log.e("rs", "Done loading strips"); + + + mRS.samplerBegin(); + mRS.samplerSet(RenderScript.SamplerParam.FILTER_MIN, + RenderScript.SamplerValue.LINEAR_MIP_LINEAR); + mRS.samplerSet(RenderScript.SamplerParam.WRAP_MODE_S, + RenderScript.SamplerValue.CLAMP); + mRS.samplerSet(RenderScript.SamplerParam.WRAP_MODE_T, + RenderScript.SamplerValue.CLAMP); + mSampler = mRS.samplerCreate(); + + mRS.programFragmentBegin(null, null); + mPFBackground = mRS.programFragmentCreate(); + mPFBackground.setName("PFBackground"); + + mRS.programFragmentBegin(null, null); + mRS.programFragmentSetTexEnable(0, true); + //mRS.programFragmentSetEnvMode(0, RS_TEX_ENV_MODE_REPLACE); + //rsProgramFragmentSetType(0, gEnv.tex[0]->getType()); + mPFImages = mRS.programFragmentCreate(); + mPFImages.setName("PFImages"); + mPFImages.bindSampler(mSampler, 0); + + mRS.programFragmentStoreBegin(null, null); + mRS.programFragmentStoreDepthFunc(RenderScript.DepthFunc.LESS); + mRS.programFragmentStoreDitherEnable(true); + mPFSBackground = mRS.programFragmentStoreCreate(); + mPFSBackground.setName("PFSBackground"); + + mRS.programFragmentStoreBegin(null, null); + mRS.programFragmentStoreDepthFunc(RenderScript.DepthFunc.EQUAL); + mRS.programFragmentStoreDitherEnable(false); + mRS.programFragmentStoreDepthMask(false); + mRS.programFragmentStoreBlendFunc(RenderScript.BlendSrcFunc.ONE, + RenderScript.BlendDstFunc.ONE); + mPFSImages = mRS.programFragmentStoreCreate(); + mPFSImages.setName("PFSImages"); + + mRS.programVertexBegin(null, null); + mRS.programVertexSetTextureMatrixEnable(true); + mPV = mRS.programVertexCreate(); + mPV.setName("PV"); + + mRS.lightBegin(); + mLight = mRS.lightCreate(); + mLight.setPosition(0, -0.5f, -1.0f); + + Log.e("rs", "Done loading named"); + } + + + private Bitmap mBackground; + + int mParams[] = new int[10]; + + private void initRS() { + int partCount = 1024; + + mRS.scriptCBegin(); + mRS.scriptCSetClearColor(0.0f, 0.0f, 0.0f, 1.0f); + mRS.scriptCSetScript(mRes, R.raw.filmstrip); + mRS.scriptCSetRoot(true); + mScriptStrip = mRS.scriptCCreate(); + + mBufferPos = new float[3]; + mAllocPos = mRS.allocationCreatePredefSized( + RenderScript.ElementPredefined.USER_FLOAT, + mBufferPos.length); + + mPVA = new ProgramVertexAlloc(mRS); + mPV.bindAllocation(0, mPVA.mAlloc); + mPVA.setupProjectionNormalized(320, 480); + + + mScriptStrip.bindAllocation(mAllocPos, 1); + //mScriptStrip.bindAllocation(gStateAlloc, 2); + mScriptStrip.bindAllocation(mPVA.mAlloc, 3); + + + //mIntAlloc = mRS.allocationCreatePredefSized(RenderScript.ElementPredefined.USER_I32, 10); + //mPartAlloc = mRS.allocationCreatePredefSized(RenderScript.ElementPredefined.USER_I32, partCount * 3 * 3); + //mPartAlloc.setName("PartBuffer"); + //mVertAlloc = mRS.allocationCreatePredefSized(RenderScript.ElementPredefined.USER_I32, partCount * 5 + 1); +/* + { + Resources res = getResources(); + Drawable d = res.getDrawable(R.drawable.gadgets_clock_mp3); + BitmapDrawable bd = (BitmapDrawable)d; + Bitmap b = bd.getBitmap(); + mTexture = mRS.allocationCreateFromBitmap(b, + RenderScript.ElementPredefined.RGB_565, + true); + mTexture.uploadToTexture(0); + } + + mRS.programFragmentStoreBegin(null, null); + mRS.programFragmentStoreBlendFunc(RenderScript.BlendSrcFunc.SRC_ALPHA, RenderScript.BlendDstFunc.ONE); + mRS.programFragmentStoreDepthFunc(RenderScript.DepthFunc.ALWAYS); + mPFS = mRS.programFragmentStoreCreate(); + mPFS.setName("MyBlend"); + mRS.contextBindProgramFragmentStore(mPFS); + + mRS.samplerBegin(); + mRS.samplerSet(RenderScript.SamplerParam.FILTER_MAG, RenderScript.SamplerValue.LINEAR); + mRS.samplerSet(RenderScript.SamplerParam.FILTER_MIN, RenderScript.SamplerValue.LINEAR); + mSampler = mRS.samplerCreate(); + + + mParams[0] = 0; + mParams[1] = partCount; + mParams[2] = 0; + mParams[3] = 0; + mParams[4] = 0; + mIntAlloc.data(mParams); + + int t2[] = new int[partCount * 4*3]; + for (int ct=0; ct < t2.length; ct++) { + t2[ct] = 0; + } + mPartAlloc.data(t2); + */ + + setFilmStripPosition(0, 0); + + mRS.contextBindRootScript(mScriptStrip); + } +} + + + diff --git a/libs/rs/java/Film/src/com/android/film/FilmStripMesh.java b/libs/rs/java/Film/src/com/android/film/FilmStripMesh.java new file mode 100644 index 0000000..02bffd8 --- /dev/null +++ b/libs/rs/java/Film/src/com/android/film/FilmStripMesh.java @@ -0,0 +1,255 @@ +/* + * Copyright (C) 2009 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +package com.android.film; + +import java.io.Writer; +import java.lang.Math; +import android.util.Log; + +import android.renderscript.RenderScript; + + +class FilmStripMesh { + + class Vertex { + float nx; + float ny; + float nz; + float s; + float t; + float x; + float y; + float z; + + Vertex() { + nx = 0; + ny = 0; + nz = 0; + s = 0; + t = 0; + x = 0; + y = 0; + z = 0; + } + + void xyz(float _x, float _y, float _z) { + x = _x; + y = _y; + z = _z; + } + + void nxyz(float _x, float _y, float _z) { + nx = _x; + ny = _y; + nz = _z; + } + + void st(float _s, float _t) { + s = _s; + t = _t; + } + + void computeNorm(Vertex v1, Vertex v2) { + float dx = v1.x - v2.x; + float dy = v1.y - v2.y; + float dz = v1.z - v2.z; + float len = (float)java.lang.Math.sqrt(dx*dx + dy*dy + dz*dz); + dx /= len; + dy /= len; + dz /= len; + + nx = dx * dz; + ny = dy * dz; + nz = (float)java.lang.Math.sqrt(dx*dx + dy*dy); + + len = (float)java.lang.Math.sqrt(nx*nx + ny*ny + nz*nz); + nx /= len; + ny /= len; + nz /= len; + } + + void addToRS(RenderScript rs) { + rs.triangleMeshAddVertex_XYZ_ST_NORM(x, y, z, s, t, nx, ny, nz); + } + } + + int[] mTriangleOffsets; + float[] mTriangleOffsetsTex; + int mTriangleOffsetsCount; + + void init(RenderScript rs) + { + float vtx[] = new float[] { + 60.431003f, 124.482050f, + 60.862074f, 120.872604f, + 61.705303f, 117.336662f, + 62.949505f, 113.921127f, + 64.578177f, 110.671304f, + 66.569716f, 107.630302f, + 68.897703f, 104.838457f, + 71.531259f, 102.332803f, + 74.435452f, 100.146577f, + 77.571757f, 98.308777f, + 80.898574f, 96.843781f, + 84.371773f, 95.771023f, + 87.945283f, 95.104731f, + 98.958994f, 95.267098f, + 109.489523f, 98.497596f, + 118.699582f, 104.539366f, + 125.856872f, 112.912022f, + 130.392311f, 122.949849f, + 131.945283f, 133.854731f, + 130.392311f, 144.759613f, + 125.856872f, 154.797439f, + 118.699582f, 163.170096f, + 109.489523f, 169.211866f, + 98.958994f, 172.442364f, + 87.945283f, 172.604731f, + 72.507313f, 172.672927f, + 57.678920f, 168.377071f, + 44.668135f, 160.067134f, + 34.534908f, 148.420104f, + 28.104767f, 134.384831f, + 25.901557f, 119.104731f, + 28.104767f, 103.824631f, + 34.534908f, 89.789358f, + 44.668135f, 78.142327f, + 57.678920f, 69.832390f, + 72.507313f, 65.536534f, + 87.945283f, 65.604731f, + 106.918117f, 65.688542f, + 125.141795f, 60.409056f, + 141.131686f, 50.196376f, + 153.585137f, 35.882502f, + 161.487600f, 18.633545f, + 164.195283f, -0.145269f, + 161.487600f, -18.924084f, + 153.585137f, -36.173040f, + 141.131686f, -50.486914f, + 125.141795f, -60.699594f, + 106.918117f, -65.979081f, + 87.945283f, -65.895269f, + 80f, -65.895269f, + 60f, -65.895269f, + 40f, -65.895269f, + 20f, -65.895269f, + 0f, -65.895269f, + -20f, -65.895269f, + -40f, -65.895269f, + -60f, -65.895269f, + -80f, -65.895269f, + -87.945283f, -65.895269f, + -106.918117f, -65.979081f, + -125.141795f, -60.699594f, + -141.131686f, -50.486914f, + -153.585137f, -36.173040f, + -161.487600f, -18.924084f, + -164.195283f, -0.145269f, + -161.487600f, 18.633545f, + -153.585137f, 35.882502f, + -141.131686f, 50.196376f, + -125.141795f, 60.409056f, + -106.918117f, 65.688542f, + -87.945283f, 65.604731f, + -72.507313f, 65.536534f, + -57.678920f, 69.832390f, + -44.668135f, 78.142327f, + -34.534908f, 89.789358f, + -28.104767f, 103.824631f, + -25.901557f, 119.104731f, + -28.104767f, 134.384831f, + -34.534908f, 148.420104f, + -44.668135f, 160.067134f, + -57.678920f, 168.377071f, + -72.507313f, 172.672927f, + -87.945283f, 172.604731f, + -98.958994f, 172.442364f, + -109.489523f, 169.211866f, + -118.699582f, 163.170096f, + -125.856872f, 154.797439f, + -130.392311f, 144.759613f, + -131.945283f, 133.854731f, + -130.392311f, 122.949849f, + -125.856872f, 112.912022f, + -118.699582f, 104.539366f, + -109.489523f, 98.497596f, + -98.958994f, 95.267098f, + -87.945283f, 95.104731f, + -84.371773f, 95.771023f, + -80.898574f, 96.843781f, + -77.571757f, 98.308777f, + -74.435452f, 100.146577f, + -71.531259f, 102.332803f, + -68.897703f, 104.838457f, + -66.569716f, 107.630302f, + -64.578177f, 110.671304f, + -62.949505f, 113.921127f, + -61.705303f, 117.336662f, + -60.862074f, 120.872604f, + -60.431003f, 124.482050f + }; + + + mTriangleOffsets = new int[64]; + mTriangleOffsetsTex = new float[64]; + + mTriangleOffsets[0] = 0; + mTriangleOffsetsCount = 1; + + Vertex t = new Vertex(); + t.nxyz(1, 0, 0); + int count = vtx.length / 2; + + float runningS = 0; + for (int ct=0; ct < (count-1); ct++) { + t.x = -vtx[ct*2] / 100.f; + t.z = vtx[ct*2+1] / 100.f; + t.s = runningS; + t.nx = (vtx[ct*2+3] - vtx[ct*2 +1]); + t.ny = (vtx[ct*2+2] - vtx[ct*2 ]); + float len = (float)java.lang.Math.sqrt(t.nx * t.nx + t.ny * t.ny); + runningS += len / 100; + t.nx /= len; + t.ny /= len; + t.y = -0.5f; + t.t = 0; + //Log.e("xx", "vtx " + t.x + " " + t.y + " " + t.z); + t.addToRS(rs); + t.y = .5f; + t.t = 1; + t.addToRS(rs); + + //LOGE(" %f", runningS); + if((runningS*2) > mTriangleOffsetsCount) { + //LOGE("**** img %i %i", gTriangleOffsetsCount, ct*2); + mTriangleOffsets[mTriangleOffsetsCount] = ct*2; + mTriangleOffsetsTex[mTriangleOffsetsCount] = t.s; + mTriangleOffsetsCount ++; + } + } + + count = (count * 2 - 2); + for (int ct=0; ct < (count-2); ct+= 2) { + rs.triangleMeshAddTriangle(ct, ct+1, ct+2); + rs.triangleMeshAddTriangle(ct+1, ct+3, ct+2); + } + } + + +} + diff --git a/libs/rs/java/Film/src/com/android/film/FilmView.java b/libs/rs/java/Film/src/com/android/film/FilmView.java new file mode 100644 index 0000000..a743b1b --- /dev/null +++ b/libs/rs/java/Film/src/com/android/film/FilmView.java @@ -0,0 +1,82 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.film; + +import java.io.Writer; +import java.util.ArrayList; +import java.util.concurrent.Semaphore; + +import android.renderscript.RSSurfaceView; +import android.renderscript.RenderScript; + +import android.content.Context; +import android.content.res.Resources; +import android.graphics.Bitmap; +import android.graphics.drawable.BitmapDrawable; +import android.graphics.drawable.Drawable; +import android.os.Handler; +import android.os.Message; +import android.util.AttributeSet; +import android.util.Log; +import android.view.Surface; +import android.view.SurfaceHolder; +import android.view.SurfaceView; +import android.view.KeyEvent; +import android.view.MotionEvent; + +public class FilmView extends RSSurfaceView { + + public FilmView(Context context) { + super(context); + + //setFocusable(true); + } + + private RenderScript mRS; + private FilmRS mRender; + + public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) { + super.surfaceChanged(holder, format, w, h); + + mRS = createRenderScript(); + mRender = new FilmRS(); + mRender.init(mRS, getResources(), w, h); + } + + @Override + public boolean onKeyDown(int keyCode, KeyEvent event) + { + // break point at here + // this method doesn't work when 'extends View' include 'extends ScrollView'. + return super.onKeyDown(keyCode, event); + } + + + @Override + public boolean onTouchEvent(MotionEvent ev) + { + boolean ret = true; + int act = ev.getAction(); + if (act == ev.ACTION_UP) { + ret = false; + } + mRender.setFilmStripPosition((int)ev.getX(), (int)ev.getY()); + return ret; + } +} + + diff --git a/libs/rs/java/Fountain/Android.mk b/libs/rs/java/Fountain/Android.mk new file mode 100644 index 0000000..af3d5fc --- /dev/null +++ b/libs/rs/java/Fountain/Android.mk @@ -0,0 +1,25 @@ +# +# Copyright (C) 2008 The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +LOCAL_PATH := $(call my-dir) +include $(CLEAR_VARS) + +LOCAL_SRC_FILES := $(call all-java-files-under, src) +LOCAL_STATIC_JAVA_LIBRARIES := android.renderscript + +LOCAL_PACKAGE_NAME := Fountain + +include $(BUILD_PACKAGE) diff --git a/libs/rs/java/Fountain/AndroidManifest.xml b/libs/rs/java/Fountain/AndroidManifest.xml new file mode 100644 index 0000000..a10938b --- /dev/null +++ b/libs/rs/java/Fountain/AndroidManifest.xml @@ -0,0 +1,13 @@ +<?xml version="1.0" encoding="utf-8"?> +<manifest xmlns:android="http://schemas.android.com/apk/res/android" + package="com.android.fountain"> + <application android:label="Fountain"> + <activity android:name="Fountain" + android:theme="@android:style/Theme.Black.NoTitleBar"> + <intent-filter> + <action android:name="android.intent.action.MAIN" /> + <category android:name="android.intent.category.LAUNCHER" /> + </intent-filter> + </activity> + </application> +</manifest> diff --git a/libs/rs/java/Fountain/res/drawable/gadgets_clock_mp3.png b/libs/rs/java/Fountain/res/drawable/gadgets_clock_mp3.png Binary files differnew file mode 100755 index 0000000..e91bfb4 --- /dev/null +++ b/libs/rs/java/Fountain/res/drawable/gadgets_clock_mp3.png diff --git a/libs/rs/java/Fountain/res/raw/fountain.c b/libs/rs/java/Fountain/res/raw/fountain.c new file mode 100644 index 0000000..6919565 --- /dev/null +++ b/libs/rs/java/Fountain/res/raw/fountain.c @@ -0,0 +1,110 @@ +// Fountain test script + +#pragma version(1) +#pragma stateVertex(default) +#pragma stateFragment(PgmFragBackground) +#pragma stateFragmentStore(PFSReplace) + + +int main(int launchID) { + int count, touch, x, y, rate, maxLife, lifeShift; + int life; + int ct, ct2; + int newPart; + int drawCount; + int dx, dy, idx; + int posx,posy; + int c; + int srcIdx; + int dstIdx; + + count = loadI32(0, 1); + touch = loadI32(0, 2); + x = loadI32(0, 3); + y = loadI32(0, 4); + + rate = 4; + maxLife = (count / rate) - 1; + lifeShift = 0; + { + life = maxLife; + while (life > 255) { + life = life >> 1; + lifeShift ++; + } + } + + drawRect(0, 256, 0, 512); + contextBindProgramFragment(NAMED_PgmFragParts); + contextBindProgramFragmentStore(NAMED_PFSBlend); + + if (touch) { + newPart = loadI32(2, 0); + for (ct2=0; ct2<rate; ct2++) { + dx = scriptRand(0x10000) - 0x8000; + dy = scriptRand(0x10000) - 0x8000; + + idx = newPart * 5 + 1; + storeI32(2, idx, dx); + storeI32(2, idx + 1, dy); + storeI32(2, idx + 2, maxLife); + storeI32(2, idx + 3, x << 16); + storeI32(2, idx + 4, y << 16); + + newPart++; + if (newPart >= count) { + newPart = 0; + } + } + storeI32(2, 0, newPart); + } + + drawCount = 0; + for (ct=0; ct < count; ct++) { + srcIdx = ct * 5 + 1; + + dx = loadI32(2, srcIdx); + dy = loadI32(2, srcIdx + 1); + life = loadI32(2, srcIdx + 2); + posx = loadI32(2, srcIdx + 3); + posy = loadI32(2, srcIdx + 4); + + if (life) { + if (posy < (480 << 16)) { + dstIdx = drawCount * 9; + c = 0xffafcf | ((life >> lifeShift) << 24); + + storeU32(1, dstIdx, c); + storeI32(1, dstIdx + 1, posx); + storeI32(1, dstIdx + 2, posy); + + storeU32(1, dstIdx + 3, c); + storeI32(1, dstIdx + 4, posx + 0x10000); + storeI32(1, dstIdx + 5, posy + dy * 4); + + storeU32(1, dstIdx + 6, c); + storeI32(1, dstIdx + 7, posx - 0x10000); + storeI32(1, dstIdx + 8, posy + dy * 4); + drawCount ++; + } else { + if (dy > 0) { + dy = (-dy) >> 1; + } + } + + posx = posx + dx; + posy = posy + dy; + dy = dy + 0x400; + life --; + + //storeI32(2, srcIdx, dx); + storeI32(2, srcIdx + 1, dy); + storeI32(2, srcIdx + 2, life); + storeI32(2, srcIdx + 3, posx); + storeI32(2, srcIdx + 4, posy); + } + } + + drawTriangleArray(NAMED_PartBuffer, drawCount); + return 1; +} diff --git a/libs/rs/java/Fountain/src/com/android/fountain/Fountain.java b/libs/rs/java/Fountain/src/com/android/fountain/Fountain.java new file mode 100644 index 0000000..58c78fa --- /dev/null +++ b/libs/rs/java/Fountain/src/com/android/fountain/Fountain.java @@ -0,0 +1,90 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.fountain; + +import android.renderscript.RSSurfaceView; +import android.renderscript.RenderScript; + +import android.app.Activity; +import android.content.res.Configuration; +import android.os.Bundle; +import android.os.Handler; +import android.os.Looper; +import android.os.Message; +import android.provider.Settings.System; +import android.util.Config; +import android.util.Log; +import android.view.Menu; +import android.view.MenuItem; +import android.view.View; +import android.view.Window; +import android.widget.Button; +import android.widget.ListView; + +import java.lang.Runtime; + +public class Fountain extends Activity { + //EventListener mListener = new EventListener(); + + private static final String LOG_TAG = "libRS_jni"; + private static final boolean DEBUG = false; + private static final boolean LOG_ENABLED = DEBUG ? Config.LOGD : Config.LOGV; + + private FountainView mView; + + // get the current looper (from your Activity UI thread for instance + + + + @Override + public void onCreate(Bundle icicle) { + super.onCreate(icicle); + + // Create our Preview view and set it as the content of our + // Activity + mView = new FountainView(this); + setContentView(mView); + } + + @Override + protected void onResume() { + // Ideally a game should implement onResume() and onPause() + // to take appropriate action when the activity looses focus + super.onResume(); + mView.onResume(); + } + + @Override + protected void onPause() { + // Ideally a game should implement onResume() and onPause() + // to take appropriate action when the activity looses focus + super.onPause(); + mView.onPause(); + + Runtime.getRuntime().exit(0); + } + + + static void log(String message) { + if (LOG_ENABLED) { + Log.v(LOG_TAG, message); + } + } + + +} + diff --git a/libs/rs/java/Fountain/src/com/android/fountain/FountainRS.java b/libs/rs/java/Fountain/src/com/android/fountain/FountainRS.java new file mode 100644 index 0000000..745635f --- /dev/null +++ b/libs/rs/java/Fountain/src/com/android/fountain/FountainRS.java @@ -0,0 +1,149 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.fountain; + +import java.io.Writer; + +import android.content.Context; +import android.content.res.Resources; +import android.graphics.Bitmap; +import android.graphics.drawable.BitmapDrawable; +import android.graphics.drawable.Drawable; +import android.renderscript.RenderScript; +import android.renderscript.ProgramVertexAlloc; +import android.util.Log; + +public class FountainRS { + + public FountainRS() { + } + + public void init(RenderScript rs, Resources res, int width, int height) { + mRS = rs; + mRes = res; + initRS(); + } + + public void newTouchPosition(int x, int y) { + mParams[0] = 1; + mParams[1] = x; + mParams[2] = y; + mIntAlloc.subData1D(2, 3, mParams); + } + + + ///////////////////////////////////////// + + private Resources mRes; + + private RenderScript mRS; + private RenderScript.Allocation mIntAlloc; + private RenderScript.Allocation mPartAlloc; + private RenderScript.Allocation mVertAlloc; + private RenderScript.Script mScript; + private RenderScript.ProgramFragmentStore mPFS; + private RenderScript.ProgramFragmentStore mPFS2; + private RenderScript.ProgramFragment mPF; + private RenderScript.ProgramFragment mPF2; + private RenderScript.Allocation mTexture; + private RenderScript.Sampler mSampler; + + private Bitmap mBackground; + + int mParams[] = new int[10]; + + private void initRS() { + int partCount = 1024; + + mIntAlloc = mRS.allocationCreatePredefSized(RenderScript.ElementPredefined.USER_I32, 10); + mPartAlloc = mRS.allocationCreatePredefSized(RenderScript.ElementPredefined.USER_I32, partCount * 3 * 3); + mPartAlloc.setName("PartBuffer"); + mVertAlloc = mRS.allocationCreatePredefSized(RenderScript.ElementPredefined.USER_I32, partCount * 5 + 1); + + { + Drawable d = mRes.getDrawable(R.drawable.gadgets_clock_mp3); + BitmapDrawable bd = (BitmapDrawable)d; + Bitmap b = bd.getBitmap(); + mTexture = mRS.allocationCreateFromBitmap(b, + RenderScript.ElementPredefined.RGB_565, + false); + mTexture.uploadToTexture(0); + } + + mRS.programFragmentStoreBegin(null, null); + mRS.programFragmentStoreBlendFunc(RenderScript.BlendSrcFunc.SRC_ALPHA, RenderScript.BlendDstFunc.ONE); + mRS.programFragmentStoreDepthFunc(RenderScript.DepthFunc.ALWAYS); + mRS.programFragmentStoreDepthMask(false); + mRS.programFragmentStoreDitherEnable(false); + mPFS = mRS.programFragmentStoreCreate(); + mPFS.setName("PFSBlend"); + + mRS.programFragmentStoreBegin(null, null); + mRS.programFragmentStoreDepthFunc(RenderScript.DepthFunc.ALWAYS); + mRS.programFragmentStoreDepthMask(false); + mRS.programFragmentStoreDitherEnable(false); + mPFS2 = mRS.programFragmentStoreCreate(); + mPFS2.setName("PFSReplace"); + mRS.contextBindProgramFragmentStore(mPFS2); + + mRS.samplerBegin(); + mRS.samplerSet(RenderScript.SamplerParam.FILTER_MAG, RenderScript.SamplerValue.NEAREST); + mRS.samplerSet(RenderScript.SamplerParam.FILTER_MIN, RenderScript.SamplerValue.NEAREST); + mSampler = mRS.samplerCreate(); + + + mRS.programFragmentBegin(null, null); + mPF = mRS.programFragmentCreate(); + mPF.setName("PgmFragParts"); + + mRS.programFragmentBegin(null, null); + mRS.programFragmentSetTexEnable(0, true); + mPF2 = mRS.programFragmentCreate(); + mRS.contextBindProgramFragment(mPF2); + mPF2.bindTexture(mTexture, 0); + mPF2.bindSampler(mSampler, 0); + mPF2.setName("PgmFragBackground"); + + + mParams[0] = 0; + mParams[1] = partCount; + mParams[2] = 0; + mParams[3] = 0; + mParams[4] = 0; + mIntAlloc.data(mParams); + + int t2[] = new int[partCount * 4*3]; + for (int ct=0; ct < t2.length; ct++) { + t2[ct] = 0; + } + mPartAlloc.data(t2); + + mRS.scriptCBegin(); + mRS.scriptCSetClearColor(0.0f, 0.0f, 0.0f, 1.0f); + mRS.scriptCSetScript(mRes, R.raw.fountain); + mRS.scriptCSetRoot(true); + mScript = mRS.scriptCCreate(); + + mScript.bindAllocation(mIntAlloc, 0); + mScript.bindAllocation(mPartAlloc, 1); + mScript.bindAllocation(mVertAlloc, 2); + mRS.contextBindRootScript(mScript); + } + +} + + diff --git a/libs/rs/java/Fountain/src/com/android/fountain/FountainView.java b/libs/rs/java/Fountain/src/com/android/fountain/FountainView.java new file mode 100644 index 0000000..be8b24e --- /dev/null +++ b/libs/rs/java/Fountain/src/com/android/fountain/FountainView.java @@ -0,0 +1,74 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.fountain; + +import java.io.Writer; +import java.util.ArrayList; +import java.util.concurrent.Semaphore; + +import android.renderscript.RSSurfaceView; +import android.renderscript.RenderScript; + +import android.content.Context; +import android.content.res.Resources; +import android.graphics.Bitmap; +import android.graphics.drawable.BitmapDrawable; +import android.graphics.drawable.Drawable; +import android.os.Handler; +import android.os.Message; +import android.util.AttributeSet; +import android.util.Log; +import android.view.Surface; +import android.view.SurfaceHolder; +import android.view.SurfaceView; +import android.view.KeyEvent; +import android.view.MotionEvent; + +public class FountainView extends RSSurfaceView { + + public FountainView(Context context) { + super(context); + + //setFocusable(true); + } + + private RenderScript mRS; + private FountainRS mRender; + + public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) { + super.surfaceChanged(holder, format, w, h); + + mRS = createRenderScript(); + mRender = new FountainRS(); + mRender.init(mRS, getResources(), w, h); + } + + + @Override + public boolean onTouchEvent(MotionEvent ev) + { + boolean ret = true; + int act = ev.getAction(); + if (act == ev.ACTION_UP) { + ret = false; + } + mRender.newTouchPosition((int)ev.getX(), (int)ev.getY()); + return ret; + } +} + + diff --git a/libs/rs/java/RenderScript/Android.mk b/libs/rs/java/RenderScript/Android.mk new file mode 100644 index 0000000..616fbd2 --- /dev/null +++ b/libs/rs/java/RenderScript/Android.mk @@ -0,0 +1,28 @@ +# +# Copyright (C) 2008 Esmertec AG. +# Copyright (C) 2008 The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +LOCAL_PATH := $(call my-dir) + +# the library +# ============================================================ +include $(CLEAR_VARS) + +LOCAL_SRC_FILES := \ + $(call all-subdir-java-files) + +LOCAL_MODULE:= android.renderscript + +include $(BUILD_STATIC_JAVA_LIBRARY) diff --git a/libs/rs/java/RenderScript/android/renderscript/Matrix.java b/libs/rs/java/RenderScript/android/renderscript/Matrix.java new file mode 100644 index 0000000..79b60d0 --- /dev/null +++ b/libs/rs/java/RenderScript/android/renderscript/Matrix.java @@ -0,0 +1,188 @@ +/* + * Copyright (C) 2009 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package android.renderscript; + +import java.lang.Math; +import android.util.Log; + + +public class Matrix { + + public Matrix() { + mMat = new float[16]; + loadIdentity(); + } + + public float get(int i, int j) { + return mMat[i*4 + j]; + } + + public void set(int i, int j, float v) { + mMat[i*4 + j] = v; + } + + public void loadIdentity() { + mMat[0] = 1; + mMat[1] = 0; + mMat[2] = 0; + mMat[3] = 0; + + mMat[4] = 0; + mMat[5] = 1; + mMat[6] = 0; + mMat[7] = 0; + + mMat[8] = 0; + mMat[9] = 0; + mMat[10] = 1; + mMat[11] = 0; + + mMat[12] = 0; + mMat[13] = 0; + mMat[14] = 0; + mMat[15] = 1; + } + + public void load(Matrix src) { + mMat = src.mMat; + } + + public void loadRotate(float rot, float x, float y, float z) { + float c, s; + mMat[3] = 0; + mMat[7] = 0; + mMat[11]= 0; + mMat[12]= 0; + mMat[13]= 0; + mMat[14]= 0; + mMat[15]= 1; + rot *= (float)(java.lang.Math.PI / 180.0f); + c = (float)java.lang.Math.cos(rot); + s = (float)java.lang.Math.sin(rot); + + float len = (float)java.lang.Math.sqrt(x*x + y*y + z*z); + if (!(len != 1)) { + float recipLen = 1.f / len; + x *= recipLen; + y *= recipLen; + z *= recipLen; + } + float nc = 1.0f - c; + float xy = x * y; + float yz = y * z; + float zx = z * x; + float xs = x * s; + float ys = y * s; + float zs = z * s; + mMat[ 0] = x*x*nc + c; + mMat[ 4] = xy*nc - zs; + mMat[ 8] = zx*nc + ys; + mMat[ 1] = xy*nc + zs; + mMat[ 5] = y*y*nc + c; + mMat[ 9] = yz*nc - xs; + mMat[ 2] = zx*nc - ys; + mMat[ 6] = yz*nc + xs; + mMat[10] = z*z*nc + c; + } + + public void loadScale(float x, float y, float z) { + loadIdentity(); + mMat[0] = x; + mMat[5] = y; + mMat[10] = z; + } + + public void loadTranslate(float x, float y, float z) { + loadIdentity(); + mMat[12] = x; + mMat[13] = y; + mMat[14] = z; + } + + public void loadMultiply(Matrix lhs, Matrix rhs) { + for (int i=0 ; i<4 ; i++) { + float ri0 = 0; + float ri1 = 0; + float ri2 = 0; + float ri3 = 0; + for (int j=0 ; j<4 ; j++) { + float rhs_ij = rhs.get(i,j); + ri0 += lhs.get(j,0) * rhs_ij; + ri1 += lhs.get(j,1) * rhs_ij; + ri2 += lhs.get(j,2) * rhs_ij; + ri3 += lhs.get(j,3) * rhs_ij; + } + set(i,0, ri0); + set(i,1, ri1); + set(i,2, ri2); + set(i,3, ri3); + } + } + + public void loadOrtho(float l, float r, float b, float t, float n, float f) { + loadIdentity(); + mMat[0] = 2 / (r - l); + mMat[5] = 2 / (t - b); + mMat[10]= -2 / (f - n); + mMat[12]= -(r + l) / (r - l); + mMat[13]= -(t + b) / (t - b); + mMat[14]= -(f + n) / (f - n); + } + + public void loadFrustum(float l, float r, float b, float t, float n, float f) { + loadIdentity(); + mMat[0] = 2 * n / (r - l); + mMat[5] = 2 * n / (t - b); + mMat[8] = (r + l) / (r - l); + mMat[9] = (t + b) / (t - b); + mMat[10]= -(f + n) / (f - n); + mMat[11]= -1; + mMat[14]= -2*f*n / (f - n); + mMat[15]= 0; + } + + public void multiply(Matrix rhs) { + Matrix tmp = new Matrix(); + tmp.loadMultiply(this, rhs); + load(tmp); + } + public void rotate(float rot, float x, float y, float z) { + Matrix tmp = new Matrix(); + tmp.loadRotate(rot, x, y, z); + multiply(tmp); + } + public void scale(float x, float y, float z) { + Matrix tmp = new Matrix(); + tmp.loadScale(x, y, z); + multiply(tmp); + } + public void translate(float x, float y, float z) { + Matrix tmp = new Matrix(); + tmp.loadTranslate(x, y, z); + multiply(tmp); + } + + + + float[] mMat; + +} + + + + + diff --git a/libs/rs/java/RenderScript/android/renderscript/ProgramVertexAlloc.java b/libs/rs/java/RenderScript/android/renderscript/ProgramVertexAlloc.java new file mode 100644 index 0000000..020ddb2 --- /dev/null +++ b/libs/rs/java/RenderScript/android/renderscript/ProgramVertexAlloc.java @@ -0,0 +1,112 @@ +/* + * Copyright (C) 2009 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package android.renderscript; + +import java.lang.Math; +import android.util.Log; + + +public class ProgramVertexAlloc { + public static final int MODELVIEW_OFFSET = 0; + public static final int PROJECTION_OFFSET = 16; + public static final int TEXTURE_OFFSET = 32; + + Matrix mModel; + Matrix mProjection; + Matrix mTexture; + + public RenderScript.Allocation mAlloc; + + public ProgramVertexAlloc(RenderScript rs) { + mModel = new Matrix(); + mProjection = new Matrix(); + mTexture = new Matrix(); + + mAlloc = rs.allocationCreatePredefSized( + RenderScript.ElementPredefined.USER_FLOAT, + 48); + + mAlloc.subData1D(MODELVIEW_OFFSET, 16, mModel.mMat); + mAlloc.subData1D(PROJECTION_OFFSET, 16, mProjection.mMat); + mAlloc.subData1D(TEXTURE_OFFSET, 16, mTexture.mMat); + } + + public void loadModelview(Matrix m) { + mModel = m; + mAlloc.subData1D(MODELVIEW_OFFSET, 16, m.mMat); + } + + public void loadProjection(Matrix m) { + mProjection = m; + mAlloc.subData1D(PROJECTION_OFFSET, 16, m.mMat); + } + + public void loadTexture(Matrix m) { + mTexture = m; + mAlloc.subData1D(TEXTURE_OFFSET, 16, m.mMat); + } + + public void setupOrthoWindow(int w, int h) { + mProjection.loadOrtho(0,w, h,0, -1,1); + mAlloc.subData1D(PROJECTION_OFFSET, 16, mProjection.mMat); + } + + public void setupOrthoNormalized(int w, int h) { + // range -1,1 in the narrow axis. + if(w > h) { + float aspect = ((float)w) / h; + mProjection.loadOrtho(-aspect,aspect, -1,1, -1,1); + } else { + float aspect = ((float)h) / w; + mProjection.loadOrtho(-1,1, -aspect,aspect, -1,1); + } + mAlloc.subData1D(PROJECTION_OFFSET, 16, mProjection.mMat); + } + + public void setupProjectionNormalized(int w, int h) { + // range -1,1 in the narrow axis at z = 0. + Matrix m1 = new Matrix(); + Matrix m2 = new Matrix(); + + if(w > h) { + float aspect = ((float)w) / h; + m1.loadFrustum(-aspect,aspect, -1,1, 1,100); + } else { + float aspect = ((float)h) / w; + m1.loadFrustum(-1,1, -aspect,aspect, 1,100); + } + + m2.loadRotate(180, 0, 1, 0); + m1.loadMultiply(m1, m2); + + m2.loadScale(-2, 2, 1); + m1.loadMultiply(m1, m2); + + m2.loadTranslate(0, 0, 2); + m1.loadMultiply(m1, m2); + + mProjection = m1; + mAlloc.subData1D(PROJECTION_OFFSET, 16, mProjection.mMat); + } + +} + + + + + + diff --git a/libs/rs/java/RenderScript/android/renderscript/RSSurfaceView.java b/libs/rs/java/RenderScript/android/renderscript/RSSurfaceView.java new file mode 100644 index 0000000..3835793 --- /dev/null +++ b/libs/rs/java/RenderScript/android/renderscript/RSSurfaceView.java @@ -0,0 +1,154 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package android.renderscript; + +import java.io.Writer; +import java.util.ArrayList; +import java.util.concurrent.Semaphore; + +import android.content.Context; +import android.os.Handler; +import android.os.Message; +import android.util.AttributeSet; +import android.util.Log; +import android.util.Log; +import android.view.Surface; +import android.view.SurfaceHolder; +import android.view.SurfaceView; + +public class RSSurfaceView extends SurfaceView implements SurfaceHolder.Callback { + private SurfaceHolder mSurfaceHolder; + + /** + * Standard View constructor. In order to render something, you + * must call {@link #setRenderer} to register a renderer. + */ + public RSSurfaceView(Context context) { + super(context); + init(); + Log.v(RenderScript.LOG_TAG, "RSSurfaceView"); + } + + /** + * Standard View constructor. In order to render something, you + * must call {@link #setRenderer} to register a renderer. + */ + public RSSurfaceView(Context context, AttributeSet attrs) { + super(context, attrs); + init(); + Log.v(RenderScript.LOG_TAG, "RSSurfaceView"); + } + + private void init() { + // Install a SurfaceHolder.Callback so we get notified when the + // underlying surface is created and destroyed + SurfaceHolder holder = getHolder(); + holder.addCallback(this); + holder.setType(SurfaceHolder.SURFACE_TYPE_GPU); + } + + /** + * This method is part of the SurfaceHolder.Callback interface, and is + * not normally called or subclassed by clients of RSSurfaceView. + */ + public void surfaceCreated(SurfaceHolder holder) { + Log.v(RenderScript.LOG_TAG, "surfaceCreated"); + mSurfaceHolder = holder; + //mGLThread.surfaceCreated(); + } + + /** + * This method is part of the SurfaceHolder.Callback interface, and is + * not normally called or subclassed by clients of RSSurfaceView. + */ + public void surfaceDestroyed(SurfaceHolder holder) { + // Surface will be destroyed when we return + Log.v(RenderScript.LOG_TAG, "surfaceDestroyed"); + //mGLThread.surfaceDestroyed(); + } + + /** + * This method is part of the SurfaceHolder.Callback interface, and is + * not normally called or subclassed by clients of RSSurfaceView. + */ + public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) { + Log.v(RenderScript.LOG_TAG, "surfaceChanged"); + + //mGLThread.onWindowResize(w, h); + } + + /** + * Inform the view that the activity is paused. The owner of this view must + * call this method when the activity is paused. Calling this method will + * pause the rendering thread. + * Must not be called before a renderer has been set. + */ + public void onPause() { + Log.v(RenderScript.LOG_TAG, "onPause"); + //mGLThread.onPause(); + } + + /** + * Inform the view that the activity is resumed. The owner of this view must + * call this method when the activity is resumed. Calling this method will + * recreate the OpenGL display and resume the rendering + * thread. + * Must not be called before a renderer has been set. + */ + public void onResume() { + Log.v(RenderScript.LOG_TAG, "onResume"); + //mGLThread.onResume(); + } + + /** + * Queue a runnable to be run on the GL rendering thread. This can be used + * to communicate with the Renderer on the rendering thread. + * Must not be called before a renderer has been set. + * @param r the runnable to be run on the GL rendering thread. + */ + public void queueEvent(Runnable r) { + Log.v(RenderScript.LOG_TAG, "queueEvent"); + //mGLThread.queueEvent(r); + } + + /** + * This method is used as part of the View class and is not normally + * called or subclassed by clients of RSSurfaceView. + * Must not be called before a renderer has been set. + */ + @Override + protected void onDetachedFromWindow() { + super.onDetachedFromWindow(); + //mGLThread.requestExitAndWait(); + } + + // ---------------------------------------------------------------------- + + public RenderScript createRenderScript() { + Log.v(RenderScript.LOG_TAG, "createRenderScript 1"); + Surface sur = null; + while ((sur == null) || (mSurfaceHolder == null)) { + sur = getHolder().getSurface(); + } + Log.v(RenderScript.LOG_TAG, "createRenderScript 2"); + RenderScript rs = new RenderScript(sur); + Log.v(RenderScript.LOG_TAG, "createRenderScript 3 rs"); + return rs; + } + +} + diff --git a/libs/rs/java/RenderScript/android/renderscript/RenderScript.java b/libs/rs/java/RenderScript/android/renderscript/RenderScript.java new file mode 100644 index 0000000..a9db15f --- /dev/null +++ b/libs/rs/java/RenderScript/android/renderscript/RenderScript.java @@ -0,0 +1,956 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package android.renderscript; + +import java.io.InputStream; +import java.io.IOException; + +import android.os.Bundle; +import android.content.res.Resources; +import android.util.Log; +import android.util.Config; +import android.view.Menu; +import android.view.MenuItem; +import android.view.Window; +import android.view.View; +import android.view.Surface; +import android.graphics.Bitmap; +import android.graphics.Color; + +public class RenderScript { + static final String LOG_TAG = "libRS_jni"; + private static final boolean DEBUG = false; + private static final boolean LOG_ENABLED = DEBUG ? Config.LOGD : Config.LOGV; + + + + /* + * We use a class initializer to allow the native code to cache some + * field offsets. + */ + private static boolean sInitialized; + native private static void _nInit(); + + static { + sInitialized = false; + try { + System.loadLibrary("RS_jni"); + _nInit(); + sInitialized = true; + } catch (UnsatisfiedLinkError e) { + Log.d(LOG_TAG, "RenderScript JNI library not found!"); + } + } + + native private int nDeviceCreate(); + native private void nDeviceDestroy(int dev); + native private int nContextCreate(int dev, Surface sur, int ver); + native private void nContextDestroy(int con); + + //void rsContextBindSampler (uint32_t slot, RsSampler sampler); + //void rsContextBindRootScript (RsScript sampler); + native private void nContextBindRootScript(int script); + native private void nContextBindSampler(int sampler, int slot); + native private void nContextBindProgramFragmentStore(int pfs); + native private void nContextBindProgramFragment(int pf); + native private void nContextBindProgramVertex(int pf); + + native private void nAssignName(int obj, byte[] name); + + native private void nElementBegin(); + native private void nElementAddPredefined(int predef); + native private void nElementAdd(int kind, int type, int norm, int bits); + native private int nElementCreate(); + native private int nElementGetPredefined(int predef); + native private void nElementDestroy(int obj); + + native private void nTypeBegin(int elementID); + native private void nTypeAdd(int dim, int val); + native private int nTypeCreate(); + native private void nTypeDestroy(int id); + + native private int nAllocationCreateTyped(int type); + native private int nAllocationCreatePredefSized(int predef, int count); + native private int nAllocationCreateSized(int elem, int count); + native private int nAllocationCreateFromBitmap(int dstFmt, boolean genMips, Bitmap bmp); + + native private void nAllocationUploadToTexture(int alloc, int baseMioLevel); + native private void nAllocationDestroy(int alloc); + native private void nAllocationData(int id, int[] d); + native private void nAllocationData(int id, float[] d); + native private void nAllocationSubData1D(int id, int off, int count, int[] d); + native private void nAllocationSubData1D(int id, int off, int count, float[] d); + native private void nAllocationSubData2D(int id, int xoff, int yoff, int w, int h, int[] d); + native private void nAllocationSubData2D(int id, int xoff, int yoff, int w, int h, float[] d); + + native private void nTriangleMeshDestroy(int id); + native private void nTriangleMeshBegin(int vertex, int index); + native private void nTriangleMeshAddVertex_XY (float x, float y); + native private void nTriangleMeshAddVertex_XYZ (float x, float y, float z); + native private void nTriangleMeshAddVertex_XY_ST (float x, float y, float s, float t); + native private void nTriangleMeshAddVertex_XYZ_ST (float x, float y, float z, float s, float t); + native private void nTriangleMeshAddVertex_XYZ_ST_NORM (float x, float y, float z, float s, float t, float nx, float ny, float nz); + native private void nTriangleMeshAddTriangle(int i1, int i2, int i3); + native private int nTriangleMeshCreate(); + + native private void nAdapter1DDestroy(int id); + native private void nAdapter1DBindAllocation(int ad, int alloc); + native private void nAdapter1DSetConstraint(int ad, int dim, int value); + native private void nAdapter1DData(int ad, int[] d); + native private void nAdapter1DSubData(int ad, int off, int count, int[] d); + native private void nAdapter1DData(int ad, float[] d); + native private void nAdapter1DSubData(int ad, int off, int count, float[] d); + native private int nAdapter1DCreate(); + + native private void nScriptDestroy(int script); + native private void nScriptBindAllocation(int vtm, int alloc, int slot); + native private void nScriptCBegin(); + native private void nScriptCSetClearColor(float r, float g, float b, float a); + native private void nScriptCSetClearDepth(float depth); + native private void nScriptCSetClearStencil(int stencil); + native private void nScriptCAddType(int type); + native private void nScriptCSetRoot(boolean isRoot); + native private void nScriptCSetScript(byte[] script, int offset, int length); + native private int nScriptCCreate(); + + native private void nSamplerDestroy(int sampler); + native private void nSamplerBegin(); + native private void nSamplerSet(int param, int value); + native private int nSamplerCreate(); + + native private void nProgramFragmentStoreBegin(int in, int out); + native private void nProgramFragmentStoreDepthFunc(int func); + native private void nProgramFragmentStoreDepthMask(boolean enable); + native private void nProgramFragmentStoreColorMask(boolean r, boolean g, boolean b, boolean a); + native private void nProgramFragmentStoreBlendFunc(int src, int dst); + native private void nProgramFragmentStoreDither(boolean enable); + native private int nProgramFragmentStoreCreate(); + native private void nProgramFragmentStoreDestroy(int pgm); + + native private void nProgramFragmentBegin(int in, int out); + native private void nProgramFragmentBindTexture(int vpf, int slot, int a); + native private void nProgramFragmentBindSampler(int vpf, int slot, int s); + native private void nProgramFragmentSetType(int slot, int vt); + native private void nProgramFragmentSetEnvMode(int slot, int env); + native private void nProgramFragmentSetTexEnable(int slot, boolean enable); + native private int nProgramFragmentCreate(); + native private void nProgramFragmentDestroy(int pgm); + + native private void nProgramVertexDestroy(int pv); + native private void nProgramVertexBindAllocation(int pv, int slot, int mID); + native private void nProgramVertexBegin(int inID, int outID); + native private void nProgramVertexSetType(int slot, int mID); + native private void nProgramVertexSetTextureMatrixEnable(boolean enable); + native private int nProgramVertexCreate(); + + native private void nLightBegin(); + native private void nLightSetIsMono(boolean isMono); + native private void nLightSetIsLocal(boolean isLocal); + native private int nLightCreate(); + native private void nLightDestroy(int l); + native private void nLightSetColor(int l, float r, float g, float b); + native private void nLightSetPosition(int l, float x, float y, float z); + + + private int mDev; + private int mContext; + private Surface mSurface; + + + + /////////////////////////////////////////////////////////////////////////////////// + // + + RenderScript(Surface sur) { + mSurface = sur; + mDev = nDeviceCreate(); + mContext = nContextCreate(mDev, mSurface, 0); + } + + private class BaseObj { + BaseObj() { + mID = 0; + } + + public int getID() { + return mID; + } + + int mID; + String mName; + + public void setName(String s) throws IllegalStateException, IllegalArgumentException + { + if(s.length() < 1) { + throw new IllegalArgumentException("setName does not accept a zero length string."); + } + if(mName != null) { + throw new IllegalArgumentException("setName object already has a name."); + } + + try { + byte[] bytes = s.getBytes("UTF-8"); + nAssignName(mID, bytes); + mName = s; + } catch (java.io.UnsupportedEncodingException e) { + throw new RuntimeException(e); + } + } + + protected void finalize() throws Throwable + { + if (mID != 0) { + Log.v(LOG_TAG, + "Element finalized without having released the RS reference."); + } + super.finalize(); + } + } + + + ////////////////////////////////////////////////////////////////////////////////// + // Element + + public enum ElementPredefined { + USER_U8 (0), + USER_I8 (1), + USER_U16 (2), + USER_I16 (3), + USER_U32 (4), + USER_I32 (5), + USER_FLOAT (6), + + A_8 (7), + RGB_565 (8), + RGB_888 (11), + RGBA_5551 (9), + RGBA_4444 (10), + RGBA_8888 (12), + + INDEX_16 (13), + INDEX_32 (14), + XY_F32 (15), + XYZ_F32 (16), + ST_XY_F32 (17), + ST_XYZ_F32 (18), + NORM_XYZ_F32 (19), + NORM_ST_XYZ_F32 (20); + + int mID; + ElementPredefined(int id) { + mID = id; + } + } + + public enum DataType { + FLOAT (0), + UNSIGNED (1), + SIGNED (2); + + int mID; + DataType(int id) { + mID = id; + } + } + + public enum DataKind { + USER (0), + RED (1), + GREEN (2), + BLUE (3), + ALPHA (4), + LUMINANCE (5), + INTENSITY (6), + X (7), + Y (8), + Z (9), + W (10), + S (11), + T (12), + Q (13), + R (14), + NX (15), + NY (16), + NZ (17), + INDEX (18); + + int mID; + DataKind(int id) { + mID = id; + } + } + + public enum DepthFunc { + ALWAYS (0), + LESS (1), + LEQUAL (2), + GREATER (3), + GEQUAL (4), + EQUAL (5), + NOTEQUAL (6); + + int mID; + DepthFunc(int id) { + mID = id; + } + } + + public enum BlendSrcFunc { + ZERO (0), + ONE (1), + DST_COLOR (2), + ONE_MINUS_DST_COLOR (3), + SRC_ALPHA (4), + ONE_MINUS_SRC_ALPHA (5), + DST_ALPHA (6), + ONE_MINUS_DST_ALPA (7), + SRC_ALPHA_SATURATE (8); + + int mID; + BlendSrcFunc(int id) { + mID = id; + } + } + + public enum BlendDstFunc { + ZERO (0), + ONE (1), + SRC_COLOR (2), + ONE_MINUS_SRC_COLOR (3), + SRC_ALPHA (4), + ONE_MINUS_SRC_ALPHA (5), + DST_ALPHA (6), + ONE_MINUS_DST_ALPA (7); + + int mID; + BlendDstFunc(int id) { + mID = id; + } + } + + public enum EnvMode { + REPLACE (0), + MODULATE (1), + DECAL (2); + + int mID; + EnvMode(int id) { + mID = id; + } + } + + public enum SamplerParam { + FILTER_MIN (0), + FILTER_MAG (1), + WRAP_MODE_S (2), + WRAP_MODE_T (3), + WRAP_MODE_R (4); + + int mID; + SamplerParam(int id) { + mID = id; + } + } + + public enum SamplerValue { + NEAREST (0), + LINEAR (1), + LINEAR_MIP_LINEAR (2), + WRAP (3), + CLAMP (4); + + int mID; + SamplerValue(int id) { + mID = id; + } + } + + + + public class Element extends BaseObj { + Element(int id) { + mID = id; + } + + public void estroy() { + nElementDestroy(mID); + mID = 0; + } + } + + public void elementBegin() { + nElementBegin(); + } + + public void elementAddPredefined(ElementPredefined e) { + nElementAddPredefined(e.mID); + } + + public void elementAdd(DataType dt, DataKind dk, boolean isNormalized, int bits) { + int norm = 0; + if (isNormalized) { + norm = 1; + } + nElementAdd(dt.mID, dk.mID, norm, bits); + } + + public Element elementCreate() { + int id = nElementCreate(); + return new Element(id); + } + + public Element elementGetPredefined(ElementPredefined predef) { + int id = nElementGetPredefined(predef.mID); + return new Element(id); + } + + + ////////////////////////////////////////////////////////////////////////////////// + // Type + + public enum Dimension { + X (0), + Y (1), + Z (2), + LOD (3), + FACE (4), + ARRAY_0 (100); + + int mID; + Dimension(int id) { + mID = id; + } + } + + public class Type extends BaseObj { + Type(int id) { + mID = id; + } + + public void destroy() { + nTypeDestroy(mID); + mID = 0; + } + } + + public void typeBegin(Element e) { + nTypeBegin(e.mID); + } + + public void typeAdd(Dimension d, int value) { + nTypeAdd(d.mID, value); + } + + public Type typeCreate() { + int id = nTypeCreate(); + return new Type(id); + } + + + ////////////////////////////////////////////////////////////////////////////////// + // Allocation + + public class Allocation extends BaseObj { + Allocation(int id) { + mID = id; + } + + public void uploadToTexture(int baseMipLevel) { + nAllocationUploadToTexture(mID, baseMipLevel); + } + + public void destroy() { + nAllocationDestroy(mID); + mID = 0; + } + + public void data(int[] d) { + nAllocationData(mID, d); + } + + public void data(float[] d) { + nAllocationData(mID, d); + } + + public void subData1D(int off, int count, int[] d) { + nAllocationSubData1D(mID, off, count, d); + } + + public void subData1D(int off, int count, float[] d) { + nAllocationSubData1D(mID, off, count, d); + } + + public void subData2D(int xoff, int yoff, int w, int h, int[] d) { + nAllocationSubData2D(mID, xoff, yoff, w, h, d); + } + + public void subData2D(int xoff, int yoff, int w, int h, float[] d) { + nAllocationSubData2D(mID, xoff, yoff, w, h, d); + } + } + + public Allocation allocationCreateTyped(Type type) { + int id = nAllocationCreateTyped(type.mID); + return new Allocation(id); + } + + public Allocation allocationCreatePredefSized(ElementPredefined e, int count) { + int id = nAllocationCreatePredefSized(e.mID, count); + return new Allocation(id); + } + + public Allocation allocationCreateSized(Element e, int count) { + int id = nAllocationCreateSized(e.mID, count); + return new Allocation(id); + } + + public Allocation allocationCreateFromBitmap(Bitmap b, ElementPredefined dstFmt, boolean genMips) { + int id = nAllocationCreateFromBitmap(dstFmt.mID, genMips, b); + return new Allocation(id); + } + + ////////////////////////////////////////////////////////////////////////////////// + // Adapter1D + + public class Adapter1D extends BaseObj { + Adapter1D(int id) { + mID = id; + } + + public void destroy() { + nAdapter1DDestroy(mID); + mID = 0; + } + + public void bindAllocation(Allocation a) { + nAdapter1DBindAllocation(mID, a.mID); + } + + public void setConstraint(Dimension dim, int value) { + nAdapter1DSetConstraint(mID, dim.mID, value); + } + + public void data(int[] d) { + nAdapter1DData(mID, d); + } + + public void subData(int off, int count, int[] d) { + nAdapter1DSubData(mID, off, count, d); + } + + public void data(float[] d) { + nAdapter1DData(mID, d); + } + + public void subData(int off, int count, float[] d) { + nAdapter1DSubData(mID, off, count, d); + } + } + + public Adapter1D adapter1DCreate() { + int id = nAdapter1DCreate(); + return new Adapter1D(id); + } + + + ////////////////////////////////////////////////////////////////////////////////// + // Triangle Mesh + + public class TriangleMesh extends BaseObj { + TriangleMesh(int id) { + mID = id; + } + + public void destroy() { + nTriangleMeshDestroy(mID); + mID = 0; + } + } + + public void triangleMeshBegin(Element vertex, Element index) { + nTriangleMeshBegin(vertex.mID, index.mID); + } + + public void triangleMeshAddVertex_XY(float x, float y) { + nTriangleMeshAddVertex_XY(x, y); + } + + public void triangleMeshAddVertex_XYZ(float x, float y, float z) { + nTriangleMeshAddVertex_XYZ(x, y, z); + } + + public void triangleMeshAddVertex_XY_ST(float x, float y, float s, float t) { + nTriangleMeshAddVertex_XY_ST(x, y, s, t); + } + + public void triangleMeshAddVertex_XYZ_ST(float x, float y, float z, float s, float t) { + nTriangleMeshAddVertex_XYZ_ST(x, y, z, s, t); + } + + public void triangleMeshAddVertex_XYZ_ST_NORM(float x, float y, float z, float s, float t, float nx, float ny, float nz) { + nTriangleMeshAddVertex_XYZ_ST_NORM(x, y, z, s, t, nx, ny, nz); + } + + public void triangleMeshAddTriangle(int i1, int i2, int i3) { + nTriangleMeshAddTriangle(i1, i2, i3); + } + + public TriangleMesh triangleMeshCreate() { + int id = nTriangleMeshCreate(); + return new TriangleMesh(id); + } + + ////////////////////////////////////////////////////////////////////////////////// + // Script + + public class Script extends BaseObj { + Script(int id) { + mID = id; + } + + public void destroy() { + nScriptDestroy(mID); + mID = 0; + } + + public void bindAllocation(Allocation va, int slot) { + nScriptBindAllocation(mID, va.mID, slot); + } + } + + public void scriptCBegin() { + nScriptCBegin(); + } + + public void scriptCSetClearColor(float r, float g, float b, float a) { + nScriptCSetClearColor(r, g, b, a); + } + + public void scriptCSetClearDepth(float d) { + nScriptCSetClearDepth(d); + } + + public void scriptCSetClearStencil(int stencil) { + nScriptCSetClearStencil(stencil); + } + + public void scriptCAddType(Type t) { + nScriptCAddType(t.mID); + } + + public void scriptCSetRoot(boolean r) { + nScriptCSetRoot(r); + } + + public void scriptCSetScript(String s) { + try { + byte[] bytes = s.getBytes("UTF-8"); + nScriptCSetScript(bytes, 0, bytes.length); + } catch (java.io.UnsupportedEncodingException e) { + throw new RuntimeException(e); + } + } + + public void scriptCSetScript(Resources resources, int id) { + InputStream is = resources.openRawResource(id); + try { + try { + scriptCSetScript(is); + } finally { + is.close(); + } + } catch(IOException e) { + throw new Resources.NotFoundException(); + } + } + + public void scriptCSetScript(InputStream is) throws IOException { + byte[] buf = new byte[1024]; + int currentPos = 0; + while(true) { + int bytesLeft = buf.length - currentPos; + if (bytesLeft == 0) { + byte[] buf2 = new byte[buf.length * 2]; + System.arraycopy(buf, 0, buf2, 0, buf.length); + buf = buf2; + bytesLeft = buf.length - currentPos; + } + int bytesRead = is.read(buf, currentPos, bytesLeft); + if (bytesRead <= 0) { + break; + } + currentPos += bytesRead; + } + nScriptCSetScript(buf, 0, currentPos); + } + + public Script scriptCCreate() { + int id = nScriptCCreate(); + return new Script(id); + } + + ////////////////////////////////////////////////////////////////////////////////// + // ProgramVertex + + public class ProgramVertex extends BaseObj { + ProgramVertex(int id) { + mID = id; + } + + public void destroy() { + nProgramVertexDestroy(mID); + mID = 0; + } + + public void bindAllocation(int slot, Allocation va) { + nProgramVertexBindAllocation(mID, slot, va.mID); + } + + } + + public void programVertexBegin(Element in, Element out) { + int inID = 0; + int outID = 0; + if (in != null) { + inID = in.mID; + } + if (out != null) { + outID = out.mID; + } + nProgramVertexBegin(inID, outID); + } + + public void programVertexSetType(int slot, Type t) { + nProgramVertexSetType(slot, t.mID); + } + + public void programVertexSetTextureMatrixEnable(boolean enable) { + nProgramVertexSetTextureMatrixEnable(enable); + } + + public ProgramVertex programVertexCreate() { + int id = nProgramVertexCreate(); + return new ProgramVertex(id); + } + + + ////////////////////////////////////////////////////////////////////////////////// + // ProgramFragmentStore + + public class ProgramFragmentStore extends BaseObj { + ProgramFragmentStore(int id) { + mID = id; + } + + public void destroy() { + nProgramFragmentStoreDestroy(mID); + mID = 0; + } + } + + public void programFragmentStoreBegin(Element in, Element out) { + int inID = 0; + int outID = 0; + if (in != null) { + inID = in.mID; + } + if (out != null) { + outID = out.mID; + } + nProgramFragmentStoreBegin(inID, outID); + } + + public void programFragmentStoreDepthFunc(DepthFunc func) { + nProgramFragmentStoreDepthFunc(func.mID); + } + + public void programFragmentStoreDepthMask(boolean enable) { + nProgramFragmentStoreDepthMask(enable); + } + + public void programFragmentStoreColorMask(boolean r, boolean g, boolean b, boolean a) { + nProgramFragmentStoreColorMask(r,g,b,a); + } + + public void programFragmentStoreBlendFunc(BlendSrcFunc src, BlendDstFunc dst) { + nProgramFragmentStoreBlendFunc(src.mID, dst.mID); + } + + public void programFragmentStoreDitherEnable(boolean enable) { + nProgramFragmentStoreDither(enable); + } + + public ProgramFragmentStore programFragmentStoreCreate() { + int id = nProgramFragmentStoreCreate(); + return new ProgramFragmentStore(id); + } + + ////////////////////////////////////////////////////////////////////////////////// + // ProgramFragment + + public class ProgramFragment extends BaseObj { + ProgramFragment(int id) { + mID = id; + } + + public void destroy() { + nProgramFragmentDestroy(mID); + mID = 0; + } + + public void bindTexture(Allocation va, int slot) { + nProgramFragmentBindTexture(mID, slot, va.mID); + } + + public void bindSampler(Sampler vs, int slot) { + nProgramFragmentBindSampler(mID, slot, vs.mID); + } + } + + public void programFragmentBegin(Element in, Element out) { + int inID = 0; + int outID = 0; + if (in != null) { + inID = in.mID; + } + if (out != null) { + outID = out.mID; + } + nProgramFragmentBegin(inID, outID); + } + + public void programFragmentSetType(int slot, Type t) { + nProgramFragmentSetType(slot, t.mID); + } + + public void programFragmentSetType(int slot, EnvMode t) { + nProgramFragmentSetEnvMode(slot, t.mID); + } + + public void programFragmentSetTexEnable(int slot, boolean enable) { + nProgramFragmentSetTexEnable(slot, enable); + } + + public ProgramFragment programFragmentCreate() { + int id = nProgramFragmentCreate(); + return new ProgramFragment(id); + } + + ////////////////////////////////////////////////////////////////////////////////// + // Sampler + + public class Sampler extends BaseObj { + Sampler(int id) { + mID = id; + } + + public void destroy() { + nSamplerDestroy(mID); + mID = 0; + } + } + + public void samplerBegin() { + nSamplerBegin(); + } + + public void samplerSet(SamplerParam p, SamplerValue v) { + nSamplerSet(p.mID, v.mID); + } + + public Sampler samplerCreate() { + int id = nSamplerCreate(); + return new Sampler(id); + } + + ////////////////////////////////////////////////////////////////////////////////// + // Light + + public class Light extends BaseObj { + Light(int id) { + mID = id; + } + + public void destroy() { + nLightDestroy(mID); + mID = 0; + } + + public void setColor(float r, float g, float b) { + nLightSetColor(mID, r, g, b); + } + + public void setPosition(float x, float y, float z) { + nLightSetPosition(mID, x, y, z); + } + } + + public void lightBegin() { + nLightBegin(); + } + + public void lightSetIsMono(boolean isMono) { + nLightSetIsMono(isMono); + } + + public void lightSetIsLocal(boolean isLocal) { + nLightSetIsLocal(isLocal); + } + + public Light lightCreate() { + int id = nLightCreate(); + return new Light(id); + } + + /////////////////////////////////////////////////////////////////////////////////// + // Root state + + public void contextBindRootScript(Script s) { + nContextBindRootScript(s.mID); + } + + //public void contextBindSampler(Sampler s, int slot) { + //nContextBindSampler(s.mID); + //} + + public void contextBindProgramFragmentStore(ProgramFragmentStore pfs) { + nContextBindProgramFragmentStore(pfs.mID); + } + + public void contextBindProgramFragment(ProgramFragment pf) { + nContextBindProgramFragment(pf.mID); + } + + public void contextBindProgramVertex(ProgramVertex pf) { + nContextBindProgramVertex(pf.mID); + } + +/* + RsAdapter2D rsAdapter2DCreate (); + void rsAdapter2DBindAllocation (RsAdapter2D adapt, RsAllocation alloc); + void rsAdapter2DDestroy (RsAdapter2D adapter); + void rsAdapter2DSetConstraint (RsAdapter2D adapter, RsDimension dim, uint32_t value); + void rsAdapter2DData (RsAdapter2D adapter, const void * data); + void rsAdapter2DSubData (RsAdapter2D adapter, uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h, const void * data); + void rsSamplerBegin (); + void rsSamplerSet (RsSamplerParam p, RsSamplerValue value); + RsSampler rsSamplerCreate (); + void rsSamplerBind (RsSampler sampler, RsAllocation alloc); +*/ + +} + diff --git a/libs/rs/java/Rollo/Android.mk b/libs/rs/java/Rollo/Android.mk new file mode 100644 index 0000000..1c6dfdf --- /dev/null +++ b/libs/rs/java/Rollo/Android.mk @@ -0,0 +1,25 @@ +# +# Copyright (C) 2008 The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +LOCAL_PATH := $(call my-dir) +include $(CLEAR_VARS) + +LOCAL_SRC_FILES := $(call all-java-files-under, src) +LOCAL_STATIC_JAVA_LIBRARIES := android.renderscript + +LOCAL_PACKAGE_NAME := Rollo + +include $(BUILD_PACKAGE) diff --git a/libs/rs/java/Rollo/AndroidManifest.xml b/libs/rs/java/Rollo/AndroidManifest.xml new file mode 100644 index 0000000..da160a3 --- /dev/null +++ b/libs/rs/java/Rollo/AndroidManifest.xml @@ -0,0 +1,13 @@ +<?xml version="1.0" encoding="utf-8"?> +<manifest xmlns:android="http://schemas.android.com/apk/res/android" + package="com.android.rollo"> + <application android:label="Rollo"> + <activity android:name="Rollo" + android:theme="@android:style/Theme.Black.NoTitleBar"> + <intent-filter> + <action android:name="android.intent.action.MAIN" /> + <category android:name="android.intent.category.LAUNCHER" /> + </intent-filter> + </activity> + </application> +</manifest> diff --git a/libs/rs/java/Rollo/res/raw/rollo.c b/libs/rs/java/Rollo/res/raw/rollo.c new file mode 100644 index 0000000..56ee425 --- /dev/null +++ b/libs/rs/java/Rollo/res/raw/rollo.c @@ -0,0 +1,14 @@ +#pragma version(1) +#pragma stateVertex(PV) +#pragma stateFragment(PF) +#pragma stateFragmentStore(PFSBackground) + +int main(void* con, int ft, int launchID) +{ + int x; + + renderTriangleMesh(con, NAMED_MeshCard); + renderTriangleMesh(con, NAMED_MeshTab); + return 1; +} + diff --git a/libs/rs/java/Rollo/src/com/android/rollo/Rollo.java b/libs/rs/java/Rollo/src/com/android/rollo/Rollo.java new file mode 100644 index 0000000..400d801 --- /dev/null +++ b/libs/rs/java/Rollo/src/com/android/rollo/Rollo.java @@ -0,0 +1,90 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rollo; + +import android.renderscript.RSSurfaceView; +import android.renderscript.RenderScript; + +import android.app.Activity; +import android.content.res.Configuration; +import android.os.Bundle; +import android.os.Handler; +import android.os.Looper; +import android.os.Message; +import android.provider.Settings.System; +import android.util.Config; +import android.util.Log; +import android.view.Menu; +import android.view.MenuItem; +import android.view.View; +import android.view.Window; +import android.widget.Button; +import android.widget.ListView; + +import java.lang.Runtime; + +public class Rollo extends Activity { + //EventListener mListener = new EventListener(); + + private static final String LOG_TAG = "libRS_jni"; + private static final boolean DEBUG = false; + private static final boolean LOG_ENABLED = DEBUG ? Config.LOGD : Config.LOGV; + + private RolloView mView; + + // get the current looper (from your Activity UI thread for instance + + + + @Override + public void onCreate(Bundle icicle) { + super.onCreate(icicle); + + // Create our Preview view and set it as the content of our + // Activity + mView = new RolloView(this); + setContentView(mView); + } + + @Override + protected void onResume() { + // Ideally a game should implement onResume() and onPause() + // to take appropriate action when the activity looses focus + super.onResume(); + mView.onResume(); + } + + @Override + protected void onPause() { + // Ideally a game should implement onResume() and onPause() + // to take appropriate action when the activity looses focus + super.onPause(); + mView.onPause(); + + Runtime.getRuntime().exit(0); + } + + + static void log(String message) { + if (LOG_ENABLED) { + Log.v(LOG_TAG, message); + } + } + + +} + diff --git a/libs/rs/java/Rollo/src/com/android/rollo/RolloMesh.java b/libs/rs/java/Rollo/src/com/android/rollo/RolloMesh.java new file mode 100644 index 0000000..d7252fb --- /dev/null +++ b/libs/rs/java/Rollo/src/com/android/rollo/RolloMesh.java @@ -0,0 +1,90 @@ + /* + * Copyright (C) 2009 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +package com.android.rollo; + +import java.io.Writer; +import java.lang.Math; + +import android.renderscript.RenderScript; + + +class RolloMesh { + static public final float mCardHeight = 1.2f; + static public final float mCardWidth = 1.8f; + static public final float mTabHeight = 0.2f; + static public final float mTabs = 3; + static public final float mTabGap = 0.1f; + + static RenderScript.TriangleMesh createCard(RenderScript rs) { + RenderScript.Element vtx = rs.elementGetPredefined( + RenderScript.ElementPredefined.ST_XYZ_F32); + RenderScript.Element idx = rs.elementGetPredefined( + RenderScript.ElementPredefined.INDEX_16); + + float w = mCardWidth / 2; + float h = mCardHeight; + float z = 0; + + rs.triangleMeshBegin(vtx, idx); + rs.triangleMeshAddVertex_XYZ_ST(-w, 0, z, 0, 0); + rs.triangleMeshAddVertex_XYZ_ST(-w, h, z, 0, 1); + rs.triangleMeshAddVertex_XYZ_ST( w, h, z, 1, 1); + rs.triangleMeshAddVertex_XYZ_ST( w, 0, z, 1, 0); + rs.triangleMeshAddTriangle(0,1,2); + rs.triangleMeshAddTriangle(0,2,3); + return rs.triangleMeshCreate(); + } + + static RenderScript.TriangleMesh createTab(RenderScript rs) { + RenderScript.Element vtx = rs.elementGetPredefined( + RenderScript.ElementPredefined.ST_XYZ_F32); + RenderScript.Element idx = rs.elementGetPredefined( + RenderScript.ElementPredefined.INDEX_16); + + + float tabSlope = 0.1f; + float num = 0; + + float w = (mCardWidth - ((mTabs - 1) * mTabGap)) / mTabs; + float w1 = -(mCardWidth / 2) + ((w + mTabGap) * num); + float w2 = w1 + (w * tabSlope); + float w3 = w1 + w - (w * tabSlope); + float w4 = w1 + w; + float h1 = mCardHeight; + float h2 = h1 + mTabHeight; + float z = 0; + + float stScale = w / mTabHeight / 2; + float stScale2 = stScale * (tabSlope / w); + + + rs.triangleMeshBegin(vtx, idx); + rs.triangleMeshAddVertex_XYZ_ST(w1, h1, z, -stScale, 0); + rs.triangleMeshAddVertex_XYZ_ST(w2, h2, z, -stScale2, 1); + rs.triangleMeshAddVertex_XYZ_ST(w3, h2, z, stScale2, 1); + rs.triangleMeshAddVertex_XYZ_ST(w4, h1, z, stScale, 0); + rs.triangleMeshAddTriangle(0,1,2); + rs.triangleMeshAddTriangle(0,2,3); + return rs.triangleMeshCreate(); + } + + + +} + + diff --git a/libs/rs/java/Rollo/src/com/android/rollo/RolloRS.java b/libs/rs/java/Rollo/src/com/android/rollo/RolloRS.java new file mode 100644 index 0000000..da0b146 --- /dev/null +++ b/libs/rs/java/Rollo/src/com/android/rollo/RolloRS.java @@ -0,0 +1,147 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rollo; + +import java.io.Writer; + +import android.renderscript.RenderScript; +import android.renderscript.ProgramVertexAlloc; + +import android.content.Context; +import android.content.res.Resources; +import android.graphics.Bitmap; +import android.graphics.drawable.BitmapDrawable; +import android.graphics.drawable.Drawable; +import android.os.Handler; +import android.os.Message; +import android.util.AttributeSet; +import android.util.Log; +import android.view.Surface; +import android.view.SurfaceHolder; +import android.view.SurfaceView; +import android.view.KeyEvent; +import android.view.MotionEvent; + +public class RolloRS { + + public RolloRS() { + } + + public void init(RenderScript rs, Resources res, int width, int height) { + mRS = rs; + mRes = res; + initNamed(); + initRS(); + } + + + private Resources mRes; + private RenderScript mRS; + + + private RenderScript.Script mScript; + + private RenderScript.Sampler mSampler; + private RenderScript.ProgramFragmentStore mPFSBackground; + private RenderScript.ProgramFragmentStore mPFSImages; + private RenderScript.ProgramFragment mPFBackground; + private RenderScript.ProgramFragment mPFImages; + private RenderScript.ProgramVertex mPV; + private ProgramVertexAlloc mPVAlloc; + + private RenderScript.Allocation mAllocEnv; + private RenderScript.Allocation mAllocPos; + private RenderScript.Allocation mAllocState; + //private RenderScript.Allocation mAllocPV; + private RenderScript.TriangleMesh mMeshCard; + private RenderScript.TriangleMesh mMeshTab; + + private float[] mBufferPos; + //private float[] mBufferPV; + + private void initNamed() { + mMeshTab = RolloMesh.createTab(mRS); + mMeshTab.setName("MeshTab"); + mMeshCard = RolloMesh.createCard(mRS); + mMeshCard.setName("MeshCard"); + Log.e("rs", "Done loading strips"); + + mRS.samplerBegin(); + mRS.samplerSet(RenderScript.SamplerParam.FILTER_MIN, + RenderScript.SamplerValue.LINEAR_MIP_LINEAR); + mRS.samplerSet(RenderScript.SamplerParam.WRAP_MODE_S, + RenderScript.SamplerValue.CLAMP); + mRS.samplerSet(RenderScript.SamplerParam.WRAP_MODE_T, + RenderScript.SamplerValue.CLAMP); + mSampler = mRS.samplerCreate(); + + + mRS.programFragmentBegin(null, null); + mRS.programFragmentSetTexEnable(0, true); + //mRS.programFragmentSetEnvMode(0, RS_TEX_ENV_MODE_REPLACE); + mPFImages = mRS.programFragmentCreate(); + mPFImages.setName("PF"); + mPFImages.bindSampler(mSampler, 0); + + mRS.programFragmentStoreBegin(null, null); + mRS.programFragmentStoreDepthFunc(RenderScript.DepthFunc.ALWAYS); + mRS.programFragmentStoreDitherEnable(true); + mPFSBackground = mRS.programFragmentStoreCreate(); + mPFSBackground.setName("PFSBackground"); + + /* + mRS.programFragmentStoreBegin(null, null); + mRS.programFragmentStoreDepthFunc(RenderScript.DepthFunc.EQUAL); + mRS.programFragmentStoreDitherEnable(false); + mRS.programFragmentStoreDepthMask(false); + mRS.programFragmentStoreBlendFunc(RenderScript.BlendSrcFunc.ONE, + RenderScript.BlendDstFunc.ONE); + mPFSImages = mRS.programFragmentStoreCreate(); + mPFSImages.setName("PFSImages"); +*/ + + + mPVAlloc = new ProgramVertexAlloc(mRS); + mRS.programVertexBegin(null, null); + mRS.programVertexSetTextureMatrixEnable(true); + mPV = mRS.programVertexCreate(); + mPV.setName("PV"); + mPV.bindAllocation(0, mPVAlloc.mAlloc); + + mPVAlloc.setupProjectionNormalized(320, 480); + //mPVAlloc.setupOrthoNormalized(320, 480); + mRS.contextBindProgramVertex(mPV); + + + Log.e("rs", "Done loading named"); + } + + + private void initRS() { + mRS.scriptCBegin(); + mRS.scriptCSetClearColor(0.0f, 0.7f, 0.0f, 1.0f); + mRS.scriptCSetScript(mRes, R.raw.rollo); + mRS.scriptCSetRoot(true); + mScript = mRS.scriptCCreate(); + + + mRS.contextBindRootScript(mScript); + } +} + + + diff --git a/libs/rs/java/Rollo/src/com/android/rollo/RolloView.java b/libs/rs/java/Rollo/src/com/android/rollo/RolloView.java new file mode 100644 index 0000000..9a30aed --- /dev/null +++ b/libs/rs/java/Rollo/src/com/android/rollo/RolloView.java @@ -0,0 +1,82 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rollo; + +import java.io.Writer; +import java.util.ArrayList; +import java.util.concurrent.Semaphore; + +import android.renderscript.RSSurfaceView; +import android.renderscript.RenderScript; + +import android.content.Context; +import android.content.res.Resources; +import android.graphics.Bitmap; +import android.graphics.drawable.BitmapDrawable; +import android.graphics.drawable.Drawable; +import android.os.Handler; +import android.os.Message; +import android.util.AttributeSet; +import android.util.Log; +import android.view.Surface; +import android.view.SurfaceHolder; +import android.view.SurfaceView; +import android.view.KeyEvent; +import android.view.MotionEvent; + +public class RolloView extends RSSurfaceView { + + public RolloView(Context context) { + super(context); + + //setFocusable(true); + } + + private RenderScript mRS; + private RolloRS mRender; + + public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) { + super.surfaceChanged(holder, format, w, h); + + mRS = createRenderScript(); + mRender = new RolloRS(); + mRender.init(mRS, getResources(), w, h); + } + + @Override + public boolean onKeyDown(int keyCode, KeyEvent event) + { + // break point at here + // this method doesn't work when 'extends View' include 'extends ScrollView'. + return super.onKeyDown(keyCode, event); + } + + + @Override + public boolean onTouchEvent(MotionEvent ev) + { + boolean ret = true; + int act = ev.getAction(); + if (act == ev.ACTION_UP) { + ret = false; + } + //mRender.newTouchPosition((int)ev.getX(), (int)ev.getY()); + return ret; + } +} + + |
