3D引擎，渲染系统使用的OpenGL 及 OpenGL ES，Windows上OpenGL ES使用AMD的ES模拟器.zip

/* --------------------------------------------------------------------------- Open Asset Import Library - Java Binding (jassimp) --------------------------------------------------------------------------- Copyright (c) 2006-2012, assimp team All rights reserved. Redistribution and use of this software in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the assimp team, nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission of the assimp team. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --------------------------------------------------------------------------- */ package jassimp; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.nio.FloatBuffer; import java.nio.IntBuffer; import java.util.ArrayList; import java.util.EnumSet; import java.util.List; import java.util.Set; /** * A mesh represents a geometry or model with a single material. * <p> * * <h3>Data</h3> * Meshes usually consist of a number of vertices and a series of faces * referencing the vertices. In addition there might be a series of bones, each * of them addressing a number of vertices with a certain weight. Vertex data is * presented in channels with each channel containing a single per-vertex * information such as a set of texture coordinates or a normal vector.<p> * * Faces consist of one or more references to vertices, called vertex indices. * The {@link #getPrimitiveTypes()} method can be used to check what * face types are present in the mesh. Note that a single mesh can possess * faces of different types. The number of indices used by a specific face can * be retrieved with the {@link #getFaceNumIndices(int)} method. * * * <h3>API for vertex and face data</h3> * The jassimp interface for accessing vertex and face data is not a one-to-one * mapping of the c/c++ interface. The c/c++ interface uses an object-oriented * approach to represent data, which provides a considerable * overhead using a naive java based realization (cache locality would be * unpredictable and most likely bad, bulk data transfer would be impossible). * <p> * * The jassimp interface uses flat byte buffers to store vertex and face data. * This data can be accessed through three APIs: * <ul> * <li><b>Buffer API:</b> the <code>getXXXBuffer()</code> methods return * raw data buffers. * <li><b>Direct API:</b> the <code>getXXX()</code> methods allow reading * and writing of individual data values. * <li><b>Wrapped API:</b> the <code>getWrappedXXX()</code> methods provide * an object oriented view on the data. * </ul> * * The Buffer API is optimized for use in conjunction with rendering APIs * such as LWJGL. The returned buffers are guaranteed to have native byte order * and to be direct byte buffers. They can be passed directly to LWJGL * methods, e.g., to fill VBOs with data. Each invocation of a * <code>getXXXBuffer()</code> method will return a new view of the internal * buffer, i.e., if is safe to use the relative byte buffer operations. * The Buffer API provides the best performance of all three APIs, especially * if large data volumes have to be processed.<p> * * The Direct API provides an easy to use interface for reading and writing * individual data values. Its performance is comparable to the Buffer API's * performance for these operations. The main difference to the Buffer API is * the missing support for bulk operations. If you intend to retrieve or modify * large subsets of the raw data consider using the Buffer API, especially * if the subsets are contiguous. * <p> * * The Wrapped API offers an object oriented interface for accessing * and modifying mesh data. As the name implies, this interface is realized * through wrapper objects that provide a view on the raw data. For each * invocation of a <code>getWrappedXXX()</code> method, a new wrapper object * is created. Iterating over mesh data via this interface will create many * short-lived wrapper objects which -depending on usage and virtual machine- * may cause considerable garbage collection overhead. The Wrapped API provides * the worst performance of all three APIs, which may nevertheless still be * good enough to warrant its usage. See {@link AiWrapperProvider} for more * details on wrappers. * * * <h3>API for bones</h3> * As there is no standardized way for doing skinning in different graphics * engines, bones are not represented as flat buffers but as object structure. * Users of this library should convert this structure to the format required * by the specific graphics engine. * * * <h3>Changing Data</h3> * This class is designed to be mutable, i.e., the returned objects and buffers * may be modified. It is not possible to add/remove vertices as this would * require reallocation of the data buffers. Wrapped objects may or may not * propagate changes to the underlying data buffers. Consult the documentation * of your wrapper provider for details. The built in wrappers will propagate * changes. * <p> * Modification of face data is theoretically possible by modifying the face * buffer and the faceOffset buffer however it is strongly disadvised to do so * because it might break all algorithms that depend on the internal consistency * of these two data structures. */ public final class AiMesh { /** * Number of bytes per float value. */ private static final int SIZEOF_FLOAT = Jassimp.NATIVE_FLOAT_SIZE; /** * Number of bytes per int value. */ private static final int SIZEOF_INT = Jassimp.NATIVE_INT_SIZE; /** * Size of an AiVector3D in the native world. */ private static final int SIZEOF_V3D = Jassimp.NATIVE_AIVEKTOR3D_SIZE; /** * This class is instantiated via JNI, no accessible constructor. */ private AiMesh() { /* nothing to do */ } /** * Returns the primitive types used by this mesh. * * @return a set of primitive types used by this mesh */ public Set<AiPrimitiveType> getPrimitiveTypes() { return m_primitiveTypes; } /** * Tells whether the mesh is a pure triangle mesh, i.e., contains only * triangular faces.<p> * * To automatically triangulate meshes the * {@link AiPostProcessSteps#TRIANGULATE} post processing option can be * used when loading the scene * * @return true if the mesh is a pure triangle mesh, false otherwise */ public boolean isPureTriangle() { return m_primitiveTypes.contains(AiPrimitiveType.TRIANGLE) && m_primitiveTypes.size() == 1; } /** * Tells whether the mesh has vertex positions.<p>