rs_structs.h revision e3af53b643677c40d228ffd3624cf259f4dc68ed 
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 *****************************************************************************/
21typedef 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
27typedef 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 *****************************************************************************/
88typedef 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 *****************************************************************************/
122typedef 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 *****************************************************************************/
151typedef 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 *****************************************************************************/
187typedef 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 *****************************************************************************/
229typedef 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 *****************************************************************************/
270typedef 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