1 #ifndef _RS_STRUCTS_H_ 2 #define _RS_STRUCTS_H_ 3 4 /***************************************************************************** 5 * CAUTION 6 * 7 * The following structure layout provides a more efficient way to access 8 * internal members of the C++ class Allocation owned by librs. Unfortunately, 9 * since this class has virtual members, we can't simply use offsetof() or any 10 * other compiler trickery to dynamically get the appropriate values at 11 * build-time. This layout may need to be updated whenever 12 * frameworks/base/libs/rs/rsAllocation.h is modified. 13 * 14 * Having the layout information available in this file allows us to 15 * accelerate functionality like rsAllocationGetDimX(). Without this 16 * information, we would not be able to inline the bitcode, thus resulting in 17 * potential runtime performance penalties for tight loops operating on 18 * allocations. 19 * 20 *****************************************************************************/ 21 typedef enum { 22 RS_ALLOCATION_MIPMAP_NONE = 0, 23 RS_ALLOCATION_MIPMAP_FULL = 1, 24 RS_ALLOCATION_MIPMAP_ON_SYNC_TO_TEXTURE = 2 25 } rs_allocation_mipmap_control; 26 27 typedef struct Allocation { 28 #ifndef __LP64__ 29 char __pad[32]; 30 #else 31 char __pad[56]; 32 #endif 33 struct { 34 void * drv; 35 struct { 36 const void *type; 37 uint32_t usageFlags; 38 rs_allocation_mipmap_control mipmapControl; 39 uint32_t yuv; 40 uint32_t elementSizeBytes; 41 bool hasMipmaps; 42 bool hasFaces; 43 bool hasReferences; 44 void * usrPtr; 45 int32_t surfaceTextureID; 46 void * nativeBuffer; 47 int64_t timestamp; 48 } state; 49 50 struct DrvState { 51 struct LodState { 52 void * mallocPtr; 53 size_t stride; 54 uint32_t dimX; 55 uint32_t dimY; 56 uint32_t dimZ; 57 } lod[16/*android::renderscript::Allocation::MAX_LOD*/]; 58 size_t faceOffset; 59 uint32_t lodCount; 60 uint32_t faceCount; 61 62 struct YuvState { 63 uint32_t shift; 64 uint32_t step; 65 } yuv; 66 } drvState; 67 } mHal; 68 } Allocation_t; 69 70 #ifndef __LP64__ 71 /***************************************************************************** 72 * CAUTION 73 * 74 * The following structure layout provides a more efficient way to access 75 * internal members of the C++ class ProgramStore owned by librs. Unfortunately, 76 * since this class has virtual members, we can't simply use offsetof() or any 77 * other compiler trickery to dynamically get the appropriate values at 78 * build-time. This layout may need to be updated whenever 79 * frameworks/base/libs/rs/rsProgramStore.h is modified. 80 * 81 * Having the layout information available in this file allows us to 82 * accelerate functionality like rsgProgramStoreGetDepthFunc(). Without this 83 * information, we would not be able to inline the bitcode, thus resulting in 84 * potential runtime performance penalties for tight loops operating on 85 * program store. 86 * 87 *****************************************************************************/ 88 typedef struct ProgramStore { 89 char __pad[40]; 90 struct { 91 struct { 92 bool ditherEnable; 93 bool colorRWriteEnable; 94 bool colorGWriteEnable; 95 bool colorBWriteEnable; 96 bool colorAWriteEnable; 97 rs_blend_src_func blendSrc; 98 rs_blend_dst_func blendDst; 99 bool depthWriteEnable; 100 rs_depth_func depthFunc; 101 } state; 102 } mHal; 103 } ProgramStore_t; 104 105 /***************************************************************************** 106 * CAUTION 107 * 108 * The following structure layout provides a more efficient way to access 109 * internal members of the C++ class ProgramRaster owned by librs. Unfortunately, 110 * since this class has virtual members, we can't simply use offsetof() or any 111 * other compiler trickery to dynamically get the appropriate values at 112 * build-time. This layout may need to be updated whenever 113 * frameworks/base/libs/rs/rsProgramRaster.h is modified. 114 * 115 * Having the layout information available in this file allows us to 116 * accelerate functionality like rsgProgramRasterGetCullMode(). Without this 117 * information, we would not be able to inline the bitcode, thus resulting in 118 * potential runtime performance penalties for tight loops operating on 119 * program raster. 120 * 121 *****************************************************************************/ 122 typedef struct ProgramRaster { 123 char __pad[36]; 124 struct { 125 void * drv; 126 struct { 127 bool pointSprite; 128 rs_cull_mode cull; 129 } state; 130 } mHal; 131 } ProgramRaster_t; 132 #endif //__LP64__ 133 134 /***************************************************************************** 135 * CAUTION 136 * 137 * The following structure layout provides a more efficient way to access 138 * internal members of the C++ class Sampler owned by librs. Unfortunately, 139 * since this class has virtual members, we can't simply use offsetof() or any 140 * other compiler trickery to dynamically get the appropriate values at 141 * build-time. This layout may need to be updated whenever 142 * frameworks/base/libs/rs/rsSampler.h is modified. 143 * 144 * Having the layout information available in this file allows us to 145 * accelerate functionality like rsgProgramRasterGetMagFilter(). Without this 146 * information, we would not be able to inline the bitcode, thus resulting in 147 * potential runtime performance penalties for tight loops operating on 148 * samplers. 149 * 150 *****************************************************************************/ 151 typedef struct Sampler { 152 #ifndef __LP64__ 153 char __pad[32]; 154 #else 155 char __pad[56]; 156 #endif 157 struct { 158 void *drv; 159 struct { 160 rs_sampler_value magFilter; 161 rs_sampler_value minFilter; 162 rs_sampler_value wrapS; 163 rs_sampler_value wrapT; 164 rs_sampler_value wrapR; 165 float aniso; 166 } state; 167 } mHal; 168 } Sampler_t; 169 170 /***************************************************************************** 171 * CAUTION 172 * 173 * The following structure layout provides a more efficient way to access 174 * internal members of the C++ class Element owned by librs. Unfortunately, 175 * since this class has virtual members, we can't simply use offsetof() or any 176 * other compiler trickery to dynamically get the appropriate values at 177 * build-time. This layout may need to be updated whenever 178 * frameworks/base/libs/rs/rsElement.h is modified. 179 * 180 * Having the layout information available in this file allows us to 181 * accelerate functionality like rsElementGetSubElementCount(). Without this 182 * information, we would not be able to inline the bitcode, thus resulting in 183 * potential runtime performance penalties for tight loops operating on 184 * elements. 185 * 186 *****************************************************************************/ 187 typedef struct Element { 188 #ifndef __LP64__ 189 char __pad[32]; 190 #else 191 char __pad[56]; 192 #endif 193 struct { 194 void *drv; 195 struct { 196 rs_data_type dataType; 197 rs_data_kind dataKind; 198 uint32_t vectorSize; 199 uint32_t elementSizeBytes; 200 201 // Subelements 202 const void **fields; 203 uint32_t *fieldArraySizes; 204 const char **fieldNames; 205 uint32_t *fieldNameLengths; 206 uint32_t *fieldOffsetBytes; 207 uint32_t fieldsCount; 208 } state; 209 } mHal; 210 } Element_t; 211 212 /***************************************************************************** 213 * CAUTION 214 * 215 * The following structure layout provides a more efficient way to access 216 * internal members of the C++ class Type owned by librs. Unfortunately, 217 * since this class has virtual members, we can't simply use offsetof() or any 218 * other compiler trickery to dynamically get the appropriate values at 219 * build-time. This layout may need to be updated whenever 220 * frameworks/base/libs/rs/rsType.h is modified. 221 * 222 * Having the layout information available in this file allows us to 223 * accelerate functionality like rsAllocationGetElement(). Without this 224 * information, we would not be able to inline the bitcode, thus resulting in 225 * potential runtime performance penalties for tight loops operating on 226 * types. 227 * 228 *****************************************************************************/ 229 typedef struct Type { 230 #ifndef __LP64__ 231 char __pad[32]; 232 #else 233 char __pad[56]; 234 #endif 235 struct { 236 void *drv; 237 struct { 238 const void * element; 239 uint32_t dimX; 240 uint32_t dimY; 241 uint32_t dimZ; 242 uint32_t *lodDimX; 243 uint32_t *lodDimY; 244 uint32_t *lodDimZ; 245 uint32_t *lodOffset; 246 uint32_t lodCount; 247 bool faces; 248 } state; 249 } mHal; 250 } Type_t; 251 252 #ifndef __LP64__ 253 /***************************************************************************** 254 * CAUTION 255 * 256 * The following structure layout provides a more efficient way to access 257 * internal members of the C++ class Mesh owned by librs. Unfortunately, 258 * since this class has virtual members, we can't simply use offsetof() or any 259 * other compiler trickery to dynamically get the appropriate values at 260 * build-time. This layout may need to be updated whenever 261 * frameworks/base/libs/rs/rsMesh.h is modified. 262 * 263 * Having the layout information available in this file allows us to 264 * accelerate functionality like rsMeshGetVertexAllocationCount(). Without this 265 * information, we would not be able to inline the bitcode, thus resulting in 266 * potential runtime performance penalties for tight loops operating on 267 * meshes. 268 * 269 *****************************************************************************/ 270 typedef struct Mesh { 271 char __pad[32]; 272 struct { 273 void *drv; 274 struct { 275 void **vertexBuffers; 276 uint32_t vertexBuffersCount; 277 278 // indexBuffers[i] could be NULL, in which case only primitives[i] is used 279 void **indexBuffers; 280 uint32_t indexBuffersCount; 281 rs_primitive *primitives; 282 uint32_t primitivesCount; 283 } state; 284 } mHal; 285 } Mesh_t; 286 #endif //__LP64__ 287 #endif // _RS_CORE_H_ 288
