FileA3D.java revision bca8e6d35fc16506ce1070000ce3804bbeaee399 
1/*
2 * Copyright (C) 2008-2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package android.renderscript;
18
19import java.io.File;
20import java.io.InputStream;
21
22import android.content.res.AssetManager;
23import android.content.res.Resources;
24
25/**
26 * @hide
27 * @deprecated in API 16
28 * FileA3D allows users to load RenderScript objects from files
29 * or resources stored on disk. It could be used to load items
30 * such as 3D geometry data converted to a RenderScript format from
31 * content creation tools. Currently only meshes are supported
32 * in FileA3D.
33 *
34 * When successfully loaded, FileA3D will contain a list of
35 * index entries for all the objects stored inside it.
36 *
37 **/
38public class FileA3D extends BaseObj {
39
40    /**
41    * @deprecated in API 16
42    * Specifies what renderscript object type is contained within
43    * the FileA3D IndexEntry
44    **/
45    public enum EntryType {
46
47        /**
48        * @deprecated in API 16
49        * Unknown or or invalid object, nothing will be loaded
50        **/
51        UNKNOWN (0),
52        /**
53        * @deprecated in API 16
54        * RenderScript Mesh object
55        **/
56        MESH (1);
57
58        int mID;
59        EntryType(int id) {
60            mID = id;
61        }
62
63        static EntryType toEntryType(int intID) {
64            return EntryType.values()[intID];
65        }
66    }
67
68    /**
69    * @deprecated in API 16
70    * IndexEntry contains information about one of the RenderScript
71    * objects inside the file's index. It could be used to query the
72    * object's type and also name and load the object itself if
73    * necessary.
74    */
75    public static class IndexEntry {
76        RenderScript mRS;
77        int mIndex;
78        long mID;
79        String mName;
80        EntryType mEntryType;
81        BaseObj mLoadedObj;
82
83        /**
84        * @deprecated in API 16
85        * Returns the name of a renderscript object the index entry
86        * describes
87        *
88        * @return name of a renderscript object the index entry
89        * describes
90        *
91        */
92        public String getName() {
93            return mName;
94        }
95
96        /**
97        * @deprecated in API 16
98        * Returns the type of a renderscript object the index entry
99        * describes
100        * @return type of a renderscript object the index entry
101        *         describes
102        */
103        public EntryType getEntryType() {
104            return mEntryType;
105        }
106
107        /**
108        * @deprecated in API 16
109        * Used to load the object described by the index entry
110        * @return base renderscript object described by the entry
111        */
112        public BaseObj getObject() {
113            mRS.validate();
114            BaseObj obj = internalCreate(mRS, this);
115            return obj;
116        }
117
118        /**
119        * @deprecated in API 16
120        * Used to load the mesh described by the index entry, object
121        * described by the index entry must be a renderscript mesh
122        *
123        * @return renderscript mesh object described by the entry
124        */
125        public Mesh getMesh() {
126            return (Mesh)getObject();
127        }
128
129        static synchronized BaseObj internalCreate(RenderScript rs, IndexEntry entry) {
130            if(entry.mLoadedObj != null) {
131                return entry.mLoadedObj;
132            }
133
134            // to be purged on cleanup
135            if(entry.mEntryType == EntryType.UNKNOWN) {
136                return null;
137            }
138
139            long objectID = rs.nFileA3DGetEntryByIndex(entry.mID, entry.mIndex);
140            if(objectID == 0) {
141                return null;
142            }
143
144            switch (entry.mEntryType) {
145            case MESH:
146                entry.mLoadedObj = new Mesh(objectID, rs);
147                break;
148
149            default:
150                throw new RSRuntimeException("Unrecognized object type in file.");
151            }
152
153            entry.mLoadedObj.updateFromNative();
154            return entry.mLoadedObj;
155        }
156
157        IndexEntry(RenderScript rs, int index, long id, String name, EntryType type) {
158            mRS = rs;
159            mIndex = index;
160            mID = id;
161            mName = name;
162            mEntryType = type;
163            mLoadedObj = null;
164        }
165    }
166
167    IndexEntry[] mFileEntries;
168    InputStream mInputStream;
169
170    FileA3D(long id, RenderScript rs, InputStream stream) {
171        super(id, rs);
172        mInputStream = stream;
173    }
174
175    private void initEntries() {
176        int numFileEntries = mRS.nFileA3DGetNumIndexEntries(getID(mRS));
177        if(numFileEntries <= 0) {
178            return;
179        }
180
181        mFileEntries = new IndexEntry[numFileEntries];
182        int[] ids = new int[numFileEntries];
183        String[] names = new String[numFileEntries];
184
185        mRS.nFileA3DGetIndexEntries(getID(mRS), numFileEntries, ids, names);
186
187        for(int i = 0; i < numFileEntries; i ++) {
188            mFileEntries[i] = new IndexEntry(mRS, i, getID(mRS), names[i], EntryType.toEntryType(ids[i]));
189        }
190    }
191
192    /**
193    * @deprecated in API 16
194    * Returns the number of objects stored inside the a3d file
195    *
196    * @return the number of objects stored inside the a3d file
197    */
198    public int getIndexEntryCount() {
199        if(mFileEntries == null) {
200            return 0;
201        }
202        return mFileEntries.length;
203    }
204
205    /**
206    * @deprecated in API 16
207    * Returns an index entry from the list of all objects inside
208    * FileA3D
209    *
210    * @param index number of the entry from the list to return
211    *
212    * @return entry in the a3d file described by the index
213    */
214    public IndexEntry getIndexEntry(int index) {
215        if(getIndexEntryCount() == 0 || index < 0 || index >= mFileEntries.length) {
216            return null;
217        }
218        return mFileEntries[index];
219    }
220
221    /**
222    * @deprecated in API 16
223    * Creates a FileA3D object from an asset stored on disk
224    *
225    * @param rs Context to which the object will belong.
226    * @param mgr asset manager used to load asset
227    * @param path location of the file to load
228    *
229    * @return a3d file containing renderscript objects
230    */
231    static public FileA3D createFromAsset(RenderScript rs, AssetManager mgr, String path) {
232        rs.validate();
233        long fileId = rs.nFileA3DCreateFromAsset(mgr, path);
234
235        if(fileId == 0) {
236            throw new RSRuntimeException("Unable to create a3d file from asset " + path);
237        }
238        FileA3D fa3d = new FileA3D(fileId, rs, null);
239        fa3d.initEntries();
240        return fa3d;
241    }
242
243    /**
244    * @deprecated in API 16
245    * Creates a FileA3D object from a file stored on disk
246    *
247    * @param rs Context to which the object will belong.
248    * @param path location of the file to load
249    *
250    * @return a3d file containing renderscript objects
251    */
252    static public FileA3D createFromFile(RenderScript rs, String path) {
253        long fileId = rs.nFileA3DCreateFromFile(path);
254
255        if(fileId == 0) {
256            throw new RSRuntimeException("Unable to create a3d file from " + path);
257        }
258        FileA3D fa3d = new FileA3D(fileId, rs, null);
259        fa3d.initEntries();
260        return fa3d;
261    }
262
263    /**
264    * @deprecated in API 16
265    * Creates a FileA3D object from a file stored on disk
266    *
267    * @param rs Context to which the object will belong.
268    * @param path location of the file to load
269    *
270    * @return a3d file containing renderscript objects
271    */
272    static public FileA3D createFromFile(RenderScript rs, File path) {
273        return createFromFile(rs, path.getAbsolutePath());
274    }
275
276    /**
277    * @deprecated in API 16
278    * Creates a FileA3D object from an application resource
279    *
280    * @param rs Context to which the object will belong.
281    * @param res resource manager used for loading
282    * @param id resource to create FileA3D from
283    *
284    * @return a3d file containing renderscript objects
285    */
286    static public FileA3D createFromResource(RenderScript rs, Resources res, int id) {
287
288        rs.validate();
289        InputStream is = null;
290        try {
291            is = res.openRawResource(id);
292        } catch (Exception e) {
293            throw new RSRuntimeException("Unable to open resource " + id);
294        }
295
296        long fileId = 0;
297        if (is instanceof AssetManager.AssetInputStream) {
298            long asset = ((AssetManager.AssetInputStream) is).getNativeAsset();
299            fileId = rs.nFileA3DCreateFromAssetStream(asset);
300        } else {
301            throw new RSRuntimeException("Unsupported asset stream");
302        }
303
304        if(fileId == 0) {
305            throw new RSRuntimeException("Unable to create a3d file from resource " + id);
306        }
307        FileA3D fa3d = new FileA3D(fileId, rs, is);
308        fa3d.initEntries();
309        return fa3d;
310
311    }
312}
313