You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
313 lines
11 KiB
313 lines
11 KiB
#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_
|