/*
 * 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 com.android.ex.carousel.CarouselRS.CarouselCallback;
import com.android.ex.carousel.CarouselView.DetailAlignment;

import android.graphics.Bitmap;
import android.renderscript.Float4;
import android.renderscript.Mesh;
import android.renderscript.RenderScriptGL;
import android.util.Log;

/**
 * <p>
 * This class represents the basic building block for using a 3D Carousel. The Carousel is
 * basically a scene of cards and slots.  The spacing between cards is dictated by the number
 * of slots and the radius. The number of visible cards dictates how far the Carousel can be moved.
 * If the number of cards exceeds the number of slots, then the Carousel will continue to go
 * around until the last card can be seen.
 */
public class CarouselController {
    private final int DEFAULT_SLOT_COUNT = 10;
    private final float DEFAULT_RADIUS = 20.0f;
    private final int DEFAULT_VISIBLE_DETAIL_COUNT = 3;
    private final int DEFAULT_PREFETCH_CARD_COUNT = 2;
    private final int DEFAULT_ROW_COUNT = 1;
    private final float DEFAULT_OVERSCROLL_SLOTS = 1.0f;
    private final float DEFAULT_ROW_SPACING = 0.0f;
    private final float DEFAULT_SWAY_SENSITIVITY = 0.0f;
    private final float DEFAULT_FRICTION_COEFFICIENT = 10.0f;
    private final float DEFAULT_DRAG_FACTOR = 0.25f;
    private final int DEFAULT_DETAIL_ALIGNMENT =
            DetailAlignment.VIEW_TOP | DetailAlignment.LEFT;
    private CarouselRS mRenderScript;
    private RenderScriptGL mRS;
    private static final String TAG = "CarouselController";
    private static final boolean DBG = false;

    // These shadow the state of the renderer in case the surface changes so the surface
    // can be restored to its previous state.
    private Bitmap mDefaultBitmap;
    private Bitmap mLoadingBitmap;
    private Bitmap mBackgroundBitmap;
    private Bitmap mDefaultLineBitmap = Bitmap.createBitmap(
            new int[] {0x00000000, 0xffffffff, 0x00000000}, 0, 3, 3, 1, Bitmap.Config.ARGB_4444);
    private int mDefaultGeometry;
    private int mLoadingGeometry;
    private float[] mDefaultCardMatrix;
    private int mCardCount = 0;
    private int mVisibleSlots = 0;
    private int mVisibleDetails = DEFAULT_VISIBLE_DETAIL_COUNT;
    private int mPrefetchCardCount = DEFAULT_PREFETCH_CARD_COUNT;
    private int mDetailTextureAlignment = DEFAULT_DETAIL_ALIGNMENT;
    private boolean mForceBlendCardsWithZ = false;
    private boolean mDrawRuler = true;
    private float mStartAngle;
    private float mCarouselRotationAngle;
    private float mRadius = DEFAULT_RADIUS;
    private float mCardRotation = 0.0f;
    private boolean mCardsFaceTangent = false;
    private float mOverscrollSlots = DEFAULT_OVERSCROLL_SLOTS;
    private float mSwaySensitivity = DEFAULT_SWAY_SENSITIVITY;
    private float mFrictionCoefficient = DEFAULT_FRICTION_COEFFICIENT;
    private float mDragFactor = DEFAULT_DRAG_FACTOR;
    private int mSlotCount = DEFAULT_SLOT_COUNT;
    private int mRowCount = DEFAULT_ROW_COUNT;
    private float mRowSpacing = DEFAULT_ROW_SPACING;
    private float mEye[] = { 20.6829f, 2.77081f, 16.7314f };
    private float mAt[] = { 14.7255f, -3.40001f, -1.30184f };
    private float mUp[] = { 0.0f, 1.0f, 0.0f };
    private Float4 mBackgroundColor = new Float4(0.0f, 0.0f, 0.0f, 1.0f);
    private CarouselCallback mCarouselCallback;
    private float mRezInCardCount = 0.0f;
    private long mFadeInDuration = 250L;
    private long mCardCreationFadeDuration = 0L;
    private Bitmap mDetailLoadingBitmap = Bitmap.createBitmap(
            new int[] {0}, 0, 1, 1, 1, Bitmap.Config.ARGB_4444);
    private int mDragModel = CarouselRS.DRAG_MODEL_SCREEN_DELTA;
    private int mFillDirection = CarouselRS.FILL_DIRECTION_CCW;
    private boolean mFirstCardTop = false;
    private int[] mStoreConfigs;

    public CarouselController() {
        boolean useDepthBuffer = true;
    }

    public void setRS(RenderScriptGL rs, CarouselRS renderScript) {
        mRS = rs;
        mRenderScript = renderScript;
    }

    public void onSurfaceChanged() {
        setSlotCount(mSlotCount);
        setDefaultCardMatrix(mDefaultCardMatrix);
        createCards(mCardCount);
        setVisibleSlots(mVisibleSlots);
        setVisibleDetails(mVisibleDetails);
        setPrefetchCardCount(mPrefetchCardCount);
        setOverscrollSlots(mOverscrollSlots);
        setRowCount(mRowCount);
        setRowSpacing(mRowSpacing);
        setFirstCardTop(mFirstCardTop);
        setDetailTextureAlignment(mDetailTextureAlignment);
        setForceBlendCardsWithZ(mForceBlendCardsWithZ);
        setDrawRuler(mDrawRuler);
        setCallback(mCarouselCallback);
        setDefaultBitmap(mDefaultBitmap);
        setLoadingBitmap(mLoadingBitmap);
        setDefaultGeometry(mDefaultGeometry);
        setLoadingGeometry(mLoadingGeometry);
        setBackgroundColor(mBackgroundColor.x, mBackgroundColor.y, mBackgroundColor.z,
                mBackgroundColor.w);
        setBackgroundBitmap(mBackgroundBitmap);
        setDetailLineBitmap(mDefaultLineBitmap);
        setStartAngle(mStartAngle);
        setCarouselRotationAngle(mCarouselRotationAngle);
        setRadius(mRadius);
        setCardRotation(mCardRotation);
        setCardsFaceTangent(mCardsFaceTangent);
        setSwaySensitivity(mSwaySensitivity);
        setFrictionCoefficient(mFrictionCoefficient);
        setDragFactor(mDragFactor);
        setDragModel(mDragModel);
        setFillDirection(mFillDirection);
        setLookAt(mEye, mAt, mUp);
        setRezInCardCount(mRezInCardCount);
        setFadeInDuration(mFadeInDuration);
        setCardCreationFadeDuration(mCardCreationFadeDuration);
        setDetailLoadingBitmap(mDetailLoadingBitmap);
        setStoreConfigs(mStoreConfigs);
    }

    /**
     * Loads geometry from a resource id.
     *
     * @param resId
     * @return the loaded mesh or null if it cannot be loaded
     */
    public Mesh loadGeometry(int resId) {
        if (mRenderScript != null) {
          return mRenderScript.loadGeometry(resId);
        }
        return null;
    }

    /**
     * Set the geometry to show for a given slot.
     * @param n The card to set the geometry for
     * @param mesh The geometry for that item
     * @see {@link #setDefaultGeometry}
     */
    public void setGeometryForItem(int n, Mesh mesh) {
        if (mRenderScript != null) {
            mRenderScript.setGeometry(n, mesh);
        }
    }

    /**
     * Load A3D file from resource. If resId == 0, will clear geometry for this item.
     * @param n The card to set the geometry for
     * @param resId The resource ID for the geometry for that item
     * @see {@link #setDefaultGeometry}
     */
    public void setGeometryForItem(int n, int resId) {
        if (mRenderScript != null) {
            Mesh mesh = mRenderScript.loadGeometry(resId);
            mRenderScript.setGeometry(n, mesh);
        }
    }

    /**
     * Set the matrix for the specified card
     * @param n The card to set the matrix for
     * @param matrix The matrix to use
     * @see {@link #setDefaultGeometry}
     */
    public void setMatrixForItem(int n, float[] matrix) {
        if (mRenderScript != null) {
            mRenderScript.setMatrix(n, matrix);
        }
    }

    /**
     * Set the number of slots around the Carousel. Basically equivalent to the poles horses
     * might attach to on a real Carousel.
     *
     * @param n the number of slots
     */
    public void setSlotCount(int n) {
        mSlotCount = n;
        if (mRenderScript != null) {
            mRenderScript.setSlotCount(n);
        }
    }

    /**
     * Sets the number of visible slots around the Carousel.  This is primarily used as a cheap
     * form of clipping. The Carousel will never show more than this many cards.
     * @param n the number of visible slots
     */
    public void setVisibleSlots(int n) {
        mVisibleSlots = n;
        if (mRenderScript != null) {
            mRenderScript.setVisibleSlots(n);
        }
    }

    /**
     * Set the number of detail textures that can be visible at one time.
     *
     * @param n the number of slots
     */
    public void setVisibleDetails(int n) {
        mVisibleDetails = n;
        if (mRenderScript != null) {
            mRenderScript.setVisibleDetails(n);
        }
    }

    /**
     * Set the number of cards to pre-load that are outside of the visible region, as determined by
     * setVisibleSlots(). This number gets added to the number of visible slots and used to
     * determine when resources for cards should be loaded. This number should be small (n <= 4)
     * for systems with limited texture memory or views that show more than half dozen cards in the
     * view.
     *
     * @param n the number of cards; should be even, so the count is the same on each side
     */
    public void setPrefetchCardCount(int n) {
        mPrefetchCardCount = n;
        if (mRenderScript != null) {
            mRenderScript.setPrefetchCardCount(n);
        }
    }

    /**
     * Sets the number of rows of cards to show in each slot.
     */
    public void setRowCount(int n) {
        mRowCount = n;
        if (mRenderScript != null) {
            mRenderScript.setRowCount(n);
        }
    }

    /**
     * Sets the spacing between each row of cards when rowCount > 1.
     */
    public void setRowSpacing(float s) {
        mRowSpacing = s;
        if (mRenderScript != null) {
            mRenderScript.setRowSpacing(s);
        }
    }

     /**
     * Sets the position of the first card when rowCount > 1 .
     */
    public void setFirstCardTop(boolean f) {
        mFirstCardTop = f;
        if (mRenderScript != null) {
            mRenderScript.setFirstCardTop(f);
        }
    }

    /**
     * Sets the amount of allowed overscroll (in slots)
     */
    public void setOverscrollSlots(float slots) {
        mOverscrollSlots = slots;
        if (mRenderScript != null) {
            mRenderScript.setOverscrollSlots(slots);
        }
    }

    /**
     * Sets how detail textures are aligned with respect to the card.
     *
     * @param alignment a bitmask of DetailAlignment flags.
     */
    public void setDetailTextureAlignment(int alignment) {
        int xBits = alignment & DetailAlignment.HORIZONTAL_ALIGNMENT_MASK;
        if (xBits == 0 || ((xBits & (xBits - 1)) != 0)) {
            throw new IllegalArgumentException(
                    "Must specify exactly one horizontal alignment flag");
        }
        int yBits = alignment & DetailAlignment.VERTICAL_ALIGNMENT_MASK;
        if (yBits == 0 || ((yBits & (yBits - 1)) != 0)) {
            throw new IllegalArgumentException(
                    "Must specify exactly one vertical alignment flag");
        }

        mDetailTextureAlignment = alignment;
        if (mRenderScript != null) {
            mRenderScript.setDetailTextureAlignment(alignment);
        }
    }

    /**
     * Set whether depth is enabled while blending. Generally, this is discouraged because
     * it causes bad artifacts. Careful attention to geometry and alpha transparency of
     * textures can mitigate much of this. Geometry for an individual item must be drawn
     * back-to-front, for example.
     *
     * @param enabled True to enable depth while blending, and false to disable it.
     */
    public void setForceBlendCardsWithZ(boolean enabled) {
        mForceBlendCardsWithZ = enabled;
        if (mRenderScript != null) {
            mRenderScript.setForceBlendCardsWithZ(enabled);
        }
    }

    /**
     * Set whether to draw a ruler from the card to the detail texture
     *
     * @param drawRuler True to draw a ruler, false to draw nothing where the ruler would go.
     */
    public void setDrawRuler(boolean drawRuler) {
        mDrawRuler = drawRuler;
        if (mRenderScript != null) {
            mRenderScript.setDrawRuler(drawRuler);
        }
    }

    /**
     * This dictates how many cards are in the deck.  If the number of cards is greater than the
     * number of slots, then the Carousel goes around n / slot_count times.
     *
     * Can be called again to increase or decrease the number of cards.
     *
     * @param n the number of cards to create.
     */
    public void createCards(int n) {
        mCardCount = n;
        if (mRenderScript != null) {
            mRenderScript.createCards(n);
        }
    }

    public int getCardCount() {
        return mCardCount;
    }

    /**
     * This sets the texture on card n.  It should only be called in response to
     * {@link CarouselCallback#onRequestTexture(int)}.  Since there's no guarantee
     * that a given texture is still on the screen, replacing this texture should be done
     * by first setting it to null and then waiting for the next
     * {@link CarouselCallback#onRequestTexture(int)} to swap it with the new one.
     *
     * @param n the card given by {@link CarouselCallback#onRequestTexture(int)}
     * @param bitmap the bitmap image to show
     */
    public void setTextureForItem(int n, Bitmap bitmap) {
        // Also check against mRS, to handle the case where the result is being delivered by a
        // background thread but the sender no longer exists.
        if (mRenderScript != null && mRS != null) {
            if (DBG) Log.v(TAG, "setTextureForItem(" + n + ")");
            mRenderScript.setTexture(n, bitmap);
            if (DBG) Log.v(TAG, "done");
        }
    }

    /**
     * This sets the detail texture that floats above card n. It should only be called in response
     * to {@link CarouselCallback#onRequestDetailTexture(int)}.  Since there's no guarantee
     * that a given texture is still on the screen, replacing this texture should be done
     * by first setting it to null and then waiting for the next
     * {@link CarouselCallback#onRequestDetailTexture(int)} to swap it with the new one.
     *
     * @param n the card to set detail texture for
     * @param offx an optional offset to apply to the texture (in pixels) from top of detail line
     * @param offy an optional offset to apply to the texture (in pixels) from top of detail line
     * @param loffx an optional offset to apply to the line (in pixels) from left edge of card
     * @param loffy an optional offset to apply to the line (in pixels) from top of screen
     * @param bitmap the bitmap to show as the detail
     */
    public void setDetailTextureForItem(int n, float offx, float offy, float loffx, float loffy,
            Bitmap bitmap) {
        if (mRenderScript != null && mRS != null) {
            if (DBG) Log.v(TAG, "setDetailTextureForItem(" + n + ")");
            mRenderScript.setDetailTexture(n, offx, offy, loffx, loffy, bitmap);
            if (DBG) Log.v(TAG, "done");
        }
    }

    /**
     * Sets the specified texture as invalid. If {@code eraseCurrent} is true,
     * the texture will be immediately cleared from view and an invalidate
     * handler will be called. If {@code eraseCurrent} is false, a replacement
     * texture will be requested, and the old texture will be left in place in
     * the meantime.
     *
     * @param n the card to invalidate the detail texture for
     * @param eraseCurrent whether to erase the current texture
     */
    public void invalidateTexture(int n, boolean eraseCurrent) {
        if (mRenderScript != null && mRS != null) {
            if (DBG) Log.v(TAG, "invalidateTexture(" + n + ", " + eraseCurrent + ")");
            mRenderScript.invalidateTexture(n, eraseCurrent);
            if (DBG) Log.v(TAG, "done");
        }
    }

    /**
     * Sets the specified detail texture as invalid. If eraseCurrent is true, the texture will be
     * immediately cleared from view and an invalidate handler will be called. If eraseCurrent is
     * false, a replacement texture will be requested, and the old texture will be left in place
     * in the meantime.
     * @param n the card to invalidate the detail texture for
     * @param eraseCurrent whether to erase the current texture
     */
    public void invalidateDetailTexture(int n, boolean eraseCurrent) {
        if (mRenderScript != null && mRS != null) {
            if (DBG) Log.v(TAG, "invalidateDetailTexture(" + n + ", " + eraseCurrent + ")");
            mRenderScript.invalidateDetailTexture(n, eraseCurrent);
            if (DBG) Log.v(TAG, "done");
        }
    }

    /**
     * Sets the bitmap to show on a card when the card draws the very first time.
     * Generally, this bitmap will only be seen during the first few frames of startup
     * or when the number of cards are changed.  It can be ignored in most cases,
     * as the cards will generally only be in the loading or loaded state.
     *
     * @param bitmap
     */
    public void setDefaultBitmap(Bitmap bitmap) {
        mDefaultBitmap = bitmap;
        if (mRenderScript != null) {
            mRenderScript.setDefaultBitmap(bitmap);
        }
    }

    /**
     * Sets the bitmap to show on the card while the texture is loading. It is set to this
     * value just before {@link CarouselCallback#onRequestTexture(int)} is called and changed
     * when {@link CarouselView#setTextureForItem(int, Bitmap)} is called. It is shared by all
     * cards.
     *
     * @param bitmap
     */
    public void setLoadingBitmap(Bitmap bitmap) {
        mLoadingBitmap = bitmap;
        if (mRenderScript != null) {
            mRenderScript.setLoadingBitmap(bitmap);
        }
    }

    /**
     * Sets background to specified color.  If a background texture is specified with
     * {@link CarouselView#setBackgroundBitmap(Bitmap)}, then this call has no effect.
     *
     * @param red the amount of red
     * @param green the amount of green
     * @param blue the amount of blue
     * @param alpha the amount of alpha
     */
    public void setBackgroundColor(float red, float green, float blue, float alpha) {
        mBackgroundColor = new Float4(red, green, blue, alpha);
        if (mRenderScript != null) {
            mRenderScript.setBackgroundColor(mBackgroundColor);
        }
    }

    /**
     * Can be used to optionally set the background to a bitmap. When set to something other than
     * null, this overrides {@link CarouselController#setBackgroundColor(Float4)}.
     *
     * @param bitmap
     */
    public void setBackgroundBitmap(Bitmap bitmap) {
        mBackgroundBitmap = bitmap;
        if (mRenderScript != null) {
            mRenderScript.setBackgroundTexture(bitmap);
        }
    }

    /**
     * Can be used to optionally set a "loading" detail bitmap. Typically, this is just a black
     * texture with alpha = 0 to allow details to slowly fade in.
     *
     * @param bitmap
     */
    public void setDetailLoadingBitmap(Bitmap bitmap) {
        mDetailLoadingBitmap = bitmap;
        if (mRenderScript != null) {
            mRenderScript.setDetailLoadingTexture(bitmap);
        }
    }

    /**
     * This texture is used to draw a line from the card alongside the texture detail. The line
     * will be as wide as the texture. It can be used to give the line glow effects as well as
     * allowing other blending effects. It is typically one dimensional, e.g. 3x1.
     *
     * @param bitmap
     */
    public void setDetailLineBitmap(Bitmap bitmap) {
        mDefaultLineBitmap = bitmap;
        if (mRenderScript != null) {
            mRenderScript.setDetailLineTexture(bitmap);
        }
    }

    /**
     * This geometry will be shown when no geometry has been loaded for a given slot. If not set,
     * a quad will be drawn in its place. It is shared for all cards. If something other than
     * simple planar geometry is used, consider enabling depth test with
     * {@link CarouselController#setForceBlendCardsWithZ(boolean)}
     *
     * @param mesh
     */
    public void setDefaultGeometry(int resId) {
        mDefaultGeometry = resId;
        if (mRenderScript != null) {
            Mesh mesh = mRenderScript.loadGeometry(resId);
            mRenderScript.setDefaultGeometry(mesh);
        }
    }

    /**
     * Sets the matrix used to transform card geometries.  By default, this
     * is the identity matrix, but you can specify a different matrix if you
     * want to scale, translate and / or rotate the card before drawing.
     *
     * @param matrix array of 9 or 16 floats representing a 3x3 or 4x4 matrix,
     * or null as a shortcut for an identity matrix.
     */
    public void setDefaultCardMatrix(float[] matrix) {
        mDefaultCardMatrix = matrix;
        if (mRenderScript != null) {
           mRenderScript.setDefaultCardMatrix(matrix);
        }
    }

    /**
     * This is an intermediate version of the object to show while geometry is loading. If not set,
     * a quad will be drawn in its place.  It is shared for all cards. If something other than
     * simple planar geometry is used, consider enabling depth test with
     * {@link CarouselView#setForceBlendCardsWithZ(boolean)}
     *
     * @param resId
     */
    public void setLoadingGeometry(int resId) {
        mLoadingGeometry = resId;
        if (mRenderScript != null) {
            Mesh mesh = mRenderScript.loadGeometry(resId);
            mRenderScript.setLoadingGeometry(mesh);
        }
    }

    /**
     * Sets the callback for receiving events from RenderScript.
     *
     * @param callback
     */
    public void setCallback(CarouselCallback callback)
    {
        mCarouselCallback = callback;
        if (mRenderScript != null) {
            mRenderScript.setCallback(callback);
        }
    }

    /**
     * Gets the callback for receiving events from Renderscript.
     */
    public CarouselCallback getCallback() {
        return mCarouselCallback;
    }

    /**
     * Sets the startAngle for the Carousel. The start angle is the first position of the first
     * slot draw.  Cards will be drawn from this angle in a counter-clockwise manner around the
     * Carousel.
     *
     * @param angle the angle, in radians.
     */
    public void setStartAngle(float angle)
    {
        mStartAngle = angle;
        if (mRenderScript != null) {
            mRenderScript.setStartAngle(angle);
        }
    }

    /**
     * Set the current carousel rotation angle, in card units.
     * This is measured in card positions, not in radians or degrees.
     *
     * A value of 0.0 means that card 0 is in the home position.
     * A value of 1.0 means that card 1 is in the home position, and so on.
     * The maximum value will be somewhat less than the total number of cards.
     *
     * @param angle
     */
    public void setCarouselRotationAngle(float angle) {
        mCarouselRotationAngle = angle;
        if (mRenderScript != null) {
            mRenderScript.setCarouselRotationAngle(angle);
        }
    }

    /**
     * Triggers a rotation of the carousel. All angles are in card units, see:
     * {@link CarouselController#setCarouselRotationAngle(float)}) for more details.
     *
     * @param endAngle the card unit to which the carousel should rotate to
     * @param milliseconds the length of the animation
     * @param interpolationMode three modes are currently supported :
     * {@link CarouselView.InterpolationMode#LINEAR}
     * {@link CarouselView.InterpolationMode#DECELERATE_QUADRATIC}
     * {@link CarouselView.InterpolationMode#ACCELERATE_DECELERATE_CUBIC}
     * @param maxAnimatedArc the maximum angular distance over which the transition will be
     * animated.
     * If the current position is further away, it is set at maxAnimatedArc from endAngle.
     * This parameter is ignored when <= 0.
     */
    public void setCarouselRotationAngle(float endAngle, int milliseconds, int interpolationMode,
            float maxAnimatedArc) {
        if (mRenderScript != null) {
            mRenderScript.setCarouselRotationAngle(endAngle, milliseconds,
                    interpolationMode, maxAnimatedArc);
        }
    }

    public void setRadius(float radius) {
        mRadius = radius;
        if (mRenderScript != null) {
            mRenderScript.setRadius(radius);
        }
    }

    /**
     * Sets the current model for dragging. There are currently four drag models:
     * {@link CarouselView#DRAG_MODEL_SCREEN_DELTA}
     * {@link CarouselView#DRAG_MODEL_PLANE}
     * {@link CarouselView#DRAG_MODEL_CYLINDER_INSIDE}
     * {@link CarouselView#DRAG_MODEL_CYLINDER_OUTSIDE}
     *
     * @param model
     */
    public void setDragModel(int model) {
        mDragModel  = model;
        if (mRenderScript != null) {
            mRenderScript.setDragModel(model);
        }
    }

    /** Sets the direction to fill in cards around the carousel.
     *
     * @param direction Either {@link CarouselRS#FILL_DIRECTION_CCW} or
     * {@link CarouselRS#FILL_DIRECTION_CW}.
     */
    public void setFillDirection(int direction) {
        mFillDirection = direction;
        if (mRenderScript != null) {
            mRenderScript.setFillDirection(direction);
        }
    }

    public void setCardRotation(float cardRotation) {
        mCardRotation = cardRotation;
        if (mRenderScript != null) {
            mRenderScript.setCardRotation(cardRotation);
        }
    }

    public void setCardsFaceTangent(boolean faceTangent) {
        mCardsFaceTangent = faceTangent;
        if (mRenderScript != null) {
            mRenderScript.setCardsFaceTangent(faceTangent);
        }
    }

    public void setSwaySensitivity(float swaySensitivity) {
        mSwaySensitivity = swaySensitivity;
        if (mRenderScript != null) {
            mRenderScript.setSwaySensitivity(swaySensitivity);
        }
    }

    public void setFrictionCoefficient(float frictionCoefficient) {
        mFrictionCoefficient = frictionCoefficient;
        if (mRenderScript != null) {
            mRenderScript.setFrictionCoefficient(frictionCoefficient);
        }
    }

    public void setDragFactor(float dragFactor) {
        mDragFactor = dragFactor;
        if (mRenderScript != null) {
            mRenderScript.setDragFactor(dragFactor);
        }
    }

    public void setLookAt(float[] eye, float[] at, float[] up) {
        mEye = eye;
        mAt = at;
        mUp = up;
        if (mRenderScript != null) {
            mRenderScript.setLookAt(eye, at, up);
        }
    }

    /**
     * This sets the number of cards in the distance that will be shown "rezzing in".
     * These alpha values will be faded in from the background to the foreground over
     * 'n' cards.  A floating point value is used to allow subtly changing the rezzing in
     * position.
     *
     * @param n the number of cards to rez in.
     */
    public void setRezInCardCount(float n) {
        mRezInCardCount = n;
        if (mRenderScript != null) {
            mRenderScript.setRezInCardCount(n);
        }
    }

    /**
     * This sets the duration (in ms) that a card takes to fade in when loaded via a call
     * to {@link CarouselView#setTextureForItem(int, Bitmap)}. The timer starts the
     * moment {@link CarouselView#setTextureForItem(int, Bitmap)} is called and continues
     * until all of the cards have faded in.  Note: using large values will extend the
     * animation until all cards have faded in.
     *
     * @param t The time, in milliseconds
     */
    public void setFadeInDuration(long t) {
        mFadeInDuration = t;
        if (mRenderScript != null) {
            mRenderScript.setFadeInDuration(t);
        }
    }

    /**
     * This sets the duration (in ms) that a card takes to fade in when it is initially created,
     * such as when it is added or when the application starts. The timer starts at the moment
     * when the card is first created. Replacing a card's contents does not affect the timer.
     * @param t The time, in milliseconds
     */
    public void setCardCreationFadeDuration(long t) {
        mCardCreationFadeDuration = t;
        if (mRenderScript != null) {
            mRenderScript.setCardCreationFadeDuration(t);
        }
    }

    /**
     * Tells the carousel that a touch event has started at the designated location.
     * @param x The number of pixels from the left edge that the event occurred
     * @param y The number of pixels from the top edge that the event occurred
     * @param t The time stamp of the event
     */
    public void onTouchStarted(float x, float y, long t) {
        mRenderScript.doStart(x, y, t);
    }

    /**
     * Tells the carousel that a touch event has moved to the designated location.
     * @param x The number of pixels from the left edge that the event occurred
     * @param y The number of pixels from the top edge that the event occurred
     * @param t The time stamp of the event
     */
    public void onTouchMoved(float x, float y, long t) {
        mRenderScript.doMotion(x, y, t);
    }

    /**
     * Tells the carousel that the user has long-pressed.
     */
    public void onLongPress() {
        mRenderScript.doLongPress();
    }

    /**
     * Tells the carousel that a touch event has stopped at the designated location.
     * @param x The number of pixels from the left edge that the event occurred
     * @param y The number of pixels from the top edge that the event occurred
     * @param t The time stamp of the event
     */
    public void onTouchStopped(float x, float y, long t) {
        mRenderScript.doStop(x, y, t);
    }

    /**
     * Whether to use alpha when drawing a primitive: on for translucent, off for opaque.
     */
    public static final int STORE_CONFIG_ALPHA = 1;

    /**
     * Whether to read from the depth buffer when rendering. Determines with glDepthFunc()
     * is given GL_LESS or GL_ALWAYS. On for GL_LESS, off for GL_ALWAYS.
     */
    public static final int STORE_CONFIG_DEPTH_READS = 2;

    /**
     * Whether to write to the depth buffer when rendering. Passed to glDepthMask().
     */
    public static final int STORE_CONFIG_DEPTH_WRITES = 4;

    /**
     * Set the StoreConfig parameters that will be used for each mesh primitive.
     *
     * Each integer in the array is a bitfield composed of
     * {@link CarouselController#STORE_CONFIG_ALPHA},
     * {@link CarouselController#STORE_CONFIG_DEPTH_READS}, and
     * {@link CarouselController#STORE_CONFIG_DEPTH_WRITES}.
     *
     * These parameters MUST correspond to primitives in geometry previously set in
     * {@link CarouselController#setDefaultGeometry(int)} or
     * {@link CarouselController#setLoadingGeometry(int)} or
     * {@link CarouselController#setGeometryForItem(int,Mesh)}.
     *
     * @param configs An array, each element of which corresponds to an ordered mesh primitive
     */
    public void setStoreConfigs(int configs[]) {
        mStoreConfigs = configs;
        if (mRenderScript != null) {
            mRenderScript.setStoreConfigs(configs);
        }
    }
}