/*
* 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();
}
}