| /* |
| * Copyright (C) 2010 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.ex.carousel; |
| |
| import android.content.res.Resources; |
| import android.graphics.Bitmap; |
| import android.graphics.Rect; |
| import android.renderscript.*; |
| import static android.renderscript.Element.*; |
| import android.renderscript.Program.TextureType; |
| import android.renderscript.RenderScript.RSMessageHandler; |
| import android.util.Log; |
| |
| /** |
| * This is a support class for Carousel renderscript. It handles most of the low-level interactions |
| * with Renderscript as well as dispatching events. |
| * |
| */ |
| public class CarouselRS { |
| private static final int DEFAULT_VISIBLE_SLOTS = 1; |
| private static final int DEFAULT_CARD_COUNT = 0; |
| private static final int DEFAULT_ROW_COUNT = 1; |
| |
| // Client messages *** THIS LIST MUST MATCH THOSE IN carousel.rs *** |
| public static final int CMD_CARD_SELECTED = 100; |
| public static final int CMD_DETAIL_SELECTED = 105; |
| public static final int CMD_CARD_LONGPRESS = 110; |
| public static final int CMD_REQUEST_TEXTURE = 200; |
| public static final int CMD_INVALIDATE_TEXTURE = 210; |
| public static final int CMD_REQUEST_GEOMETRY = 300; |
| public static final int CMD_INVALIDATE_GEOMETRY = 310; |
| public static final int CMD_ANIMATION_STARTED = 400; |
| public static final int CMD_ANIMATION_FINISHED = 500; |
| public static final int CMD_REQUEST_DETAIL_TEXTURE = 600; |
| public static final int CMD_INVALIDATE_DETAIL_TEXTURE = 610; |
| public static final int CMD_PING = 1000; // for debugging |
| |
| // Drag models *** THIS LIST MUST MATCH THOSE IN carousel.rs *** |
| public static final int DRAG_MODEL_SCREEN_DELTA = 0; |
| public static final int DRAG_MODEL_PLANE = 1; |
| public static final int DRAG_MODEL_CYLINDER_INSIDE = 2; |
| public static final int DRAG_MODEL_CYLINDER_OUTSIDE = 3; |
| |
| public static final int FILL_DIRECTION_CCW = +1; |
| public static final int FILL_DIRECTION_CW = -1; |
| |
| private static final String TAG = "CarouselRS"; |
| private static final int DEFAULT_SLOT_COUNT = 10; |
| private static final Allocation.MipmapControl MIPMAP = |
| Allocation.MipmapControl.MIPMAP_NONE; |
| private static final boolean DBG = false; |
| |
| private RenderScriptGL mRS; |
| private Resources mRes; |
| private ScriptC_carousel mScript; |
| private ScriptField_Card mCards; |
| private ScriptField_FragmentShaderConstants_s mFSConst; |
| private ScriptField_ProgramStore_s mProgramStoresCard; |
| private ProgramFragment mSingleTextureFragmentProgram; |
| private ProgramFragment mSingleTextureBlendingFragmentProgram; |
| private ProgramFragment mMultiTextureFragmentProgram; |
| private ProgramFragment mMultiTextureBlendingFragmentProgram; |
| private ProgramVertex mVertexProgram; |
| private ProgramRaster mRasterProgram; |
| private Allocation[] mAllocationPool; |
| private boolean mForceBlendCardsWithZ; |
| private int mVisibleSlots; |
| private int mRowCount; |
| private int mPrefetchCardCount; |
| private CarouselCallback mCallback; |
| private float[] mEyePoint = new float[] { 2.0f, 0.0f, 0.0f }; |
| private float[] mAtPoint = new float[] { 0.0f, 0.0f, 0.0f }; |
| private float[] mUp = new float[] { 0.0f, 1.0f, 0.0f }; |
| |
| private static final String mSingleTextureShader = new String( |
| "varying vec2 varTex0;" + |
| "void main() {" + |
| "vec2 t0 = varTex0.xy;" + |
| "vec4 col = texture2D(UNI_Tex0, t0);" + |
| "gl_FragColor = col; " + |
| "}"); |
| |
| private static final String mSingleTextureBlendingShader = new String( |
| "varying vec2 varTex0;" + |
| "void main() {" + |
| "vec2 t0 = varTex0.xy;" + |
| "vec4 col = texture2D(UNI_Tex0, t0);" + |
| "gl_FragColor = col * UNI_overallAlpha; " + |
| "}"); |
| |
| private static final String mMultiTextureShader = new String( |
| "varying vec2 varTex0;" + |
| "void main() {" + |
| "vec2 t0 = varTex0.xy;" + |
| "vec4 col = texture2D(UNI_Tex0, t0);" + |
| "vec4 col2 = texture2D(UNI_Tex1, t0);" + |
| "gl_FragColor = mix(col, col2, UNI_fadeAmount);}"); |
| |
| private static final String mMultiTextureBlendingShader = new String( |
| "varying vec2 varTex0;" + |
| "void main() {" + |
| "vec2 t0 = varTex0.xy;" + |
| "vec4 col = texture2D(UNI_Tex0, t0);" + |
| "vec4 col2 = texture2D(UNI_Tex1, t0);" + |
| "gl_FragColor = mix(col, col2, UNI_fadeAmount) * UNI_overallAlpha;" + |
| "}" |
| ); |
| |
| public static interface CarouselCallback { |
| /** |
| * Called when a card is selected |
| * @param n the id of the card |
| */ |
| void onCardSelected(int n); |
| |
| /** |
| * Called when the detail texture for a card is tapped |
| * @param n the id of the card |
| * @param x how far the user tapped from the left edge of the card, in pixels |
| * @param y how far the user tapped from the top edge of the card, in pixels |
| */ |
| void onDetailSelected(int n, int x, int y); |
| |
| /** |
| * Called when a card is long-pressed |
| * @param n the id of the card |
| * @param touchPosition position of where the user pressed, in screen coordinates |
| * @param detailCoordinates position of detail texture, in screen coordinates |
| */ |
| void onCardLongPress(int n, int touchPosition[], Rect detailCoordinates); |
| |
| /** |
| * Called when texture is needed for card n. This happens when the given card becomes |
| * visible. |
| * @param n the id of the card |
| */ |
| void onRequestTexture(int n); |
| |
| /** |
| * Called when a texture is no longer needed for card n. This happens when the card |
| * goes out of view. |
| * @param n the id of the card |
| */ |
| void onInvalidateTexture(int n); |
| |
| /** |
| * Called when detail texture is needed for card n. This happens when the given card |
| * becomes visible. |
| * @param n the id of the card |
| */ |
| void onRequestDetailTexture(int n); |
| |
| /** |
| * Called when a detail texture is no longer needed for card n. This happens when the card |
| * goes out of view. |
| * @param n the id of the card |
| */ |
| void onInvalidateDetailTexture(int n); |
| |
| /** |
| * Called when geometry is needed for card n. |
| * @param n the id of the card. |
| */ |
| void onRequestGeometry(int n); |
| |
| /** |
| * Called when geometry is no longer needed for card n. This happens when the card goes |
| * out of view. |
| * @param n the id of the card |
| */ |
| void onInvalidateGeometry(int n); |
| |
| /** |
| * Called when card animation (e.g. a fling) has started. |
| */ |
| void onAnimationStarted(); |
| |
| /** |
| * Called when card animation has stopped. |
| * @param carouselRotationAngle the angle of rotation, in radians, at which the animation |
| * stopped. |
| */ |
| void onAnimationFinished(float carouselRotationAngle); |
| }; |
| |
| private RSMessageHandler mRsMessage = new RSMessageHandler() { |
| public void run() { |
| if (mCallback == null) return; |
| switch (mID) { |
| case CMD_CARD_SELECTED: |
| mCallback.onCardSelected(mData[0]); |
| break; |
| |
| case CMD_DETAIL_SELECTED: |
| mCallback.onDetailSelected(mData[0], mData[1], mData[2]); |
| break; |
| |
| case CMD_CARD_LONGPRESS: |
| int touchPosition[] = { mData[1], mData[2] }; |
| Rect detailCoordinates = new Rect(mData[3], mData[4], mData[5], mData[6]); |
| mCallback.onCardLongPress(mData[0], touchPosition, detailCoordinates); |
| break; |
| |
| case CMD_REQUEST_TEXTURE: |
| mCallback.onRequestTexture(mData[0]); |
| break; |
| |
| case CMD_INVALIDATE_TEXTURE: |
| setTexture(mData[0], null); |
| mCallback.onInvalidateTexture(mData[0]); |
| break; |
| |
| case CMD_REQUEST_DETAIL_TEXTURE: |
| mCallback.onRequestDetailTexture(mData[0]); |
| break; |
| |
| case CMD_INVALIDATE_DETAIL_TEXTURE: |
| setDetailTexture(mData[0], 0.0f, 0.0f, 0.0f, 0.0f, null); |
| mCallback.onInvalidateDetailTexture(mData[0]); |
| break; |
| |
| case CMD_REQUEST_GEOMETRY: |
| mCallback.onRequestGeometry(mData[0]); |
| break; |
| |
| case CMD_INVALIDATE_GEOMETRY: |
| setGeometry(mData[0], null); |
| mCallback.onInvalidateGeometry(mData[0]); |
| break; |
| |
| case CMD_ANIMATION_STARTED: |
| mCallback.onAnimationStarted(); |
| break; |
| |
| case CMD_ANIMATION_FINISHED: |
| mCallback.onAnimationFinished(Float.intBitsToFloat(mData[0])); |
| break; |
| |
| case CMD_PING: |
| if (DBG) Log.v(TAG, "PING..."); |
| break; |
| |
| default: |
| Log.e(TAG, "Unknown RSMessage: " + mID); |
| } |
| } |
| }; |
| |
| public CarouselRS(RenderScriptGL rs, Resources res, int resId) { |
| mRS = rs; |
| mRes = res; |
| |
| // create the script object |
| mScript = new ScriptC_carousel(mRS, mRes, resId); |
| mRS.setMessageHandler(mRsMessage); |
| initProgramStore(); |
| initFragmentProgram(); |
| initRasterProgram(); |
| initVertexProgram(); |
| setSlotCount(DEFAULT_SLOT_COUNT); |
| setVisibleSlots(DEFAULT_VISIBLE_SLOTS); |
| setRowCount(DEFAULT_ROW_COUNT); |
| createCards(DEFAULT_CARD_COUNT); |
| setStartAngle(0.0f); |
| setCarouselRotationAngle(0.0f); |
| setRadius(1.0f); |
| setLookAt(mEyePoint, mAtPoint, mUp); |
| setRadius(20.0f); |
| // Fov: 25 |
| } |
| |
| public void setLookAt(float[] eye, float[] at, float[] up) { |
| for (int i = 0; i < 3; i++) { |
| mEyePoint[i] = eye[i]; |
| mAtPoint[i] = at[i]; |
| mUp[i] = up[i]; |
| } |
| mScript.invoke_lookAt(eye[0], eye[1], eye[2], at[0], at[1], at[2], up[0], up[1], up[2]); |
| } |
| |
| public void setRadius(float radius) { |
| mScript.invoke_setRadius(radius); |
| } |
| |
| public void setCardRotation(float cardRotation) { |
| mScript.set_cardRotation(cardRotation); |
| } |
| |
| public void setCardsFaceTangent(boolean faceTangent) { |
| mScript.set_cardsFaceTangent(faceTangent); |
| } |
| |
| public void setSwaySensitivity(float swaySensitivity) { |
| mScript.set_swaySensitivity(swaySensitivity); |
| } |
| |
| public void setFrictionCoefficient(float frictionCoeff) { |
| mScript.set_frictionCoeff(frictionCoeff); |
| } |
| |
| public void setDragFactor(float dragFactor) { |
| mScript.set_dragFactor(dragFactor); |
| } |
| |
| public void setDragModel(int model) { |
| mScript.set_dragModel(model); |
| } |
| |
| public void setFillDirection(int direction) { |
| mScript.set_fillDirection(direction); |
| } |
| |
| private Matrix4f matrixFromFloat(float[] matrix) { |
| int dimensions; |
| if (matrix == null || matrix.length == 0) { |
| dimensions = 0; |
| } else if (matrix.length == 16) { |
| dimensions = 4; |
| } else if (matrix.length == 9) { |
| dimensions = 3; |
| } else { |
| throw new IllegalArgumentException("matrix length not 0,9 or 16"); |
| } |
| |
| Matrix4f rsMatrix = new Matrix4f(); // initialized as identity. |
| for (int i = 0; i < dimensions; i++) { |
| for (int j = 0; j < dimensions; j++) { |
| rsMatrix.set(i, j, matrix[i*dimensions + j]); |
| } |
| } |
| |
| return rsMatrix; |
| } |
| |
| public void setDefaultCardMatrix(float[] matrix) { |
| mScript.set_defaultCardMatrix(matrixFromFloat(matrix)); |
| } |
| |
| private void initVertexProgram() { |
| ProgramVertexFixedFunction.Builder pvb = new ProgramVertexFixedFunction.Builder(mRS); |
| mVertexProgram = pvb.create(); |
| ProgramVertexFixedFunction.Constants pva = new ProgramVertexFixedFunction.Constants(mRS); |
| ((ProgramVertexFixedFunction)mVertexProgram).bindConstants(pva); |
| Matrix4f proj = new Matrix4f(); |
| proj.loadProjectionNormalized(1, 1); |
| pva.setProjection(proj); |
| mScript.set_vertexProgram(mVertexProgram); |
| } |
| |
| private void initRasterProgram() { |
| ProgramRaster.Builder programRasterBuilder = new ProgramRaster.Builder(mRS); |
| mRasterProgram = programRasterBuilder.create(); |
| //mRasterProgram.setCullMode(CullMode.NONE); |
| mScript.set_rasterProgram(mRasterProgram); |
| } |
| |
| private void initFragmentProgram() { |
| // |
| // Single texture program |
| // |
| ProgramFragment.Builder pfbSingle = new ProgramFragment.Builder(mRS); |
| // Specify the resource that contains the shader string |
| pfbSingle.setShader(mSingleTextureShader); |
| // Tell the builder how many textures we have |
| pfbSingle.addTexture(Program.TextureType.TEXTURE_2D); |
| mSingleTextureFragmentProgram = pfbSingle.create(); |
| // Bind the source of constant data |
| mSingleTextureFragmentProgram.bindSampler(Sampler.CLAMP_LINEAR(mRS), 0); |
| |
| // |
| // Single texture program, plus blending |
| // |
| mFSConst = new ScriptField_FragmentShaderConstants_s(mRS, 1); |
| mScript.bind_shaderConstants(mFSConst); |
| ProgramFragment.Builder pfbSingleBlend = new ProgramFragment.Builder(mRS); |
| // Specify the resource that contains the shader string |
| pfbSingleBlend.setShader(mSingleTextureBlendingShader); |
| // Tell the builder how many textures we have |
| pfbSingleBlend.addTexture(Program.TextureType.TEXTURE_2D); |
| // Define the constant input layout |
| pfbSingleBlend.addConstant(mFSConst.getAllocation().getType()); |
| mSingleTextureBlendingFragmentProgram = pfbSingleBlend.create(); |
| // Bind the source of constant data |
| mSingleTextureBlendingFragmentProgram.bindConstants(mFSConst.getAllocation(), 0); |
| mSingleTextureBlendingFragmentProgram.bindSampler(Sampler.CLAMP_LINEAR(mRS), 0); |
| |
| // |
| // Multi texture program |
| // |
| ProgramFragment.Builder pfbMulti = new ProgramFragment.Builder(mRS); |
| // Specify the resource that contains the shader string |
| pfbMulti.setShader(mMultiTextureShader); |
| // Tell the builder how many textures we have |
| pfbMulti.addTexture(Program.TextureType.TEXTURE_2D); |
| pfbMulti.addTexture(Program.TextureType.TEXTURE_2D); |
| // Define the constant input layout |
| pfbMulti.addConstant(mFSConst.getAllocation().getType()); |
| mMultiTextureFragmentProgram = pfbMulti.create(); |
| // Bind the source of constant data |
| mMultiTextureFragmentProgram.bindConstants(mFSConst.getAllocation(), 0); |
| mMultiTextureFragmentProgram.bindSampler(Sampler.CLAMP_LINEAR(mRS), 0); |
| mMultiTextureFragmentProgram.bindSampler(Sampler.CLAMP_LINEAR(mRS), 1); |
| |
| // |
| // Multi texture program, plus blending |
| // |
| ProgramFragment.Builder pfbMultiBlend = new ProgramFragment.Builder(mRS); |
| // Specify the resource that contains the shader string |
| pfbMultiBlend.setShader(mMultiTextureBlendingShader); |
| // Tell the builder how many textures we have |
| pfbMultiBlend.addTexture(Program.TextureType.TEXTURE_2D); |
| pfbMultiBlend.addTexture(Program.TextureType.TEXTURE_2D); |
| // Define the constant input layout |
| pfbMultiBlend.addConstant(mFSConst.getAllocation().getType()); |
| mMultiTextureBlendingFragmentProgram = pfbMultiBlend.create(); |
| // Bind the source of constant data |
| mMultiTextureBlendingFragmentProgram.bindConstants(mFSConst.getAllocation(), 0); |
| mMultiTextureBlendingFragmentProgram.bindSampler(Sampler.CLAMP_LINEAR(mRS), 0); |
| mMultiTextureBlendingFragmentProgram.bindSampler(Sampler.CLAMP_LINEAR(mRS), 1); |
| |
| mScript.set_linearClamp(Sampler.CLAMP_LINEAR(mRS)); |
| mScript.set_singleTextureFragmentProgram(mSingleTextureFragmentProgram); |
| mScript.set_singleTextureBlendingFragmentProgram(mSingleTextureBlendingFragmentProgram); |
| mScript.set_multiTextureFragmentProgram(mMultiTextureFragmentProgram); |
| mScript.set_multiTextureBlendingFragmentProgram(mMultiTextureBlendingFragmentProgram); |
| } |
| |
| private void initProgramStore() { |
| resizeProgramStoresCard(1); |
| |
| final boolean dither = true; |
| final ProgramStore.DepthFunc depthFunc = mForceBlendCardsWithZ ? |
| ProgramStore.DepthFunc.LESS : ProgramStore.DepthFunc.ALWAYS; |
| |
| // Background: Alpha disabled, depth optional |
| mScript.set_programStoreBackground(new ProgramStore.Builder(mRS) |
| .setBlendFunc(ProgramStore.BlendSrcFunc.ONE, ProgramStore.BlendDstFunc.ZERO) |
| .setDitherEnabled(dither) |
| .setDepthFunc(depthFunc) |
| .setDepthMaskEnabled(mForceBlendCardsWithZ) |
| .create()); |
| |
| // Card: Alpha enabled, depth optional |
| setProgramStoreCard(0, new ProgramStore.Builder(mRS) |
| .setBlendFunc(ProgramStore.BlendSrcFunc.ONE, |
| ProgramStore.BlendDstFunc.ONE_MINUS_SRC_ALPHA) |
| .setDitherEnabled(dither) |
| .setDepthFunc(depthFunc) |
| .setDepthMaskEnabled(mForceBlendCardsWithZ) |
| .create()); |
| |
| // Detail: Alpha enabled, depth disabled |
| mScript.set_programStoreDetail(new ProgramStore.Builder(mRS) |
| .setBlendFunc(ProgramStore.BlendSrcFunc.ONE, |
| ProgramStore.BlendDstFunc.ONE_MINUS_SRC_ALPHA) |
| .setDitherEnabled(dither) |
| .setDepthFunc(ProgramStore.DepthFunc.ALWAYS) |
| .setDepthMaskEnabled(false) |
| .create()); |
| } |
| |
| public void createCards(int count) |
| { |
| // Because RenderScript can't have allocations with 0 dimensions, we always create |
| // an allocation of at least one card. This relies on invoke_createCards() to keep |
| // track of when the allocation is not valid. |
| if (mCards != null && count > 0) { |
| // resize the array |
| int oldSize = mCards.getAllocation().getType().getX(); |
| mCards.resize(count); |
| mScript.invoke_createCards(oldSize, count); |
| } else { |
| // create array from scratch |
| mCards = new ScriptField_Card(mRS, count > 0 ? count : 1); |
| mScript.bind_cards(mCards); |
| mScript.invoke_createCards(0, count); |
| } |
| } |
| |
| public void setVisibleSlots(int count) |
| { |
| mVisibleSlots = count; |
| mScript.set_visibleSlotCount(count); |
| } |
| |
| public void setVisibleDetails(int count) { |
| mScript.set_visibleDetailCount(count); |
| } |
| |
| public void setRowCount(int count) { |
| mRowCount = count; |
| mScript.set_rowCount(count); |
| } |
| |
| public void setRowSpacing(float spacing) { |
| mScript.set_rowSpacing(spacing); |
| } |
| |
| public void setOverscrollSlots(float slots) { |
| mScript.set_overscrollSlots(slots); |
| } |
| |
| public void setFirstCardTop(boolean first) { |
| mScript.set_firstCardTop(first); |
| } |
| |
| public void setPrefetchCardCount(int count) { |
| mPrefetchCardCount = count; |
| mScript.set_prefetchCardCount(count); |
| } |
| |
| public void setDetailTextureAlignment(int alignment) { |
| mScript.set_detailTextureAlignment(alignment); |
| } |
| |
| private void resizeProgramStoresCard(int count) { |
| // enableResize works around a Renderscript bug that keeps resizes from being propagated. |
| // TODO(jshuma): Remove enableResize once the Renderscript bug is fixed |
| final boolean enableResize = false; |
| |
| if (mProgramStoresCard != null && enableResize) { |
| int newSize = count > 0 ? count : 1; |
| mProgramStoresCard.resize(newSize); |
| } else { |
| mProgramStoresCard = new ScriptField_ProgramStore_s(mRS, count > 0 ? count : 1); |
| mScript.bind_programStoresCard(mProgramStoresCard); |
| } |
| } |
| |
| private void setProgramStoreCard(int n, ProgramStore programStore) { |
| ScriptField_ProgramStore_s.Item item = mProgramStoresCard.get(n); |
| if (item == null) { |
| item = new ScriptField_ProgramStore_s.Item(); |
| } |
| item.programStore = programStore; |
| mProgramStoresCard.set(item, n, false); |
| mScript.invoke_setProgramStoresCard(n, programStore); |
| } |
| |
| public void setStoreConfigs(int configs[]) { |
| if (configs == null) { |
| initProgramStore(); |
| return; |
| } |
| |
| final int count = configs.length; |
| |
| resizeProgramStoresCard(count); |
| for (int i=0; i<count; ++i) { |
| final int config = configs[i]; |
| |
| final boolean alpha = (config & CarouselController.STORE_CONFIG_ALPHA) != 0; |
| final boolean depthReads = (config & CarouselController.STORE_CONFIG_DEPTH_READS) != 0; |
| final boolean depthWrites = |
| (config & CarouselController.STORE_CONFIG_DEPTH_WRITES) != 0; |
| |
| final boolean dither = true; |
| final ProgramStore.BlendDstFunc dstFunc = alpha ? |
| ProgramStore.BlendDstFunc.ONE_MINUS_SRC_ALPHA : |
| ProgramStore.BlendDstFunc.ZERO; |
| final ProgramStore.DepthFunc depthFunc = depthReads ? |
| ProgramStore.DepthFunc.LESS : |
| ProgramStore.DepthFunc.ALWAYS; |
| |
| final ProgramStore ps = new ProgramStore.Builder(mRS) |
| .setBlendFunc(ProgramStore.BlendSrcFunc.ONE, dstFunc) |
| .setDitherEnabled(dither) |
| .setDepthFunc(depthFunc) |
| .setDepthMaskEnabled(depthWrites) |
| .create(); |
| |
| setProgramStoreCard(i, ps); |
| } |
| } |
| |
| /** |
| * Sets whether the background texture and default card geometry are to be drawn with respect |
| * to the depth buffer (both reading from it and writing to it). |
| * |
| * This method is a specialization of functionality that can be done with greater flexibility |
| * by setStoreConfigs. Calling setForceBlendCardsWithZ() after calling setStoreConfigs() |
| * results in the values set in setStoreConfigs() being discarded. |
| * |
| * @param enabled true to read from and write to the depth buffer, false to ignore it |
| */ |
| public void setForceBlendCardsWithZ(boolean enabled) { |
| mForceBlendCardsWithZ = enabled; |
| initProgramStore(); |
| } |
| |
| public void setDrawRuler(boolean drawRuler) { |
| mScript.set_drawRuler(drawRuler); |
| } |
| |
| public void setDefaultBitmap(Bitmap bitmap) |
| { |
| mScript.set_defaultTexture(allocationFromBitmap(bitmap, MIPMAP)); |
| } |
| |
| public void setLoadingBitmap(Bitmap bitmap) |
| { |
| mScript.set_loadingTexture(allocationFromBitmap(bitmap, MIPMAP)); |
| } |
| |
| public void setDefaultGeometry(Mesh mesh) |
| { |
| mScript.set_defaultGeometry(mesh); |
| } |
| |
| public void setLoadingGeometry(Mesh mesh) |
| { |
| mScript.set_loadingGeometry(mesh); |
| } |
| |
| public void setStartAngle(float theta) |
| { |
| mScript.set_startAngle(theta); |
| } |
| |
| public void setCarouselRotationAngle(float theta) { |
| mScript.invoke_setCarouselRotationAngle(theta); |
| } |
| |
| public void setCarouselRotationAngle(float endAngle, int milliseconds, int interpolationMode, |
| float maxAnimatedArc) { |
| mScript.invoke_setCarouselRotationAngle2(endAngle, milliseconds, interpolationMode, |
| maxAnimatedArc); |
| } |
| |
| public void setCallback(CarouselCallback callback) |
| { |
| mCallback = callback; |
| } |
| |
| private Allocation allocationFromBitmap(Bitmap bitmap, Allocation.MipmapControl mipmap) |
| { |
| if (bitmap == null) return null; |
| Allocation allocation = Allocation.createFromBitmap(mRS, bitmap, |
| mipmap, Allocation.USAGE_GRAPHICS_TEXTURE); |
| return allocation; |
| } |
| |
| private Allocation allocationFromPool(int n, Bitmap bitmap, Allocation.MipmapControl mipmap) |
| { |
| int count = (mVisibleSlots + 2*mPrefetchCardCount) * mRowCount; |
| if (mAllocationPool == null || mAllocationPool.length != count) { |
| Allocation[] tmp = new Allocation[count]; |
| int oldsize = mAllocationPool == null ? 0 : mAllocationPool.length; |
| for (int i = 0; i < Math.min(count, oldsize); i++) { |
| tmp[i] = mAllocationPool[i]; |
| } |
| mAllocationPool = tmp; |
| } |
| Allocation allocation = mAllocationPool[n % count]; |
| if (allocation == null) { |
| allocation = allocationFromBitmap(bitmap, mipmap); |
| mAllocationPool[n % count] = allocation; |
| } else if (bitmap != null) { |
| if (bitmap.getWidth() == allocation.getType().getX() |
| && bitmap.getHeight() == allocation.getType().getY()) { |
| allocation.copyFrom(bitmap); |
| } else { |
| Log.v(TAG, "Warning, bitmap has different size. Taking slow path"); |
| allocation = allocationFromBitmap(bitmap, mipmap); |
| mAllocationPool[n % count] = allocation; |
| } |
| } |
| return allocation; |
| } |
| |
| private ScriptField_Card.Item getCard(int n) { |
| ScriptField_Card.Item item; |
| try { |
| item = mCards.get(n); |
| } |
| catch (ArrayIndexOutOfBoundsException e) { |
| if (DBG) Log.v(TAG, "getCard(): no item at index " + n); |
| item = null; |
| } |
| return item; |
| } |
| |
| private ScriptField_Card.Item getOrCreateCard(int n) { |
| ScriptField_Card.Item item = getCard(n); |
| if (item == null) { |
| if (DBG) Log.v(TAG, "getOrCreateCard(): no item at index " + n + "; creating new"); |
| item = new ScriptField_Card.Item(); |
| } |
| return item; |
| } |
| |
| private void setCard(int n, ScriptField_Card.Item item) { |
| try { |
| mCards.set(item, n, false); // This is primarily used for reference counting. |
| } |
| catch (ArrayIndexOutOfBoundsException e) { |
| // The specified index didn't exist. This can happen when a stale invalidate |
| // request outlived an array resize request. Something might be getting dropped, |
| // but there's not much we can do about this at this point to recover. |
| Log.w(TAG, "setCard(" + n + "): Texture " + n + " doesn't exist"); |
| } |
| } |
| |
| public void setTexture(int n, Bitmap bitmap) |
| { |
| if (n < 0) throw new IllegalArgumentException("Index cannot be negative"); |
| |
| synchronized(this) { |
| ScriptField_Card.Item item = getOrCreateCard(n); |
| if (bitmap != null) { |
| item.texture = allocationFromPool(n, bitmap, MIPMAP); |
| } else { |
| if (item.texture != null) { |
| if (DBG) Log.v(TAG, "unloading texture " + n); |
| item.texture = null; |
| } |
| } |
| setCard(n, item); |
| mScript.invoke_setTexture(n, item.texture); |
| } |
| } |
| |
| void setDetailTexture(int n, float offx, float offy, float loffx, float loffy, Bitmap bitmap) |
| { |
| if (n < 0) throw new IllegalArgumentException("Index cannot be negative"); |
| |
| synchronized(this) { |
| ScriptField_Card.Item item = getOrCreateCard(n); |
| float width = 0.0f; |
| float height = 0.0f; |
| if (bitmap != null) { |
| item.detailTexture = allocationFromBitmap(bitmap, MIPMAP); |
| width = bitmap.getWidth(); |
| height = bitmap.getHeight(); |
| } else { |
| if (item.detailTexture != null) { |
| if (DBG) Log.v(TAG, "unloading detail texture " + n); |
| // Don't wait for GC to free native memory. |
| // Only works if textures are not shared. |
| item.detailTexture.destroy(); |
| item.detailTexture = null; |
| } |
| } |
| setCard(n, item); |
| mScript.invoke_setDetailTexture(n, offx, offy, loffx, loffy, item.detailTexture); |
| } |
| } |
| |
| void invalidateTexture(int n, boolean eraseCurrent) |
| { |
| if (n < 0) throw new IllegalArgumentException("Index cannot be negative"); |
| |
| synchronized(this) { |
| ScriptField_Card.Item item = getCard(n); |
| if (item == null) { |
| // This card was never created, so there's nothing to invalidate. |
| return; |
| } |
| if (eraseCurrent && item.texture != null) { |
| if (DBG) Log.v(TAG, "unloading texture " + n); |
| // Don't wait for GC to free native memory. |
| // Only works if textures are not shared. |
| item.texture.destroy(); |
| item.texture = null; |
| } |
| setCard(n, item); |
| mScript.invoke_invalidateTexture(n, eraseCurrent); |
| } |
| } |
| |
| void invalidateDetailTexture(int n, boolean eraseCurrent) |
| { |
| if (n < 0) throw new IllegalArgumentException("Index cannot be negative"); |
| |
| synchronized(this) { |
| ScriptField_Card.Item item = getCard(n); |
| if (item == null) { |
| // This card was never created, so there's nothing to invalidate. |
| return; |
| } |
| if (eraseCurrent && item.detailTexture != null) { |
| if (DBG) Log.v(TAG, "unloading detail texture " + n); |
| // Don't wait for GC to free native memory. |
| // Only works if textures are not shared. |
| item.detailTexture.destroy(); |
| item.detailTexture = null; |
| } |
| setCard(n, item); |
| mScript.invoke_invalidateDetailTexture(n, eraseCurrent); |
| } |
| } |
| |
| public void setGeometry(int n, Mesh geometry) |
| { |
| if (n < 0) throw new IllegalArgumentException("Index cannot be negative"); |
| |
| synchronized(this) { |
| final boolean mipmap = false; |
| ScriptField_Card.Item item = getOrCreateCard(n); |
| if (geometry != null) { |
| item.geometry = geometry; |
| } else { |
| if (DBG) Log.v(TAG, "unloading geometry " + n); |
| if (item.geometry != null) { |
| // item.geometry.destroy(); |
| item.geometry = null; |
| } |
| } |
| setCard(n, item); |
| mScript.invoke_setGeometry(n, item.geometry); |
| } |
| } |
| |
| public void setMatrix(int n, float[] matrix) { |
| if (n < 0) throw new IllegalArgumentException("Index cannot be negative"); |
| |
| synchronized(this) { |
| final boolean mipmap = false; |
| ScriptField_Card.Item item = getOrCreateCard(n); |
| if (matrix != null) { |
| item.matrix = matrixFromFloat(matrix); |
| } else { |
| if (DBG) Log.v(TAG, "unloading matrix " + n); |
| item.matrix = null; |
| } |
| setCard(n, item); |
| mScript.invoke_setMatrix(n, item.matrix); |
| } |
| } |
| |
| public void setBackgroundColor(Float4 color) { |
| mScript.set_backgroundColor(color); |
| } |
| |
| public void setBackgroundTexture(Bitmap bitmap) { |
| Allocation texture = null; |
| if (bitmap != null) { |
| texture = Allocation.createFromBitmap(mRS, bitmap, |
| MIPMAP, Allocation.USAGE_GRAPHICS_TEXTURE); |
| } |
| mScript.set_backgroundTexture(texture); |
| } |
| |
| public void setDetailLineTexture(Bitmap bitmap) { |
| Allocation texture = null; |
| if (bitmap != null) { |
| texture = Allocation.createFromBitmap(mRS, bitmap, |
| MIPMAP, Allocation.USAGE_GRAPHICS_TEXTURE); |
| } |
| mScript.set_detailLineTexture(texture); |
| } |
| |
| public void setDetailLoadingTexture(Bitmap bitmap) { |
| Allocation texture = null; |
| if (bitmap != null) { |
| texture = Allocation.createFromBitmap(mRS, bitmap, |
| MIPMAP, Allocation.USAGE_GRAPHICS_TEXTURE); |
| } |
| mScript.set_detailLoadingTexture(texture); |
| } |
| |
| public void pauseRendering() { |
| // Used to update multiple states at once w/o redrawing for each. |
| mRS.bindRootScript(null); |
| } |
| |
| public void resumeRendering() { |
| mRS.bindRootScript(mScript); |
| } |
| |
| public void doLongPress() { |
| mScript.invoke_doLongPress(); |
| } |
| |
| public void doMotion(float x, float y, long t) { |
| mScript.invoke_doMotion(x, y, t); |
| } |
| |
| public void doStart(float x, float y, long t) { |
| mScript.invoke_doStart(x, y, t); |
| } |
| |
| public void doStop(float x, float y, long t) { |
| mScript.invoke_doStop(x, y, t); |
| } |
| |
| public void setSlotCount(int n) { |
| mScript.set_slotCount(n); |
| } |
| |
| public void setRezInCardCount(float alpha) { |
| mScript.set_rezInCardCount(alpha); |
| } |
| |
| public void setFadeInDuration(long t) { |
| mScript.set_fadeInDuration((int)t); // TODO: Remove cast when RS supports exporting longs |
| } |
| |
| public void setCardCreationFadeDuration(long t) { |
| mScript.set_cardCreationFadeDuration((int)t); |
| } |
| |
| private Element elementForBitmap(Bitmap bitmap, Bitmap.Config defaultConfig) { |
| Bitmap.Config config = bitmap.getConfig(); |
| if (config == null) { |
| config = defaultConfig; |
| } |
| if (config == Bitmap.Config.ALPHA_8) { |
| return A_8(mRS); |
| } else if (config == Bitmap.Config.RGB_565) { |
| return RGB_565(mRS); |
| } else if (config == Bitmap.Config.ARGB_4444) { |
| return RGBA_4444(mRS); |
| } else if (config == Bitmap.Config.ARGB_8888) { |
| return RGBA_8888(mRS); |
| } else { |
| throw new IllegalArgumentException("Unknown configuration"); |
| } |
| } |
| |
| public Mesh loadGeometry(int resId) { |
| if (resId == 0) { |
| return null; |
| } |
| FileA3D model = FileA3D.createFromResource(mRS, mRes, resId); |
| if (model == null) { |
| return null; |
| } |
| FileA3D.IndexEntry entry = model.getIndexEntry(0); |
| if(entry == null || entry.getEntryType() != FileA3D.EntryType.MESH) { |
| return null; |
| } |
| return (Mesh) entry.getObject(); |
| } |
| } |
