1/* 2 * Copyright 2010, The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#ifndef _COMPILE_SLANG_SLANG_RS_TYPE_SPEC_H_ // NOLINT 18#define _COMPILE_SLANG_SLANG_RS_TYPE_SPEC_H_ 19 20#define RS_DATA_TYPE_CLASS_ENUMS \ 21 ENUM_RS_DATA_TYPE_CLASS(Primitive) \ 22 ENUM_RS_DATA_TYPE_CLASS(Pointer) \ 23 ENUM_RS_DATA_TYPE_CLASS(Vector) \ 24 ENUM_RS_DATA_TYPE_CLASS(Matrix) \ 25 ENUM_RS_DATA_TYPE_CLASS(ConstantArray) \ 26 ENUM_RS_DATA_TYPE_CLASS(Record) 27 28#define PRIMITIVE_DATA_TYPE_ENUMS \ 29 ENUM_PRIMITIVE_DATA_TYPE(Float16, NULL, 16) \ 30 ENUM_PRIMITIVE_DATA_TYPE(Float32, "float", 32) \ 31 ENUM_PRIMITIVE_DATA_TYPE(Float64, "double", 64) \ 32 ENUM_PRIMITIVE_DATA_TYPE(Signed8, "char", 8) \ 33 ENUM_PRIMITIVE_DATA_TYPE(Signed16, "short", 16) \ 34 ENUM_PRIMITIVE_DATA_TYPE(Signed32, "int", 32) \ 35 ENUM_PRIMITIVE_DATA_TYPE(Signed64, "long", 64) \ 36 ENUM_PRIMITIVE_DATA_TYPE(Unsigned8, "uchar", 8) \ 37 ENUM_PRIMITIVE_DATA_TYPE(Unsigned16, "ushort", 16) \ 38 ENUM_PRIMITIVE_DATA_TYPE(Unsigned32, "uint", 32) \ 39 ENUM_PRIMITIVE_DATA_TYPE(Unsigned64, "ulong", 64) \ 40 ENUM_PRIMITIVE_DATA_TYPE(Boolean, "bool", 8) \ 41 ENUM_PRIMITIVE_DATA_TYPE(Unsigned565, "u565", 16) \ 42 ENUM_PRIMITIVE_DATA_TYPE(Unsigned5551, "u5551", 16) \ 43 ENUM_PRIMITIVE_DATA_TYPE(Unsigned4444, "u4444", 16) \ 44 PRIMITIVE_DATA_TYPE_RANGE(Float16, Unsigned4444) 45 46#define RS_MATRIX_DATA_TYPE_ENUMS \ 47 ENUM_RS_MATRIX_DATA_TYPE(RSMatrix2x2, "rs_matrix2x2", 2) \ 48 ENUM_RS_MATRIX_DATA_TYPE(RSMatrix3x3, "rs_matrix3x3", 3) \ 49 ENUM_RS_MATRIX_DATA_TYPE(RSMatrix4x4, "rs_matrix4x4", 4) \ 50 RS_MATRIX_DATA_TYPE_RANGE(RSMatrix2x2, RSMatrix4x4) 51 52#define RS_OBJECT_DATA_TYPE_ENUMS \ 53 ENUM_RS_OBJECT_DATA_TYPE(RSElement, "rs_element") \ 54 ENUM_RS_OBJECT_DATA_TYPE(RSType, "rs_type") \ 55 ENUM_RS_OBJECT_DATA_TYPE(RSAllocation, "rs_allocation") \ 56 ENUM_RS_OBJECT_DATA_TYPE(RSSampler, "rs_sampler") \ 57 ENUM_RS_OBJECT_DATA_TYPE(RSScript, "rs_script") \ 58 ENUM_RS_OBJECT_DATA_TYPE(RSMesh, "rs_mesh") \ 59 ENUM_RS_OBJECT_DATA_TYPE(RSPath, "rs_path") \ 60 ENUM_RS_OBJECT_DATA_TYPE(RSProgramFragment, "rs_program_fragment") \ 61 ENUM_RS_OBJECT_DATA_TYPE(RSProgramVertex, "rs_program_vertex") \ 62 ENUM_RS_OBJECT_DATA_TYPE(RSProgramRaster, "rs_program_raster") \ 63 ENUM_RS_OBJECT_DATA_TYPE(RSProgramStore, "rs_program_store") \ 64 ENUM_RS_OBJECT_DATA_TYPE(RSFont, "rs_font") \ 65 RS_OBJECT_DATA_TYPE_RANGE(RSElement, RSFont) 66 67enum RSTypeClass { 68#define ENUM_RS_DATA_TYPE_CLASS(x) RS_TC_ ## x, 69 RS_DATA_TYPE_CLASS_ENUMS 70#undef ENUM_RS_DATA_TYPE_CLASS 71 RS_TC_Max 72}; 73 74enum RSDataType { 75#define ENUM_PRIMITIVE_DATA_TYPE(x, name, bits) RS_DT_ ## x, 76#define PRIMITIVE_DATA_TYPE_RANGE(x, y) \ 77 RS_DT_FirstPrimitiveType = RS_DT_ ## x, \ 78 RS_DT_LastPrimitiveType = RS_DT_ ## y, 79 PRIMITIVE_DATA_TYPE_ENUMS 80#undef ENUM_PRIMITIVE_DATA_TYPE 81#undef PRIMITIVE_DATA_TYPE_RANGE 82 83#define ENUM_RS_MATRIX_DATA_TYPE(x, name, dim) RS_DT_ ## x, 84#define RS_MATRIX_DATA_TYPE_RANGE(x, y) \ 85 RS_DT_FirstMatrixType = RS_DT_ ## x, \ 86 RS_DT_LastMatrixType = RS_DT_ ## y, 87 RS_MATRIX_DATA_TYPE_ENUMS 88#undef ENUM_RS_MATRIX_DATA_TYPE 89#undef RS_MATRIX_DATA_TYPE_RANGE 90 91#define ENUM_RS_OBJECT_DATA_TYPE(x, name) RS_DT_ ## x, 92#define RS_OBJECT_DATA_TYPE_RANGE(x, y) \ 93 RS_DT_FirstRSObjectType = RS_DT_ ## x, \ 94 RS_DT_LastRSObjectType = RS_DT_ ## y, 95 RS_OBJECT_DATA_TYPE_ENUMS 96#undef ENUM_RS_OBJECT_DATA_TYPE 97#undef RS_OBJECT_DATA_TYPE_RANGE 98 99 RS_DT_USER_DEFINED 100}; 101 102// Forward declaration 103union RSType; 104 105// NOTE: Current design need to keep struct RSTypeBase as a 4-byte integer for 106// efficient decoding process (see DecodeTypeMetadata). 107struct RSTypeBase { 108 /* enum RSTypeClass tc; */ 109 // tc is encoded in b[0]. 110 union { 111 // FIXME: handle big-endianess case 112 unsigned bits; // NOTE: Little-endian is assumed. 113 unsigned char b[4]; 114 }; 115}; 116 117struct RSPrimitiveType { 118 struct RSTypeBase base; 119 /* enum RSDataType dt; */ 120 // dt is encoded in base.b[1] 121}; 122 123struct RSPointerType { 124 struct RSTypeBase base; 125 const union RSType *pointee; 126}; 127 128struct RSVectorType { 129 struct RSPrimitiveType base; // base type of vec must be in primitive type 130 /* unsigned char vsize; */ 131 // vsize is encoded in base.b[2] 132}; 133 134// RSMatrixType is actually a specialize class of RSPrimitiveType whose value of 135// dt (data type) can only be RS_DT_RSMatrix2x2, RS_DT_RSMatrix3x3 and 136// RS_DT_RSMatrix4x4. 137struct RSMatrixType { 138 struct RSTypeBase base; 139}; 140 141struct RSConstantArrayType { 142 struct RSTypeBase base; 143 const union RSType *element_type; 144 /* unsigned esize; */ 145 // esize is encoded in base.bits{8-31} in little-endian way. This implicates 146 // the number of elements in any constant array type should never exceed 2^24. 147}; 148 149struct RSRecordField { 150 const char *name; // field name 151 const union RSType *type; 152}; 153 154struct RSRecordType { 155 struct RSTypeBase base; 156 const char *name; // type name 157 /* unsigned num_fields; */ 158 // num_fields is encoded in base.bits{16-31} in little-endian way. This 159 // implicates the number of fields defined in any record type should never 160 // exceed 2^16. 161 162 struct RSRecordField field[1]; 163}; 164 165union RSType { 166 struct RSTypeBase base; 167 struct RSPrimitiveType prim; 168 struct RSPointerType pointer; 169 struct RSVectorType vec; 170 struct RSConstantArrayType ca; 171 struct RSRecordType rec; 172}; 173 174#define RS_GET_TYPE_BASE(R) (&((R)->base)) 175#define RS_CAST_TO_PRIMITIVE_TYPE(R) (&((R)->prim)) 176#define RS_CAST_TO_POINTER_TYPE(R) (&((R)->pointer)) 177#define RS_CAST_TO_VECTOR_TYPE(R) (&((R)->vec)) 178#define RS_CAST_TO_CONSTANT_ARRAY_TYPE(R) (&((R)->ca)) 179#define RS_CAST_TO_RECORD_TYPE(R) (&((R)->rec)) 180 181// RSType 182#define RS_TYPE_GET_CLASS(R) RS_GET_TYPE_BASE(R)->b[0] 183#define RS_TYPE_SET_CLASS(R, V) RS_TYPE_GET_CLASS(R) = (V) 184 185// RSPrimitiveType 186#define RS_PRIMITIVE_TYPE_GET_DATA_TYPE(R) \ 187 RS_CAST_TO_PRIMITIVE_TYPE(R)->base.b[1] 188#define RS_PRIMITIVE_TYPE_SET_DATA_TYPE(R, V) \ 189 RS_PRIMITIVE_TYPE_GET_DATA_TYPE(R) = (V) 190 191// RSPointerType 192#define RS_POINTER_TYPE_GET_POINTEE_TYPE(R) \ 193 RS_CAST_TO_POINTER_TYPE(R)->pointee 194#define RS_POINTER_TYPE_SET_POINTEE_TYPE(R, V) \ 195 RS_POINTER_TYPE_GET_POINTEE_TYPE(R) = (V) 196 197// RSVectorType 198#define RS_VECTOR_TYPE_GET_ELEMENT_TYPE(R) \ 199 RS_PRIMITIVE_TYPE_GET_DATA_TYPE(R) 200#define RS_VECTOR_TYPE_SET_ELEMENT_TYPE(R, V) \ 201 RS_VECTOR_TYPE_GET_ELEMENT_TYPE(R) = (V) 202 203#define RS_VECTOR_TYPE_GET_VECTOR_SIZE(R) \ 204 RS_CAST_TO_VECTOR_TYPE(R)->base.base.b[2] 205#define RS_VECTOR_TYPE_SET_VECTOR_SIZE(R, V) \ 206 RS_VECTOR_TYPE_GET_VECTOR_SIZE(R) = (V) 207 208// RSMatrixType 209#define RS_MATRIX_TYPE_GET_DATA_TYPE(R) RS_PRIMITIVE_TYPE_GET_DATA_TYPE(R) 210#define RS_MATRIX_TYPE_SET_DATA_TYPE(R, V) \ 211 RS_MATRIX_TYPE_GET_DATA_TYPE(R) = (V) 212 213// RSConstantArrayType 214#define RS_CONSTANT_ARRAY_TYPE_GET_ELEMENT_TYPE(R) \ 215 RS_CAST_TO_CONSTANT_ARRAY_TYPE(R)->element_type 216#define RS_CONSTANT_ARRAY_TYPE_SET_ELEMENT_TYPE(R, V) \ 217 RS_CONSTANT_ARRAY_TYPE_GET_ELEMENT_TYPE(R) = (V) 218 219#define RS_CONSTANT_ARRAY_TYPE_GET_ELEMENT_SIZE(R) \ 220 (RS_CAST_TO_CONSTANT_ARRAY_TYPE(R)->base.bits & 0x00ffffff) 221#define RS_CONSTANT_ARRAY_TYPE_SET_ELEMENT_SIZE(R, V) \ 222 RS_CAST_TO_CONSTANT_ARRAY_TYPE(R)->base.bits = \ 223 ((RS_CAST_TO_CONSTANT_ARRAY_TYPE(R)->base.bits & 0x000000ff) | \ 224 ((V & 0xffffff) << 8)) 225 226// RSRecordType 227#define RS_RECORD_TYPE_GET_NAME(R) RS_CAST_TO_RECORD_TYPE(R)->name 228#define RS_RECORD_TYPE_SET_NAME(R, V) RS_RECORD_TYPE_GET_NAME(R) = (V) 229 230#define RS_RECORD_TYPE_GET_NUM_FIELDS(R) \ 231 ((RS_CAST_TO_RECORD_TYPE(R)->base.bits & 0xffff0000) >> 16) 232#define RS_RECORD_TYPE_SET_NUM_FIELDS(R, V) \ 233 RS_CAST_TO_RECORD_TYPE(R)->base.bits = \ 234 ((RS_CAST_TO_RECORD_TYPE(R)->base.bits & 0x0000ffff) | ((V & 0xffff) << 16)) 235 236#define RS_RECORD_TYPE_GET_FIELD_NAME(R, I) \ 237 RS_CAST_TO_RECORD_TYPE(R)->field[(I)].name 238#define RS_RECORD_TYPE_SET_FIELD_NAME(R, I, V) \ 239 RS_RECORD_TYPE_GET_FIELD_NAME(R, I) = (V) 240 241#define RS_RECORD_TYPE_GET_FIELD_TYPE(R, I) \ 242 RS_CAST_TO_RECORD_TYPE(R)->field[(I)].type 243#define RS_RECORD_TYPE_SET_FIELD_TYPE(R, I, V) \ 244 RS_RECORD_TYPE_GET_FIELD_TYPE(R, I) = (V) 245 246#endif // _COMPILE_SLANG_SLANG_RS_TYPE_SPEC_H_ NOLINT 247