466 lines
16 KiB
D
466 lines
16 KiB
D
/*
|
|
---------------------------------------------------------------------------
|
|
Open Asset Import Library (ASSIMP)
|
|
---------------------------------------------------------------------------
|
|
|
|
Copyright (c) 2006-2009, ASSIMP Development 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 Development 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.
|
|
---------------------------------------------------------------------------
|
|
*/
|
|
|
|
/**
|
|
* Contains the data structures in which the imported geometry is returned by
|
|
* Assimp.
|
|
*/
|
|
module assimp.mesh;
|
|
|
|
import assimp.math;
|
|
import assimp.types;
|
|
|
|
extern ( C ) {
|
|
/*
|
|
* These limits are required to match the settings Assimp was compiled
|
|
* against. Therefore, do not redefine them unless you build the library
|
|
* from source using the same definitions.
|
|
*/
|
|
|
|
/**
|
|
* Maximum number of indices per face (polygon).
|
|
*/
|
|
const AI_MAX_FACE_INDICES = 0x7fff;
|
|
|
|
/**
|
|
* Maximum number of indices per face (polygon).
|
|
*/
|
|
const AI_MAX_BONE_WEIGHTS = 0x7fffffff;
|
|
|
|
/**
|
|
* Maximum number of vertices per mesh.
|
|
*/
|
|
const AI_MAX_VERTICES = 0x7fffffff;
|
|
|
|
/**
|
|
* Maximum number of faces per mesh.
|
|
*/
|
|
const AI_MAX_FACES = 0x7fffffff;
|
|
|
|
/**
|
|
* Supported number of vertex color sets per mesh.
|
|
*/
|
|
const AI_MAX_NUMBER_OF_COLOR_SETS = 0x4;
|
|
|
|
/**
|
|
* Supported number of texture coord sets (UV(W) channels) per mesh.
|
|
*/
|
|
const AI_MAX_NUMBER_OF_TEXTURECOORDS = 0x4;
|
|
|
|
|
|
/**
|
|
* A single face in a mesh, referring to multiple vertices.
|
|
*
|
|
* If <code>mNumIndices</code> is 3, we call the face <em>triangle</em>, for
|
|
* for <code>mNumIndices > 3</code> it's called <em>polygon</em>.
|
|
*
|
|
* <code>aiMesh.mPrimitiveTypes</code> can be queried to quickly examine
|
|
* which types of primitive are actually present in a mesh. The
|
|
* <code>aiProcess.SortByPType</code> flag post-processing step splits
|
|
* meshes containing different primitive types (e.g. lines and triangles) in
|
|
* several "clean" submeshes.
|
|
*
|
|
* Furthermore, there is a configuration option
|
|
* (<code>AI_CONFIG_PP_SBP_REMOVE</code>) to force <code>SortByPType</code>
|
|
* to completely remove specific kinds of primitives from the imported scene.
|
|
* In many cases you'll probably want to set this setting to
|
|
* <code>aiPrimitiveType.LINE | aiPrimitiveType.POINT</code>. Together with
|
|
* the <code>aiProcess.Triangulate</code> flag you can then be sure that
|
|
* <code>mNumIndices</code> is always 3.
|
|
*/
|
|
struct aiFace {
|
|
/**
|
|
* Number of indices defining this face.
|
|
*
|
|
* The maximum value for this member is <code>AI_MAX_FACE_INDICES</code>.
|
|
*/
|
|
uint mNumIndices;
|
|
|
|
/**
|
|
* Array of the indices defining the face.
|
|
*
|
|
* The size is given in <code>mNumIndices</code>.
|
|
*/
|
|
uint* mIndices;
|
|
}
|
|
|
|
/**
|
|
* A single influence of a bone on a vertex.
|
|
*/
|
|
struct aiVertexWeight {
|
|
/**
|
|
* Index of the vertex which is influenced by the bone.
|
|
*/
|
|
uint mVertexId;
|
|
|
|
/**
|
|
* The strength of the influence in the range <code>[0..1]</code>.
|
|
*
|
|
* The influence from all bones at one vertex sums up to 1.
|
|
*/
|
|
float mWeight;
|
|
}
|
|
|
|
/**
|
|
* A single bone of a mesh.
|
|
*
|
|
* A bone has a name by which it can be found in the frame hierarchy and by
|
|
* which it can be addressed by animations. In addition it has a number of
|
|
* influences on vertices.
|
|
*/
|
|
struct aiBone {
|
|
/**
|
|
* The name of the bone.
|
|
*/
|
|
aiString mName;
|
|
|
|
/**
|
|
* The number of vertices affected by this bone.
|
|
*
|
|
* The maximum value for this member is <code>AI_MAX_BONE_WEIGHTS</code>.
|
|
*/
|
|
uint mNumWeights;
|
|
|
|
/**
|
|
* The vertices affected by this bone.
|
|
*
|
|
* This array is <code>mNumWeights</code> entries in size.
|
|
*/
|
|
aiVertexWeight* mWeights;
|
|
|
|
/**
|
|
* Matrix that transforms from mesh space to bone space (in the bind
|
|
* pose).
|
|
*/
|
|
aiMatrix4x4 mOffsetMatrix;
|
|
}
|
|
|
|
/**
|
|
* Enumerates the types of geometric primitives supported by Assimp.
|
|
*
|
|
* See: <code>aiFace</code>, <code>aiProcess.SortByPType</code>,
|
|
* <code>aiProcess.Triangulate</code>,
|
|
* <code>AI_CONFIG_PP_SBP_REMOVE</code>.
|
|
*/
|
|
enum aiPrimitiveType : uint {
|
|
/** A point primitive.
|
|
*
|
|
* This is just a single vertex in the virtual world,
|
|
* <code>aiFace</code> contains just one index for such a primitive.
|
|
*/
|
|
POINT = 0x1,
|
|
|
|
/** A line primitive.
|
|
*
|
|
* This is a line defined through a start and an end position.
|
|
* <code>aiFace</code> contains exactly two indices for such a primitive.
|
|
*/
|
|
LINE = 0x2,
|
|
|
|
/** A triangular primitive.
|
|
*
|
|
* A triangle consists of three indices.
|
|
*/
|
|
TRIANGLE = 0x4,
|
|
|
|
/** A higher-level polygon with more than 3 edges.
|
|
*
|
|
* A triangle is a polygon, but in this context, polygon means
|
|
* "all polygons that are not triangles". The <code>Triangulate</code>
|
|
* post processing step is provided for your convenience, it splits all
|
|
* polygons in triangles (which are much easier to handle).
|
|
*/
|
|
POLYGON = 0x8
|
|
}
|
|
|
|
// Note: The AI_PRIMITIVE_TYPE_FOR_N_INDICES(n) macro from the C headers is
|
|
// missing since there is probably not much use for it when just reading
|
|
// scene files.
|
|
|
|
/**
|
|
* NOT CURRENTLY IN USE. An AnimMesh is an attachment to an #aiMesh stores
|
|
* per-vertex animations for a particular frame.
|
|
*
|
|
* You may think of an <code>aiAnimMesh</code> as a `patch` for the host
|
|
* mesh, which replaces only certain vertex data streams at a particular
|
|
* time.
|
|
*
|
|
* Each mesh stores n attached attached meshes (<code>aiMesh.mAnimMeshes</code>).
|
|
* The actual relationship between the time line and anim meshes is
|
|
* established by #aiMeshAnim, which references singular mesh attachments
|
|
* by their ID and binds them to a time offset.
|
|
*/
|
|
struct aiAnimMesh {
|
|
/**
|
|
* Replacement for aiMesh.mVertices.
|
|
*
|
|
* If this array is non-null, it *must* contain mNumVertices entries.
|
|
* The corresponding array in the host mesh must be non-null as well -
|
|
* animation meshes may neither add or nor remove vertex components (if
|
|
* a replacement array is NULL and the corresponding source array is
|
|
* not, the source data is taken instead).
|
|
*/
|
|
aiVector3D* mVertices;
|
|
|
|
/// Replacement for <code>aiMesh.mNormals</code>.
|
|
aiVector3D* mNormals;
|
|
|
|
/// Replacement for <code>aiMesh.mTangents</code>.
|
|
aiVector3D* mTangents;
|
|
|
|
/// Replacement for <code>aiMesh.mBitangents</code>.
|
|
aiVector3D* mBitangents;
|
|
|
|
/// Replacement for <code>aiMesh.mColors</code>.
|
|
aiColor4D* mColors[ AI_MAX_NUMBER_OF_COLOR_SETS ];
|
|
|
|
/// Replacement for <code>aiMesh.mTextureCoords</code>.
|
|
aiVector3D* mTextureCoords[ AI_MAX_NUMBER_OF_TEXTURECOORDS ];
|
|
|
|
/**
|
|
* The number of vertices in the aiAnimMesh, and thus the length of all
|
|
* the member arrays.
|
|
*
|
|
* This has always the same value as the mNumVertices property in the
|
|
* corresponding aiMesh. It is duplicated here merely to make the length
|
|
* of the member arrays accessible even if the aiMesh is not known, e.g.
|
|
* from language bindings.
|
|
*/
|
|
uint mNumVertices;
|
|
}
|
|
|
|
/**
|
|
* A mesh represents a geometry or model with a single material.
|
|
*
|
|
* It usually consists of a number of vertices and a series
|
|
* primitives/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
|
|
* coords or a normal vector. If a data pointer is non-null, the
|
|
* corresponding data stream is present.
|
|
*
|
|
* A mesh uses only a single material which is referenced by a material ID.
|
|
*
|
|
* Note: The <code>mPositions</code> member is usually not optional.
|
|
* However, vertex positions <em>could</em> be missing if the
|
|
* <code>AI_SCENE_FLAGS_INCOMPLETE</code> flag is set in
|
|
* <code>aiScene.mFlags</code>.
|
|
*/
|
|
struct aiMesh {
|
|
/**
|
|
* Bitwise combination of <code>aiPrimitiveType</code> members.
|
|
*
|
|
* This specifies which types of primitives are present in the mesh.
|
|
* The <code>SortByPrimitiveType</code> post processing step can be used
|
|
* to make sure the output meshes consist of one primitive type each.
|
|
*/
|
|
uint mPrimitiveTypes;
|
|
|
|
/**
|
|
* The number of vertices in this mesh.
|
|
*
|
|
* This is also the size of all of the per-vertex data arrays. The
|
|
* maximum value for this member is <code>AI_MAX_VERTICES</code>.
|
|
*/
|
|
uint mNumVertices;
|
|
|
|
/**
|
|
* The number of primitives (triangles, polygons, lines) in this mesh.
|
|
*
|
|
* This is also the size of the <code>mFaces</code> array. The maximum
|
|
* value for this member is <code>AI_MAX_FACES</code>.
|
|
*/
|
|
uint mNumFaces;
|
|
|
|
/**
|
|
* Vertex positions.
|
|
*
|
|
* This array is always present in a mesh. The array is
|
|
* <code>mNumVertices</code> in size.
|
|
*/
|
|
aiVector3D* mVertices;
|
|
|
|
/**
|
|
* Vertex normals.
|
|
*
|
|
* The array contains normalized vectors, null if not present.
|
|
* The array is <code>mNumVertices</code> in size.
|
|
*
|
|
* Normals are undefined for point and line primitives. A mesh
|
|
* consisting of points and lines only may not have normal vectors.
|
|
* Meshes with mixed primitive types (i.e. lines and triangles) may have
|
|
* normals, but the normals for vertices that are only referenced by
|
|
* point or line primitives are undefined and set to <code>QNAN</code>.
|
|
*
|
|
* Note: Normal vectors computed by Assimp are always unit-length.
|
|
* However, this needn't apply for normals that have been taken
|
|
* directly from the model file.
|
|
*/
|
|
aiVector3D* mNormals;
|
|
|
|
/**
|
|
* Vertex tangents.
|
|
*
|
|
* The tangent of a vertex points in the direction of the positive x
|
|
* texture axis. The array contains normalized vectors, null if
|
|
* not present. The array is <code>mNumVertices</code> in size.
|
|
*
|
|
* A mesh consisting of points and lines only may not have normal
|
|
* vectors. Meshes with mixed primitive types (i.e. lines and triangles)
|
|
* may have normals, but the normals for vertices that are only
|
|
* referenced by point or line primitives are undefined and set to
|
|
* <code>QNAN</code>.
|
|
*
|
|
* Note: If the mesh contains tangents, it automatically also contains
|
|
* bitangents (the bitangent is just the cross product of tangent and
|
|
* normal vectors).
|
|
*/
|
|
aiVector3D* mTangents;
|
|
|
|
/**
|
|
* Vertex bitangents.
|
|
*
|
|
* The bitangent of a vertex points in the direction of the positive Y
|
|
* texture axis. The array contains normalized vectors, null if not
|
|
* present. The array is <code>mNumVertices</code> in size.
|
|
*
|
|
* Note: If the mesh contains tangents, it automatically also contains
|
|
* bitangents.
|
|
*/
|
|
aiVector3D* mBitangents;
|
|
|
|
/**
|
|
* Vertex color sets.
|
|
*
|
|
* A mesh may contain 0 to <code>AI_MAX_NUMBER_OF_COLOR_SETS</code>
|
|
* vertex colors per vertex. null if not present.
|
|
*
|
|
* Each array is <code>mNumVertices</code> in size if present.
|
|
*/
|
|
aiColor4D* mColors[ AI_MAX_NUMBER_OF_COLOR_SETS ];
|
|
|
|
/**
|
|
* Vertex texture coords, also known as UV channels.
|
|
* A mesh may contain 0 to <code>AI_MAX_NUMBER_OF_TEXTURECOORDS</code>
|
|
* per vertex. null if not present.
|
|
*
|
|
* Each array is <code>mNumVertices</code> in size.
|
|
*/
|
|
aiVector3D* mTextureCoords[ AI_MAX_NUMBER_OF_TEXTURECOORDS ];
|
|
|
|
/**
|
|
* Specifies the number of components for a given UV channel.
|
|
*
|
|
* Up to three channels are supported (UVW, for accessing volume or cube
|
|
* maps). If the value is 2 for a given channel <code>n</code>, the
|
|
* component <code>p.z</code> of <code>mTextureCoords[n][p]</code> is set
|
|
* to 0. If the value is 1 for a given channel, <code>p.y</code> is set
|
|
* to 0, too. If this value is 0, 2 should be assumed.
|
|
*
|
|
* Note: 4D coords are not supported.
|
|
*/
|
|
uint mNumUVComponents[ AI_MAX_NUMBER_OF_TEXTURECOORDS ];
|
|
|
|
/**
|
|
* The faces the mesh is contstructed from.
|
|
*
|
|
* Each face refers to a number of vertices by their indices.
|
|
* This array is always present in a mesh, its size is given
|
|
* in <code>mNumFaces</code>. If the
|
|
* <code>AI_SCENE_FLAGS_NON_VERBOSE_FORMAT</code> is <em>not</em> set,
|
|
* each face references an unique set of vertices.
|
|
*/
|
|
aiFace* mFaces;
|
|
|
|
/**
|
|
* The number of bones this mesh contains.
|
|
*
|
|
* Can be 0, in which case the <code>mBones</code> array is null.
|
|
*/
|
|
uint mNumBones;
|
|
|
|
/**
|
|
* The bones of this mesh.
|
|
*
|
|
* A bone consists of a name by which it can be found in the frame
|
|
* hierarchy and a set of vertex weights.
|
|
*/
|
|
aiBone** mBones;
|
|
|
|
/**
|
|
* The material used by this mesh.
|
|
*
|
|
* A mesh does use only a single material. If an imported model uses
|
|
* multiple materials, the import splits up the mesh. Use this value as
|
|
* index into the scene's material list.
|
|
*/
|
|
uint mMaterialIndex;
|
|
|
|
/**
|
|
* Name of the mesh.
|
|
*
|
|
* Meshes can be named, but this is not a requirement and leaving this
|
|
* field empty is totally fine.
|
|
*
|
|
* There are mainly three uses for mesh names:
|
|
* - Some formats name nodes and meshes independently.
|
|
* - Importers tend to split meshes up to meet the one-material-per-mesh
|
|
* requirement. Assigning the same (dummy) name to each of the result
|
|
* meshes aids the caller at recovering the original mesh partitioning.
|
|
* - Vertex animations refer to meshes by their names.
|
|
*/
|
|
aiString mName;
|
|
|
|
/// NOT CURRENTLY IN USE. The number of attachment meshes.
|
|
uint mNumAnimMeshes;
|
|
|
|
/**
|
|
* NOT CURRENTLY IN USE. Attachment meshes for this mesh, for vertex-
|
|
* based animation.
|
|
*
|
|
* Attachment meshes carry replacement data for some of the mesh's
|
|
* vertex components (usually positions, normals).
|
|
*/
|
|
aiAnimMesh** mAnimMeshes;
|
|
}
|
|
}
|