diff options
Diffstat (limited to 'graphics/java')
19 files changed, 7779 insertions, 437 deletions
diff --git a/graphics/java/android/renderscript/Allocation.java b/graphics/java/android/renderscript/Allocation.java index f253ed8..45dd25a 100644 --- a/graphics/java/android/renderscript/Allocation.java +++ b/graphics/java/android/renderscript/Allocation.java @@ -77,6 +77,65 @@ public class Allocation extends BaseObj { new HashMap<Long, Allocation>(); OnBufferAvailableListener mBufferNotifier; + private Element.DataType validateObjectIsPrimitiveArray(Object d, boolean checkType) { + final Class c = d.getClass(); + if (!c.isArray()) { + throw new RSIllegalArgumentException("Object passed is not an array of primitives."); + } + final Class cmp = c.getComponentType(); + if (!cmp.isPrimitive()) { + throw new RSIllegalArgumentException("Object passed is not an Array of primitives."); + } + + if (cmp == Long.TYPE) { + if (checkType) { + validateIsInt64(); + return mType.mElement.mType; + } + return Element.DataType.SIGNED_64; + } + + if (cmp == Integer.TYPE) { + if (checkType) { + validateIsInt32(); + return mType.mElement.mType; + } + return Element.DataType.SIGNED_32; + } + + if (cmp == Short.TYPE) { + if (checkType) { + validateIsInt16(); + return mType.mElement.mType; + } + return Element.DataType.SIGNED_16; + } + + if (cmp == Byte.TYPE) { + if (checkType) { + validateIsInt8(); + return mType.mElement.mType; + } + return Element.DataType.SIGNED_8; + } + + if (cmp == Float.TYPE) { + if (checkType) { + validateIsFloat32(); + } + return Element.DataType.FLOAT_32; + } + + if (cmp == Double.TYPE) { + if (checkType) { + validateIsFloat64(); + } + return Element.DataType.FLOAT_64; + } + return null; + } + + /** * The usage of the Allocation. These signal to RenderScript where to place * the Allocation in memory. @@ -285,6 +344,15 @@ public class Allocation extends BaseObj { super.finalize(); } + private void validateIsInt64() { + if ((mType.mElement.mType == Element.DataType.SIGNED_64) || + (mType.mElement.mType == Element.DataType.UNSIGNED_64)) { + return; + } + throw new RSIllegalArgumentException( + "64 bit integer source does not match allocation type " + mType.mElement.mType); + } + private void validateIsInt32() { if ((mType.mElement.mType == Element.DataType.SIGNED_32) || (mType.mElement.mType == Element.DataType.UNSIGNED_32)) { @@ -320,6 +388,14 @@ public class Allocation extends BaseObj { "32 bit float source does not match allocation type " + mType.mElement.mType); } + private void validateIsFloat64() { + if (mType.mElement.mType == Element.DataType.FLOAT_64) { + return; + } + throw new RSIllegalArgumentException( + "64 bit float source does not match allocation type " + mType.mElement.mType); + } + private void validateIsObject() { if ((mType.mElement.mType == Element.DataType.RS_ELEMENT) || (mType.mElement.mType == Element.DataType.RS_TYPE) || @@ -500,23 +576,30 @@ public class Allocation extends BaseObj { } } + private void copyFromUnchecked(Object array, Element.DataType dt, int arrayLen) { + Trace.traceBegin(RenderScript.TRACE_TAG, "copyFromUnchecked"); + mRS.validate(); + if (mCurrentDimZ > 0) { + copy3DRangeFromUnchecked(0, 0, 0, mCurrentDimX, mCurrentDimY, mCurrentDimZ, array, dt, arrayLen); + } else if (mCurrentDimY > 0) { + copy2DRangeFromUnchecked(0, 0, mCurrentDimX, mCurrentDimY, array, dt, arrayLen); + } else { + copy1DRangeFromUnchecked(0, mCurrentCount, array, dt, arrayLen); + } + Trace.traceEnd(RenderScript.TRACE_TAG); + } + /** * Copy into this Allocation from an array. This method does not guarantee * that the Allocation is compatible with the input buffer; it copies memory * without reinterpretation. * - * @param d the source data array + * @param array The source data array */ - public void copyFromUnchecked(int[] d) { + public void copyFromUnchecked(Object array) { Trace.traceBegin(RenderScript.TRACE_TAG, "copyFromUnchecked"); - mRS.validate(); - if (mCurrentDimZ > 0) { - copy3DRangeFromUnchecked(0, 0, 0, mCurrentDimX, mCurrentDimY, mCurrentDimZ, d); - } else if (mCurrentDimY > 0) { - copy2DRangeFromUnchecked(0, 0, mCurrentDimX, mCurrentDimY, d); - } else { - copy1DRangeFromUnchecked(0, mCurrentCount, d); - } + copyFromUnchecked(array, validateObjectIsPrimitiveArray(array, false), + java.lang.reflect.Array.getLength(array)); Trace.traceEnd(RenderScript.TRACE_TAG); } @@ -527,17 +610,19 @@ public class Allocation extends BaseObj { * * @param d the source data array */ + public void copyFromUnchecked(int[] d) { + copyFromUnchecked(d, Element.DataType.SIGNED_32, d.length); + } + + /** + * Copy into this Allocation from an array. This method does not guarantee + * that the Allocation is compatible with the input buffer; it copies memory + * without reinterpretation. + * + * @param d the source data array + */ public void copyFromUnchecked(short[] d) { - Trace.traceBegin(RenderScript.TRACE_TAG, "copyFromUnchecked"); - mRS.validate(); - if (mCurrentDimZ > 0) { - copy3DRangeFromUnchecked(0, 0, 0, mCurrentDimX, mCurrentDimY, mCurrentDimZ, d); - } else if (mCurrentDimY > 0) { - copy2DRangeFromUnchecked(0, 0, mCurrentDimX, mCurrentDimY, d); - } else { - copy1DRangeFromUnchecked(0, mCurrentCount, d); - } - Trace.traceEnd(RenderScript.TRACE_TAG); + copyFromUnchecked(d, Element.DataType.SIGNED_16, d.length); } /** @@ -548,16 +633,7 @@ public class Allocation extends BaseObj { * @param d the source data array */ public void copyFromUnchecked(byte[] d) { - Trace.traceBegin(RenderScript.TRACE_TAG, "copyFromUnchecked"); - mRS.validate(); - if (mCurrentDimZ > 0) { - copy3DRangeFromUnchecked(0, 0, 0, mCurrentDimX, mCurrentDimY, mCurrentDimZ, d); - } else if (mCurrentDimY > 0) { - copy2DRangeFromUnchecked(0, 0, mCurrentDimX, mCurrentDimY, d); - } else { - copy1DRangeFromUnchecked(0, mCurrentCount, d); - } - Trace.traceEnd(RenderScript.TRACE_TAG); + copyFromUnchecked(d, Element.DataType.SIGNED_8, d.length); } /** @@ -568,37 +644,35 @@ public class Allocation extends BaseObj { * @param d the source data array */ public void copyFromUnchecked(float[] d) { - Trace.traceBegin(RenderScript.TRACE_TAG, "copyFromUnchecked"); - mRS.validate(); - if (mCurrentDimZ > 0) { - copy3DRangeFromUnchecked(0, 0, 0, mCurrentDimX, mCurrentDimY, mCurrentDimZ, d); - } else if (mCurrentDimY > 0) { - copy2DRangeFromUnchecked(0, 0, mCurrentDimX, mCurrentDimY, d); - } else { - copy1DRangeFromUnchecked(0, mCurrentCount, d); - } - Trace.traceEnd(RenderScript.TRACE_TAG); + copyFromUnchecked(d, Element.DataType.FLOAT_32, d.length); } /** * Copy into this Allocation from an array. This variant is type checked * and will generate exceptions if the Allocation's {@link + * android.renderscript.Element} does not match the array's + * primitive type. + * + * @param array The source data array + */ + public void copyFrom(Object array) { + Trace.traceBegin(RenderScript.TRACE_TAG, "copyFrom"); + copyFromUnchecked(array, validateObjectIsPrimitiveArray(array, true), + java.lang.reflect.Array.getLength(array)); + Trace.traceEnd(RenderScript.TRACE_TAG); + } + + /** + * Copy into this Allocation from an array. This variant is type checked + * and will generate exceptions if the Allocation's {@link * android.renderscript.Element} is not a 32 bit integer type. * * @param d the source data array */ public void copyFrom(int[] d) { - Trace.traceBegin(RenderScript.TRACE_TAG, "copyFrom"); - mRS.validate(); - if (mCurrentDimZ > 0) { - copy3DRangeFrom(0, 0, 0, mCurrentDimX, mCurrentDimY, mCurrentDimZ, d); - } else if (mCurrentDimY > 0) { - copy2DRangeFrom(0, 0, mCurrentDimX, mCurrentDimY, d); - } else { - copy1DRangeFrom(0, mCurrentCount, d); - } - Trace.traceEnd(RenderScript.TRACE_TAG); + validateIsInt32(); + copyFromUnchecked(d, Element.DataType.SIGNED_32, d.length); } /** @@ -609,16 +683,8 @@ public class Allocation extends BaseObj { * @param d the source data array */ public void copyFrom(short[] d) { - Trace.traceBegin(RenderScript.TRACE_TAG, "copyFrom"); - mRS.validate(); - if (mCurrentDimZ > 0) { - copy3DRangeFrom(0, 0, 0, mCurrentDimX, mCurrentDimY, mCurrentDimZ, d); - } else if (mCurrentDimY > 0) { - copy2DRangeFrom(0, 0, mCurrentDimX, mCurrentDimY, d); - } else { - copy1DRangeFrom(0, mCurrentCount, d); - } - Trace.traceEnd(RenderScript.TRACE_TAG); + validateIsInt16(); + copyFromUnchecked(d, Element.DataType.SIGNED_16, d.length); } /** @@ -629,16 +695,8 @@ public class Allocation extends BaseObj { * @param d the source data array */ public void copyFrom(byte[] d) { - Trace.traceBegin(RenderScript.TRACE_TAG, "copyFrom"); - mRS.validate(); - if (mCurrentDimZ > 0) { - copy3DRangeFrom(0, 0, 0, mCurrentDimX, mCurrentDimY, mCurrentDimZ, d); - } else if (mCurrentDimY > 0) { - copy2DRangeFrom(0, 0, mCurrentDimX, mCurrentDimY, d); - } else { - copy1DRangeFrom(0, mCurrentCount, d); - } - Trace.traceEnd(RenderScript.TRACE_TAG); + validateIsInt8(); + copyFromUnchecked(d, Element.DataType.SIGNED_8, d.length); } /** @@ -649,16 +707,8 @@ public class Allocation extends BaseObj { * @param d the source data array */ public void copyFrom(float[] d) { - Trace.traceBegin(RenderScript.TRACE_TAG, "copyFrom"); - mRS.validate(); - if (mCurrentDimZ > 0) { - copy3DRangeFrom(0, 0, 0, mCurrentDimX, mCurrentDimY, mCurrentDimZ, d); - } else if (mCurrentDimY > 0) { - copy2DRangeFrom(0, 0, mCurrentDimX, mCurrentDimY, d); - } else { - copy1DRangeFrom(0, mCurrentCount, d); - } - Trace.traceEnd(RenderScript.TRACE_TAG); + validateIsFloat32(); + copyFromUnchecked(d, Element.DataType.FLOAT_32, d.length); } /** @@ -787,6 +837,29 @@ public class Allocation extends BaseObj { mRS.nAllocationGenerateMipmaps(getID(mRS)); } + private void copy1DRangeFromUnchecked(int off, int count, Object array, + Element.DataType dt, int arrayLen) { + Trace.traceBegin(RenderScript.TRACE_TAG, "copy1DRangeFromUnchecked"); + final int dataSize = mType.mElement.getBytesSize() * count; + data1DChecks(off, count, arrayLen * dt.mSize, dataSize); + mRS.nAllocationData1D(getIDSafe(), off, mSelectedLOD, count, array, dataSize, dt); + Trace.traceEnd(RenderScript.TRACE_TAG); + } + + /** + * Copy an array into part of this Allocation. This method does not + * guarantee that the Allocation is compatible with the input buffer. + * + * @param off The offset of the first element to be copied. + * @param count The number of elements to be copied. + * @param array The source data array + */ + public void copy1DRangeFromUnchecked(int off, int count, Object array) { + copy1DRangeFromUnchecked(off, count, array, + validateObjectIsPrimitiveArray(array, false), + java.lang.reflect.Array.getLength(array)); + } + /** * Copy an array into part of this Allocation. This method does not * guarantee that the Allocation is compatible with the input buffer. @@ -796,11 +869,7 @@ public class Allocation extends BaseObj { * @param d the source data array */ public void copy1DRangeFromUnchecked(int off, int count, int[] d) { - Trace.traceBegin(RenderScript.TRACE_TAG, "copy1DRangeFromUnchecked"); - int dataSize = mType.mElement.getBytesSize() * count; - data1DChecks(off, count, d.length * 4, dataSize); - mRS.nAllocationData1D(getIDSafe(), off, mSelectedLOD, count, d, dataSize, Element.DataType.SIGNED_32); - Trace.traceEnd(RenderScript.TRACE_TAG); + copy1DRangeFromUnchecked(off, count, (Object)d, Element.DataType.SIGNED_32, d.length); } /** @@ -812,11 +881,7 @@ public class Allocation extends BaseObj { * @param d the source data array */ public void copy1DRangeFromUnchecked(int off, int count, short[] d) { - Trace.traceBegin(RenderScript.TRACE_TAG, "copy1DRangeFromUnchecked"); - int dataSize = mType.mElement.getBytesSize() * count; - data1DChecks(off, count, d.length * 2, dataSize); - mRS.nAllocationData1D(getIDSafe(), off, mSelectedLOD, count, d, dataSize, Element.DataType.SIGNED_16); - Trace.traceEnd(RenderScript.TRACE_TAG); + copy1DRangeFromUnchecked(off, count, (Object)d, Element.DataType.SIGNED_16, d.length); } /** @@ -828,11 +893,7 @@ public class Allocation extends BaseObj { * @param d the source data array */ public void copy1DRangeFromUnchecked(int off, int count, byte[] d) { - Trace.traceBegin(RenderScript.TRACE_TAG, "copy1DRangeFromUnchecked"); - int dataSize = mType.mElement.getBytesSize() * count; - data1DChecks(off, count, d.length, dataSize); - mRS.nAllocationData1D(getIDSafe(), off, mSelectedLOD, count, d, dataSize, Element.DataType.SIGNED_8); - Trace.traceEnd(RenderScript.TRACE_TAG); + copy1DRangeFromUnchecked(off, count, (Object)d, Element.DataType.SIGNED_8, d.length); } /** @@ -844,11 +905,23 @@ public class Allocation extends BaseObj { * @param d the source data array */ public void copy1DRangeFromUnchecked(int off, int count, float[] d) { - Trace.traceBegin(RenderScript.TRACE_TAG, "copy1DRangeFromUnchecked"); - int dataSize = mType.mElement.getBytesSize() * count; - data1DChecks(off, count, d.length * 4, dataSize); - mRS.nAllocationData1D(getIDSafe(), off, mSelectedLOD, count, d, dataSize, Element.DataType.FLOAT_32); - Trace.traceEnd(RenderScript.TRACE_TAG); + copy1DRangeFromUnchecked(off, count, (Object)d, Element.DataType.FLOAT_32, d.length); + } + + + /** + * Copy an array into part of this Allocation. This variant is type checked + * and will generate exceptions if the Allocation type does not + * match the component type of the array passed in. + * + * @param off The offset of the first element to be copied. + * @param count The number of elements to be copied. + * @param array The source data array. + */ + public void copy1DRangeFrom(int off, int count, Object array) { + copy1DRangeFromUnchecked(off, count, array, + validateObjectIsPrimitiveArray(array, true), + java.lang.reflect.Array.getLength(array)); } /** @@ -861,10 +934,8 @@ public class Allocation extends BaseObj { * @param d the source data array */ public void copy1DRangeFrom(int off, int count, int[] d) { - Trace.traceBegin(RenderScript.TRACE_TAG, "copy1DRangeFrom"); validateIsInt32(); - copy1DRangeFromUnchecked(off, count, d); - Trace.traceEnd(RenderScript.TRACE_TAG); + copy1DRangeFromUnchecked(off, count, d, Element.DataType.SIGNED_32, d.length); } /** @@ -877,10 +948,8 @@ public class Allocation extends BaseObj { * @param d the source data array */ public void copy1DRangeFrom(int off, int count, short[] d) { - Trace.traceBegin(RenderScript.TRACE_TAG, "copy1DRangeFrom"); validateIsInt16(); - copy1DRangeFromUnchecked(off, count, d); - Trace.traceEnd(RenderScript.TRACE_TAG); + copy1DRangeFromUnchecked(off, count, d, Element.DataType.SIGNED_16, d.length); } /** @@ -893,10 +962,8 @@ public class Allocation extends BaseObj { * @param d the source data array */ public void copy1DRangeFrom(int off, int count, byte[] d) { - Trace.traceBegin(RenderScript.TRACE_TAG, "copy1DRangeFrom"); validateIsInt8(); - copy1DRangeFromUnchecked(off, count, d); - Trace.traceEnd(RenderScript.TRACE_TAG); + copy1DRangeFromUnchecked(off, count, d, Element.DataType.SIGNED_8, d.length); } /** @@ -909,11 +976,10 @@ public class Allocation extends BaseObj { * @param d the source data array. */ public void copy1DRangeFrom(int off, int count, float[] d) { - Trace.traceBegin(RenderScript.TRACE_TAG, "copy1DRangeFrom"); validateIsFloat32(); - copy1DRangeFromUnchecked(off, count, d); - Trace.traceEnd(RenderScript.TRACE_TAG); + copy1DRangeFromUnchecked(off, count, d, Element.DataType.FLOAT_32, d.length); } + /** * Copy part of an Allocation into this Allocation. * @@ -948,39 +1014,31 @@ public class Allocation extends BaseObj { } } - void copy2DRangeFromUnchecked(int xoff, int yoff, int w, int h, byte[] data) { + void copy2DRangeFromUnchecked(int xoff, int yoff, int w, int h, Object array, + Element.DataType dt, int arrayLen) { Trace.traceBegin(RenderScript.TRACE_TAG, "copy2DRangeFromUnchecked"); mRS.validate(); validate2DRange(xoff, yoff, w, h); - mRS.nAllocationData2D(getIDSafe(), xoff, yoff, mSelectedLOD, mSelectedFace.mID, - w, h, data, data.length, Element.DataType.SIGNED_8); + mRS.nAllocationData2D(getIDSafe(), xoff, yoff, mSelectedLOD, mSelectedFace.mID, w, h, + array, arrayLen * dt.mSize, dt); Trace.traceEnd(RenderScript.TRACE_TAG); } - void copy2DRangeFromUnchecked(int xoff, int yoff, int w, int h, short[] data) { - Trace.traceBegin(RenderScript.TRACE_TAG, "copy2DRangeFromUnchecked"); - mRS.validate(); - validate2DRange(xoff, yoff, w, h); - mRS.nAllocationData2D(getIDSafe(), xoff, yoff, mSelectedLOD, mSelectedFace.mID, - w, h, data, data.length * 2, Element.DataType.SIGNED_16); - Trace.traceEnd(RenderScript.TRACE_TAG); - } - - void copy2DRangeFromUnchecked(int xoff, int yoff, int w, int h, int[] data) { - Trace.traceBegin(RenderScript.TRACE_TAG, "copy2DRangeFromUnchecked"); - mRS.validate(); - validate2DRange(xoff, yoff, w, h); - mRS.nAllocationData2D(getIDSafe(), xoff, yoff, mSelectedLOD, mSelectedFace.mID, - w, h, data, data.length * 4, Element.DataType.SIGNED_32); - Trace.traceEnd(RenderScript.TRACE_TAG); - } - - void copy2DRangeFromUnchecked(int xoff, int yoff, int w, int h, float[] data) { - Trace.traceBegin(RenderScript.TRACE_TAG, "copy2DRangeFromUnchecked"); - mRS.validate(); - validate2DRange(xoff, yoff, w, h); - mRS.nAllocationData2D(getIDSafe(), xoff, yoff, mSelectedLOD, mSelectedFace.mID, - w, h, data, data.length * 4, Element.DataType.FLOAT_32); + /** + * Copy from an array into a rectangular region in this Allocation. The + * array is assumed to be tightly packed. + * + * @param xoff X offset of the region to update in this Allocation + * @param yoff Y offset of the region to update in this Allocation + * @param w Width of the region to update + * @param h Height of the region to update + * @param array Data to be placed into the Allocation + */ + public void copy2DRangeFrom(int xoff, int yoff, int w, int h, Object array) { + Trace.traceBegin(RenderScript.TRACE_TAG, "copy2DRangeFrom"); + copy2DRangeFromUnchecked(xoff, yoff, w, h, array, + validateObjectIsPrimitiveArray(array, true), + java.lang.reflect.Array.getLength(array)); Trace.traceEnd(RenderScript.TRACE_TAG); } @@ -995,10 +1053,9 @@ public class Allocation extends BaseObj { * @param data to be placed into the Allocation */ public void copy2DRangeFrom(int xoff, int yoff, int w, int h, byte[] data) { - Trace.traceBegin(RenderScript.TRACE_TAG, "copy2DRangeFrom"); validateIsInt8(); - copy2DRangeFromUnchecked(xoff, yoff, w, h, data); - Trace.traceEnd(RenderScript.TRACE_TAG); + copy2DRangeFromUnchecked(xoff, yoff, w, h, data, + Element.DataType.SIGNED_8, data.length); } /** @@ -1012,10 +1069,9 @@ public class Allocation extends BaseObj { * @param data to be placed into the Allocation */ public void copy2DRangeFrom(int xoff, int yoff, int w, int h, short[] data) { - Trace.traceBegin(RenderScript.TRACE_TAG, "copy2DRangeFrom"); validateIsInt16(); - copy2DRangeFromUnchecked(xoff, yoff, w, h, data); - Trace.traceEnd(RenderScript.TRACE_TAG); + copy2DRangeFromUnchecked(xoff, yoff, w, h, data, + Element.DataType.SIGNED_16, data.length); } /** @@ -1029,10 +1085,9 @@ public class Allocation extends BaseObj { * @param data to be placed into the Allocation */ public void copy2DRangeFrom(int xoff, int yoff, int w, int h, int[] data) { - Trace.traceBegin(RenderScript.TRACE_TAG, "copy2DRangeFrom"); validateIsInt32(); - copy2DRangeFromUnchecked(xoff, yoff, w, h, data); - Trace.traceEnd(RenderScript.TRACE_TAG); + copy2DRangeFromUnchecked(xoff, yoff, w, h, data, + Element.DataType.SIGNED_32, data.length); } /** @@ -1046,10 +1101,9 @@ public class Allocation extends BaseObj { * @param data to be placed into the Allocation */ public void copy2DRangeFrom(int xoff, int yoff, int w, int h, float[] data) { - Trace.traceBegin(RenderScript.TRACE_TAG, "copy2DRangeFrom"); validateIsFloat32(); - copy2DRangeFromUnchecked(xoff, yoff, w, h, data); - Trace.traceEnd(RenderScript.TRACE_TAG); + copy2DRangeFromUnchecked(xoff, yoff, w, h, data, + Element.DataType.FLOAT_32, data.length); } /** @@ -1122,47 +1176,16 @@ public class Allocation extends BaseObj { * @hide * */ - void copy3DRangeFromUnchecked(int xoff, int yoff, int zoff, int w, int h, int d, byte[] data) { - mRS.validate(); - validate3DRange(xoff, yoff, zoff, w, h, d); - mRS.nAllocationData3D(getIDSafe(), xoff, yoff, zoff, mSelectedLOD, - w, h, d, data, data.length, Element.DataType.SIGNED_8); - } - - /** - * @hide - * - */ - void copy3DRangeFromUnchecked(int xoff, int yoff, int zoff, int w, int h, int d, short[] data) { + private void copy3DRangeFromUnchecked(int xoff, int yoff, int zoff, int w, int h, int d, + Object array, Element.DataType dt, int arrayLen) { + Trace.traceBegin(RenderScript.TRACE_TAG, "copy3DRangeFromUnchecked"); mRS.validate(); validate3DRange(xoff, yoff, zoff, w, h, d); - mRS.nAllocationData3D(getIDSafe(), xoff, yoff, zoff, mSelectedLOD, - w, h, d, data, data.length * 2, Element.DataType.SIGNED_16); - } - - /** - * @hide - * - */ - void copy3DRangeFromUnchecked(int xoff, int yoff, int zoff, int w, int h, int d, int[] data) { - mRS.validate(); - validate3DRange(xoff, yoff, zoff, w, h, d); - mRS.nAllocationData3D(getIDSafe(), xoff, yoff, zoff, mSelectedLOD, - w, h, d, data, data.length * 4, Element.DataType.SIGNED_32); - } - - /** - * @hide - * - */ - void copy3DRangeFromUnchecked(int xoff, int yoff, int zoff, int w, int h, int d, float[] data) { - mRS.validate(); - validate3DRange(xoff, yoff, zoff, w, h, d); - mRS.nAllocationData3D(getIDSafe(), xoff, yoff, zoff, mSelectedLOD, - w, h, d, data, data.length * 4, Element.DataType.FLOAT_32); + mRS.nAllocationData3D(getIDSafe(), xoff, yoff, zoff, mSelectedLOD, w, h, d, + array, arrayLen * dt.mSize, dt); + Trace.traceEnd(RenderScript.TRACE_TAG); } - /** * @hide * Copy a rectangular region from the array into the allocation. @@ -1176,36 +1199,12 @@ public class Allocation extends BaseObj { * @param d Depth of the region to update * @param data to be placed into the allocation */ - public void copy3DRangeFrom(int xoff, int yoff, int zoff, int w, int h, int d, byte[] data) { - validateIsInt8(); - copy3DRangeFromUnchecked(xoff, yoff, zoff, w, h, d, data); - } - - /** - * @hide - * - */ - public void copy3DRangeFrom(int xoff, int yoff, int zoff, int w, int h, int d, short[] data) { - validateIsInt16(); - copy3DRangeFromUnchecked(xoff, yoff, zoff, w, h, d, data); - } - - /** - * @hide - * - */ - public void copy3DRangeFrom(int xoff, int yoff, int zoff, int w, int h, int d, int[] data) { - validateIsInt32(); - copy3DRangeFromUnchecked(xoff, yoff, zoff, w, h, d, data); - } - - /** - * @hide - * - */ - public void copy3DRangeFrom(int xoff, int yoff, int zoff, int w, int h, int d, float[] data) { - validateIsFloat32(); - copy3DRangeFromUnchecked(xoff, yoff, zoff, w, h, d, data); + public void copy3DRangeFrom(int xoff, int yoff, int zoff, int w, int h, int d, Object array) { + Trace.traceBegin(RenderScript.TRACE_TAG, "copy3DRangeFrom"); + copy3DRangeFromUnchecked(xoff, yoff, zoff, w, h, d, array, + validateObjectIsPrimitiveArray(array, true), + java.lang.reflect.Array.getLength(array)); + Trace.traceEnd(RenderScript.TRACE_TAG); } /** @@ -1249,6 +1248,26 @@ public class Allocation extends BaseObj { Trace.traceEnd(RenderScript.TRACE_TAG); } + private void copyTo(Object array, Element.DataType dt, int arrayLen) { + Trace.traceBegin(RenderScript.TRACE_TAG, "copyTo"); + mRS.validate(); + mRS.nAllocationRead(getID(mRS), array, dt); + Trace.traceEnd(RenderScript.TRACE_TAG); + } + + /** + * Copy from the Allocation into an array. The array must be at + * least as large as the Allocation. The + * {@link android.renderscript.Element} must match the component + * type of the array passed in. + * + * @param array The array to be set from the Allocation. + */ + public void copyTo(Object array) { + copyTo(array, validateObjectIsPrimitiveArray(array, true), + java.lang.reflect.Array.getLength(array)); + } + /** * Copy from the Allocation into a byte array. The array must be at least * as large as the Allocation. The allocation must be of an 8 bit integer @@ -1257,11 +1276,8 @@ public class Allocation extends BaseObj { * @param d The array to be set from the Allocation. */ public void copyTo(byte[] d) { - Trace.traceBegin(RenderScript.TRACE_TAG, "copyTo"); validateIsInt8(); - mRS.validate(); - mRS.nAllocationRead(getID(mRS), d, Element.DataType.SIGNED_8); - Trace.traceEnd(RenderScript.TRACE_TAG); + copyTo(d, Element.DataType.SIGNED_8, d.length); } /** @@ -1272,11 +1288,8 @@ public class Allocation extends BaseObj { * @param d The array to be set from the Allocation. */ public void copyTo(short[] d) { - Trace.traceBegin(RenderScript.TRACE_TAG, "copyTo"); validateIsInt16(); - mRS.validate(); - mRS.nAllocationRead(getID(mRS), d, Element.DataType.SIGNED_16); - Trace.traceEnd(RenderScript.TRACE_TAG); + copyTo(d, Element.DataType.SIGNED_16, d.length); } /** @@ -1287,11 +1300,8 @@ public class Allocation extends BaseObj { * @param d The array to be set from the Allocation. */ public void copyTo(int[] d) { - Trace.traceBegin(RenderScript.TRACE_TAG, "copyTo"); validateIsInt32(); - mRS.validate(); - mRS.nAllocationRead(getID(mRS), d, Element.DataType.SIGNED_32); - Trace.traceEnd(RenderScript.TRACE_TAG); + copyTo(d, Element.DataType.SIGNED_32, d.length); } /** @@ -1302,11 +1312,8 @@ public class Allocation extends BaseObj { * @param d The array to be set from the Allocation. */ public void copyTo(float[] d) { - Trace.traceBegin(RenderScript.TRACE_TAG, "copyTo"); validateIsFloat32(); - mRS.validate(); - mRS.nAllocationRead(getID(mRS), d, Element.DataType.FLOAT_32); - Trace.traceEnd(RenderScript.TRACE_TAG); + copyTo(d, Element.DataType.FLOAT_32, d.length); } /** @@ -1856,4 +1863,3 @@ public class Allocation extends BaseObj { } } - diff --git a/graphics/java/android/renderscript/Byte2.java b/graphics/java/android/renderscript/Byte2.java index ef7c770..3ad79e4 100644 --- a/graphics/java/android/renderscript/Byte2.java +++ b/graphics/java/android/renderscript/Byte2.java @@ -22,6 +22,9 @@ package android.renderscript; * **/ public class Byte2 { + public byte x; + public byte y; + public Byte2() { } @@ -30,8 +33,357 @@ public class Byte2 { y = initY; } - public byte x; - public byte y; + /** @hide */ + public Byte2(Byte2 source) { + this.x = source.x; + this.y = source.y; + } + + /** @hide + * Vector add + * + * @param a + */ + public void add(Byte2 a) { + this.x += a.x; + this.y += a.y; + } + + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Byte2 add(Byte2 a, Byte2 b) { + Byte2 result = new Byte2(); + result.x = (byte)(a.x + b.x); + result.y = (byte)(a.y + b.y); + + return result; + } + + /** @hide + * Vector add + * + * @param value + */ + public void add(byte value) { + x += value; + y += value; + } + + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Byte2 add(Byte2 a, byte b) { + Byte2 result = new Byte2(); + result.x = (byte)(a.x + b); + result.y = (byte)(a.y + b); + + return result; + } + + /** @hide + * Vector subtraction + * + * @param a + */ + public void sub(Byte2 a) { + this.x -= a.x; + this.y -= a.y; + } + + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Byte2 sub(Byte2 a, Byte2 b) { + Byte2 result = new Byte2(); + result.x = (byte)(a.x - b.x); + result.y = (byte)(a.y - b.y); + + return result; + } + + /** @hide + * Vector subtraction + * + * @param value + */ + public void sub(byte value) { + x -= value; + y -= value; + } + + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Byte2 sub(Byte2 a, byte b) { + Byte2 result = new Byte2(); + result.x = (byte)(a.x - b); + result.y = (byte)(a.y - b); + + return result; + } + + /** @hide + * Vector multiplication + * + * @param a + */ + public void mul(Byte2 a) { + this.x *= a.x; + this.y *= a.y; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Byte2 mul(Byte2 a, Byte2 b) { + Byte2 result = new Byte2(); + result.x = (byte)(a.x * b.x); + result.y = (byte)(a.y * b.y); + + return result; + } + + /** @hide + * Vector multiplication + * + * @param value + */ + public void mul(byte value) { + x *= value; + y *= value; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Byte2 mul(Byte2 a, byte b) { + Byte2 result = new Byte2(); + result.x = (byte)(a.x * b); + result.y = (byte)(a.y * b); + + return result; + } + + /** @hide + * Vector division + * + * @param a + */ + public void div(Byte2 a) { + this.x /= a.x; + this.y /= a.y; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Byte2 div(Byte2 a, Byte2 b) { + Byte2 result = new Byte2(); + result.x = (byte)(a.x / b.x); + result.y = (byte)(a.y / b.y); + + return result; + } + + /** @hide + * Vector division + * + * @param value + */ + public void div(byte value) { + x /= value; + y /= value; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Byte2 div(Byte2 a, byte b) { + Byte2 result = new Byte2(); + result.x = (byte)(a.x / b); + result.y = (byte)(a.y / b); + + return result; + } + + /** @hide + * get vector length + * + * @return + */ + public byte length() { + return 2; + } + + /** @hide + * set vector negate + */ + public void negate() { + this.x = (byte)(-x); + this.y = (byte)(-y); + } + + /** @hide + * Vector dot Product + * + * @param a + * @return + */ + public byte dotProduct(Byte2 a) { + return (byte)((x * a.x) + (y * a.y)); + } + + /** @hide + * Vector dot Product + * + * @param a + * @param b + * @return + */ + public static byte dotProduct(Byte2 a, Byte2 b) { + return (byte)((b.x * a.x) + (b.y * a.y)); + } + + /** @hide + * Vector add Multiple + * + * @param a + * @param factor + */ + public void addMultiple(Byte2 a, byte factor) { + x += a.x * factor; + y += a.y * factor; + } + + /** @hide + * set vector value by Byte2 + * + * @param a + */ + public void set(Byte2 a) { + this.x = a.x; + this.y = a.y; + } + + /** @hide + * set the vector field value by Char + * + * @param a + * @param b + */ + public void setValues(byte a, byte b) { + this.x = a; + this.y = b; + } + + /** @hide + * return the element sum of vector + * + * @return + */ + public byte elementSum() { + return (byte)(x + y); + } + + /** @hide + * get the vector field value by index + * + * @param i + * @return + */ + public byte get(int i) { + switch (i) { + case 0: + return x; + case 1: + return y; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * set the vector field value by index + * + * @param i + * @param value + */ + public void setAt(int i, byte value) { + switch (i) { + case 0: + x = value; + return; + case 1: + y = value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * add the vector field value by index + * + * @param i + * @param value + */ + public void addAt(int i, byte value) { + switch (i) { + case 0: + x += value; + return; + case 1: + y += value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * copy the vector to Char array + * + * @param data + * @param offset + */ + public void copyTo(byte[] data, int offset) { + data[offset] = x; + data[offset + 1] = y; + } + } diff --git a/graphics/java/android/renderscript/Byte3.java b/graphics/java/android/renderscript/Byte3.java index 025e8de..a138313 100644 --- a/graphics/java/android/renderscript/Byte3.java +++ b/graphics/java/android/renderscript/Byte3.java @@ -22,6 +22,10 @@ package android.renderscript; * **/ public class Byte3 { + public byte x; + public byte y; + public byte z; + public Byte3() { } @@ -31,9 +35,387 @@ public class Byte3 { z = initZ; } - public byte x; - public byte y; - public byte z; + /** @hide */ + public Byte3(Byte3 source) { + this.x = source.x; + this.y = source.y; + this.z = source.z; + } + + /** @hide + * Vector add + * + * @param a + */ + public void add(Byte3 a) { + this.x += a.x; + this.y += a.y; + this.z += a.z; + } + + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Byte3 add(Byte3 a, Byte3 b) { + Byte3 result = new Byte3(); + result.x = (byte)(a.x + b.x); + result.y = (byte)(a.y + b.y); + result.z = (byte)(a.z + b.z); + + return result; + } + + /** @hide + * Vector add + * + * @param value + */ + public void add(byte value) { + x += value; + y += value; + z += value; + } + + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Byte3 add(Byte3 a, byte b) { + Byte3 result = new Byte3(); + result.x = (byte)(a.x + b); + result.y = (byte)(a.y + b); + result.z = (byte)(a.z + b); + + return result; + } + + /** @hide + * Vector subtraction + * + * @param a + */ + public void sub(Byte3 a) { + this.x -= a.x; + this.y -= a.y; + this.z -= a.z; + } + + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Byte3 sub(Byte3 a, Byte3 b) { + Byte3 result = new Byte3(); + result.x = (byte)(a.x - b.x); + result.y = (byte)(a.y - b.y); + result.z = (byte)(a.z - b.z); + + return result; + } + + /** @hide + * Vector subtraction + * + * @param value + */ + public void sub(byte value) { + x -= value; + y -= value; + z -= value; + } + + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Byte3 sub(Byte3 a, byte b) { + Byte3 result = new Byte3(); + result.x = (byte)(a.x - b); + result.y = (byte)(a.y - b); + result.z = (byte)(a.z - b); + + return result; + } + + /** @hide + * Vector multiplication + * + * @param a + */ + public void mul(Byte3 a) { + this.x *= a.x; + this.y *= a.y; + this.z *= a.z; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Byte3 mul(Byte3 a, Byte3 b) { + Byte3 result = new Byte3(); + result.x = (byte)(a.x * b.x); + result.y = (byte)(a.y * b.y); + result.z = (byte)(a.z * b.z); + + return result; + } + + /** @hide + * Vector multiplication + * + * @param value + */ + public void mul(byte value) { + x *= value; + y *= value; + z *= value; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Byte3 mul(Byte3 a, byte b) { + Byte3 result = new Byte3(); + result.x = (byte)(a.x * b); + result.y = (byte)(a.y * b); + result.z = (byte)(a.z * b); + + return result; + } + + /** @hide + * Vector division + * + * @param a + */ + public void div(Byte3 a) { + this.x /= a.x; + this.y /= a.y; + this.z /= a.z; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Byte3 div(Byte3 a, Byte3 b) { + Byte3 result = new Byte3(); + result.x = (byte)(a.x / b.x); + result.y = (byte)(a.y / b.y); + result.z = (byte)(a.z / b.z); + + return result; + } + + /** @hide + * Vector division + * + * @param value + */ + public void div(byte value) { + x /= value; + y /= value; + z /= value; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Byte3 div(Byte3 a, byte b) { + Byte3 result = new Byte3(); + result.x = (byte)(a.x / b); + result.y = (byte)(a.y / b); + result.z = (byte)(a.z / b); + + return result; + } + + /** @hide + * get vector length + * + * @return + */ + public byte length() { + return 3; + } + + /** @hide + * set vector negate + */ + public void negate() { + this.x = (byte)(-x); + this.y = (byte)(-y); + this.z = (byte)(-z); + } + + /** @hide + * Vector dot Product + * + * @param a + * @return + */ + public byte dotProduct(Byte3 a) { + return (byte)((byte)((byte)(x * a.x) + (byte)(y * a.y)) + (byte)(z * a.z)); + } + + /** @hide + * Vector dot Product + * + * @param a + * @param b + * @return + */ + public static byte dotProduct(Byte3 a, Byte3 b) { + return (byte)((byte)((byte)(b.x * a.x) + (byte)(b.y * a.y)) + (byte)(b.z * a.z)); + } + + /** @hide + * Vector add Multiple + * + * @param a + * @param factor + */ + public void addMultiple(Byte3 a, byte factor) { + x += a.x * factor; + y += a.y * factor; + z += a.z * factor; + } + + /** @hide + * set vector value by Byte3 + * + * @param a + */ + public void set(Byte3 a) { + this.x = a.x; + this.y = a.y; + this.z = a.z; + } + + /** @hide + * set the vector field value by Char + * + * @param a + * @param b + * @param c + */ + public void setValues(byte a, byte b, byte c) { + this.x = a; + this.y = b; + this.z = c; + } + + /** @hide + * return the element sum of vector + * + * @return + */ + public byte elementSum() { + return (byte)(x + y + z); + } + + /** @hide + * get the vector field value by index + * + * @param i + * @return + */ + public byte get(int i) { + switch (i) { + case 0: + return x; + case 1: + return y; + case 2: + return z; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * set the vector field value by index + * + * @param i + * @param value + */ + public void setAt(int i, byte value) { + switch (i) { + case 0: + x = value; + return; + case 1: + y = value; + return; + case 2: + z = value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * add the vector field value by index + * + * @param i + * @param value + */ + public void addAt(int i, byte value) { + switch (i) { + case 0: + x += value; + return; + case 1: + y += value; + return; + case 2: + z += value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * copy the vector to Char array + * + * @param data + * @param offset + */ + public void copyTo(byte[] data, int offset) { + data[offset] = x; + data[offset + 1] = y; + data[offset + 2] = z; + } } diff --git a/graphics/java/android/renderscript/Byte4.java b/graphics/java/android/renderscript/Byte4.java index 7df2104..fa4c13d 100644 --- a/graphics/java/android/renderscript/Byte4.java +++ b/graphics/java/android/renderscript/Byte4.java @@ -22,6 +22,11 @@ package android.renderscript; * **/ public class Byte4 { + public byte x; + public byte y; + public byte z; + public byte w; + public Byte4() { } @@ -31,11 +36,418 @@ public class Byte4 { z = initZ; w = initW; } + /** @hide */ + public Byte4(Byte4 source) { + this.x = source.x; + this.y = source.y; + this.z = source.z; + this.w = source.w; + } - public byte x; - public byte y; - public byte z; - public byte w; + /** @hide + * Vector add + * + * @param a + */ + public void add(Byte4 a) { + this.x += a.x; + this.y += a.y; + this.z += a.z; + this.w += a.w; + } + + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Byte4 add(Byte4 a, Byte4 b) { + Byte4 result = new Byte4(); + result.x = (byte)(a.x + b.x); + result.y = (byte)(a.y + b.y); + result.z = (byte)(a.z + b.z); + result.w = (byte)(a.w + b.w); + + return result; + } + + /** @hide + * Vector add + * + * @param value + */ + public void add(byte value) { + x += value; + y += value; + z += value; + w += value; + } + + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Byte4 add(Byte4 a, byte b) { + Byte4 result = new Byte4(); + result.x = (byte)(a.x + b); + result.y = (byte)(a.y + b); + result.z = (byte)(a.z + b); + result.w = (byte)(a.w + b); + + return result; + } + + /** @hide + * Vector subtraction + * + * @param a + */ + public void sub(Byte4 a) { + this.x -= a.x; + this.y -= a.y; + this.z -= a.z; + this.w -= a.w; + } + + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Byte4 sub(Byte4 a, Byte4 b) { + Byte4 result = new Byte4(); + result.x = (byte)(a.x - b.x); + result.y = (byte)(a.y - b.y); + result.z = (byte)(a.z - b.z); + result.w = (byte)(a.w - b.w); + + return result; + } + + /** @hide + * Vector subtraction + * + * @param value + */ + public void sub(byte value) { + x -= value; + y -= value; + z -= value; + w -= value; + } + + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Byte4 sub(Byte4 a, byte b) { + Byte4 result = new Byte4(); + result.x = (byte)(a.x - b); + result.y = (byte)(a.y - b); + result.z = (byte)(a.z - b); + result.w = (byte)(a.w - b); + + return result; + } + + /** @hide + * Vector multiplication + * + * @param a + */ + public void mul(Byte4 a) { + this.x *= a.x; + this.y *= a.y; + this.z *= a.z; + this.w *= a.w; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Byte4 mul(Byte4 a, Byte4 b) { + Byte4 result = new Byte4(); + result.x = (byte)(a.x * b.x); + result.y = (byte)(a.y * b.y); + result.z = (byte)(a.z * b.z); + result.w = (byte)(a.w * b.w); + + return result; + } + + /** @hide + * Vector multiplication + * + * @param value + */ + public void mul(byte value) { + x *= value; + y *= value; + z *= value; + w *= value; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Byte4 mul(Byte4 a, byte b) { + Byte4 result = new Byte4(); + result.x = (byte)(a.x * b); + result.y = (byte)(a.y * b); + result.z = (byte)(a.z * b); + result.w = (byte)(a.w * b); + + return result; + } + + /** @hide + * Vector division + * + * @param a + */ + public void div(Byte4 a) { + this.x /= a.x; + this.y /= a.y; + this.z /= a.z; + this.w /= a.w; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Byte4 div(Byte4 a, Byte4 b) { + Byte4 result = new Byte4(); + result.x = (byte)(a.x / b.x); + result.y = (byte)(a.y / b.y); + result.z = (byte)(a.z / b.z); + result.w = (byte)(a.w / b.w); + + return result; + } + + /** @hide + * Vector division + * + * @param value + */ + public void div(byte value) { + x /= value; + y /= value; + z /= value; + w /= value; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Byte4 div(Byte4 a, byte b) { + Byte4 result = new Byte4(); + result.x = (byte)(a.x / b); + result.y = (byte)(a.y / b); + result.z = (byte)(a.z / b); + result.w = (byte)(a.w / b); + + return result; + } + + /** @hide + * get vector length + * + * @return + */ + public byte length() { + return 4; + } + + /** @hide + * set vector negate + */ + public void negate() { + this.x = (byte)(-x); + this.y = (byte)(-y); + this.z = (byte)(-z); + this.w = (byte)(-w); + } + + /** @hide + * Vector dot Product + * + * @param a + * @return + */ + public byte dotProduct(Byte4 a) { + return (byte)((x * a.x) + (y * a.y) + (z * a.z) + (w * a.w)); + } + + /** @hide + * Vector dot Product + * + * @param a + * @param b + * @return + */ + public static byte dotProduct(Byte4 a, Byte4 b) { + return (byte)((b.x * a.x) + (b.y * a.y) + (b.z * a.z) + (b.w * a.w)); + } + + /** @hide + * Vector add Multiple + * + * @param a + * @param factor + */ + public void addMultiple(Byte4 a, byte factor) { + x += a.x * factor; + y += a.y * factor; + z += a.z * factor; + w += a.w * factor; + } + + /** @hide + * set vector value by Byte4 + * + * @param a + */ + public void set(Byte4 a) { + this.x = a.x; + this.y = a.y; + this.z = a.z; + this.w = a.w; + } + + /** @hide + * set the vector field values + * + * @param a + * @param b + * @param c + * @param d + */ + public void setValues(byte a, byte b, byte c, byte d) { + this.x = a; + this.y = b; + this.z = c; + this.w = d; + } + + /** @hide + * return the element sum of vector + * + * @return + */ + public byte elementSum() { + return (byte)(x + y + z + w); + } + + /** @hide + * get the vector field value by index + * + * @param i + * @return + */ + public byte get(int i) { + switch (i) { + case 0: + return x; + case 1: + return y; + case 2: + return z; + case 3: + return w; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * set the vector field value by index + * + * @param i + * @param value + */ + public void setAt(int i, byte value) { + switch (i) { + case 0: + x = value; + return; + case 1: + y = value; + return; + case 2: + z = value; + return; + case 3: + w = value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * add the vector field value by index + * + * @param i + * @param value + */ + public void addAt(int i, byte value) { + switch (i) { + case 0: + x += value; + return; + case 1: + y += value; + return; + case 2: + z += value; + return; + case 3: + w += value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * copy the vector to Char array + * + * @param data + * @param offset + */ + public void copyTo(byte[] data, int offset) { + data[offset] = x; + data[offset + 1] = y; + data[offset + 2] = z; + data[offset + 3] = w; + } } diff --git a/graphics/java/android/renderscript/Double2.java b/graphics/java/android/renderscript/Double2.java index 6e1afe6..4c7319d 100644 --- a/graphics/java/android/renderscript/Double2.java +++ b/graphics/java/android/renderscript/Double2.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2011 The Android Open Source Project + * Copyright (C) 2013 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. @@ -16,25 +16,370 @@ package android.renderscript; - /** - * Class for exposing the native RenderScript double2 type back - * to the Android system. - * - **/ + * Vector version of the basic double type. + * Provides two double fields packed. + */ public class Double2 { + public double x; + public double y; + public Double2() { } - public Double2(double initX, double initY) { - x = initX; - y = initY; + /** @hide */ + public Double2(Double2 data) { + this.x = data.x; + this.y = data.y; } - public double x; - public double y; -} + public Double2(double x, double y) { + this.x = x; + this.y = y; + } + + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Double2 add(Double2 a, Double2 b) { + Double2 res = new Double2(); + res.x = a.x + b.x; + res.y = a.y + b.y; + + return res; + } + + /** @hide + * Vector add + * + * @param value + */ + public void add(Double2 value) { + x += value.x; + y += value.y; + } + + /** @hide + * Vector add + * + * @param value + */ + public void add(double value) { + x += value; + y += value; + } + + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Double2 add(Double2 a, double b) { + Double2 res = new Double2(); + res.x = a.x + b; + res.y = a.y + b; + return res; + } + + /** @hide + * Vector subtraction + * + * @param value + */ + public void sub(Double2 value) { + x -= value.x; + y -= value.y; + } + + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Double2 sub(Double2 a, Double2 b) { + Double2 res = new Double2(); + res.x = a.x - b.x; + res.y = a.y - b.y; + + return res; + } + + /** @hide + * Vector subtraction + * + * @param value + */ + public void sub(double value) { + x -= value; + y -= value; + } + + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Double2 sub(Double2 a, double b) { + Double2 res = new Double2(); + res.x = a.x - b; + res.y = a.y - b; + return res; + } + + /** @hide + * Vector multiplication + * + * @param value + */ + public void mul(Double2 value) { + x *= value.x; + y *= value.y; + } + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Double2 mul(Double2 a, Double2 b) { + Double2 res = new Double2(); + res.x = a.x * b.x; + res.y = a.y * b.y; + + return res; + } + /** @hide + * Vector multiplication + * + * @param value + */ + public void mul(double value) { + x *= value; + y *= value; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Double2 mul(Double2 a, double b) { + Double2 res = new Double2(); + res.x = a.x * b; + res.y = a.y * b; + + return res; + } + + /** @hide + * Vector division + * + * @param value + */ + public void div(Double2 value) { + x /= value.x; + y /= value.y; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Double2 div(Double2 a, Double2 b) { + Double2 res = new Double2(); + res.x = a.x / b.x; + res.y = a.y / b.y; + + return res; + } + + /** @hide + * Vector division + * + * @param value + */ + public void div(double value) { + x /= value; + y /= value; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Double2 div(Double2 a, double b) { + Double2 res = new Double2(); + res.x = a.x / b; + res.y = a.y / b; + + return res; + } + + /** @hide + * Vector dot Product + * + * @param a + * @return + */ + public double dotProduct(Double2 a) { + return (x * a.x) + (y * a.y); + } + + /** @hide + * Vector dot Product + * + * @param a + * @param b + * @return + */ + public static Double dotProduct(Double2 a, Double2 b) { + return (b.x * a.x) + (b.y * a.y); + } + + /** @hide + * Vector add Multiple + * + * @param a + * @param factor + */ + public void addMultiple(Double2 a, double factor) { + x += a.x * factor; + y += a.y * factor; + } + + /** @hide + * Set vector value by double2 + * + * @param a + */ + public void set(Double2 a) { + this.x = a.x; + this.y = a.y; + } + + /** @hide + * Set vector negate + */ + public void negate() { + x = -x; + y = -y; + } + + /** @hide + * Get vector length + * + * @return + */ + public int length() { + return 2; + } + + /** @hide + * Return the element sum of vector + * + * @return + */ + public double elementSum() { + return x + y; + } + + /** @hide + * Get the vector field value by index + * + * @param i + * @return + */ + public double get(int i) { + switch (i) { + case 0: + return x; + case 1: + return y; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * Set the vector field value by index + * + * @param i + * @param value + */ + public void setAt(int i, double value) { + switch (i) { + case 0: + x = value; + return; + case 1: + y = value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * Add the vector field value by index + * + * @param i + * @param value + */ + public void addAt(int i, double value) { + switch (i) { + case 0: + x += value; + return; + case 1: + y += value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * Set the vector field value + * + * @param x + * @param y + */ + public void setValues(double x, double y) { + this.x = x; + this.y = y; + } + + /** @hide + * Copy the vector to double array + * + * @param data + * @param offset + */ + public void copyTo(double[] data, int offset) { + data[offset] = x; + data[offset + 1] = y; + } +} diff --git a/graphics/java/android/renderscript/Double3.java b/graphics/java/android/renderscript/Double3.java index 7c0979d..b819716 100644 --- a/graphics/java/android/renderscript/Double3.java +++ b/graphics/java/android/renderscript/Double3.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2011 The Android Open Source Project + * Copyright (C) 2013 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. @@ -16,27 +16,402 @@ package android.renderscript; - /** - * Class for exposing the native RenderScript double3 type back - * to the Android system. - * - **/ + * Vector version of the basic double type. + * Provides three double fields packed. + */ public class Double3 { + public double x; + public double y; + public double z; + public Double3() { } + /** @hide */ + public Double3(Double3 data) { + this.x = data.x; + this.y = data.y; + this.z = data.z; + } - public Double3(double initX, double initY, double initZ) { - x = initX; - y = initY; - z = initZ; + public Double3(double x, double y, double z) { + this.x = x; + this.y = y; + this.z = z; } - public double x; - public double y; - public double z; -} + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Double3 add(Double3 a, Double3 b) { + Double3 res = new Double3(); + res.x = a.x + b.x; + res.y = a.y + b.y; + res.z = a.z + b.z; + + return res; + } + + /** @hide + * Vector add + * + * @param value + */ + public void add(Double3 value) { + x += value.x; + y += value.y; + z += value.z; + } + + /** @hide + * Vector add + * + * @param value + */ + public void add(double value) { + x += value; + y += value; + z += value; + } + + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Double3 add(Double3 a, double b) { + Double3 res = new Double3(); + res.x = a.x + b; + res.y = a.y + b; + res.z = a.z + b; + + return res; + } + + /** @hide + * Vector subtraction + * + * @param value + */ + public void sub(Double3 value) { + x -= value.x; + y -= value.y; + z -= value.z; + } + + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Double3 sub(Double3 a, Double3 b) { + Double3 res = new Double3(); + res.x = a.x - b.x; + res.y = a.y - b.y; + res.z = a.z - b.z; + + return res; + } + + /** @hide + * Vector subtraction + * + * @param value + */ + public void sub(double value) { + x -= value; + y -= value; + z -= value; + } + + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Double3 sub(Double3 a, double b) { + Double3 res = new Double3(); + res.x = a.x - b; + res.y = a.y - b; + res.z = a.z - b; + + return res; + } + + /** @hide + * Vector multiplication + * + * @param value + */ + public void mul(Double3 value) { + x *= value.x; + y *= value.y; + z *= value.z; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Double3 mul(Double3 a, Double3 b) { + Double3 res = new Double3(); + res.x = a.x * b.x; + res.y = a.y * b.y; + res.z = a.z * b.z; + + return res; + } + /** @hide + * Vector multiplication + * + * @param value + */ + public void mul(double value) { + x *= value; + y *= value; + z *= value; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Double3 mul(Double3 a, double b) { + Double3 res = new Double3(); + res.x = a.x * b; + res.y = a.y * b; + res.z = a.z * b; + + return res; + } + + /** @hide + * Vector division + * + * @param value + */ + public void div(Double3 value) { + x /= value.x; + y /= value.y; + z /= value.z; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Double3 div(Double3 a, Double3 b) { + Double3 res = new Double3(); + res.x = a.x / b.x; + res.y = a.y / b.y; + res.z = a.z / b.z; + + return res; + } + + /** @hide + * Vector division + * + * @param value + */ + public void div(double value) { + x /= value; + y /= value; + z /= value; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Double3 div(Double3 a, double b) { + Double3 res = new Double3(); + res.x = a.x / b; + res.y = a.y / b; + res.z = a.z / b; + + return res; + } + + /** @hide + * Vector dot Product + * + * @param a + * @return + */ + public double dotProduct(Double3 a) { + return (x * a.x) + (y * a.y) + (z * a.z); + } + + /** @hide + * Vector dot Product + * + * @param a + * @param b + * @return + */ + public static double dotProduct(Double3 a, Double3 b) { + return (b.x * a.x) + (b.y * a.y) + (b.z * a.z); + } + /** @hide + * Vector add Multiple + * + * @param a + * @param factor + */ + public void addMultiple(Double3 a, double factor) { + x += a.x * factor; + y += a.y * factor; + z += a.z * factor; + } + + /** @hide + * Set vector value by double3 + * + * @param a + */ + public void set(Double3 a) { + this.x = a.x; + this.y = a.y; + this.z = a.z; + } + + /** @hide + * Set vector negate + */ + public void negate() { + x = -x; + y = -y; + z = -z; + } + + /** @hide + * Get vector length + * + * @return + */ + public int length() { + return 3; + } + + /** @hide + * Return the element sum of vector + * + * @return + */ + public double elementSum() { + return x + y + z; + } + /** @hide + * Get the vector field value by index + * + * @param i + * @return + */ + public double get(int i) { + switch (i) { + case 0: + return x; + case 1: + return y; + case 2: + return z; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * Set the vector field value by index + * + * @param i + * @param value + */ + public void setAt(int i, double value) { + switch (i) { + case 0: + x = value; + return; + case 1: + y = value; + return; + case 2: + z = value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * Add the vector field value by index + * + * @param i + * @param value + */ + public void addAt(int i, double value) { + switch (i) { + case 0: + x += value; + return; + case 1: + y += value; + return; + case 2: + z += value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + /** @hide + * Set the vector field value + * + * @param x + * @param y + * @param z + */ + public void setValues(double x, double y, double z) { + this.x = x; + this.y = y; + this.z = z; + } + + /** @hide + * Copy the vector to double array + * + * @param data + * @param offset + */ + public void copyTo(double[] data, int offset) { + data[offset] = x; + data[offset + 1] = y; + data[offset + 2] = z; + } +} diff --git a/graphics/java/android/renderscript/Double4.java b/graphics/java/android/renderscript/Double4.java index 9e82611..e4829f7 100644 --- a/graphics/java/android/renderscript/Double4.java +++ b/graphics/java/android/renderscript/Double4.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2011 The Android Open Source Project + * Copyright (C) 2013 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. @@ -16,28 +16,435 @@ package android.renderscript; - /** - * Class for exposing the native RenderScript double4 type back - * to the Android system. - * - **/ + * Vector version of the basic double type. + * Provides four double fields packed. + */ public class Double4 { + public double x; + public double y; + public double z; + public double w; + public Double4() { } + /** @hide */ + public Double4(Double4 data) { + this.x = data.x; + this.y = data.y; + this.z = data.z; + this.w = data.w; + } - public Double4(double initX, double initY, double initZ, double initW) { - x = initX; - y = initY; - z = initZ; - w = initW; + public Double4(double x, double y, double z, double w) { + this.x = x; + this.y = y; + this.z = z; + this.w = w; } - public double x; - public double y; - public double z; - public double w; -} + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Double4 add(Double4 a, Double4 b) { + Double4 res = new Double4(); + res.x = a.x + b.x; + res.y = a.y + b.y; + res.z = a.z + b.z; + res.w = a.w + b.w; + + return res; + } + + /** @hide + * Vector add + * + * @param value + */ + public void add(Double4 value) { + x += value.x; + y += value.y; + z += value.z; + w += value.w; + } + + /** @hide + * Vector add + * + * @param value + */ + public void add(double value) { + x += value; + y += value; + z += value; + w += value; + } + + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Double4 add(Double4 a, double b) { + Double4 res = new Double4(); + res.x = a.x + b; + res.y = a.y + b; + res.z = a.z + b; + res.w = a.w + b; + + return res; + } + + /** @hide + * Vector subtraction + * + * @param value + */ + public void sub(Double4 value) { + x -= value.x; + y -= value.y; + z -= value.z; + w -= value.w; + } + + /** @hide + * Vector subtraction + * + * @param value + */ + public void sub(double value) { + x -= value; + y -= value; + z -= value; + w -= value; + } + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Double4 sub(Double4 a, double b) { + Double4 res = new Double4(); + res.x = a.x - b; + res.y = a.y - b; + res.z = a.z - b; + res.w = a.w - b; + + return res; + } + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Double4 sub(Double4 a, Double4 b) { + Double4 res = new Double4(); + res.x = a.x - b.x; + res.y = a.y - b.y; + res.z = a.z - b.z; + res.w = a.w - b.w; + + return res; + } + + /** @hide + * Vector multiplication + * + * @param value + */ + public void mul(Double4 value) { + x *= value.x; + y *= value.y; + z *= value.z; + w *= value.w; + } + + /** @hide + * Vector multiplication + * + * @param value + */ + public void mul(double value) { + x *= value; + y *= value; + z *= value; + w *= value; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Double4 mul(Double4 a, Double4 b) { + Double4 res = new Double4(); + res.x = a.x * b.x; + res.y = a.y * b.y; + res.z = a.z * b.z; + res.w = a.w * b.w; + + return res; + } + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Double4 mul(Double4 a, double b) { + Double4 res = new Double4(); + res.x = a.x * b; + res.y = a.y * b; + res.z = a.z * b; + res.w = a.w * b; + + return res; + } + + /** @hide + * Vector division + * + * @param value + */ + public void div(Double4 value) { + x /= value.x; + y /= value.y; + z /= value.z; + w /= value.w; + } + + /** @hide + * Vector division + * + * @param value + */ + public void div(double value) { + x /= value; + y /= value; + z /= value; + w /= value; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Double4 div(Double4 a, double b) { + Double4 res = new Double4(); + res.x = a.x / b; + res.y = a.y / b; + res.z = a.z / b; + res.w = a.w / b; + + return res; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Double4 div(Double4 a, Double4 b) { + Double4 res = new Double4(); + res.x = a.x / b.x; + res.y = a.y / b.y; + res.z = a.z / b.z; + res.w = a.w / b.w; + + return res; + } + + /** @hide + * Vector dot Product + * + * @param a + * @return + */ + public double dotProduct(Double4 a) { + return (x * a.x) + (y * a.y) + (z * a.z) + (w * a.w); + } + + /** @hide + * Vector dot Product + * + * @param a + * @param b + * @return + */ + public static double dotProduct(Double4 a, Double4 b) { + return (b.x * a.x) + (b.y * a.y) + (b.z * a.z) + (b.w * a.w); + } + + /** @hide + * Vector add Multiple + * + * @param a + * @param factor + */ + public void addMultiple(Double4 a, double factor) { + x += a.x * factor; + y += a.y * factor; + z += a.z * factor; + w += a.w * factor; + } + + /** @hide + * Set vector value by double4 + * + * @param a + */ + public void set(Double4 a) { + this.x = a.x; + this.y = a.y; + this.z = a.z; + this.w = a.w; + } + + /** @hide + * Set vector negate + */ + public void negate() { + x = -x; + y = -y; + z = -z; + w = -w; + } + + /** @hide + * Get vector length + * + * @return + */ + public int length() { + return 4; + } + + /** @hide + * Return the element sum of vector + * + * @return + */ + public double elementSum() { + return x + y + z + w; + } + + /** @hide + * Get the vector field value by index + * + * @param i + * @return + */ + public double get(int i) { + switch (i) { + case 0: + return x; + case 1: + return y; + case 2: + return z; + case 3: + return w; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * Set the vector field value by index + * + * @param i + * @param value + */ + public void setAt(int i, double value) { + switch (i) { + case 0: + x = value; + return; + case 1: + y = value; + return; + case 2: + z = value; + return; + case 3: + w = value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * Add the vector field value by index + * + * @param i + * @param value + */ + public void addAt(int i, double value) { + switch (i) { + case 0: + x += value; + return; + case 1: + y += value; + return; + case 2: + z += value; + return; + case 3: + w += value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * Set the vector field value + * + * @param x + * @param y + * @param z + * @param w + */ + public void setValues(double x, double y, double z, double w) { + this.x = x; + this.y = y; + this.z = z; + this.w = w; + } + + /** @hide + * Copy the vector to double array + * + * @param data + * @param offset + */ + public void copyTo(double[] data, int offset) { + data[offset] = x; + data[offset + 1] = y; + data[offset + 2] = z; + data[offset + 3] = w; + } +} diff --git a/graphics/java/android/renderscript/Float2.java b/graphics/java/android/renderscript/Float2.java index 427f038..e9f8ca7 100644 --- a/graphics/java/android/renderscript/Float2.java +++ b/graphics/java/android/renderscript/Float2.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2009 The Android Open Source Project + * Copyright (C) 2013 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. @@ -16,24 +16,369 @@ package android.renderscript; - /** - * Class for exposing the native RenderScript float2 type back to the Android system. - * - **/ -public class Float2 { + * Vector version of the basic float type. + * Provides two float fields packed. + */ +public class Float2 { + public float x; + public float y; + public Float2() { } + /** @hide */ + public Float2(Float2 data) { + this.x = data.x; + this.y = data.y; + } - public Float2(float initX, float initY) { - x = initX; - y = initY; + public Float2(float x, float y) { + this.x = x; + this.y = y; } - public float x; - public float y; -} + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Float2 add(Float2 a, Float2 b) { + Float2 res = new Float2(); + res.x = a.x + b.x; + res.y = a.y + b.y; + + return res; + } + + /** @hide + * Vector add + * + * @param value + */ + public void add(Float2 value) { + x += value.x; + y += value.y; + } + + /** @hide + * Vector add + * + * @param value + */ + public void add(float value) { + x += value; + y += value; + } + + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Float2 add(Float2 a, float b) { + Float2 res = new Float2(); + res.x = a.x + b; + res.y = a.y + b; + + return res; + } + + /** @hide + * Vector subtraction + * + * @param value + */ + public void sub(Float2 value) { + x -= value.x; + y -= value.y; + } + + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Float2 sub(Float2 a, Float2 b) { + Float2 res = new Float2(); + res.x = a.x - b.x; + res.y = a.y - b.y; + + return res; + } + + /** @hide + * Vector subtraction + * + * @param value + */ + public void sub(float value) { + x -= value; + y -= value; + } + + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Float2 sub(Float2 a, float b) { + Float2 res = new Float2(); + res.x = a.x - b; + res.y = a.y - b; + + return res; + } + + /** @hide + * Vector multiplication + * + * @param value + */ + public void mul(Float2 value) { + x *= value.x; + y *= value.y; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Float2 mul(Float2 a, Float2 b) { + Float2 res = new Float2(); + res.x = a.x * b.x; + res.y = a.y * b.y; + + return res; + } + + /** @hide + * Vector multiplication + * + * @param value + */ + public void mul(float value) { + x *= value; + y *= value; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Float2 mul(Float2 a, float b) { + Float2 res = new Float2(); + res.x = a.x * b; + res.y = a.y * b; + + return res; + } + + /** @hide + * Vector division + * + * @param value + */ + public void div(Float2 value) { + x /= value.x; + y /= value.y; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Float2 div(Float2 a, Float2 b) { + Float2 res = new Float2(); + res.x = a.x / b.x; + res.y = a.y / b.y; + + return res; + } + /** @hide + * Vector division + * + * @param value + */ + public void div(float value) { + x /= value; + y /= value; + } + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Float2 div(Float2 a, float b) { + Float2 res = new Float2(); + res.x = a.x / b; + res.y = a.y / b; + return res; + } + /** @hide + * Vector dot Product + * + * @param a + * @return + */ + public float dotProduct(Float2 a) { + return (x * a.x) + (y * a.y); + } + + /** @hide + * Vector dot Product + * + * @param a + * @param b + * @return + */ + public static float dotProduct(Float2 a, Float2 b) { + return (b.x * a.x) + (b.y * a.y); + } + + /** @hide + * Vector add Multiple + * + * @param a + * @param factor + */ + public void addMultiple(Float2 a, float factor) { + x += a.x * factor; + y += a.y * factor; + } + + /** @hide + * set vector value by float2 + * + * @param a + */ + public void set(Float2 a) { + this.x = a.x; + this.y = a.y; + } + + /** @hide + * set vector negate + */ + public void negate() { + x = -x; + y = -y; + } + + /** @hide + * get vector length + * + * @return + */ + public int length() { + return 2; + } + + /** @hide + * return the element sum of vector + * + * @return + */ + public float elementSum() { + return x + y; + } + + /** @hide + * get the vector field value by index + * + * @param i + * @return + */ + public float get(int i) { + switch (i) { + case 0: + return x; + case 1: + return y; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * set the vector field value by index + * + * @param i + * @param value + */ + public void setAt(int i, float value) { + switch (i) { + case 0: + x = value; + return; + case 1: + y = value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * add the vector field value by index + * + * @param i + * @param value + */ + public void addAt(int i, float value) { + switch (i) { + case 0: + x += value; + return; + case 1: + y += value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * set the vector field value + * + * @param x + * @param y + */ + public void setValues(float x, float y) { + this.x = x; + this.y = y; + } + + /** @hide + * copy the vector to float array + * + * @param data + * @param offset + */ + public void copyTo(float[] data, int offset) { + data[offset] = x; + data[offset + 1] = y; + } +} diff --git a/graphics/java/android/renderscript/Float3.java b/graphics/java/android/renderscript/Float3.java index bfe143a..555bdf6 100644 --- a/graphics/java/android/renderscript/Float3.java +++ b/graphics/java/android/renderscript/Float3.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2009 The Android Open Source Project + * Copyright (C) 2013 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. @@ -16,25 +16,402 @@ package android.renderscript; - /** - * Class for exposing the native RenderScript float2 type back to the Android system. - * - **/ + * Vector version of the basic float type. + * Provides three float fields packed. + */ public class Float3 { + public float x; + public float y; + public float z; + public Float3() { } - public Float3(float initX, float initY, float initZ) { - x = initX; - y = initY; - z = initZ; + /** @hide */ + public Float3(Float3 data) { + this.x = data.x; + this.y = data.y; + this.z = data.z; } - public float x; - public float y; - public float z; -} + public Float3(float x, float y, float z) { + this.x = x; + this.y = y; + this.z = z; + } + + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Float3 add(Float3 a, Float3 b) { + Float3 res = new Float3(); + res.x = a.x + b.x; + res.y = a.y + b.y; + res.z = a.z + b.z; + + return res; + } + + /** @hide + * Vector add + * + * @param value + */ + public void add(Float3 value) { + x += value.x; + y += value.y; + z += value.z; + } + + /** @hide + * Vector add + * + * @param value + */ + public void add(float value) { + x += value; + y += value; + z += value; + } + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Float3 add(Float3 a, float b) { + Float3 res = new Float3(); + res.x = a.x + b; + res.y = a.y + b; + res.z = a.z + b; + return res; + } + + /** @hide + * Vector subtraction + * + * @param value + */ + public void sub(Float3 value) { + x -= value.x; + y -= value.y; + z -= value.z; + } + + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Float3 sub(Float3 a, Float3 b) { + Float3 res = new Float3(); + res.x = a.x - b.x; + res.y = a.y - b.y; + res.z = a.z - b.z; + + return res; + } + + /** @hide + * Vector subtraction + * + * @param value + */ + public void sub(float value) { + x -= value; + y -= value; + z -= value; + } + + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Float3 sub(Float3 a, float b) { + Float3 res = new Float3(); + res.x = a.x - b; + res.y = a.y - b; + res.z = a.z - b; + + return res; + } + + /** @hide + * Vector multiplication + * + * @param value + */ + public void mul(Float3 value) { + x *= value.x; + y *= value.y; + z *= value.z; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Float3 mul(Float3 a, Float3 b) { + Float3 res = new Float3(); + res.x = a.x * b.x; + res.y = a.y * b.y; + res.z = a.z * b.z; + + return res; + } + + /** @hide + * Vector multiplication + * + * @param value + */ + public void mul(float value) { + x *= value; + y *= value; + z *= value; + } + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Float3 mul(Float3 a, float b) { + Float3 res = new Float3(); + res.x = a.x * b; + res.y = a.y * b; + res.z = a.z * b; + return res; + } + + /** @hide + * Vector division + * + * @param value + */ + public void div(Float3 value) { + x /= value.x; + y /= value.y; + z /= value.z; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Float3 div(Float3 a, Float3 b) { + Float3 res = new Float3(); + res.x = a.x / b.x; + res.y = a.y / b.y; + res.z = a.z / b.z; + + return res; + } + + /** @hide + * Vector division + * + * @param value + */ + public void div(float value) { + x /= value; + y /= value; + z /= value; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Float3 div(Float3 a, float b) { + Float3 res = new Float3(); + res.x = a.x / b; + res.y = a.y / b; + res.z = a.z / b; + + return res; + } + + /** @hide + * Vector dot Product + * + * @param a + * @return + */ + public Float dotProduct(Float3 a) { + return new Float((x * a.x) + (y * a.y) + (z * a.z)); + } + + /** @hide + * Vector dot Product + * + * @param a + * @param b + * @return + */ + public static Float dotProduct(Float3 a, Float3 b) { + return new Float((b.x * a.x) + (b.y * a.y) + (b.z * a.z)); + } + + /** @hide + * Vector add Multiple + * + * @param a + * @param factor + */ + public void addMultiple(Float3 a, float factor) { + x += a.x * factor; + y += a.y * factor; + z += a.z * factor; + } + + /** @hide + * set vector value by float3 + * + * @param a + */ + public void set(Float3 a) { + this.x = a.x; + this.y = a.y; + this.z = a.z; + } + + /** @hide + * set vector negate + */ + public void negate() { + x = -x; + y = -y; + z = -z; + } + + /** @hide + * get vector length + * + * @return + */ + public int length() { + return 3; + } + + /** @hide + * return the element sum of vector + * + * @return + */ + public Float elementSum() { + return new Float(x + y + z); + } + + /** @hide + * get the vector field value by index + * + * @param i + * @return + */ + public float get(int i) { + switch (i) { + case 0: + return x; + case 1: + return y; + case 2: + return z; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * set the vector field value by index + * + * @param i + * @param value + */ + public void setAt(int i, float value) { + switch (i) { + case 0: + x = value; + return; + case 1: + y = value; + return; + case 2: + z = value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * add the vector field value by index + * + * @param i + * @param value + */ + public void addAt(int i, float value) { + switch (i) { + case 0: + x += value; + return; + case 1: + y += value; + return; + case 2: + z += value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * set the vector field value + * + * @param x + * @param y + * @param z + */ + public void setValues(float x, float y, float z) { + this.x = x; + this.y = y; + this.z = z; + } + + /** @hide + * copy the vector to float array + * + * @param data + * @param offset + */ + public void copyTo(float[] data, int offset) { + data[offset] = x; + data[offset + 1] = y; + data[offset + 2] = z; + } +} diff --git a/graphics/java/android/renderscript/Float4.java b/graphics/java/android/renderscript/Float4.java index 67c7afc..6541b2e 100644 --- a/graphics/java/android/renderscript/Float4.java +++ b/graphics/java/android/renderscript/Float4.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2009 The Android Open Source Project + * Copyright (C) 2013 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. @@ -16,27 +16,435 @@ package android.renderscript; - /** - * Class for exposing the native RenderScript float2 type back to the Android system. - * - **/ + * Vector version of the basic float type. + * Provides four float fields packed. + */ public class Float4 { + public float x; + public float y; + public float z; + public float w; + public Float4() { } + /** @hide */ + public Float4(Float4 data) { + this.x = data.x; + this.y = data.y; + this.z = data.z; + this.w = data.w; + } - public Float4(float initX, float initY, float initZ, float initW) { - x = initX; - y = initY; - z = initZ; - w = initW; + public Float4(float x, float y, float z, float w) { + this.x = x; + this.y = y; + this.z = z; + this.w = w; } - public float x; - public float y; - public float z; - public float w; -} + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Float4 add(Float4 a, Float4 b) { + Float4 res = new Float4(); + res.x = a.x + b.x; + res.y = a.y + b.y; + res.z = a.z + b.z; + res.w = a.w + b.w; + + return res; + } + + /** @hide + * Vector add + * + * @param value + */ + public void add(Float4 value) { + x += value.x; + y += value.y; + z += value.z; + w += value.w; + } + + /** @hide + * Vector add + * + * @param value + */ + public void add(float value) { + x += value; + y += value; + z += value; + w += value; + } + + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Float4 add(Float4 a, float b) { + Float4 res = new Float4(); + res.x = a.x + b; + res.y = a.y + b; + res.z = a.z + b; + res.w = a.w + b; + + return res; + } + + /** @hide + * Vector subtraction + * + * @param value + */ + public void sub(Float4 value) { + x -= value.x; + y -= value.y; + z -= value.z; + w -= value.w; + } + + /** @hide + * Vector subtraction + * + * @param value + */ + public void sub(float value) { + x -= value; + y -= value; + z -= value; + w -= value; + } + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Float4 sub(Float4 a, float b) { + Float4 res = new Float4(); + res.x = a.x - b; + res.y = a.y - b; + res.z = a.z - b; + res.w = a.w - b; + + return res; + } + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Float4 sub(Float4 a, Float4 b) { + Float4 res = new Float4(); + res.x = a.x - b.x; + res.y = a.y - b.y; + res.z = a.z - b.z; + res.w = a.w - b.w; + + return res; + } + + /** @hide + * Vector multiplication + * + * @param value + */ + public void mul(Float4 value) { + x *= value.x; + y *= value.y; + z *= value.z; + w *= value.w; + } + + /** @hide + * Vector multiplication + * + * @param value + */ + public void mul(float value) { + x *= value; + y *= value; + z *= value; + w *= value; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Float4 mul(Float4 a, Float4 b) { + Float4 res = new Float4(); + res.x = a.x * b.x; + res.y = a.y * b.y; + res.z = a.z * b.z; + res.w = a.w * b.w; + + return res; + } + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Float4 mul(Float4 a, float b) { + Float4 res = new Float4(); + res.x = a.x * b; + res.y = a.y * b; + res.z = a.z * b; + res.w = a.w * b; + + return res; + } + + /** @hide + * Vector division + * + * @param value + */ + public void div(Float4 value) { + x /= value.x; + y /= value.y; + z /= value.z; + w /= value.w; + } + + /** @hide + * Vector division + * + * @param value + */ + public void div(float value) { + x /= value; + y /= value; + z /= value; + w /= value; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Float4 div(Float4 a, float b) { + Float4 res = new Float4(); + res.x = a.x / b; + res.y = a.y / b; + res.z = a.z / b; + res.w = a.w / b; + + return res; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Float4 div(Float4 a, Float4 b) { + Float4 res = new Float4(); + res.x = a.x / b.x; + res.y = a.y / b.y; + res.z = a.z / b.z; + res.w = a.w / b.w; + + return res; + } + + /** @hide + * Vector dot Product + * + * @param a + * @return + */ + public float dotProduct(Float4 a) { + return (x * a.x) + (y * a.y) + (z * a.z) + (w * a.w); + } + + /** @hide + * Vector dot Product + * + * @param a + * @param b + * @return + */ + public static float dotProduct(Float4 a, Float4 b) { + return (b.x * a.x) + (b.y * a.y) + (b.z * a.z) + (b.w * a.w); + } + + /** @hide + * Vector add Multiple + * + * @param a + * @param factor + */ + public void addMultiple(Float4 a, float factor) { + x += a.x * factor; + y += a.y * factor; + z += a.z * factor; + w += a.w * factor; + } + + /** @hide + * set vector value by float4 + * + * @param a + */ + public void set(Float4 a) { + this.x = a.x; + this.y = a.y; + this.z = a.z; + this.w = a.w; + } + + /** @hide + * set vector negate + */ + public void negate() { + x = -x; + y = -y; + z = -z; + w = -w; + } + + /** @hide + * get vector length + * + * @return + */ + public int length() { + return 4; + } + + /** @hide + * return the element sum of vector + * + * @return + */ + public float elementSum() { + return x + y + z + w; + } + + /** @hide + * get the vector field value by index + * + * @param i + * @return + */ + public float get(int i) { + switch (i) { + case 0: + return x; + case 1: + return y; + case 2: + return z; + case 3: + return w; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * set the vector field value by index + * + * @param i + * @param value + */ + public void setAt(int i, float value) { + switch (i) { + case 0: + x = value; + return; + case 1: + y = value; + return; + case 2: + z = value; + return; + case 3: + w = value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * add the vector field value by index + * + * @param i + * @param value + */ + public void addAt(int i, float value) { + switch (i) { + case 0: + x += value; + return; + case 1: + y += value; + return; + case 2: + z += value; + return; + case 3: + w += value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * set the vector field value + * + * @param x + * @param y + * @param z + * @param w + */ + public void setValues(float x, float y, float z, float w) { + this.x = x; + this.y = y; + this.z = z; + this.w = w; + } + + /** @hide + * copy the vector to float array + * + * @param data + * @param offset + */ + public void copyTo(float[] data, int offset) { + data[offset] = x; + data[offset + 1] = y; + data[offset + 2] = z; + data[offset + 3] = w; + } +} diff --git a/graphics/java/android/renderscript/Int2.java b/graphics/java/android/renderscript/Int2.java index 524e361..120957b 100644 --- a/graphics/java/android/renderscript/Int2.java +++ b/graphics/java/android/renderscript/Int2.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2009 The Android Open Source Project + * Copyright (C) 2013 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. @@ -16,24 +16,425 @@ package android.renderscript; - /** - * Class for exposing the native RenderScript int2 type back to the Android system. - * - **/ + * Vector version of the basic int type. + * Provides two int fields packed. + */ public class Int2 { + public int x; + public int y; + public Int2() { } - public Int2(int initX, int initY) { - x = initX; - y = initY; + /** @hide */ + public Int2(int i) { + this.x = this.y = i; } - public int x; - public int y; -} + public Int2(int x, int y) { + this.x = x; + this.y = y; + } + + /** @hide */ + public Int2(Int2 source) { + this.x = source.x; + this.y = source.y; + } + + /** @hide + * Vector add + * + * @param a + */ + public void add(Int2 a) { + this.x += a.x; + this.y += a.y; + } + + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Int2 add(Int2 a, Int2 b) { + Int2 result = new Int2(); + result.x = a.x + b.x; + result.y = a.y + b.y; + + return result; + } + + /** @hide + * Vector add + * + * @param value + */ + public void add(int value) { + x += value; + y += value; + } + + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Int2 add(Int2 a, int b) { + Int2 result = new Int2(); + result.x = a.x + b; + result.y = a.y + b; + + return result; + } + + /** @hide + * Vector subtraction + * + * @param a + */ + public void sub(Int2 a) { + this.x -= a.x; + this.y -= a.y; + } + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Int2 sub(Int2 a, Int2 b) { + Int2 result = new Int2(); + result.x = a.x - b.x; + result.y = a.y - b.y; + return result; + } + + /** @hide + * Vector subtraction + * + * @param value + */ + public void sub(int value) { + x -= value; + y -= value; + } + + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Int2 sub(Int2 a, int b) { + Int2 result = new Int2(); + result.x = a.x - b; + result.y = a.y - b; + + return result; + } + + /** @hide + * Vector multiplication + * + * @param a + */ + public void mul(Int2 a) { + this.x *= a.x; + this.y *= a.y; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Int2 mul(Int2 a, Int2 b) { + Int2 result = new Int2(); + result.x = a.x * b.x; + result.y = a.y * b.y; + + return result; + } + + /** @hide + * Vector multiplication + * + * @param value + */ + public void mul(int value) { + x *= value; + y *= value; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Int2 mul(Int2 a, int b) { + Int2 result = new Int2(); + result.x = a.x * b; + result.y = a.y * b; + + return result; + } + + /** @hide + * Vector division + * + * @param a + */ + public void div(Int2 a) { + this.x /= a.x; + this.y /= a.y; + } + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Int2 div(Int2 a, Int2 b) { + Int2 result = new Int2(); + result.x = a.x / b.x; + result.y = a.y / b.y; + return result; + } + + /** @hide + * Vector division + * + * @param value + */ + public void div(int value) { + x /= value; + y /= value; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Int2 div(Int2 a, int b) { + Int2 result = new Int2(); + result.x = a.x / b; + result.y = a.y / b; + + return result; + } + + /** @hide + * Vector Modulo + * + * @param a + */ + public void mod(Int2 a) { + this.x %= a.x; + this.y %= a.y; + } + + /** @hide + * Vector Modulo + * + * @param a + * @param b + * @return + */ + public static Int2 mod(Int2 a, Int2 b) { + Int2 result = new Int2(); + result.x = a.x % b.x; + result.y = a.y % b.y; + + return result; + } + + /** @hide + * Vector Modulo + * + * @param value + */ + public void mod(int value) { + x %= value; + y %= value; + } + + /** @hide + * Vector Modulo + * + * @param a + * @param b + * @return + */ + public static Int2 mod(Int2 a, int b) { + Int2 result = new Int2(); + result.x = a.x % b; + result.y = a.y % b; + + return result; + } + + /** @hide + * get vector length + * + * @return + */ + public int length() { + return 2; + } + + /** @hide + * set vector negate + */ + public void negate() { + this.x = -x; + this.y = -y; + } + + /** @hide + * Vector dot Product + * + * @param a + * @return + */ + public int dotProduct(Int2 a) { + return (int)((x * a.x) + (y * a.y)); + } + + /** @hide + * Vector dot Product + * + * @param a + * @param b + * @return + */ + public static int dotProduct(Int2 a, Int2 b) { + return (int)((b.x * a.x) + (b.y * a.y)); + } + + /** @hide + * Vector add Multiple + * + * @param a + * @param factor + */ + public void addMultiple(Int2 a, int factor) { + x += a.x * factor; + y += a.y * factor; + } + + /** @hide + * set vector value by Int2 + * + * @param a + */ + public void set(Int2 a) { + this.x = a.x; + this.y = a.y; + } + + /** @hide + * set the vector field value by Int + * + * @param a + * @param b + */ + public void setValues(int a, int b) { + this.x = a; + this.y = b; + } + + /** @hide + * return the element sum of vector + * + * @return + */ + public int elementSum() { + return (int)(x + y); + } + + /** @hide + * get the vector field value by index + * + * @param i + * @return + */ + public int get(int i) { + switch (i) { + case 0: + return (int)(x); + case 1: + return (int)(y); + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * set the vector field value by index + * + * @param i + * @param value + */ + public void setAt(int i, int value) { + switch (i) { + case 0: + x = value; + return; + case 1: + y = value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * add the vector field value by index + * + * @param i + * @param value + */ + public void addAt(int i, int value) { + switch (i) { + case 0: + x += value; + return; + case 1: + y += value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * copy the vector to int array + * + * @param data + * @param offset + */ + public void copyTo(int[] data, int offset) { + data[offset] = (int)(x); + data[offset + 1] = (int)(y); + } +} diff --git a/graphics/java/android/renderscript/Int3.java b/graphics/java/android/renderscript/Int3.java index df42e28..5431b9a 100644 --- a/graphics/java/android/renderscript/Int3.java +++ b/graphics/java/android/renderscript/Int3.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2009 The Android Open Source Project + * Copyright (C) 2013 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. @@ -16,26 +16,462 @@ package android.renderscript; - /** - * Class for exposing the native RenderScript int3 type back to the Android system. - * - **/ + * Vector version of the basic int type. + * Provides three int fields packed. + */ public class Int3 { + public int x; + public int y; + public int z; + public Int3() { } - public Int3(int initX, int initY, int initZ) { - x = initX; - y = initY; - z = initZ; + /** @hide */ + public Int3(int i) { + this.x = this.y = this.z = i; } - public int x; - public int y; - public int z; -} + public Int3(int x, int y, int z) { + this.x = x; + this.y = y; + this.z = z; + } + + /** @hide */ + public Int3(Int3 source) { + this.x = source.x; + this.y = source.y; + this.z = source.z; + } + /** @hide + * Vector add + * + * @param a + */ + public void add(Int3 a) { + this.x += a.x; + this.y += a.y; + this.z += a.z; + } + + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Int3 add(Int3 a, Int3 b) { + Int3 result = new Int3(); + result.x = a.x + b.x; + result.y = a.y + b.y; + result.z = a.z + b.z; + return result; + } + + /** @hide + * Vector add + * + * @param value + */ + public void add(int value) { + x += value; + y += value; + z += value; + } + + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Int3 add(Int3 a, int b) { + Int3 result = new Int3(); + result.x = a.x + b; + result.y = a.y + b; + result.z = a.z + b; + + return result; + } + /** @hide + * Vector subtraction + * + * @param a + */ + public void sub(Int3 a) { + this.x -= a.x; + this.y -= a.y; + this.z -= a.z; + } + + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Int3 sub(Int3 a, Int3 b) { + Int3 result = new Int3(); + result.x = a.x - b.x; + result.y = a.y - b.y; + result.z = a.z - b.z; + + return result; + } + + /** @hide + * Vector subtraction + * + * @param value + */ + public void sub(int value) { + x -= value; + y -= value; + z -= value; + } + + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Int3 sub(Int3 a, int b) { + Int3 result = new Int3(); + result.x = a.x - b; + result.y = a.y - b; + result.z = a.z - b; + + return result; + } + + /** @hide + * Vector multiplication + * + * @param a + */ + public void mul(Int3 a) { + this.x *= a.x; + this.y *= a.y; + this.z *= a.z; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Int3 mul(Int3 a, Int3 b) { + Int3 result = new Int3(); + result.x = a.x * b.x; + result.y = a.y * b.y; + result.z = a.z * b.z; + + return result; + } + + /** @hide + * Vector multiplication + * + * @param value + */ + public void mul(int value) { + x *= value; + y *= value; + z *= value; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Int3 mul(Int3 a, int b) { + Int3 result = new Int3(); + result.x = a.x * b; + result.y = a.y * b; + result.z = a.z * b; + + return result; + } + + /** @hide + * Vector division + * + * @param a + */ + public void div(Int3 a) { + this.x /= a.x; + this.y /= a.y; + this.z /= a.z; + } + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Int3 div(Int3 a, Int3 b) { + Int3 result = new Int3(); + result.x = a.x / b.x; + result.y = a.y / b.y; + result.z = a.z / b.z; + + return result; + } + + /** @hide + * Vector division + * + * @param value + */ + public void div(int value) { + x /= value; + y /= value; + z /= value; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Int3 div(Int3 a, int b) { + Int3 result = new Int3(); + result.x = a.x / b; + result.y = a.y / b; + result.z = a.z / b; + + return result; + } + + /** @hide + * Vector Modulo + * + * @param a + */ + public void mod(Int3 a) { + this.x %= a.x; + this.y %= a.y; + this.z %= a.z; + } + + /** @hide + * Vector Modulo + * + * @param a + * @param b + * @return + */ + public static Int3 mod(Int3 a, Int3 b) { + Int3 result = new Int3(); + result.x = a.x % b.x; + result.y = a.y % b.y; + result.z = a.z % b.z; + + return result; + } + + /** @hide + * Vector Modulo + * + * @param value + */ + public void mod(int value) { + x %= value; + y %= value; + z %= value; + } + + /** @hide + * Vector Modulo + * + * @param a + * @param b + * @return + */ + public static Int3 mod(Int3 a, int b) { + Int3 result = new Int3(); + result.x = a.x % b; + result.y = a.y % b; + result.z = a.z % b; + + return result; + } + + /** @hide + * get vector length + * + * @return + */ + public int length() { + return 3; + } + + /** @hide + * set vector negate + */ + public void negate() { + this.x = -x; + this.y = -y; + this.z = -z; + } + + /** @hide + * Vector dot Product + * + * @param a + * @return + */ + public int dotProduct(Int3 a) { + return (int)((x * a.x) + (y * a.y) + (z * a.z)); + } + + /** @hide + * Vector dot Product + * + * @param a + * @param b + * @return + */ + public static int dotProduct(Int3 a, Int3 b) { + return (int)((b.x * a.x) + (b.y * a.y) + (b.z * a.z)); + } + + /** @hide + * Vector add Multiple + * + * @param a + * @param factor + */ + public void addMultiple(Int3 a, int factor) { + x += a.x * factor; + y += a.y * factor; + z += a.z * factor; + } + + /** @hide + * set vector value by Int3 + * + * @param a + */ + public void set(Int3 a) { + this.x = a.x; + this.y = a.y; + this.z = a.z; + } + + /** @hide + * set the vector field value by Int + * + * @param a + * @param b + * @param c + */ + public void setValues(int a, int b, int c) { + this.x = a; + this.y = b; + this.z = c; + } + + /** @hide + * return the element sum of vector + * + * @return + */ + public int elementSum() { + return (int)(x + y + z); + } + + /** @hide + * get the vector field value by index + * + * @param i + * @return + */ + public int get(int i) { + switch (i) { + case 0: + return (int)(x); + case 1: + return (int)(y); + case 2: + return (int)(z); + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * set the vector field value by index + * + * @param i + * @param value + */ + public void setAt(int i, int value) { + switch (i) { + case 0: + x = value; + return; + case 1: + y = value; + return; + case 2: + z = value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * add the vector field value by index + * + * @param i + * @param value + */ + public void addAt(int i, int value) { + switch (i) { + case 0: + x += value; + return; + case 1: + y += value; + return; + case 2: + z += value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * copy the vector to int array + * + * @param data + * @param offset + */ + public void copyTo(int[] data, int offset) { + data[offset] = (int)(x); + data[offset + 1] = (int)(y); + data[offset + 2] = (int)(z); + } +} diff --git a/graphics/java/android/renderscript/Int4.java b/graphics/java/android/renderscript/Int4.java index 408fb0d..1c0e2e2 100644 --- a/graphics/java/android/renderscript/Int4.java +++ b/graphics/java/android/renderscript/Int4.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2009 The Android Open Source Project + * Copyright (C) 2013 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. @@ -16,27 +16,499 @@ package android.renderscript; - /** - * Class for exposing the native RenderScript int4 type back to the Android system. - * - **/ + * Vector version of the basic int type. + * Provides four int fields packed. + */ public class Int4 { + public int x; + public int y; + public int z; + public int w; + public Int4() { } - public Int4(int initX, int initY, int initZ, int initW) { - x = initX; - y = initY; - z = initZ; - w = initW; + /** @hide */ + public Int4(int i) { + this.x = this.y = this.z = this.w = i; } - public int x; - public int y; - public int z; - public int w; -} + public Int4(int x, int y, int z, int w) { + this.x = x; + this.y = y; + this.z = z; + this.w = w; + } + + /** @hide */ + public Int4(Int4 source) { + this.x = source.x; + this.y = source.y; + this.z = source.z; + this.w = source.w; + } + + /** @hide + * Vector add + * + * @param a + */ + public void add(Int4 a) { + this.x += a.x; + this.y += a.y; + this.z += a.z; + this.w += a.w; + } + + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Int4 add(Int4 a, Int4 b) { + Int4 result = new Int4(); + result.x = a.x + b.x; + result.y = a.y + b.y; + result.z = a.z + b.z; + result.w = a.w + b.w; + + return result; + } + + /** @hide + * Vector add + * + * @param value + */ + public void add(int value) { + x += value; + y += value; + z += value; + w += value; + } + + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Int4 add(Int4 a, int b) { + Int4 result = new Int4(); + result.x = a.x + b; + result.y = a.y + b; + result.z = a.z + b; + result.w = a.w + b; + + return result; + } + + /** @hide + * Vector subtraction + * + * @param a + */ + public void sub(Int4 a) { + this.x -= a.x; + this.y -= a.y; + this.z -= a.z; + this.w -= a.w; + } + + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Int4 sub(Int4 a, Int4 b) { + Int4 result = new Int4(); + result.x = a.x - b.x; + result.y = a.y - b.y; + result.z = a.z - b.z; + result.w = a.w - b.w; + + return result; + } + + /** @hide + * Vector subtraction + * + * @param value + */ + public void sub(int value) { + x -= value; + y -= value; + z -= value; + w -= value; + } + + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Int4 sub(Int4 a, int b) { + Int4 result = new Int4(); + result.x = a.x - b; + result.y = a.y - b; + result.z = a.z - b; + result.w = a.w - b; + + return result; + } + + /** @hide + * Vector multiplication + * + * @param a + */ + public void mul(Int4 a) { + this.x *= a.x; + this.y *= a.y; + this.z *= a.z; + this.w *= a.w; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Int4 mul(Int4 a, Int4 b) { + Int4 result = new Int4(); + result.x = a.x * b.x; + result.y = a.y * b.y; + result.z = a.z * b.z; + result.w = a.w * b.w; + + return result; + } + + /** @hide + * Vector multiplication + * + * @param value + */ + public void mul(int value) { + x *= value; + y *= value; + z *= value; + w *= value; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Int4 mul(Int4 a, int b) { + Int4 result = new Int4(); + result.x = a.x * b; + result.y = a.y * b; + result.z = a.z * b; + result.w = a.w * b; + return result; + } + + /** @hide + * Vector division + * + * @param a + */ + public void div(Int4 a) { + this.x /= a.x; + this.y /= a.y; + this.z /= a.z; + this.w /= a.w; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Int4 div(Int4 a, Int4 b) { + Int4 result = new Int4(); + result.x = a.x / b.x; + result.y = a.y / b.y; + result.z = a.z / b.z; + result.w = a.w / b.w; + + return result; + } + + /** @hide + * Vector division + * + * @param value + */ + public void div(int value) { + x /= value; + y /= value; + z /= value; + w /= value; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Int4 div(Int4 a, int b) { + Int4 result = new Int4(); + result.x = a.x / b; + result.y = a.y / b; + result.z = a.z / b; + result.w = a.w / b; + + return result; + } + + /** @hide + * Vector Modulo + * + * @param a + */ + public void mod(Int4 a) { + this.x %= a.x; + this.y %= a.y; + this.z %= a.z; + this.w %= a.w; + } + + /** @hide + * Vector Modulo + * + * @param a + * @param b + * @return + */ + public static Int4 mod(Int4 a, Int4 b) { + Int4 result = new Int4(); + result.x = a.x % b.x; + result.y = a.y % b.y; + result.z = a.z % b.z; + result.w = a.w % b.w; + + return result; + } + + /** @hide + * Vector Modulo + * + * @param value + */ + public void mod(int value) { + x %= value; + y %= value; + z %= value; + w %= value; + } + + /** @hide + * Vector Modulo + * + * @param a + * @param b + * @return + */ + public static Int4 mod(Int4 a, int b) { + Int4 result = new Int4(); + result.x = a.x % b; + result.y = a.y % b; + result.z = a.z % b; + result.w = a.w % b; + + return result; + } + + /** @hide + * get vector length + * + * @return + */ + public int length() { + return 4; + } + + /** @hide + * set vector negate + */ + public void negate() { + this.x = -x; + this.y = -y; + this.z = -z; + this.w = -w; + } + + /** @hide + * Vector dot Product + * + * @param a + * @return + */ + public int dotProduct(Int4 a) { + return (int)((x * a.x) + (y * a.y) + (z * a.z) + (w * a.w)); + } + + /** @hide + * Vector dot Product + * + * @param a + * @param b + * @return + */ + public static int dotProduct(Int4 a, Int4 b) { + return (int)((b.x * a.x) + (b.y * a.y) + (b.z * a.z) + (b.w * a.w)); + } + + /** @hide + * Vector add Multiple + * + * @param a + * @param factor + */ + public void addMultiple(Int4 a, int factor) { + x += a.x * factor; + y += a.y * factor; + z += a.z * factor; + w += a.w * factor; + } + + /** @hide + * set vector value by Int4 + * + * @param a + */ + public void set(Int4 a) { + this.x = a.x; + this.y = a.y; + this.z = a.z; + this.w = a.w; + } + /** @hide + * set the vector field value by Int + * + * @param a + * @param b + * @param c + * @param d + */ + public void setValues(int a, int b, int c, int d) { + this.x = a; + this.y = b; + this.z = c; + this.w = d; + } + + /** @hide + * return the element sum of vector + * + * @return + */ + public int elementSum() { + return (int)(x + y + z + w); + } + /** @hide + * get the vector field value by index + * + * @param i + * @return + */ + public int get(int i) { + switch (i) { + case 0: + return (int)(x); + case 1: + return (int)(y); + case 2: + return (int)(z); + case 3: + return (int)(w); + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * set the vector field value by index + * + * @param i + * @param value + */ + public void setAt(int i, int value) { + switch (i) { + case 0: + x = value; + return; + case 1: + y = value; + return; + case 2: + z = value; + return; + case 3: + w = value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * add the vector field value by index + * + * @param i + * @param value + */ + public void addAt(int i, int value) { + switch (i) { + case 0: + x += value; + return; + case 1: + y += value; + return; + case 2: + z += value; + return; + case 3: + w += value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * copy the vector to int array + * + * @param data + * @param offset + */ + public void copyTo(int[] data, int offset) { + data[offset] = (int)(x); + data[offset + 1] = (int)(y); + data[offset + 2] = (int)(z); + data[offset + 3] = (int)(w); + } +} diff --git a/graphics/java/android/renderscript/Long2.java b/graphics/java/android/renderscript/Long2.java index 70fc374..fabf204 100644 --- a/graphics/java/android/renderscript/Long2.java +++ b/graphics/java/android/renderscript/Long2.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2009 The Android Open Source Project + * Copyright (C) 2013 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. @@ -16,23 +16,425 @@ package android.renderscript; - /** - * Class for exposing the native RenderScript long2 type back to the Android system. - **/ + * Vector version of the basic long type. + * Provides two long fields packed. + */ public class Long2 { + public long x; + public long y; + public Long2() { } - public Long2(long initX, long initY) { - x = initX; - y = initY; + /** @hide */ + public Long2(long i) { + this.x = this.y = i; } - public long x; - public long y; -} + public Long2(long x, long y) { + this.x = x; + this.y = y; + } + + /** @hide */ + public Long2(Long2 source) { + this.x = source.x; + this.y = source.y; + } + + /** @hide + * Vector add + * + * @param a + */ + public void add(Long2 a) { + this.x += a.x; + this.y += a.y; + } + + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Long2 add(Long2 a, Long2 b) { + Long2 result = new Long2(); + result.x = a.x + b.x; + result.y = a.y + b.y; + + return result; + } + + /** @hide + * Vector add + * + * @param value + */ + public void add(long value) { + x += value; + y += value; + } + + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Long2 add(Long2 a, long b) { + Long2 result = new Long2(); + result.x = a.x + b; + result.y = a.y + b; + + return result; + } + + /** @hide + * Vector subtraction + * + * @param a + */ + public void sub(Long2 a) { + this.x -= a.x; + this.y -= a.y; + } + + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Long2 sub(Long2 a, Long2 b) { + Long2 result = new Long2(); + result.x = a.x - b.x; + result.y = a.y - b.y; + + return result; + } + + /** @hide + * Vector subtraction + * + * @param value + */ + public void sub(long value) { + x -= value; + y -= value; + } + + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Long2 sub(Long2 a, long b) { + Long2 result = new Long2(); + result.x = a.x - b; + result.y = a.y - b; + + return result; + } + + /** @hide + * Vector multiplication + * + * @param a + */ + public void mul(Long2 a) { + this.x *= a.x; + this.y *= a.y; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Long2 mul(Long2 a, Long2 b) { + Long2 result = new Long2(); + result.x = a.x * b.x; + result.y = a.y * b.y; + + return result; + } + + /** @hide + * Vector multiplication + * + * @param value + */ + public void mul(long value) { + x *= value; + y *= value; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Long2 mul(Long2 a, long b) { + Long2 result = new Long2(); + result.x = a.x * b; + result.y = a.y * b; + + return result; + } + /** @hide + * Vector division + * + * @param a + */ + public void div(Long2 a) { + this.x /= a.x; + this.y /= a.y; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Long2 div(Long2 a, Long2 b) { + Long2 result = new Long2(); + result.x = a.x / b.x; + result.y = a.y / b.y; + + return result; + } + + /** @hide + * Vector division + * + * @param value + */ + public void div(long value) { + x /= value; + y /= value; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Long2 div(Long2 a, long b) { + Long2 result = new Long2(); + result.x = a.x / b; + result.y = a.y / b; + + return result; + } + + /** @hide + * Vector Modulo + * + * @param a + */ + public void mod(Long2 a) { + this.x %= a.x; + this.y %= a.y; + } + /** @hide + * Vector Modulo + * + * @param a + * @param b + * @return + */ + public static Long2 mod(Long2 a, Long2 b) { + Long2 result = new Long2(); + result.x = a.x % b.x; + result.y = a.y % b.y; + return result; + } + + /** @hide + * Vector Modulo + * + * @param value + */ + public void mod(long value) { + x %= value; + y %= value; + } + + /** @hide + * Vector Modulo + * + * @param a + * @param b + * @return + */ + public static Long2 mod(Long2 a, long b) { + Long2 result = new Long2(); + result.x = a.x % b; + result.y = a.y % b; + + return result; + } + + /** @hide + * get vector length + * + * @return + */ + public long length() { + return 2; + } + + /** @hide + * set vector negate + */ + public void negate() { + this.x = -x; + this.y = -y; + } + /** @hide + * Vector dot Product + * + * @param a + * @return + */ + public long dotProduct(Long2 a) { + return (long)((x * a.x) + (y * a.y)); + } + + /** @hide + * Vector dot Product + * + * @param a + * @param b + * @return + */ + public static long dotProduct(Long2 a, Long2 b) { + return (long)((b.x * a.x) + (b.y * a.y)); + } + + /** @hide + * Vector add Multiple + * + * @param a + * @param factor + */ + public void addMultiple(Long2 a, long factor) { + x += a.x * factor; + y += a.y * factor; + } + + /** @hide + * set vector value by Long2 + * + * @param a + */ + public void set(Long2 a) { + this.x = a.x; + this.y = a.y; + } + + /** @hide + * set the vector field value by Long + * + * @param a + * @param b + */ + public void setValues(long a, long b) { + this.x = a; + this.y = b; + } + + /** @hide + * return the element sum of vector + * + * @return + */ + public long elementSum() { + return (long)(x + y); + } + + /** @hide + * get the vector field value by index + * + * @param i + * @return + */ + public long get(int i) { + switch (i) { + case 0: + return (long)(x); + case 1: + return (long)(y); + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * set the vector field value by index + * + * @param i + * @param value + */ + public void setAt(int i, long value) { + switch (i) { + case 0: + x = value; + return; + case 1: + y = value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * add the vector field value by index + * + * @param i + * @param value + */ + public void addAt(int i, long value) { + switch (i) { + case 0: + x += value; + return; + case 1: + y += value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * copy the vector to long array + * + * @param data + * @param offset + */ + public void copyTo(long[] data, int offset) { + data[offset] = (long)(x); + data[offset + 1] = (long)(y); + } +} diff --git a/graphics/java/android/renderscript/Long3.java b/graphics/java/android/renderscript/Long3.java index d81826b..8e243cc 100644 --- a/graphics/java/android/renderscript/Long3.java +++ b/graphics/java/android/renderscript/Long3.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2009 The Android Open Source Project + * Copyright (C) 2013 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. @@ -16,25 +16,462 @@ package android.renderscript; - /** - * Class for exposing the native RenderScript long3 type back to the Android system. - **/ + * Vector version of the basic long type. + * Provides three long fields packed. + */ public class Long3 { + public long x; + public long y; + public long z; + public Long3() { } - public Long3(long initX, long initY, long initZ) { - x = initX; - y = initY; - z = initZ; + /** @hide */ + public Long3(long i) { + this.x = this.y = this.z = i; } - public long x; - public long y; - public long z; -} + public Long3(long x, long y, long z) { + this.x = x; + this.y = y; + this.z = z; + } + + /** @hide */ + public Long3(Long3 source) { + this.x = source.x; + this.y = source.y; + this.z = source.z; + } + + /** @hide + * Vector add + * + * @param a + */ + public void add(Long3 a) { + this.x += a.x; + this.y += a.y; + this.z += a.z; + } + + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Long3 add(Long3 a, Long3 b) { + Long3 result = new Long3(); + result.x = a.x + b.x; + result.y = a.y + b.y; + result.z = a.z + b.z; + + return result; + } + + /** @hide + * Vector add + * + * @param value + */ + public void add(long value) { + x += value; + y += value; + z += value; + } + + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Long3 add(Long3 a, long b) { + Long3 result = new Long3(); + result.x = a.x + b; + result.y = a.y + b; + result.z = a.z + b; + + return result; + } + + /** @hide + * Vector subtraction + * + * @param a + */ + public void sub(Long3 a) { + this.x -= a.x; + this.y -= a.y; + this.z -= a.z; + } + + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Long3 sub(Long3 a, Long3 b) { + Long3 result = new Long3(); + result.x = a.x - b.x; + result.y = a.y - b.y; + result.z = a.z - b.z; + + return result; + } + + /** @hide + * Vector subtraction + * + * @param value + */ + public void sub(long value) { + x -= value; + y -= value; + z -= value; + } + + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Long3 sub(Long3 a, long b) { + Long3 result = new Long3(); + result.x = a.x - b; + result.y = a.y - b; + result.z = a.z - b; + + return result; + } + + /** @hide + * Vector multiplication + * + * @param a + */ + public void mul(Long3 a) { + this.x *= a.x; + this.y *= a.y; + this.z *= a.z; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Long3 mul(Long3 a, Long3 b) { + Long3 result = new Long3(); + result.x = a.x * b.x; + result.y = a.y * b.y; + result.z = a.z * b.z; + + return result; + } + + /** @hide + * Vector multiplication + * + * @param value + */ + public void mul(long value) { + x *= value; + y *= value; + z *= value; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Long3 mul(Long3 a, long b) { + Long3 result = new Long3(); + result.x = a.x * b; + result.y = a.y * b; + result.z = a.z * b; + + return result; + } + + /** @hide + * Vector division + * + * @param a + */ + public void div(Long3 a) { + this.x /= a.x; + this.y /= a.y; + this.z /= a.z; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Long3 div(Long3 a, Long3 b) { + Long3 result = new Long3(); + result.x = a.x / b.x; + result.y = a.y / b.y; + result.z = a.z / b.z; + + return result; + } + + /** @hide + * Vector division + * + * @param value + */ + public void div(long value) { + x /= value; + y /= value; + z /= value; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Long3 div(Long3 a, long b) { + Long3 result = new Long3(); + result.x = a.x / b; + result.y = a.y / b; + result.z = a.z / b; + + return result; + } + + /** @hide + * Vector Modulo + * + * @param a + */ + public void mod(Long3 a) { + this.x %= a.x; + this.y %= a.y; + this.z %= a.z; + } + + /** @hide + * Vector Modulo + * + * @param a + * @param b + * @return + */ + public static Long3 mod(Long3 a, Long3 b) { + Long3 result = new Long3(); + result.x = a.x % b.x; + result.y = a.y % b.y; + result.z = a.z % b.z; + + return result; + } + + /** @hide + * Vector Modulo + * + * @param value + */ + public void mod(long value) { + x %= value; + y %= value; + z %= value; + } + + /** @hide + * Vector Modulo + * + * @param a + * @param b + * @return + */ + public static Long3 mod(Long3 a, long b) { + Long3 result = new Long3(); + result.x = a.x % b; + result.y = a.y % b; + result.z = a.z % b; + + return result; + } + /** @hide + * get vector length + * + * @return + */ + public long length() { + return 3; + } + + /** @hide + * set vector negate + */ + public void negate() { + this.x = -x; + this.y = -y; + this.z = -z; + } + /** @hide + * Vector dot Product + * + * @param a + * @return + */ + public long dotProduct(Long3 a) { + return (long)((x * a.x) + (y * a.y) + (z * a.z)); + } + + /** @hide + * Vector dot Product + * + * @param a + * @param b + * @return + */ + public static long dotProduct(Long3 a, Long3 b) { + return (long)((b.x * a.x) + (b.y * a.y) + (b.z * a.z)); + } + /** @hide + * Vector add Multiple + * + * @param a + * @param factor + */ + public void addMultiple(Long3 a, long factor) { + x += a.x * factor; + y += a.y * factor; + z += a.z * factor; + } + + /** @hide + * set vector value by Long3 + * + * @param a + */ + public void set(Long3 a) { + this.x = a.x; + this.y = a.y; + this.z = a.z; + } + + /** @hide + * set the vector field value by Long + * + * @param a + * @param b + * @param c + */ + public void setValues(long a, long b, long c) { + this.x = a; + this.y = b; + this.z = c; + } + /** @hide + * return the element sum of vector + * + * @return + */ + public long elementSum() { + return (long)(x + y + z); + } + + /** @hide + * get the vector field value by index + * + * @param i + * @return + */ + public long get(int i) { + switch (i) { + case 0: + return (long)(x); + case 1: + return (long)(y); + case 2: + return (long)(z); + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * set the vector field value by index + * + * @param i + * @param value + */ + public void setAt(int i, long value) { + switch (i) { + case 0: + x = value; + return; + case 1: + y = value; + return; + case 2: + z = value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * add the vector field value by index + * + * @param i + * @param value + */ + public void addAt(int i, long value) { + switch (i) { + case 0: + x += value; + return; + case 1: + y += value; + return; + case 2: + z += value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * copy the vector to long array + * + * @param data + * @param offset + */ + public void copyTo(long[] data, int offset) { + data[offset] = (long)(x); + data[offset + 1] = (long)(y); + data[offset + 2] = (long)(z); + } +} diff --git a/graphics/java/android/renderscript/Long4.java b/graphics/java/android/renderscript/Long4.java index 47ef437..757b910 100644 --- a/graphics/java/android/renderscript/Long4.java +++ b/graphics/java/android/renderscript/Long4.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2009 The Android Open Source Project + * Copyright (C) 2013 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. @@ -16,26 +16,499 @@ package android.renderscript; - /** - * Class for exposing the native RenderScript long4 type back to the Android system. - **/ + * Vector version of the basic long type. + * Provides four long fields packed. + */ public class Long4 { + public long x; + public long y; + public long z; + public long w; + public Long4() { } - public Long4(long initX, long initY, long initZ, long initW) { - x = initX; - y = initY; - z = initZ; - w = initW; + /** @hide */ + public Long4(long i) { + this.x = this.y = this.z = this.w = i; } - public long x; - public long y; - public long z; - public long w; -} + public Long4(long x, long y, long z, long w) { + this.x = x; + this.y = y; + this.z = z; + this.w = w; + } + + /** @hide */ + public Long4(Long4 source) { + this.x = source.x; + this.y = source.y; + this.z = source.z; + this.w = source.w; + } + + /** @hide + * Vector add + * + * @param a + */ + public void add(Long4 a) { + this.x += a.x; + this.y += a.y; + this.z += a.z; + this.w += a.w; + } + + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Long4 add(Long4 a, Long4 b) { + Long4 result = new Long4(); + result.x = a.x + b.x; + result.y = a.y + b.y; + result.z = a.z + b.z; + result.w = a.w + b.w; + + return result; + } + + /** @hide + * Vector add + * + * @param value + */ + public void add(long value) { + x += value; + y += value; + z += value; + w += value; + } + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Long4 add(Long4 a, long b) { + Long4 result = new Long4(); + result.x = a.x + b; + result.y = a.y + b; + result.z = a.z + b; + result.w = a.w + b; + return result; + } + + /** @hide + * Vector subtraction + * + * @param a + */ + public void sub(Long4 a) { + this.x -= a.x; + this.y -= a.y; + this.z -= a.z; + this.w -= a.w; + } + + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Long4 sub(Long4 a, Long4 b) { + Long4 result = new Long4(); + result.x = a.x - b.x; + result.y = a.y - b.y; + result.z = a.z - b.z; + result.w = a.w - b.w; + + return result; + } + + /** @hide + * Vector subtraction + * + * @param value + */ + public void sub(long value) { + x -= value; + y -= value; + z -= value; + w -= value; + } + + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Long4 sub(Long4 a, long b) { + Long4 result = new Long4(); + result.x = a.x - b; + result.y = a.y - b; + result.z = a.z - b; + result.w = a.w - b; + + return result; + } + /** @hide + * Vector multiplication + * + * @param a + */ + public void mul(Long4 a) { + this.x *= a.x; + this.y *= a.y; + this.z *= a.z; + this.w *= a.w; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Long4 mul(Long4 a, Long4 b) { + Long4 result = new Long4(); + result.x = a.x * b.x; + result.y = a.y * b.y; + result.z = a.z * b.z; + result.w = a.w * b.w; + + return result; + } + + /** @hide + * Vector multiplication + * + * @param value + */ + public void mul(long value) { + x *= value; + y *= value; + z *= value; + w *= value; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Long4 mul(Long4 a, long b) { + Long4 result = new Long4(); + result.x = a.x * b; + result.y = a.y * b; + result.z = a.z * b; + result.w = a.w * b; + + return result; + } + + /** @hide + * Vector division + * + * @param a + */ + public void div(Long4 a) { + this.x /= a.x; + this.y /= a.y; + this.z /= a.z; + this.w /= a.w; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Long4 div(Long4 a, Long4 b) { + Long4 result = new Long4(); + result.x = a.x / b.x; + result.y = a.y / b.y; + result.z = a.z / b.z; + result.w = a.w / b.w; + + return result; + } + + /** @hide + * Vector division + * + * @param value + */ + public void div(long value) { + x /= value; + y /= value; + z /= value; + w /= value; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Long4 div(Long4 a, long b) { + Long4 result = new Long4(); + result.x = a.x / b; + result.y = a.y / b; + result.z = a.z / b; + result.w = a.w / b; + + return result; + } + + /** @hide + * Vector Modulo + * + * @param a + */ + public void mod(Long4 a) { + this.x %= a.x; + this.y %= a.y; + this.z %= a.z; + this.w %= a.w; + } + + /** @hide + * Vector Modulo + * + * @param a + * @param b + * @return + */ + public static Long4 mod(Long4 a, Long4 b) { + Long4 result = new Long4(); + result.x = a.x % b.x; + result.y = a.y % b.y; + result.z = a.z % b.z; + result.w = a.w % b.w; + + return result; + } + + /** @hide + * Vector Modulo + * + * @param value + */ + public void mod(long value) { + x %= value; + y %= value; + z %= value; + w %= value; + } + + /** @hide + * Vector Modulo + * + * @param a + * @param b + * @return + */ + public static Long4 mod(Long4 a, long b) { + Long4 result = new Long4(); + result.x = a.x % b; + result.y = a.y % b; + result.z = a.z % b; + result.w = a.w % b; + + return result; + } + + /** @hide + * get vector length + * + * @return + */ + public long length() { + return 4; + } + + /** @hide + * set vector negate + */ + public void negate() { + this.x = -x; + this.y = -y; + this.z = -z; + this.w = -w; + } + + /** @hide + * Vector dot Product + * + * @param a + * @return + */ + public long dotProduct(Long4 a) { + return (long)((x * a.x) + (y * a.y) + (z * a.z) + (w * a.w)); + } + + /** @hide + * Vector dot Product + * + * @param a + * @param b + * @return + */ + public static long dotProduct(Long4 a, Long4 b) { + return (long)((b.x * a.x) + (b.y * a.y) + (b.z * a.z) + (b.w * a.w)); + } + + /** @hide + * Vector add Multiple + * + * @param a + * @param factor + */ + public void addMultiple(Long4 a, long factor) { + x += a.x * factor; + y += a.y * factor; + z += a.z * factor; + w += a.w * factor; + } + + /** @hide + * set vector value by Long4 + * + * @param a + */ + public void set(Long4 a) { + this.x = a.x; + this.y = a.y; + this.z = a.z; + this.w = a.w; + } + + /** @hide + * set the vector field value by Long + * + * @param a + * @param b + * @param c + * @param d + */ + public void setValues(long a, long b, long c, long d) { + this.x = a; + this.y = b; + this.z = c; + this.w = d; + } + + /** @hide + * return the element sum of vector + * + * @return + */ + public long elementSum() { + return (long)(x + y + z + w); + } + + /** @hide + * get the vector field value by index + * + * @param i + * @return + */ + public long get(int i) { + switch (i) { + case 0: + return (long)(x); + case 1: + return (long)(y); + case 2: + return (long)(z); + case 3: + return (long)(w); + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * set the vector field value by index + * + * @param i + * @param value + */ + public void setAt(int i, long value) { + switch (i) { + case 0: + x = value; + return; + case 1: + y = value; + return; + case 2: + z = value; + return; + case 3: + w = value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * add the vector field value by index + * + * @param i + * @param value + */ + public void addAt(int i, long value) { + switch (i) { + case 0: + x += value; + return; + case 1: + y += value; + return; + case 2: + z += value; + return; + case 3: + w += value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * copy the vector to long array + * + * @param data + * @param offset + */ + public void copyTo(Long[] data, int offset) { + data[offset] = (long)(x); + data[offset + 1] = (long)(y); + data[offset + 2] = (long)(z); + data[offset + 3] = (long)(w); + } +} diff --git a/graphics/java/android/renderscript/Short2.java b/graphics/java/android/renderscript/Short2.java index 2c6c334..24809f7 100644 --- a/graphics/java/android/renderscript/Short2.java +++ b/graphics/java/android/renderscript/Short2.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2009 The Android Open Source Project + * Copyright (C) 2013 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. @@ -20,20 +20,424 @@ package android.renderscript; /** * Class for exposing the native RenderScript Short2 type back to the Android system. * - **/ + * Vector version of the basic short type. + * Provides two short fields packed. + */ public class Short2 { + public short x; + public short y; + public Short2() { } - public Short2(short initX, short initY) { - x = initX; - y = initY; + /** @hide */ + public Short2(short i) { + this.x = this.y = i; } - public short x; - public short y; -} + public Short2(short x, short y) { + this.x = x; + this.y = y; + } + /** @hide */ + public Short2(Short2 source) { + this.x = source.x; + this.y = source.y; + } + /** @hide + * Vector add + * + * @param a + */ + public void add(Short2 a) { + this.x += a.x; + this.y += a.y; + } + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Short2 add(Short2 a, Short2 b) { + Short2 result = new Short2(); + result.x = (short)(a.x + b.x); + result.y = (short)(a.y + b.y); + return result; + } + + /** @hide + * Vector add + * + * @param value + */ + public void add(short value) { + x += value; + y += value; + } + + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Short2 add(Short2 a, short b) { + Short2 result = new Short2(); + result.x = (short)(a.x + b); + result.y = (short)(a.y + b); + + return result; + } + + /** @hide + * Vector subtraction + * + * @param a + */ + public void sub(Short2 a) { + this.x -= a.x; + this.y -= a.y; + } + + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Short2 sub(Short2 a, Short2 b) { + Short2 result = new Short2(); + result.x = (short)(a.x - b.x); + result.y = (short)(a.y - b.y); + + return result; + } + + /** @hide + * Vector subtraction + * + * @param value + */ + public void sub(short value) { + x -= value; + y -= value; + } + + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Short2 sub(Short2 a, short b) { + Short2 result = new Short2(); + result.x = (short)(a.x - b); + result.y = (short)(a.y - b); + + return result; + } + + /** @hide + * Vector multiplication + * + * @param a + */ + public void mul(Short2 a) { + this.x *= a.x; + this.y *= a.y; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Short2 mul(Short2 a, Short2 b) { + Short2 result = new Short2(); + result.x = (short)(a.x * b.x); + result.y = (short)(a.y * b.y); + + return result; + } + + /** @hide + * Vector multiplication + * + * @param value + */ + public void mul(short value) { + x *= value; + y *= value; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Short2 mul(Short2 a, short b) { + Short2 result = new Short2(); + result.x = (short)(a.x * b); + result.y = (short)(a.y * b); + + return result; + } + + /** @hide + * Vector division + * + * @param a + */ + public void div(Short2 a) { + this.x /= a.x; + this.y /= a.y; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Short2 div(Short2 a, Short2 b) { + Short2 result = new Short2(); + result.x = (short)(a.x / b.x); + result.y = (short)(a.y / b.y); + + return result; + } + + /** @hide + * Vector division + * + * @param value + */ + public void div(short value) { + x /= value; + y /= value; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Short2 div(Short2 a, short b) { + Short2 result = new Short2(); + result.x = (short)(a.x / b); + result.y = (short)(a.y / b); + + return result; + } + + /** @hide + * Vector Modulo + * + * @param a + */ + public void mod(Short2 a) { + this.x %= a.x; + this.y %= a.y; + } + + /** @hide + * Vector Modulo + * + * @param a + * @param b + * @return + */ + public static Short2 mod(Short2 a, Short2 b) { + Short2 result = new Short2(); + result.x = (short)(a.x % b.x); + result.y = (short)(a.y % b.y); + + return result; + } + + /** @hide + * Vector Modulo + * + * @param value + */ + public void mod(short value) { + x %= value; + y %= value; + } + + /** @hide + * Vector Modulo + * + * @param a + * @param b + * @return + */ + public static Short2 mod(Short2 a, short b) { + Short2 result = new Short2(); + result.x = (short)(a.x % b); + result.y = (short)(a.y % b); + + return result; + } + + /** @hide + * get vector length + * + * @return + */ + public short length() { + return 2; + } + + /** @hide + * set vector negate + */ + public void negate() { + this.x = (short)(-x); + this.y = (short)(-y); + } + + /** @hide + * Vector dot Product + * + * @param a + * @return + */ + public short dotProduct(Short2 a) { + return (short)((x * a.x) + (y * a.y)); + } + + /** @hide + * Vector dot Product + * + * @param a + * @param b + * @return + */ + public static short dotProduct(Short2 a, Short2 b) { + return (short)((b.x * a.x) + (b.y * a.y)); + } + + /** @hide + * Vector add Multiple + * + * @param a + * @param factor + */ + public void addMultiple(Short2 a, short factor) { + x += a.x * factor; + y += a.y * factor; + } + + /** @hide + * set vector value by Short2 + * + * @param a + */ + public void set(Short2 a) { + this.x = a.x; + this.y = a.y; + } + + /** @hide + * set the vector field value by Short + * + * @param a + * @param b + */ + public void setValues(short a, short b) { + this.x = a; + this.y = b; + } + + /** @hide + * return the element sum of vector + * + * @return + */ + public short elementSum() { + return (short)(x + y); + } + + /** @hide + * get the vector field value by index + * + * @param i + * @return + */ + public short get(int i) { + switch (i) { + case 0: + return (short)(x); + case 1: + return (short)(y); + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * set the vector field value by index + * + * @param i + * @param value + */ + public void setAt(int i, short value) { + switch (i) { + case 0: + x = value; + return; + case 1: + y = value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * add the vector field value by index + * + * @param i + * @param value + */ + public void addAt(int i, short value) { + switch (i) { + case 0: + x += value; + return; + case 1: + y += value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * copy the vector to short array + * + * @param data + * @param offset + */ + public void copyTo(short[] data, int offset) { + data[offset] = (short)(x); + data[offset + 1] = (short)(y); + } +} diff --git a/graphics/java/android/renderscript/Short3.java b/graphics/java/android/renderscript/Short3.java index aafd27b..661db0a 100644 --- a/graphics/java/android/renderscript/Short3.java +++ b/graphics/java/android/renderscript/Short3.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2009 The Android Open Source Project + * Copyright (C) 2013 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. @@ -16,26 +16,462 @@ package android.renderscript; - /** - * Class for exposing the native RenderScript short3 type back to the Android system. - * - **/ + * Vector version of the basic short type. + * Provides three short fields packed. + */ public class Short3 { + public short x; + public short y; + public short z; + public Short3() { } - public Short3(short initX, short initY, short initZ) { - x = initX; - y = initY; - z = initZ; + /** @hide */ + public Short3(short i) { + this.x = this.y = this.z = i; } - public short x; - public short y; - public short z; -} + public Short3(short x, short y, short z) { + this.x = x; + this.y = y; + this.z = z; + } + + /** @hide */ + public Short3(Short3 source) { + this.x = source.x; + this.y = source.y; + this.z = source.z; + } + /** @hide + * Vector add + * + * @param a + */ + public void add(Short3 a) { + this.x += a.x; + this.y += a.y; + this.z += a.z; + } + + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Short3 add(Short3 a, Short3 b) { + Short3 result = new Short3(); + result.x = (short)(a.x + b.x); + result.y = (short)(a.y + b.y); + result.z = (short)(a.z + b.z); + return result; + } + + /** @hide + * Vector add + * + * @param value + */ + public void add(short value) { + x += value; + y += value; + z += value; + } + + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Short3 add(Short3 a, short b) { + Short3 result = new Short3(); + result.x = (short)(a.x + b); + result.y = (short)(a.y + b); + result.z = (short)(a.z + b); + + return result; + } + /** @hide + * Vector subtraction + * + * @param a + */ + public void sub(Short3 a) { + this.x -= a.x; + this.y -= a.y; + this.z -= a.z; + } + + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Short3 sub(Short3 a, Short3 b) { + Short3 result = new Short3(); + result.x = (short)(a.x - b.x); + result.y = (short)(a.y - b.y); + result.z = (short)(a.z - b.z); + + return result; + } + + /** @hide + * Vector subtraction + * + * @param value + */ + public void sub(short value) { + x -= value; + y -= value; + z -= value; + } + + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Short3 sub(Short3 a, short b) { + Short3 result = new Short3(); + result.x = (short)(a.x - b); + result.y = (short)(a.y - b); + result.z = (short)(a.z - b); + + return result; + } + + /** @hide + * Vector multiplication + * + * @param a + */ + public void mul(Short3 a) { + this.x *= a.x; + this.y *= a.y; + this.z *= a.z; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Short3 mul(Short3 a, Short3 b) { + Short3 result = new Short3(); + result.x = (short)(a.x * b.x); + result.y = (short)(a.y * b.y); + result.z = (short)(a.z * b.z); + + return result; + } + + /** @hide + * Vector multiplication + * + * @param value + */ + public void mul(short value) { + x *= value; + y *= value; + z *= value; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Short3 mul(Short3 a, short b) { + Short3 result = new Short3(); + result.x = (short)(a.x * b); + result.y = (short)(a.y * b); + result.z = (short)(a.z * b); + + return result; + } + + /** @hide + * Vector division + * + * @param a + */ + public void div(Short3 a) { + this.x /= a.x; + this.y /= a.y; + this.z /= a.z; + } + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Short3 div(Short3 a, Short3 b) { + Short3 result = new Short3(); + result.x = (short)(a.x / b.x); + result.y = (short)(a.y / b.y); + result.z = (short)(a.z / b.z); + + return result; + } + + /** @hide + * Vector division + * + * @param value + */ + public void div(short value) { + x /= value; + y /= value; + z /= value; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Short3 div(Short3 a, short b) { + Short3 result = new Short3(); + result.x = (short)(a.x / b); + result.y = (short)(a.y / b); + result.z = (short)(a.z / b); + + return result; + } + + /** @hide + * Vector Modulo + * + * @param a + */ + public void mod(Short3 a) { + this.x %= a.x; + this.y %= a.y; + this.z %= a.z; + } + + /** @hide + * Vector Modulo + * + * @param a + * @param b + * @return + */ + public static Short3 mod(Short3 a, Short3 b) { + Short3 result = new Short3(); + result.x = (short)(a.x % b.x); + result.y = (short)(a.y % b.y); + result.z = (short)(a.z % b.z); + + return result; + } + + /** @hide + * Vector Modulo + * + * @param value + */ + public void mod(short value) { + x %= value; + y %= value; + z %= value; + } + + /** @hide + * Vector Modulo + * + * @param a + * @param b + * @return + */ + public static Short3 mod(Short3 a, short b) { + Short3 result = new Short3(); + result.x = (short)(a.x % b); + result.y = (short)(a.y % b); + result.z = (short)(a.z % b); + + return result; + } + + /** @hide + * get vector length + * + * @return + */ + public short length() { + return 3; + } + + /** @hide + * set vector negate + */ + public void negate() { + this.x = (short)(-x); + this.y = (short)(-y); + this.z = (short)(-z); + } + + /** @hide + * Vector dot Product + * + * @param a + * @return + */ + public short dotProduct(Short3 a) { + return (short)((x * a.x) + (y * a.y) + (z * a.z)); + } + + /** @hide + * Vector dot Product + * + * @param a + * @param b + * @return + */ + public static short dotProduct(Short3 a, Short3 b) { + return (short)((b.x * a.x) + (b.y * a.y) + (b.z * a.z)); + } + + /** @hide + * Vector add Multiple + * + * @param a + * @param factor + */ + public void addMultiple(Short3 a, short factor) { + x += a.x * factor; + y += a.y * factor; + z += a.z * factor; + } + + /** @hide + * set vector value by Short3 + * + * @param a + */ + public void set(Short3 a) { + this.x = a.x; + this.y = a.y; + this.z = a.z; + } + + /** @hide + * set the vector field value by Short + * + * @param a + * @param b + * @param c + */ + public void setValues(short a, short b, short c) { + this.x = a; + this.y = b; + this.z = c; + } + + /** @hide + * return the element sum of vector + * + * @return + */ + public short elementSum() { + return (short)(x + y + z); + } + + /** @hide + * get the vector field value by index + * + * @param i + * @return + */ + public short get(int i) { + switch (i) { + case 0: + return (short)(x); + case 1: + return (short)(y); + case 2: + return (short)(z); + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * set the vector field value by index + * + * @param i + * @param value + */ + public void setAt(int i, short value) { + switch (i) { + case 0: + x = value; + return; + case 1: + y = value; + return; + case 2: + z = value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * add the vector field value by index + * + * @param i + * @param value + */ + public void addAt(int i, short value) { + switch (i) { + case 0: + x += value; + return; + case 1: + y += value; + return; + case 2: + z += value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * copy the vector to short array + * + * @param data + * @param offset + */ + public void copyTo(short[] data, int offset) { + data[offset] = (short)(x); + data[offset + 1] = (short)(y); + data[offset + 2] = (short)(z); + } +} diff --git a/graphics/java/android/renderscript/Short4.java b/graphics/java/android/renderscript/Short4.java index 176bde9..a2d74f2 100644 --- a/graphics/java/android/renderscript/Short4.java +++ b/graphics/java/android/renderscript/Short4.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2009 The Android Open Source Project + * Copyright (C) 2013 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. @@ -16,27 +16,499 @@ package android.renderscript; - /** - * Class for exposing the native RenderScript short4 type back to the Android system. - * - **/ + * Vector version of the basic short type. + * Provides four short fields packed. + */ public class Short4 { + public short x; + public short y; + public short z; + public short w; + public Short4() { } - public Short4(short initX, short initY, short initZ, short initW) { - x = initX; - y = initY; - z = initZ; - w = initW; + /** @hide */ + public Short4(short i) { + this.x = this.y = this.z = this.w = i; } - public short x; - public short y; - public short z; - public short w; -} + public Short4(short x, short y, short z, short w) { + this.x = x; + this.y = y; + this.z = z; + this.w = w; + } + + /** @hide */ + public Short4(Short4 source) { + this.x = source.x; + this.y = source.y; + this.z = source.z; + this.w = source.w; + } + + /** @hide + * Vector add + * + * @param a + */ + public void add(Short4 a) { + this.x += a.x; + this.y += a.y; + this.z += a.z; + this.w += a.w; + } + + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Short4 add(Short4 a, Short4 b) { + Short4 result = new Short4(); + result.x = (short)(a.x + b.x); + result.y = (short)(a.y + b.y); + result.z = (short)(a.z + b.z); + result.w = (short)(a.w + b.w); + + return result; + } + + /** @hide + * Vector add + * + * @param value + */ + public void add(short value) { + x += value; + y += value; + z += value; + w += value; + } + + /** @hide + * Vector add + * + * @param a + * @param b + * @return + */ + public static Short4 add(Short4 a, short b) { + Short4 result = new Short4(); + result.x = (short)(a.x + b); + result.y = (short)(a.y + b); + result.z = (short)(a.z + b); + result.w = (short)(a.w + b); + + return result; + } + + /** @hide + * Vector subtraction + * + * @param a + */ + public void sub(Short4 a) { + this.x -= a.x; + this.y -= a.y; + this.z -= a.z; + this.w -= a.w; + } + + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Short4 sub(Short4 a, Short4 b) { + Short4 result = new Short4(); + result.x = (short)(a.x - b.x); + result.y = (short)(a.y - b.y); + result.z = (short)(a.z - b.z); + result.w = (short)(a.w - b.w); + + return result; + } + + /** @hide + * Vector subtraction + * + * @param value + */ + public void sub(short value) { + x -= value; + y -= value; + z -= value; + w -= value; + } + + /** @hide + * Vector subtraction + * + * @param a + * @param b + * @return + */ + public static Short4 sub(Short4 a, short b) { + Short4 result = new Short4(); + result.x = (short)(a.x - b); + result.y = (short)(a.y - b); + result.z = (short)(a.z - b); + result.w = (short)(a.w - b); + + return result; + } + + /** @hide + * Vector multiplication + * + * @param a + */ + public void mul(Short4 a) { + this.x *= a.x; + this.y *= a.y; + this.z *= a.z; + this.w *= a.w; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Short4 mul(Short4 a, Short4 b) { + Short4 result = new Short4(); + result.x = (short)(a.x * b.x); + result.y = (short)(a.y * b.y); + result.z = (short)(a.z * b.z); + result.w = (short)(a.w * b.w); + + return result; + } + + /** @hide + * Vector multiplication + * + * @param value + */ + public void mul(short value) { + x *= value; + y *= value; + z *= value; + w *= value; + } + + /** @hide + * Vector multiplication + * + * @param a + * @param b + * @return + */ + public static Short4 mul(Short4 a, short b) { + Short4 result = new Short4(); + result.x = (short)(a.x * b); + result.y = (short)(a.y * b); + result.z = (short)(a.z * b); + result.w = (short)(a.w * b); + return result; + } + + /** @hide + * Vector division + * + * @param a + */ + public void div(Short4 a) { + this.x /= a.x; + this.y /= a.y; + this.z /= a.z; + this.w /= a.w; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Short4 div(Short4 a, Short4 b) { + Short4 result = new Short4(); + result.x = (short)(a.x / b.x); + result.y = (short)(a.y / b.y); + result.z = (short)(a.z / b.z); + result.w = (short)(a.w / b.w); + + return result; + } + + /** @hide + * Vector division + * + * @param value + */ + public void div(short value) { + x /= value; + y /= value; + z /= value; + w /= value; + } + + /** @hide + * Vector division + * + * @param a + * @param b + * @return + */ + public static Short4 div(Short4 a, short b) { + Short4 result = new Short4(); + result.x = (short)(a.x / b); + result.y = (short)(a.y / b); + result.z = (short)(a.z / b); + result.w = (short)(a.w / b); + + return result; + } + + /** @hide + * Vector Modulo + * + * @param a + */ + public void mod(Short4 a) { + this.x %= a.x; + this.y %= a.y; + this.z %= a.z; + this.w %= a.w; + } + + /** @hide + * Vector Modulo + * + * @param a + * @param b + * @return + */ + public static Short4 mod(Short4 a, Short4 b) { + Short4 result = new Short4(); + result.x = (short)(a.x % b.x); + result.y = (short)(a.y % b.y); + result.z = (short)(a.z % b.z); + result.w = (short)(a.w % b.w); + + return result; + } + + /** @hide + * Vector Modulo + * + * @param value + */ + public void mod(short value) { + x %= value; + y %= value; + z %= value; + w %= value; + } + + /** @hide + * Vector Modulo + * + * @param a + * @param b + * @return + */ + public static Short4 mod(Short4 a, short b) { + Short4 result = new Short4(); + result.x = (short)(a.x % b); + result.y = (short)(a.y % b); + result.z = (short)(a.z % b); + result.w = (short)(a.w % b); + + return result; + } + + /** @hide + * get vector length + * + * @return + */ + public short length() { + return 4; + } + + /** @hide + * set vector negate + */ + public void negate() { + this.x = (short)(-x); + this.y = (short)(-y); + this.z = (short)(-z); + this.w = (short)(-w); + } + + /** @hide + * Vector dot Product + * + * @param a + * @return + */ + public short dotProduct(Short4 a) { + return (short)((x * a.x) + (y * a.y) + (z * a.z) + (w * a.w)); + } + + /** @hide + * Vector dot Product + * + * @param a + * @param b + * @return + */ + public static short dotProduct(Short4 a, Short4 b) { + return (short)((b.x * a.x) + (b.y * a.y) + (b.z * a.z) + (b.w * a.w)); + } + + /** @hide + * Vector add Multiple + * + * @param a + * @param factor + */ + public void addMultiple(Short4 a, short factor) { + x += a.x * factor; + y += a.y * factor; + z += a.z * factor; + w += a.w * factor; + } + + /** @hide + * set vector value by Short4 + * + * @param a + */ + public void set(Short4 a) { + this.x = a.x; + this.y = a.y; + this.z = a.z; + this.w = a.w; + } + /** @hide + * set the vector field value by Short + * + * @param a + * @param b + * @param c + * @param d + */ + public void setValues(short a, short b, short c, short d) { + this.x = a; + this.y = b; + this.z = c; + this.w = d; + } + + /** @hide + * return the element sum of vector + * + * @return + */ + public short elementSum() { + return (short)(x + y + z + w); + } + /** @hide + * get the vector field value by index + * + * @param i + * @return + */ + public short get(int i) { + switch (i) { + case 0: + return (short)(x); + case 1: + return (short)(y); + case 2: + return (short)(z); + case 3: + return (short)(w); + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * set the vector field value by index + * + * @param i + * @param value + */ + public void setAt(int i, short value) { + switch (i) { + case 0: + x = value; + return; + case 1: + y = value; + return; + case 2: + z = value; + return; + case 3: + w = value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * add the vector field value by index + * + * @param i + * @param value + */ + public void addAt(int i, short value) { + switch (i) { + case 0: + x += value; + return; + case 1: + y += value; + return; + case 2: + z += value; + return; + case 3: + w += value; + return; + default: + throw new IndexOutOfBoundsException("Index: i"); + } + } + + /** @hide + * copy the vector to short array + * + * @param data + * @param offset + */ + public void copyTo(short[] data, int offset) { + data[offset] = (short)(x); + data[offset + 1] = (short)(y); + data[offset + 2] = (short)(z); + data[offset + 3] = (short)(w); + } +} |