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