Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Element restructuring. Add support for new basic Element types including the RS objects and vectors(2-4). In theory this paves the way for maintaining type info for RS objects, passing elements for GLSL uiforms/attribs/varyings, and supporting nested structures.

Browse Source 
This will break some apps, checkings for other projects will follow to unbreak them.
This commit is contained in:
Jason Sams
2009-12-23 14:35:29 -08:00
parent ceedafacdb
commit 718cd1f322
32 changed files with 1109 additions and 890 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
graphics/java/android/renderscript/Allocation.java
View File

@@ -171,9 +171,10 @@ public class Allocation extends BaseObj {
public Adapter1D createAdapter1D() {
mRS.validate();
int id = mRS.nAdapter1DCreate();
if (id != 0) {
mRS.nAdapter1DBindAllocation(id, mID);
if(id == 0) {
throw new IllegalStateException("allocation failed.");
}
mRS.nAdapter1DBindAllocation(id, mID);
return new Adapter1D(id, mRS);
}
@@ -213,9 +214,10 @@ public class Allocation extends BaseObj {
public Adapter2D createAdapter2D() {
mRS.validate();
int id = mRS.nAdapter2DCreate();
if (id != 0) {
mRS.nAdapter2DBindAllocation(id, mID);
if(id == 0) {
throw new IllegalStateException("allocation failed.");
}
mRS.nAdapter2DBindAllocation(id, mID);
return new Adapter2D(id, mRS);
}
@@ -258,6 +260,9 @@ public class Allocation extends BaseObj {
rs.validate();
int id = rs.nAllocationCreateFromBitmap(dstFmt.mID, genMips, b);
if(id == 0) {
throw new IllegalStateException("Load failed.");
}
return new Allocation(id, rs, null);
}
@@ -266,6 +271,9 @@ public class Allocation extends BaseObj {
rs.validate();
int id = rs.nAllocationCreateFromBitmapBoxed(dstFmt.mID, genMips, b);
if(id == 0) {
throw new IllegalStateException("Load failed.");
}
return new Allocation(id, rs, null);
}
@@ -282,6 +290,9 @@ public class Allocation extends BaseObj {
int allocationId = rs.nAllocationCreateFromAssetStream(dstFmt.mID, genMips,
asset);
if(allocationId == 0) {
throw new IllegalStateException("Load failed.");
}
return new Allocation(allocationId, rs, null);
} catch (Exception e) {
// Ignore

1
graphics/java/android/renderscript/BaseObj.java
View File

@@ -25,6 +25,7 @@ import android.util.Log;
class BaseObj {
BaseObj(RenderScript rs) {
rs.validate();
mRS = rs;
mID = 0;
mDestroyed = false;

735
graphics/java/android/renderscript/Element.java
View File

@@ -24,248 +24,66 @@ import java.lang.reflect.Field;
**/
public class Element extends BaseObj {
int mSize;
Entry[] mEntries;
Element[] mElements;
String[] mElementNames;
int getSizeBytes() {
return mSize;
}
int getComponentCount() {
return mEntries.length;
}
Element.DataType getComponentDataType(int num) {
return mEntries[num].mType;
}
Element.DataKind getComponentDataKind(int num) {
return mEntries[num].mKind;
}
boolean getComponentIsNormalized(int num) {
return mEntries[num].mIsNormalized;
}
int getComponentBits(int num) {
return mEntries[num].mBits;
}
String getComponentName(int num) {
return mEntries[num].mName;
}
DataType mType;
DataKind mKind;
boolean mNormalized;
int mVectorSize;
static class Entry {
//Element mElement;
Element.DataType mType;
Element.DataKind mKind;
boolean mIsNormalized;
int mBits;
String mName;
//Entry(Element e, int bits) {
//mElement = e;
//int mBits = bits;
//}
Entry(DataType dt, DataKind dk, boolean isNorm, int bits, String name) {
mType = dt;
mKind = dk;
mIsNormalized = isNorm;
mBits = bits;
mName = name;
}
}
public static Element USER_U8(RenderScript rs) {
if(rs.mElement_USER_U8 == null) {
rs.mElement_USER_U8 = new Element(rs, 1);
rs.mElement_USER_U8.mEntries[0] = new Entry(DataType.UNSIGNED, DataKind.USER, false, 8, null);
rs.mElement_USER_U8.init();
}
return rs.mElement_USER_U8;
}
public static Element USER_I8(RenderScript rs) {
if(rs.mElement_USER_I8 == null) {
rs.mElement_USER_I8 = new Element(rs, 1);
rs.mElement_USER_I8.mEntries[0] = new Entry(DataType.SIGNED, DataKind.USER, false, 8, null);
rs.mElement_USER_I8.init();
}
return rs.mElement_USER_I8;
}
public static Element USER_U16(RenderScript rs) {
if(rs.mElement_USER_U16 == null) {
rs.mElement_USER_U16 = new Element(rs, 1);
rs.mElement_USER_U16.mEntries[0] = new Entry(DataType.UNSIGNED, DataKind.USER, false, 16, null);
rs.mElement_USER_U16.init();
}
return rs.mElement_USER_U16;
}
public static Element USER_I16(RenderScript rs) {
if(rs.mElement_USER_I16 == null) {
rs.mElement_USER_I16 = new Element(rs, 1);
rs.mElement_USER_I16.mEntries[0] = new Entry(DataType.SIGNED, DataKind.USER, false, 16, null);
rs.mElement_USER_I16.init();
}
return rs.mElement_USER_I16;
}
public static Element USER_U32(RenderScript rs) {
if(rs.mElement_USER_U32 == null) {
rs.mElement_USER_U32 = new Element(rs, 1);
rs.mElement_USER_U32.mEntries[0] = new Entry(DataType.UNSIGNED, DataKind.USER, false, 32, null);
rs.mElement_USER_U32.init();
}
return rs.mElement_USER_U32;
}
public static Element USER_I32(RenderScript rs) {
if(rs.mElement_USER_I32 == null) {
rs.mElement_USER_I32 = new Element(rs, 1);
rs.mElement_USER_I32.mEntries[0] = new Entry(DataType.SIGNED, DataKind.USER, false, 32, null);
rs.mElement_USER_I32.init();
}
return rs.mElement_USER_I32;
}
public static Element USER_F32(RenderScript rs) {
if(rs.mElement_USER_FLOAT == null) {
rs.mElement_USER_FLOAT = new Element(rs, 1);
rs.mElement_USER_FLOAT.mEntries[0] = new Entry(DataType.FLOAT, DataKind.USER, false, 32, null);
rs.mElement_USER_FLOAT.init();
}
return rs.mElement_USER_FLOAT;
}
public static Element A_8(RenderScript rs) {
if(rs.mElement_A_8 == null) {
rs.mElement_A_8 = new Element(rs, 1);
rs.mElement_A_8.mEntries[0] = new Entry(DataType.UNSIGNED, DataKind.ALPHA, true, 8, "a");
rs.mElement_A_8.init();
}
return rs.mElement_A_8;
}
public static Element RGB_565(RenderScript rs) {
if(rs.mElement_RGB_565 == null) {
rs.mElement_RGB_565 = new Element(rs, 3);
rs.mElement_RGB_565.mEntries[0] = new Entry(DataType.UNSIGNED, DataKind.RED, true, 5, "r");
rs.mElement_RGB_565.mEntries[1] = new Entry(DataType.UNSIGNED, DataKind.GREEN, true, 6, "g");
rs.mElement_RGB_565.mEntries[2] = new Entry(DataType.UNSIGNED, DataKind.BLUE, true, 5, "b");
rs.mElement_RGB_565.init();
}
return rs.mElement_RGB_565;
}
public static Element RGB_888(RenderScript rs) {
if(rs.mElement_RGB_888 == null) {
rs.mElement_RGB_888 = new Element(rs, 3);
rs.mElement_RGB_888.mEntries[0] = new Entry(DataType.UNSIGNED, DataKind.RED, true, 8, "r");
rs.mElement_RGB_888.mEntries[1] = new Entry(DataType.UNSIGNED, DataKind.GREEN, true, 8, "g");
rs.mElement_RGB_888.mEntries[2] = new Entry(DataType.UNSIGNED, DataKind.BLUE, true, 8, "b");
rs.mElement_RGB_888.init();
}
return rs.mElement_RGB_888;
}
public static Element RGBA_5551(RenderScript rs) {
if(rs.mElement_RGBA_5551 == null) {
rs.mElement_RGBA_5551 = new Element(rs, 4);
rs.mElement_RGBA_5551.mEntries[0] = new Entry(DataType.UNSIGNED, DataKind.RED, true, 5, "r");
rs.mElement_RGBA_5551.mEntries[1] = new Entry(DataType.UNSIGNED, DataKind.GREEN, true, 5, "g");
rs.mElement_RGBA_5551.mEntries[2] = new Entry(DataType.UNSIGNED, DataKind.BLUE, true, 5, "b");
rs.mElement_RGBA_5551.mEntries[3] = new Entry(DataType.UNSIGNED, DataKind.ALPHA, true, 1, "a");
rs.mElement_RGBA_5551.init();
}
return rs.mElement_RGBA_5551;
}
public static Element RGBA_4444(RenderScript rs) {
if(rs.mElement_RGBA_4444 == null) {
rs.mElement_RGBA_4444 = new Element(rs, 4);
rs.mElement_RGBA_4444.mEntries[0] = new Entry(DataType.UNSIGNED, DataKind.RED, true, 4, "r");
rs.mElement_RGBA_4444.mEntries[1] = new Entry(DataType.UNSIGNED, DataKind.GREEN, true, 4, "g");
rs.mElement_RGBA_4444.mEntries[2] = new Entry(DataType.UNSIGNED, DataKind.BLUE, true, 4, "b");
rs.mElement_RGBA_4444.mEntries[3] = new Entry(DataType.UNSIGNED, DataKind.ALPHA, true, 4, "a");
rs.mElement_RGBA_4444.init();
}
return rs.mElement_RGBA_4444;
}
public static Element RGBA_8888(RenderScript rs) {
if(rs.mElement_RGBA_8888 == null) {
rs.mElement_RGBA_8888 = new Element(rs, 4);
rs.mElement_RGBA_8888.mEntries[0] = new Entry(DataType.UNSIGNED, DataKind.RED, true, 8, "r");
rs.mElement_RGBA_8888.mEntries[1] = new Entry(DataType.UNSIGNED, DataKind.GREEN, true, 8, "g");
rs.mElement_RGBA_8888.mEntries[2] = new Entry(DataType.UNSIGNED, DataKind.BLUE, true, 8, "b");
rs.mElement_RGBA_8888.mEntries[3] = new Entry(DataType.UNSIGNED, DataKind.ALPHA, true, 8, "a");
rs.mElement_RGBA_8888.init();
}
return rs.mElement_RGBA_8888;
}
public static Element INDEX_16(RenderScript rs) {
if(rs.mElement_INDEX_16 == null) {
rs.mElement_INDEX_16 = new Element(rs, 1);
rs.mElement_INDEX_16.mEntries[0] = new Entry(DataType.UNSIGNED, DataKind.INDEX, false, 16, "index");
rs.mElement_INDEX_16.init();
}
return rs.mElement_INDEX_16;
}
public static Element XY_F32(RenderScript rs) {
if(rs.mElement_XY_F32 == null) {
rs.mElement_XY_F32 = new Element(rs, 2);
rs.mElement_XY_F32.mEntries[0] = new Entry(DataType.UNSIGNED, DataKind.X, false, 32, "x");
rs.mElement_XY_F32.mEntries[1] = new Entry(DataType.UNSIGNED, DataKind.Y, false, 32, "y");
rs.mElement_XY_F32.init();
}
return rs.mElement_XY_F32;
}
public static Element XYZ_F32(RenderScript rs) {
if(rs.mElement_XYZ_F32 == null) {
rs.mElement_XYZ_F32 = new Element(rs, 3);
rs.mElement_XYZ_F32.mEntries[0] = new Entry(DataType.UNSIGNED, DataKind.X, false, 32, "x");
rs.mElement_XYZ_F32.mEntries[1] = new Entry(DataType.UNSIGNED, DataKind.Y, false, 32, "y");
rs.mElement_XYZ_F32.mEntries[2] = new Entry(DataType.UNSIGNED, DataKind.Z, false, 32, "z");
rs.mElement_XYZ_F32.init();
}
return rs.mElement_XYZ_F32;
}
static void initPredefined(RenderScript rs) {
rs.nInitElements(A_8(rs).mID, RGBA_4444(rs).mID, RGBA_8888(rs).mID, RGB_565(rs).mID);
}
int getSizeBytes() {return mSize;}
public enum DataType {
FLOAT (0),
UNSIGNED (1),
SIGNED (2);
//FLOAT_16 (1, 2),
FLOAT_32 (2, 4),
//FLOAT_64 (3, 8),
SIGNED_8 (4, 1),
SIGNED_16 (5, 2),
SIGNED_32 (6, 4),
//SIGNED_64 (7, 8),
UNSIGNED_8 (8, 1),
UNSIGNED_16 (9, 2),
UNSIGNED_32 (10, 4),
//UNSIGNED_64 (11, 8),
UNSIGNED_5_6_5 (12, 2),
UNSIGNED_5_5_5_1 (13, 2),
UNSIGNED_4_4_4_4 (14, 2),
RS_ELEMENT (15, 4),
RS_TYPE (16, 4),
RS_ALLOCATION (17, 4),
RS_SAMPLER (18, 4),
RS_SCRIPT (19, 4),
RS_MESH (20, 4),
RS_PROGRAM_FRAGMENT (21, 4),
RS_PROGRAM_VERTEX (22, 4),
RS_PROGRAM_RASTER (23, 4),
RS_PROGRAM_STORE (24, 4);
int mID;
DataType(int id) {
int mSize;
DataType(int id, int size) {
mID = id;
mSize = size;
}
}
public enum DataKind {
USER (0),
RED (1),
GREEN (2),
BLUE (3),
ALPHA (4),
LUMINANCE (5),
INTENSITY (6),
X (7),
Y (8),
Z (9),
W (10),
S (11),
T (12),
Q (13),
R (14),
NX (15),
NY (16),
NZ (17),
INDEX (18),
POINT_SIZE(19);
COLOR (1),
POSITION (2),
TEXTURE (3),
NORMAL (4),
INDEX (5),
POINT_SIZE(6),
PIXEL_L (7),
PIXEL_A (8),
PIXEL_LA (9),
PIXEL_RGB (10),
PIXEL_RGBA (11);
int mID;
DataKind(int id) {
@@ -273,10 +91,153 @@ public class Element extends BaseObj {
}
}
Element(RenderScript rs, int count) {
public static Element USER_U8(RenderScript rs) {
if(rs.mElement_USER_U8 == null) {
rs.mElement_USER_U8 = createUser(rs, DataType.UNSIGNED_8);
}
return rs.mElement_USER_U8;
}
public static Element USER_I8(RenderScript rs) {
if(rs.mElement_USER_I8 == null) {
rs.mElement_USER_I8 = createUser(rs, DataType.SIGNED_8);
}
return rs.mElement_USER_I8;
}
public static Element USER_U32(RenderScript rs) {
if(rs.mElement_USER_U32 == null) {
rs.mElement_USER_U32 = createUser(rs, DataType.UNSIGNED_32);
}
return rs.mElement_USER_U32;
}
public static Element USER_I32(RenderScript rs) {
if(rs.mElement_USER_I32 == null) {
rs.mElement_USER_I32 = createUser(rs, DataType.SIGNED_32);
}
return rs.mElement_USER_I32;
}
public static Element USER_F32(RenderScript rs) {
if(rs.mElement_USER_F32 == null) {
rs.mElement_USER_F32 = createUser(rs, DataType.FLOAT_32);
}
return rs.mElement_USER_F32;
}
public static Element A_8(RenderScript rs) {
if(rs.mElement_A_8 == null) {
rs.mElement_A_8 = createPixel(rs, DataType.UNSIGNED_8, DataKind.PIXEL_A);
}
return rs.mElement_A_8;
}
public static Element RGB_565(RenderScript rs) {
if(rs.mElement_RGB_565 == null) {
rs.mElement_RGB_565 = createPixel(rs, DataType.UNSIGNED_5_6_5, DataKind.PIXEL_RGB);
}
return rs.mElement_RGB_565;
}
public static Element RGB_888(RenderScript rs) {
if(rs.mElement_RGB_888 == null) {
rs.mElement_RGB_888 = createPixel(rs, DataType.UNSIGNED_8, DataKind.PIXEL_RGB);
}
return rs.mElement_RGB_888;
}
public static Element RGBA_5551(RenderScript rs) {
if(rs.mElement_RGBA_5551 == null) {
rs.mElement_RGBA_5551 = createPixel(rs, DataType.UNSIGNED_5_5_5_1, DataKind.PIXEL_RGBA);
}
return rs.mElement_RGBA_5551;
}
public static Element RGBA_4444(RenderScript rs) {
if(rs.mElement_RGBA_4444 == null) {
rs.mElement_RGBA_4444 = createPixel(rs, DataType.UNSIGNED_4_4_4_4, DataKind.PIXEL_RGBA);
}
return rs.mElement_RGBA_4444;
}
public static Element RGBA_8888(RenderScript rs) {
if(rs.mElement_RGBA_8888 == null) {
rs.mElement_RGBA_8888 = createPixel(rs, DataType.UNSIGNED_8, DataKind.PIXEL_RGBA);
}
return rs.mElement_RGBA_8888;
}
public static Element INDEX_16(RenderScript rs) {
if(rs.mElement_INDEX_16 == null) {
rs.mElement_INDEX_16 = createIndex(rs);
}
return rs.mElement_INDEX_16;
}
public static Element ATTRIB_POSITION_2(RenderScript rs) {
if(rs.mElement_POSITION_2 == null) {
rs.mElement_POSITION_2 = createAttrib(rs, DataType.FLOAT_32, DataKind.POSITION, 2);
}
return rs.mElement_POSITION_2;
}
public static Element ATTRIB_POSITION_3(RenderScript rs) {
if(rs.mElement_POSITION_3 == null) {
rs.mElement_POSITION_3 = createAttrib(rs, DataType.FLOAT_32, DataKind.POSITION, 3);
}
return rs.mElement_POSITION_3;
}
public static Element ATTRIB_TEXTURE_2(RenderScript rs) {
if(rs.mElement_TEXTURE_2 == null) {
rs.mElement_TEXTURE_2 = createAttrib(rs, DataType.FLOAT_32, DataKind.TEXTURE, 2);
}
return rs.mElement_TEXTURE_2;
}
public static Element ATTRIB_NORMAL_3(RenderScript rs) {
if(rs.mElement_NORMAL_3 == null) {
rs.mElement_NORMAL_3 = createAttrib(rs, DataType.FLOAT_32, DataKind.NORMAL, 3);
}
return rs.mElement_NORMAL_3;
}
public static Element ATTRIB_COLOR_U8_4(RenderScript rs) {
if(rs.mElement_COLOR_U8_4 == null) {
rs.mElement_COLOR_U8_4 = createAttrib(rs, DataType.UNSIGNED_8, DataKind.COLOR, 4);
}
return rs.mElement_COLOR_U8_4;
}
public static Element ATTRIB_COLOR_F32_4(RenderScript rs) {
if(rs.mElement_COLOR_F32_4 == null) {
rs.mElement_COLOR_F32_4 = createAttrib(rs, DataType.FLOAT_32, DataKind.COLOR, 4);
}
return rs.mElement_COLOR_F32_4;
}
Element(RenderScript rs, Element[] e, String[] n) {
super(rs);
mSize = 0;
mEntries = new Entry[count];
mElements = e;
mElementNames = n;
int[] ids = new int[mElements.length];
for (int ct = 0; ct < mElements.length; ct++ ) {
mSize += mElements[ct].mSize;
ids[ct] = mElements[ct].mID;
}
mID = rs.nElementCreate2(ids, mElementNames);
}
Element(RenderScript rs, DataType dt, DataKind dk, boolean norm, int size) {
super(rs);
mSize = dt.mSize * size;
mType = dt;
mKind = dk;
mNormalized = norm;
mVectorSize = size;
mID = rs.nElementCreate(dt.mID, dk.mID, norm, size);
}
public void destroy() throws IllegalStateException {
@@ -291,13 +252,13 @@ public class Element extends BaseObj {
for(Field f: fields) {
Class fc = f.getType();
if(fc == int.class) {
b.add(Element.DataType.SIGNED, Element.DataKind.USER, false, 32, f.getName());
b.add(createUser(rs, DataType.SIGNED_32), f.getName());
} else if(fc == short.class) {
b.add(Element.DataType.SIGNED, Element.DataKind.USER, false, 16, f.getName());
b.add(createUser(rs, DataType.SIGNED_16), f.getName());
} else if(fc == byte.class) {
b.add(Element.DataType.SIGNED, Element.DataKind.USER, false, 8, f.getName());
b.add(createUser(rs, DataType.SIGNED_8), f.getName());
} else if(fc == float.class) {
b.add(Element.DataType.FLOAT, Element.DataKind.USER, false, 32, f.getName());
b.add(createUser(rs, DataType.FLOAT_32), f.getName());
} else {
throw new IllegalArgumentException("Unkown field type");
}
@@ -305,193 +266,161 @@ public class Element extends BaseObj {
return b.create();
}
static synchronized void internalCreate(RenderScript rs, Element e) {
rs.nElementBegin();
int bits = 0;
for (int ct=0; ct < e.mEntries.length; ct++) {
Entry en = e.mEntries[ct];
//if(en.mElement != null) {
//rs.nElementAdd(en.mElement.mID);
//} else
{
rs.nElementAdd(en.mKind.mID, en.mType.mID, en.mIsNormalized, en.mBits, en.mName);
bits += en.mBits;
}
/////////////////////////////////////////
public static Element createUser(RenderScript rs, DataType dt) {
//android.util.Log.e("rs", "createUser " + dt.mID);
return new Element(rs, dt, DataKind.USER, false, 1);
}
public static Element createVector(RenderScript rs, DataType dt, int size) {
//android.util.Log.e("rs", "createVector " + dt.mID + ", " + size);
if (size < 2 || size > 4) {
throw new IllegalArgumentException("Bad size");
}
e.mID = rs.nElementCreate();
e.mSize = (bits + 7) >> 3;
return new Element(rs, dt, DataKind.USER, false, size);
}
void init() {
mRS.validate();
internalCreate(mRS, this);
public static Element createIndex(RenderScript rs) {
android.util.Log.e("rs", "createIndex ");
return new Element(rs, DataType.UNSIGNED_16, DataKind.INDEX, false, 1);
}
public static Element createAttrib(RenderScript rs, DataType dt, DataKind dk, int size) {
android.util.Log.e("rs", "createAttrib " + dt.mID + ", " + dk.mID + ", " + size);
if (!(dt == DataType.FLOAT_32 ||
dt == DataType.UNSIGNED_8 ||
dt == DataType.UNSIGNED_16 ||
dt == DataType.UNSIGNED_32 ||
dt == DataType.SIGNED_8 ||
dt == DataType.SIGNED_16 ||
dt == DataType.SIGNED_32)) {
throw new IllegalArgumentException("Unsupported DataType");
}
if (!(dk == DataKind.COLOR ||
dk == DataKind.POSITION ||
dk == DataKind.TEXTURE ||
dk == DataKind.NORMAL ||
dk == DataKind.POINT_SIZE)) {
throw new IllegalArgumentException("Unsupported DataKind");
}
if (dk == DataKind.COLOR &&
((dt != DataType.FLOAT_32 && dt != DataType.UNSIGNED_8) ||
size < 3 || size > 4)) {
throw new IllegalArgumentException("Bad combo");
}
if (dk == DataKind.POSITION && (size < 1 || size > 4)) {
throw new IllegalArgumentException("Bad combo");
}
if (dk == DataKind.TEXTURE &&
(dt != DataType.FLOAT_32 || size < 1 || size > 4)) {
throw new IllegalArgumentException("Bad combo");
}
if (dk == DataKind.NORMAL &&
(dt != DataType.FLOAT_32 || size != 3)) {
throw new IllegalArgumentException("Bad combo");
}
if (dk == DataKind.POINT_SIZE &&
(dt != DataType.FLOAT_32 || size != 1)) {
throw new IllegalArgumentException("Bad combo");
}
boolean norm = false;
if (dk == DataKind.COLOR && dt == DataType.UNSIGNED_8) {
norm = true;
}
return new Element(rs, dt, dk, norm, size);
}
public static Element createPixel(RenderScript rs, DataType dt, DataKind dk) {
android.util.Log.e("rs", "createPixel " + dt.mID + ", " + dk.mID);
if (!(dk == DataKind.PIXEL_L ||
dk == DataKind.PIXEL_A ||
dk == DataKind.PIXEL_LA ||
dk == DataKind.PIXEL_RGB ||
dk == DataKind.PIXEL_RGBA)) {
throw new IllegalArgumentException("Unsupported DataKind");
}
if (!(dt == DataType.UNSIGNED_8 ||
dt == DataType.UNSIGNED_5_6_5 ||
dt == DataType.UNSIGNED_4_4_4_4 ||
dt == DataType.UNSIGNED_5_5_5_1)) {
throw new IllegalArgumentException("Unsupported DataType");
}
if (dt == DataType.UNSIGNED_5_6_5 && dk != DataKind.PIXEL_RGB) {
throw new IllegalArgumentException("Bad kind and type combo");
}
if (dt == DataType.UNSIGNED_5_5_5_1 && dk != DataKind.PIXEL_RGBA) {
throw new IllegalArgumentException("Bad kind and type combo");
}
if (dt == DataType.UNSIGNED_4_4_4_4 && dk != DataKind.PIXEL_RGBA) {
throw new IllegalArgumentException("Bad kind and type combo");
}
int size = 1;
if (dk == DataKind.PIXEL_LA) {
size = 2;
}
if (dk == DataKind.PIXEL_RGB) {
size = 3;
}
if (dk == DataKind.PIXEL_RGBA) {
size = 4;
}
return new Element(rs, dt, dk, true, size);
}
public static class Builder {
RenderScript mRS;
Entry[] mEntries;
int mEntryCount;
Element[] mElements;
String[] mElementNames;
int mCount;
public Builder(RenderScript rs) {
mRS = rs;
mEntryCount = 0;
mEntries = new Entry[8];
mCount = 0;
mElements = new Element[8];
mElementNames = new String[8];
}
void addEntry(Entry e) {
if(mEntries.length >= mEntryCount) {
Entry[] en = new Entry[mEntryCount + 8];
System.arraycopy(mEntries, 0, en, 0, mEntries.length);
mEntries = en;
public void add(Element element, String name) {
if(mCount == mElements.length) {
Element[] e = new Element[mCount + 8];
String[] s = new String[mCount + 8];
System.arraycopy(mElements, 0, e, 0, mCount);
System.arraycopy(mElementNames, 0, s, 0, mCount);
mElements = e;
mElementNames = s;
}
mEntries[mEntryCount] = e;
mEntryCount++;
}
//public Builder add(Element e) throws IllegalArgumentException {
//Entry en = new Entry(e, e.mSize * 8);
//addEntry(en);
//return this;
//}
public Builder add(Element.DataType dt, Element.DataKind dk, boolean isNormalized, int bits, String name) {
Entry en = new Entry(dt, dk, isNormalized, bits, name);
addEntry(en);
return this;
}
public Builder add(Element.DataType dt, Element.DataKind dk, boolean isNormalized, int bits) {
add(dt, dk, isNormalized, bits, null);
return this;
}
public Builder addFloat(Element.DataKind dk) {
add(DataType.FLOAT, dk, false, 32, null);
return this;
}
public Builder addFloat(Element.DataKind dk, String name) {
add(DataType.FLOAT, dk, false, 32, name);
return this;
}
public Builder addFloatXY() {
add(DataType.FLOAT, DataKind.X, false, 32, null);
add(DataType.FLOAT, DataKind.Y, false, 32, null);
return this;
}
public Builder addFloatXY(String prefix) {
add(DataType.FLOAT, DataKind.X, false, 32, prefix + "x");
add(DataType.FLOAT, DataKind.Y, false, 32, prefix + "y");
return this;
}
public Builder addFloatXYZ() {
add(DataType.FLOAT, DataKind.X, false, 32, null);
add(DataType.FLOAT, DataKind.Y, false, 32, null);
add(DataType.FLOAT, DataKind.Z, false, 32, null);
return this;
}
public Builder addFloatXYZ(String prefix) {
add(DataType.FLOAT, DataKind.X, false, 32, prefix + "x");
add(DataType.FLOAT, DataKind.Y, false, 32, prefix + "y");
add(DataType.FLOAT, DataKind.Z, false, 32, prefix + "z");
return this;
}
public Builder addFloatST() {
add(DataType.FLOAT, DataKind.S, false, 32, null);
add(DataType.FLOAT, DataKind.T, false, 32, null);
return this;
}
public Builder addFloatST(String prefix) {
add(DataType.FLOAT, DataKind.S, false, 32, prefix + "s");
add(DataType.FLOAT, DataKind.T, false, 32, prefix + "t");
return this;
}
public Builder addFloatNorm() {
add(DataType.FLOAT, DataKind.NX, false, 32, null);
add(DataType.FLOAT, DataKind.NY, false, 32, null);
add(DataType.FLOAT, DataKind.NZ, false, 32, null);
return this;
}
public Builder addFloatNorm(String prefix) {
add(DataType.FLOAT, DataKind.NX, false, 32, prefix + "nx");
add(DataType.FLOAT, DataKind.NY, false, 32, prefix + "ny");
add(DataType.FLOAT, DataKind.NZ, false, 32, prefix + "nz");
return this;
}
public Builder addFloatPointSize() {
add(DataType.FLOAT, DataKind.POINT_SIZE, false, 32, null);
return this;
}
public Builder addFloatPointSize(String prefix) {
add(DataType.FLOAT, DataKind.POINT_SIZE, false, 32, prefix + "pointSize");
return this;
}
public Builder addFloatRGB() {
add(DataType.FLOAT, DataKind.RED, false, 32, null);
add(DataType.FLOAT, DataKind.GREEN, false, 32, null);
add(DataType.FLOAT, DataKind.BLUE, false, 32, null);
return this;
}
public Builder addFloatRGB(String prefix) {
add(DataType.FLOAT, DataKind.RED, false, 32, prefix + "r");
add(DataType.FLOAT, DataKind.GREEN, false, 32, prefix + "g");
add(DataType.FLOAT, DataKind.BLUE, false, 32, prefix + "b");
return this;
}
public Builder addFloatRGBA() {
add(DataType.FLOAT, DataKind.RED, false, 32, null);
add(DataType.FLOAT, DataKind.GREEN, false, 32, null);
add(DataType.FLOAT, DataKind.BLUE, false, 32, null);
add(DataType.FLOAT, DataKind.ALPHA, false, 32, null);
return this;
}
public Builder addFloatRGBA(String prefix) {
add(DataType.FLOAT, DataKind.RED, false, 32, prefix + "r");
add(DataType.FLOAT, DataKind.GREEN, false, 32, prefix + "g");
add(DataType.FLOAT, DataKind.BLUE, false, 32, prefix + "b");
add(DataType.FLOAT, DataKind.ALPHA, false, 32, prefix + "a");
return this;
}
public Builder addUNorm8RGBA() {
add(DataType.UNSIGNED, DataKind.RED, true, 8, null);
add(DataType.UNSIGNED, DataKind.GREEN, true, 8, null);
add(DataType.UNSIGNED, DataKind.BLUE, true, 8, null);
add(DataType.UNSIGNED, DataKind.ALPHA, true, 8, null);
return this;
}
public Builder addUNorm8RGBA(String prefix) {
add(DataType.UNSIGNED, DataKind.RED, true, 8, prefix + "r");
add(DataType.UNSIGNED, DataKind.GREEN, true, 8, prefix + "g");
add(DataType.UNSIGNED, DataKind.BLUE, true, 8, prefix + "b");
add(DataType.UNSIGNED, DataKind.ALPHA, true, 8, prefix + "a");
return this;
mElements[mCount] = element;
mElementNames[mCount] = name;
mCount++;
}
public Element create() {
mRS.validate();
Element e = new Element(mRS, mEntryCount);
java.lang.System.arraycopy(mEntries, 0, e.mEntries, 0, mEntryCount);
e.init();
return e;
Element[] ein = new Element[mCount];
String[] sin = new String[mCount];
java.lang.System.arraycopy(mElements, 0, ein, 0, mCount);
java.lang.System.arraycopy(mElementNames, 0, sin, 0, mCount);
return new Element(mRS, ein, sin);
}
}
static void initPredefined(RenderScript rs) {
int a8 = rs.nElementCreate(DataType.UNSIGNED_8.mID,
DataKind.PIXEL_A.mID, true, 1);
int rgba4444 = rs.nElementCreate(DataType.UNSIGNED_4_4_4_4.mID,
DataKind.PIXEL_RGBA.mID, true, 4);
int rgba8888 = rs.nElementCreate(DataType.UNSIGNED_8.mID,
DataKind.PIXEL_RGBA.mID, true, 4);
int rgb565 = rs.nElementCreate(DataType.UNSIGNED_5_6_5.mID,
DataKind.PIXEL_RGB.mID, true, 3);
rs.nInitElements(a8, rgba4444, rgba8888, rgb565);
}
}

2
graphics/java/android/renderscript/ProgramVertex.java
View File

@@ -107,7 +107,7 @@ public class ProgramVertex extends Program {
mProjection = new Matrix();
mTexture = new Matrix();
mAlloc = Allocation.createSized(rs, Element.USER_F32(rs), 48);
mAlloc = Allocation.createSized(rs, Element.createUser(rs, Element.DataType.FLOAT_32), 48);
mAlloc.subData1D(MODELVIEW_OFFSET, 16, mModel.mMat);
mAlloc.subData1D(PROJECTION_OFFSET, 16, mProjection.mMat);
mAlloc.subData1D(TEXTURE_OFFSET, 16, mTexture.mMat);

20
graphics/java/android/renderscript/RenderScript.java
View File

@@ -89,9 +89,9 @@ public class RenderScript {
native void nObjDestroyOOB(int id);
native int nFileOpen(byte[] name);
native void nElementBegin();
native void nElementAdd(int kind, int type, boolean norm, int bits, String s);
native int nElementCreate();
native int nElementCreate(int type, int kind, boolean norm, int vecSize);
native int nElementCreate2(int[] elements, String[] names);
native void nTypeBegin(int elementID);
native void nTypeAdd(int dim, int val);
@@ -198,14 +198,13 @@ public class RenderScript {
private Surface mSurface;
private MessageThread mMessageThread;
Element mElement_USER_U8;
Element mElement_USER_I8;
Element mElement_USER_U16;
Element mElement_USER_I16;
Element mElement_USER_U32;
Element mElement_USER_I32;
Element mElement_USER_FLOAT;
Element mElement_USER_F32;
Element mElement_A_8;
Element mElement_RGB_565;
@@ -215,9 +214,12 @@ public class RenderScript {
Element mElement_RGBA_8888;
Element mElement_INDEX_16;
Element mElement_XY_F32;
Element mElement_XYZ_F32;
Element mElement_POSITION_2;
Element mElement_POSITION_3;
Element mElement_TEXTURE_2;
Element mElement_NORMAL_3;
Element mElement_COLOR_U8_4;
Element mElement_COLOR_F32_4;
///////////////////////////////////////////////////////////////////////////////////
//
@@ -303,9 +305,9 @@ public class RenderScript {
nDeviceSetConfig(mDev, 0, 1);
}
mContext = nContextCreate(mDev, 0, useDepth);
Element.initPredefined(this);
mMessageThread = new MessageThread(this);
mMessageThread.start();
Element.initPredefined(this);
}
public void contextSetSurface(int w, int h, Surface sur) {

28
graphics/java/android/renderscript/SimpleMesh.java
View File

@@ -313,28 +313,38 @@ public class SimpleMesh extends BaseObj {
public SimpleMesh create() {
Element.Builder b = new Element.Builder(mRS);
int floatCount = mVtxSize;
if (mVtxSize == 2) {
b.addFloatXY();
} else {
b.addFloatXYZ();
}
b.add(Element.createAttrib(mRS,
Element.DataType.FLOAT_32,
Element.DataKind.POSITION,
mVtxSize), "position");
if ((mFlags & COLOR) != 0) {
floatCount += 4;
b.addFloatRGBA();
b.add(Element.createAttrib(mRS,
Element.DataType.FLOAT_32,
Element.DataKind.COLOR,
4), "color");
}
if ((mFlags & TEXTURE_0) != 0) {
floatCount += 2;
b.addFloatST();
b.add(Element.createAttrib(mRS,
Element.DataType.FLOAT_32,
Element.DataKind.TEXTURE,
2), "texture");
}
if ((mFlags & NORMAL) != 0) {
floatCount += 3;
b.addFloatNorm();
b.add(Element.createAttrib(mRS,
Element.DataType.FLOAT_32,
Element.DataKind.NORMAL,
3), "normal");
}
mElement = b.create();
android.util.Log.e("rs", "sm create size=" + (mVtxCount / floatCount) + ", count=" + mVtxCount);
Builder smb = new Builder(mRS);
smb.addVertexType(mElement, mVtxCount / floatCount);
smb.setIndexType(Element.INDEX_16(mRS), mIndexCount);
smb.setIndexType(Element.createIndex(mRS), mIndexCount);
smb.setPrimitive(Primitive.TRIANGLE);
SimpleMesh sm = smb.create();

8
graphics/java/android/renderscript/Type.java
View File

@@ -122,16 +122,16 @@ public class Type extends BaseObj {
Field f = fields[ct];
Class fc = f.getType();
if(fc == int.class) {
arTypes[ct] = Element.DataType.SIGNED.mID;
arTypes[ct] = Element.DataType.SIGNED_32.mID;
arBits[ct] = 32;
} else if(fc == short.class) {
arTypes[ct] = Element.DataType.SIGNED.mID;
arTypes[ct] = Element.DataType.SIGNED_16.mID;
arBits[ct] = 16;
} else if(fc == byte.class) {
arTypes[ct] = Element.DataType.SIGNED.mID;
arTypes[ct] = Element.DataType.SIGNED_8.mID;
arBits[ct] = 8;
} else if(fc == float.class) {
arTypes[ct] = Element.DataType.FLOAT.mID;
arTypes[ct] = Element.DataType.FLOAT_32.mID;
arBits[ct] = 32;
} else {
throw new IllegalArgumentException("Unkown field type");

86
graphics/jni/android_renderscript_RenderScript.cpp
View File

@@ -247,36 +247,39 @@ static void nContextDeinitToClient(JNIEnv *_env, jobject _this)
}
static void
nElementBegin(JNIEnv *_env, jobject _this)
static jint
nElementCreate(JNIEnv *_env, jobject _this, jint type, jint kind, jboolean norm, jint size)
{
RsContext con = (RsContext)(_env->GetIntField(_this, gContextId));
LOG_API("nElementBegin, con(%p)", con);
rsElementBegin(con);
}
static void
nElementAdd(JNIEnv *_env, jobject _this, jint kind, jint type, jboolean norm, jint bits, jstring name)
{
RsContext con = (RsContext)(_env->GetIntField(_this, gContextId));
const char* n = NULL;
if (name) {
n = _env->GetStringUTFChars(name, NULL);
}
LOG_API("nElementAdd, con(%p), kind(%i), type(%i), norm(%i), bits(%i)", con, kind, type, norm, bits);
rsElementAdd(con, (RsDataKind)kind, (RsDataType)type, norm != 0, (size_t)bits, n);
if (n) {
_env->ReleaseStringUTFChars(name, n);
}
LOG_API("nElementCreate, con(%p), type(%i), kind(%i), norm(%i), size(%i)", con, type, kind, norm, size);
return (jint)rsElementCreate(con, (RsDataType)type, (RsDataKind)kind, norm, size);
}
static jint
nElementCreate(JNIEnv *_env, jobject _this)
nElementCreate2(JNIEnv *_env, jobject _this, jintArray _ids, jobjectArray _names)
{
int fieldCount = _env->GetArrayLength(_ids);
RsContext con = (RsContext)(_env->GetIntField(_this, gContextId));
LOG_API("nElementCreate, con(%p)", con);
return (jint)rsElementCreate(con);
LOG_API("nElementCreate, con(%p), type(%i), kind(%i), norm(%i), size(%i)", con, type, kind, norm, size);
jint *ids = _env->GetIntArrayElements(_ids, NULL);
const char ** nameArray = (const char **)calloc(fieldCount, sizeof(char *));
size_t* sizeArray = (size_t*)calloc(fieldCount, sizeof(size_t));
for (int ct=0; ct < fieldCount; ct++) {
jstring s = (jstring)_env->GetObjectArrayElement(_names, ct);
nameArray[ct] = _env->GetStringUTFChars(s, NULL);
sizeArray[ct] = _env->GetStringUTFLength(s);
}
jint id = (jint)rsElementCreate2(con, fieldCount, (RsElement *)ids, nameArray, sizeArray);
for (int ct=0; ct < fieldCount; ct++) {
jstring s = (jstring)_env->GetObjectArrayElement(_names, ct);
_env->ReleaseStringUTFChars(s, nameArray[ct]);
}
_env->ReleaseIntArrayElements(_ids, ids, JNI_ABORT);
free(nameArray);
free(sizeArray);
return (jint)id;
}
// -----------------------------------
@@ -395,26 +398,24 @@ nTypeSetupFields(JNIEnv *_env, jobject _this, jobject _type, jintArray _types, j
tfc[ct].bits = fBits[ct];
switch(fType[ct]) {
case RS_TYPE_FLOAT:
case RS_TYPE_FLOAT_32:
tfc[ct].ptr = SF_LoadFloat;
tfc[ct].readPtr = SF_SaveFloat;
break;
case RS_TYPE_UNSIGNED:
case RS_TYPE_SIGNED:
switch(tfc[ct].bits) {
case 32:
tfc[ct].ptr = SF_LoadInt;
tfc[ct].readPtr = SF_SaveInt;
break;
case 16:
tfc[ct].ptr = SF_LoadShort;
tfc[ct].readPtr = SF_SaveShort;
break;
case 8:
tfc[ct].ptr = SF_LoadByte;
tfc[ct].readPtr = SF_SaveByte;
break;
}
case RS_TYPE_UNSIGNED_32:
case RS_TYPE_SIGNED_32:
tfc[ct].ptr = SF_LoadInt;
tfc[ct].readPtr = SF_SaveInt;
break;
case RS_TYPE_UNSIGNED_16:
case RS_TYPE_SIGNED_16:
tfc[ct].ptr = SF_LoadShort;
tfc[ct].readPtr = SF_SaveShort;
break;
case RS_TYPE_UNSIGNED_8:
case RS_TYPE_SIGNED_8:
tfc[ct].ptr = SF_LoadByte;
tfc[ct].readPtr = SF_SaveByte;
break;
}
tc->size += 4;
@@ -1367,9 +1368,8 @@ static JNINativeMethod methods[] = {
{"nFileOpen", "([B)I", (void*)nFileOpen },
{"nElementBegin", "()V", (void*)nElementBegin },
{"nElementAdd", "(IIZILjava/lang/String;)V", (void*)nElementAdd },
{"nElementCreate", "()I", (void*)nElementCreate },
{"nElementCreate", "(IIZI)I", (void*)nElementCreate },
{"nElementCreate2", "([I[Ljava/lang/String;)I", (void*)nElementCreate2 },
{"nTypeBegin", "(I)V", (void*)nTypeBegin },
{"nTypeAdd", "(II)V", (void*)nTypeAdd },

1
libs/rs/Android.mk
View File

@@ -76,6 +76,7 @@ ifneq ($(TARGET_SIMULATOR),true)
LOCAL_SRC_FILES:= \
rsAdapter.cpp \
rsAllocation.cpp \
rsComponent.cpp \
rsContext.cpp \
rsDevice.cpp \
rsElement.cpp \

60
libs/rs/RenderScript.h
View File

@@ -66,32 +66,50 @@ void rsContextDeinitToClient(RsContext);
#define RS_MAX_TEXTURE 2
enum RsDataType {
RS_TYPE_FLOAT,
RS_TYPE_UNSIGNED,
RS_TYPE_SIGNED
RS_TYPE_NONE,
RS_TYPE_FLOAT_16,
RS_TYPE_FLOAT_32,
RS_TYPE_FLOAT_64,
RS_TYPE_SIGNED_8,
RS_TYPE_SIGNED_16,
RS_TYPE_SIGNED_32,
RS_TYPE_SIGNED_64,
RS_TYPE_UNSIGNED_8,
RS_TYPE_UNSIGNED_16,
RS_TYPE_UNSIGNED_32,
RS_TYPE_UNSIGNED_64,
RS_TYPE_UNSIGNED_5_6_5,
RS_TYPE_UNSIGNED_5_5_5_1,
RS_TYPE_UNSIGNED_4_4_4_4,
RS_TYPE_ELEMENT,
RS_TYPE_TYPE,
RS_TYPE_ALLOCATION,
RS_TYPE_SAMPLER,
RS_TYPE_SCRIPT,
RS_TYPE_MESH,
RS_TYPE_PROGRAM_FRAGMENT,
RS_TYPE_PROGRAM_VERTEX,
RS_TYPE_PROGRAM_RASTER,
RS_TYPE_PROGRAM_STORE
};
enum RsDataKind {
RS_KIND_USER,
RS_KIND_RED,
RS_KIND_GREEN,
RS_KIND_BLUE,
RS_KIND_ALPHA,
RS_KIND_LUMINANCE,
RS_KIND_INTENSITY,
RS_KIND_X,
RS_KIND_Y,
RS_KIND_Z,
RS_KIND_W,
RS_KIND_S,
RS_KIND_T,
RS_KIND_Q,
RS_KIND_R,
RS_KIND_NX,
RS_KIND_NY,
RS_KIND_NZ,
RS_KIND_COLOR,
RS_KIND_POSITION,
RS_KIND_TEXTURE,
RS_KIND_NORMAL,
RS_KIND_INDEX,
RS_KIND_POINT_SIZE
RS_KIND_POINT_SIZE,
RS_KIND_PIXEL_L,
RS_KIND_PIXEL_A,
RS_KIND_PIXEL_LA,
RS_KIND_PIXEL_RGB,
RS_KIND_PIXEL_RGBA,
};
enum RsSamplerParam {

14
libs/rs/java/Film/src/com/android/film/FilmRS.java
View File

@@ -152,10 +152,13 @@ public class FilmRS {
mBufferIDs = new int[13];
mImages = new Allocation[13];
mAllocIDs = Allocation.createSized(mRS,
Element.USER_F32(mRS), mBufferIDs.length);
Element.createUser(mRS, Element.DataType.FLOAT_32),
mBufferIDs.length);
Element ie = Element.RGB_565(mRS);
Element ie = Element.createPixel(mRS, Element.DataType.UNSIGNED_5_6_5, Element.DataKind.PIXEL_RGB);
android.util.Log.e("rs", "load 1");
mImages[0] = Allocation.createFromBitmapResourceBoxed(mRS, mRes, R.drawable.p01, ie, true);
android.util.Log.e("rs", "load 2");
mImages[1] = Allocation.createFromBitmapResourceBoxed(mRS, mRes, R.drawable.p02, ie, true);
mImages[2] = Allocation.createFromBitmapResourceBoxed(mRS, mRes, R.drawable.p03, ie, true);
mImages[3] = Allocation.createFromBitmapResourceBoxed(mRS, mRes, R.drawable.p04, ie, true);
@@ -195,7 +198,8 @@ public class FilmRS {
{
mBufferState = new int[10];
mAllocState = Allocation.createSized(mRS,
Element.USER_F32(mRS), mBufferState.length);
Element.createUser(mRS, Element.DataType.FLOAT_32),
mBufferState.length);
mBufferState[STATE_LAST_FOCUS] = -1;
mAllocState.data(mBufferState);
}
@@ -238,12 +242,12 @@ public class FilmRS {
mAllocOffsets = Allocation.createSized(mRS,
Element.USER_I32(mRS), mFSM.mTriangleOffsets.length);
Element.createUser(mRS, Element.DataType.SIGNED_32), mFSM.mTriangleOffsets.length);
mAllocOffsets.data(mFSM.mTriangleOffsets);
mScriptStrip.bindAllocation(mAllocOffsets, 4);
mAllocOffsetsTex = Allocation.createSized(mRS,
Element.USER_F32(mRS), mFSM.mTriangleOffsetsTex.length);
Element.createUser(mRS, Element.DataType.FLOAT_32), mFSM.mTriangleOffsetsTex.length);
mAllocOffsetsTex.data(mFSM.mTriangleOffsetsTex);
mScriptStrip.bindAllocation(mAllocOffsetsTex, 5);

28
libs/rs/java/Fountain/res/raw/fountain.c
View File

@@ -14,19 +14,17 @@ int main(int launchID) {
float rMax = ((float)rate) * 0.005f;
int x = Control->x;
int y = Control->y;
char r = Control->r * 255.f;
char g = Control->g * 255.f;
char b = Control->b * 255.f;
int color = ((int)(Control->r * 255.f)) |
((int)(Control->g * 255.f)) << 8 |
((int)(Control->b * 255.f)) << 16 |
(0xf0 << 24);
struct point_s * np = &p[newPart];
while (rate--) {
vec2Rand((float *)np, rMax);
np->x = x;
np->y = y;
np->r = r;
np->g = g;
np->b = b;
np->a = 0xf0;
vec2Rand((float *)&np->delta.x, rMax);
np->position.x = x;
np->position.y = y;
np->color = color;
newPart++;
np++;
if (newPart >= count) {
@@ -37,14 +35,14 @@ int main(int launchID) {
}
for (ct=0; ct < count; ct++) {
float dy = p->dy + 0.15f;
float posy = p->y + dy;
float dy = p->delta.y + 0.15f;
float posy = p->position.y + dy;
if ((posy > height) && (dy > 0)) {
dy *= -0.3f;
}
p->dy = dy;
p->x += p->dx;
p->y = posy;
p->delta.y = dy;
p->position.x += p->delta.x;
p->position.y = posy;
p++;
}

7
libs/rs/java/Fountain/src/com/android/fountain/FountainRS.java
View File

@@ -79,10 +79,9 @@ public class FountainRS {
mIntAlloc.data(mSD);
Element.Builder eb = new Element.Builder(mRS);
eb.addFloat(Element.DataKind.USER, "dx");
eb.addFloat(Element.DataKind.USER, "dy");
eb.addFloatXY("");
eb.addUNorm8RGBA("");
eb.add(Element.createVector(mRS, Element.DataType.FLOAT_32, 2), "delta");
eb.add(Element.createAttrib(mRS, Element.DataType.FLOAT_32, Element.DataKind.POSITION, 2), "position");
eb.add(Element.createAttrib(mRS, Element.DataType.UNSIGNED_8, Element.DataKind.COLOR, 4), "color");
Element primElement = eb.create();

14
libs/rs/java/ImageProcessing/src/com/android/rs/image/ImageProcessingActivity.java
View File

@@ -62,7 +62,7 @@ public class ImageProcessingActivity extends Activity implements SurfaceHolder.C
public float threshold;
}
static class Pixel {
public byte a;
public byte r;
@@ -78,7 +78,7 @@ public class ImageProcessingActivity extends Activity implements SurfaceHolder.C
mParams.outWidth, mParams.outHeight);
mDisplayView.invalidate();
}
};
};
@Override
public void run() {
@@ -131,7 +131,7 @@ public class ImageProcessingActivity extends Activity implements SurfaceHolder.C
public void surfaceDestroyed(SurfaceHolder holder) {
}
private Script.Invokable createScript() {
mRS = new RenderScript(false, false);
mRS.mMessageCallback = new FilterCallback();
@@ -143,9 +143,11 @@ public class ImageProcessingActivity extends Activity implements SurfaceHolder.C
final int pixelCount = mParams.inWidth * mParams.inHeight;
mPixelType = Type.createFromClass(mRS, Pixel.class, 1, "Pixel");
mInPixelsAllocation = Allocation.createSized(mRS, Element.USER_I32(mRS),
mInPixelsAllocation = Allocation.createSized(mRS,
Element.createUser(mRS, Element.DataType.SIGNED_32),
pixelCount);
mOutPixelsAllocation = Allocation.createSized(mRS, Element.USER_I32(mRS),
mOutPixelsAllocation = Allocation.createSized(mRS,
Element.createUser(mRS, Element.DataType.SIGNED_32),
pixelCount);
final int[] data = new int[pixelCount];
@@ -154,7 +156,7 @@ public class ImageProcessingActivity extends Activity implements SurfaceHolder.C
mOutData = new int[pixelCount];
mOutPixelsAllocation.data(mOutData);
ScriptC.Builder sb = new ScriptC.Builder(mRS);
sb.setType(mParamsType, "Params", 0);
sb.setType(mPixelType, "InPixel", 1);

21
libs/rs/rs.spec
View File

@@ -60,18 +60,19 @@ ObjDestroy {
param void *obj
}
ElementBegin {
}
ElementAdd {
param RsDataKind dataKind
param RsDataType dataType
param bool isNormalized
param size_t bits
param const char * name
ElementCreate {
param RsDataType mType
param RsDataKind mKind
param bool mNormalized
param uint32_t mVectorSize
ret RsElement
}
ElementCreate {
ElementCreate2 {
param size_t count
param const RsElement * elements
param const char ** names
param const size_t * nameLengths
ret RsElement
}

12
libs/rs/rsAllocation.cpp
View File

@@ -106,8 +106,8 @@ void Allocation::uploadToTexture(const Context *rsc)
return;
}
GLenum type = mType->getElement()->getGLType();
GLenum format = mType->getElement()->getGLFormat();
GLenum type = mType->getElement()->getComponent().getGLType();
GLenum format = mType->getElement()->getComponent().getGLFormat();
if (!type || !format) {
return;
@@ -422,10 +422,10 @@ static void elementConverter_8888_to_565(void *dst, const void *src, uint32_t co
static ElementConverter_t pickConverter(const Element *dst, const Element *src)
{
GLenum srcGLType = src->getGLType();
GLenum srcGLFmt = src->getGLFormat();
GLenum dstGLType = dst->getGLType();
GLenum dstGLFmt = dst->getGLFormat();
GLenum srcGLType = src->getComponent().getGLType();
GLenum srcGLFmt = src->getComponent().getGLFormat();
GLenum dstGLType = dst->getComponent().getGLType();
GLenum dstGLFmt = dst->getComponent().getGLFormat();
if (srcGLFmt == dstGLFmt && srcGLType == dstGLType) {
switch(dst->getSizeBytes()) {

316
libs/rs/rsComponent.cpp Normal file
View File

@@ -0,0 +1,316 @@
/*
* Copyright (C) 2009 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "rsComponent.h"
#include <GLES/gl.h>
using namespace android;
using namespace android::renderscript;
Component::Component()
{
set(RS_TYPE_NONE, RS_KIND_USER, false, 1);
}
Component::~Component()
{
}
void Component::set(RsDataType dt, RsDataKind dk, bool norm, uint32_t vecSize)
{
mType = dt;
mKind = dk;
mNormalized = norm;
mVectorSize = vecSize;
rsAssert(vecSize <= 4);
mBits = 0;
mTypeBits = 0;
mIsFloat = false;
mIsSigned = false;
mIsPixel = false;
switch(mKind) {
case RS_KIND_PIXEL_L:
case RS_KIND_PIXEL_A:
mIsPixel = true;
rsAssert(mVectorSize == 1);
rsAssert(mNormalized == true);
break;
case RS_KIND_PIXEL_LA:
mIsPixel = true;
rsAssert(mVectorSize == 2);
rsAssert(mNormalized == true);
break;
case RS_KIND_PIXEL_RGB:
mIsPixel = true;
rsAssert(mVectorSize == 3);
rsAssert(mNormalized == true);
break;
case RS_KIND_PIXEL_RGBA:
mIsPixel = true;
rsAssert(mVectorSize == 4);
rsAssert(mNormalized == true);
break;
default:
break;
}
switch(mType) {
case RS_TYPE_NONE:
return;
case RS_TYPE_UNSIGNED_5_6_5:
mVectorSize = 3;
mBits = 16;
mNormalized = true;
rsAssert(mKind == RS_KIND_PIXEL_RGB);
return;
case RS_TYPE_UNSIGNED_5_5_5_1:
mVectorSize = 4;
mBits = 16;
mNormalized = true;
rsAssert(mKind == RS_KIND_PIXEL_RGBA);
return;
case RS_TYPE_UNSIGNED_4_4_4_4:
mVectorSize = 4;
mBits = 16;
mNormalized = true;
rsAssert(mKind == RS_KIND_PIXEL_RGBA);
return;
case RS_TYPE_ELEMENT:
case RS_TYPE_TYPE:
case RS_TYPE_ALLOCATION:
case RS_TYPE_SAMPLER:
case RS_TYPE_SCRIPT:
case RS_TYPE_MESH:
case RS_TYPE_PROGRAM_FRAGMENT:
case RS_TYPE_PROGRAM_VERTEX:
case RS_TYPE_PROGRAM_RASTER:
case RS_TYPE_PROGRAM_STORE:
rsAssert(mVectorSize == 1);
rsAssert(mNormalized == false);
rsAssert(mKind == RS_KIND_USER);
mBits = 32;
mTypeBits = 32;
return;
case RS_TYPE_FLOAT_16:
mTypeBits = 16;
mIsFloat = true;
break;
case RS_TYPE_FLOAT_32:
mTypeBits = 32;
mIsFloat = true;
break;
case RS_TYPE_FLOAT_64:
mTypeBits = 64;
mIsFloat = true;
break;
case RS_TYPE_SIGNED_8:
mTypeBits = 8;
mIsSigned = true;
break;
case RS_TYPE_SIGNED_16:
mTypeBits = 16;
mIsSigned = true;
break;
case RS_TYPE_SIGNED_32:
mTypeBits = 32;
mIsSigned = true;
break;
case RS_TYPE_SIGNED_64:
mTypeBits = 64;
mIsSigned = true;
break;
case RS_TYPE_UNSIGNED_8:
mTypeBits = 8;
break;
case RS_TYPE_UNSIGNED_16:
mTypeBits = 16;
break;
case RS_TYPE_UNSIGNED_32:
mTypeBits = 32;
break;
case RS_TYPE_UNSIGNED_64:
mTypeBits = 64;
break;
}
mBits = mTypeBits * mVectorSize;
}
uint32_t Component::getGLType() const
{
switch (mType) {
case RS_TYPE_UNSIGNED_5_6_5: return GL_UNSIGNED_SHORT_5_6_5;
case RS_TYPE_UNSIGNED_5_5_5_1: return GL_UNSIGNED_SHORT_5_5_5_1;
case RS_TYPE_UNSIGNED_4_4_4_4: return GL_UNSIGNED_SHORT_4_4_4_4;
//case RS_TYPE_FLOAT_16: return GL_HALF_FLOAT;
case RS_TYPE_FLOAT_32: return GL_FLOAT;
case RS_TYPE_UNSIGNED_8: return GL_UNSIGNED_BYTE;
case RS_TYPE_UNSIGNED_16: return GL_UNSIGNED_SHORT;
case RS_TYPE_SIGNED_8: return GL_BYTE;
case RS_TYPE_SIGNED_16: return GL_SHORT;
default: break;
}
return 0;
}
uint32_t Component::getGLFormat() const
{
switch (mKind) {
case RS_KIND_PIXEL_L: return GL_LUMINANCE;
case RS_KIND_PIXEL_A: return GL_ALPHA;
case RS_KIND_PIXEL_LA: return GL_LUMINANCE_ALPHA;
case RS_KIND_PIXEL_RGB: return GL_RGB;
case RS_KIND_PIXEL_RGBA: return GL_RGBA;
default: break;
}
return 0;
}
static const char * gCTypeStrings[] = {
0,
0,//"F16",
"float",
"double",
"char",
"short",
"int",
0,//"S64",
"char",//U8",
"short",//U16",
"int",//U32",
0,//"U64",
0,//"UP_565",
0,//"UP_5551",
0,//"UP_4444",
0,//"ELEMENT",
0,//"TYPE",
0,//"ALLOCATION",
0,//"SAMPLER",
0,//"SCRIPT",
0,//"MESH",
0,//"PROGRAM_FRAGMENT",
0,//"PROGRAM_VERTEX",
0,//"PROGRAM_RASTER",
0,//"PROGRAM_STORE",
};
static const char * gCVecTypeStrings[] = {
0,
0,//"F16",
"vecF32",
"vecF64",
"vecI8",
"vecI16",
"vecI32",
0,//"S64",
"vecU8",//U8",
"vecU16",//U16",
"vecU32",//U32",
0,//"U64",
0,//"UP_565",
0,//"UP_5551",
0,//"UP_4444",
0,//"ELEMENT",
0,//"TYPE",
0,//"ALLOCATION",
0,//"SAMPLER",
0,//"SCRIPT",
0,//"MESH",
0,//"PROGRAM_FRAGMENT",
0,//"PROGRAM_VERTEX",
0,//"PROGRAM_RASTER",
0,//"PROGRAM_STORE",
};
String8 Component::getCType() const
{
char buf[64];
if (mVectorSize == 1) {
return String8(gCTypeStrings[mType]);
}
// Yuck, acc WAR
// Appears to have problems packing chars
if (mVectorSize == 4 && mType == RS_TYPE_UNSIGNED_8) {
return String8("int");
}
String8 s(gCVecTypeStrings[mType]);
sprintf(buf, "_%i_t", mVectorSize);
s.append(buf);
return s;
}
static const char * gTypeStrings[] = {
"NONE",
"F16",
"F32",
"F64",
"S8",
"S16",
"S32",
"S64",
"U8",
"U16",
"U32",
"U64",
"UP_565",
"UP_5551",
"UP_4444",
"ELEMENT",
"TYPE",
"ALLOCATION",
"SAMPLER",
"SCRIPT",
"MESH",
"PROGRAM_FRAGMENT",
"PROGRAM_VERTEX",
"PROGRAM_RASTER",
"PROGRAM_STORE",
};
static const char * gKindStrings[] = {
"USER",
"COLOR",
"POSITION",
"TEXTURE",
"NORMAL",
"INDEX",
"POINT_SIZE",
"PIXEL_L",
"PIXEL_A",
"PIXEL_LA",
"PIXEL_RGB",
"PIXEL_RGBA",
};
void Component::dumpLOGV(const char *prefix) const
{
LOGV("%s Component: %s, %s, vectorSize=%i, bits=%i",
prefix, gTypeStrings[mType], gKindStrings[mKind], mVectorSize, mBits);
}

68
libs/rs/rsComponent.h Normal file
View File

@@ -0,0 +1,68 @@
/*
* Copyright (C) 2009 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ANDROID_COMPONENT_H
#define ANDROID_COMPONENT_H
#include "rsUtils.h"
// ---------------------------------------------------------------------------
namespace android {
namespace renderscript {
// An element is a group of Components that occupies one cell in a structure.
class Component
{
public:
Component();
~Component();
void set(RsDataType dt, RsDataKind dk, bool norm, uint32_t vecSize=1);
uint32_t getGLType() const;
uint32_t getGLFormat() const;
String8 getCType() const;
void dumpLOGV(const char *prefix) const;
RsDataType getType() const {return mType;}
RsDataKind getKind() const {return mKind;}
bool getIsNormalized() const {return mNormalized;}
uint32_t getVectorSize() const {return mVectorSize;}
bool getIsFloat() const {return mIsFloat;}
bool getIsSigned() const {return mIsSigned;}
uint32_t getBits() const {return mBits;}
protected:
RsDataType mType;
RsDataKind mKind;
bool mNormalized;
uint32_t mVectorSize;
// derived
uint32_t mBits;
uint32_t mTypeBits;
bool mIsFloat;
bool mIsSigned;
bool mIsPixel;
};
}
}
#endif

17
libs/rs/rsContext.cpp
View File

@@ -142,6 +142,13 @@ uint32_t Context::runScript(Script *s, uint32_t launchID)
return ret;
}
void Context::checkError(const char *msg) const
{
GLenum err = glGetError();
if (err != GL_NO_ERROR) {
LOGE("GL Error, 0x%x, from %s", err, msg);
}
}
uint32_t Context::runRootScript()
{
@@ -169,11 +176,7 @@ uint32_t Context::runRootScript()
mStateFragmentStore.mLast.clear();
uint32_t ret = runScript(mRootScript.get(), 0);
GLenum err = glGetError();
if (err != GL_NO_ERROR) {
LOGE("Pending GL Error, 0x%x", err);
}
checkError("runRootScript");
return ret;
}
@@ -340,10 +343,6 @@ void * Context::threadProc(void *vrsc)
rsc->mObjDestroy.mNeedToEmpty = true;
rsc->objDestroyOOBRun();
glClearColor(0,0,0,0);
glClear(GL_COLOR_BUFFER_BIT);
eglSwapBuffers(rsc->mEGL.mDisplay, rsc->mEGL.mSurface);
pthread_mutex_lock(&gInitMutex);
rsc->deinitEGL();
pthread_mutex_unlock(&gInitMutex);

1
libs/rs/rsContext.h
View File

@@ -168,6 +168,7 @@ public:
} props;
void dumpDebug() const;
void checkError(const char *) const;
mutable const ObjectBase * mObjHead;

243
libs/rs/rsElement.cpp
View File

@@ -24,9 +24,6 @@ using namespace android::renderscript;
Element::Element(Context *rsc) : ObjectBase(rsc)
{
mType = RS_TYPE_FLOAT;
mIsNormalized = false;
mKind = RS_KIND_USER;
mBits = 0;
mAllocFile = __FILE__;
mAllocLine = __LINE__;
@@ -80,161 +77,6 @@ size_t Element::getFieldOffsetBits(uint32_t componentNumber) const
return offset;
}
uint32_t Element::getGLType() const
{
int bits[4];
if (!mFieldCount) {
switch (mType) {
case RS_TYPE_FLOAT:
if (mBits == 32) {
return GL_FLOAT;
}
return 0;
case RS_TYPE_SIGNED:
switch (mBits) {
case 8:
return GL_BYTE;
case 16:
return GL_SHORT;
//case 32:
//return GL_INT;
}
return 0;
case RS_TYPE_UNSIGNED:
switch (mBits) {
case 8:
return GL_UNSIGNED_BYTE;
case 16:
return GL_UNSIGNED_SHORT;
//case 32:
//return GL_UNSIGNED_INT;
}
return 0;
}
}
if (mFieldCount > 4) {
return 0;
}
for (uint32_t ct=0; ct < mFieldCount; ct++) {
bits[ct] = mFields[ct].e->mBits;
if (mFields[ct].e->mFieldCount) {
return 0;
}
if (mFields[ct].e->mType != RS_TYPE_UNSIGNED) {
return 0;
}
if (!mFields[ct].e->mIsNormalized) {
return 0;
}
}
switch(mFieldCount) {
case 1:
if (bits[0] == 8) {
return GL_UNSIGNED_BYTE;
}
return 0;
case 2:
if ((bits[0] == 8) &&
(bits[1] == 8)) {
return GL_UNSIGNED_BYTE;
}
return 0;
case 3:
if ((bits[0] == 8) &&
(bits[1] == 8) &&
(bits[2] == 8)) {
return GL_UNSIGNED_BYTE;
}
if ((bits[0] == 5) &&
(bits[1] == 6) &&
(bits[2] == 5)) {
return GL_UNSIGNED_SHORT_5_6_5;
}
return 0;
case 4:
if ((bits[0] == 8) &&
(bits[1] == 8) &&
(bits[2] == 8) &&
(bits[3] == 8)) {
return GL_UNSIGNED_BYTE;
}
if ((bits[0] == 4) &&
(bits[1] == 4) &&
(bits[2] == 4) &&
(bits[3] == 4)) {
return GL_UNSIGNED_SHORT_4_4_4_4;
}
if ((bits[0] == 5) &&
(bits[1] == 5) &&
(bits[2] == 5) &&
(bits[3] == 1)) {
return GL_UNSIGNED_SHORT_5_5_5_1;
}
}
return 0;
}
uint32_t Element::getGLFormat() const
{
if (!mFieldCount) {
if (mKind == RS_KIND_ALPHA) {
return GL_ALPHA;
}
if (mKind == RS_KIND_LUMINANCE) {
return GL_LUMINANCE;
}
}
switch(mFieldCount) {
case 2:
if ((mFields[0].e->mKind == RS_KIND_LUMINANCE) &&
(mFields[1].e->mKind == RS_KIND_ALPHA)) {
return GL_LUMINANCE_ALPHA;
}
break;
case 3:
if ((mFields[0].e->mKind == RS_KIND_RED) &&
(mFields[1].e->mKind == RS_KIND_GREEN) &&
(mFields[2].e->mKind == RS_KIND_BLUE)) {
return GL_RGB;
}
break;
case 4:
if ((mFields[0].e->mKind == RS_KIND_RED) &&
(mFields[1].e->mKind == RS_KIND_GREEN) &&
(mFields[2].e->mKind == RS_KIND_BLUE) &&
(mFields[3].e->mKind == RS_KIND_ALPHA)) {
return GL_RGBA;
}
break;
}
return 0;
}
const char * Element::getCType() const
{
switch(mType) {
case RS_TYPE_FLOAT:
return "float";
case RS_TYPE_SIGNED:
case RS_TYPE_UNSIGNED:
switch(mBits) {
case 32:
return "int";
case 16:
return "short";
case 8:
return "char";
}
break;
}
return NULL;
}
void Element::dumpLOGV(const char *prefix) const
{
ObjectBase::dumpLOGV(prefix);
@@ -246,19 +88,18 @@ void Element::dumpLOGV(const char *prefix) const
}
}
Element * Element::create(Context *rsc, RsDataKind dk, RsDataType dt,
bool isNorm, size_t bits)
Element * Element::create(Context *rsc, RsDataType dt, RsDataKind dk,
bool isNorm, uint32_t vecSize)
{
Element *e = new Element(rsc);
e->mKind = dk;
e->mType = dt;
e->mIsNormalized = isNorm;
e->mBits = bits;
e->mComponent.set(dt, dk, isNorm, vecSize);
e->mBits = e->mComponent.getBits();
return e;
}
Element * Element::create(Context *rsc, Element **ein, const char **nin,
const size_t * lengths, size_t count)
Element * Element::create(Context *rsc, size_t count, const Element **ein,
const char **nin, const size_t * lengths)
{
Element *e = new Element(rsc);
e->mFields = new ElementField_t [count];
@@ -267,11 +108,53 @@ Element * Element::create(Context *rsc, Element **ein, const char **nin,
for (size_t ct=0; ct < count; ct++) {
e->mFields[ct].e.set(ein[ct]);
e->mFields[ct].name.setTo(nin[ct], lengths[ct]);
LOGE("element %p %s", ein[ct], e->mFields[ct].name.string());
}
return e;
}
String8 Element::getCStructBody(uint32_t indent) const
{
String8 si;
for (uint32_t ct=0; ct < indent; ct++) {
si.append(" ");
}
String8 s(si);
s.append("{\n");
for (uint32_t ct = 0; ct < mFieldCount; ct++) {
s.append(si);
s.append(mFields[ct].e->getCType(indent+4));
s.append(" ");
s.append(mFields[ct].name);
s.append(";\n");
}
s.append(si);
s.append("}");
return s;
}
String8 Element::getCType(uint32_t indent) const
{
String8 s;
for (uint32_t ct=0; ct < indent; ct++) {
s.append(" ");
}
if (!mFieldCount) {
// Basic component.
s.append(mComponent.getCType());
} else {
s.append("struct ");
s.append(getCStructBody(indent));
}
return s;
}
ElementState::ElementState()
{
@@ -288,14 +171,31 @@ ElementState::~ElementState()
namespace android {
namespace renderscript {
void rsi_ElementBegin(Context *rsc)
RsElement rsi_ElementCreate(Context *rsc,
RsDataType dt,
RsDataKind dk,
bool norm,
uint32_t vecSize)
{
ElementState * sec = &rsc->mStateElement;
sec->mBuildList.clear();
sec->mNames.clear();
//LOGE("rsi_ElementCreate %i %i %i %i", dt, dk, norm, vecSize);
Element *e = Element::create(rsc, dt, dk, norm, vecSize);
e->incUserRef();
return e;
}
RsElement rsi_ElementCreate2(Context *rsc,
size_t count,
const RsElement * ein,
const char ** names,
const size_t * nameLengths)
{
//LOGE("rsi_ElementCreate2 %i", count);
Element *e = Element::create(rsc, count, (const Element **)ein, names, nameLengths);
e->incUserRef();
return e;
}
/*
void rsi_ElementAdd(Context *rsc, RsDataKind dk, RsDataType dt, bool isNormalized, size_t bits, const char *name)
{
ElementState * sec = &rsc->mStateElement;
@@ -345,6 +245,7 @@ RsElement rsi_ElementCreate(Context *rsc)
free(tmpLengths);
return se;
}
*/
}

30
libs/rs/rsElement.h
View File

@@ -17,7 +17,7 @@
#ifndef ANDROID_STRUCTURED_ELEMENT_H
#define ANDROID_STRUCTURED_ELEMENT_H
//#include "rsComponent.h"
#include "rsComponent.h"
#include "rsUtils.h"
#include "rsObjectBase.h"
@@ -53,20 +53,22 @@ public:
const Element * getField(uint32_t idx) const {return mFields[idx].e.get();}
const char * getFieldName(uint32_t idx) const {return mFields[idx].name.string();}
RsDataType getType() const {return mType;}
bool getIsNormalized() const {return mIsNormalized;}
RsDataKind getKind() const {return mKind;}
const Component & getComponent() const {return mComponent;}
RsDataType getType() const {return mComponent.getType();}
//bool getIsNormalized() const {return mIsNormalized;}
RsDataKind getKind() const {return mComponent.getKind();}
uint32_t getBits() const {return mBits;}
//uint32_t getGLType() const;
const char * getCType() const;
String8 getCType(uint32_t indent=0) const;
String8 getCStructBody(uint32_t indent=0) const;
void dumpLOGV(const char *prefix) const;
static Element * create(Context *rsc, RsDataKind dk, RsDataType dt,
bool isNorm, size_t bits);
static Element * create(Context *rsc, Element **, const char **,
const size_t * lengths, size_t count);
static Element * create(Context *rsc, RsDataType dt, RsDataKind dk,
bool isNorm, uint32_t vecSize);
static Element * create(Context *rsc, size_t count, const Element **,
const char **, const size_t * lengths);
protected:
// deallocate any components that are part of this element.
@@ -74,7 +76,7 @@ protected:
typedef struct {
String8 name;
ObjectBaseRef<Element> e;
ObjectBaseRef<const Element> e;
} ElementField_t;
ElementField_t *mFields;
size_t mFieldCount;
@@ -82,12 +84,8 @@ protected:
Element(Context *);
RsDataType mType;
bool mIsNormalized;
RsDataKind mKind;
Component mComponent;
uint32_t mBits;
//String8 mName;
};

2
libs/rs/rsFileA3D.cpp
View File

@@ -324,6 +324,7 @@ void FileA3D::processChunk_Verticies(Context *rsc, IO *io, A3DIndexEntry *ie)
void FileA3D::processChunk_Element(Context *rsc, IO *io, A3DIndexEntry *ie)
{
/*
rsi_ElementBegin(rsc);
uint32_t count = io->loadU32();
@@ -338,6 +339,7 @@ void FileA3D::processChunk_Element(Context *rsc, IO *io, A3DIndexEntry *ie)
}
LOGE("processChunk_Element create");
ie->mRsObj = rsi_ElementCreate(rsc);
*/
}
void FileA3D::processChunk_ElementSource(Context *rsc, IO *io, A3DIndexEntry *ie)

36
libs/rs/rsProgramFragment.cpp
View File

@@ -213,9 +213,9 @@ void ProgramFragment::createShader()
if (mTextureEnableMask) {
if (mPointSpriteEnable) {
mShader.append(" vec2 tex0 = gl_PointCoord;\n");
mShader.append(" vec2 t0 = gl_PointCoord;\n");
} else {
mShader.append(" vec2 tex0 = varTex0.xy;\n");
mShader.append(" vec2 t0 = varTex0.xy;\n");
}
}
@@ -228,13 +228,39 @@ void ProgramFragment::createShader()
rsAssert(0);
break;
case RS_TEX_ENV_MODE_REPLACE:
mShader.append(" col = texture2D(uni_Tex0, tex0);\n");
switch(mTextureFormats[texNum]) {
case 1:
mShader.append(" col.a = texture2D(uni_Tex0, t0).a;\n");
break;
case 2:
mShader.append(" col.rgba = texture2D(uni_Tex0, t0).rgba;\n");
break;
case 3:
mShader.append(" col.rgb = texture2D(uni_Tex0, t0).rgb;\n");
break;
case 4:
mShader.append(" col.rgba = texture2D(uni_Tex0, t0).rgba;\n");
break;
}
break;
case RS_TEX_ENV_MODE_MODULATE:
mShader.append(" col *= texture2D(uni_Tex0, tex0);\n");
switch(mTextureFormats[texNum]) {
case 1:
mShader.append(" col.a *= texture2D(uni_Tex0, t0).a;\n");
break;
case 2:
mShader.append(" col.rgba *= texture2D(uni_Tex0, t0).rgba;\n");
break;
case 3:
mShader.append(" col.rgb *= texture2D(uni_Tex0, t0).rgb;\n");
break;
case 4:
mShader.append(" col.rgba *= texture2D(uni_Tex0, t0).rgba;\n");
break;
}
break;
case RS_TEX_ENV_MODE_DECAL:
mShader.append(" col = texture2D(uni_Tex0, tex0);\n");
mShader.append(" col = texture2D(uni_Tex0, t0);\n");
break;
}

4
libs/rs/rsProgramVertex.cpp
View File

@@ -246,9 +246,7 @@ ProgramVertexState::~ProgramVertexState()
void ProgramVertexState::init(Context *rsc, int32_t w, int32_t h)
{
rsi_ElementBegin(rsc);
rsi_ElementAdd(rsc, RS_KIND_USER, RS_TYPE_FLOAT, false, 32, NULL);
RsElement e = rsi_ElementCreate(rsc);
RsElement e = Element::create(rsc, RS_TYPE_FLOAT_32, RS_KIND_USER, false, 1);
rsi_TypeBegin(rsc, e);
rsi_TypeAdd(rsc, RS_DIMENSION_X, 48);

65
libs/rs/rsScriptC.cpp
View File

@@ -311,9 +311,15 @@ void ScriptCState::appendTypes(const Context *rsc, String8 *str)
char buf[256];
String8 tmp;
str->append("struct vec2_s {float x; float y;};");
str->append("struct vec3_s {float x; float y; float z;};");
str->append("struct vec4_s {float x; float y; float z; float w;};");
str->append("struct vecF32_2_s {float x; float y;};\n");
str->append("struct vecF32_3_s {float x; float y; float z;};\n");
str->append("struct vecF32_4_s {float x; float y; float z; float w;};\n");
str->append("struct vecU8_4_s {char r; char g; char b; char a;};\n");
str->append("#define vecF32_2_t struct vecF32_2_s\n");
str->append("#define vecF32_3_t struct vecF32_3_s\n");
str->append("#define vecF32_4_t struct vecF32_4_s\n");
str->append("#define vecU8_4_t struct vecU8_4_s\n");
str->append("#define vecI8_4_t struct vecU8_4_s\n");
for (size_t ct=0; ct < MAX_SCRIPT_BANKS; ct++) {
const Type *t = mConstantBufferTypes[ct].get();
@@ -324,8 +330,9 @@ void ScriptCState::appendTypes(const Context *rsc, String8 *str)
if (e->getName() && (e->getFieldCount() > 1)) {
String8 s("struct struct_");
s.append(e->getName());
appendElementBody(&s, e);
s.append(e->getCStructBody());
s.append(";\n");
s.append("#define ");
s.append(e->getName());
s.append("_t struct struct_");
@@ -337,45 +344,25 @@ void ScriptCState::appendTypes(const Context *rsc, String8 *str)
str->append(s);
}
if (t->getName()) {
for (size_t ct2=0; ct2 < e->getFieldCount(); ct2++) {
const Element *c = e->getField(ct2);
tmp.setTo("#define OFFSETOF_");
tmp.append(t->getName());
tmp.append("_");
tmp.append(e->getFieldName(ct2));
sprintf(buf, " %i\n", ct2);
tmp.append(buf);
if (rsc->props.mLogScripts) {
LOGV(tmp);
}
str->append(tmp);
}
}
if (mSlotNames[ct].length() > 0) {
String8 s;
if (e->getFieldCount() > 1) {
if (e->getName()) {
// Use the named struct
s.setTo(e->getName());
s.append("_t *");
} else {
// create an struct named from the slot.
s.setTo("struct ");
s.append(mSlotNames[ct]);
s.append("_s");
appendElementBody(&s, e);
s.append(";\n");
s.append("struct ");
s.append(mSlotNames[ct]);
s.append("_s * ");
}
if (e->getName()) {
// Use the named struct
s.setTo(e->getName());
} else {
// Just make an array
s.setTo(e->getField(0)->getCType());
s.append("_t *");
// create an struct named from the slot.
s.setTo("struct ");
s.append(mSlotNames[ct]);
s.append("_s");
s.append(e->getCStructBody());
//appendElementBody(&s, e);
s.append(";\n");
s.append("struct ");
s.append(mSlotNames[ct]);
s.append("_s");
}
s.append(" * ");
s.append(mSlotNames[ct]);
s.append(";\n");
if (rsc->props.mLogScripts) {

38
libs/rs/rsScriptC_Lib.cpp
View File

@@ -689,9 +689,9 @@ static void SC_drawLine(float x1, float y1, float z1,
VertexArray va;
va.setPosition(2, GL_FLOAT, 12, (uint32_t)&vtx);
if (rsc->checkVersion2_0()) {
va.setupGL2(&rsc->mStateVertexArray, &rsc->mShaderCache);
va.setupGL2(rsc, &rsc->mStateVertexArray, &rsc->mShaderCache);
} else {
va.setupGL(&rsc->mStateVertexArray);
va.setupGL(rsc, &rsc->mStateVertexArray);
}
glDrawArrays(GL_LINES, 0, 2);
@@ -707,9 +707,9 @@ static void SC_drawPoint(float x, float y, float z)
VertexArray va;
va.setPosition(1, GL_FLOAT, 12, (uint32_t)&vtx);
if (rsc->checkVersion2_0()) {
va.setupGL2(&rsc->mStateVertexArray, &rsc->mShaderCache);
va.setupGL2(rsc, &rsc->mStateVertexArray, &rsc->mShaderCache);
} else {
va.setupGL(&rsc->mStateVertexArray);
va.setupGL(rsc, &rsc->mStateVertexArray);
}
glDrawArrays(GL_POINTS, 0, 1);
@@ -742,9 +742,9 @@ static void SC_drawQuadTexCoords(float x1, float y1, float z1,
//va.setTexture(2, GL_FLOAT, 8, (uint32_t)&tex, 1);
//
if (rsc->checkVersion2_0()) {
va.setupGL2(&rsc->mStateVertexArray, &rsc->mShaderCache);
va.setupGL2(rsc, &rsc->mStateVertexArray, &rsc->mShaderCache);
} else {
va.setupGL(&rsc->mStateVertexArray);
va.setupGL(rsc, &rsc->mStateVertexArray);
}
@@ -1223,33 +1223,33 @@ ScriptCState::SymbolTable_t ScriptCState::gSyms[] = {
// vec3
{ "vec3Norm", (void *)&SC_vec3Norm,
"void", "(struct vec3_s *)" },
"void", "(struct vecF32_3_s *)" },
{ "vec3Length", (void *)&SC_vec3Length,
"float", "(struct vec3_s *)" },
"float", "(struct vecF32_3_s *)" },
{ "vec3Add", (void *)&SC_vec3Add,
"void", "(struct vec3_s *dest, struct vec3_s *lhs, struct vec3_s *rhs)" },
"void", "(struct vecF32_3_s *dest, struct vecF32_3_s *lhs, struct vecF32_3_s *rhs)" },
{ "vec3Sub", (void *)&SC_vec3Sub,
"void", "(struct vec3_s *dest, struct vec3_s *lhs, struct vec3_s *rhs)" },
"void", "(struct vecF32_3_s *dest, struct vecF32_3_s *lhs, struct vecF32_3_s *rhs)" },
{ "vec3Cross", (void *)&SC_vec3Cross,
"void", "(struct vec3_s *dest, struct vec3_s *lhs, struct vec3_s *rhs)" },
"void", "(struct vecF32_3_s *dest, struct vecF32_3_s *lhs, struct vecF32_3_s *rhs)" },
{ "vec3Dot", (void *)&SC_vec3Dot,
"float", "(struct vec3_s *lhs, struct vec3_s *rhs)" },
"float", "(struct vecF32_3_s *lhs, struct vecF32_3_s *rhs)" },
{ "vec3Scale", (void *)&SC_vec3Scale,
"void", "(struct vec3_s *lhs, float scale)" },
"void", "(struct vecF32_3_s *lhs, float scale)" },
// vec4
{ "vec4Norm", (void *)&SC_vec4Norm,
"void", "(struct vec4_s *)" },
"void", "(struct vecF32_4_s *)" },
{ "vec4Length", (void *)&SC_vec4Length,
"float", "(struct vec4_s *)" },
"float", "(struct vecF32_4_s *)" },
{ "vec4Add", (void *)&SC_vec4Add,
"void", "(struct vec4_s *dest, struct vec4_s *lhs, struct vec4_s *rhs)" },
"void", "(struct vecF32_4_s *dest, struct vecF32_4_s *lhs, struct vecF32_4_s *rhs)" },
{ "vec4Sub", (void *)&SC_vec4Sub,
"void", "(struct vec4_s *dest, struct vec4_s *lhs, struct vec4_s *rhs)" },
"void", "(struct vecF32_4_s *dest, struct vecF32_4_s *lhs, struct vecF32_4_s *rhs)" },
{ "vec4Dot", (void *)&SC_vec4Dot,
"float", "(struct vec4_s *lhs, struct vec4_s *rhs)" },
"float", "(struct vecF32_4_s *lhs, struct vecF32_4_s *rhs)" },
{ "vec4Scale", (void *)&SC_vec4Scale,
"void", "(struct vec4_s *lhs, float scale)" },
"void", "(struct vecF32_4_s *lhs, float scale)" },
// context
{ "bindProgramFragment", (void *)&SC_bindProgramFragment,

5
libs/rs/rsShaderCache.cpp
View File

@@ -93,7 +93,10 @@ bool ShaderCache::lookup(Context *rsc, ProgramVertex *vtx, ProgramFragment *frag
glBindAttribLocation(pgm, VertexArray::POSITION, "attrib_Position");
glBindAttribLocation(pgm, VertexArray::COLOR, "attrib_Color");
//glBindAttribLocation(pgm, VertexArray::NORMAL, "attrib_Normal");
//glBindAttribLocation(pgm, VertexArray::POINT_SIZE, "attrib_PointSize");
//glBindAttribLocation(pgm, VertexArray::TEXTURE_0, "attrib_T0");
//glBindAttribLocation(pgm, VertexArray::TEXTURE_1, "attrib_T1");
//LOGE("e2 %x", glGetError());
glLinkProgram(pgm);

7
libs/rs/rsSimpleMesh.cpp
View File

@@ -62,9 +62,9 @@ void SimpleMesh::renderRange(Context *rsc, uint32_t start, uint32_t len) const
mVertexTypes[ct]->enableGLVertexBuffer(&va);
}
if (rsc->checkVersion2_0()) {
va.setupGL2(0, &rsc->mShaderCache);
va.setupGL2(rsc, 0, &rsc->mShaderCache);
} else {
va.setupGL(0);
va.setupGL(rsc, 0);
}
if (mIndexType.get()) {
@@ -74,6 +74,8 @@ void SimpleMesh::renderRange(Context *rsc, uint32_t start, uint32_t len) const
} else {
glDrawArrays(mGLPrimitive, start, len);
}
rsc->checkError("SimpleMesh::renderRange");
}
void SimpleMesh::uploadAll(Context *rsc)
@@ -89,6 +91,7 @@ void SimpleMesh::uploadAll(Context *rsc)
if (mPrimitiveBuffer.get()) {
mPrimitiveBuffer->deferedUploadToBufferObject(rsc);
}
rsc->checkError("SimpleMesh::uploadAll");
}

98
libs/rs/rsType.cpp
View File

@@ -137,106 +137,44 @@ void Type::makeGLComponents()
memset(&mGL, 0, sizeof(mGL));
for (uint32_t ct=0; ct < getElement()->getFieldCount(); ct++) {
const Element *c = getElement()->getField(ct);
const Component &c = getElement()->getField(ct)->getComponent();
switch(c->getKind()) {
case RS_KIND_X:
switch(c.getKind()) {
case RS_KIND_POSITION:
rsAssert(mGL.mVtx.size == 0);
mGL.mVtx.size = 1;
mGL.mVtx.size = c.getVectorSize();
mGL.mVtx.offset = mElement->getFieldOffsetBytes(ct);
mGL.mVtx.type = c->getGLType();
mGL.mVtx.type = c.getGLType();
break;
case RS_KIND_Y:
rsAssert(mGL.mVtx.size == 1);
rsAssert(mGL.mVtx.type == c->getGLType());
mGL.mVtx.size = 2;
break;
case RS_KIND_Z:
rsAssert(mGL.mVtx.size == 2);
rsAssert(mGL.mVtx.type == c->getGLType());
mGL.mVtx.size = 3;
break;
case RS_KIND_W:
rsAssert(mGL.mVtx.size == 4);
rsAssert(mGL.mVtx.type == c->getGLType());
mGL.mVtx.size = 4;
break;
case RS_KIND_RED:
case RS_KIND_COLOR:
rsAssert(mGL.mColor.size == 0);
mGL.mColor.size = 1;
mGL.mColor.size = c.getVectorSize();
mGL.mColor.offset = mElement->getFieldOffsetBytes(ct);
mGL.mColor.type = c->getGLType();
mGL.mColor.type = c.getGLType();
break;
case RS_KIND_GREEN:
rsAssert(mGL.mColor.size == 1);
rsAssert(mGL.mColor.type == c->getGLType());
mGL.mColor.size = 2;
break;
case RS_KIND_BLUE:
rsAssert(mGL.mColor.size == 2);
rsAssert(mGL.mColor.type == c->getGLType());
mGL.mColor.size = 3;
break;
case RS_KIND_ALPHA:
// Can be RGBA or A at this point
if (mGL.mColor.size > 0) {
rsAssert(mGL.mColor.size == 3);
rsAssert(mGL.mColor.type == c->getGLType());
mGL.mColor.size = 4;
} else {
mGL.mColor.size = 1;
mGL.mColor.offset = mElement->getFieldOffsetBytes(ct);
mGL.mColor.type = c->getGLType();
}
break;
case RS_KIND_NX:
case RS_KIND_NORMAL:
rsAssert(mGL.mNorm.size == 0);
mGL.mNorm.size = 1;
mGL.mNorm.size = c.getVectorSize();
mGL.mNorm.offset = mElement->getFieldOffsetBytes(ct);
mGL.mNorm.type = c->getGLType();
break;
case RS_KIND_NY:
rsAssert(mGL.mNorm.size == 1);
rsAssert(mGL.mNorm.type == c->getGLType());
mGL.mNorm.size = 2;
break;
case RS_KIND_NZ:
rsAssert(mGL.mNorm.size == 2);
rsAssert(mGL.mNorm.type == c->getGLType());
mGL.mNorm.size = 3;
break;
mGL.mNorm.type = c.getGLType();
break;
case RS_KIND_S:
case RS_KIND_TEXTURE:
if (mGL.mTex[texNum].size) {
texNum++;
}
mGL.mTex[texNum].size = 1;
mGL.mTex[texNum].size = c.getVectorSize();
mGL.mTex[texNum].offset = mElement->getFieldOffsetBytes(ct);
mGL.mTex[texNum].type = c->getGLType();
break;
case RS_KIND_T:
rsAssert(mGL.mTex[texNum].size == 1);
rsAssert(mGL.mTex[texNum].type == c->getGLType());
mGL.mTex[texNum].size = 2;
break;
case RS_KIND_R:
rsAssert(mGL.mTex[texNum].size == 2);
rsAssert(mGL.mTex[texNum].type == c->getGLType());
mGL.mTex[texNum].size = 3;
break;
case RS_KIND_Q:
rsAssert(mGL.mTex[texNum].size == 3);
rsAssert(mGL.mTex[texNum].type == c->getGLType());
mGL.mTex[texNum].size = 4;
break;
mGL.mTex[texNum].type = c.getGLType();
break;
case RS_KIND_POINT_SIZE:
rsAssert(!mGL.mPointSize.size);
mGL.mPointSize.size = 1;
mGL.mPointSize.size = c.getVectorSize();
mGL.mPointSize.offset = mElement->getFieldOffsetBytes(ct);
mGL.mPointSize.type = c->getGLType();
mGL.mPointSize.type = c.getGLType();
break;
default:

9
libs/rs/rsVertexArray.cpp
View File

@@ -96,15 +96,16 @@ void VertexArray::setTexture(uint32_t size, uint32_t type, uint32_t stride, uint
}
void VertexArray::logAttrib(uint32_t idx) const {
LOGE("va %i: buf=%i size=%i type=0x%x stride=0x%x offset=0x%x", idx,
LOGE("va %i: buf=%i size=%i type=0x%x stride=0x%x norm=%i offset=0x%x", idx,
mAttribs[idx].buffer,
mAttribs[idx].size,
mAttribs[idx].type,
mAttribs[idx].stride,
mAttribs[idx].normalized,
mAttribs[idx].offset);
}
void VertexArray::setupGL(class VertexArrayState *state) const
void VertexArray::setupGL(const Context *rsc, class VertexArrayState *state) const
{
if (mAttribs[POSITION].size) {
//logAttrib(POSITION);
@@ -168,9 +169,10 @@ void VertexArray::setupGL(class VertexArrayState *state) const
} else {
glDisableClientState(GL_POINT_SIZE_ARRAY_OES);
}
rsc->checkError("VertexArray::setupGL");
}
void VertexArray::setupGL2(class VertexArrayState *state, ShaderCache *sc) const
void VertexArray::setupGL2(const Context *rsc, class VertexArrayState *state, ShaderCache *sc) const
{
for (int ct=1; ct < _LAST; ct++) {
glDisableVertexAttribArray(ct);
@@ -194,6 +196,7 @@ void VertexArray::setupGL2(class VertexArrayState *state, ShaderCache *sc) const
rsAssert(ct);
}
}
rsc->checkError("VertexArray::setupGL2");
}
////////////////////////////////////////////

4
libs/rs/rsVertexArray.h
View File

@@ -64,8 +64,8 @@ public:
void setPointSize(uint32_t type, uint32_t stride, uint32_t offset);
void setTexture(uint32_t size, uint32_t type, uint32_t stride, uint32_t offset, uint32_t num);
void setupGL(class VertexArrayState *) const;
void setupGL2(class VertexArrayState *, ShaderCache *) const;
void setupGL(const Context *rsc, class VertexArrayState *) const;
void setupGL2(const Context *rsc, class VertexArrayState *, ShaderCache *) const;
void logAttrib(uint32_t idx) const;
protected: