summaryrefslogtreecommitdiffstats
path: root/libs/rs/rsComponent.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'libs/rs/rsComponent.cpp')
-rw-r--r--libs/rs/rsComponent.cpp349
1 files changed, 288 insertions, 61 deletions
diff --git a/libs/rs/rsComponent.cpp b/libs/rs/rsComponent.cpp
index de074c8..15a56f7 100644
--- a/libs/rs/rsComponent.cpp
+++ b/libs/rs/rsComponent.cpp
@@ -15,96 +15,323 @@
*/
#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(Context *rsc) : ObjectBase(rsc)
+Component::~Component()
{
- mAllocFile = __FILE__;
- mAllocLine = __LINE__;
- mType = FLOAT;
- mKind = USER;
- mIsNormalized = false;
- mBits = 0;
}
-Component::Component(Context *rsc,
- DataKind dk, DataType dt,
- bool isNormalized, uint32_t bits, const char * name) : ObjectBase(rsc)
+void Component::set(RsDataType dt, RsDataKind dk, bool norm, uint32_t vecSize)
{
- mAllocFile = __FILE__;
- mAllocLine = __LINE__;
mType = dt;
mKind = dk;
- mIsNormalized = isNormalized;
- mBits = bits;
- if (name) {
- mName = name;
+ 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;
}
-}
-const char * Component::getCType() const
-{
switch(mType) {
- case FLOAT:
- return "float";
- case SIGNED:
- case UNSIGNED:
- switch(mBits) {
- case 32:
- return "int";
- case 16:
- return "short";
- case 8:
- return "char";
- }
+ 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;
}
- return NULL;
+
+ mBits = mTypeBits * mVectorSize;
}
-Component::~Component()
+
+
+
+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::getGLType() const
+uint32_t Component::getGLFormat() const
{
- switch(mType) {
- case RS_TYPE_FLOAT:
- rsAssert(mBits == 32);
- return GL_FLOAT;
- case RS_TYPE_SIGNED:
- switch(mBits) {
- case 32:
- return 0;//GL_INT;
- case 16:
- return GL_SHORT;
- case 8:
- return GL_BYTE;
+ 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;
+}
+
+String8 Component::getGLSLType() const
+{
+ if (mType == RS_TYPE_SIGNED_32) {
+ switch(mVectorSize) {
+ case 1: return String8("int");
+ case 2: return String8("ivec2");
+ case 3: return String8("ivec3");
+ case 4: return String8("ivec4");
}
- break;
- case RS_TYPE_UNSIGNED:
- switch(mBits) {
- case 32:
- return 0;//GL_UNSIGNED_INT;
- case 16:
- return GL_UNSIGNED_SHORT;
- case 8:
- return GL_UNSIGNED_BYTE;
+ }
+ if (mType == RS_TYPE_FLOAT_32) {
+ switch(mVectorSize) {
+ case 1: return String8("float");
+ case 2: return String8("vec2");
+ case 3: return String8("vec3");
+ case 4: return String8("vec4");
}
- break;
}
- //rsAssert(!"Bad type");
- //LOGE("mType %i, mKind %i, mBits %i, mIsNormalized %i", mType, mKind, mBits, mIsNormalized);
- return 0;
+ return String8();
}
+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
{
- ObjectBase::dumpLOGV(prefix);
- LOGV("%s component: %i %i %i %i", prefix, mType, mKind, mIsNormalized, mBits);
+ LOGV("%s Component: %s, %s, vectorSize=%i, bits=%i",
+ prefix, gTypeStrings[mType], gKindStrings[mKind], mVectorSize, mBits);
}
+