#ifndef _RS_STRUCTS_H_ #define _RS_STRUCTS_H_ #include "rs_core.rsh" #include "rs_graphics.rsh" /***************************************************************************** * CAUTION * * The following structure layout provides a more efficient way to access * internal members of the C++ class Allocation owned by librs. Unfortunately, * since this class has virtual members, we can't simply use offsetof() or any * other compiler trickery to dynamically get the appropriate values at * build-time. This layout may need to be updated whenever * frameworks/base/libs/rs/rsAllocation.h is modified. * * Having the layout information available in this file allows us to * accelerate functionality like rsAllocationGetDimX(). Without this * information, we would not be able to inline the bitcode, thus resulting in * potential runtime performance penalties for tight loops operating on * allocations. * *****************************************************************************/ typedef enum { RS_ALLOCATION_MIPMAP_NONE = 0, RS_ALLOCATION_MIPMAP_FULL = 1, RS_ALLOCATION_MIPMAP_ON_SYNC_TO_TEXTURE = 2 } rs_allocation_mipmap_control; typedef struct Allocation { #ifndef __LP64__ char __pad[32]; #else char __pad[56]; #endif struct { void * drv; struct { const void *type; uint32_t usageFlags; rs_allocation_mipmap_control mipmapControl; uint32_t yuv; uint32_t elementSizeBytes; bool hasMipmaps; bool hasFaces; bool hasReferences; void * usrPtr; int32_t surfaceTextureID; void * nativeBuffer; int64_t timestamp; // Allocation adapter state const void *baseAlloc; uint32_t originX; uint32_t originY; uint32_t originZ; uint32_t originLOD; uint32_t originFace; uint32_t originArray[4/*Type::mMaxArrays*/]; } state; struct DrvState { struct LodState { void * mallocPtr; size_t stride; uint32_t dimX; uint32_t dimY; uint32_t dimZ; } lod[16/*android::renderscript::Allocation::MAX_LOD*/]; size_t faceOffset; uint32_t lodCount; uint32_t faceCount; struct YuvState { uint32_t shift; uint32_t step; } yuv; int grallocFlags; uint32_t dimArray[4/*Type::mMaxArrays*/]; } drvState; } mHal; } Allocation_t; #ifndef __LP64__ /***************************************************************************** * CAUTION * * The following structure layout provides a more efficient way to access * internal members of the C++ class ProgramStore owned by librs. Unfortunately, * since this class has virtual members, we can't simply use offsetof() or any * other compiler trickery to dynamically get the appropriate values at * build-time. This layout may need to be updated whenever * frameworks/base/libs/rs/rsProgramStore.h is modified. * * Having the layout information available in this file allows us to * accelerate functionality like rsgProgramStoreGetDepthFunc(). Without this * information, we would not be able to inline the bitcode, thus resulting in * potential runtime performance penalties for tight loops operating on * program store. * *****************************************************************************/ typedef struct ProgramStore { char __pad[40]; struct { struct { bool ditherEnable; bool colorRWriteEnable; bool colorGWriteEnable; bool colorBWriteEnable; bool colorAWriteEnable; rs_blend_src_func blendSrc; rs_blend_dst_func blendDst; bool depthWriteEnable; rs_depth_func depthFunc; } state; } mHal; } ProgramStore_t; /***************************************************************************** * CAUTION * * The following structure layout provides a more efficient way to access * internal members of the C++ class ProgramRaster owned by librs. Unfortunately, * since this class has virtual members, we can't simply use offsetof() or any * other compiler trickery to dynamically get the appropriate values at * build-time. This layout may need to be updated whenever * frameworks/base/libs/rs/rsProgramRaster.h is modified. * * Having the layout information available in this file allows us to * accelerate functionality like rsgProgramRasterGetCullMode(). Without this * information, we would not be able to inline the bitcode, thus resulting in * potential runtime performance penalties for tight loops operating on * program raster. * *****************************************************************************/ typedef struct ProgramRaster { char __pad[36]; struct { void * drv; struct { bool pointSprite; rs_cull_mode cull; } state; } mHal; } ProgramRaster_t; #endif //__LP64__ /***************************************************************************** * CAUTION * * The following structure layout provides a more efficient way to access * internal members of the C++ class Sampler owned by librs. Unfortunately, * since this class has virtual members, we can't simply use offsetof() or any * other compiler trickery to dynamically get the appropriate values at * build-time. This layout may need to be updated whenever * frameworks/base/libs/rs/rsSampler.h is modified. * * Having the layout information available in this file allows us to * accelerate functionality like rsgProgramRasterGetMagFilter(). Without this * information, we would not be able to inline the bitcode, thus resulting in * potential runtime performance penalties for tight loops operating on * samplers. * *****************************************************************************/ typedef struct Sampler { #ifndef __LP64__ char __pad[32]; #else char __pad[56]; #endif struct { void *drv; struct { rs_sampler_value magFilter; rs_sampler_value minFilter; rs_sampler_value wrapS; rs_sampler_value wrapT; rs_sampler_value wrapR; float aniso; } state; } mHal; } Sampler_t; /***************************************************************************** * CAUTION * * The following structure layout provides a more efficient way to access * internal members of the C++ class Element owned by librs. Unfortunately, * since this class has virtual members, we can't simply use offsetof() or any * other compiler trickery to dynamically get the appropriate values at * build-time. This layout may need to be updated whenever * frameworks/base/libs/rs/rsElement.h is modified. * * Having the layout information available in this file allows us to * accelerate functionality like rsElementGetSubElementCount(). Without this * information, we would not be able to inline the bitcode, thus resulting in * potential runtime performance penalties for tight loops operating on * elements. * *****************************************************************************/ typedef struct Element { #ifndef __LP64__ char __pad[32]; #else char __pad[56]; #endif struct { void *drv; struct { rs_data_type dataType; rs_data_kind dataKind; uint32_t vectorSize; uint32_t elementSizeBytes; // Subelements const void **fields; uint32_t *fieldArraySizes; const char **fieldNames; uint32_t *fieldNameLengths; uint32_t *fieldOffsetBytes; uint32_t fieldsCount; } state; } mHal; } Element_t; /***************************************************************************** * CAUTION * * The following structure layout provides a more efficient way to access * internal members of the C++ class Type owned by librs. Unfortunately, * since this class has virtual members, we can't simply use offsetof() or any * other compiler trickery to dynamically get the appropriate values at * build-time. This layout may need to be updated whenever * frameworks/base/libs/rs/rsType.h is modified. * * Having the layout information available in this file allows us to * accelerate functionality like rsAllocationGetElement(). Without this * information, we would not be able to inline the bitcode, thus resulting in * potential runtime performance penalties for tight loops operating on * types. * *****************************************************************************/ typedef struct Type { #ifndef __LP64__ char __pad[32]; #else char __pad[56]; #endif struct { void *drv; struct { const void * element; uint32_t dimX; uint32_t dimY; uint32_t dimZ; uint32_t *lodDimX; uint32_t *lodDimY; uint32_t *lodDimZ; uint32_t *arrays; uint32_t lodCount; uint32_t dimYuv; uint32_t arrayCount; bool faces; } state; } mHal; } Type_t; #ifndef __LP64__ /***************************************************************************** * CAUTION * * The following structure layout provides a more efficient way to access * internal members of the C++ class Mesh owned by librs. Unfortunately, * since this class has virtual members, we can't simply use offsetof() or any * other compiler trickery to dynamically get the appropriate values at * build-time. This layout may need to be updated whenever * frameworks/base/libs/rs/rsMesh.h is modified. * * Having the layout information available in this file allows us to * accelerate functionality like rsMeshGetVertexAllocationCount(). Without this * information, we would not be able to inline the bitcode, thus resulting in * potential runtime performance penalties for tight loops operating on * meshes. * *****************************************************************************/ typedef struct Mesh { char __pad[32]; struct { void *drv; struct { void **vertexBuffers; uint32_t vertexBuffersCount; // indexBuffers[i] could be nullptr, in which case only primitives[i] is used void **indexBuffers; uint32_t indexBuffersCount; rs_primitive *primitives; uint32_t primitivesCount; } state; } mHal; } Mesh_t; #endif //__LP64__ // Null version of _RS_OBJECT_DECL defined in script_api/rs_object_types.spec #ifndef __LP64__ #define RS_NULL_OBJ {0} #else #define RS_NULL_OBJ {0, 0, 0, 0} #endif //__LP64__ #endif // _RS_CORE_H_