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