1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
/*
* Copyright (C) 2009 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ANDROID_STRUCTURED_ELEMENT_H
#define ANDROID_STRUCTURED_ELEMENT_H
#include "rsComponent.h"
#include "rsUtils.h"
#include "rsObjectBase.h"
// ---------------------------------------------------------------------------
namespace android {
namespace renderscript {
// An element is a group of Components that occupies one cell in a structure.
class Element : public ObjectBase {
public:
class Builder {
public:
Builder();
void add(const Element *e, const char *nameStr, uint32_t arraySize);
ObjectBaseRef<const Element> create(Context *rsc);
private:
Vector<ObjectBaseRef<const Element> > mBuilderElementRefs;
Vector<const Element *> mBuilderElements;
Vector<const char*> mBuilderNameStrings;
Vector<size_t> mBuilderNameLengths;
Vector<uint32_t> mBuilderArrays;
};
uint32_t getGLType() const;
uint32_t getGLFormat() const;
size_t getSizeBits() const;
size_t getSizeBytes() const {
return (getSizeBits() + 7) >> 3;
}
size_t getFieldOffsetBits(uint32_t componentNumber) const {
return mFields[componentNumber].offsetBits;
}
size_t getFieldOffsetBytes(uint32_t componentNumber) const {
return mFields[componentNumber].offsetBits >> 3;
}
uint32_t getFieldCount() const {return mFieldCount;}
const Element * getField(uint32_t idx) const {return mFields[idx].e.get();}
const char * getFieldName(uint32_t idx) const {return mFields[idx].name.string();}
uint32_t getFieldArraySize(uint32_t idx) const {return mFields[idx].arraySize;}
const Component & getComponent() const {return mComponent;}
RsDataType getType() const {return mComponent.getType();}
RsDataKind getKind() const {return mComponent.getKind();}
uint32_t getBits() const {return mBits;}
void dumpLOGV(const char *prefix) const;
virtual void serialize(OStream *stream) const;
virtual RsA3DClassID getClassId() const { return RS_A3D_CLASS_ID_ELEMENT; }
static Element *createFromStream(Context *rsc, IStream *stream);
static ObjectBaseRef<const Element> createRef(Context *rsc,
RsDataType dt,
RsDataKind dk,
bool isNorm,
uint32_t vecSize);
static ObjectBaseRef<const Element> createRef(Context *rsc, size_t count,
const Element **,
const char **,
const size_t * lengths,
const uint32_t *asin);
static const Element* create(Context *rsc,
RsDataType dt,
RsDataKind dk,
bool isNorm,
uint32_t vecSize) {
ObjectBaseRef<const Element> elem = createRef(rsc, dt, dk, isNorm, vecSize);
elem->incUserRef();
return elem.get();
}
static const Element* create(Context *rsc, size_t count,
const Element **ein,
const char **nin,
const size_t * lengths,
const uint32_t *asin) {
ObjectBaseRef<const Element> elem = createRef(rsc, count, ein, nin, lengths, asin);
elem->incUserRef();
return elem.get();
}
void incRefs(const void *) const;
void decRefs(const void *) const;
bool getHasReferences() const {return mHasReference;}
protected:
// deallocate any components that are part of this element.
void clear();
typedef struct {
String8 name;
ObjectBaseRef<const Element> e;
uint32_t offsetBits;
uint32_t arraySize;
} ElementField_t;
ElementField_t *mFields;
size_t mFieldCount;
bool mHasReference;
virtual ~Element();
Element(Context *);
Component mComponent;
uint32_t mBits;
void compute();
virtual void preDestroy() const;
};
class ElementState {
public:
ElementState();
~ElementState();
// Cache of all existing elements.
Vector<Element *> mElements;
};
}
}
#endif //ANDROID_STRUCTURED_ELEMENT_H
|
